it-swarm.com.de

Finden Sie alle Dateien in einem Verzeichnis mit der Erweiterung .txt in Python

Wie finde ich alle Dateien in einem Verzeichnis mit der Erweiterung .txt in Python?

1043
usertest

Sie können glob verwenden:

_import glob, os
os.chdir("/mydir")
for file in glob.glob("*.txt"):
    print(file)
_

oder einfach os.listdir :

_import os
for file in os.listdir("/mydir"):
    if file.endswith(".txt"):
        print(os.path.join("/mydir", file))
_

oder wenn Sie das Verzeichnis durchlaufen möchten, verwenden Sie os.walk :

_import os
for root, dirs, files in os.walk("/mydir"):
    for file in files:
        if file.endswith(".txt"):
             print(os.path.join(root, file))
_
2028
ghostdog74

Verwenden Sie glob .

>>> import glob
>>> glob.glob('./*.txt')
['./outline.txt', './pip-log.txt', './test.txt', './testingvim.txt']
211

So etwas sollte den Job machen

for root, dirs, files in os.walk(directory):
    for file in files:
        if file.endswith('.txt'):
            print file
131
Adam Byrtek

So etwas wird funktionieren:

>>> import os
>>> path = '/usr/share/cups/charmaps'
>>> text_files = [f for f in os.listdir(path) if f.endswith('.txt')]
>>> text_files
['euc-cn.txt', 'euc-jp.txt', 'euc-kr.txt', 'euc-tw.txt', ... 'windows-950.txt']
101
Seth
import os

path = 'mypath/path' 
files = os.listdir(path)

files_txt = [i for i in files if i.endswith('.txt')]
30
user3281344

Ich mag os.walk () :

import os, os.path

for root, dirs, files in os.walk(dir):
    for f in files:
        fullpath = os.path.join(root, f)
        if os.path.splitext(fullpath)[1] == '.txt':
            print fullpath

Oder mit Generatoren:

import os, os.path

fileiter = (os.path.join(root, f)
    for root, _, files in os.walk(dir)
    for f in files)
txtfileiter = (f for f in fileiter if os.path.splitext(f)[1] == '.txt')
for txt in txtfileiter:
    print txt
27
hughdbrown

Sie können einfach pathlib s glob verwenden 1:

_import pathlib

list(pathlib.Path('your_directory').glob('*.txt'))
_

oder in einer Schleife:

_for txt_file in pathlib.Path('your_directory').glob('*.txt'):
    # do something with "txt_file"
_

Wenn Sie möchten, dass es rekursiv ist, können Sie .glob('**/*.txt) verwenden.


1Das Modul pathlib wurde in die Standardbibliothek in python 3.4 aufgenommen. Sie können die Back-Ports dieses Moduls jedoch auch in älteren Python-Versionen installieren (z. B. mit conda oder pip): pathlib und pathlib2 .

25
MSeifert

Hier sind weitere Versionen derselben, die zu geringfügig unterschiedlichen Ergebnissen führen:

glob.iglob ()

import glob
for f in glob.iglob("/mydir/*/*.txt"): # generator, search immediate subdirectories 
    print f

glob.glob1 ()

print glob.glob1("/mydir", "*.tx?")  # literal_directory, basename_pattern

fnmatch.filter ()

import fnmatch, os
print fnmatch.filter(os.listdir("/mydir"), "*.tx?") # include dot-files
23
jfs

path.py ist eine andere Alternative: https://github.com/jaraco/path.py

from path import path
p = path('/path/to/the/directory')
for f in p.files(pattern='*.txt'):
    print f
19

Python verfügt über alle Tools, um dies zu tun:

import os

the_dir = 'the_dir_that_want_to_search_in'
all_txt_files = filter(lambda x: x.endswith('.txt'), os.listdir(the_dir))
11
Xxxo

So rufen Sie alle TXT-Dateinamen im Ordner "dataPath" auf pythonische Weise als Liste ab

from os import listdir
from os.path import isfile, join
path = "/dataPath/"
onlyTxtFiles = [f for f in listdir(path) if isfile(join(path, f)) and  f.endswith(".txt")]
print onlyTxtFiles
9
ewalel
import os
import sys 

if len(sys.argv)==2:
    print('no params')
    sys.exit(1)

dir = sys.argv[1]
mask= sys.argv[2]

files = os.listdir(dir); 

res = filter(lambda x: x.endswith(mask), files); 

print res
8
mrgloom

Python v3.5 +

Schnelle Methode mit os.scandir in einer rekursiven Funktion. Sucht nach allen Dateien mit einer bestimmten Erweiterung in Ordnern und Unterordnern.

import os

def findFilesInFolder(path, pathList, extension, subFolders = True):
    """  Recursive function to find all files of an extension type in a folder (and optionally in all subfolders too)

    path:        Base directory to find files
    pathList:    A list that stores all paths
    extension:   File extension to find
    subFolders:  Bool.  If True, find files in all subfolders under path. If False, only searches files in the specified folder
    """

    try:   # Trapping a OSError:  File permissions problem I believe
        for entry in os.scandir(path):
            if entry.is_file() and entry.path.endswith(extension):
                pathList.append(entry.path)
            Elif entry.is_dir() and subFolders:   # if its a directory, then repeat process as a nested function
                pathList = findFilesInFolder(entry.path, pathList, extension, subFolders)
    except OSError:
        print('Cannot access ' + path +'. Probably a permissions error')

    return pathList

dir_name = r'J:\myDirectory'
extension = ".txt"

pathList = []
pathList = findFilesInFolder(dir_name, pathList, extension, True)

Update April 2019

Wenn Sie Verzeichnisse durchsuchen, die 10.000 Dateien enthalten, wird das Anhängen an eine Liste ineffizient. Die Ergebnisse zu „liefern“ ist eine bessere Lösung. Ich habe auch eine Funktion zum Konvertieren der Ausgabe in einen Pandas-Datenrahmen eingefügt.

import os
import re
import pandas as pd
import numpy as np


def findFilesInFolderYield(path,  extension, containsTxt='', subFolders = True, excludeText = ''):
    """  Recursive function to find all files of an extension type in a folder (and optionally in all subfolders too)

    path:               Base directory to find files
    extension:          File extension to find.  e.g. 'txt'.  Regular expression. Or  'ls\d' to match ls1, ls2, ls3 etc
    containsTxt:        List of Strings, only finds file if it contains this text.  Ignore if '' (or blank)
    subFolders:         Bool.  If True, find files in all subfolders under path. If False, only searches files in the specified folder
    excludeText:        Text string.  Ignore if ''. Will exclude if text string is in path.
    """
    if type(containsTxt) == str: # if a string and not in a list
        containsTxt = [containsTxt]

    myregexobj = re.compile('\.' + extension + '$')    # Makes sure the file extension is at the end and is preceded by a .

    try:   # Trapping a OSError or FileNotFoundError:  File permissions problem I believe
        for entry in os.scandir(path):
            if entry.is_file() and myregexobj.search(entry.path): # 

                bools = [True for txt in containsTxt if txt in entry.path and (excludeText == '' or excludeText not in entry.path)]

                if len(bools)== len(containsTxt):
                    yield entry.stat().st_size, entry.stat().st_atime_ns, entry.stat().st_mtime_ns, entry.stat().st_ctime_ns, entry.path

            Elif entry.is_dir() and subFolders:   # if its a directory, then repeat process as a nested function
                yield from findFilesInFolderYield(entry.path,  extension, containsTxt, subFolders)
    except OSError as ose:
        print('Cannot access ' + path +'. Probably a permissions error ', ose)
    except FileNotFoundError as fnf:
        print(path +' not found ', fnf)

def findFilesInFolderYieldandGetDf(path,  extension, containsTxt, subFolders = True, excludeText = ''):
    """  Converts returned data from findFilesInFolderYield and creates and Pandas Dataframe.
    Recursive function to find all files of an extension type in a folder (and optionally in all subfolders too)

    path:               Base directory to find files
    extension:          File extension to find.  e.g. 'txt'.  Regular expression. Or  'ls\d' to match ls1, ls2, ls3 etc
    containsTxt:        List of Strings, only finds file if it contains this text.  Ignore if '' (or blank)
    subFolders:         Bool.  If True, find files in all subfolders under path. If False, only searches files in the specified folder
    excludeText:        Text string.  Ignore if ''. Will exclude if text string is in path.
    """

    fileSizes, accessTimes, modificationTimes, creationTimes , paths  = Zip(*findFilesInFolderYield(path,  extension, containsTxt, subFolders))
    df = pd.DataFrame({
            'FLS_File_Size':fileSizes,
            'FLS_File_Access_Date':accessTimes,
            'FLS_File_Modification_Date':np.array(modificationTimes).astype('timedelta64[ns]'),
            'FLS_File_Creation_Date':creationTimes,
            'FLS_File_PathName':paths,
                  })

    df['FLS_File_Modification_Date'] = pd.to_datetime(df['FLS_File_Modification_Date'],infer_datetime_format=True)
    df['FLS_File_Creation_Date'] = pd.to_datetime(df['FLS_File_Creation_Date'],infer_datetime_format=True)
    df['FLS_File_Access_Date'] = pd.to_datetime(df['FLS_File_Access_Date'],infer_datetime_format=True)

    return df

ext =   'txt'  # regular expression 
containsTxt=[]
path = 'C:\myFolder'
df = findFilesInFolderYieldandGetDf(path,  ext, containsTxt, subFolders = True)
8
DougR

Ich habe einen Test (Python 3.6.4, W7x64) durchgeführt, um festzustellen, welche Lösung für einen Ordner ohne Unterverzeichnisse am schnellsten ist, um eine Liste der vollständigen Dateipfade für Dateien mit einer bestimmten Erweiterung zu erhalten.

Um es kurz zu machen, für diese Aufgabe ist os.listdir() die schnellste und ist 1,7x so schnell wie die nächstbeste: os.walk() (mit einer Pause!), 2,7x so schnell wie pathlib, 3,2x schneller als os.scandir() und 3,3x schneller als glob.
Bitte beachten Sie, dass sich diese Ergebnisse ändern, wenn Sie rekursive Ergebnisse benötigen. Wenn Sie eine der folgenden Methoden kopieren/einfügen, fügen Sie ein .lower () hinzu, da sonst bei der Suche nach .ext .EXT nicht gefunden wird.

import os
import pathlib
import timeit
import glob

def a():
    path = pathlib.Path().cwd()
    list_sqlite_files = [str(f) for f in path.glob("*.sqlite")]

def b(): 
    path = os.getcwd()
    list_sqlite_files = [f.path for f in os.scandir(path) if os.path.splitext(f)[1] == ".sqlite"]

def c():
    path = os.getcwd()
    list_sqlite_files = [os.path.join(path, f) for f in os.listdir(path) if f.endswith(".sqlite")]

def d():
    path = os.getcwd()
    os.chdir(path)
    list_sqlite_files = [os.path.join(path, f) for f in glob.glob("*.sqlite")]

def e():
    path = os.getcwd()
    list_sqlite_files = [os.path.join(path, f) for f in glob.glob1(str(path), "*.sqlite")]

def f():
    path = os.getcwd()
    list_sqlite_files = []
    for root, dirs, files in os.walk(path):
        for file in files:
            if file.endswith(".sqlite"):
                list_sqlite_files.append( os.path.join(root, file) )
        break



print(timeit.timeit(a, number=1000))
print(timeit.timeit(b, number=1000))
print(timeit.timeit(c, number=1000))
print(timeit.timeit(d, number=1000))
print(timeit.timeit(e, number=1000))
print(timeit.timeit(f, number=1000))

Ergebnisse:

# Python 3.6.4
0.431
0.515
0.161
0.548
0.537
0.274
7
user136036

Sie können diesen Code ausprobieren

import glob
import os
filenames_without_extension = [os.path.basename(c).split('.')[0:1][0] for c in glob.glob('your/files/dir/*.txt')]
filenames_with_extension = [os.path.basename(c) for c in glob.glob('your/files/dir/*.txt')]
6
x01saa

Dieser Code macht mein Leben einfacher.

import os
fnames = ([file for root, dirs, files in os.walk(dir)
    for file in files
    if file.endswith('.txt') #or file.endswith('.png') or file.endswith('.pdf')
    ])
for fname in fnames: print(fname)
5
praba230890

Versuchen Sie dies, um alle Ihre Dateien rekursiv zu finden:

import glob, os
os.chdir("H:\\wallpaper")# use whatever you directory 

#double\\ no single \

for file in glob.glob("**/*.psd", recursive = True):#your format
    print(file)
5
mayank

Verwenden Sie fnmatch: https://docs.python.org/2/library/fnmatch.html

import fnmatch
import os

for file in os.listdir('.'):
    if fnmatch.fnmatch(file, '*.txt'):
        print file
5
yucer

Um ein Array mit ".txt" -Dateinamen aus einem Ordner mit dem Namen "data" im selben Verzeichnis abzurufen, verwende ich normalerweise die folgende einfache Codezeile:

import os
fileNames = [fileName for fileName in os.listdir("data") if fileName.endswith(".txt")]
3
Kamen Tsvetkov
import glob,os

data_dir = 'data_folder/'
file_dir_extension = os.path.join(data_dir, '*.txt')

for file_name in glob.glob(file_dir_extension):
    if file_name.endswith('.txt'):
        print file_name

Für mich. Es ist klassisch.

3
CodeTarsier

Ich schlage vor, dass Sie fnmatch und die obere Methode verwenden. Auf diese Weise können Sie Folgendes finden:

  1. Name. txt ;
  2. Name. TXT;
  3. Name. Txt

.

import fnmatch
import os

    for file in os.listdir("/Users/Johnny/Desktop/MyTXTfolder"):
        if fnmatch.fnmatch(file.upper(), '*.TXT'):
            print(file)
3
Nicolaesse

Sie können diesen Code ausprobieren:

import glob
import os

os.chdir("D:\...\DirName")
filename_arr={}
i=0
for files in glob.glob("*.txt"):
    filename_arr[i] = files
    i= i+1

for key,value in filename_arr.items():
    print key , value
2
Anand

Hier ist eine mit extend()

types = ('*.jpg', '*.png')
images_list = []
for files in types:
    images_list.extend(glob.glob(os.path.join(path, files)))
2
Efreeto

Wenn der Ordner viele Dateien enthält oder der Arbeitsspeicher eine Einschränkung darstellt, sollten Sie die Verwendung von Generatoren in Betracht ziehen:

def yield_files_with_extensions(folder_path, file_extension):
   for _, _, files in os.walk(folder_path):
       for file in files:
           if file.endswith(file_extension):
               yield file

Option A: Iterieren

for f in yield_files_with_extensions('.', '.txt'): 
    print(f)

Option B: Holen Sie sich alle

files = [f for f in yield_files_with_extensions('.', '.txt')]
2
tashuhka
import glob
import os

path=os.getcwd()

extensions=('*.py','*.cpp')

for i in extensions:
  for files in glob.glob(i):
     print files
2
banoth ravinder

Funktionslösung mit Unterverzeichnissen:

from fnmatch import filter
from functools import partial
from itertools import chain
from os import path, walk

print(*chain(*(map(partial(path.join, root), filter(filenames, "*.txt")) for root, _, filenames in walk("mydir"))))
2

Eine kopierfähige Lösung ähnlich der von Ghostdog:

def get_all_filepaths(root_path, ext):
    """
    Search all files which have a given extension within root_path.

    This ignores the case of the extension and searches subdirectories, too.

    Parameters
    ----------
    root_path : str
    ext : str

    Returns
    -------
    list of str

    Examples
    --------
    >>> get_all_filepaths('/run', '.lock')
    ['/run/unattended-upgrades.lock',
     '/run/mlocate.daily.lock',
     '/run/xtables.lock',
     '/run/mysqld/mysqld.sock.lock',
     '/run/postgresql/.s.PGSQL.5432.lock',
     '/run/network/.ifstate.lock',
     '/run/lock/asound.state.lock']
    """
    import os
    all_files = []
    for root, dirs, files in os.walk(root_path):
        for filename in files:
            if filename.lower().endswith(ext):
                all_files.append(os.path.join(root, filename))
    return all_files
2
Martin Thoma

verwenden Sie das Modul Python OS , um Dateien mit einer bestimmten Erweiterung zu finden.

das einfache Beispiel ist hier:

import os

# This is the path where you want to search
path = r'd:'  

# this is extension you want to detect
extension = '.txt'   # this can be : .jpg  .png  .xls  .log .....

for root, dirs_list, files_list in os.walk(path):
    for file_name in files_list:
        if os.path.splitext(file_name)[-1] == extension:
            file_name_path = os.path.join(root, file_name)
            print file_name
            print file_name_path   # This is the full path of the filter file
1
Rajiv Sharma

Eine einfache Methode mit der for -Schleife:

import os

dir = ["e","x","e"]

p = os.listdir('E:')  #path

for n in range(len(p)):
   name = p[n]
   myfile = [name[-3],name[-2],name[-1]]  #for .txt
   if myfile == dir :
      print(name)
   else:
      print("nops")

Dies kann jedoch verallgemeinert werden.

1
BoRRis

Viele Benutzer haben mit os.walk Antworten geantwortet, die alle Dateien, aber auch alle Verzeichnisse und Unterverzeichnisse und deren Dateien enthalten.

import os


def files_in_dir(path, extension=''):
    """
       Generator: yields all of the files in <path> ending with
       <extension>

       \param   path       Absolute or relative path to inspect,
       \param   extension  [optional] Only yield files matching this,

       \yield              [filenames]
    """


    for _, dirs, files in os.walk(path):
        dirs[:] = []  # do not recurse directories.
        yield from [f for f in files if f.endswith(extension)]

# Example: print all the .py files in './python'
for filename in files_in_dir('./python', '*.py'):
    print("-", filename)

Oder für ein Einzelstück, bei dem Sie keinen Generator benötigen:

path, ext = "./python", ext = ".py"
for _, _, dirfiles in os.walk(path):
    matches = (f for f in dirfiles if f.endswith(ext))
    break

for filename in matches:
    print("-", filename)

Wenn Sie Übereinstimmungen für etwas anderes verwenden möchten, möchten Sie möglicherweise eine Liste anstelle eines Generatorausdrucks erstellen:

    matches = [f for f in dirfiles if f.endswith(ext)]
0
kfsone