python öffnen - Wie liste ich alle Dateien eines Verzeichnisses auf?




auflisten dateinamen (25)

Seit Version 3.4 gibt es dafür eingebaute Iteratoren, die wesentlich effizienter sind als os.listdir() :

pathlib : Neu in Version 3.4.

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

Gemäß PEP 428 besteht das Ziel der pathlib Bibliothek darin, eine einfache Hierarchie von Klassen bereitzustellen, um Dateisystempfade und die üblichen Vorgänge zu behandeln, die Benutzer über sie ausführen.

os.scandir() : Neu in Version 3.5.

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

Beachten Sie, dass os.walk() os.scandir() anstelle von os.listdir() aus Version 3.5 verwendet und seine Geschwindigkeit gemäß PEP 471 um das 2-20-fache erhöht wurde.

Lassen Sie mich auch empfehlen, den Kommentar von ShadowRanger unten zu lesen.

Wie kann ich alle Dateien eines Verzeichnisses in Python auflisten und einer list hinzufügen?


os.listdir() Ihnen alles, was sich in einem Verzeichnis befindet - Dateien und Verzeichnisse.

Wenn Sie nur Dateien wünschen, können Sie dies entweder mit os.path :

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

Oder Sie könnten os.walk() das für jedes Verzeichnis, das es besucht, zwei Listen enthält - und zwar in Dateien und Verzeichnisse für Sie. Wenn Sie nur das oberste Verzeichnis wünschen, können Sie das erste Mal unterbrechen, wenn es das erste Mal ergibt

from os import walk

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

Und schließlich, wie dieses Beispiel zeigt, können Sie .extend() oder

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

Persönlich bevorzuge ich .extend()


Ich gehe davon aus, dass alle Ihre Dateien ein *.txtFormat haben und in einem Verzeichnis mit Pfad gespeichert sind data/.

Man kann verwenden glob Modul pythonalle Dateien des Verzeichnisses aufzulisten, und fügen Sie sie in einer Liste genannt fnames, auf folgende Weise:

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

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 

Erster Teil 1

Vorbemerkungen

  • Zwar gibt es im Fragetext eine klare Unterscheidung zwischen Datei- und Verzeichnisausdrücken , manche behaupten jedoch, dass Verzeichnisse eigentlich spezielle Dateien sind
  • Die Anweisung: " Alle Dateien eines Verzeichnisses " kann auf zwei Arten interpretiert werden:
    1. Nur direkte (oder Stufe 1) Nachkommen
    2. Alle Nachkommen im gesamten Verzeichnisbaum (einschließlich derjenigen in Unterverzeichnissen)
  • Als die Frage gestellt wurde, kann ich mir vorstellen, dass Python 2 die LTS- Version war. Die Codebeispiele werden jedoch von Python 3 ( .5 ) ausgeführt (Ich werde sie so python 2- kompatibel wie möglich halten; auch den dazugehörigen Code Python , das ich posten werde, stammt aus Version 3.5.4 - sofern nicht anders angegeben. Das hat Konsequenzen im Zusammenhang mit einem anderen Keyword in der Frage: " Fügen Sie sie in eine Liste ein ":

    • In Versionen vor Python 2.2 wurden Sequenzen (Iterables) meistens durch Listen (Tupel, Sets, ...) dargestellt.
    • In Python 2.2 wurde das Konzept des Generators ( [Python]: Generators ) - mit freundlicher Genehmigung von [Python]: The Yield Statement - - eingeführt. Im Laufe der Zeit wurden Generator-Entsprechungen für Funktionen angezeigt, die Listen zurückgaben bzw. mit Listen arbeiteten
    • In Python 3 ist der Generator das Standardverhalten
    • Ich weiß nicht, ob das Zurückgeben einer Liste immer noch obligatorisch ist (oder ein Generator würde dies ebenfalls tun), aber wenn Sie einen Generator an den list , wird daraus eine Liste erstellt (und auch konsumiert). Das folgende Beispiel veranschaulicht die Unterschiede bei [Python]: map ( Funktion, iterierbar, ... )
    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'>)
    
  • Die Beispiele basieren auf einem Verzeichnis namens root_dir mit der folgenden Struktur (dieses Beispiel ist für Windows , aber ich habe den Ordnerbaum für Ux ( Lnx ) ebenfalls dupliziert):

    E:\Work\Dev\\q003207219>tree /f "root_dir"
    Folder PATH listing for volume Work
    Volume serial number is 00000029 3655:6FED
    E:\WORK\DEV\\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
    


Lösungen

Programmatische Ansätze:

  1. [Python]: os. listdir ( pfad = '.' )

    Gibt eine Liste mit den Namen der Einträge in dem durch path angegebenen Verzeichnis zurück. Die Liste ist in beliebiger Reihenfolge und enthält nicht die Sondereinträge '.' und '..' ...


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

    Hier ist ein ausführlicheres Beispiel ( 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()
    

    Anmerkungen :

    • Es gibt zwei Implementierungen:
      • Einer, der Generatoren verwendet (natürlich scheint es in diesem Beispiel nutzlos zu sein, da ich das Ergebnis sofort in eine Liste umwandle).
      • Der Klassiker (Funktionsnamen, die auf _old enden )
    • Rekursion wird verwendet (um in Unterverzeichnisse zu gelangen)
    • Für jede Implementierung gibt es zwei Funktionen:
      • Eine, die mit einem Unterstrich ( _ ) beginnt: "privat" (sollte nicht direkt aufgerufen werden) - das erledigt die ganze Arbeit
      • Der öffentliche (Wrapper über den vorherigen): Er entfernt den ursprünglichen Pfad (falls erforderlich) von den zurückgegebenen Einträgen. Es ist eine hässliche Implementierung, aber es ist die einzige Idee, mit der ich an diesem Punkt kommen könnte
    • Generatoren sind generell etwas schneller (sowohl bei der Erstellung als auch bei den Wiederholungszeiten ), aber ich habe sie nicht in rekursiven Funktionen getestet. Außerdem durchläuft ich die Funktion über innere Generatoren - ich weiß nicht, wie sie funktionieren soll freundlich ist das
    • Spielen Sie mit den Argumenten, um unterschiedliche Ergebnisse zu erhalten


    Ausgabe :

    (py35x64_test) E:\Work\Dev\\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. [Python]: os. scandir ( path = '.' ) ( !!! Python 3.5 + !!!, obwohl ich denke, dass es sich bei früheren Versionen um ein separates Modul handelte (auch auf Python 2 portiert))

    os.DirEntry einen Iterator von os.DirEntry Objekten zurück, die den Einträgen in dem durch path angegebenen Verzeichnis entsprechen. Die Einträge werden in beliebiger Reihenfolge ausgegeben und die speziellen Einträge '.' und '..' sind nicht enthalten.

    Die Verwendung von scandir () anstelle von listdir () kann die Leistung von Code, für den auch Dateityp- oder Dateiattributinformationen erforderlich sind, erheblich steigern, da os.DirEntry Objekte diese Informationen os.DirEntry , wenn das Betriebssystem sie beim Durchsuchen eines Verzeichnisses bereitstellt. Alle os.DirEntry Methoden können einen Systemaufruf ausführen, aber is_dir() und is_file() erfordern normalerweise nur einen Systemaufruf für symbolische Links. os.DirEntry.stat() erfordert immer einen Systemaufruf unter Unix, aber nur einen für symbolische Links unter 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
    

    Anmerkungen :

    • Es ist ähnlich os.listdir
    • Es ist aber auch flexibler (und bietet mehr Funktionalität), mehr Python ic (und in manchen Fällen auch schneller).


  1. [Python]: os. walk ( top, topdown = True, onerror = Keine, followlinks = False )

    Generieren Sie die Dateinamen in einer Verzeichnisstruktur, indem Sie entweder von oben nach unten oder von unten nach oben navigieren. Für jedes Verzeichnis in dem Verzeichnisbaum am wurzelt oben (einschließlich der oben selbst), ergibt es eine 3-Tupel ( dirpath, dirnames, filenames).


    >>> import os
    >>> root_dir = os.path.join(os.getcwd(), "root_dir")  # Specify the full path
    >>> root_dir
    'E:\\Work\\Dev\\\\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\\\\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\\\\q003207219\\root_dir\\dir0', 'E:\\Work\\Dev\\\\q003207219\\root_dir\\dir1', 'E:\\Work\\Dev\\\\q003207219\\root_dir\\dir2', 'E:\\Work\\Dev\\\\q003207219\\root_dir\\dir3', 'E:\\Work\\Dev\\\\q003207219\\root_dir\\file0', 'E:\\Work\\Dev\\\\q003207219\\root_dir\\file1']
    >>>
    >>> for entry in walk_generator:  # Display the rest of the elements (corresponding to every subdir)
    ...     print(entry)
    ...
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir0', ['dir00', 'dir01', 'dir02'], [])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir0\\dir00', ['dir000'], ['file000'])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir0\\dir00\\dir000', [], ['file0000'])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir0\\dir01', [], ['file010', 'file011'])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir0\\dir02', ['dir020'], [])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir0\\dir02\\dir020', ['dir0200'], [])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir0\\dir02\\dir020\\dir0200', [], [])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir1', [], ['file10', 'file11', 'file12'])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir2', ['dir20'], ['file20'])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir2\\dir20', [], ['file200'])
    ('E:\\Work\\Dev\\\\q003207219\\root_dir\\dir3', [], [])
    

    Anmerkungen :

    • Unter den Kulissen benutzt es os.listdir( os.scandirwo verfügbar)
    • Es macht das schwere Heben durch Wiederholung in Unterordnern


  1. [Python]: glob. glob ( Pfadname, *, rekursiv = falsch ) ( [Python]: glob. iglob ( Pfadname, *, rekursiv = falsch ) )

    Gibt eine möglicherweise leere Liste von Pfadnamen zurück , die dem Pfadnamen entsprechen. Dies muss eine Zeichenfolge sein, die eine Pfadangabe enthält. Der Pfadname kann entweder absolut (like /usr/src/Python-1.5/Makefile) oder relativ (like ../../Tools/*/*.gif) sein und kann Platzhalter im Shell-Stil enthalten. Defekte Symlinks sind in den Ergebnissen enthalten (wie in der Shell).
    ...
    In Version 3.5 geändert : Unterstützung für rekursive Globs mit "**".


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

    Anmerkungen :

    • Verwendet os.listdir
    • Bei großen Bäumen (besonders wenn recursiveauf) steht, iglobwird bevorzugt
    • Ermöglicht erweiterte Filterung nach Namen (aufgrund des Platzhalters)


  1. [Python]: Klassenpfadlib. Pfad ( * Pfadsegmente ) ( !!! Python 3 + !!! weiß nicht, ob zurückportiert)

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

    Anmerkungen :

    • Dies ist ein Weg, um unser Ziel zu erreichen
    • Es ist der OOP- Stil für die Handhabung von Pfaden
    • Bietet viele Funktionalitäten


  1. [Python]: dircache.listdir (Pfad) ( !!! in Python 3 entfernt !!! )

    • Laut $ {PYTHON_SRC_DIR} /Lib/dircache.py : ~ # 20 + (von v2.7.14 ) ist es jedoch nur ein (dünner) Wrapperos.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. [man]: OPENDIR (3) / [man]: READDIR (3) / [man]: CLOSEDIR (3) via [Python]: ctypes - Eine fremde Funktionsbibliothek für Python ( !!! Ux- spezifisch !!! )

    ctypes ist eine Fremdfunktionsbibliothek für Python. Es bietet C-kompatible Datentypen und ermöglicht den Aufruf von Funktionen in DLLs oder gemeinsam genutzten Bibliotheken. Es kann verwendet werden, um diese Bibliotheken in reines Python einzubinden.

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

    Anmerkungen :

    • Es lädt die drei Funktionen aus libc (wird im aktuellen Prozess geladen) und ruft sie auf (weitere Informationen finden Sie unter []: Wie überprüfe ich, ob eine Datei mit Python vorhanden ist? (Antwort von @ CristiFati) - letzte Notizen aus Punkt 4 . ). Dies würde diese Annäherung sehr nahe an die Python / C- Kante bringen
    • LinuxDirent64ist die ctypes- Darstellung struct dirent64von dirent.h (so wie die DT_*Konstanten) von meinem Rechner: Ubtu 16 x64 ( 4.10.0-40-generic und libc6-dev: amd64 ). Bei anderen Versionen / Versionen kann sich die Strukturdefinition unterscheiden. Wenn dies der Fall ist, sollte der Alias ctypes aktualisiert werden. Andernfalls wird Undefined Behavior erzeugt
    • errno_loc_func(und alles was damit zusammenhängt) liegt daran, dass die Funktionen errnoim Fehlerfall eingestellt werden und ich deren Wert überprüfen muss. Anscheinend get_errnofunktioniert nicht (mit einem ungültigen Namen wird opendirzurückgegeben NULL, aber get_errnoimmer noch 0 zurückgegeben), oder ich habe es noch nicht herausgefunden
    • Es gibt Daten im os.walkFormat s zurück. Ich habe mir nicht die Mühe gemacht, es rekursiv zu machen, aber ausgehend vom vorhandenen Code wäre dies eine ziemlich triviale Aufgabe
    • Alles ist auch unter Win machbar , die Daten (Bibliotheken, Funktionen, Strukturen, Konstanten, ...) sind unterschiedlich


    Ausgabe :

    [email protected]:~/work//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 ( !!! Win- spezifisch !!! )

    Ruft mithilfe der Windows Unicode-API eine Liste übereinstimmender Dateinamen ab. Eine Schnittstelle zur API FindFirstFileW / FindNextFileW / Find close-Funktionen.


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

    Anmerkungen :


  1. Installieren Sie ein (anderes) Paket eines Drittanbieters, das den Trick ausführt
    • Wird höchstwahrscheinlich von einem (oder mehreren) der oben genannten abhängen (möglicherweise mit geringfügigen Anpassungen)


Hinweise (zu den oben genannten Sachen):

  • Code ist portabel (außer an Orten, die auf einen bestimmten Bereich abzielen - die markiert sind) oder
    • Plattform ( Ux , Win ,)
    • Python- Version (2, 3,)
  • Mehrere Pfadstile (absolut, verwandt) wurden für die obigen Varianten verwendet, um die Tatsache zu veranschaulichen, dass die verwendeten "Werkzeuge" in diese Richtung flexibel sind
  • os.listdirund os.scandirbenutze opendir/ readdir/ closedir( [MSDN]: FindFirstFile-Funktion / [MSDN]: FindNextFile-Funktion / [MSDN]: FindClose-Funktion (über " $ {PYTHON_SRC_DIR} /Modules/posixmodule.c ")
  • win32file.FindFilesWverwendet auch diese ( Win- spezifischen) Funktionen (über " $ {PYWIN32_SRC_DIR} /win32/src/win32file.i ")
  • get_dir_content(ab Punkt 1. ) kann mit einem dieser Ansätze implementiert werden (einige erfordern mehr Arbeit und einige weniger)
    • Einige erweiterte Filterungen (anstatt nur Datei vs. Verzeichnis) könnten durchgeführt werden: Das include_foldersArgument könnte beispielsweise durch ein anderes ersetzt werden (zB filter_func). filter_func=lambda x: TrueDies wäre eine Funktion, die einen Pfad als Argument verwendet: und in get_dir_contentetwas wie: if not filter_func(entry_with_path): continue(Wenn die Funktion für einen Eintrag fehlschlägt, wird sie übersprungen), aber je komplexer der Code wird, desto länger dauert die Ausführung
  • Nota bene! Da Rekursion verwendet wird, muss ich erwähnen, dass ich einige Tests mit meinem Laptop ( Win 10 x64 ) durchgeführt habe, die in keinem Zusammenhang mit diesem Problem standen, und wenn die Rekursionsstufe Werte im Bereich (990 .. 1000) erreichte ( Rekursionslimit - 1000) (Standardeinstellung), ich habe :). Wenn der Verzeichnisbaum dieses Limit überschreitet (ich bin kein FS- Experte, daher weiß ich nicht, ob das überhaupt möglich ist), könnte dies ein Problem sein.
    Ich muss auch erwähnen, dass ich nicht versucht habe, das Rekursionslimit zu erhöhen, weil ich keine Erfahrung in diesem Bereich habe (wie viel kann ich erhöhen, bevor ich auch den Stack bei OS erhöhen muss)Level), aber theoretisch besteht immer die Möglichkeit des Scheiterns, wenn die Tiefe des Ziels größer ist als das höchstmögliche Rekursionslimit (auf dieser Maschine).
  • Die Codebeispiele dienen nur zu Demonstrationszwecken. Das bedeutet, dass ich die Fehlerbehandlung nicht berücksichtigt habe (ich glaube nicht, dass es einen try/ except/ else/ finally-Block gibt), daher ist der Code nicht robust (der Grund ist: um es so einfach und kurz wie möglich zu halten). Für die Produktion sollte auch die Fehlerbehandlung hinzugefügt werden

Ende von Teil 1 1


1. Aufgrund der Tatsache, dass das Post-Limit (Frage / Antwort) von Home30000 Zeichen liegt ( [SE.Meta]: Kennen Sie Ihre Grenzen: Wie lang darf ein Fragetitel, Beitrag, Bild und Links maximal sein? ), Die Antwort wurde in zwei Teile aufgeteilt. Bitte besuchen Sie auch [SO]: Wie liste ich alle Dateien eines Verzeichnisses auf? (@ CristiFatis Antwort - "Zweiter Teil") .


import os
lst=os.listdir(path)

os.listdir gibt eine Liste mit den Namen der Einträge in dem durch path angegebenen Verzeichnis zurück.


Ich mochte die Antwort von adamk sehr und schlug vor , dass Sie glob() aus dem gleichnamigen Modul verwenden. Dadurch können Sie Muster mit * s abgleichen.

Aber andere Leute haben in den Kommentaren darauf hingewiesen, dass glob() über inkonsistente Slash-Anweisungen stolpern kann. Um dies zu unterstützen, schlage ich vor, dass Sie die Funktionen join() und expanduser() im Modul os.path und möglicherweise auch die Funktion getcwd() im os Modul verwenden.

Als Beispiele:

from glob import glob

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

Das obige ist schrecklich - der Pfad wurde hartcodiert und funktioniert nur unter Windows zwischen dem Laufwerksnamen und dem \ s, der in den Pfad hartcodiert ist.

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

Das Obige funktioniert besser, aber es basiert auf dem Ordnernamen Users der häufig unter Windows und nicht so oft bei anderen Betriebssystemen gefunden wird. Es hängt auch davon ab, dass der Benutzer einen bestimmten Namen hat, 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'))

Dies funktioniert perfekt auf allen Plattformen.

Ein weiteres großartiges Beispiel, das perfekt für Plattformen funktioniert und etwas anderes macht:

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

Ich hoffe, diese Beispiele helfen Ihnen, die Leistungsfähigkeit einiger der Funktionen der Standard-Python-Bibliotheksmodule kennenzulernen.


Sie sollten das os Modul zum Auflisten des Verzeichnisinhalts verwenden. os.listdir(".") gibt den gesamten Inhalt des Verzeichnisses zurück. Wir durchlaufen das Ergebnis und hängen an die Liste an.

import os

content_list = []

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

print content_list

Verwenden Sie diese Funktion, wenn Sie einen anderen Dateityp verwenden oder das vollständige Verzeichnis abrufen möchten:

import os 
os.listdir(path)

Hier ist meine Allzweckfunktion. Es gibt eine Liste der Dateipfade statt der Dateinamen zurück, da ich das für sinnvoller fand. Es gibt einige optionale Argumente, die es vielseitig machen. Zum Beispiel verwende ich es oft mit Argumenten wie pattern='*.txt'oder subfolders=True.

(py35x64_test) E:\Work\Dev\\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

Ich ziehe es vor, das glob Modul zu verwenden, da es Mustervergleich und -erweiterung macht.

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

Es wird eine Liste mit den abgefragten Dateien zurückgegeben:

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

Vollständige Dateipfade aus einem Verzeichnis und allen seinen Unterverzeichnissen abrufen

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")
  • Der Pfad, den ich in der obigen Funktion angegeben habe, enthielt 3 Dateien - zwei davon im Stammverzeichnis und eine weitere in einem Unterordner namens "SUBFOLDER". Sie können jetzt Dinge tun wie:
  • print full_file_paths wodurch die Liste print full_file_paths wird:

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

Wenn Sie möchten, können Sie den Inhalt öffnen und lesen oder sich nur auf Dateien mit der Erweiterung ".dat" wie im folgenden Code konzentrieren:

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

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


Alle Dateien in einem Verzeichnis auflisten:

import os
from os import path

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

Hier erhalten Sie eine Liste aller Dateien in einem Verzeichnis.


Mit der osBibliothek.

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

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

Hier verwende ich eine rekursive Struktur.


Rufen Sie eine Liste der Dateien mit Python 2 und 3 ab

Ich habe hier auch ein kurzes Video gemacht: Python: So erhalten Sie eine Liste der Dateien in einem Verzeichnis

os.listdir ()

oder ..... wie alle Dateien (und Verzeichnisse) im aktuellen Verzeichnis abgerufen werden (Python 3)

Die einfachste Möglichkeit, die Datei im aktuellen Verzeichnis in Python 3 zu haben, ist dies. Es ist wirklich einfach; Verwenden Sie das os Modul und die listdir () - Funktion, und Sie haben die Datei in diesem Verzeichnis (und eventuellen Ordnern, die sich im Verzeichnis befinden, aber Sie werden die Datei nicht im Unterverzeichnis haben. Dafür können Sie walk verwenden - ich werde es tun.) darüber später sprechen).

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

Glob verwenden

Ich fand glob einfacher, Dateien des gleichen Typs oder mit etwas gemeinsamem auszuwählen. Sehen Sie sich folgendes Beispiel an:

import glob

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

Listenverständnis verwenden

import glob

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

Den vollständigen Pfadnamen mit os.path.abspath erhalten

Wie Sie bemerkt haben, haben Sie nicht den vollständigen Pfad der Datei im obigen Code. Wenn Sie den absoluten Pfad benötigen, können Sie eine andere Funktion des Moduls os.path mit dem Namen _getfullpathname . Die Datei, die Sie von os.listdir() als Argument verwendet. Es gibt andere Möglichkeiten, den vollständigen Pfad zu verwenden, wie wir später überprüfen werden (ich habe, wie von mexmex vorgeschlagen, _getfullpathname durch abspath ).

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

Holen Sie sich den vollständigen Pfadnamen eines Dateityps in alle Unterverzeichnisse mit walk

Ich finde das sehr nützlich, um Dinge in vielen Verzeichnissen zu finden, und es half mir, eine Datei zu finden, über die ich mich nicht mehr an den Namen erinnern konnte:

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 (): Dateien im aktuellen Verzeichnis abrufen (Python 2)

Wenn Sie in Python 2 die Liste der Dateien im aktuellen Verzeichnis anzeigen möchten, müssen Sie das Argument als '.' Angeben. oder os.getcwd () in der os.listdir-Methode.

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

Um in den Verzeichnisbaum zu gelangen

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

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

Dateien abrufen: os.listdir () in einem bestimmten Verzeichnis (Python 2 und 3)

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

Mit os.listdir () Dateien eines bestimmten Unterverzeichnisses abrufen

import os

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

os.walk ('.') - aktuelles Verzeichnis

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

Glob-Modul - alle Dateien

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

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

next (os.walk ('.')) und os.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)

>output

F:\\_python\\dict_class.py
F:\\_python\\programmi.txt

next (os.walk ('F: \')) - Holen Sie sich das vollständige Pfadlisten-Verständnis

>>> [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 - get full path - alle Dateien in Unterverzeichnissen

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 () - holt nur TXT-Dateien

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

glob - nur txt-Dateien abrufen

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

Verwendung von glob, um den vollständigen Pfad der Dateien abzurufen

Wenn ich den absoluten Pfad der Dateien benötigen sollte:

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

Andere Verwendung von glob

Wenn ich alle Dateien im Verzeichnis haben möchte:

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

Verwenden von os.path.isfile, um Verzeichnisse in der Liste zu vermeiden

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

Verwenden von pathlib von (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

Wenn Sie Listenverständnis verwenden möchten

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

* Sie können auch nur pathlib.Path () anstelle von pathlib.Path (".") Verwenden.

Verwenden Sie die Glob-Methode in pathlib.Path ().

import pathlib

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

Ausgabe:

stack_overflow_list.py
stack_overflow_list_tkinter.py

Holen Sie sich alle und nur Dateien mit 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']

Holen Sie sich nur Dateien mit next und gehen Sie in ein Verzeichnis

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

Holen Sie sich nur Verzeichnisse mit next und gehen Sie in ein Verzeichnis

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

Holen Sie sich alle Unterverzeichnisnamen mit 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 () ab Python 3.5

>>> 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: Wie viele Dateien befinden sich in den Unterverzeichnissen?

In diesem Beispiel suchen wir nach der Anzahl der Dateien, die in allen Verzeichnissen und deren Unterverzeichnissen enthalten sind.

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'

Beispiel 2: Wie kopiere ich alle Dateien von einem Verzeichnis in ein anderes?

Ein Skript, mit dem Sie auf Ihrem Computer eine Reihenfolge festlegen können, in der alle Dateien eines Typs (Standard: pptx) gesucht und in einen neuen Ordner kopiert werden.

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: So erhalten Sie alle Dateien in einer TXT-Datei

Wenn Sie eine TXT-Datei mit allen Dateinamen erstellen möchten:

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

Beispiel: txt mit allen Dateien einer Festplatte

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

Alle Dateien von C: \\ in einer Textdatei

Dies ist eine kürzere Version des vorherigen Codes. Ändern Sie den Ordner, in dem die Dateien gesucht werden sollen, wenn Sie an einer anderen Position beginnen müssen. Mit diesem Code werden auf meinem Computer 50 MB Textdatei mit etwas weniger als 500.000 Zeilen mit Dateien mit dem vollständigen Pfad generiert.

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

Eine Funktion zum Suchen nach einem bestimmten Dateityp

import os

def searchfiles(extension='.ttf'):
    "Create a txt file with all the file of a type"
    with open("file.txt", "w", encoding="utf-8") as filewrite:
        for r, d, f in os.walk("C:\\"):
            for file in f:
                if file.endswith(extension):
                    filewrite.write(f"{r + file}\n")

# looking for ttf file (fonts)
searchfiles('ttf')

Python 3.5 führte eine neue, schnellere Methode ein, um das Verzeichnis zu durchsuchen - os.scandir().

Beispiel:

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

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

Wenn Sie Wert auf Leistung legen, versuchen Sie es scandir. Für Python 2.x müssen Sie sie möglicherweise manuell installieren. Beispiele:

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

Dies spart viel Zeit, wenn Sie ein großes Verzeichnis scannen müssen und keine große Liste zwischenspeichern müssen, sondern nur eine nach der anderen abrufen. Und du kannst es auch rekursiv machen:

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

Generatoren verwenden

# 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

Wenn Sie nach einer Python-Implementierung von find suchen , verwende ich dieses Rezept eher häufig:

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

Also habe ich ein PyPI- package daraus gemacht und es gibt auch ein GitHub-Repository . Ich hoffe, dass jemand es für diesen Code als nützlich erachtet.


Bezüglich der Antwort von @adamk, hier ist meine OS- Erkennungsmethode als Antwort auf den Slash-Inkonsistenz-Kommentar von @Anti Earth

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

Ich gehe davon aus, dass Sie nur die basenames in der Liste wollen.

In diesem post erfahren Sie, wie Sie mehrere Dateiformate für Methode 1 vordefinieren.


Ich werde ein Beispiel für einen Liner bereitstellen, in dem Quellpfad und Dateityp als Eingabe bereitgestellt werden können. Der Code gibt eine Liste von Dateinamen mit der CSV-Erweiterung zurück. Verwenden . falls alle Dateien zurückgegeben werden müssen. Dadurch werden auch die Unterverzeichnisse rekursiv durchsucht.

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

Ändern Sie die Dateierweiterungen und den Quellpfad nach Bedarf.


Pathlib kann auf diese Weise verwendet werden, um das Verzeichnis mit dem aktuellen Skript zu erhalten:

import pathlib
filepath = pathlib.Path(__file__).resolve().parent




python directory