Verzeichnisbaumauflistung in Python

Sie können verwenden

os.listdir(path)

Referenz und weitere Funktionen von os finden Sie hier:

• Python 2-Dokumente: https://docs.python.org/2/library/os.html#os.listdir
• Python 3-Dokumente: https://docs.python.org/3/library/os.html#os.listdir

Hier ist eine Hilfsfunktion, die ich häufig benutze:

import os

def listdir_fullpath(d):
    return [os.path.join(d, f) for f in os.listdir(d)]

import os

for filename in os.listdir("C:\\temp"):
    print  filename

Wenn Sie Globbing-Fähigkeiten benötigen, gibt es dafür auch ein Modul. Zum Beispiel:

import glob
glob.glob('./[0-9].*')

wird etwas zurückgeben wie:

['./1.gif', './2.txt']

Siehe die Dokumentation hier .

Versuche dies:

import os
for top, dirs, files in os.walk('./'):
    for nm in files:       
        print os.path.join(top, nm)

Für Dateien im aktuellen Arbeitsverzeichnis ohne Angabe eines Pfads

Python 2.7:  

import os
os.listdir(os.getcwd())

Python 3.x:  

import os
os.listdir()

Danke an Stam Kaly für den Kommentar zu python 3.x

Eine rekursive Implementierung

import os

def scan_dir(dir):
    for name in os.listdir(dir):
        path = os.path.join(dir, name)
        if os.path.isfile(path):
            print path
        else:
            scan_dir(path)

Ich habe eine lange Version mit allen Optionen geschrieben, die ich benötigen könnte: http://sam.nipl.net/code/python/find.py

Ich denke, es wird auch hier passen:

#!/usr/bin/env python

import os
import sys

def ls(dir, hidden=False, relative=True):
    nodes = []
    for nm in os.listdir(dir):
        if not hidden and nm.startswith('.'):
            continue
        if not relative:
            nm = os.path.join(dir, nm)
        nodes.append(nm)
    nodes.sort()
    return nodes

def find(root, files=True, dirs=False, hidden=False, relative=True, topdown=True):
    root = os.path.join(root, '')  # add slash if not there
    for parent, ldirs, lfiles in os.walk(root, topdown=topdown):
        if relative:
            parent = parent[len(root):]
        if dirs and parent:
            yield os.path.join(parent, '')
        if not hidden:
            lfiles   = [nm for nm in lfiles if not nm.startswith('.')]
            ldirs[:] = [nm for nm in ldirs  if not nm.startswith('.')]  # in place
        if files:
            lfiles.sort()
            for nm in lfiles:
                nm = os.path.join(parent, nm)
                yield nm

def test(root):
    print "* directory listing, with hidden files:"
    print ls(root, hidden=True)
    print
    print "* recursive listing, with dirs, but no hidden files:"
    for f in find(root, dirs=True):
        print f
    print

if __== "__main__":
    test(*sys.argv[1:])

Für Python 2

#!/bin/python2

import os

def scan_dir(path):
    print map(os.path.abspath, os.listdir(pwd))

Für Python 3

Für Filter und Map müssen Sie sie mit list () umschließen.

#!/bin/python3

import os

def scan_dir(path):
    print(list(map(os.path.abspath, os.listdir(pwd))))

Jetzt empfehlen wir Ihnen, Ihre Verwendung von Map und Filter durch Generatorenausdrücke oder Listenverständnisse zu ersetzen:

#!/bin/python

import os

def scan_dir(path):
    print([os.path.abspath(f) for f in os.listdir(path)])

Ein Nice-Liner, um nur die Dateien rekursiv aufzulisten. Ich habe dies in meiner setup.py package_data Direktive verwendet:

import os

[os.path.join(x[0],y) for x in os.walk('<some_directory>') for y in x[2]]

Ich weiß, dass es nicht die Antwort auf die Frage ist, aber es könnte nützlich sein

Hier ist eine einzeilige Pythonic-Version:

import os
dir = 'given_directory_name'
filenames = [os.path.join(os.path.dirname(os.path.abspath(__file__)),dir,i) for i in os.listdir(dir)]

Dieser Code listet den vollständigen Pfad aller Dateien und Verzeichnisse im angegebenen Verzeichnisnamen auf. 

#import modules
import os

_CURRENT_DIR = '.'


def rec_tree_traverse(curr_dir, indent):
    "recurcive function to traverse the directory"
    #print "[traverse_tree]"

    try :
        dfList = [os.path.join(curr_dir, f_or_d) for f_or_d in os.listdir(curr_dir)]
    except:
        print "wrong path name/directory name"
        return

    for file_or_dir in dfList:

        if os.path.isdir(file_or_dir):
            #print "dir  : ",
            print indent, file_or_dir,"\\"
            rec_tree_traverse(file_or_dir, indent*2)

        if os.path.isfile(file_or_dir):
            #print "file : ",
            print indent, file_or_dir

    #end if for loop
#end of traverse_tree()

def main():

    base_dir = _CURRENT_DIR

    rec_tree_traverse(base_dir," ")

    raw_input("enter any key to exit....")
#end of main()


if __== '__main__':
    main()

Während os.listdir() für das Generieren einer Liste von Datei- und Verzeichnisnamen geeignet ist, möchten Sie häufig mehr, wenn Sie diese Namen haben - und in Python3 macht pathlib diese anderen Aufgaben einfach. Lassen Sie uns einen Blick darauf werfen, ob es Ihnen genauso gut gefällt wie mir.

Um Ihren Inhalt aufzulisten, konstruieren Sie ein Path-Objekt und greifen Sie den Iterator auf:

In [16]: Path('/etc').iterdir()
Out[16]: <generator object Path.iterdir at 0x110853fc0>

Wenn wir nur eine Liste mit Namen von Dingen wollen:

In [17]: [x.name for x in Path('/etc').iterdir()]
Out[17]:
['emond.d',
 'ntp-restrict.conf',
 'periodic',

Wenn Sie nur die Verzeichnisse wollen: 

In [18]: [x.name for x in Path('/etc').iterdir() if x.is_dir()]
Out[18]:
['emond.d',
 'periodic',
 'mach_init.d',

Wenn Sie die Namen aller Conf-Dateien in diesem Baum anzeigen möchten:

In [20]: [x.name for x in Path('/etc').glob('**/*.conf')]
Out[20]:
['ntp-restrict.conf',
 'dnsextd.conf',
 'syslog.conf',

Wenn Sie eine Liste der Conf-Dateien in der Struktur> = 1K erhalten möchten:

In [23]: [x.name for x in Path('/etc').glob('**/*.conf') if x.stat().st_size > 1024]
Out[23]:
['dnsextd.conf',
 'pf.conf',
 'autofs.conf',

Das Auflösen relativer Pfade wird einfach:

In [32]: Path('../Operational Metrics.md').resolve()
Out[32]: PosixPath('/Users/starver/code/xxxx/Operational Metrics.md')

Die Navigation mit einem Pfad ist ziemlich klar (obwohl unerwartet):

In [10]: p = Path('.')

In [11]: core = p / 'web' / 'core'

In [13]: [x for x in core.iterdir() if x.is_file()]
Out[13]:
[PosixPath('web/core/metrics.py'),
 PosixPath('web/core/services.py'),
 PosixPath('web/core/querysets.py'),

Hier ist eine weitere Option.

os.scandir(path='.')

Es gibt einen Iterator von os.DirEntry-Objekten zurück, die den Einträgen (zusammen mit den Dateiattributinformationen) in dem durch path angegebenen Verzeichnis entsprechen. 

Beispiel:

with os.scandir(path) as it:
    for entry in it:
        if not entry.name.startswith('.'):
            print(entry.name)

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 verfügbar machen, 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.

Python-Dokumente

Die eine, die mit mir gearbeitet hat, ist eine modifizierte Version von Salehs Antwort oben.

Der Code lautet wie folgt: 

"dir = 'given_directory_name' Dateinamen = [os.path.abspath (os.path.join (dir, i)) für i in os.listdir (dir)]"

import os, sys

#open files in directory

path = "My Documents"
dirs = os.listdir( path )

# print the files in given directory

for file in dirs:
   print (file)

Unter dem Code werden Verzeichnisse und die Dateien im Verzeichnis aufgelistet

def print_directory_contents(sPath):
        import os                                       
        for sChild in os.listdir(sPath):                
            sChildPath = os.path.join(sPath,sChild)
            if os.path.isdir(sChildPath):
                print_directory_contents(sChildPath)
            else:
                print(sChildPath)

Wenn ich mir gedacht hätte, würde ich das hier reinwerfen.

import re
import os

[a for a in os.listdir(".") if re.search("^.*\.py$",a)]

Zu Ihrer Information Fügen Sie einen Filter für die Erweiterungs- oder Ext-Datei hinzu import os

path = '.'
for dirname, dirnames, filenames in os.walk(path):
    # print path to all filenames with extension py.
    for filename in filenames:
        fname_path = os.path.join(dirname, filename)
        fext = os.path.splitext(fname_path)[1]
        if fext == '.py':
            print fname_path
        else:
            continue

Ich weiß, das ist eine alte Frage. Dies ist eine nette Art, auf die ich gestoßen bin, wenn Sie sich auf einer Liunx-Maschine befinden. 

import subprocess
print(subprocess.check_output(["ls", "/"]).decode("utf8"))