Как перечислить все файлы каталога?

Как я могу перечислить все файлы каталога в Python и добавить их в list?

2924
задан duhhunjonn 08 июля '10 в 22:31
источник поделиться
33 ответов
  • 1
  • 2

os.listdir() предоставит вам все, что в каталоге - файлы и каталоги.

Если вы хотите просто файлы, вы можете либо отфильтровать это, используя os.path:

from os import listdir
from os.path import isfile, join
onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]

или вы можете использовать os.walk(), который даст два списка для каждой посещаемой директории - разделение на файлы и для вас. Если вам нужен только верхний каталог, вы можете просто сломать первый раз, когда он даст

from os import walk

f = []
for (dirpath, dirnames, filenames) in walk(mypath):
    f.extend(filenames)
    break

И, наконец, как показано в этом примере, добавив один список в другой, вы можете либо использовать .extend(), либо

>>> q = [1, 2, 3]
>>> w = [4, 5, 6]
>>> q = q + w
>>> q
[1, 2, 3, 4, 5, 6]

Лично я предпочитаю .extend()

2906
ответ дан pycruft 09 июля '10 в 0:01
источник поделиться

Я предпочитаю использовать модуль glob, так как он сопоставляет и расширяет шаблон.

import glob
print(glob.glob("/home/adam/*.txt"))

Он вернет список с запрошенными файлами:

['/home/adam/file1.txt', '/home/adam/file2.txt', .... ]
1174
ответ дан adamk 09 июля '10 в 21:13
источник поделиться
import os
os.listdir("somedirectory")

вернет список всех файлов и каталогов в "somedirectory".

530
ответ дан sepp2k 08 июля '10 в 22:35
источник поделиться

Получить список файлов с Python 2 и 3


Я также сделал короткое видео здесь: WJeCC.png Python: как получить список файлов в каталоге


os.listdir()

или..... hot, чтобы получить все файлы (и каталоги) в текущем каталоге (Python 3)

Самый простой способ иметь файл в текущем каталоге в Python 3. Это очень просто; используйте модуль os и функцию listdir(), и у вас будет файл в этом каталоге (и в конечном итоге папки, которые находятся в каталоге, но вы не будете иметь файл в подкаталоге, для этого вы можете использовать прогулку - я буду поговорите об этом позже).

>>> import os
>>> arr = os.listdir()
>>> arr
['$RECYCLE.BIN', 'work.txt', '3ebooks.txt', 'documents']

Использование glob

Я нашел glob легче выбрать файл того же типа или что-то общее. Посмотрите на следующий пример:

import glob

txtfiles = []
for file in glob.glob("*.txt"):
    txtfiles.append(file)

Использование учета списков

import glob

mylist = [f for f in glob.glob("*.txt")]

Получение полного имени пути с помощью os.path.abspath

Как вы заметили, у вас нет полного пути к файлу в приведенном выше коде. Если вам нужно иметь абсолютный путь, вы можете использовать другую функцию os.path модуля под названием _getfullpathname, помещая файл, который вы получаете от os.listdir() в качестве аргумента. Есть и другие способы иметь полный путь, как мы будем проверять позже (я заменил, как было предложено mexmex, _getfullpathname с abspath).

>>> import os
>>> files_path = [os.path.abspath(x) for x in os.listdir()]
>>> files_path
['F:\\documenti\applications.txt', 'F:\\documenti\collections.txt']

Получить полный путь к типу файла во всех подкаталогах с помощью walk

Мне очень полезно найти материал во многих каталогах, и это помогло мне найти файл, о котором я не помню имя:

import os

# Getting the current work directory (cwd)
thisdir = os.getcwd()

# r=root, d=directories, f = files
for r, d, f in os.walk(thisdir):
    for file in f:
        if ".docx" in file:
            print(os.path.join(r, file))

os.listdir(): получить файлы в текущем каталоге (Python 2)

В Python 2 вы, если хотите список файлов в текущем каталоге, должны указать аргумент как. или os.getcwd() в методе os.listdir.

>>> import os
>>> arr = os.listdir('.')
>>> arr
['$RECYCLE.BIN', 'work.txt', '3ebooks.txt', 'documents']

Чтобы перейти в дерево каталогов

>>> # Method 1
>>> x = os.listdir('..')

# Method 2
>>> x= os.listdir('/')

Получить файлы: os.listdir() в определенном каталоге (Python 2 и 3)

>>> import os
>>> arr = os.listdir('F:\\python')
>>> arr
['$RECYCLE.BIN', 'work.txt', '3ebooks.txt', 'documents']

Получите файлы определенного подкаталога с помощью os.listdir()

import os

x = os.listdir("./content")

os.walk('.') - текущий каталог

>>> import os
>>> arr = next(os.walk('.'))[2]
>>> arr
['5bs_Turismo1.pdf', '5bs_Turismo1.pptx', 'esperienza.txt']

glob module - все файлы

import glob
print(glob.glob("*"))

out:['content', 'start.py']

next (os.walk('.')) и os.path.join('dir', 'file')

>>> import os
>>> arr = []
>>> for d,r,f in next(os.walk("F:\_python")):
>>>     for file in f:
>>>         arr.append(os.path.join(r,file))
...
>>> for f in arr:
>>>     print(files)

>output

F:\\_python\\dict_class.py
F:\\_python\\programmi.txt

next (os.walk('F: \') - получить полное описание списка пути

>>> [os.path.join(r,file) for r,d,f in next(os.walk("F:\\_python")) for file in f]
['F:\\_python\\dict_class.py', 'F:\\_python\\programmi.txt']

os.walk - получить полный путь - все файлы в sub dirs

x = [os.path.join(r,file) for r,d,f in os.walk("F:\\_python") for file in f]

>>>x
['F:\\_python\\dict.py', 'F:\\_python\\progr.txt', 'F:\\_python\\readl.py']

os.listdir() - получать только файлы txt

>>> arr_txt = [x for x in os.listdir() if x.endswith(".txt")]
>>> print(arr_txt)
['work.txt', '3ebooks.txt']

glob - получить только txt файлы

>>> import glob
>>> x = glob.glob("*.txt")
>>> x
['ale.txt', 'alunni2015.txt', 'assenze.text.txt', 'text2.txt', 'untitled.txt']

Использование glob для получения полного пути к файлам

Если мне нужен абсолютный путь к файлам:

>>> from path import path
>>> from glob import glob
>>> x = [path(f).abspath() for f in glob("F:\*.txt")]
>>> for f in x:
...  print(f)
...
F:\acquistionline.txt
F:\acquisti_2018.txt
F:\bootstrap_jquery_ecc.txt

Другое использование glob

Если мне нужны все файлы в каталоге:

>>> x = glob.glob("*")

Использование os.path.isfile для исключения каталогов в списке

import os.path
listOfFiles = [f for f in os.listdir() if os.path.isfile(f)]
print(listOfFiles)

> output

['a simple game.py', 'data.txt', 'decorator.py']

Использование pathlib из (Python 3.4)

import pathlib

>>> flist = []
>>> for p in pathlib.Path('.').iterdir():
...  if p.is_file():
...   print(p)
...   flist.append(p)
...
error.PNG
exemaker.bat
guiprova.mp3
setup.py
speak_gui2.py
thumb.PNG

Если вы хотите использовать понимание списка

>>> flist = [p for p in pathlib.Path('.').iterdir() if p.is_file()]

* Вы также можете использовать только pathlib.Path() вместо pathlib.Path(".")

Использовать метод glob в pathlib.Path()

import pathlib

py = pathlib.Path().glob("*.py")
for file in py:
    print(file)

вывод:

stack_overflow_list.py
stack_overflow_list_tkinter.py

Получите все и только файлы с os.walk

import os
x = [i[2] for i in os.walk('.')]
y=[]
for t in x:
    for f in t:
        y.append(f)

>>> y
['append_to_list.py', 'data.txt', 'data1.txt', 'data2.txt', 'data_180617', 'os_walk.py', 'READ2.py', 'read_data.py', 'somma_defaltdic.py', 'substitute_words.py', 'sum_data.py', 'data.txt', 'data1.txt', 'data_180617']

Получайте только файлы со следующими и пройдите в каталог

>>> import os
>>> x = next(os.walk('F://python'))[2]
>>> x
['calculator.bat','calculator.py']

Получайте только каталоги со следующими и пройдите в каталог

>>> import os
>>> next(os.walk('F://python'))[1] # for the current dir use ('.')
['python3','others']

Получите все имена субдира с помощью прогулки

>>> for r,d,f in os.walk("F:\_python"):
...  for dirs in d:
...   print(dirs)
...
.vscode
pyexcel
pyschool.py
subtitles
_metaprogramming
.ipynb_checkpoints

os.scandir() из Python 3.5 on

>>> import os
>>> x = [f.name for f in os.scandir() if f.is_file()]
>>> x
['calculator.bat','calculator.py']

# Another example with scandir (a little variation from docs.python.org)
# This one is more efficient than os.listdir.
# In this case, it shows the files only in the current directory
# where the script is executed.

>>> import os
>>> with os.scandir() as i:
...  for entry in i:
...   if entry.is_file():
...    print(entry.name)
...
ebookmaker.py
error.PNG
exemaker.bat
guiprova.mp3
setup.py
speakgui4.py
speak_gui2.py
speak_gui3.py
thumb.PNG
>>>

Ex. 1: Сколько файлов есть в подкаталогах?

В этом примере мы ищем количество файлов, которые включены во всю директорию и ее подкаталоги.

import os

def count(dir, counter=0):
    "returns number of files in dir and subdirs"
    for pack in os.walk(dir):
        for f in pack[2]:
            counter += 1
    return dir + " : " + str(counter) + "files"

print(count("F:\\python"))

> output

>'F:\\\python' : 12057 files'

Пример 2. Как скопировать все файлы из каталога в другой?

Скрипт, чтобы сделать заказ на вашем компьютере, чтобы найти все файлы типа (по умолчанию: pptx) и скопировать их в новую папку.

import os
import shutil
from path import path

destination = "F:\\file_copied"
# os.makedirs(destination)

def copyfile(dir, filetype='pptx', counter=0):
    "Searches for pptx (or other - pptx is the default) files and copies them"
    for pack in os.walk(dir):
        for f in pack[2]:
            if f.endswith(filetype):
                fullpath = pack[0] + "\\" + f
                print(fullpath)
                shutil.copy(fullpath, destination)
                counter += 1
    if counter > 0:
        print("------------------------")
        print("\t==> Found in: '" + dir + "' : " + str(counter) + " files\n")

for dir in os.listdir():
    "searches for folders that starts with '_'"
    if dir[0] == '_':
        # copyfile(dir, filetype='pdf')
        copyfile(dir, filetype='txt')


> Output

_compiti18\Compito Contabilità 1\conti.txt
_compiti18\Compito Contabilità 1\modula4.txt
_compiti18\Compito Contabilità 1\moduloa4.txt
------------------------
==> Found in: '_compiti18' : 3 files

Ex. 3: Как получить все файлы в txt файле

Если вы хотите создать txt файл со всеми именами файлов:

import os
mylist = ""
with open("filelist.txt", "w", encoding="utf-8") as file:
    for eachfile in os.listdir():
        mylist += eachfile + "\n"
    file.write(mylist)

Пример: txt со всеми файлами жесткого диска

"""We are going to save a txt file with all the files in your directory.
We will use the function walk()

"""

import os

# see all the methos of os
# print(*dir(os), sep=", ")
listafile = []
percorso = []
with open("lista_file.txt", "w", encoding='utf-8') as testo:
    for root, dirs, files in os.walk("D:\\"):
        for file in files:
            listafile.append(file)
            percorso.append(root + "\\" + file)
            testo.write(file + "\n")
listafile.sort()
print("N. of files", len(listafile))
with open("lista_file_ordinata.txt", "w", encoding="utf-8") as testo_ordinato:
    for file in listafile:
        testo_ordinato.write(file + "\n")

with open("percorso.txt", "w", encoding="utf-8") as file_percorso:
    for file in percorso:
        file_percorso.write(file + "\n")

os.system("lista_file.txt")
os.system("lista_file_ordinata.txt")
os.system("percorso.txt")
361
ответ дан Giovanni Gianni 03 янв. '17 в 18:36
источник поделиться

Однострочное решение для получения только списка файлов (без подкаталогов):

filenames = next(os.walk(path))[2]

или абсолютные пути:

paths = [os.path.join(path,fn) for fn in next(os.walk(path))[2]]
145
ответ дан Remi 18 янв. '14 в 20:42
источник поделиться

Получение полных путей к файлу из каталога и всех его подкаталогов

import os

def get_filepaths(directory):
    """
    This function will generate the file names in a directory 
    tree by walking the tree either top-down or bottom-up. For each 
    directory in the tree rooted at directory top (including top itself), 
    it yields a 3-tuple (dirpath, dirnames, filenames).
    """
    file_paths = []  # List which will store all of the full filepaths.

    # Walk the tree.
    for root, directories, files in os.walk(directory):
        for filename in files:
            # Join the two strings in order to form the full filepath.
            filepath = os.path.join(root, filename)
            file_paths.append(filepath)  # Add it to the list.

    return file_paths  # Self-explanatory.

# Run the above function and store its results in a variable.   
full_file_paths = get_filepaths("/Users/johnny/Desktop/TEST")

  • Путь, указанный в приведенной выше функции, содержал 3 файла - два из них в корневом каталоге, а другой - в подпапке под названием "SUBFOLDER". Теперь вы можете делать такие вещи, как:
  • print full_file_paths, который распечатает список:

    • ['/Users/johnny/Desktop/TEST/file1.txt', '/Users/johnny/Desktop/TEST/file2.txt', '/Users/johnny/Desktop/TEST/SUBFOLDER/file3.dat']

Если вы хотите, вы можете открыть и прочитать содержимое или сосредоточиться только на файлах с расширением ".dat", как в приведенном ниже коде:

for f in full_file_paths:
  if f.endswith(".dat"):
    print f

/Users/johnny/Desktop/TEST/SUBFOLDER/file3.dat

111
ответ дан Johnny 11 окт. '13 в 3:55
источник поделиться

Начиная с версии 3.4 есть встроенные итераторы для этого, которые намного эффективнее, чем os.listdir():

pathlib: Новое в версии 3.4.

>>> import pathlib
>>> [p for p in pathlib.Path('.').iterdir() if p.is_file()]

Согласно PEP 428, цель библиотеки pathlib состоит в том, чтобы обеспечить простую иерархию классов для обработки путей файловой системы и общих действий пользователей над ними.

os.scandir(): Новое в версии 3.5.

>>> import os
>>> [entry for entry in os.scandir('.') if entry.is_file()]

Обратите внимание, что os.walk() использует os.scandir() вместо os.listdir() из версии 3.5, и его скорость увеличивается в 2-20 раз в соответствии с PEP 471.

Позвольте мне также рекомендовать прочитать комментарий ShadowRanger ниже.

57
ответ дан SzieberthAdam 18 июня '15 в 23:58
источник поделиться

Мне действительно понравился ответ adamk, предлагая использовать glob() из модуля с тем же именем. Это позволяет вам сопоставлять шаблоны с * s.

Но, как отмечали другие люди в комментариях, glob() может столкнуться с несогласованными направлениями косой черты. Чтобы помочь в этом, я предлагаю вам использовать функции join() и expanduser() в модуле os.path и, возможно, функцию getcwd() в модуле os.

В качестве примеров:

from glob import glob

# Return everything under C:\Users\admin that contains a folder called wlp.
glob('C:\Users\admin\*\wlp')

Это ужасно - путь жестко запрограммирован и будет работать только в Windows между именем диска и \, жестко закодированным в пути.

from glob    import glob
from os.path import join

# Return everything under Users, admin, that contains a folder called wlp.
glob(join('Users', 'admin', '*', 'wlp'))

Приведенное выше работает лучше, но оно зависит от имени папки Users, которое часто встречается в Windows и не так часто встречается на других ОС. Он также зависит от пользователя, имеющего определенное имя, admin.

from glob    import glob
from os.path import expanduser, join

# Return everything under the user directory that contains a folder called wlp.
glob(join(expanduser('~'), '*', 'wlp'))

Это отлично работает на всех платформах.

Еще один отличный пример, который отлично работает на разных платформах и делает что-то совсем другое:

from glob    import glob
from os      import getcwd
from os.path import join

# Return everything under the current directory that contains a folder called wlp.
glob(join(getcwd(), '*', 'wlp'))

Надеемся, что эти примеры помогут вам увидеть мощь нескольких функций, которые вы можете найти в стандартных библиотечных модулях Python.

45
ответ дан ArtOfWarfare 09 июля '14 в 14:43
источник поделиться
def list_files(path):
    # returns a list of names (with extension, without full path) of all files 
    # in folder path
    files = []
    for name in os.listdir(path):
        if os.path.isfile(os.path.join(path, name)):
            files.append(name)
    return files 
33
ответ дан Apogentus 10 июня '14 в 19:16
источник поделиться

Вы должны использовать модуль os для размещения содержимого каталога. os.listdir(".") возвращает все содержимое каталога. Мы перебираем результат и добавляем его в список.

import os

content_list = []

for content in os.listdir("."): # "." means current directory
    content_list.append(content)

print content_list
27
ответ дан Harun ERGUL 23 марта '16 в 13:09
источник поделиться

Часть первая 1

Предварительные примечания

  • Хотя в тексте вопроса существует четкое различие между условиями файла и каталога, некоторые могут утверждать, что каталоги на самом деле являются специальными файлами
  • Вывод: "все файлы каталога" можно интерпретировать двумя способами:
    1. Только все прямые (или 1 -го уровня), потомки
    2. Все потомки во всем дереве каталогов (в том числе в подкаталогах)
  • Когда вопрос был задан, я предполагаю, что Python 2 был версией LTS, однако образцы кода будут выполняться Python 3 (.5) (я сохраню их как совместимые с Python 2, а также любой код, принадлежащий Python, который я собираюсь опубликовать, из v3.5.4 - если не указано иное). Это имеет последствия, связанные с другим ключевым словом в вопросе: "добавить их в список ":

    • В версиях pre Python 2.2 последовательности (iterables) были в основном представлены списками (кортежи, наборы,...)
    • В Python 2.2 была введена концепция генератора ([Python]: Generators) - любезно предоставлена [Python]: оператор yield). По прошествии времени начали появляться экземпляры генераторов для функций, которые возвращались/работали со списками
    • В Python 3 генератор - это поведение по умолчанию
    • Теперь я не знаю, является ли возвращение списка по-прежнему обязательным (или генератор тоже будет работать), но передача генератора в конструктор list приведет к созданию из него списка (а также его уничтожению). Пример ниже иллюстрирует различия на [Python]: map (function, iterable,...)
    Python 2.7.10 (default, Mar  8 2016, 15:02:46) [MSC v.1600 64 bit (AMD64)] on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>> m = map(lambda x: x, [1, 2, 3])  # Just a dummy lambda function
    >>> m, type(m)
    ([1, 2, 3], <type 'list'>)
    >>> len(m)
    3
    


    Python 3.5.4 (v3.5.4:3f56838, Aug  8 2017, 02:17:05) [MSC v.1900 64 bit (AMD64)] on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>> m = map(lambda x: x, [1, 2, 3])
    >>> m, type(m)
    (<map object at 0x000001B4257342B0>, <class 'map'>)
    >>> len(m)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: object of type 'map' has no len()
    >>> lm0 = list(m)  # Construct a list out of the generator
    >>> lm0, type(lm0)
    ([1, 2, 3], <class 'list'>)
    >>>
    >>> lm1 = list(m)  # Construct a list out of the same generator
    >>> lm1, type(lm1)  # Empty list this time - generator already consumed
    ([], <class 'list'>)
    
  • Примеры будут основаны на каталоге root_dir со следующей структурой (этот пример для Win, но я также дублировал дерево папок для Ux (Lnx)):

    E:\Work\Dev\StackOverflow\q003207219>tree /f "root_dir"
    Folder PATH listing for volume Work
    Volume serial number is 00000029 3655:6FED
    E:\WORK\DEV\STACKOVERFLOW\Q003207219\ROOT_DIR
    │   file0
    │   file1
    │
    ├───dir0
    │   ├───dir00
    │   │   │   file000
    │   │   │
    │   │   └───dir000
    │   │           file0000
    │   │
    │   ├───dir01
    │   │       file010
    │   │       file011
    │   │
    │   └───dir02
    │       └───dir020
    │           └───dir0200
    ├───dir1
    │       file10
    │       file11
    │       file12
    │
    ├───dir2
    │   │   file20
    │   │
    │   └───dir20
    │           file200
    │
    └───dir3
    


Решения

Программные подходы:

  1. [Python]: os. listdir (path = '.')

    Верните список, содержащий имена записей в каталоге, заданном путем. Список имеет произвольный порядок и не включает специальные записи '.' и '..'...


    >>> import os
    >>> root_dir = "root_dir"  # Path relative to current dir (os.getcwd())
    >>>
    >>> os.listdir(root_dir)  # List all the items in root_dir
    ['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']
    >>>
    >>> [item for item in os.listdir(root_dir) if os.path.isfile(os.path.join(root_dir, item))]  # Filter the items and only keep files (strip out directories)
    ['file0', 'file1']
    

    Вот более сложный пример (code_os_listdir.py):

    import os
    from pprint import pformat
    
    
    def _get_dir_content(path, include_folders, recursive):
        entries = os.listdir(path)
        for entry in entries:
            entry_with_path = os.path.join(path, entry)
            if os.path.isdir(entry_with_path):
                if include_folders:
                    yield entry_with_path
                if recursive:
                    for sub_entry in _get_dir_content(entry_with_path, include_folders, recursive):
                        yield sub_entry
            else:
                yield entry_with_path
    
    
    def get_dir_content(path, include_folders=True, recursive=True, prepend_folder_name=True):
        path_len = len(path) + len(os.path.sep)
        for item in _get_dir_content(path, include_folders, recursive):
            yield item if prepend_folder_name else item[path_len:]
    
    
    def _get_dir_content_old(path, include_folders, recursive):
        entries = os.listdir(path)
        ret = list()
        for entry in entries:
            entry_with_path = os.path.join(path, entry)
            if os.path.isdir(entry_with_path):
                if include_folders:
                    ret.append(entry_with_path)
                if recursive:
                    ret.extend(_get_dir_content_old(entry_with_path, include_folders, recursive))
            else:
                ret.append(entry_with_path)
        return ret
    
    
    def get_dir_content_old(path, include_folders=True, recursive=True, prepend_folder_name=True):
        path_len = len(path) + len(os.path.sep)
        return [item if prepend_folder_name else item[path_len:] for item in _get_dir_content_old(path, include_folders, recursive)]
    
    
    def main():
        root_dir = "root_dir"
        ret0 = get_dir_content(root_dir, include_folders=True, recursive=True, prepend_folder_name=True)
        lret0 = list(ret0)
        print(ret0, len(lret0), pformat(lret0))
        ret1 = get_dir_content_old(root_dir, include_folders=False, recursive=True, prepend_folder_name=False)
        print(len(ret1), pformat(ret1))
    
    
    if __name__ == "__main__":
        main()
    

    Примечания:

    • Существуют две реализации:
      • Тот, который использует генераторы (конечно, в этом примере это кажется бесполезным, поскольку я сразу конвертирую результат в список)
      • Классический (имена функций, заканчивающиеся на _old)
    • Рекурсия используется (чтобы попасть в подкаталоги)
    • Для каждой реализации есть две функции:
      • Тот, который начинается с подчеркивания (_): "частный" (не должен вызываться напрямую) - это делает всю работу
      • Публичный (обертка над предыдущим): он просто удаляет исходный путь (если требуется) из возвращаемых записей. Это уродливая реализация, но это единственная идея, с которой я мог бы прийти в этот момент
    • С точки зрения производительности генераторы, как правило, немного быстрее (с учетом времени создания и итерации), но я не тестировал их в рекурсивных функциях, а также выполняю функцию внутри внутренних генераторов - не знаю, как производительность это то, что
    • Играйте с аргументами, чтобы получить разные результаты


    Выход:

    (py35x64_test) E:\Work\Dev\StackOverflow\q003207219>"e:\Work\Dev\VEnvs\py35x64_test\Scripts\python.exe" "code_os_listdir.py"
    <generator object get_dir_content at 0x000001BDDBB3DF10> 22 ['root_dir\\dir0',
     'root_dir\\dir0\\dir00',
     'root_dir\\dir0\\dir00\\dir000',
     'root_dir\\dir0\\dir00\\dir000\\file0000',
     'root_dir\\dir0\\dir00\\file000',
     'root_dir\\dir0\\dir01',
     'root_dir\\dir0\\dir01\\file010',
     'root_dir\\dir0\\dir01\\file011',
     'root_dir\\dir0\\dir02',
     'root_dir\\dir0\\dir02\\dir020',
     'root_dir\\dir0\\dir02\\dir020\\dir0200',
     'root_dir\\dir1',
     'root_dir\\dir1\\file10',
     'root_dir\\dir1\\file11',
     'root_dir\\dir1\\file12',
     'root_dir\\dir2',
     'root_dir\\dir2\\dir20',
     'root_dir\\dir2\\dir20\\file200',
     'root_dir\\dir2\\file20',
     'root_dir\\dir3',
     'root_dir\\file0',
     'root_dir\\file1']
    11 ['dir0\\dir00\\dir000\\file0000',
     'dir0\\dir00\\file000',
     'dir0\\dir01\\file010',
     'dir0\\dir01\\file011',
     'dir1\\file10',
     'dir1\\file11',
     'dir1\\file12',
     'dir2\\dir20\\file200',
     'dir2\\file20',
     'file0',
     'file1']
    


  1. [Python]: os. scandir (path = '.') (!!! Python 3.5 + !!! хотя я думаю, что для более ранних версий это был отдельный модуль (также перенесенный на Python 2))

    Верните итератор объектов os.DirEntry, соответствующих записям в каталоге, заданном путем. Записи вводятся в произвольном порядке, а специальные записи '.' и '..' не включены.

    Использование scandir() вместо listdir() может значительно повысить производительность кода, который также нуждается в информации о типе файла или атрибуте файла, поскольку объекты os.DirEntry раскрывают эту информацию, если операционная система предоставляет ее при сканировании каталога. Все методы os.DirEntry могут выполнять системный вызов, но is_dir() и is_file() обычно требуют только системного вызова для символических ссылок; os.DirEntry.stat() всегда требует системного вызова в Unix, но требует только одного для символических ссылок в Windows.


    >>> import os
    >>> root_dir = os.path.join(".", "root_dir")  # Explicitly prepending current directory
    >>> root_dir
    '.\\root_dir'
    >>>
    >>> scandir_iterator = os.scandir(root_dir)
    >>> scandir_iterator
    <nt.ScandirIterator object at 0x00000268CF4BC140>
    >>> [item.path for item in scandir_iterator]
    ['.\\root_dir\\dir0', '.\\root_dir\\dir1', '.\\root_dir\\dir2', '.\\root_dir\\dir3', '.\\root_dir\\file0', '.\\root_dir\\file1']
    >>>
    >>> [item.path for item in scandir_iterator]  # Will yield an empty list as it was consumed by previous iteration (automatically performed by the list comprehension)
    []
    >>>
    >>> scandir_iterator = os.scandir(root_dir)  # Reinitialize the generator
    >>> for item in scandir_iterator :
    ...     if os.path.isfile(item.path):
    ...             print(item.name)
    ...
    file0
    file1
    

    Примечания:

    • Это похоже на os.listdir
    • Но он также более гибкий (и предлагает больше функциональности), больше Pythonic (а в некоторых случаях и быстрее)


  1. [Python]: os. walk (top, topdown = True, onerror = None, followlinks = False)

    Создайте имена файлов в дереве каталогов, идя по дереву сверху вниз или снизу вверх. Для каждого каталога в дереве, укорененном в верхней части каталога (включая сам верх), он дает 3-кортеж (dirpath, dirnames, filenames).


    >>> import os
    >>> root_dir = os.path.join(os.getcwd(), "root_dir")  # Specify the full path
    >>> root_dir
    'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir'
    >>>
    >>> walk_generator = os.walk(root_dir)
    >>> root_dir_entry = next(walk_generator)  # First entry corresponds to the root dir (that was passed as an argument)
    >>> root_dir_entry
    ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir', ['dir0', 'dir1', 'dir2', 'dir3'], ['file0', 'file1'])
    >>>
    >>> root_dir_entry[1] + root_dir_entry[2]  # Display the dirs and the files (that are direct descendants) in a single list
    ['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']
    >>>
    >>> [os.path.join(root_dir_entry[0], item) for item in root_dir_entry[1] + root_dir_entry[2]]  # Display all the entries in the previous list by their full path
    ['E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir1', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir2', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir3', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\file0', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\file1']
    >>>
    >>> for entry in walk_generator:  # Display the rest of the elements (corresponding to every subdir)
    ...     print(entry)
    ...
    ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0', ['dir00', 'dir01', 'dir02'], [])
    ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir00', ['dir000'], ['file000'])
    ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir00\\dir000', [], ['file0000'])
    ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir01', [], ['file010', 'file011'])
    ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir02', ['dir020'], [])
    ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir02\\dir020', ['dir0200'], [])
    ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir02\\dir020\\dir0200', [], [])
    ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir1', [], ['file10', 'file11', 'file12'])
    ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir2', ['dir20'], ['file20'])
    ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir2\\dir20', [], ['file200'])
    ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir3', [], [])
    

    Примечания:

    • В os.listdir используется os.listdir (os.scandir если доступно)
    • Он делает тяжелый подъем, повторяясь в подпапках


  1. [Python]: glob. glob (pathname, *, recursive = False) ([Python]: glob. iglob (pathname, *, recursive = False))

    Верните, возможно, пустой список имен путей, которые соответствуют имени пути, которое должно быть строкой, содержащей спецификацию пути. pathname может быть либо абсолютным (например, /usr/src/Python-1.5/Makefile), либо относительным (например, ../../Tools/*/*.gif) и может содержать подстановочные знаки оболочки. Сломанные символические ссылки включены в результаты (как в оболочке).
    ...
    Изменено в версии 3.5: Поддержка рекурсивных глобусов с использованием " ** ".


    >>> import glob, os
    >>> wildcard_pattern = "*"
    >>> root_dir = os.path.join("root_dir", wildcard_pattern)  # Match every file/dir name
    >>> root_dir
    'root_dir\\*'
    >>>
    >>> glob_list = glob.glob(root_dir)
    >>> glob_list
    ['root_dir\\dir0', 'root_dir\\dir1', 'root_dir\\dir2', 'root_dir\\dir3', 'root_dir\\file0', 'root_dir\\file1']
    >>>
    >>> [item.replace("root_dir" + os.path.sep, "") for item in glob_list]  # Strip the dir name and the path separator from begining
    ['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']
    >>>
    >>> for entry in glob.iglob(root_dir + "*", recursive=True):
    ...     print(entry)
    ...
    root_dir\
    root_dir\dir0
    root_dir\dir0\dir00
    root_dir\dir0\dir00\dir000
    root_dir\dir0\dir00\dir000\file0000
    root_dir\dir0\dir00\file000
    root_dir\dir0\dir01
    root_dir\dir0\dir01\file010
    root_dir\dir0\dir01\file011
    root_dir\dir0\dir02
    root_dir\dir0\dir02\dir020
    root_dir\dir0\dir02\dir020\dir0200
    root_dir\dir1
    root_dir\dir1\file10
    root_dir\dir1\file11
    root_dir\dir1\file12
    root_dir\dir2
    root_dir\dir2\dir20
    root_dir\dir2\dir20\file200
    root_dir\dir2\file20
    root_dir\dir3
    root_dir\file0
    root_dir\file1
    

    Примечания:

    • Использует os.listdir
    • Для больших деревьев (особенно если recursive iglob), iglob является предпочтительным
    • Позволяет использовать расширенную фильтрацию на основе имени (из-за шаблона)


  1. [Python]: class pathlib. Путь (* pathsegments) (!!! Python 3 + !!! не знаю, если бэкпорт)

    >>> import pathlib
    >>> root_dir = "root_dir"
    >>> root_dir_instance = pathlib.Path(root_dir)
    >>> root_dir_instance
    WindowsPath('root_dir')
    >>> root_dir_instance.name
    'root_dir'
    >>> root_dir_instance.is_dir()
    True
    >>>
    >>> [item.name for item in root_dir_instance.glob("*")]  # Wildcard searching for all direct descendants
    ['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']
    >>>
    >>> [os.path.join(item.parent.name, item.name) for item in root_dir_instance.glob("*") if not item.is_dir()]  # Display paths (including parent) for files only
    ['root_dir\\file0', 'root_dir\\file1']
    

    Примечания:

    • Это один из способов достижения нашей цели
    • Это стиль ООП путей обработки
    • Предлагает множество функций


  1. [Python]: dircache.listdir (путь) (!!! удалено в Python 3 !!!)

    • Но, согласно $ {PYTHON_SRC_DIR}/Lib/dircache.py: ~ # 20+ (из версии 2.2.14), это просто (тонкая) обертка поверх os.listdir


    def listdir(path):
        """List directory contents, using cache."""
        try:
            cached_mtime, list = cache[path]
            del cache[path]
        except KeyError:
            cached_mtime, list = -1, []
        mtime = os.stat(path).st_mtime
        if mtime != cached_mtime:
            list = os.listdir(path)
            list.sort()
        cache[path] = mtime, list
        return list
    


  1. [man]: OPENDIR (3)/[man]: READDIR (3)/[man]: CLOSEDIR (3) через [Python]: ctypes - библиотека внешних функций для Python (!!! Ux specific !!!)

    ctypes - это библиотека внешних функций для Python. Он обеспечивает совместимые типы данных C и позволяет вызывать функции в библиотеках DLL или совместно используемых библиотеках. Его можно использовать для переноса этих библиотек в чистый Python.

    code_ctypes.py:

    #!/usr/bin/env python3
    
    import sys
    from ctypes import Structure, \
        c_ulonglong, c_longlong, c_ushort, c_ubyte, c_char, c_int, \
        CDLL, POINTER, \
        create_string_buffer, get_errno, set_errno, cast, sizeof
    
    
    DT_DIR = 4
    DT_REG = 8
    
    char256 = c_char * 256
    
    class LinuxDirent64(Structure):
        _fields_ = [
            ("d_ino", c_ulonglong),
            ("d_off", c_longlong),
            ("d_reclen", c_ushort),
            ("d_type", c_ubyte),
            ("d_name", char256),
        ]
    
    LinuxDirent64Ptr = POINTER(LinuxDirent64)
    
    libc_dll = CDLL(None)
    opendir = libc_dll.opendir
    readdir = libc_dll.readdir
    closedir = libc_dll.closedir
    libc_dll.__errno_location.restype = POINTER(c_int)
    errno_loc_func = libc_dll.__errno_location
    
    
    def _get_errno():
        return "errno: {:d}({:d})".format(get_errno(), errno_loc_func().contents.value)
    
    
    def get_dir_content(path):
        ret = [path, list(), list()]
        dir_stream = opendir(create_string_buffer(path.encode()))
        if (dir_stream == 0):
            print("opendir returned NULL ({:s})".format(_get_errno()))
            return ret
        set_errno(0)
        dirent_addr = readdir(dir_stream)
        while dirent_addr:
            dirent_ptr = cast(dirent_addr, LinuxDirent64Ptr)
            dirent = dirent_ptr.contents
            name = dirent.d_name.decode()
            if dirent.d_type & DT_DIR:
                if name not in (".", ".."):
                    ret[1].append(name)
            elif dirent.d_type & DT_REG:
                ret[2].append(name)
            dirent_addr = readdir(dir_stream)
        if get_errno() or errno_loc_func().contents.value:
            print("readdir returned NULL ({:s})".format(_get_errno()))
        closedir(dir_stream)
        return ret
    
    
    def main():
        print("{:s} on {:s}\n".format(sys.version, sys.platform))
        root_dir = "root_dir"
        entries = get_dir_content(root_dir)
        print(entries)
    
    
    if __name__ == "__main__":
        main()
    

    Примечания:

    • Он загружает три функции из libc (загружается в текущий процесс) и вызывает их (для более подробной информации проверьте [Переполнение стека]: как проверить, существует ли файл с использованием Python? (Ответ @CristiFati) - последние заметки из пункта № 4.). Это поставило бы этот подход очень близко к краю Python/C
    • LinuxDirent64 - это представление ctypes struct dirent64 из dirent.h (так же как и DT_* константы) с моей машины: Ubtu 16 x64 (4.10.0-40-generic и libc6-dev: amd64). В других вариантах/вариантах определение структуры может отличаться, и если да, то псевдоним ctypes должен быть обновлен, иначе он приведет к неопределенному поведению
    • errno_loc_func (и все, что с ним связано), потому что funcs set errno в случае ошибки, и мне нужно проверить его значение. Видимо, get_errno не работает (с недопустимым именем, opendir возвращает NULL, но get_errno все равно возвращает 0), или я еще не get_errno его
    • Он возвращает данные в формате os.walk. Я не потрудился сделать его рекурсивным, но, начиная с существующего кода, это была бы довольно тривиальная задача
    • Все можно сделать и на Win, данные (библиотеки, функции, структуры, константы,...) отличаются


    Выход:

    cfati@testserver:~/work/stackoverflow/q003207219$ ./code_ctypes.py
    3.5.2 (default, Nov 23 2017, 16:37:01)
    [GCC 5.4.0 20160609] on linux
    
    ['root_dir', ['dir3', 'dir2', 'dir0', 'dir1'], ['file0', 'file1']]
    


  1. [ActiveState]: win32file.FindFilesW (!!! Win specific !!!)

    Получает список совпадающих имен файлов, используя API Юникода Windows. Интерфейс API FindFirstFileW/FindNextFileW/Find close.


    >>> import os, win32file, win32con
    >>> root_dir = "root_dir"
    >>> wildcard = "*"
    >>> root_dir_wildcard = os.path.join(root_dir, wildcard)
    >>> entry_list = win32file.FindFilesW(root_dir_wildcard)
    >>> len(entry_list)  # Don't display the whole content as it too long
    8
    >>> [entry[-2] for entry in entry_list]  # Only display the entry names
    ['.', '..', 'dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']
    >>>
    >>> [entry[-2] for entry in entry_list if entry[0] & win32con.FILE_ATTRIBUTE_DIRECTORY and entry[-2] not in (".", "..")]  # Filter entries and only display dir names (except self and parent)
    ['dir0', 'dir1', 'dir2', 'dir3']
    >>>
    >>> [os.path.join(root_dir, entry[-2]) for entry in entry_list if entry[0] & (win32con.FILE_ATTRIBUTE_NORMAL | win32con.FILE_ATTRIBUTE_ARCHIVE)]  # Only display file "full" names
    ['root_dir\\file0', 'root_dir\\file1']
    

    Примечания:


  1. Установите некоторый (другой) сторонний пакет, который делает трюк
    • Скорее всего, будет полагаться на один (или более) из вышеперечисленного (возможно, с небольшими настройками)


Примечания (о материалах выше):

  • Код предназначен для переносимости (кроме мест, предназначенных для определенной области, которые отмечены) или крест:
    • платформа (Ux, Win,)
    • Версия Python (2, 3,)
  • В приведенных выше вариантах использовались несколько стилей пути (абсолютные, родственники), чтобы проиллюстрировать тот факт, что используемые "инструменты" являются гибкими в этом направлении
  • os.listdir и os.scandir используют opendir/readdir/closedir ([MSDN]: функция FindFirstFile/[MSDN]: функция FindNextFile/[MSDN]: функция FindClose) (через "$ {PYTHON_SRC_DIR}/Modules/posixmodule.c")
  • win32file.FindFilesW использует эти (определенные для Win) функции (через "$ {PYWIN32_SRC_DIR}/win32/src/win32file.i")
  • get_dir_content (из пункта № 1.) может быть реализован с использованием любого из этих подходов (некоторые из них потребуют больше работы и некоторые меньше)
    • filter_func быть выполнена некоторая расширенная фильтрация (а не только файл против dir): например, аргумент include_folders может быть заменен другим (например, filter_func), который будет функцией, которая принимает путь в качестве аргумента: filter_func=lambda x: True ( это не исключает ничего) и внутри get_dir_content что-то вроде: if not filter_func(entry_with_path): continue (если функция не удалась для одной записи, она будет пропущена), но чем сложнее код, тем дольше это займет выполнить
  • Нота бене! Поскольку рекурсия используется, я должен упомянуть, что я сделал несколько тестов на своем ноутбуке (Win 10 x64), полностью не связанный с этой проблемой, и когда уровень рекурсии достиг значений где-то в диапазоне (990.. 1000) (recursionlimit - 1000 (по умолчанию)), я получил StackOverflow :). Если дерево каталогов превышает это ограничение (я не эксперт по FS, поэтому я не знаю, возможно ли это), это может быть проблемой.
    Я также должен упомянуть, что я не пытался увеличить рекурсию, потому что у меня нет опыта в этой области (сколько я могу увеличить ее, прежде чем придется увеличивать стек на уровне ОС), но теоретически всегда будет возможность если глубина ребра больше максимально возможного рекурсивного предела (на этой машине)
  • Образцы кода предназначены только для демонстрации. Это означает, что я не принимал во внимание обработку ошибок (я не думаю, что там есть блок try/except/else/finally), поэтому код не является надежным (причина в том, чтобы сохранить его как можно более простым и коротким). Для производства также необходимо добавить обработку ошибок

Конец первой части 1


1. В связи с тем, что предел /qaru.site/... post (question/answer) составляет 30000 символов ([SE.Meta]: Знание ваших лимитов: какова максимальная длина заголовка вопроса, сообщения, изображения и ссылок?), Ответ был разделен на 2 части.Также посетите [SO]: Как я могу перечислить все файлы каталога?(Ответ @CristiFati - "Часть вторая").

24
ответ дан CristiFati 23 янв. '18 в 6:09
источник поделиться
import os
lst=os.listdir(path)

os.listdir возвращает список, содержащий имена записей в каталоге, заданном путем.

22
ответ дан Rajat Garg 07 июля '15 в 13:12
источник поделиться

Если вы ищете реализацию find на Python, это рецепт, который я использую довольно часто:

from findtools.find_files import (find_files, Match)

# Recursively find all *.sh files in **/usr/bin**
sh_files_pattern = Match(filetype='f', name='*.sh')
found_files = find_files(path='/usr/bin', match=sh_files_pattern)

for found_file in found_files:
    print found_file

Итак, я сделал из него PyPI пакет, а также есть Репозиторий GitHub. Я надеюсь, что кто-то найдет это потенциально полезным для этого кода.

21
ответ дан Yauhen Yakimovich 10 апр. '14 в 17:09
источник поделиться

Python 3.5 представил новый, более быстрый метод для os.scandir() по каталогу - os.scandir().

Пример:

for file in os.scandir('/usr/bin'):
    line = ''
    if file.is_file():
        line += 'f'
    elif file.is_dir():
        line += 'd'
    elif file.is_symlink():
        line += 'l'
    line += '\t'
    print("{}{}".format(line, file.name))
16
ответ дан enedil 17 янв. '16 в 21:17
источник поделиться

Возврат списка абсолютных путей к файлу, не рекурсивно вложенные подкаталоги

L = [os.path.join(os.getcwd(),f) for f in os.listdir('.') if os.path.isfile(os.path.join(os.getcwd(),f))]
14
ответ дан The2ndSon 13 июня '14 в 19:26
источник поделиться

Список всех файлов в каталоге:

import os
from os import path

files = [x for x in os.listdir(directory_path) if path.isfile(directory_path+os.sep+x)]

Здесь вы получаете список всех файлов в каталоге.

13
ответ дан shiminsh 29 авг. '15 в 20:44
источник поделиться
import os
import os.path


def get_files(target_dir):
    item_list = os.listdir(target_dir)

    file_list = list()
    for item in item_list:
        item_dir = os.path.join(target_dir,item)
        if os.path.isdir(item_dir):
            file_list += get_files(item_dir)
        else:
            file_list.append(item_dir)
    return file_list

Здесь я использую рекурсивную структуру.

10
ответ дан pah8J 19 июня '18 в 15:03
источник поделиться
# -** coding: utf-8 -*-
import os
import traceback

print '\n\n'

def start():
    address = "/home/ubuntu/Desktop"
    try:
        Folders = []
        Id = 1
        for item in os.listdir(address):
            endaddress = address + "/" + item
            Folders.append({'Id': Id, 'TopId': 0, 'Name': item, 'Address': endaddress })
            Id += 1         

            state = 0
            for item2 in os.listdir(endaddress):
                state = 1
            if state == 1: 
                Id = FolderToList(endaddress, Id, Id - 1, Folders)
        return Folders
    except:
        print "___________________________ ERROR ___________________________\n" + traceback.format_exc()

def FolderToList(address, Id, TopId, Folders):
    for item in os.listdir(address):
        endaddress = address + "/" + item
        Folders.append({'Id': Id, 'TopId': TopId, 'Name': item, 'Address': endaddress })
        Id += 1

        state = 0
        for item in os.listdir(endaddress):
            state = 1
        if state == 1: 
            Id = FolderToList(endaddress, Id, Id - 1, Folders)
    return Id

print start()
8
ответ дан barisim.net 07 марта '14 в 13:28
источник поделиться

Использование генераторов

import os
def get_files(search_path):
     for (dirpath, _, filenames) in os.walk(search_path):
         for filename in filenames:
             yield os.path.join(dirpath, filename)
list_files = get_files('.')
for filename in list_files:
    print(filename)
6
ответ дан shantanoo 02 дек. '16 в 10:01
источник поделиться

Если вы заботитесь о производительности, попробуйте scandir. Для Python 2.x вам может потребоваться установить его вручную. Примеры:

# python 2.x
import scandir
import sys

de = scandir.scandir(sys.argv[1])
while 1:
    try:
        d = de.next()
        print d.path
    except StopIteration as _:
        break

Это экономит много времени, когда вам нужно сканировать огромный каталог, и вам не нужно буферизировать огромный список, просто выберите один за другим. А также вы можете сделать это рекурсивно:

def scan_path(path):
    de = scandir.scandir(path)
    while 1:
        try:
            e = de.next()
            if e.is_dir():
                scan_path(e.path)
            else:
                print e.path
        except StopIteration as _:
                break
6
ответ дан coanor 12 марта '16 в 12:31
источник поделиться

Используйте эту функцию, если вы хотите использовать другой тип файла или получить полный каталог:

import os

def createList(foldername, fulldir = True, suffix=".jpg"):
    file_list_tmp = os.listdir(foldername)
    #print len(file_list_tmp)
    file_list = []
    if fulldir:
        for item in file_list_tmp:
            if item.endswith(suffix):
                file_list.append(os.path.join(foldername, item))
    else:
        for item in file_list_tmp:
            if item.endswith(suffix):
                file_list.append(item)
    return file_list
6
ответ дан neouyghur 11 нояб. '16 в 15:48
источник поделиться
import dircache
list = dircache.listdir(pathname)
i = 0
check = len(list[0])
temp = []
count = len(list)
while count != 0:
  if len(list[i]) != check:
     temp.append(list[i-1])
     check = len(list[i])
  else:
    i = i + 1
    count = count - 1

print temp
6
ответ дан shaji 25 июля '12 в 13:25
источник поделиться
import os 
os.listdir(path)

Это вернет список всех файлов и каталогов в path.

filenames = next(os.walk(path))[2]

Это вернет только список файлов, а не подкаталогов.

5
ответ дан Ashiq Imran 18 окт. '17 в 9:46
источник поделиться

Выполните findfiles() с каталогом в качестве параметра, и он вернет список всех файлов в нем.

import os
def findfiles(directory):
    objects = os.listdir(directory)  # find all objects in a dir

    files = []
    for i in objects:  # check if very object in the folder ...
        if os.path.isfile(os.path.join(directory, i)):  # ... is a file.
            files.append(i)  # if yes, append it.
    return files
4
ответ дан phyyyl 24 февр. '18 в 20:28
источник поделиться

Используя os библиотеку.

import os
for root, dirs,files in os.walk("your dir path", topdown=True):
    for name in files:
        print(os.path.join(root, name))
4
ответ дан Sankar 15 окт. '16 в 19:29
источник поделиться

Другой очень читаемый вариант для Python 3. 4+ использует pathlib.Path.glob:

from pathlib import Path
folder = '/foo'
[f for f in Path(folder).glob('*') if f.is_file()]

Просто сделать более конкретным, например, искать только исходные файлы Python, которые не являются символическими ссылками, также во всех подкаталогах:

[f for f in Path(folder).glob('**/*.py') if not f.is_symlink()]
2
ответ дан fhchl 28 марта '18 в 15:20
источник поделиться

Часть вторая 1

Решения (продолжение)

Другие подходы:

  1. Использовать Python только как оболочку

    • Все делается с использованием другой технологии
    • Эта технология вызывается из Python
    • Самый известный аромат, который я знаю, - это то, что я называю системным администратором:

      • Используйте Python (или любой язык программирования, если на то пошло), чтобы выполнять команды оболочки (и анализировать их выходы), в общем, этого подхода следует избегать, поскольку, если некоторый формат вывода команды немного отличается между версиями/версиями ОС, код разбора должен быть адаптированы также, не говоря уже о не EN-локалях)
      • Некоторые считают это аккуратным взломом
      • Я считаю его более похожим на хромое обходное решение (gainarie), поскольку действие само по себе выполняется из оболочки (в этом случае cmd) и, следовательно, не имеет ничего общего с Python.
      • Фильтрация (grep/findstr) или форматирование вывода могут выполняться с обеих сторон, но я не буду настаивать на этом. Кроме того, я специально использовал os.system вместо subprocess.Popen.
      (py35x64_test) E:\Work\Dev\StackOverflow\q003207219>"e:\Work\Dev\VEnvs\py35x64_test\Scripts\python.exe" -c "import os;os.system(\"dir /b root_dir\")"
      dir0
      dir1
      dir2
      dir3
      file0
      file1
      

Конец второй части 1


1. В связи с тем, что предел /qaru.site/... post (question/answer) составляет 30000 символов ([SE.Meta]: Знание ваших лимитов: какова максимальная длина заголовка вопроса, сообщения, изображения и ссылок?), Ответ был разделен на 2 части.Обязательно прочтите [SO]: Как я могу перечислить все файлы каталога?(Ответ @CristiFati - "Часть первая").

2
ответ дан CristiFati 18 февр. '18 в 16:38
источник поделиться

Ссылаясь на ответ @adamk, вот мой метод обнаружения os в ответ на комментарий несогласованности косой чертой от @Anti Earth

import sys
import os
from pathlib import Path
from glob import glob
platformtype = sys.platform
if platformtype == 'win32':
    slash = "\\"
if platformtype == 'darwin':
    slash = "/"

# TODO: How can I list all files of a directory in Python and add them to a list?

# Step 1 - List all files of a directory

# Method 1: Find only pre-defined filetypes (.txt) and no subfiles, answer provided by @adamk
dir1 = "%sfoo%sbar%s*.txt" % (slash)
_files = glob(dir1)

# Method 2: Find all files and no subfiles
dir2 = "%sfoo%sbar%s" % (slash)
_files = (x for x in Path("dir2").iterdir() if x.is_file())

# Method 3: Find all files and all subfiles
dir3 = "%sfoo%sbar" % (slash)
_files = (x for x in Path('dir3').glob('**/*') if x.is_file())


# Step 2 - Add them to a list

files_list = []
for eachfiles in _files:
    files_basename = os.path.basename(eachfiles)
    files_list.append(files_basename)

print(files_list)
['file1.txt', 'file2.txt', .... ]

Я предполагаю, что вы хотите только basenames в списке.

Обратитесь к этому сообщению для предварительного определения нескольких форматов файлов для метода 1.

2
ответ дан Joseph K. 22 окт. '17 в 4:52
источник поделиться

Действительно простая версия:

import os
[f for f in os.listdir(os.getcwd) if ...]
2
ответ дан Jared Shulman 08 мая '18 в 19:27
источник поделиться

Я приведу образец одного лайнера, в котором исходный путь и тип файла могут быть предоставлены в качестве входных данных. Код возвращает список имен файлов с расширением csv. Используйте. в случае, если все файлы должны быть возвращены. Это также рекурсивно сканирует подкаталоги.

[y for x in os.walk(sourcePath) for y in glob(os.path.join(x[0], '*.csv'))]

При необходимости измените расширения файлов и путь к источнику.

2
ответ дан Vinodh Krishnaraju 11 дек. '17 в 20:51
источник поделиться
  • 1
  • 2

Другие вопросы по меткам