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
?
30 réponses
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()
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 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:
- tous descendants directs (ou niveau 1) seulement
- 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:
-
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']
- il y a deux implémentations:
-
[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)
- C'est similaire à
-
[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
- sous les scènes, il utilise
-
[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)
- Utilise
-
[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
-
[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
- mais, selon ${PYTHON_SRC_DIR}/Lib/dircache.py : ~#20 + (de v2.7.14 ), c'est juste un emballage (fin) sur
-
[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 destruct dirent64
de dirent.h (ainsi que leDT_*
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 fonctionserrno
dans le cas d'erreur, et je dois vérifier sa valeur. Apparemment,get_errno
ne fonctionne pas (avec un nom invalide,opendir
retourneNULL
, maisget_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']]
-
[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
-
- 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
etos.scandir
utilisationopendir
/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 exemplefilter_func
) qui serait une fonction qui prend un chemin comme argument:filter_func=lambda x: True
(cela ne supprime rien) et à l'intérieur deget_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
- un filtrage avancé (au lieu du simple fichier vs. dir) pourrait être fait: par exemple l'argument
- 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") .
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.
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.
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))
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))]
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.
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.
# -** 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()
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
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)
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
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
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.
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
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.
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.
, très simple:
import os
[f for f in os.listdir(os.getcwd) if ...]
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()]
Deuxième Partie 1
Solutions (suite)
autres approches:
-
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 desubprocess.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.