572

पायथन में दी गई डायरेक्टरी में मुझे सभी फाइलों (और निर्देशिकाओं) की सूची कैसे मिलेगी?

— मैट
स्रोत

615

यह एक डायरेक्टरी ट्री में हर फाइल और डायरेक्टरी को ट्रेस करने का एक तरीका है:

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

— Jerub
स्रोत

19

और अगर आप पायथन शेल से इस कोड (जैसा है) को चलाते हैं, तो याद रखें कि Ctrl + C उक्त शेल में आउटपुट को रोक देगा। ;)

— गैरी

41

यह फ़ाइलों और निर्देशिकाओं की पुनरावर्ती सूची देगा

— rds

आप इसे कुछ रास्तों को फिर से शुरू करने से रोकने के लिए dirnames सूची को संपादित भी कर सकते हैं।

— बुगलाफ

8

@ क्लेमेंट "जब टॉपडाउन सही होता है, तो कॉल करने वाला डायरनेम सूची को इन-प्लेस (शायद डेल या स्लाइस असाइनमेंट का उपयोग करके) संशोधित कर सकता है, और वॉक () केवल उन सबडायरेक्टरीज में फिर से आ जाएगा, जिनके नाम डायरैम्स में रहते हैं; इसका इस्तेमाल प्रून करने के लिए किया जा सकता है। खोज, आने का एक विशिष्ट क्रम लागू करें, या यहां तक कि चलने के बारे में सूचित करने के लिए (फिर से चलने से पहले) कॉल करने वाले का नाम बनाता है या नाम बदल देता है। " से docs.python.org/2/library/os.html#os.walk

— bugloaf

कुछ निर्देशिकाओं को नजरअंदाज करने का सबसे सरल तरीका उन्हें पहली जगह में dirnames में शामिल नहीं करना हैfor subdirname in dirnames: if subdirname != '.git'

— smci

537

आप उपयोग कर सकते हैं

os.listdir(path)

संदर्भ और अधिक ओएस कार्यों के लिए यहां देखें:

अजगर 2 डॉक्स: https://docs.python.org/2/library/os.html#os.listdir
पायथन 3 डॉक्स: https://docs.python.org/3/library/os.html#os.listdir

— rslite
स्रोत

1

अच्छी तरह से मूल सवाल सिर्फ इतना अस्पष्ट है कि वे एक पुनरावर्ती समाधान चाहते थे या नहीं। "एक निर्देशिका में सभी फाइलें" को पुनरावर्ती के रूप में व्याख्या की जा सकती है।

— टॉमी

3

@ टॉमी, एक "निर्देशिका" एक स्पष्ट रूप से परिभाषित डेटा संरचना है, और यह "एलएस-आर" के बजाय "एलएस" को संदर्भित करता है। इसके अलावा, लगभग सभी UNIX उपकरण डिफ़ॉल्ट रूप से पुनरावर्ती रूप से काम नहीं करते हैं। मुझे नहीं पता कि प्रश्नकर्ता का क्या मतलब है लेकिन उसने जो लिखा वह स्पष्ट था।

— टॉरस्टेन ब्रॉन्जर

अजगर 3 डॉक्स आपको os.scandirइसके बजाय उपयोग करने के लिए कहता है , क्योंकि कई मामलों में यह आपको सिस्टम कॉल को रोकने की अनुमति देता है, जिससे एक मुफ्त स्पीडअप (आईपीसी और आईओ दोनों धीमा होते हैं)।

— जप्पी केर्क

5

listdir आपको निर्देशिका में केवल फ़ाइल नाम देता है, क्या पूर्ण पथ प्राप्त करने के लिए कोई विधि उपलब्ध है?

— 21

1

@greperror आप उपयोग कर सकते हैं os.path.abspath पूर्ण पथ प्राप्त करने के लिए। इसके अलावा, यह जांचने के लिए कि क्या दिया गया पथ एक फ़ाइल है, os.path.isfile का उपयोग करें या os.path.isdir।

— अलेक्जेंडार

111

यहाँ एक सहायक कार्य है जिसका मैं काफी बार उपयोग करता हूँ:

import os

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

— giltay
स्रोत

3

एक जनरेटर बेहतर होगा।

— रॉबर्ट सिएमर

1

@RobertSiemer जो उपयोग पर निर्भर करता है। कई मामलों में, एक सूची बेहतर होगी, लेकिन मुझे लगता है कि एक जनरेटर अधिक बहुमुखी है क्योंकि इसे सूची में परिवर्तित किया जा सकता है। यह इस बात पर निर्भर करता है कि आप तलाश कर रहे हैं, बहुमुखी प्रतिभा या कुछ और अधिक सुव्यवस्थित।

— जेम्स मचघ

3

यह दस साल हो गया है, लेकिन मुझे लगता है कि मैंने इसे इस तरह से किया क्योंकि os.listdir () एक सूची देता है और मैं इसकी नकल कर रहा था।

— गिल्ट

82

import os

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

— curtisk
स्रोत

16

r'C:\temp'स्पष्ट है और "C:\\temp"रॉस्ट्रिंग के लिए पसंदीदा बैकस्लैश को बचाना बेहतर है।

— मुस्कान

13

यदि आपको ग्लोबिंग क्षमताओं की आवश्यकता है, तो इसके लिए एक मॉड्यूल भी है। उदाहरण के लिए:

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

कुछ इस तरह लौटेगा:

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

दस्तावेज़ यहाँ देखें ।

— केनी
स्रोत

10

इसे इस्तेमाल करे:

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

— paxdiablo
स्रोत

एक पंक्ति में: [top + os.sep + f for top, dirs, files in os.walk ('' ./ ') f में फाइलों के लिए]

— जे। पीटरसन

9

एक पथ निर्दिष्ट किए बिना वर्तमान कार्य निर्देशिका में फ़ाइलों के लिए

पायथन 2.7:

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

अजगर 3.x:

import os
os.listdir()

अजगर 3.x पर टिप्पणी के लिए स्टैम काल के लिए धन्यवाद

— डेव इंजीनियर
स्रोत

5

os.listdir()डिफ़ॉल्ट रूप से वर्तमान निर्देशिका में तत्वों को सूचीबद्ध करता है! तो इसके लिए कोई आवश्यकता नहीं है os.getcwd():)

— स्टैम कालि

यह मैं कैसे करूंगा? जब मैं किसी तर्क के बिना >>> os.listdir () का उपयोग करता हूं तो मुझे टाइप करें: TypeError: listdir () बिल्कुल 1 तर्क (0 दिया गया) लेता है

— डेव इंजीनियर

2

मुझे लगता है कि आप 2.7 पर चल रहे हैं। यह 3.x

— स्टैम कालि

5

एक पुनरावर्ती कार्यान्वयन

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)

— अर्नाल्डो पी। फिगुएरा फिग्यूइरा
स्रोत

3

मैंने एक लंबा संस्करण लिखा, मेरे लिए सभी विकल्पों की आवश्यकता हो सकती है: http://sam.nipl.net/code/python/find

मुझे लगता है कि यह यहाँ भी फिट होगा:

#!/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:])

— सैम वॉटकिंस
स्रोत

3

यहाँ एक और विकल्प है।

os.scandir(path='.')

यह पथ के द्वारा दी गई निर्देशिका में प्रविष्टियों (फ़ाइल विशेषता जानकारी के साथ) के अनुरूप os.DirEntry वस्तुओं का एक पुनरावर्तक लौटाता है।

उदाहरण:

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

श्रोता () के बजाय स्कैंडिर () का उपयोग करने से कोड के प्रदर्शन में काफी वृद्धि हो सकती है जिसे फ़ाइल प्रकार या फ़ाइल विशेषता जानकारी की भी आवश्यकता होती है , क्योंकि os.DirEntry ऑब्जेक्ट इस जानकारी को उजागर करते हैं यदि ऑपरेटिंग सिस्टम एक निर्देशिका को स्कैन करते समय प्रदान करता है। सभी os.DirEntry विधियाँ एक सिस्टम कॉल कर सकती हैं, लेकिन is_dir () और is_file () आमतौर पर केवल प्रतीकात्मक लिंक के लिए सिस्टम कॉल की आवश्यकता होती है; os.DirEntry.stat () को हमेशा यूनिक्स पर एक सिस्टम कॉल की आवश्यकता होती है, लेकिन केवल विंडोज पर प्रतीकात्मक लिंक के लिए एक की आवश्यकता होती है।

पायथन डॉक्स

— Khaino
स्रोत

3

जबकि os.listdir()फ़ाइल और dir नामों की सूची पैदा करने के लिए ठीक है, अक्सर आप एक बार आप उन नामों है अधिक करने के लिए चाहते हैं - और python3 में, pathlib उन अन्य काम सरल बनाता है। आइए एक नज़र डालते हैं और देखते हैं कि क्या आप इसे पसंद करते हैं जितना मैं करता हूं।

डीआईआर सामग्री को सूचीबद्ध करने के लिए, एक पथ वस्तु का निर्माण करें और पुनरावृत्ति को पकड़ो:

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

अगर हम केवल चीजों के नामों की एक सूची चाहते हैं:

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

यदि आप सिर्फ डायर चाहते हैं:

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

यदि आप उस पेड़ की सभी फाइलों के नाम चाहते हैं:

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

यदि आप पेड़ में conf फाइलों की सूची चाहते हैं> = 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',

रिश्तेदार पथ को हल करना आसान हो जाता है:

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

एक पथ के साथ नेविगेट करना बहुत स्पष्ट है (हालांकि अप्रत्याशित है):

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

— स्टीव तारवर
स्रोत

1

एक अच्छा एक लाइनर केवल फ़ाइलों को पुनरावर्ती रूप से सूचीबद्ध करने के लिए। मैंने इसे अपने setup.py package_data निर्देश में उपयोग किया है:

import os

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

मुझे पता है कि यह सवाल का जवाब नहीं है, लेकिन काम आ सकता है

— fivetentaylor
स्रोत

1

अजगर 2 के लिए

#!/bin/python2

import os

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

पायथन 3 के लिए

फ़िल्टर और मानचित्र के लिए, आपको उन्हें सूची () के साथ लपेटने की आवश्यकता है

#!/bin/python3

import os

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

अब अनुशंसा यह है कि आप अपने नक्शे का उपयोग करें और जनरेटर के भावों या सूची की समझ के साथ फ़िल्टर करें:

#!/bin/python

import os

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

— एलेजांद्रो ब्लास्को
स्रोत

1

यहाँ एक पंक्ति पायथनिक संस्करण है:

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

यह कोड दी गई निर्देशिका नाम में सभी फाइलों और निर्देशिकाओं का पूरा मार्ग सूचीबद्ध करता है।

— salehinejad
स्रोत

थैंक्स सालेह, लेकिन आपके कोड ने पूरी तरह से काम नहीं किया, और जो काम किया, उसे इस प्रकार संशोधित किया गया: 'dir =' दिए_निर्देश_नाम 'filenames = [os.path.abspath (os.path.join (dir, i) i) के लिए os.listdir (dir)] '

— हसनशाह_3571619

1

मैं जानता हूं कि यह एक पुराना सवाल है। यह एक साफ-सुथरा तरीका है जो मुझे पता चला कि अगर आप एक लूनक्स मशीन पर हैं।

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

— apeter
स्रोत

0

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

— आलोक
स्रोत

5

इस सवाल का पहले से ही एक अच्छा जवाब है, फिर से जवाब देने की आवश्यकता नहीं है

— माइक पेनिंगटन

0

FYI करें एक्सटेंशन या ext फ़ाइल आयात 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

— moylop260
स्रोत

0

अगर मुझे लगा कि मैं इसे फेंक दूंगा। वाइल्डकार्ड खोजों को सरल और गंदा तरीका।

import re
import os

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

— bng44270
स्रोत

0

नीचे दिए गए कोड निर्देशिका और फ़ाइलों को dir के भीतर सूचीबद्ध करेगा

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)

— हेनाश्री खंडेलवाल
स्रोत

0

मेरे साथ काम करने वाला ऊपर के सालेह उत्तर से एक संशोधित संस्करण है।

कोड इस प्रकार है:

"dir = 'दिए_निर्देश_नाम' फ़ाइलनाम = [os.path.abspath (os.path.join (dir, i)) के लिए i में os.listdir (dir)]"

— HassanSh__3571619
स्रोत

पायथन में डायरेक्टरी-ट्री लिस्टिंग

अजगर 2 के लिए

पायथन 3 के लिए