Gids-boom notering in Python

Question

Hoe kry ek 'n lys van al die lêers (en dopgehou) in 'n gegewe gids in Python?

Answer 1

Dit is 'n manier om elke lêer en gids in 'n gids boom deurkruis:

import os

for dirname, dirnames, filenames in os.walk('.'):
    # print path to all subdirectories first.
    for subdirname in dirnames:
        print(os.path.join(dirname, subdirname))

    # print path to all filenames.
    for filename in filenames:
        print(os.path.join(dirname, filename))

    # Advanced usage:
    # editing the 'dirnames' list will stop os.walk() from recursing into there.
    if '.git' in dirnames:
        # don't go into any .git directories.
        dirnames.remove('.git')

Answer 2

Jy kan gebruik

os.listdir(path)

Vir verwysing en meer os funksies kyk hier:

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

Answer 3

Hier is 'n helper funksie Ek gebruik dikwels:

import os

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

Answer 4

import os

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

Answer 5

As jy globbing vermoëns nodig het, is daar 'n module vir wat as goed. Byvoorbeeld:

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

sal so iets terug te keer:

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

Sien die dokumentasie hier .

Answer 6

Probeer hierdie:

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

Answer 7

Vir lêers in die huidige werk gids sonder vermelding van 'n pad

Python 2.7:

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

Python 3.x:

import os
os.listdir()

Danksy Afdeling Kaly vir kommentaar op luislang 3.x

Answer 8

'n rekursiewe implementering

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)

Answer 9

Ek het 'n lang weergawe, met al die opsies wat ek dalk nodig: http: // sam.nipl.net/code/python/find.py

Ek dink dit sal ook hier inpas:

#!/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 __name__ == "__main__":
    test(*sys.argv[1:])

Answer 10

'n lekker een sak om die lêers rekursief lys net. Ek gebruik dit in my setup.py package_data aanwysing:

import os

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

Ek weet dit is nie die antwoord op die vraag, maar kan handig te pas kom

Answer 11

Vir Python 2

#!/bin/python2

import os

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

Vir Python 3

Vir filter en kaart, moet jy draai dit met lys ()

#!/bin/python3

import os

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

Die aanbeveling is nou dat jy jou gebruik van kaart te vervang en te filtreer met kragopwekkers uitdrukkings of lys begripstoetse:

#!/bin/python

import os

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

Answer 12

Hier is 'n een lyn Pythonic weergawe:

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

Dit kode bevat die volledige pad van al die lêers en gidse in die gegewe gids naam.

Answer 13

Hier is 'n ander opsie.

os.scandir(path='.')

Dit gee 'n iterator van os.DirEntry voorwerpe wat ooreenstem met die inskrywings (saam met lêer kenmerk inligting) in die gids gegee deur pad.

Voorbeeld:

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

Die gebruik van scandir () in plaas van listdir () kan aansienlik verhoog die werkverrigting van kode wat ook nodig lêertipe of lêer kenmerk inligting , want os.DirEntry voorwerpe blootstel hierdie inligting as die bedryfstelsel bied dit wanneer die skandering van 'n gids. Alle os.DirEntry metodes kan 'n stelsel oproep, maar is_dir () en is_file () uit te voer gewoonlik net 'n stelsel oproep vir simboliese skakels vereis; os.DirEntry.stat () vereis altyd 'n stelsel 'n beroep op Unix maar vereis net een vir simboliese skakels op Windows.

Python Dokumente

Answer 14

#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 __name__ == '__main__':
    main()

Answer 15

FYI Voeg 'n filter van uitbreiding of ext lêer     invoer 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

Answer 16

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)

Answer 17

As gedink ek wil hierdie gooi in. Eenvoudige en vuil manier om wildcard soektogte doen.

import re
import os

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

Answer 18

Hier kode dopgehou en die lêers sal 'n lys van binne die r

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)

Answer 19

Ek weet dit is 'n ou vraag. Dit is 'n netjiese manier wat ek afgekom as jy op 'n liunx masjien.

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

Answer 20

Die een saam met my is 'n soort van 'n aangepaste weergawe van Saleh beantwoord hierbo.

Die kode is soos volg:

"dir =" given_directory_name 'lêername = [os.path.abspath (os.path.join (r, i)) vir i in os.listdir (r)] "

Answer 21

Hoewel os.listdir() is goed vir die opwekking van 'n lys van lêer en rig name, dikwels jy wil meer doen wanneer jy die name - en in Python3, pathlib maak die ander take eenvoudig. Kom ons neem 'n blik en sien as jy dit wil hê soveel as wat ek doen.

Om 'n lys rig inhoud, bou 'n pad voorwerp en gryp die iterator:

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

As ons wil net 'n lys van name van dinge:

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

As jy wil net die dirs:

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

As jy wil hê dat die name van al conf lêers in daardie boom:

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

As jy wil 'n lys van conf lêers in die boom> = 1K:

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

Die oplossing van relatiewe paaie word maklik:

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

Navigasie met 'n pad is redelik duidelik (hoewel onverwagte):

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