有没有办法在 Python 中返回当前目录中所有子目录的列表?
我知道您可以对文件执行此操作,但我需要获取目录列表。
[f for f in data_path.iterdir() if f.is_dir()]
:stackoverflow.com/a/44228436/1601580。这为您提供了字符串文件夹名称。不知何故,它还排除了 .
和 ..
,感谢上帝。 Glob 解决方案也很有价值:glob.glob("/path/to/directory/*/")
。
您是指直接子目录,还是树下的每个目录?
无论哪种方式,您都可以使用 os.walk
来执行此操作:
os.walk(directory)
将为每个子目录生成一个元组。三元组中的第一个条目是目录名,所以
[x[0] for x in os.walk(directory)]
应该递归地给你所有的子目录。
请注意,元组中的第二个条目是第一个位置的条目的子目录列表,因此您可以使用它来代替,但这不太可能为您节省太多。
但是,您可以使用它来为您提供直接子目录:
next(os.walk('.'))[1]
或使用 os.listdir
和 os.path.isdir
查看已发布的其他解决方案,包括“How to get all of the immediate subdirectories in Python”中的解决方案。
您可以只使用 glob.glob
from glob import glob
glob("/path/to/directory/*/", recursive = True)
不要忘记 *
之后的尾随 /
。
/
/
是文件夹分隔符,请执行以下操作:glob(os.path.join(path_to_directory, "*", ""))
recursive=True
比上面好多了,因为你不需要几个 os.path.join() 并且你会直接得到完整的路径(如果你愿意的话),你可以在 Python 3.5 及更高版本中做到这一点。
subfolders = [ f.path for f in os.scandir(folder) if f.is_dir() ]
这将给出子目录的完整路径。如果您只想要子目录的名称,请使用 f.name
而不是 f.path
https://docs.python.org/3/library/os.html#os.scandir
有点 OT:如果您需要递归所有子文件夹和/或递归所有文件,请查看此函数,它比 os.walk
& glob
并将返回所有子文件夹以及这些(子)子文件夹中的所有文件的列表:https://stackoverflow.com/a/59803793/2441026
如果您只需要递归所有子文件夹:
def fast_scandir(dirname):
subfolders= [f.path for f in os.scandir(dirname) if f.is_dir()]
for dirname in list(subfolders):
subfolders.extend(fast_scandir(dirname))
return subfolders
返回所有子文件夹及其完整路径的列表。这又比 os.walk
快,比 glob
快很多。
所有功能的分析
tl;dr:
- 如果你想获取文件夹的所有 immediate 子目录,请使用 os.scandir
。
- 如果你想获取 all 子目录,即使是嵌套,也可以使用 os.walk
或 - 稍微快一点 - 上面的 fast_scandir
函数。
- 切勿仅将 os.walk
用于顶级子目录,因为它可能有数百个(! ) 比 os.scandir
慢几倍。
如果您运行下面的代码,请确保运行一次,以便您的操作系统访问该文件夹,丢弃结果并运行测试,否则结果将被搞砸。
您可能想混淆函数调用,但我测试了它,这并不重要。
所有示例都将给出文件夹的完整路径。 pathlib 示例作为 (Windows)Path 对象。
os.walk 的第一个元素将是基本文件夹。所以你不会只得到子目录。您可以使用 fu.pop(0) 将其删除。
所有结果都不会使用自然排序。这意味着结果将按如下方式排序:1、10、2。要获得自然排序(1、2、10),请查看 https://stackoverflow.com/a/48030307/2441026
结果:
os.scandir took 1 ms. Found dirs: 439
os.walk took 463 ms. Found dirs: 441 -> it found the nested one + base folder.
glob.glob took 20 ms. Found dirs: 439
pathlib.iterdir took 18 ms. Found dirs: 439
os.listdir took 18 ms. Found dirs: 439
使用 W7x64、Python 3.8.1 测试。
# -*- coding: utf-8 -*-
# Python 3
import time
import os
from glob import glob
from pathlib import Path
directory = r"<insert_folder>"
RUNS = 1
def run_os_walk():
a = time.time_ns()
for i in range(RUNS):
fu = [x[0] for x in os.walk(directory)]
print(f"os.walk\t\t\ttook {(time.time_ns() - a) / 1000 / 1000 / RUNS:.0f} ms. Found dirs: {len(fu)}")
def run_glob():
a = time.time_ns()
for i in range(RUNS):
fu = glob(directory + "/*/")
print(f"glob.glob\t\ttook {(time.time_ns() - a) / 1000 / 1000 / RUNS:.0f} ms. Found dirs: {len(fu)}")
def run_pathlib_iterdir():
a = time.time_ns()
for i in range(RUNS):
dirname = Path(directory)
fu = [f for f in dirname.iterdir() if f.is_dir()]
print(f"pathlib.iterdir\ttook {(time.time_ns() - a) / 1000 / 1000 / RUNS:.0f} ms. Found dirs: {len(fu)}")
def run_os_listdir():
a = time.time_ns()
for i in range(RUNS):
dirname = Path(directory)
fu = [os.path.join(directory, o) for o in os.listdir(directory) if os.path.isdir(os.path.join(directory, o))]
print(f"os.listdir\t\ttook {(time.time_ns() - a) / 1000 / 1000 / RUNS:.0f} ms. Found dirs: {len(fu)}")
def run_os_scandir():
a = time.time_ns()
for i in range(RUNS):
fu = [f.path for f in os.scandir(directory) if f.is_dir()]
print(f"os.scandir\t\ttook {(time.time_ns() - a) / 1000 / 1000 / RUNS:.0f} ms.\tFound dirs: {len(fu)}")
if __name__ == '__main__':
run_os_scandir()
run_os_walk()
run_glob()
run_pathlib_iterdir()
run_os_listdir()
using
pathlib` 如下 `[f for f in p.iterdir() if f.is_dir()]``
fast_scandir
,它需要一个多小时。这是正常的吗?我有什么办法可以加快速度吗?
import os
d = '.'
[os.path.join(d, o) for o in os.listdir(d)
if os.path.isdir(os.path.join(d,o))]
o
上执行 os.path.join
以获取完整路径,否则 isdir(0)
将始终返回 false
os.path.join
两次,您可以先加入,然后使用 os.path.isdir
过滤列表:filter(os.path.isdir, [os.path.join(d, o) for o in os.listdir(d)])
[f for f in data_path.iterdir() if f.is_dir()]
或 glob 一起使用更简单且更易于阅读:glob.glob("/path/to/directory/*/")
。
Python 3.4 将 the pathlib
module 引入标准库,它提供了一种面向对象的方法来处理文件系统路径:
from pathlib import Path
p = Path('./')
# All subdirectories in the current directory, not recursive.
[f for f in p.iterdir() if f.is_dir()]
要递归列出所有子目录,path globbing can be used with the **
pattern.
# This will also include the current directory '.'
list(p.glob('**'))
请注意,作为 glob 模式的单个 *
将非递归地包含文件和目录。要仅获取目录,可以附加尾随 /
,但这仅在直接使用 glob 库时有效,而不是在通过 pathlib 使用 glob 时:
import glob
# These three lines return both files and directories
list(p.glob('*'))
list(p.glob('*/'))
glob.glob('*')
# Whereas this returns only directories
glob.glob('*/')
所以 Path('./').glob('**')
匹配与 glob.glob('**/', recursive=True)
相同的路径。
Pathlib 也可通过 the pathlib2 module on PyPi. 在 Python 2.7 上使用
for f in filter(Path.is_dir, p.iterdir()):
gloab(*/)
还不够吗?无论如何,绝妙的答案,特别适合您对 pathlib
的干净使用。如果它也允许递归,那么评论会很好,尽管从不需要的问题的标题中,未来的读者应该阅读您链接的文档。
**
与 pathlib 的 glob 一起使用时不需要斜杠。关于使用单个星号,这将非递归地匹配文件和目录。
glob.glob('**/', recursive=True)
不包含隐藏目录,但 Path('./').glob('**')
包含
sorted()
,以便对返回的列表进行排序...根据用例可能有用也可能没用
如果您需要一个递归解决方案来查找子目录中的所有子目录,请按照之前的建议使用 walk。
如果您只需要当前目录的子目录,请将 os.listdir
与 os.path.isdir
组合
pathlib
更简单:[f for f in p.iterdir() if f.is_dir()]
pathlib
早了几年。
仅列出目录
print("\nWe are listing out only the directories in current directory -")
directories_in_curdir = list(filter(os.path.isdir, os.listdir(os.curdir)))
print(directories_in_curdir)
仅列出当前目录中的文件
files = list(filter(os.path.isfile, os.listdir(os.curdir)))
print("\nThe following are the list of all files in the current directory -")
print(files)
isdir
。
我更喜欢使用过滤器 (https://docs.python.org/2/library/functions.html#filter),但这只是个人喜好问题。
d='.'
filter(lambda x: os.path.isdir(os.path.join(d, x)), os.listdir(d))
pathlib
更简单:[f for f in p.iterdir() if f.is_dir()]
使用 python-os-walk 实现了这个。 (http://www.pythonforbeginners.com/code-snippets-source-code/python-os-walk/)
import os
print("root prints out directories only from what you specified")
print("dirs prints out sub-directories from root")
print("files prints out all files from root and directories")
print("*" * 20)
for root, dirs, files in os.walk("/var/log"):
print(root)
print(dirs)
print(files)
pathlib
更简单:[f for f in p.iterdir() if f.is_dir()]
您可以使用 os.listdir(path) 在 Python 2.7 中获取子目录(和文件)的列表
import os
os.listdir(path) # list of subdirectories and files
os.listdir
列出了目录的内容,包括文件。
由于我在使用 Python 3.4 和 Windows UNC 路径时偶然发现了这个问题,因此这里有一个适用于该环境的变体:
from pathlib import WindowsPath
def SubDirPath (d):
return [f for f in d.iterdir() if f.is_dir()]
subdirs = SubDirPath(WindowsPath(r'\\file01.acme.local\home$'))
print(subdirs)
Pathlib 是 Python 3.4 中的新功能,它使在不同操作系统下使用路径变得更加容易:https://docs.python.org/3.4/library/pathlib.html
虽然这个问题很久以前就已经回答了。我想推荐使用 pathlib
模块,因为这是在 Windows 和 Unix 操作系统上工作的可靠方式。
因此,要获取特定目录中的所有路径,包括子目录:
from pathlib import Path
paths = list(Path('myhomefolder', 'folder').glob('**/*.txt'))
# all sorts of operations
file = paths[0]
file.name
file.stem
file.parent
file.suffix
等等
在 ipython
中复制粘贴友好:
import os
d='.'
folders = list(filter(lambda x: os.path.isdir(os.path.join(d, x)), os.listdir(d)))
print(folders)
的输出:
['folderA', 'folderB']
x
是 os.listdir(d)
创建的列表中的项目,因为 listdir
将返回文件和文件夹,他使用 filter
命令和 os.path.isdir
过滤列表中的任何文件。
谢谢提醒伙计。我遇到了将软链接(无限递归)作为目录返回的问题。软链接?我们不希望没有臭软的链接!所以...
这仅呈现目录,而不是软链接:
>>> import os
>>> inf = os.walk('.')
>>> [x[0] for x in inf]
['.', './iamadir']
[x[0] for x in inf]
以便我可以查找它?
以下是基于@Blair Conrad 示例的几个简单函数 -
import os
def get_subdirs(dir):
"Get a list of immediate subdirectories"
return next(os.walk(dir))[1]
def get_subfiles(dir):
"Get a list of immediate subfiles"
return next(os.walk(dir))[2]
我就是这样做的。
import os
for x in os.listdir(os.getcwd()):
if os.path.isdir(x):
print(x)
基于 Eli Bendersky 的解决方案,使用以下示例:
import os
test_directory = <your_directory>
for child in os.listdir(test_directory):
test_path = os.path.join(test_directory, child)
if os.path.isdir(test_path):
print test_path
# Do stuff to the directory "test_path"
其中 <your_directory>
是您要遍历的目录的路径。
使用完整路径并考虑路径为 .
、..
、\\
、..\\..\\subfolder
等:
import os, pprint
pprint.pprint([os.path.join(os.path.abspath(path), x[0]) \
for x in os.walk(os.path.abspath(path))])
这个答案似乎并不存在。
directories = [ x for x in os.listdir('.') if os.path.isdir(x) ]
我最近有一个类似的问题,我发现python 3.6(正如用户 havlock 添加的)的最佳答案是使用 os.scandir
。由于似乎没有使用它的解决方案,我将添加我自己的。首先,一种非递归解决方案,仅列出根目录下的子目录。
def get_dirlist(rootdir):
dirlist = []
with os.scandir(rootdir) as rit:
for entry in rit:
if not entry.name.startswith('.') and entry.is_dir():
dirlist.append(entry.path)
dirlist.sort() # Optional, in case you want sorted directory names
return dirlist
递归版本如下所示:
def get_dirlist(rootdir):
dirlist = []
with os.scandir(rootdir) as rit:
for entry in rit:
if not entry.name.startswith('.') and entry.is_dir():
dirlist.append(entry.path)
dirlist += get_dirlist(entry.path)
dirlist.sort() # Optional, in case you want sorted directory names
return dirlist
请记住,entry.path
使用子目录的绝对路径。如果您只需要文件夹名称,则可以改用 entry.name
。有关 entry
对象的更多详细信息,请参阅 os.DirEntry。
最简单的方法:
from pathlib import Path
from glob import glob
current_dir = Path.cwd()
all_sub_dir_paths = glob(str(current_dir) + '/*/') # returns list of sub directory paths
all_sub_dir_names = [Path(sub_dir).name for sub_dir in all_sub_dir_paths]
这将列出文件树下的所有子目录。
import pathlib
def list_dir(dir):
path = pathlib.Path(dir)
dir = []
try:
for item in path.iterdir():
if item.is_dir():
dir.append(item)
dir = dir + list_dir(item)
return dir
except FileNotFoundError:
print('Invalid directory')
pathlib
是 3.4 版中的新功能
函数返回给定文件路径中所有子目录的列表。将搜索整个文件树。
import os
def get_sub_directory_paths(start_directory, sub_directories):
"""
This method iterates through all subdirectory paths of a given
directory to collect all directory paths.
:param start_directory: The starting directory path.
:param sub_directories: A List that all subdirectory paths will be
stored to.
:return: A List of all sub-directory paths.
"""
for item in os.listdir(start_directory):
full_path = os.path.join(start_directory, item)
if os.path.isdir(full_path):
sub_directories.append(full_path)
# Recursive call to search through all subdirectories.
get_sub_directory_paths(full_path, sub_directories)
return sub_directories
在 os.listdir()
上使用过滤函数 os.path.isdir
,类似于 filter(os.path.isdir,[os.path.join(os.path.abspath('PATH'),p) for p in os.listdir('PATH/')])
此函数使用给定的父 directory
以递归方式迭代其所有 directories
和 prints
它在内部找到的所有 filenames
。太有用了。
import os
def printDirectoryFiles(directory):
for filename in os.listdir(directory):
full_path=os.path.join(directory, filename)
if not os.path.isdir(full_path):
print( full_path + "\n")
def checkFolders(directory):
dir_list = next(os.walk(directory))[1]
#print(dir_list)
for dir in dir_list:
print(dir)
checkFolders(directory +"/"+ dir)
printDirectoryFiles(directory)
main_dir="C:/Users/S0082448/Desktop/carpeta1"
checkFolders(main_dir)
input("Press enter to exit ;")
我们可以使用 os.walk() 获取所有文件夹的列表
import os
path = os.getcwd()
pathObject = os.walk(path)
这个 pathObject 是一个对象,我们可以通过
arr = [x for x in pathObject]
arr is of type [('current directory', [array of folder in current directory], [files in current directory]),('subdirectory', [array of folder in subdirectory], [files in subdirectory]) ....]
我们可以通过遍历 arr 并打印中间数组来获取所有子目录的列表
for i in arr:
for j in i[1]:
print(j)
这将打印所有子目录。
获取所有文件:
for i in arr:
for j in i[2]:
print(i[0] + "/" + j)
通过从这里加入多个解决方案,这就是我最终使用的:
import os
import glob
def list_dirs(path):
return [os.path.basename(x) for x in filter(
os.path.isdir, glob.glob(os.path.join(path, '*')))]
那里有很多不错的答案,但是如果您来这里寻找一种简单的方法来一次获取所有文件或文件夹的列表。您可以利用在 linux 和 mac 上提供的 os,它比 os.walk 快得多
import os
all_files_list = os.popen("find path/to/my_base_folder -type f").read().splitlines()
all_sub_directories_list = os.popen("find path/to/my_base_folder -type d").read().splitlines()
或者
import os
def get_files(path):
all_files_list = os.popen(f"find {path} -type f").read().splitlines()
return all_files_list
def get_sub_folders(path):
all_sub_directories_list = os.popen(f"find {path} -type d").read().splitlines()
return all_sub_directories_list
下面这个类将能够获取给定目录中的文件、文件夹和所有子文件夹的列表
import os
import json
class GetDirectoryList():
def __init__(self, path):
self.main_path = path
self.absolute_path = []
self.relative_path = []
def get_files_and_folders(self, resp, path):
all = os.listdir(path)
resp["files"] = []
for file_folder in all:
if file_folder != "." and file_folder != "..":
if os.path.isdir(path + "/" + file_folder):
resp[file_folder] = {}
self.get_files_and_folders(resp=resp[file_folder], path= path + "/" + file_folder)
else:
resp["files"].append(file_folder)
self.absolute_path.append(path.replace(self.main_path + "/", "") + "/" + file_folder)
self.relative_path.append(path + "/" + file_folder)
return resp, self.relative_path, self.absolute_path
@property
def get_all_files_folder(self):
self.resp = {self.main_path: {}}
all = self.get_files_and_folders(self.resp[self.main_path], self.main_path)
return all
if __name__ == '__main__':
mylib = GetDirectoryList(path="sample_folder")
file_list = mylib.get_all_files_folder
print (json.dumps(file_list))
而示例目录看起来像
sample_folder/
lib_a/
lib_c/
lib_e/
__init__.py
a.txt
__init__.py
b.txt
c.txt
lib_d/
__init__.py
__init__.py
d.txt
lib_b/
__init__.py
e.txt
__init__.py
获得的结果
[
{
"files": [
"__init__.py"
],
"lib_b": {
"files": [
"__init__.py",
"e.txt"
]
},
"lib_a": {
"files": [
"__init__.py",
"d.txt"
],
"lib_c": {
"files": [
"__init__.py",
"c.txt",
"b.txt"
],
"lib_e": {
"files": [
"__init__.py",
"a.txt"
]
}
},
"lib_d": {
"files": [
"__init__.py"
]
}
}
},
[
"sample_folder/lib_b/__init__.py",
"sample_folder/lib_b/e.txt",
"sample_folder/__init__.py",
"sample_folder/lib_a/lib_c/lib_e/__init__.py",
"sample_folder/lib_a/lib_c/lib_e/a.txt",
"sample_folder/lib_a/lib_c/__init__.py",
"sample_folder/lib_a/lib_c/c.txt",
"sample_folder/lib_a/lib_c/b.txt",
"sample_folder/lib_a/lib_d/__init__.py",
"sample_folder/lib_a/__init__.py",
"sample_folder/lib_a/d.txt"
],
[
"lib_b/__init__.py",
"lib_b/e.txt",
"sample_folder/__init__.py",
"lib_a/lib_c/lib_e/__init__.py",
"lib_a/lib_c/lib_e/a.txt",
"lib_a/lib_c/__init__.py",
"lib_a/lib_c/c.txt",
"lib_a/lib_c/b.txt",
"lib_a/lib_d/__init__.py",
"lib_a/__init__.py",
"lib_a/d.txt"
]
]
使用 os walk
sub_folders = []
for dir, sub_dirs, files in os.walk(test_folder):
sub_folders.extend(sub_dirs)
不定期副业成功案例分享
os.walk
和os.listdir
+os.path.isdir
解决方案之间的性能差异的人:我刚刚在一个包含 10,000 个子目录(下面的层次结构中有数百万个文件)的目录上进行了测试,性能差异可以忽略不计。os.walk
:“10 次循环,3 次中的最佳:每个循环 44.6 毫秒”和os.listdir
+os.path.isdir
:“10 次循环,3 次中的最佳:每个循环 45.1 毫秒”