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

recorrer directorios con python

Question

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

Answer 1

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

Answer 2

Parte uno ¹

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

2. [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)

3. [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.

4. [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)

5. [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.

6. [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

7. [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 :

   cfati@testserver:~/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'']]

8. [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 :

   • win32file.FindFilesWes parte de [GitHub]: Python para Windows (pywin32) Extensions , que es un contenedor de Python sobre WINAPI s
   • El enlace de la documentación es de https://www.activestate.com , ya que no encontré ninguna documentación oficial de pywin32

9. 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. 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") .}

Answer 3

Parte dos ¹

Soluciones (continuación)

Otros enfoques:

1. Usa Python solo como una envoltura

   • Todo se hace utilizando otra tecnología.
   • Esa tecnología es invocada desde Python.

   • El sabor más famoso que conozco es lo que llamo el enfoque de administrador de sistemas :

     • Utilice Python (o cualquier lenguaje de programación) para ejecutar comandos de shell (y analizar sus salidas). En general, se debe evitar este enfoque, ya que si algún formato de salida de comandos difiere ligeramente entre las versiones / versiones de SO , el código de análisis ser adaptado también; por no hablar de lugares no EN )
     • Algunos consideran que esto es un buen truco
     • Lo considero más como una solución alternativa ( ganancia ), ya que la acción en sí misma se realiza desde shell ( cmd en este caso), y por lo tanto no tiene nada que ver con Python .
     • El filtrado ( grep/ findstr) o el formato de salida se puede hacer en ambos lados, pero no voy a insistir en ello. Además, he utilizado deliberadamente en os.systemlugar de subprocess.Popen.

     (py35x64_test) E:/Work/Dev//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

Fin de la segunda parte ¹

_{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. Asegúrese de leer [SO]: ¿Cómo enumero todos los archivos de un directorio? (Respuesta de @ CristiFati - "Parte Uno") antes.}

Answer 4

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

Answer 5

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.

Answer 6

Prefiero usar el módulo glob , ya que hace la comparación de patrones y la expansión.

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

Devolverá una lista con los archivos consultados:

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

Answer 7

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.

Answer 8

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

Answer 9

os.listdir() le proporcionará todo lo que hay en un directorio: archivos y directorios.

Si solo desea archivos, puede filtrar esto utilizando os.path :

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

o puede usar os.walk() que generará dos listas para cada directorio que visite: división en archivos y direcciones para usted. Si solo desea el directorio superior, puede romper la primera vez que cede.

from os import walk

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

Y, por último, como muestra el ejemplo, al agregar una lista a otra puede usar .extend() o

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

Personalmente, prefiero .extend()

Answer 10

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

Answer 11

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

Answer 12

Ejecute findfiles () con un directorio como parámetro y devolverá una lista de todos los archivos que contiene.

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

Answer 13

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.

Answer 14

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

Answer 15

Utilice esta función si desea usar un tipo de archivo diferente u obtener el directorio completo:

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

Answer 16

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)

Answer 17

Versión realmente simple:

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

Answer 18

Mediante el uso de la osbiblioteca.

import os
for root, dirs,files in os.walk("your dir path", topdown=True):
    for name in files:
        print(os.path.join(root, name))

Answer 19

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.

Answer 20

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

Answer 21

Refiriéndose a la respuesta de @adamk, aquí está mi método de detección de sistema operativo en respuesta al comentario de inconsistencia de barra de @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'', .... ]

Supongo que desea solo los nombres de basenames en la lista.

Consulte esta post para predefinir múltiples formatos de archivo para el Método 1.

Answer 22

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.

Answer 23

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

Answer 24

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

Answer 25

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 

Answer 26

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

Answer 27

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

Aquí utilizo una estructura recursiva.

Answer 28

import os
lst=os.listdir(path)

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

Answer 29

import os
os.listdir("somedirectory")

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

Answer 30

import os 
os.listdir(path)

Esto devolverá una lista de todos los archivos y directorios en path.

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

Esto devolverá solo una lista de archivos, no subdirectorios.