Comment lister tous les fichiers d'un répertoire?
Comment puis-je lister tous les fichiers d'un répertoire dans Python et les ajouter à un list?
os.listdir() vous obtiendrez tout ce qui est dans un répertoire - fichiers et répertoires.
Si vous voulez seulement fichiers, vous pouvez soit filtrer cela à l’aide de 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 visité - division en fichiers et répertoires pour vous. Si vous ne voulez que le premier répertoire, vous pouvez simplement casser la première fois qu'il cède.
_from os import walk
f = []
for (dirpath, dirnames, filenames) in walk(mypath):
f.extend(filenames)
break
_Je préfère utiliser le module glob , comme c'est le cas pour le filtrage et l'expansion.
import glob
print(glob.glob("/home/adam/*.txt"))
Il retournera une liste avec les fichiers demandés:
['/home/adam/file1.txt', '/home/adam/file2.txt', .... ]
import os
os.listdir("somedirectory")
retournera une liste de tous les fichiers et répertoires dans "somedirectory".
Obtenez une liste de fichiers avec Python 2 et 3
J'ai fait une courte vidéo qui est disponible ici: 
Python: comment obtenir une liste de fichiers dans un répertoire
os.listdir()
Comment obtenir tous les fichiers (et répertoires) dans le répertoire en cours (Python 3)
Voici des méthodes simples pour extraire uniquement les fichiers du répertoire en cours, en utilisant os et la fonction listdir(), dans Python 3. Une exploration plus approfondie montrera comment retourner des dossiers dans le répertoire. n'aura pas le fichier dans le sous-répertoire, vous pouvez utiliser walk - discuté plus tard).
import os
arr = os.listdir()
print(arr)
>>> ['$RECYCLE.BIN', 'work.txt', '3ebooks.txt', 'documents']
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)
globavec compréhension de la liste
import glob
mylist = [f for f in glob.glob("*.txt")]
globavec une fonction
import glob
def filebrowser():
return [f for f in glob.glob("*")]
x = filebrowser()
print(x)
>>> ['example.txt', 'fb.py', 'filebrowser.py', 'help']
globétendre le code précédent
La fonction retourne maintenant une liste de fichiers correspondant à la chaîne que vous transmettez en argument
import glob
def filebrowser(Word=""):
"""Returns a list with all files with the Word/extension in it"""
file = []
for f in glob.glob("*"):
if Word in f:
file.append(f)
return file
flist = filebrowser("example")
print(flist)
flist = filebrowser(".py")
print(flist)
>>> ['example.txt']
>>> ['fb.py', 'filebrowser.py']
Obtenir le nom de chemin complet avec
os.path.abspath
Comme vous l'avez remarqué, vous n'avez pas le chemin complet du fichier dans le code ci-dessus. Si vous avez besoin du chemin absolu, vous pouvez utiliser une autre fonction du module os.path appelée _getfullpathname, en plaçant le fichier que vous obtenez de os.listdir() en argument. Il existe d'autres moyens d'avoir le chemin complet, comme nous le verrons 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()]
print(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 de trouver des éléments dans de nombreux répertoires et cela m'a aidé à trouver un fichier dont je ne me souvenais plus 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(): récupère les fichiers dans le répertoire actuel (Python 2)
Dans Python 2, si vous voulez la liste des fichiers du répertoire en cours, vous devez donner l'argument comme '.' ou os.getcwd () dans la méthode os.listdir.
import os
arr = os.listdir('.')
print(arr)
>>> ['$RECYCLE.BIN', 'work.txt', '3ebooks.txt', 'documents']
Monter dans l'arborescence
# Method 1
x = os.listdir('..')
# Method 2
x= os.listdir('/')
Récupère les fichiers:
os.listdir()dans un répertoire particulier (Python 2 et 3)
import os
arr = os.listdir('F:\\python')
print(arr)
>>> ['$RECYCLE.BIN', 'work.txt', '3ebooks.txt', 'documents']
Obtenir les fichiers d'un sous-répertoire particulier avec
os.listdir()
import os
x = os.listdir("./content")
os.walk('.')- répertoire en cours
import os
arr = next(os.walk('.'))[2]
print(arr)
>>> ['5bs_Turismo1.pdf', '5bs_Turismo1.pptx', 'esperienza.txt']
next(os.walk('.'))andos.path.join('dir', 'file')
import os
arr = []
for d,r,f in next(os.walk("F:\\_python")):
for file in f:
arr.append(os.path.join(r,file))
for f in arr:
print(files)
>>> F:\\_python\\dict_class.py
>>> F:\\_python\\programmi.txt
next(os.walk('F:\\')- récupère le chemin complet - liste la compréhension
[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- récupère le chemin complet - tous les fichiers dans les sous-répertoires **
x = [os.path.join(r,file) for r,d,f in os.walk("F:\\_python") for file in f]
print(x)
>>> ['F:\\_python\\dict.py', 'F:\\_python\\progr.txt', 'F:\\_python\\readl.py']
os.listdir()- récupère uniquement les fichiers txt
arr_txt = [x for x in os.listdir() if x.endswith(".txt")]
print(arr_txt)
>>> ['work.txt', '3ebooks.txt']
Utiliser
globpour obtenir le chemin complet des fichiers
Si j'avais besoin du 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
Utiliser
os.path.isfilepour éviter les répertoires dans la liste
import os.path
listOfFiles = [f for f in os.listdir() if os.path.isfile(f)]
print(listOfFiles)
>>> ['a simple game.py', 'data.txt', 'decorator.py']
Utilisation de
pathlibde 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
Avec list comprehension:
flist = [p for p in pathlib.Path('.').iterdir() if p.is_file()]
Sinon, utilisez pathlib.Path() au lieu de pathlib.Path(".")
Utilisez la méthode glob dans pathlib.Path ()
import pathlib
py = pathlib.Path().glob("*.py")
for file in py:
print(file)
>>> stack_overflow_list.py
>>> stack_overflow_list_tkinter.py
Obtenez tous et uniquement les fichiers avec os.walk
import os
x = [i[2] for i in os.walk('.')]
y=[]
for t in x:
for f in t:
y.append(f)
print(y)
>>> ['append_to_list.py', 'data.txt', 'data1.txt', 'data2.txt', 'data_180617', 'os_walk.py', 'READ2.py', 'read_data.py', 'somma_defaltdic.py', 'substitute_words.py', 'sum_data.py', 'data.txt', 'data1.txt', 'data_180617']
Ne récupère que les fichiers next et marche dans un répertoire
import os
x = next(os.walk('F://python'))[2]
print(x)
>>> ['calculator.bat','calculator.py']
Obtenez seulement les répertoires avec next et allez dans un répertoire
import os
next(os.walk('F://python'))[1] # for the current dir use ('.')
>>> ['python3','others']
Obtenez tous les noms de sous-répertoires 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()from Python 3.5 et versions supérieures
import os
x = [f.name for f in os.scandir() if f.is_file()]
print(x)
>>> ['calculator.bat','calculator.py']
# Another example with scandir (a little variation from docs.python.org)
# This one is more efficient than os.listdir.
# In this case, it shows the files only in the current directory
# where the script is executed.
import os
with os.scandir() as i:
for entry in i:
if entry.is_file():
print(entry.name)
>>> ebookmaker.py
>>> error.PNG
>>> exemaker.bat
>>> guiprova.mp3
>>> setup.py
>>> speakgui4.py
>>> speak_gui2.py
>>> speak_gui3.py
>>> thumb.PNG
Exemples:
Ex. 1: Combien de fichiers y a-t-il dans les sous-répertoires?
Dans cet exemple, nous recherchons le nombre de fichiers 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"))
>>> 'F:\\\python' : 12057 files'
Ex.2: Comment copier tous les fichiers d’un répertoire à un autre?
Un script pour ordonner à votre ordinateur de trouver tous les fichiers d’un type (par défaut: pptx) et de les copier 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('-' * 30)
print("\t==> Found in: `" + dir + "` : " + str(counter) + " files\n")
for dir in os.listdir():
"searches for folders that starts with `_`"
if dir[0] == '_':
# copyfile(dir, filetype='pdf')
copyfile(dir, filetype='txt')
>>> _compiti18\Compito Contabilità 1\conti.txt
>>> _compiti18\Compito Contabilità 1\modula4.txt
>>> _compiti18\Compito Contabilità 1\moduloa4.txt
>>> ------------------------
>>> ==> Found in: `_compiti18` : 3 files
Ex. 3: Comment obtenir tous les fichiers dans un fichier txt
Si vous souhaitez 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 methods of os
# print(*dir(os), sep=", ")
listafile = []
percorso = []
with open("lista_file.txt", "w", encoding='utf-8') as testo:
for root, dirs, files in os.walk("D:\\"):
for file in files:
listafile.append(file)
percorso.append(root + "\\" + file)
testo.write(file + "\n")
listafile.sort()
print("N. of files", len(listafile))
with open("lista_file_ordinata.txt", "w", encoding="utf-8") as testo_ordinato:
for file in listafile:
testo_ordinato.write(file + "\n")
with open("percorso.txt", "w", encoding="utf-8") as file_percorso:
for file in percorso:
file_percorso.write(file + "\n")
os.system("lista_file.txt")
os.system("lista_file_ordinata.txt")
os.system("percorso.txt")
Tout le fichier de C:\dans un fichier texte
Ceci est une version plus courte du code précédent. Changez le dossier où commencer à trouver les fichiers si vous devez partir d’un autre poste. Ce code génère 50 Mo sur un fichier texte sur mon ordinateur avec quelque chose de moins de 500 000 lignes avec des fichiers avec le chemin complet.
import os
with open("file.txt", "w", encoding="utf-8") as filewrite:
for r, d, f in os.walk("C:\\"):
for file in f:
filewrite.write(f"{r + file}\n")
Comment écrire un fichier avec tous les chemins dans un dossier d'un type
Avec cette fonction, vous pouvez créer un fichier txt qui portera le nom d'un type de fichier que vous recherchez (par exemple, pngfile.txt) avec le chemin complet de tous les fichiers de ce type. Cela peut être utile parfois, je pense.
import os
def searchfiles(extension='.ttf', folder='H:\\'):
"Create a txt file with all the file of a type"
with open(extension[1:] + "file.txt", "w", encoding="utf-8") as filewrite:
for r, d, f in os.walk(folder):
for file in f:
if file.endswith(extension):
filewrite.write(f"{r + file}\n")
# looking for png file (fonts) in the hard disk H:\
searchfiles('.png', 'H:\\')
>>> H:\4bs_18\Dolphins5.png
>>> H:\4bs_18\Dolphins6.png
>>> H:\4bs_18\Dolphins7.png
>>> H:\5_18\marketing html\assets\imageslogo2.png
>>> H:\7z001.png
>>> H:\7z002.png
Une solution à une ligne à obtenir niquement liste de fichiers (pas de sous-répertoires):
filenames = next(os.walk(path))[2]
ou chemins absolus:
paths = [os.path.join(path,fn) for fn in next(os.walk(path))[2]]
Obtention des 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 contient 3 fichiers, deux dans le répertoire racine et un autre dans un sous-dossier appelé "SUBFOLDER". Vous pouvez maintenant faire des choses comme:
print full_file_pathsqui 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, des itérateurs intégrés sont beaucoup plus efficaces que os.listdir() :
pathlib : Nouveauté de la version 3.4.
>>> import pathlib
>>> [p for p in pathlib.Path('.').iterdir() if p.is_file()]
Selon PEP 428 , le but de la bibliothèque pathlib est de fournir une hiérarchie simple de classes permettant de gérer les chemins des systèmes de fichiers et les opérations courantes effectuées par les utilisateurs.
os.scandir() : Nouveauté de la version 3.5.
>>> import os
>>> [entry for entry in os.scandir('.') if entry.is_file()]
Notez que os.walk() utilise os.scandir() au lieu de os.listdir() à partir de la version 3.5, et sa vitesse a été augmentée de 2 à 20 fois selon PEP 471 .
Permettez-moi également de lire le commentaire de ShadowRanger ci-dessous.
J'ai vraiment aimé réponse d'Adamk , suggérant que vous utilisiez glob(), à partir du module du même nom. Cela vous permet d’avoir une correspondance de motif avec *s.
Mais comme d'autres personnes l'ont souligné dans les commentaires, glob() peut être dérangé par des barres obliques incohérentes. Pour vous aider, je vous suggère d’utiliser les fonctions join() et expanduser() du module os.path, et peut-être la fonction getcwd() du module os, comme bien.
A titre d'exemple:
from glob import glob
# Return everything under C:\Users\admin that contains a folder called wlp.
glob('C:\Users\admin\*\wlp')
Ce qui précède est terrible: le chemin a été codé en dur et ne fonctionnera jamais sous Windows qu'entre le nom du lecteur et le \s étant codé 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 du dossier Users, qui se trouve souvent sous Windows et pas si souvent sur d'autres systèmes d'exploitation. Il faut également que l'utilisateur ait 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 excellent exemple qui fonctionne parfaitement sur toutes les plateformes 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'))
J'espère que ces exemples vous aideront à voir le pouvoir de quelques-unes des fonctions que vous pouvez trouver dans les modules de bibliothèque standard Python.
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
Si vous recherchez une implémentation Python de find , voici une recette que j'utilise assez souvent:
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
J'ai donc fait un PyPI package et il y a aussi un référentiel GitHub . J'espère que quelqu'un le trouvera potentiellement utile pour ce code.
retourne une liste de chemins de fichiers absolus, ne rentre 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))]
Pour de meilleurs résultats, vous pouvez utiliser la méthode listdir() du module os avec un générateur (un générateur est un puissant itérateur qui conserve son état, rappelez-vous?). Le code suivant fonctionne correctement avec les deux versions: Python 2 et Python 3.
Voici un code:
import os
def files(path):
for file in os.listdir(path):
if os.path.isfile(os.path.join(path, file)):
yield file
for file in files("."):
print (file)
La méthode listdir() renvoie la liste des entrées pour le répertoire donné. La méthode os.path.isfile() renvoie True si l'entrée donnée est un fichier. Et l'opérateur yield quitte la fonction mais conserve son état actuel et renvoie uniquement le nom de l'entrée détectée sous forme de fichier. Tout ce qui précède nous permet de boucler la fonction du générateur.
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
Ici, j'utilise une structure récursive.
Je suppose que tous vos fichiers sont au format *.txt et sont stockés dans un répertoire avec le chemin data/.
On peut utiliser le module glob de python pour répertorier tous les fichiers du répertoire et les ajouter à une liste nommée fnames de la manière suivante:
import glob
fnames = glob.glob("data/*.txt") #fnames: list data type
Un enseignant sage m'a dit une fois que:
Lorsqu'il existe plusieurs façons bien établies de faire quelque chose, aucune d'entre elles n'est bonne pour tous les cas.
J'ajouterai donc une solution pour un sous-ensemble du problème: assez souvent, nous voulons seulement vérifier si un fichier correspond à une chaîne de début et à une chaîne de fin, sans entrer dans les sous-répertoires. Nous aimerions donc une fonction qui retourne une liste de noms de fichiers, comme:
filenames = dir_filter('foo/baz', radical='radical', extension='.txt')
Si vous souhaitez d'abord déclarer deux fonctions, vous pouvez le faire:
def file_filter(filename, radical='', extension=''):
"Check if a filename matches a radical and extension"
if not filename:
return False
filename = filename.strip()
return(filename.startswith(radical) and filename.endswith(extension))
def dir_filter(dirname='', radical='', extension=''):
"Filter filenames in directory according to radical and extension"
if not dirname:
dirname = '.'
return [filename for filename in os.listdir(dirname)
if file_filter(filename, radical, extension)]
Cette solution pourrait facilement être généralisée avec des expressions régulières (et vous pouvez ajouter un argument pattern si vous ne voulez pas que vos modèles restent toujours au début ou à la fin du nom de fichier).
Utiliser 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)
Vous pouvez utiliser ce code pour obtenir un itérateur qui s’exécute sur le chemin complet des fichiers (Répertoires + nom du fichier).
import os
def get_iterator_all_files_name(dir_path):
for (dirpath, dirnames, filenames) in os.walk(dir_path):
for f in filenames:
yield os.path.join(dirpath, f)
Ou utilisez-le pour l'obtenir dans la liste.
import os
def get_list_all_files_name(dir_path):
all_files_path = []
for (dirpath, dirnames, filenames) in os.walk(dir_path):
for f in filenames:
all_files_path.append(os.path.join(dirpath, f))
return all_files_path
# -** 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()
Utilisez cette fonction si vous souhaitez 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
Une autre variante très lisible pour Python 3.4+ utilise pathlib.Path.glob:
from pathlib import Path
folder = '/foo'
[f for f in Path(folder).glob('*') if f.is_file()]
Il est simple de faire plus spécifique, par exemple. recherchez uniquement les 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()]
dircache est "Obsolète depuis la version 2.6: le module dircache a été supprimé de Python 3.0."
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
Voici ma fonction polyvalente pour cela. Il retourne une liste de chemins de fichiers plutôt que de noms de fichiers car je l’ai trouvé plus utile. Il a quelques arguments optionnels qui le rendent polyvalent. Par exemple, je l'utilise souvent avec des arguments tels que pattern='*.txt' ou subfolders=True.
import os
import fnmatch
def list_paths(folder='.', pattern='*', case_sensitive=False, subfolders=False):
"""Return a list of the file paths matching the pattern in the specified
folder, optionally including files inside subfolders.
"""
match = fnmatch.fnmatchcase if case_sensitive else fnmatch.fnmatch
walked = os.walk(folder) if subfolders else [next(os.walk(folder))]
return [os.path.join(root, f)
for root, dirnames, filenames in walked
for f in filenames if match(f, pattern)]
Pour python2: pip install rglob
import rglob
file_list=rglob.rglob("/home/base/dir/", "*")
print file_list
Je vais fournir un exemple d'un liner où sourcepath et le type de fichier peuvent être fournis en entrée. Le code retourne une liste de noms de fichiers avec l'extension csv. Utilisez . au cas où tous les fichiers doivent être retournés. Cela analysera également les sous-répertoires de manière récursive.
[y for x in os.walk(sourcePath) for y in glob(os.path.join(x[0], '*.csv'))]
Modifiez les extensions de fichier et le chemin source si nécessaire.