os.listdir() vous obtiendrez tout ce qui est dans un répertoire - fichiers et répertoires.

si vous voulez juste fichiers, vous pouvez soit filtrer ce vers le bas en utilisant os.path :

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

ou vous pouvez utiliser os.walk() qui donnera deux listes pour chaque répertoire qu'il visite - se divisant en fichiers et en dirs pour vous. Si vous vous pouvez simplement casser la première fois qu'il donne

from os import walk

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

et enfin, comme cet exemple le montre, en ajoutant une liste à une autre, vous pouvez utiliser .extend() ou

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

personnellement, je préfère .extend()

je préfère utiliser le module glob , car il fait l'appariement et l'expansion des motifs.

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

il retournera une liste avec les fichiers recherchés:

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

import os
os.listdir("somedirectory")

renverra une liste de tous les fichiers et répertoires de"somedirectory".

obtenir une liste de fichiers avec Python 2 et 3

---

j'ai aussi fait une courte vidéo ici: Python: comment obtenir une liste de fichiers dans un répertoire

---

os.listdir ()

ou..... chaud pour obtenir tous les fichiers (et répertoires) dans le répertoire courant (Python 3)

la façon la plus simple d'avoir le fichier dans le répertoire courant en Python 3 est celle-ci. C'est très simple; utilisez le module os et la fonction listdir() et vous aurez le fichier dans ce répertoire (et éventuellement des dossiers qui sont dans le répertoire, mais vous n'aurez pas le fichier dans le sous - répertoire, pour cela vous pouvez utiliser walk-j'en parlerai plus tard).

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

---

Utilisation de glob

j'ai trouvé glob plus facile de sélectionner le fichier du même type ou avec quelque chose en commun. Regardez l'exemple suivant:

import glob

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

à l'Aide de compréhension de liste

import glob

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

obtenir le nom complet du chemin avec os.chemin.abspath

Comme vous l'avez remarqué, vous n'avez pas le chemin d'accès complet du fichier dans le code ci-dessus. Si vous besoin d'avoir le chemin absolu, vous pouvez utiliser une autre fonction du os.path module appelé _getfullpathname , en mettant le fichier que vous obtenez de os.listdir() comme argument. Il y a d'autres façons d'avoir le chemin complet, comme nous le vérifierons plus tard (j'ai remplacé, comme suggéré par mexmex, _getfullpathname avec abspath ).

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

---

obtenez le nom de chemin complet d'un type de fichier dans tous les sous-répertoires avec walk

Je trouve cela très utile pour trouver des choses dans de nombreux répertoires, et cela m'a aidé à trouver un fichier dont je ne me souvenais pas du nom:

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(): obtenir les fichiers dans le répertoire courant (Python 2)

En Python 2, si vous voulez la liste des fichiers dans le répertoire courant, vous devez donner l'argument que"."ou os.getcwd() dans l'os.méthode listdir.

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

à emporter dans l'arborescence des répertoires

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

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

Obtenir des fichiers: os.listdir () dans un répertoire particulier (Python 2 et 3)

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

Obtenir les fichiers d'un répertoire avec des os.listdir ()

import os

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

os.marche.'(')- répertoire courant

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

module glob - tous les fichiers

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

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

suivant(os.marche.'(')) et de l'os.chemin.join('dir','fichier')

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

suivant(os.de marche ("F:\') - obtenir le chemin d'accès complet - compréhension de liste

>>> [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-obtenir le chemin complet - tous les fichiers dans les sous-dirs

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

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

os.listdir() - obtenir uniquement les fichiers txt

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

glob - obtenir uniquement les fichiers txt

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

en utilisant glob pour obtenir le chemin complet des fichiers

si j'ai besoin le chemin absolu des fichiers:

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

autre utilisation de la glob

si je veux tous les fichiers du répertoire:

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

utilisant os.chemin.isfile pour éviter les répertoires dans la liste

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

utilisant pathlib de (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 vous voulez utiliser la liste de compréhension

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

*vous pouvez utiliser aussi juste pathlib.Path() au lieu de pathlib.Chemin."(")

utiliser la méthode glob dans pathlib.Path ()

import pathlib

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

sortie:

stack_overflow_list.py
stack_overflow_list_tkinter.py

Obtenir toutes et seulement les fichiers avec l'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']

recevoir uniquement des fichiers avec d'un côté et de marcher dans un répertoire

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

recevoir uniquement les répertoires avec d'un côté et de marcher dans un répertoire

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

Obtenir toutes les sousdir noms avec 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 sur

>>> 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: Combien de fichiers sont là, dans les sous-répertoires?

dans cet exemple, nous cherchons le nombre de fichiers qui sont inclus dans tout le répertoire et ses sous-répertoires.

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'

ex.2: Comment copier tous les fichiers d'un répertoire vers un autre?

un script pour faire l'ordre dans votre ordinateur trouvant tous les fichiers d'un type (par défaut: pptx) et les copiant dans un nouveau dossier.

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: pour obtenir tous les fichiers dans un fichier txt

dans le cas où vous voulez créer un fichier txt avec tous les noms de fichier:

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

Exemple: txt avec tous les fichiers d'un disque dur

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

"""

import os

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

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

os.system("lista_file.txt")
os.system("lista_file_ordinata.txt")
os.system("percorso.txt")

une solution en une ligne pour obtenir seule liste de fichiers (pas de sous-répertoires):

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

ou noms de chemins absolus:

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

obtention de chemins de fichiers complets à partir d'un répertoire et de tous ses sous-répertoires

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

---

• le chemin que j'ai fourni dans la fonction ci - dessus contenait 3 fichiers-deux d'entre eux dans le répertoire racine, et un autre dans un sous-dossier appelé "SUBFOLDER."Vous pouvez maintenant faire des choses comme:

• print full_file_paths qui imprimera la liste:

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

si vous le souhaitez, vous pouvez ouvrir et lire le contenu, ou vous concentrer uniquement sur les fichiers avec l'extension ".dat" comme dans le code ci-dessous:

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

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

depuis la version 3.4 il y a des itérateurs pour cela qui sont beaucoup plus efficaces que os.listdir() :

pathlib : nouveau dans la version 3.4.

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

selon PEP 428 , l'objectif de la bibliothèque pathlib est de fournir une hiérarchie simple des classes pour gérer les chemins du système de fichiers et les opérations courantes que les utilisateurs font sur eux.

os.scandir() : nouveau dans la version 3.5.

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

Note que os.walk() utilise os.scandir() au lieu de os.listdir() de la version 3.5, et sa vitesse a été augmentée de 2-20 fois selon PEP 471 .

Permettez-moi également de recommander la lecture du commentaire de ShadowRanger ci-dessous.

j'ai vraiment aimé adamk la réponse de , ce qui suggère que vous utilisez glob() , à partir du module du même nom. Cela vous permet d'avoir le motif correspondant à * s.

mais comme d'autres personnes l'ont souligné dans les commentaires, glob() peut être trébuché sur les directions de barre oblique incohérente. Pour aider avec cela, je vous suggère d'utiliser les fonctions join() et expanduser() dans le module os.path , et peut-être le getcwd() fonction dans le module os aussi.

comme exemples:

from glob import glob

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

ci-dessus est terrible - le chemin d'accès a été codé en dur et ne jamais travailler sur Windows entre le nom du lecteur et le \ s codée en dur dans le chemin.

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

ce qui précède fonctionne mieux, mais il s'appuie sur le nom de dossier Users qui est souvent trouvé sur Windows et pas si souvent trouvé sur D'autres OSs. Il s'appuie aussi l'utilisateur d'un nom spécifique, 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'))

Cela fonctionne parfaitement sur toutes les plateformes.

un autre grand exemple qui fonctionne parfaitement à travers les plates-formes et fait quelque chose d'un peu différent:

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

espérons que ces exemples vous aideront à voir la puissance de quelques-unes des fonctions que vous pouvez trouver dans les modules de bibliothèque Python standard.

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 

vous devez utiliser le module os pour lister le contenu du répertoire. os.listdir(".") renvoie tout le contenu du répertoire. Nous itérons sur le résultat et ajoutons à la liste.

import os

content_list = []

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

print content_list

Première Partie ¹

notes préliminaires

• bien qu'il y ait une distinction claire entre fichier et répertoire Termes dans le texte de la question, certains peuvent faire valoir que les répertoires sont en fait des fichiers spéciaux
• la déclaration: " tous les fichiers d'un répertoire " peuvent être interprétés de deux façons:
  1. tous descendants directs (ou niveau 1) seulement
  2. tous les descendants dans l'arbre complet des répertoires (y compris ceux des sous-répertoires)

• quand la question a été posée, j'imagine que Python 2 , était la version LTS , cependant les échantillons de code seront exécuté par Python 3 ( .5 ) (je vais les garder comme Python 2 conforme que possible; aussi, tout code appartenant à Python que je vais poster, est de v3.5.4 - sauf indication contraire). Cela a des conséquences liées à un autre mot clé dans la question: " les ajouter dans un liste ":

  • in pre Python 2.2 versions, séquences (itérables) ont été la plupart du temps représentés par des listes (tuples, sets, ...)
  • dans Python 2.2 , le concept de générateur ( [Python]: générateurs ) - courtoisie de [Python]: l'indication de rendement ) - a été introduit. Comme le temps passait, générateur homologues commencé à apparaissent pour les fonctions qui ont retourné / travaillé avec des listes
  • dans Python 3 , le générateur est le comportement par défaut
  • Maintenant, je ne sais pas si une liste est encore obligatoire (ou un générateur ferait aussi bien), mais le passage d'un générateur de list constructeur, permettra de créer une liste (et aussi en consomme). L'exemple ci-dessous illustre les différences sur [Python]: carte ( fonction, itérable,... )

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

• les exemples seront basés sur un répertoire appelé root_dir avec la structure suivante (cet exemple est pour Win , mais j'ai dupliqué l'arbre des dossiers pour Ux ( Lnx ) ainsi):

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

Solutions

approches Programmatiques:

1. [os. listdir ( path=".' )

   retourner une liste contenant les noms des entrées dans le répertoire donné par chemin. La liste est dans l'ordre arbitraire, et ne comprend pas les entrées spéciales '.' et '..' ...

   
   
   

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

   voici un exemple plus élaboré ( 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()
   

   Notes :

   • il y a deux implémentations:
     • celui qui utilise des générateurs (bien sûr dans cet exemple il semble inutile, puisque je convertis le résultat en une liste immédiatement)
     • La classique (fonction des noms se terminant en _old )
   • la récursion est utilisée (pour entrer dans les sous-répertoires)
   • pour chaque implémentation il y a deux fonctions:
     • un qui commence par un underscore ( _ ): "privé "(ne doit pas être appelé directement) - qui fait tout le travail
     • Le public (wrapper cours de la précédente): il vient de se dénude le chemin initial (le cas échéant) de l'retourné entrées. C'est une mise en œuvre moche, mais c'est la seule idée que j'ai pu avoir à ce stade.
   • en termes de performance, les générateurs sont généralement un peu plus rapide (en considérant à la fois création et itération fois), mais je ne les ai pas testés dans les fonctions récursives, et aussi je suis itération à l'intérieur de la fonction sur les générateurs internes-ne sais pas comment la performance est facile est que
   • jouer avec les arguments pour obtenir des résultats différents

   
   
   

   Sortie :

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

2. [os. scandir ( path=".' ) ( !!! Python 3.5 + !!! bien que je pense que pour les versions précédentes c'était un module séparé (également porté à Python 2 )

   renvoie un itérateur de os.DirEntry objets correspondant aux entrées dans le répertoire donné par chemin . Les entrées sont donné dans un ordre arbitraire, et les entrées spéciales '.' et '..' sont pas inclus.

   en utilisant scandir () au lieu de listdir () peut augmenter de manière significative la performance du code qui nécessite également des informations sur le type de fichier ou l'attribut de fichier, parce que os.Les objets DirEntry exposent cette information si le système d'exploitation la fournit lors de la numérisation d'un répertoire. Tous les os.DirEntry méthodes peuvent effectuer un appel système, mais is_dir() et is_file() habituellement seulement besoin d'un système d'appel pour les liens symboliques; os.DirEntry.stat () nécessite toujours un appel système sur Unix mais n'en requiert qu'un pour les liens symboliques sur 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
   

   Notes :

   • C'est similaire à os.listdir
   • mais il est aussi plus flexible (et offre plus de fonctionnalités), plus Python ic (et dans certains cas, plus rapide)

3. [os. walk ( top, topdown=True, onerror = None, followlinks = False )

   génère les noms de fichiers dans un arborescence de répertoires en parcourant l'arborescence de haut en bas ou de bas en haut. Pour chaque répertoire dans l'arbre enraciné dans le répertoire top (y compris top lui-même), il donne 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\StackOverflow\q003207219\root_dir'
   >>>
   >>> walk_generator = os.walk(root_dir)
   >>> root_dir_entry = next(walk_generator)  # First entry corresponds to the root dir (that was passed as an argument)
   >>> root_dir_entry
   ('E:\Work\Dev\StackOverflow\q003207219\root_dir', ['dir0', 'dir1', 'dir2', 'dir3'], ['file0', 'file1'])
   >>>
   >>> root_dir_entry[1] + root_dir_entry[2]  # Display the dirs and the files (that are direct descendants) in a single list
   ['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']
   >>>
   >>> [os.path.join(root_dir_entry[0], item) for item in root_dir_entry[1] + root_dir_entry[2]]  # Display all the entries in the previous list by their full path
   ['E:\Work\Dev\StackOverflow\q003207219\root_dir\dir0', 'E:\Work\Dev\StackOverflow\q003207219\root_dir\dir1', 'E:\Work\Dev\StackOverflow\q003207219\root_dir\dir2', 'E:\Work\Dev\StackOverflow\q003207219\root_dir\dir3', 'E:\Work\Dev\StackOverflow\q003207219\root_dir\file0', 'E:\Work\Dev\StackOverflow\q003207219\root_dir\file1']
   >>>
   >>> for entry in walk_generator:  # Display the rest of the elements (corresponding to every subdir)
   ...     print(entry)
   ...
   ('E:\Work\Dev\StackOverflow\q003207219\root_dir\dir0', ['dir00', 'dir01', 'dir02'], [])
   ('E:\Work\Dev\StackOverflow\q003207219\root_dir\dir0\dir00', ['dir000'], ['file000'])
   ('E:\Work\Dev\StackOverflow\q003207219\root_dir\dir0\dir00\dir000', [], ['file0000'])
   ('E:\Work\Dev\StackOverflow\q003207219\root_dir\dir0\dir01', [], ['file010', 'file011'])
   ('E:\Work\Dev\StackOverflow\q003207219\root_dir\dir0\dir02', ['dir020'], [])
   ('E:\Work\Dev\StackOverflow\q003207219\root_dir\dir0\dir02\dir020', ['dir0200'], [])
   ('E:\Work\Dev\StackOverflow\q003207219\root_dir\dir0\dir02\dir020\dir0200', [], [])
   ('E:\Work\Dev\StackOverflow\q003207219\root_dir\dir1', [], ['file10', 'file11', 'file12'])
   ('E:\Work\Dev\StackOverflow\q003207219\root_dir\dir2', ['dir20'], ['file20'])
   ('E:\Work\Dev\StackOverflow\q003207219\root_dir\dir2\dir20', [], ['file200'])
   ('E:\Work\Dev\StackOverflow\q003207219\root_dir\dir3', [], [])
   

   Notes :

   • sous les scènes, il utilise os.listdir ( os.scandir si disponible)
   • Il ne le levage lourd par récurrents dans les sous-dossiers

4. [glob. glob ( pathname,*, recursive=False ) ( [glob. iglob ( chemin d'accès, * récursive=False ) )

   renvoie une liste éventuellement vide de noms de chemin qui correspondent à pathname , qui doit être une chaîne contenant une spécification de chemin. pathname peut être absolu (comme /usr/src/Python-1.5/Makefile ) ou relatif (comme ../../Tools/*/*.gif ), et peut contenir des caractères génériques de style shell. Les liens symboliques brisés sont inclus dans les résultats (comme dans le shell).
   
   ...
   
   modifié dans la version 3.5 : prise en charge des globs récursifs utilisant " ** ".

   
   
   

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

   Notes :

   • Utilise os.listdir
   • pour les grands arbres (surtout si recursive est activé), iglob est préféré
   • permet un filtrage avancé basé sur le nom (en raison de la Joker)

5. [Python]: class pathlib. Path ( *pathsegments ) ( !!! Python 3 + !!! je ne sais pas si réalignés)

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

   Notes :

   • C'est un la voie de la réalisation de notre objectif
   • C'est le programmation orientée objet style de la manipulation des chemins
   • offre beaucoup de fonctionnalités

6. [dircache.listdir(chemin de) ( !!! supprimé en Python 3 !!! )

   • mais, selon ${PYTHON_SRC_DIR}/Lib/dircache.py : ~#20 + (de v2.7.14 ), c'est juste un emballage (fin) sur os.listdir

   
   
   

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

7. [l'homme]: fonctions opendir(3) / [l'homme]: READDIR(3) / [l'homme]: CLOSEDIR(3) via [Python]: ctypes - Un étranger bibliothèque de fonctions pour Python ( !!! Ux spécifique !!! )

   ctypes est une bibliothèque de fonctions pour Python. Il fournit compatible C les types de données, et permet des fonctions d'appel dans les bibliothèques DLLs ou partagées. Il peut être utilisé pour envelopper ces bibliothèques en pur Python.

   code_ctypes.py :

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

   Notes :

   • il charge les trois fonctions de libc (chargé dans le processus en cours) et les appelle (pour plus de détails, vérifier [Stack Overflow]: Comment puis-je vérifier si un fichier existe en utilisant Python? (@Cristifati's answer) - dernières notes de l'article #4. ). Cela placerait cette approche très proche du Python / c edge
   • LinuxDirent64 est le ctypes représentation de struct dirent64 de dirent.h (ainsi que le DT_* constantes) de ma machine: Ubtu 16 x64 ( 4.10.0-40-Générique et libc6-dev:amd64 ). Sur les autres versions / saveurs, la définition de struct peut différer, et si c'est le cas, le ctypes alias doit être mis à jour, sinon il donnera comportement non défini "1519780920
   • errno_loc_func (et tout ce qui s'y rapporte) est parce que le jeu de fonctions errno dans le cas d'erreur, et je dois vérifier sa valeur. Apparemment, get_errno ne fonctionne pas (avec un nom invalide, opendir retourne NULL , mais get_errno retourne toujours 0), ou je n'ai pas encore compris
   • il renvoie des données dans le format os.walk . Je n'ai pas pris la peine de le rendre récursif, mais à partir du code existant, ce serait une tâche assez insignifiante
   • Tout est faisable sur Gagner ainsi, les données (les bibliothèques, les fonctions, les structures, les constantes ...) different 1519710920"

   
   
   

   Sortie :

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

8. [ActiveState]: win32file.FindFilesW ( !!! Gagner spécifique !!! )

   récupère une liste de noms de fichiers correspondants, en utilisant L'API Windows Unicode. Une interface vers les fonctions FINDFIRSTFILEW/FindNextFileW / Find close.

   
   
   

   >>> import os, win32file, win32con
   >>> root_dir = "root_dir"
   >>> wildcard = "*"
   >>> root_dir_wildcard = os.path.join(root_dir, wildcard)
   >>> entry_list = win32file.FindFilesW(root_dir_wildcard)
   >>> len(entry_list)  # Don't display the whole content as it'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']
   

   Notes :

   • win32file.FindFilesW fait partie de [GitHub]: Python for Windows (pywin32) Extensions , qui est un Python wrapper over WINAPI s
   • le lien de documentation est à partir de https://www.activestate.com , comme je n'ai pas trouvé de pywin32 documentation officielle

9. installer un (autre) paquet tiers qui fait l'affaire
   • très probablement, dépendra de l'un (ou plusieurs) des ci-dessus (peut-être avec de légères personnalisations)

Notes (à propos des choses ci-dessus):

• Code destiné à être portable (sauf les endroits qui ciblent une zone spécifique - qui sont marqués) ou cross:
  • plate-forme ( Ux , Gagner , )
  • Python version (2, 3,)
• plusieurs styles de chemins (absolu, relatif) ont été utilisés à travers les variantes ci-dessus, pour illustrer le fait que les "outils" utilisés sont flexibles dans cette direction
• os.listdir et os.scandir utilisation opendir / readdir / closedir ( [MSDN]: FindFirstFile fonction / [MSDN]: FindNextFile fonction / [MSDN]: FindClose fonction ) (via " ${PYTHON_SRC_DIR}/Modules/posixmodule.c ")
• win32file.FindFilesW utilise ces ( Win spécifiques) fonctions ainsi (via " $ {PYWIN32_SRC_DIR} / win32 / src / win32file.j' ")
• get_dir_content (du point #1. ) peuvent être mises en œuvre à l'aide de l'une de ces approches (certaines nécessiteront plus de travail et d'autres moins.)
  • un filtrage avancé (au lieu du simple fichier vs. dir) pourrait être fait: par exemple l'argument include_folders pourrait être remplacé par un autre (par exemple filter_func ) qui serait une fonction qui prend un chemin comme argument: filter_func=lambda x: True (cela ne supprime rien) et à l'intérieur de get_dir_content quelque chose comme: if not filter_func(entry_with_path): continue (si la fonction échoue pour une entrée, il sera sauté), mais plus le code devient complexe, plus il faudra pour exécuter
• Nota bene! puisque la récursion est utilisée, je dois mentionner que j'ai fait quelques tests sur mon ordinateur portable ( Win 10 x64 ), totalement sans rapport avec ce problème, et lorsque le niveau de récursion atteignait des valeurs quelque part dans le (990 .. 1000) range ( recursionlimit - 1000 (par défaut)), je me suis StackOverflow :). Si l'arbre des répertoires dépasse cette limite (Je ne suis pas un expert FS "1519680920, donc je ne sais pas si c'est possible), cela pourrait être un problème.
  
  Je dois aussi mentionner que je n'ai pas essayer d'augmenter recursionlimit parce que je n'ai aucune expérience dans le domaine (combien puis-je l'augmenter avant d'avoir aussi à augmenter la pile au OS niveau), mais en théorie il y aura toujours la possibilité de défaillance, si la profondeur dir est plus grande que la plus haute possible recursionlimit (sur cette machine)
• les échantillons de code ne sont utilisés qu'à des fins de démonstration. Cela signifie que je n'ai pas pris en compte traitement des erreurs (Je ne pense pas qu'il y ait try / except / else / finally block), de sorte que le code n'est pas robuste (la raison en est: le garder aussi simple et court que possible). Pour production , la gestion des erreurs doit être ajoutée aussi bien

fin de la première partie ¹

_{1. En raison du fait que SO 's post (question / answer) limite est 30000 chars ( [SE.Meta]: Connaître Vos Limites: Quelle est la longueur maximale d'une question de titre, la poste, l'image et les liens utilisés? ), la réponse a été divisée en deux parties. S'il vous plaît aussi visiter [SO]: Comment puis-je lister tous les fichiers d'un répertoire? (@CristiFati de réponse - "Part Two") .}