Comment lister tous les fichiers d'un répertoire?

Comment puis-je lister tous les fichiers d'un répertoire en Python et les ajouter à un list ?

2943
demandé sur Ioannis Filippidis 2010-07-08 23:31:22
la source

30 ответов

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

2927
répondu pycruft 2015-11-22 09:56:17
la source

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', .... ]
1183
répondu adamk 2018-05-23 21:36:28
la source
import os
os.listdir("somedirectory")

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

535
répondu sepp2k 2016-07-13 22:05:33
la source

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")
372
répondu Giovanni Gianni 2018-09-08 08:42:55
la source

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]]
146
répondu Remi 2015-01-14 21:25:57
la source

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

112
répondu Johnny 2017-04-24 04:57:49
la source

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.

57
répondu SzieberthAdam 2018-05-23 21:41:51
la source

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.

45
répondu ArtOfWarfare 2017-05-23 14:47:32
la source
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 
34
répondu Apogentus 2014-10-07 22:30:34
la source

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
27
répondu Harun ERGUL 2016-03-23 13:09:45
la source

Première Partie 1

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



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



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



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



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



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



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

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



  1. [ActiveState]: win32file.FindFilesW ( !!! 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 :



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



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

24
répondu CristiFati 2018-08-16 18:48:15
la source
import os
lst=os.listdir(path)

os.listdir renvoie une liste contenant les noms des entrées dans le répertoire donné par le chemin.

22
répondu Rajat Garg 2015-07-07 13:12:33
la source

si vous recherchez une implémentation Python de trouver , voici une recette que j'utilise assez fréquemment:

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

donc j'ai fait un PyPI paquet hors de lui et il y a aussi un dépôt GitHub . J'espère que quelqu'un le trouvera potentiellement utile pour ce code.

21
répondu Yauhen Yakimovich 2017-05-29 02:17:27
la source

Python 3.5 introduit une nouvelle méthode plus rapide pour parcourir le répertoire - os.scandir() .

exemple:

for file in os.scandir('/usr/bin'):
    line = ''
    if file.is_file():
        line += 'f'
    elif file.is_dir():
        line += 'd'
    elif file.is_symlink():
        line += 'l'
    line += '\t'
    print("{}{}".format(line, file.name))
16
répondu enedil 2018-05-23 21:42:32
la source

retour d'une liste de noms de fichiers absolus, ne se répète pas dans les sous-répertoires

L = [os.path.join(os.getcwd(),f) for f in os.listdir('.') if os.path.isfile(os.path.join(os.getcwd(),f))]
14
répondu The2ndSon 2014-12-28 06:27:49
la source

liste tous les fichiers d'un répertoire:

import os
from os import path

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

ici, vous obtenez la liste de tous les fichiers d'un répertoire.

13
répondu shiminsh 2015-09-14 16:03:04
la source
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

J'utilise ici une structure récursive.

10
répondu pah8J 2018-07-18 16:44:53
la source
# -** coding: utf-8 -*-
import os
import traceback

print '\n\n'

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

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

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

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

print start()
8
répondu barisim.net 2014-12-28 06:25:50
la source
import dircache
list = dircache.listdir(pathname)
i = 0
check = len(list[0])
temp = []
count = len(list)
while count != 0:
  if len(list[i]) != check:
     temp.append(list[i-1])
     check = len(list[i])
  else:
    i = i + 1
    count = count - 1

print temp
6
répondu shaji 2012-07-25 14:25:54
la source

utilisant des générateurs

import os
def get_files(search_path):
     for (dirpath, _, filenames) in os.walk(search_path):
         for filename in filenames:
             yield os.path.join(dirpath, filename)
list_files = get_files('.')
for filename in list_files:
    print(filename)
6
répondu shantanoo 2017-05-17 18:35:49
la source

si vous vous souciez de la performance, essayez scandir . Pour Python 2.x, vous devrez l'installer manuellement. Exemples:

# 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

cela économise beaucoup de temps quand vous avez besoin de scanner un répertoire énorme, et vous n'avez pas besoin de buffer une liste énorme, il suffit de récupérer un par un. Et vous pouvez aussi le faire récursivement:

def scan_path(path):
    de = scandir.scandir(path)
    while 1:
        try:
            e = de.next()
            if e.is_dir():
                scan_path(e.path)
            else:
                print e.path
        except StopIteration as _:
                break
6
répondu coanor 2018-05-23 21:43:29
la source

utilisez cette fonction si vous voulez utiliser un type de fichier différent ou obtenir le répertoire complet:

import os

def createList(foldername, fulldir = True, suffix=".jpg"):
    file_list_tmp = os.listdir(foldername)
    #print len(file_list_tmp)
    file_list = []
    if fulldir:
        for item in file_list_tmp:
            if item.endswith(suffix):
                file_list.append(os.path.join(foldername, item))
    else:
        for item in file_list_tmp:
            if item.endswith(suffix):
                file_list.append(item)
    return file_list
6
répondu neouyghur 2018-05-23 21:45:07
la source
import os 
os.listdir(path)

vous obtiendrez une liste de tous les fichiers et répertoires de path .

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

cela ne retournera qu'une liste de fichiers, Pas de sous-répertoires.

5
répondu Ashiq Imran 2018-05-23 22:00:18
la source

en utilisant os bibliothèque.

import os
for root, dirs,files in os.walk("your dir path", topdown=True):
    for name in files:
        print(os.path.join(root, name))
4
répondu Sankar 2016-10-15 19:29:55
la source

Exécuter findfiles() avec un répertoire en paramètre et retourne une liste de tous les fichiers qu'il contient.

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

    files = []
    for i in objects:  # check if very object in the folder ...
        if os.path.isfile(os.path.join(directory, i)):  # ... is a file.
            files.append(i)  # if yes, append it.
    return files
4
répondu phyyyl 2018-04-26 16:01:21
la source

en référence à la réponse de @adamk, voici ma méthode de détection os en réponse au commentaire incohérent 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', .... ]

je suppose que vous voulez juste le basenames dans la liste.

référez-vous à ce post pour la définition préalable des formats de fichiers multiples pour la méthode 1.

2
répondu Joseph K. 2017-10-22 07:08:16
la source

je vais fournir un exemple de liner où le type de fichier peut être fourni comme entrée. Le code renvoie une liste de noms de fichiers avec extension csv. Utilisez . au cas où tous les fichiers doivent être retournés. Cela va aussi balayer récursivement les sous-répertoires.

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

Modifier les extensions de fichiers et le chemin d'accès des sources au besoin.

2
répondu Vinodh Krishnaraju 2017-12-12 08:30:53
la source

, très simple:

import os
[f for f in os.listdir(os.getcwd) if ...]
2
répondu Jared Shulman 2018-05-23 19:33:20
la source

une autre variante très lisible pour Python 3.4+ utilise pathlib.Chemin.glob:

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

il est simple de rendre plus spécifique, par exemple Ne chercher que des fichiers source Python qui ne sont pas des liens symboliques, également dans tous les sous-répertoires:

[f for f in Path(folder).glob('**/*.py') if not f.is_symlink()]
2
répondu fhchl 2018-05-23 22:25:59
la source

Deuxième Partie 1

Solutions (suite)

autres approches:

  1. Utiliser Python ce n'est qu'un wrapper

    • Tout est fait en utilisant une autre technologie
    • que la technologie est invoquée à partir de Python
    • Le plus célèbre saveur que je sais Est ce que j'appelle le administrateur système approche:

      • utiliser Python (ou tout autre langage de programmation) pour exécuter des commandes shell (et analyser leurs sorties - en général, cette approche doit être évitée, car si un format de sortie de commande diffère légèrement entre OS versions / saveurs, le code d'analyse devrait être adaptée; pour ne pas mentionner non FR locales)
      • certains considèrent cela comme un piratage soigné
      • je le considère plutôt comme un contournement boiteux ( gainarie ), car l'action en soi est exécutée à partir de shell ( cmd dans ce cas-ci), et n'a donc rien à voir avec Python .
      • filtrage ( grep / findstr ) ou formatage de sortie pourrait être fait sur les deux côtés, mais je ne vais pas insister sur elle. En outre, j'ai délibérément utilisé os.system au lieu de subprocess.Popen .
      (py35x64_test) E:\Work\Dev\StackOverflow\q003207219>"e:\Work\Dev\VEnvs\py35x64_test\Scripts\python.exe" -c "import os;os.system(\"dir /b root_dir\")"
      dir0
      dir1
      dir2
      dir3
      file0
      file1
      

fin de la deuxième partie 1



1. En raison du fait que ainsi 's post (question / answer) limit is 30000 Cars ( [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. Assurez-vous de lire [DONC]: Comment faire pour lister tous les fichiers d'un répertoire? (@CristiFati de réponse - "première Partie") avant de.

2
répondu CristiFati 2018-08-16 18:47:37
la source

Autres questions sur python directory