python - ver - ¿Cómo enumero todos los archivos de un directorio?




ver archivos de un directorio python (20)

Obtén una lista de archivos con Python 2 y 3

También he hecho un video corto aquí: Python: cómo obtener una lista de archivos en un directorio

os.listdir ()

o ..... cómo obtener todos los archivos (y directorios) en el directorio actual (Python 3)

La forma más sencilla de tener el archivo en el directorio actual en Python 3 es esta. Es realmente simple; use el módulo os y la función listdir () y tendrá el archivo en ese directorio (y las eventuales carpetas que están en el directorio, pero no tendrá el archivo en el subdirectorio, para eso puede usar walk - lo haré hablar de ello más tarde).

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

Usando glob

Me pareció más fácil seleccionar el archivo del mismo tipo o con algo en común. Mira el siguiente ejemplo:

import glob

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

Usando la lista de comprensión

import glob

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

Obtener el nombre completo de la ruta con os.path.abspath

Como notó, no tiene la ruta completa del archivo en el código anterior. Si necesita tener la ruta absoluta, puede usar otra función del módulo os.path llamada _getfullpathname , poniendo el archivo que obtiene de os.listdir() como un argumento. Hay otras formas de tener la ruta completa, como veremos más adelante (reemplazé, como lo sugirió mexmex, _getfullpathname con abspath ).

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

Obtenga el nombre completo de la ruta de un tipo de archivo en todos los subdirectorios con walk

Encuentro esto muy útil para encontrar cosas en muchos directorios, y me ayudó a encontrar un archivo del cual no recuerdo el nombre:

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 (): obtiene archivos en el directorio actual (Python 2)

En Python 2, si desea la lista de los archivos en el directorio actual, debe presentar el argumento como ''. o os.getcwd () en el método os.listdir.

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

Subir en el árbol de directorios.

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

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

Obtenga archivos: os.listdir () en un directorio particular (Python 2 y 3)

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

Obtener archivos de un subdirectorio particular con os.listdir ()

import os

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

os.walk ('.') - directorio actual

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

módulo glob - todos los archivos

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

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

next (os.walk ('.')) y 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: \'): obtenga la ruta completa - comprenda la lista

>>> [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 - obtener ruta completa - todos los archivos en subdirectorios

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 () - obtiene solo archivos txt

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

glob - obtener solo archivos txt

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

Usando glob para obtener la ruta completa de los archivos.

Si necesito la ruta absoluta de los archivos:

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

Otro uso de glob

Si quiero todos los archivos en el directorio:

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

Usando os.path.isfile para evitar directorios en la lista

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

Usando pathlib desde (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

Si quieres utilizar la lista de comprensión.

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

* También puedes usar solo pathlib.Path () en lugar de pathlib.Path (".")

Utilice el método glob en pathlib.Path ()

import pathlib

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

salida:

stack_overflow_list.py
stack_overflow_list_tkinter.py

Obtén todos y solo archivos con 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']

Obtenga solo archivos con next y camine en un directorio

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

Obtenga solo directorios con next y camine en un directorio

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

Consigue todos los nombres de subdirección con walk.

>>> 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 () de Python 3.5 en

>>> 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: ¿Cuántos archivos hay en los subdirectorios?

En este ejemplo, buscamos la cantidad de archivos que se incluyen en todos los directorios y sus subdirectorios.

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'

Ej.2: ¿Cómo copiar todos los archivos de un directorio a otro?

Un script para poner orden en su computadora, encontrando todos los archivos de un tipo (predeterminado: pptx) y copiándolos en una nueva carpeta.

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: Cómo obtener todos los archivos en un archivo txt

En caso de que desee crear un archivo txt con todos los nombres de archivo:

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

Ejemplo: txt con todos los archivos de un disco duro.

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

Todo el archivo de C: \\ en un archivo de texto

Esta es una versión más corta del código anterior. Cambie la carpeta donde comenzar a buscar los archivos si necesita comenzar desde otra posición. Este código genera un archivo de texto de 50 mb en mi computadora con algo menos de 500.000 líneas con archivos con la ruta completa.

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

Una función para buscar un determinado tipo de archivo.

importación OS

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

# looking for ttf file (fonts)
searchfiles('ttf')

https://code.i-harness.com

¿Cómo puedo listar todos los archivos de un directorio en Python y agregarlos a una list ?


Parte uno 1

Notas preliminares

  • Aunque hay una clara diferenciación entre los términos de archivo y directorio en el texto de la pregunta, algunos pueden argumentar que los directorios son en realidad archivos especiales
  • La declaración: " todos los archivos de un directorio " se puede interpretar de dos maneras:
    1. Todos los descendientes directos (o de nivel 1) solamente
    2. Todos los descendientes en todo el árbol de directorios (incluidos los de subdirectorios)
  • Cuando se hizo la pregunta, me imagino que Python 2 era la versión LTS , sin embargo, Python 3 ( .5 ) ejecutará los ejemplos de código (los mantendré tan compatibles con Python 2 como sea posible; también, cualquier código que pertenezca a Python que voy a publicar, es de v3.5.4 (a menos que se especifique lo contrario). Eso tiene consecuencias relacionadas con otra palabra clave en la pregunta: " agréguelos a una lista ":

    • En las versiones pre Python 2.2 , las secuencias (iterables) estaban representadas principalmente por listas (tuplas, conjuntos, ...)
    • En Python 2.2 , se introdujo el concepto de generador ( [Python]: Generadores ) - cortesía de [Python]: la declaración de rendimiento ). A medida que pasaba el tiempo, las contrapartes del generador comenzaron a aparecer para las funciones que devolvían / ​​trabajaban con listas
    • En Python 3 , el generador es el comportamiento por defecto.
    • Ahora, no sé si devolver una lista sigue siendo obligatorio (o un generador también lo haría), pero pasar un generador al constructor de la list , creará una lista a partir de ella (y también la consumirá). El siguiente ejemplo ilustra las diferencias en [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'>)
    
  • Los ejemplos se basarán en un directorio llamado root_dir con la siguiente estructura (este ejemplo es para Win , pero también he duplicado el árbol de carpetas para Ux ( Lnx )):

    E:\Work\Dev\\q003207219>tree /f "root_dir"
    Folder PATH listing for volume Work
    Volume serial number is 00000029 3655:6FED
    E:\WORK\DEV\\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
    


Soluciones

Enfoques programáticos:

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

    Devuelva una lista que contenga los nombres de las entradas en el directorio dado por ruta. La lista está en orden arbitrario y no incluye las entradas especiales '.' y '..' ...


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

    Aquí hay un ejemplo más detallado ( 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()
    

    Notas :

    • Hay dos implementaciones:
      • Uno que usa generadores (por supuesto, en este ejemplo parece inútil, ya que convierto el resultado a una lista inmediatamente)
      • El clásico (nombres de funciones que terminan en _old )
    • Se usa la recursión (para entrar en los subdirectorios)
    • Para cada implementación hay dos funciones:
      • Uno que comienza con un guión bajo ( _ ): "privado" (no debe llamarse directamente) - que hace todo el trabajo
      • El público (envoltorio sobre el anterior): simplemente elimina la ruta inicial (si es necesario) de las entradas devueltas. Es una implementación fea, pero es la única idea con la que podría venir en este momento.
    • En términos de rendimiento, los generadores son generalmente un poco más rápidos (considerando los tiempos de creación e iteración ), pero no los probé en funciones recursivas, y también estoy iterando dentro de la función sobre los generadores internos, no sé cómo funciona el rendimiento amigable es que
    • Juega con los argumentos para obtener diferentes resultados.


    Salida :

    (py35x64_test) E:\Work\Dev\\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 ( ruta = '.' ) ( !!! Python 3.5 + !!! aunque creo que para versiones anteriores era un módulo separado (también portado a Python 2 ))

    Devuelve un iterador de objetos os.DirEntry correspondientes a las entradas en el directorio dado por ruta . Las entradas se entregan en orden arbitrario, y las entradas especiales '.' y '..' no están incluidos.

    El uso de scandir () en lugar de listdir () puede aumentar significativamente el rendimiento del código que también necesita información sobre el tipo de archivo o los atributos del archivo, ya que los objetos os.DirEntry exponen esta información si el sistema operativo la proporciona al escanear un directorio. Todos los métodos os.DirEntry pueden realizar una llamada al sistema, pero is_dir() y is_file() generalmente solo requieren una llamada al sistema para enlaces simbólicos; os.DirEntry.stat() siempre requiere una llamada al sistema en Unix, pero solo requiere una para los enlaces simbólicos en 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
    

    Notas :

    • Es similar a os.listdir
    • Pero también es más flexible (y ofrece más funcionalidad), más Python ic (y en algunos casos, más rápido)


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

    Genere los nombres de los archivos en un árbol de directorios recorriendo el árbol de arriba a abajo o de abajo a arriba. Para cada directorio en el árbol arraigado en la parte superior del directorio (incluyendo top en sí mismo), se obtiene un 3-tuple ( dirpath , dirnames , filenames )


    >>> import os
    >>> root_dir = os.path.join(os.getcwd(), "root_dir")  # Specify the full path
    >>> root_dir
    'E:\\Work\\Dev\\\\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\\\\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\\\\q003207219\\root_dir\\dir0', 'E:\\Work\\Dev\\\\q003207219\\root_dir\\dir1', 'E:\\Work\\Dev\\\\q003207219\\root_dir\\dir2', 'E:\\Work\\Dev\\\\q003207219\\root_dir\\dir3', 'E:\\Work\\Dev\\\\q003207219\\root_dir\\file0', 'E:\\Work\\Dev\\\\q003207219\\root_dir\\file1']
    >>>
    >>> for entry in walk_generator:  # Display the rest of the elements (corresponding to every subdir)
    ...     print(entry)
    ...
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir0', ['dir00', 'dir01', 'dir02'], [])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir0\\dir00', ['dir000'], ['file000'])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir0\\dir00\\dir000', [], ['file0000'])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir0\\dir01', [], ['file010', 'file011'])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir0\\dir02', ['dir020'], [])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir0\\dir02\\dir020', ['dir0200'], [])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir0\\dir02\\dir020\\dir0200', [], [])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir1', [], ['file10', 'file11', 'file12'])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir2', ['dir20'], ['file20'])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir2\\dir20', [], ['file200'])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir3', [], [])
    

    Notas :

    • Bajo las escenas, utiliza os.listdir( os.scandirdonde esté disponible)
    • Realiza el trabajo pesado recurriendo en subcarpetas.


  1. [Python]: glob. glob ( nombre de ruta, *, recursiva = False ) ( [Python]:. glob iglob ( nombre de ruta, *, recursiva = False ) )

    Devuelva una lista posiblemente vacía de nombres de ruta que coincidan con el nombre de ruta , que debe ser una cadena que contenga una especificación de ruta. la ruta de acceso puede ser absoluta (similar /usr/src/Python-1.5/Makefile) o relativa (similar ../../Tools/*/*.gif), y puede contener comodines de estilo shell. Los enlaces simbólicos rotos se incluyen en los resultados (como en el shell).
    ...
    Cambiado en la versión 3.5 : Soporte para globos recursivos usando "**".


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

    Notas :

    • Usos os.listdir
    • Para árboles grandes (especialmente si recursiveestá encendido), iglobse prefiere
    • Permite un filtrado avanzado basado en el nombre (debido al comodín)


  1. [Python]: clase pathlib. Ruta ( * pathsegments ) ( !!! Python 3 + ! No sé si está backported)

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

    Notas :

    • Esta es una forma de lograr nuestro objetivo.
    • Es el estilo OOP de los caminos de manejo.
    • Ofrece muchas funcionalidades.


  1. [Python]: dircache.listdir (ruta) ( !!! eliminado en Python 3 !!! )

    • Pero, de acuerdo con $ {PYTHON_SRC_DIR} /Lib/dircache.py : ~ # 20 + (a partir de v2.7.14 ), es solo una envoltura (delgada) sobreos.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. [hombre]: opendir (3) / [hombre]: READDIR (3) / [hombre]: closedir (3) a través de [Python]: ctypes - una biblioteca de funciones extranjera para Python ( !!! Ux específica !!! )

    ctypes es una biblioteca de funciones foránea para Python. Proporciona tipos de datos compatibles con C y permite funciones de llamada en DLL o bibliotecas compartidas. Se puede utilizar para envolver estas bibliotecas en Python puro.

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

    Notas :

    • Carga las tres funciones de libc (cargadas en el proceso actual) y las llama (para más detalles verifique [Desbordamiento de pila]: ¿Cómo verifico si existe un archivo usando Python? (La respuesta de @ CristiFati) - las últimas notas del elemento # 4 . ). Eso colocaría este enfoque muy cerca del borde de Python / C
    • LinuxDirent64es la ctypes representación de struct dirent64de dirent.h (también lo son las DT_*constantes) de mi máquina: Ubtu 16 x 64 ( 4.10.0-40-genérico y libc6-dev: amd64 ). En otros sabores / versiones, la definición de la estructura puede diferir, y si es así, el alias de ctypes debería actualizarse, de lo contrario producirá un comportamiento indefinido
    • errno_loc_func(y todo lo relacionado con él) se debe a que la función está configurada errnoen caso de error, y necesito verificar su valor. Aparentemente, get_errnono funciona (con un nombre no válido, opendirdevuelve NULL, pero get_errnosigue devolviendo 0), o no lo descubrí todavía
    • Devuelve datos en el os.walkformato de. No me molesté en hacerlo recursivo, pero a partir del código existente, sería una tarea bastante trivial
    • Todo se puede hacer también en Win , los datos (bibliotecas, funciones, estructuras, constantes, ...) difieren


    Salida :

    [email protected]:~/work//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 ( !!! ¡¡¡ Gana específicamente !!! )

    Recupera una lista de nombres de archivos coincidentes, utilizando la API de Windows Unicode. Una interfaz para la API FindFirstFileW / FindNextFileW / Find close funciones.


    >>> 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's 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']
    

    Notas :


  1. Instale algún (otro) paquete de terceros que haga el truco
    • Lo más probable es que dependa de uno (o más) de los anteriores (tal vez con personalizaciones leves)


Notas (sobre las cosas de arriba):

  • El código debe ser portátil (excepto los lugares que se dirigen a un área específica, que están marcados) o cruzado:
    • plataforma ( Ux , Win ,)
    • Versión de Python (2, 3,)
  • Se utilizaron múltiples estilos de ruta (absolutos, parientes) en las variantes anteriores, para ilustrar el hecho de que las "herramientas" utilizadas son flexibles en esta dirección
  • os.listdiry os.scandiruse opendir/ readdir/ closedir( [MSDN]: función FindFirstFile / [MSDN]: función FindNextFile / [MSDN]: función FindClose ) (a través de " $ {PYTHON_SRC_DIR} /Modules/posixmodule.c ")
  • win32file.FindFilesWtambién utiliza esas funciones ( específicas de Win ) (a través de " $ {PYWIN32_SRC_DIR} /win32/src/win32file.i ")
  • get_dir_content(desde el punto # 1 ) se puede implementar utilizando cualquiera de estos enfoques (algunos requerirán más trabajo y otros menos)
    • Algunos filtrado avanzado (en lugar de sólo presentar vs dir) podría hacerse: por ejemplo, el include_foldersargumento podría ser reemplazado por otro (por ejemplo filter_func), que sería una función que toma un camino como un argumento: filter_func=lambda x: True(esto no elimina cualquier cosa) y dentro de get_dir_contentalgo como: if not filter_func(entry_with_path): continue(si la función falla para una entrada, se omitirá), pero cuanto más complejo sea el código, más tiempo tomará ejecutarse.
  • Nota bene! Dado que se usa la recursión, debo mencionar que hice algunas pruebas en mi computadora portátil ( Win 10 x64 ), totalmente sin relación con este problema, y ​​cuando el nivel de recursión estaba alcanzando valores en algún lugar dentro del rango ( 990 .. 1000) ( recursionlimit - 1000 (predeterminado)), tengo :). Si el árbol de directorios supera ese límite (no soy un experto en FS , por lo que no sé si eso es posible), eso podría ser un problema.
    También debo mencionar que no intenté aumentar el límite de recursión porque no tengo experiencia en el área (¿cuánto puedo aumentar antes de tener que aumentar también la pila en el sistema operativo?)nivel), pero en teoría siempre habrá la posibilidad de fallar, si la profundidad del dir es mayor que el máximo máximo de recursión posible (en esa máquina)
  • Los ejemplos de código son sólo para fines demostrativos. Eso significa que no tomé en cuenta el manejo de errores (no creo que haya ningún try/ except/ else/ finallybloque), por lo que el código no es robusto (la razón es: mantenerlo tan simple y corto como sea posible). Para la producción , también se debe agregar el manejo de errores.

Fin de la primera parte 1


1. Debido al hecho de que Home posterior (/ respuesta de interrogación) límite 's es 30000 caracteres ( [] SE.Meta: Conocer sus propios límites:? ¿Cuál es la longitud máxima de un título de la pregunta, después, la imagen y los enlaces utilizados ), La respuesta fue dividida en 2 partes. Visite también [SO]: ¿Cómo enumero todos los archivos de un directorio? (Respuesta de @ CristiFati - "Parte Dos") .


Debe usar el módulo os para listar el contenido del directorio. os.listdir(".") devuelve todos los contenidos del directorio. Repasamos el resultado y lo agregamos a la lista.

import os

content_list = []

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

print content_list

Desde la versión 3.4 hay iteradores integrados para esto que son mucho más eficientes que os.listdir() :

pathlib : Nuevo en la versión 3.4.

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

De acuerdo con PEP 428 , el objetivo de la biblioteca pathlib es proporcionar una jerarquía simple de clases para manejar las rutas del sistema de archivos y las operaciones comunes que los usuarios realizan sobre ellas.

os.scandir() : Nuevo en la versión 3.5.

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

Tenga en cuenta que os.walk() usa os.scandir() lugar de os.listdir() de la versión 3.5, y su velocidad aumentó de 2 a 20 veces de acuerdo con PEP 471 .

Permíteme también recomendar leer el comentario de ShadowRanger a continuación.


Realmente me gustó la respuesta de adamk , sugiriendo que uses glob() , del módulo del mismo nombre. Esto le permite tener patrones de coincidencia con * s.

Pero, como otras personas señalaron en los comentarios, glob() puede ser superado por direcciones de slash inconsistentes. Para ayudar con eso, le sugiero que use las funciones join() y expanduser() en el módulo os.path , y quizás la función getcwd() en el módulo os .

Como ejemplos:

from glob import glob

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

Lo anterior es terrible: la ruta ha sido codificada y solo funcionará en Windows entre el nombre de la unidad y la que está codificada en la ruta.

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

Lo anterior funciona mejor, pero se basa en el nombre de carpeta Users que se encuentra a menudo en Windows y no tan a menudo en otros sistemas operativos. También se basa en que el usuario tenga un nombre específico, 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'))

Esto funciona perfectamente en todas las plataformas.

Otro gran ejemplo que funciona perfectamente en todas las plataformas y hace algo un poco diferente:

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

Espero que estos ejemplos te ayuden a ver el poder de algunas de las funciones que puedes encontrar en los módulos estándar de la biblioteca de Python.


Una solución de una línea para obtener solo una lista de archivos (sin subdirectorios):

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

o rutas de acceso absolutas:

paths = [os.path.join(path,fn) for fn in next(os.walk(path))[2]]

Devolviendo una lista de rutas de archivo absolutas, no retrocede en subdirectorios

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

Obtención de rutas de archivo completas desde un directorio y todos sus subdirectorios

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")
  • La ruta que proporcioné en la función anterior contenía 3 archivos: dos de ellos en el directorio raíz y otro en una subcarpeta llamada "SUBFOLDER". Ahora puedes hacer cosas como:
  • print full_file_paths que imprimirá la lista:

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

Si lo desea, puede abrir y leer el contenido, o concentrarse solo en archivos con la extensión ".dat" como en el código a continuación:

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

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


Listar todos los archivos en un directorio:

import os
from os import path

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

Aquí, obtienes una lista de todos los archivos en un directorio.


Otra variante muy legible para Python 3.4+ es usar pathlib.Path.glob:

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

Es simple de hacer más específico, por ejemplo, solo busque archivos de origen de Python que no sean enlaces simbólicos, también en todos los subdirectorios:

[f for f in Path(folder).glob('**/*.py') if not f.is_symlink()]

Utilizando generadores

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)

Versión realmente simple:

import os
[f for f in os.listdir(os.getcwd) if ...]

Proporcionaré una muestra de un trazador de líneas donde se pueden proporcionar la fuente y el tipo de archivo como entrada. El código devuelve una lista de nombres de archivo con extensión csv. Utilizar . En caso de que todos los archivos deban ser devueltos. Esto también explorará recursivamente los subdirectorios.

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

Modifique las extensiones de archivo y la ruta de origen según sea necesario.


Python 3.5 introdujo un nuevo método, más rápido para caminar a través del directorio - os.scandir().

Ejemplo:

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

Si está buscando una implementación de Python para encontrar , esta es una receta que uso con bastante frecuencia:

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

Así que hice un package PyPI y también hay un repositorio GitHub . Espero que alguien lo encuentre potencialmente útil para este código.


Si te importa el rendimiento, inténtalo scandir. Para Python 2.x, puede que necesite instalarlo manualmente. Ejemplos:

# 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

Esto ahorra mucho tiempo cuando necesita escanear un directorio enorme, y no necesita almacenar una lista enorme, solo busque uno por uno. Y también puedes hacerlo recursivamente:

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

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 

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

import os
lst=os.listdir(path)

os.listdir devuelve una lista que contiene los nombres de las entradas en el directorio dado por ruta.


import os
os.listdir("somedirectory")

devolverá una lista de todos los archivos y directorios en "algún directorio".





directory