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

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

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

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

['/home/adam/file1.txt', '/home/adam/file2.txt', .... ]

import os
os.listdir("somedirectory")

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

получаем список файлов с Python 2 и 3

<ч/>

ОС.listdir()

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

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

 import os
 arr = os.listdir()
 print(arr)

 >>> ['$RECYCLE.BIN', 'work.txt', '3ebooks.txt', 'documents']

Глоб

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

import glob

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

Глоб с список осмысления

import glob

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

Глоб с функцией

import glob

def filebrowser():
    return [f for f in glob.glob("*")]

x = filebrowser()
print(x)

>>> ['example.txt', 'fb.py', 'filebrowser.py', 'help']

Глоб продлении предыдущий код

Функция Now возвращает список файлов, которые совпали с строку вы передаете в качестве аргумента

import glob

def filebrowser(word=""):
    """Returns a list with all files with the word/extension in it"""
    file = []
    for f in glob.glob("*"):
        if word in f:
            file.append(f)
            return file

flist = filebrowser("example")
print(flist)
flist = filebrowser(".py")
print(flist)

>>> ['example.txt']
>>> ['fb.py', 'filebrowser.py']

получить полный путь с ОС.путь.abspath`

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

 import os
 files_path = [os.path.abspath(x) for x in os.listdir()]
 print(files_path)

 >>> ['F:\\documenti\applications.txt', 'F:\\documenti\collections.txt']

получить полный путь типа файл во все подпапки с прогулка

Я нахожу это очень полезным, чтобы найти материал во многих каталогах, и это помогло мне найти файл, о котором я не'т помню название:

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))

и GT;### ОС.listdir(): получение файлов в текущем каталоге (в Python 2)

В Python 2, Если вы хотите, чтобы список файлов в текущем каталоге, вы должны дать аргумент как '.' или операционной системы.функция getcwd() в ОС.listdir способ.

 import os
 arr = os.listdir('.')
 print(arr)

 >>> ['$RECYCLE.BIN', 'work.txt', '3ebooks.txt', 'documents']

для перехода в каталог

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

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

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

 import os
 arr = os.listdir('F:\\python')
 print(arr)

 >>> ['$RECYCLE.BIN', 'work.txt', '3ebooks.txt', 'documents']

получаем файлы определенного подкаталога с ОС.listdir()`

import os

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

и GT;### ОС.прогулка('.') - текущий каталог

 import os
 arr = next(os.walk('.'))[2]
 print(arr)

 >>> ['5bs_Turismo1.pdf', '5bs_Turismo1.pptx', 'esperienza.txt']

следующий(ОС.прогулка('.')) и ОС.путь.присоединиться('реж', 'файл')

 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)

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

следующий(ОС.прогулка('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']

и GT;### ОС.прогулка - получить полный путь - все файлы в подразделе Дирс**

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

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

и GT;### ОС.listdir() - вам только txt файлы

 arr_txt = [x for x in os.listdir() if x.endswith(".txt")]
 print(arr_txt)

 >>> ['work.txt', '3ebooks.txt']

используя Глоб, чтобы получить полный путь к файлам

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

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

с помощью ОС.путь.isfile, чтобы избежать каталогов в списке

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

>>> ['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.Путь() вместо pathlib.Путь (фильм".&и")

использовать метод Глоб в pathlib.Путь()

import pathlib

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

>>> stack_overflow_list.py
>>> stack_overflow_list_tkinter.py

получить все и только файлов с ОС.прогулка

import os
x = [i[2] for i in os.walk('.')]
y=[]
for t in x:
    for f in t:
        y.append(f)
print(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]
 print(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

ОС.scandir() из Python 3.5 и больше

import os
x = [f.name for f in os.scandir() if f.is_file()]
print(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

примеры:

Исх. 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"))

>>> '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('-' * 30)
        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')

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

Исх. 3: Как получить все файлы в 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 methods 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")

все файлы из C:\ в один текстовый файл

Это короткая версия предыдущего кода. Изменить папку, где, чтобы начать поиск файлов, Если вам нужно, чтобы начать с другой позиции. Этот код генерирует 50 Мб на текстовый файл на моем компьютере с чем-то менее 500.000 строк с файлов с полным путем.

import os

with open("file.txt", "w", encoding="utf-8") as filewrite:
    for r, d, f in os.walk("C:\\"):
        for file in f:
            filewrite.write(f"{r + file}\n")

Как написать файл со всеми путями в папке типа

С помощью этой функции можно создать файл txt, который будет иметь название типа файла, который вы ищите (исх. pngfile.txt) со всеми полный путь всех файлов этого типа. Это может быть полезно иногда, я думаю.

import os

def searchfiles(extension='.ttf', folder='H:\\'):
    "Create a txt file with all the file of a type"
    with open(extension[1:] + "file.txt", "w", encoding="utf-8") as filewrite:
        for r, d, f in os.walk(folder):
            for file in f:
                if file.endswith(extension):
                    filewrite.write(f"{r + file}\n")

# looking for png file (fonts) in the hard disk H:\
searchfiles('.png', 'H:\\')

>>> H:\4bs_18\Dolphins5.png
>>> H:\4bs_18\Dolphins6.png
>>> H:\4bs_18\Dolphins7.png
>>> H:\5_18\marketing html\assets\imageslogo2.png
>>> H:\7z001.png
>>> H:\7z002.png

(новый) найти все файлы и открыть их с tkinter GUI-интерфейс

Я просто хотел добавить в эту 2019 небольшое приложение, чтобы найти все файлы в каталог и иметь возможность открывать их по двойному клику на имени файла в списке.

import tkinter as tk
import os

def searchfiles(extension='.txt', folder='H:\\'):
    "insert all files in the listbox"
    for r, d, f in os.walk(folder):
        for file in f:
            if file.endswith(extension):
                lb.insert(0, r + "\\" + file)

def open_file():
    os.startfile(lb.get(lb.curselection()[0]))

root = tk.Tk()
root.geometry("400x400")
bt = tk.Button(root, text="Search", command=lambda:searchfiles('.png', 'H:\\'))
bt.pack()
lb = tk.Listbox(root)
lb.pack(fill="both", expand=1)
lb.bind("", lambda x: open_file())
root.mainloop()

Однострочное решение сделать только список файлов (без поддиректорий): питон имена файлов = следующий(ОС.прогулка(путь))[2] или абсолютного пути: питон пути = [ОС.путь.присоединиться(путь, Fn) для ФН в следующем(ОС.прогулка(путь))[2]]

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

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 файла— два из них в корневом каталоге, и еще в папку под названием "в папке&.и" Теперь вы можете делать вещи, как:

• печать full_file_paths`, которая будет печатать список:

• ['/пользователи/Джонни/рабочий стол/тест/файл1.тхт', '/пользователи/Джонни/рабочий стол/тест/файл2.тхт', '/пользователи/Джонни/рабочий стол/тест/папку/файл file3.дат']

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

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

`/Пользователи/Джонни/рабочий стол/тест/папку/файл file3.дать

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

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

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

По данным ОПТОСОЗ 428, цель [pathlib] библиотекаpathlib - обеспечить простую иерархию классов для обработки путей файловой системы и общие операции пользователей над ними.

ОС.scandir(): новое в версии 3.5.

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

Обратите внимание, что ОС .прогулка() использует ОС .scandir() вместо ОС.listdir() начиная с версии 3.5, и его скорость увеличилась на 2-20 раз по данным [Пеп 471].

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

Предварительные заметки

в

• Хотя там'ы четкую дифференциацию между файл и справочник термины в тексте вопроса, некоторые могут возразить, что каталоги на самом деле это специальные файлы
• Заявление: " повсе файлы каталога" могут быть истолкованы двумя способами:

1. Все прямой (или уровень 1) потомки только
2. Все потомки во всем дереве каталогов (в том числе и в подкаталогах)

• Когда вопрос был задан, я представляю, что Python 2, был ЛЦ версии, однако примеры кода будет выполняться в Python 3(.5) (я'буду держать их в качестве в Python 2 совместимые, насколько это возможно; кроме того, любой код, принадлежащий питон, что я'м собираюсь отправить, от В3.5.4 - если не указано иное). Это имеет последствия, связанные с другого сайта на вопрос: " Вдобавить в списоки":
• В дошкольных в Python 2.2 версии, последовательности (итераторы) были в основном представлены списки (кортежи, множества, ...)
• В языке Python 2.2 концепция генератор ([питон.Вики: генераторы) - вежливость [питон 3]: выход заявление) - был введен. Прошло время, аналоги генератор начали появляться функции, которые вернулись/работал со списками
• В в Python 3, генератор по умолчанию
• Не уверен, что возвращение в список обязательных (или генератор будет делать также), но проходя генератор список конструктор, создать список из нее (а также потреблять его). Пример ниже иллюстрирует различия в [Питон 3]: Карта(функция, метод, ...)

  импорт Сыс Сыс.версия '2.7.10 (по умолчанию, марта 8 2016, 15:02:46) [КБМ В. 1600 64 бит (для amd64)]' M = карта(лямбда-х: х, [1, 2, 3]) # просто муляж лямбда-функция M, тип(М) ([1, 2, 3], &л;тип 'список'>) Длина(м) 3 <БР> импорт Сыс Сыс.версия '3.5.4 (В3.5.4:3f56838, 8 2017 августа, 02:17:05) [КБМ В. 1900 64 бит (для amd64)]' M = карта(лямбда-х: х, [1, 2, 3]) M, тип(М) (<объект на карте 0x000001B4257342B0>, но <класс 'карта'>) Длина(м) Обратная трассировка (самый недавний призыв последнего): Файл "<устройства stdin>”, в строке 1, в <модуль> Ошибку TypeError: объект типа 'карта' не имеет функции LEN() lm0 = список(м) # построить список от генератора lm0, тип(lm0) ([1, 2, 3], &л;класс 'список'>)

  за моделями LM1 = список(м) # построить список из того же генератора за моделями LM1, тип(за моделями LM1) # пустой список теперь - генератора уже потребили ([], <класс 'список'>)

• Примеры будут на основе каталог корень_dir со следующей структурой (в данном примере - победа, но я'м, используя то же самое дерево на сайт lnx, а):

  E:\Work\Dev\StackOverflow\q003207219>дерево /ф "в root_dir и" Путь к папке списка объем работы Объем серийный номер 00000029 3655:6FED Е:\работа\Дев\сайте StackOverflow\Q003207219\ROOT_DIR ¦ file0 ¦ файл1 ¦ +---dir0 ¦ +---dir00 ¦ ¦ ¦ file000 ¦ ¦ ¦ ¦ ¦ +---dir000 ¦ ¦ file0000 ¦ ¦ ¦ +---dir01 ¦ ¦ file010 ¦ ¦ file011 ¦ ¦ ¦ +---dir02 ¦ +---dir020 ¦ +---dir0200 +---dir1 и ¦ file10 ¦ file11 ¦ file12 ¦ +---директория dir2 ¦ ¦ file20 ¦ ¦ ¦ +---dir20 ¦ file200 ¦ +---dir3 <БР>

  Решений

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

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

   импорт ОС root_dir = "и root_dir на" Путь # относительно текущей директории (ОС.функция getcwd())

   ОС.listdir(root_dir) # Список всех элементов в root_dir ['dir0', 'dir1 и', 'каталога dir2', 'dir3', 'file0', 'файл1']

   [пункт за пунктом в ОС.listdir(root_dir) ОС.путь.isfile(ОС.путь.присоединиться(root_dir, элемент))] # элементы фильтра и оставить только файлы (вырезать каталоги) ['file0', 'файл file1'] Более сложный пример (code_os_listdir.py): импорт ОС из импорт печатные pformat деф _get_dir_content(путь, include_folders, рекурсивные): записи = ОС.listdir(путь) для запись в записи: entry_with_path = ОС.путь.присоединиться(путь, выход) если ОС.путь.isdir(entry_with_path): если include_folders: доходность entry_with_path если рекурсивно: для sub_entry в _get_dir_content(entry_with_path, include_folders, рекурсивные): доходность sub_entry другое: доходность entry_with_path деф get_dir_content(путь, include_folders=true, то рекурсивно=правда, prepend_folder_name=правда): path_len = лен(путь) + лен(ОС.путь.сентября) по пункту в _get_dir_content(путь, include_folders, рекурсивные): выход элемента если prepend_folder_name еще пункт[path_len:] деф _get_dir_content_old(путь, include_folders, рекурсивные): записи = ОС.listdir(путь) рэт = список() для запись в записи: entry_with_path = ОС.путь.присоединиться(путь, выход) если ОС.путь.isdir(entry_with_path): если include_folders: рет.присоеденить(entry_with_path) если рекурсивно: рет.продлить(_get_dir_content_old(entry_with_path, include_folders, рекурсивные)) другое: рет.присоеденить(entry_with_path) вернуться в отставке деф get_dir_content_old(путь, include_folders=true, то рекурсивно=правда, prepend_folder_name=правда): path_len = лен(путь) + лен(ОС.путь.сентября) возвращение [пункт если prepend_folder_name еще пункт[path_len:] для пункта в _get_dir_content_old(путь, include_folders, рекурсивные)] деф главным образом(): root_dir = "и root_dir и" ret0 = get_dir_content(root_dir, include_folders=true, то рекурсивно=правда, prepend_folder_name=истина) lret0 = список(ret0) печати(ret0, лен(lret0), pformat(lret0)) ret1 = get_dir_content_old(root_dir, include_folders=false, то рекурсивный=правда, prepend_folder_name=ложь) печати(лен(ret1), pformat(ret1)) если имя = = и"основнойи": главная() Примечания:

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

  E:\Work\Dev\StackOverflow\q003207219&gt (py35x64_test);"и e:\Work\Dev\VEnvs\py35x64_test\Scripts\python.exe" и"code_os_listdir.пы" и <объект генератор get_dir_content на 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\файл1'] 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', 'файл1'] <БР>

2. возвращает итератор ОС.DirEntry объекты, соответствующие записи в справочнике даны по пути. Элементы даны в произвольном порядке, и специальные элементы'.' и'..' не входят. используя scandir() вместо listdir() может значительно увеличить производительность кода, который также должен тип файла или файл атрибутивной информации, потому что ОС.DirEntry объекты предоставлять эту информацию, если операционная система обеспечивает при сканировании каталогов. Все ОС.DirEntry методы могут выполнить системный вызов, но is_dir() и is_file()](https://docs.python.org/3/library/os.html#os.DirEntry.is_file) обычно только требуют системного вызова для символических ссылок; ОС.DirEntry.стат() всегда требует системных вызовов в Unix, но требует только для символических ссылок в Windows. <БР>

   импорт ОС root_dir = ОС.путь.присоединиться (на".&и" "Ну root_dir и") # явного добавления текущего каталога root_dir '.\root_dir'

   scandir_iterator = ОС.scandir(root_dir) scandir_iterator <НТ.Объект ScandirIterator в 0x00000268CF4BC140> [пункт.путь к пункту в scandir_iterator] ['.\root_dir\dir0', '.\root_dir\dir1 и', '.\root_dir\директория dir2', '.\root_dir\dir3', '.\root_dir\file0', '.\root_dir\файл1']

   [пункт.путь к пункту в scandir_iterator] # будет давать пустой список, так как он был поглощен предыдущей итерации (автоматически выполняется понимания список) []

   scandir_iterator = ОС.scandir(root_dir) # инициализация генератора для элемента в scandir_iterator : ... если ОС.путь.isfile(пункт.путь): ... печати(пункт.имя) ... file0 файл1 Примечания:

• Она'ы, похожие на ОС.listdir
• Но это's также более гибкий (и более функциональные), более питонСК (а в некоторых случаях и быстрее) <БР>

3. [Питон 3]: ОС.прогулка(верхний, нисходящий=true, то метод onerror=нет, followlinks=ложь)

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

   импорт ОС root_dir = ОС.путь.присоединяйтесь к(ОС.функция getcwd (), то "root_dir-то") # указать полный путь root_dir 'E:\Work\Dev\StackOverflow\q003207219\root_dir'

   walk_generator = ОС.прогулка(root_dir) root_dir_entry = следующий(walk_generator) # первая запись соответствует корневой каталог (в качестве аргумента) root_dir_entry ('E:\Work\Dev\StackOverflow\q003207219\root_dir', ['dir0', 'dir1 и', 'каталога dir2', 'dir3'], ['file0', 'файл file1'])

   root_dir_entry[1] + root_dir_entry[2] # отображения папок и файлов (прямые потомки) в один список ['dir0', 'dir1 и', 'каталога dir2', 'dir3', 'file0', 'файл1']

   [ОС.путь.присоединиться(root_dir_entry[0], элемент) для элемента в root_dir_entry[1] + root_dir_entry[2]] # отображения всех записей в списке по их полному пути ['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']

   для входа в walk_generator: # показать остальные элементы (в соответствии с каждым каталогом) ... печать(запись) ... ('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', [], []) Примечания:

• Под сцены, он использует ОС.scandir (`ОС.listdir на старых версиях)
• Это тяжелая атлетика, повторяющихся в подпапках <БР>

4. [Питон 3]: Глоб.Глоб(путь, *, рекурсивные=ложь) ([питон 3]: Глоб.iglob(путь, *, рекурсивные=ложь))

   возвращение возможно пустой список имен, которые соответствуют путь, который должен быть строкой, содержащей путь. пути может быть абсолютным (вроде /usr/src/и питон-1.5/make-файл) или относительный (как ../../инструменты/*/*.гиф), и может содержать раковину в стиле маски. Символические ссылки включаются в результаты (как в оболочке).<БР>...<БР>изменено в версии 3.5: поддержка для рекурсивного шарики, используя “**”. <БР>

   Глоб импорт, ОС wildcard_pattern = то "" и root_dir = ОС.путь.присоединиться (на"root_dir-то", wildcard_pattern) матч # каждый файл/реж имя root_dir 'root_dir\'

   glob_list = Глоб.Глоб(root_dir) glob_list ['root_dir\dir0', 'root_dir\dir1 и', 'root_dir\директория dir2', 'root_dir\dir3', 'root_dir\file0', 'root_dir\файл1']

   [пункт.заменить (на"root_dir на" + ОС.путь.меня сентября; и") по пункту в glob_list] # Стрип именем Dir и сепаратор путь от начала ['dir0', 'dir1 и', 'каталога dir2', 'dir3', 'file0', 'файл1']

   для вступления в Глоб.iglob(root_dir + на "*" Ну, рекурсивные=правда): ... печать(запись) ... 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\файл1 Примечания:

• ОС использует.listdir
• Для больших деревьев (особенно, если рекурсивное на), iglob* предпочтителен
• Возможность расширенной фильтрации по имени (из-за подстановки) <БР>

5. импорт pathlib root_dir = "и root_dir" и root_dir_instance = pathlib.Путь(root_dir) root_dir_instance WindowsPath('root_dir') root_dir_instance.название 'root_dir' root_dir_instance.is_dir() Правда

   [пункт.имя элемента в root_dir_instance.Глоб (на"*", у)] # поиск всех прямых потомков ['dir0', 'dir1 и', 'каталога dir2', 'dir3', 'file0', 'файл1']

   [ОС.путь.присоединиться(пункт.родителей.имя элемента.имя) по пункту в root_dir_instance.Глоб (на"*" В) если не элемент.is_dir()] # отображения контуров (в том числе родительской) только для файлов ['root_dir\file0', 'root_dir\файл1'] Примечания:

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

• Но, по словам [гитхаб]: питон/с CPython - (2.7) cpython/Lib/dircache.py, он's просто (тонкие) оболочки над ОС.listdir с кэшированием <БР> деф listdir(путь): " и" и на"список содержимого каталога, используя кэш." и" и" в попробуйте: cached_mtime, список = кэш[путь] дель кэш[путь] кроме KeyError: cached_mtime, список = -1, [] время изменения = ОС.стат(путь).тип доступа если время изменения != cached_mtime: список = ОС.listdir(путь) список.сортировать() кэш[путь] = время изменения, список список вернуться <БР>

7. [man7]: каталог файлов(3) / [man7]: вызове readdir(3) / [man7]: CLOSEDIR(3) через [питон 3]: под - иностранный функция библиотеки для Python (в POSIX специфические)

   под является иностранным функцию библиотеки для Python. Он обеспечивает с совместимыми типами данных, и позволяет вызывать функции в DLL или разделяемых библиотек. Он может быть использован, чтобы обернуть эти библиотеки в чистом Python. code_ctypes.py:

   !/usr/Бен/ОКР питон3

   импорт Сыс из под структуру импорта, \ c_ulonglong, c_longlong, c_ushort, c_ubyte, c_char, c_int, \ CDLL, УКАЗКА, \ create_string_buffer, get_errno, set_errno, литой DT_DIR = 4 DT_REG = 8 char256 = c_char * 256 LinuxDirent64 класса(структуры): fields = [ (на"d_ino" и, c_ulonglong), (на"d_off" и, c_longlong), (я d_reclen&quot и;, c_ushort), (на"d_type" и, c_ubyte), (на"d_name" и, char256), ] LinuxDirent64Ptr = указатель(LinuxDirent64) libc_dll = this_process = CDLL(нет, use_errno=истина)

   Всегда набор argtypes и ресурс для функции, в противном случае он'ы УБ!!!

   каталог файлов = libc_dll.каталог файлов вызове readdir = libc_dll.вызове readdir closedir = libc_dll.closedir деф get_dir_content(путь): рэт = [путь, список(), список()] dir_stream = каталог файлов(create_string_buffer(путь.кодирование())) если (dir_stream == 0): печать (на"каталог файлов возвращает значение null (ошибка: {:D} С) и".формат(get_errno())) вернуться в отставке set_errno(0) dirent_addr = вызове readdir(dir_stream) в то время как dirent_addr: dirent_ptr = литой(dirent_addr, LinuxDirent64Ptr) дирент = dirent_ptr.содержание имя = дирент.d_name.декодировать() если дирент.d_type & DT_DIR: если имя не в (на".&и", то ".." - а): рэт[1].добавить(имя) Элиф дирент.d_type & DT_REG: рэт[2].добавить(имя) dirent_addr = вызове readdir(dir_stream) если get_errno(): печать("в вызове readdir возвращает значение null (ошибка: {:D} С) и".формат(get_errno())) closedir(dir_stream) вернуться в отставке деф главным образом(): печать(" у{:S} на {:х}\п то".формат(представление sys.версия, сис.платформы)) root_dir = "и root_dir и" записи = get_dir_content(root_dir) печати(записи) если имя = = и"основнойи": главная() Примечания:

• Он загружает три функции из библиотеки libc* (загружается в текущий процесс) и называет их (на детали [так]: как я могу проверить, существует ли файл, без исключения? (@CristiFati'ы answer) - последние заметки из пункта #4.). Что бы разместить этот подход очень близок к питон / с края
• LinuxDirent64 это под представление структура dirent64 от [man7]: дирент.ч(0П) (так ДТ_ константы) из моей машины: Ubtu 16 х64 (4.10.0-40- универсальные и пакетом libc6-dev так:для amd64). На другие ароматы/версий, определения структуры, могут отличаться, и если это так, то под псевдоним должен быть обновлен, в противном случае это приведет неопределенному поведению
• Он возвращает данные в ОС.прогулка`'формата s. Я не'т беспокоить, чтобы сделать его рекурсивным, но исходя из существующего кода, что бы быть довольно тривиальной задачей
• Все это выполнимо на победу а также, данные (библиотеки, функции, структуры, константы, ...) отличаются <БР> Вывод:

  [cfati@cfati-ubtu16x64-0:~/работать с/dev/сайте StackOverflow/q003207219] и GT; ./code_ctypes.py 3.5.2 (по умолчанию, 12 ноября 2018, 13:43:14) [5.4.0 20160609 ССЗ] на Linux ['root_dir', ['директория dir2', 'dir1 и', 'dir3', 'dir0'], ['файл1', 'file0']] <БР>

8. возвращает список соответствующих имен файлов, с помощью API-интерфейса Windows Юникода. Интерфейс к API FindFirstFileW/FindNextFileW/найти близких функций. <БР>

   импорт ОС, win32file, win32con root_dir = "и root_dir" и подстановочные = то "*" и root_dir_wildcard = ОС.путь.присоединиться(root_dir, подстановочные) entry_list = win32file.FindFilesW(root_dir_wildcard) лен(entry_list) # Дон'т показать все содержимое, как это's слишком долго 8 [запись[-2] для входа в entry_list] # отображать только записи имен ['.', '..', 'dir0', 'dir1 и', 'каталога dir2', 'dir3', 'file0', 'файл1']

   [запись[-2] для входа в entry_list если запись[0] &ампер; win32con.FILE_ATTRIBUTE_DIRECTORY и запись[-2] не в (на".&и", то "..", у)] # элементы фильтр и отобразить только имена реж (кроме себя и родителей) ['dir0', 'dir1 и', 'каталога dir2', 'dir3']

   [ОС.путь.присоединиться(root_dir, запись[-2]) для въезда в entry_list если на вход[0] &ампер; (win32con.FILE_ATTRIBUTE_NORMAL | win32con.FILE_ATTRIBUTE_ARCHIVE)] # показывать только файл "Полный" и имена ['root_dir\file0', 'root_dir\файл1'] Примечания:

• win32file.FindFilesW - часть [гитхаб]: mhammond/pywin32 - питон для Windows (pywin32) расширения, которая является питон обертку по WinAPIс
• Ссылку на документацию от Активностити, как я'т найти любой PyWin32 официальная документация <БР>

9. Установите некоторые (другие) пакетов сторонних производителей, что делает трюк

• Скорее всего, будет опираться на одну (или более) из выше (может быть с небольшими настройками) <БР> Примечания:
• Код предназначен, чтобы быть портативным (за исключением мест, которые предназначены для определенной зоны - которые отмечены) или крест:
• платформы (дляNix, победа, )
• Питон версия (2, 3, )
• Пути несколько стилей (абсолютная, родственники) были использованы для всех вариантов, чтобы проиллюстрировать тот факт, что "инструментов" используются гибкие в этом направлении
• ОС.listdir " и " ОС.scandir использовать каталог файлов / вызове readdir / closedir ([ср. документы]: FindFirstFileW функция / [ср. документы]: FindNextFileW функция / [ср. документы]: FindClose функция) (через [гитхаб]: питон/с CPython - (мастер) с CPython/модули/posixmodule.с)
• win32file.FindFilesW использует эти (выиграть специфические) функции, а также (Через [на GitHub]: mhammond/pywin32 - (мастер) pywin32/win32/src/win32file.i)
• \Запросе_dir_content (от точки #1.) может быть реализована с использованием любой из этих подходов (некоторые из них требуют больше работы, а кто-то меньше)
• Расширенной фильтрации (а не просто файл и реж) можно сделать: например, включать_folders аргумент может быть заменен на другой (например, фильтр_func) в котором будет функция, которая принимает путь в качестве аргумента: filter_func=лямбда х: правда (это не'т прокладки из ничего) и внутри *\запросе\_dir\_content* что-то вроде:если не filter_func(entry_with_path): продолжение` (если функция не для одной записи, он будет пропущен), но чем сложнее код, тем больше времени потребуется для выполнения
• Нота Бене! Поскольку рекурсия используется, я должен упомянуть, что я сделал несколько тестов на моем ноутбуке (с Win 10 х64), никак не связанные с этой проблемой, и когда рекурсия уровень достижения значений где-то в (990 .. 1000) диапазон (recursionlimit - 1000 (по умолчанию)), я и StackOverflow :). Если дерево каталогов превышает этот предел (я не фу эксперт, поэтому я не'т знаю, если это вообще возможно), это может быть проблемой. <БР> Я должен также упомянуть, что я этого'т попытаться увеличить recursionlimit ведь у меня нет опыта в области (на сколько я могу увеличить его до того, чтобы также увеличить стек в ОС уровень), но в теории всегда будет возможность отказа, если dir глубина превышает максимально возможный recursionlimit (на этой машине)
• Примеры кода предназначены только для демонстративных целей. Это значит, что я этого'т принять во внимание обработку ошибок (я не'т думаю, что там's любой попробовать / за исключением / еще / наконец-то блока), так что код не надежный (причина: чтобы сохранить его простым и коротким, насколько это возможно). Для производства, обработка ошибок должна быть также добавлены

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

1. Использовать питон только как обертка

• Все это делается с помощью другой технологии
• Что технология вызывается из Питон
• Самый известный аромат, который я знаю, это то, что я называю системный администратор подход:
• Использовать Питон (или любой язык программирования, если на то пошло) в целях исполнения консоли команды (и анализировать их результаты)
• Некоторые считают, что это аккуратный Хак
• Я считаю, что это больше похоже на временное решение хромает (gainarie), а само действие выполняется от раковина (УМК в этом случае), и, следовательно, не'т иметь ничего общего с питон.
• Фильтрация (команда grep / она) или форматирование вывода может быть сделано с обеих сторон, но я'м не собираюсь настаивать на этом. Кроме того, я намеренно использовал ОС.система вместо подпроцесса.К popen.

  (py35x64_test) E:\Work\Dev\StackOverflow\q003207219> наша"e:\Work\Dev\VEnvs\py35x64_test\Scripts\python.exe" -с помощью "импорт ОС;ОС.системы(\"и я\root_dir реж /Б&;)" и dir0 из dir1 директория dir2 dir3 file0 файл1 В целом такой подход следует избегать, поскольку если какая-то команда формат немного отличается от ОС версий/сборок, синтаксического анализа кода должны быть хорошо приспособлены, не говоря уже о различиях между разными языками).

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

Но как другие люди указали в комментариях, Глоб() может споткнуться за несовместимых направлений Слэш. Чтобы помочь с этим, я предлагаю вам использовать присоединяйтесь() и expanduser() функции в ОС.модуль Pathи возможнофункция getcwd()функция в модулеОС`, а также.

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

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'))

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

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-модулей.

Если вы ищете реализацией 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. Я надеюсь, что кто-то считает его потенциально полезным для этого кода.

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

L = [os.path.join(os.getcwd(),f) for f in os.listdir('.') if os.path.isfile(os.path.join(os.getcwd(),f))]

Для больших результатов, вы можете использовать listdir (метод) модуля ОС вместе с генератором (генератор мощный iterator, который сохраняет свое состояние, помните?). Следующий код прекрасно работает с обеими версиями: Python 2 и Python 3.

Здесь'ы код:

import os

def files(path):  
    for file in os.listdir(path):
        if os.path.isfile(os.path.join(path, file)):
            yield file

for file in files("."):  
    print (file)

Метод listdir() возвращает список записей для данного каталога. ОС метод.путь.isfile() возвращает true, если данная запись представляет собой файл. И выход оператор завершает функцию, но сохраняет свое текущее состояние, и она возвращает только имя записи определен как файл. Все вышесказанное позволяет нам петлю на себя функцию генератора.

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

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

Мудрый учитель сказал мне однажды, что:

когда есть несколько устоявшихся способов сделать что-то, ни один из них не хорош для всех случаев.

Таким образом, я добавлю решение в подмножество проблема: довольно часто, мы всего лишь хотим проверить, является ли файл соответствует строке начало и конец строки, не вдаваясь в подкаталогах. Таким образом, мы хотели бы функцию, которая возвращает список имен файлов, таких как:

filenames = dir_filter('foo/baz', radical='radical', extension='.txt')

Если вы заботитесь, чтобы сначала объявить две функции, это может быть сделано:

def file_filter(filename, radical='', extension=''):
    "Check if a filename matches a radical and extension"
    if not filename:
        return False
    filename = filename.strip()
    return(filename.startswith(radical) and filename.endswith(extension))

def dir_filter(dirname='', radical='', extension=''):
    "Filter filenames in directory according to radical and extension"
    if not dirname:
        dirname = '.'
    return [filename for filename in os.listdir(dirname)
                if file_filter(filename, radical, extension)]

Это решение может быть легко обобщено с помощью регулярных выражений (и вы, возможно, захотите, чтобы добавить узор аргумент, если вы не хотите, чтобы ваши шаблоны, чтобы всегда держаться в начало или конец имени файла).

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

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)

Еще один очень читаемый вариант для Python 3.4+ использует pathlib.Путь.Глоб:

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()]

Здесь'Мой генерал-целевая функция для этого. Он возвращает список путей к файлам, а не имена, так как я обнаружил, что, чтобы быть более полезным. Он имеет несколько необязательных аргументов, которые делают его универсальным. Например, я часто использую его аргументы как шаблон='*.тхт' или подпапки=правда.

import os
import fnmatch

def list_paths(folder='.', pattern='*', case_sensitive=False, subfolders=False):
    """Return a list of the file paths matching the pattern in the specified 
    folder, optionally including files inside subfolders.
    """
    match = fnmatch.fnmatchcase if case_sensitive else fnmatch.fnmatch
    walked = os.walk(folder) if subfolders else [next(os.walk(folder))]
    return [os.path.join(root, f)
            for root, dirnames, filenames in walked
            for f in filenames if match(f, pattern)]

dircache есть "устаревшим с версии 2.6: модуль dircache был удален в Python 3.0.&ьquot;

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

Для python2: установите типун rglob

import rglob
file_list=rglob.rglob("/home/base/dir/", "*")
print file_list