दिलचस्प पोस्ट
मुझे स्मृति बाधा की आवश्यकता क्यों है? मैं "नेटवर्क" समय कैसे प्राप्त कर सकता हूं, ("स्वचालित" सेटिंग से "नेटवर्क-प्रदान किए गए मानों का उपयोग करें" कहलाता है), फोन पर समय नहीं है? एचटीटीपी शरीर से हटाना जावा प्रोग्रामिंग में जावास्क्रिप्ट कैसे चलाना है कस्टम UITabBar पृष्ठभूमि छवि आईओएस 5 और बाद में काम नहीं कर रहा है क्या कार्यात्मक प्रोग्रामिंग गोफ डिजाइन पैटर्न को बदलता है? ऐप सेटिंग्स में स्टोर स्ट्रिंग सरणी? जावास्क्रिप्ट – HTML फॉर्म मूल्य प्राप्त करना एसटीएल में चौड़ी चार रूपांतरण से यूटीएफ 8 स्विफ्ट 3 में गुणों के साथ सिंगलटन इनलाइन तत्वों की चौड़ाई को निर्धारित करना ग्रहण नहीं चला सकते; JVM समाप्त निकास कोड = 13 स्विफ्ट का उपयोग करके किसी श्रेणी में एक यादृच्छिक संख्या कैसे उत्पन्न करें (10 … 20) कोड में स्विच को खत्म करने के तरीके मैं एक पोर्ट से जेटी के लिए https और http को किस प्रकार सेवा देता हूं?

मैं एक निर्देशिका की सभी फाइलों को कैसे सूचीबद्ध करूं?

मैं डायरेक्टरी के सभी फाइलों को पायथन में कैसे सूचीबद्ध कर सकता हूं और उन्हें list जोड़ सकता हूं?

Solutions Collecting From Web of "मैं एक निर्देशिका की सभी फाइलों को कैसे सूचीबद्ध करूं?"

os.listdir() आपको एक निर्देशिका में सभी चीजें प्राप्त करेगा – फ़ाइलें और निर्देशिकाएं

यदि आप केवल फाइल चाहते हैं, तो आप os.path का उपयोग करके इसे नीचे फ़िल्टर कर सकते हैं:

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

या आप os.walk() उपयोग कर सकते हैं जो प्रत्येक निर्देशिका के दौरे के लिए दो सूचियों का लाभ os.walk() – आपके लिए फाइल और डीआईआर में विभाजित। यदि आप केवल शीर्ष निर्देशिका चाहते हैं तो आप पहली बार इसे पैदा कर सकते हैं

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

और अंत में, उस उदाहरण से पता चलता है, एक सूची को दूसरे में जोड़कर आप या तो उपयोग कर सकते हैं। .extend() या

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

निजी तौर पर, मैं पसंद करता .extend()

मैं glob मॉड्यूल का उपयोग करना पसंद करता हूं, क्योंकि यह पैटर्न मिलान और विस्तार करता है।

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

पूछताछ फ़ाइलों के साथ एक सूची वापस करेगा:

 ['/home/adam/file1.txt', '/home/adam/file2.txt', .... ] 
 import os os.listdir("somedirectory") 

सभी फाइलों और निर्देशिकाओं की एक सूची "सोमेडरीरीरी" में वापस करेगा

वर्तमान निर्देशिका की फ़ाइलों के साथ एक सूची कैसे प्राप्त करें – पायथन 3

यदि आप किसी विशेष निर्देशिका में खोजना चाहते हैं, तो उसे listdir विधि का एक तर्क के रूप में रखें।

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

वर्तमान निर्देशिका की फ़ाइलों के साथ एक सूची कैसे प्राप्त करें – पायथन 2

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

ओएस वाॉक ('।' के साथ) कैसे बस वर्तमान निर्देशिका में

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

मौजूदा डीआईआर में फाइलों का पूरा पथ प्राप्त करने के लिए तेज़ तरीका

 >>> import os >>> path = os.getcwd() >>> arr = [] >>> for files in next(os.walk(path))[2]: >>> arr.append(path + "\\" + files) ... >>> for files in arr: >>> print(files) ... F:\_moduli_economia\5bs_Turismo1.pdf F:\_moduli_economia\5bs_Turismo1.pptx F:\_moduli_economia\esperienza.txt 

एक गहरी देखो: पायथन 2 और 3 में फ़ाइलों की सूची कैसे प्राप्त करें?

यहां इस बात की एक सूची दी गई है कि मैंने इस उत्तर में क्या बताया:

  1. ओएस। पायथन 3 के लिए listdir ()
    • 1.1 – केवल txt फ़ाइलों का चयन करने के लिए सूची समझ का उपयोग करें
    • 1.2 – ओएस का उपयोग करना पथ । सूची में निर्देशिका से बचने के लिए
  2. pathlib
  3. ओएस। चलना ()
  4. ओएस। स्कैंडर ()
  5. अजगर 2 (OS listdir ())
    • 4.1 – अजगर 2.7 – ओएस चलना ('।')
    • ओएस के इस्तेमाल का उदाहरण चलना ('।') गिनती करने के लिए कि कितनी फाइलें निर्देशिका और उसकी उपनिर्देशिका में हैं (अजगर 3.5 और 2.7 के लिए)
    • ग्लोब का उपयोग करना
    • बोनस: एक प्रकार की फाइलों की खोज करें और उन्हें डीआईआर में कॉपी करें

    • 1. os.listdir () (3 अजगर)


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

      1.1 – केवल txt फ़ाइलों का चयन करने के लिए सूची समझ का उपयोग करें

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

      1.2 – सूची में निर्देशिकाओं से बचने के लिए os.path.isfile का उपयोग करना

       import os.path listOfFiles = [f for f in os.listdir() if os.path.isfile(f)] print(listOfFiles) 

      उत्पादन

      यहां केवल फाइलें हैं

      ['एक सरल game.py', 'data.txt', 'decorator.py', 'deep_reverse_list.py', 'deep_reverse_list2.py', 'hangman.py', 'आयात करें pygame.py', 'list_click_display.py ',' os_path.py ']


      2. पायथन 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 

      यदि आप सूची समझ का उपयोग करना चाहते हैं

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

      3. पायथन 3.5 (और 2.7) [ओएस वॉकल]


      सबडिरेक्टरीरी में सभी फाइलों को शामिल करने के लिए (इस उदाहरण में पहली निर्देशिका में 11 फ़ाइलें और एक उपनिर्देशिका में 3) मैं ओएसवॉक () का उपयोग करेगा जो अजगर 3.5 और नए संस्करणों में बेचा जाता है:

       import os x = [i[2] for i in os.walk('.')] y=[] for t in x: for f in t: y.append(f) print(y) # print y # for 2.7 uncomment this and comment the previous line 

      उत्पादन

      ['append_to_list.py', 'data.txt', 'data1.txt', 'data2.txt', 'डेटा_180617', 'os_walk.py', 'READ2.py', 'read_data.py', 'somma_defaltdic। py ',' substitute_words.py ',' sum_data.py ',' data.txt ',' data1.txt ',' data_180617 ']

      – केवल अगले फाइलें प्राप्त करें और एक निर्देशिका में चलें

       >>> import os >>> next(os.walk('F://python'))[2] # for the current dir use ('.') ['calculator.bat','calculator.py'] 

      – अगले निर्देशिका के साथ केवल निर्देशिकाएं प्राप्त करें और एक निर्देशिका में चलें

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

      – अगले के साथ रूट प्राप्त करें और एक निर्देशिका में चलें

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

      4. ओएससीसीडीर () अजगर 3.5 से


       >>> import os >>> x = [f.name for f in os.scandir() if f.is_file()] >>> x ['calculator.bat','calculator.py'] 

      स्कैंडिअर के साथ एक और उदाहरण (docs.python.org से थोड़ा भिन्नता) यह एक oslistdir से अधिक कुशल है। इस स्थिति में, यह केवल मौजूदा निर्देशिका में फ़ाइलें दिखाती है जहां स्क्रिप्ट निष्पादित होती है।

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

      5. पायथन 2


      अजगर 2 में वर्तमान कार्य निर्देशिका प्राप्त करने के लिए getcwd () का उपयोग करें (या ('।'))

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

      डायरेक्टरी ट्री में जाने के लिए, आपको इस तरह से कोड मिला:

       >>> for f in os.listdir('..'): ... print f >>> for f in os.listdir('/'): ... print f 

      पूर्ण पथ के साथ फाइलों की सूची

      यह पायथन 3 (मुद्रण को छोड़कर) के समान है

       >>> x = os.listdir('F:/python') >>> for files in x: >>> print files ... $RECYCLE.BIN work.txt 3ebooks.txt documents 

      5.1 – अजगर 2 – ओस्वाक ('।')

      चलो चलने के साथ अजगर 2.7 के लिए उदाहरण बनाओ (अजगर 3 के समान)

       >>> def getAllFiles(dir): ... """Get all the files in the dir and subdirs""" ... allfiles = [] ... for pack in os.walk(dir): ... for files in pack[2]: ... if os.path.isfile(files): ... allfiles += [files] ... return allfiles ... >>> getAllFiles("F://python") ['first.py', 'Modules.txt', 'test4Console.py', 'text4Console.bat', 'tkinter001.py'] 

      6. पायथन 3.5 और 2.7 के लिए ओस्वाक ('।') के उपयोग का उदाहरण

      इस उदाहरण में, हम उन फाइलों की संख्या की खोज करते हैं जो सभी निर्देशिका में शामिल होती हैं और इसके उप-डाइरेक्टरी

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

      उत्पादन

      'एफ: \\ अजगर': 12057 फाइलें '

      7. ग्लोब का उपयोग करना

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

      8. बोनस: फाइल ढूंढें और उन्हें गंतव्य पर प्रतिलिपि करें

      एक छोटी सी स्क्रिप्ट जो कुछ सिक्योरिटीज के सभी उप-डायरेक्टरीज़ में खोज करती है (मैं उन लोगों को चुनता हूं जिन पर शुरुआत में एक अज्ञात चिह्न है), सभी प्रकार की फाइलें (पीडीएफ या पीपीटीपी या टेक्सटाइल ईसीसी।) लेती हैं, एएमडी उन्हें गंतव्य निर्देशिका में प्रतिलिपि बनाता है यह उपयोगी है यदि आपने बहुत सी उपनिर्देशिका बनाई है और आप अपनी सारी चीजों को देखने के लिए चाहते हैं … चलो यह कहने के लिए कि आप उस फ़ाइल या दूसरे को छोड़कर कहें तो प्रस्तुतीकरण, एक जगह में। मैं चाहता हूं कि आपको यह उपयोगी लगे। मैं अपने स्वयं के प्रयोजनों के लिए इस्तेमाल किया

       import os import shutil from path import path destination = "F:\\pptx_copied" # os.makedirs(destination) def copyfile(dir, filetype='pptx', counter=0): "Searches for pptx (or other) 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') 

      उत्पादन

       _compiti18\Compito Contabilità 1\conti.txt _compiti18\Compito Contabilità 1\modula4.txt _compiti18\Compito Contabilità 1\moduloa4.txt _compiti18\ottobre\3acc\compito.txt _compiti18\ottobre\3acc\compito1530.txt _compiti18\ottobre\3acc\compito1530_correttore.txt _compiti18\ottobre\3acc\compito3825.txt _compiti18\ottobre\3acc\compito3825_correttore.txt _compiti18\ottobre\3acc\compito6028.txt ------------------------ ==> Found in: `_compiti18` : 9 files 

      केवल एक फाइल का सूची पाने के लिए एक-लाइन समाधान (कोई उपनिर्देशिका नहीं):

       filenames = next(os.walk(path))[2] 

      या पूर्ण पथ नाम:

       paths = [os.path.join(path,fn) for fn in next(os.walk(path))[2]] 

      एक निर्देशिका और उसके सभी उप-निर्देशिकाओं से पूर्ण फ़ाइल पथ प्राप्त करना

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

      • उपर्युक्त कार्य में प्रदान किए गए पथ में 3 फाइल्स हैं- उनमें से दो मूल निर्देशिका में हैं, और दूसरे को एक उपफ़ोल्डर में "SUBFOLDER" कहा जाता है। अब आप ये काम कर सकते हैं:
      • print full_file_paths जो सूची मुद्रित करेगा:

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

      यदि आप चाहें, तो आप सामग्री को खोल सकते हैं और पढ़ सकते हैं, या केवल ".dat" एक्सटेंशन के साथ फाइलों पर ध्यान केंद्रित कर सकते हैं, जैसे नीचे दिए गए कोड में:

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

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

      संस्करण 3.4 के बाद से इसके लिए निर्मित इटरेटर हैं जो os.listdir() से अधिक कुशल होते हैं:

      pathlib : संस्करण 3.4 में नया।

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

      पीईपी 428 के अनुसार, pathlib लाइब्रेरी का उद्देश्य फाइलसिस्टम पथ को संभाल करने के लिए कक्षाओं का एक सरल पदानुक्रम प्रदान करना है और सामान्य ऑपरेशन उपयोगकर्ता उनके ऊपर कार्य करते हैं।

      os.scandir() : संस्करण 3.5 में नया।

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

      नोट करें कि os.walk() os.scandir() बजाय os.scandir() संस्करण 3.5 से उपयोग करते हैं और इसकी गति पीईपी 471 के अनुसार 2-20 बार बढ़ जाती है।

      मैं भी नीचे शैडोरेन्जर की टिप्पणी को पढ़ने की अनुशंसा करते हैं।

      मैं वास्तव में adamk के जवाब पसंद आया, सुझाव है कि आप glob() उपयोग करते हैं, उसी नाम के मॉड्यूल से यह आपको * एस के साथ मिलान करने के लिए पैटर्न की अनुमति देता है

      लेकिन जैसा कि अन्य लोगों ने टिप्पणियों में बताया है, glob() असंगत स्लैश दिशाओं पर फिसल सकता है। इसके साथ मदद करने के लिए, मैं सुझाव देता हूं कि आप os.path मॉड्यूल में join() और expanduser() कार्यों का os.path करें, और शायद os मॉड्यूल में getcwd() फ़ंक्शन भी।

      उदाहरण के रूप में:

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

      उपरोक्त भयानक है – पथ को कठोर कर दिया गया है और यह केवल ड्राइव नाम के बीच और रास्ते में हार्डकोड होने के दौरान केवल विंडोज पर काम करेगा।

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

      उपरोक्त काम बेहतर है, लेकिन यह फ़ोल्डर नाम Users पर निर्भर करता है जो कि अक्सर विंडोज़ में मिलते हैं और अक्सर अन्य ओएस पर नहीं मिलते हैं। यह एक विशिष्ट नाम, 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')) 

      यह सभी प्लेटफार्मों में पूरी तरह से काम करता है

      एक और बढ़िया उदाहरण जो प्लेटफॉर्म पर पूरी तरह से काम करता है और कुछ अलग करता है:

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

      आशा है कि इन उदाहरणों में आपको मानक पायथन लायब्रेरी मॉड्यूल में मिलती-जुलती फ़ंक्शंस की कुछ शक्ति देखने में मदद मिलेगी।

       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 

      लिस्टिंग निर्देशिका सामग्री के लिए आपको os मॉड्यूल का उपयोग करना चाहिए। os.listdir(".") निर्देशिका की सभी सामग्री देता है हम परिणाम पर पुनरावृत्त करें और सूची में जोड़ें।

       import os content_list = [] for content in os.listdir("."): # "." means current directory content_list.append(content) print content_list 
       import os lst=os.listdir(path) 

      oslistdir पथ द्वारा दी गई निर्देशिका में प्रविष्टियों के नाम युक्त एक सूची देता है।

      यदि आप पाइथन के लिए खोज के कार्यान्वयन की तलाश कर रहे हैं , तो यह एक नुस्खा है जो मैं अक्सर उपयोग करता हूं:

       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 

      इसलिए मैंने इसे से बाहर एक पीईपीआई पैकेज बनाया है और एक गीथहब भंडार भी है । मुझे उम्मीद है कि किसी को यह इस कोड के लिए संभावित रूप से उपयोगी पाता है।

      पायथन 3.5 ने निर्देशिका के माध्यम से चलने के लिए नई, तेज़ विधि पेश की – os.scandir()

      उदाहरण:

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

      पूर्ण फ़ाइलपथों की एक सूची को लौटाने, उप-निर्देशिकाओं में पुनर्संरचना नहीं करता है

       L = [os.path.join(os.getcwd(),f) for f in os.listdir('.') if os.path.isfile(os.path.join(os.getcwd(),f))] 

      निर्देशिका में सभी फाइलों की सूची बनाएं:

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

      यहां, आपको एक निर्देशिका में सभी फाइलों की सूची मिलती है

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

      जनरेटर का उपयोग करना

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

      यदि आप प्रदर्शन के बारे में परवाह करते हैं, तो scandir कोशिश scandir , पायथन 2.x के लिए, आपको इसे मैन्युअल रूप से इंस्टॉल करना पड़ सकता है। उदाहरण:

       # 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 

      यह बहुत समय बचाता है जब आपको एक बड़ी डायरेक्टरी स्कैन करने की ज़रूरत होती है, आपको एक बड़ी सूची बफर करने की ज़रूरत नहीं है, सिर्फ एक के बाद एक ले आओ। और आप इसे लगातार पुन: कर सकते हैं:

       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 

      यदि आप अलग फ़ाइल प्रकार चाहते हैं या पूर्ण निर्देशिका प्राप्त करें, तो इस फ़ंक्शन का उपयोग करें।

       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 

      os पुस्तकालय का उपयोग करके

       import os for root, dirs,files in os.walk("your dir path", topdown=True): for name in files: print(os.path.join(root, name)) 
       import os os.listdir(path) 

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

       filenames = next(os.walk(path))[2] 

      यह केवल उप-डायरेक्ट्रीज़ वाली फ़ाइलों की सूची वापस नहीं करेगा

      @adamk द्वारा जवाब का जिक्र करते हुए, यहां @ एंटी धरती द्वारा स्लेश असंगति टिप्पणी के जवाब में मेरा ओएस डिटेक्शन विधि है I

       import sys import os from pathlib import Path from glob import glob platformtype = sys.platform if platformtype == 'win32': slash = "\\" if platformtype == 'darwin': slash = "/" # TODO: How can I list all files of a directory in Python and add them to a list? # Step 1 - List all files of a directory # Method 1: Find only pre-defined filetypes (.txt) and no subfiles, answer provided by @adamk dir1 = "%sfoo%sbar%s*.txt" % (slash) _files = glob(dir1) # Method 2: Find all files and no subfiles dir2 = "%sfoo%sbar%s" % (slash) _files = (x for x in Path("dir2").iterdir() if x.is_file()) # Method 3: Find all files and all subfiles dir3 = "%sfoo%sbar" % (slash) _files = (x for x in Path('dir3').glob('**/*') if x.is_file()) # Step 2 - Add them to a list files_list = [] for eachfiles in _files: files_basename = os.path.basename(eachfiles) files_list.append(files_basename) 

       print(files_list) ['file1.txt', 'file2.txt', .... ] 

      मैं मान रहा हूँ कि आप केवल सूची में मूल नाम चाहते हैं।

      विधि 1 के लिए कई फ़ाइल स्वरूपों को पूर्व-परिभाषित करने के लिए इस पोस्ट का संदर्भ लें

      ये रहा एक सरल उदाहरण:

       import os root, dirs, files = next(os.walk('.')) for file in files: print(file) # In Python 3 use: file.encode('utf-8') in case of error. 

      नोट: बदलें अपने पथ मूल्य या चर के लिए

      पूर्ण पथ के साथ फ़ाइलों की सूची लौटने का उदाहरण यहां दिया गया है:

       import os path = '.' # Change this as you need. abspaths = [] for fn in os.listdir(path): abspaths.append(os.path.abspath(os.path.join(path, fn))) print("\n".join(abspaths)) 

      प्रलेखन: पायथन 2 के लिए os और os . os.path , पायथन 3 के लिए os और os

       ls -a 

      यह छिपी सामान भी सूचीबद्ध करेगा I