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




directory (25)

import os
lst=os.listdir(path)

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

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


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 

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

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

import os
for root, dirs,files in os.walk("your dir path", topdown=True):
    for name in files:
        print(os.path.join(root, 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
os.listdir("somedirectory")

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


मुझे लगता है कि आपकी सभी फाइलें *.txtप्रारूप के हैं, और पथ के साथ निर्देशिका में संग्रहीत हैं data/

कोई निर्देशिका की सभी फाइलों को सूचीबद्ध करने के लिए ग्लोब मॉड्यूल का उपयोग कर सकता है python, और उन्हें fnamesनिम्न तरीके से नामित सूची में जोड़ सकता है:

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

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

import os
from os import path

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

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


मुझे वास्तव में एडम के जवाब पसंद आया, यह सुझाव देते हुए कि आप उसी नाम के मॉड्यूल से 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'))

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


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

यहां मैं एक पुनरावर्ती संरचना का उपयोग करता हूं।


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

मुझे नीचे छायाचित्र की टिप्पणी पढ़ने की भी सलाह दें।


एक पैरामीटर के रूप में निर्देशिका के साथ findfiles () निष्पादित करें और यह इसमें सभी फ़ाइलों की एक सूची वापस कर देगा।

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)

# -** 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 
os.listdir(path)

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

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

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

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

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

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

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

# 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

मैं एक नमूना एक लाइनर प्रदान करूंगा जहां स्रोतपैथ और फ़ाइल प्रकार इनपुट के रूप में प्रदान किया जा सकता है। कोड सीएसवी एक्सटेंशन के साथ फ़ाइल नामों की एक सूची देता है। का प्रयोग करें अगर सभी फाइलों को वापस करने की जरूरत है। यह उपनिर्देशिका को भी पुनरावर्ती स्कैन करेगा।

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

आवश्यकतानुसार फ़ाइल एक्सटेंशन और स्रोत पथ संशोधित करें।


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

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

पायथन 2 और 3 के साथ फाइलों की एक सूची प्राप्त करें

मैंने यहां एक छोटा वीडियो भी बनाया है: पायथन: निर्देशिका में फ़ाइल की सूची कैसे प्राप्त करें

os.listdir ()

या ..... वर्तमान निर्देशिका में सभी फाइलें (और निर्देशिका) कैसे प्राप्त करें (पायथन 3)

पायथन 3 में वर्तमान निर्देशिका में फ़ाइल रखने का सबसे आसान तरीका यह है। यह वास्तव में सरल है; os मॉड्यूल और listdir () फ़ंक्शन का उपयोग करें और आपके पास उस निर्देशिका में फ़ाइल होगी (और निर्देशिका में मौजूद अंतिम फ़ोल्डर्स, लेकिन आपके पास उपनिर्देशिका में फ़ाइल नहीं होगी, जिसके लिए आप चल सकते हैं - I will बाद में इसके बारे में बात करें)।

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

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

मैंने ग्लोब को एक ही प्रकार की फ़ाइल या सामान्य में कुछ चुनने के लिए आसान पाया। निम्नलिखित उदाहरण देखें:

import glob

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

सूची समझ का उपयोग करना

import glob

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

Os.path.abspath के साथ पूरा पथ नाम प्राप्त करना

जैसा कि आपने देखा है, आपके पास उपरोक्त कोड में फ़ाइल का पूरा पथ नहीं है। यदि आपको पूर्ण पथ प्राप्त करने की आवश्यकता है, तो आप os.path मॉड्यूल नामक _getfullpathname मॉड्यूल के किसी अन्य फ़ंक्शन का उपयोग कर सकते हैं, जिसे आप os.listdir() से एक तर्क के रूप में प्राप्त करते हैं। पूर्ण पथ रखने के अन्य तरीके हैं, क्योंकि हम बाद में जांच करेंगे (मैंने बदल दिया है, जैसा कि मेक्सिको द्वारा सुझाया गया है, absfath के साथ abspath )।

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

चलने के साथ सभी उपनिर्देशिकाओं में फ़ाइल के प्रकार का पूरा पथ नाम प्राप्त करें

मुझे कई निर्देशिकाओं में सामान खोजने के लिए यह बहुत उपयोगी लगता है, और इससे मुझे एक फ़ाइल खोजने में मदद मिली जिसके बारे में मुझे नाम याद नहीं आया:

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 (): वर्तमान निर्देशिका में फ़ाइलें प्राप्त करें (पायथन 2)

पाइथन 2 में, यदि आप वर्तमान निर्देशिका में फ़ाइलों की सूची चाहते हैं, तो आपको तर्क '।' os.getcwd () os.listdir विधि में।

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

निर्देशिका पेड़ में जाने के लिए

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

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

फाइलें प्राप्त करें: os.listdir () किसी विशेष निर्देशिका में (पायथन 2 और 3)

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

Os.listdir () के साथ किसी विशेष उपनिर्देशिका की फ़ाइलें प्राप्त करें

import os

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

os.walk ('।') - वर्तमान निर्देशिका

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

ग्लोब मॉड्यूल - सभी फाइलें

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

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

अगला (os.walk ('।')) और 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

अगला (os.walk ('एफ: \') - पूर्ण पथ - सूची समझ प्राप्त करें

>>> [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 - पूरा पथ प्राप्त करें - उप डीआईआरएस में सभी फाइलें

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 () - केवल txt फ़ाइलों को प्राप्त करें

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

ग्लोब - केवल txt फ़ाइलों को प्राप्त करें

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

फ़ाइलों का पूरा पथ प्राप्त करने के लिए ग्लोब का उपयोग करना

अगर मुझे फाइलों के पूर्ण पथ की आवश्यकता होनी चाहिए:

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

ग्लोब का अन्य उपयोग

अगर मैं निर्देशिका में सभी फाइलों को चाहता हूं:

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

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

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

पाथलिब का उपयोग करना (पायथन 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()]

* आप pathlib.Path ("।") के बजाय सिर्फ pathlib.Path () का भी उपयोग कर सकते हैं।

Pathlib.Path () में ग्लोब विधि का प्रयोग करें

import pathlib

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

उत्पादन:

stack_overflow_list.py
stack_overflow_list_tkinter.py

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

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

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

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

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

चलने के साथ सभी subdir नाम प्राप्त करें

>>> 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 () पायथन 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
>>>

पूर्व। 1: उपनिर्देशिका में कितनी फाइलें हैं?

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

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'

Ex.2: निर्देशिका से सभी फ़ाइलों को दूसरी निर्देशिका में कैसे कॉपी करें?

आपके कंप्यूटर में ऑर्डर करने के लिए एक स्क्रिप्ट एक प्रकार की सभी फाइलें (डिफ़ॉल्ट: पीपीटीएक्स) ढूंढ रही है और उन्हें एक नए फ़ोल्डर में कॉपी कर रही है।

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

पूर्व। 3: सभी फ़ाइलों को एक txt फ़ाइल में कैसे प्राप्त करें

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

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

उदाहरण: हार्ड ड्राइव की सभी फाइलों के साथ txt

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

एक पाठ फ़ाइल में सी: \\ की सभी फाइलें

यह पिछले कोड का एक छोटा संस्करण है। यदि आपको किसी अन्य स्थिति से प्रारंभ करने की आवश्यकता है तो फ़ाइलों को ढूंढना शुरू करने के लिए फ़ोल्डर को बदलें। यह कोड मेरे कंप्यूटर पर टेक्स्ट फ़ाइल पर 50 एमबी उत्पन्न करता है, जिसमें पूर्ण पथ वाले फाइलों के साथ 500,000 लाइनें कम होती हैं।

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

एक निश्चित प्रकार की फ़ाइल खोजने के लिए एक फ़ंक्शन

आयात ओएस

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

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

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

यह पूछे जाने वाले फाइलों के साथ एक सूची वापस करेगा:

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

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

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 फाइलें हैं- उनमें से दो मूल निर्देशिका में हैं, और दूसरा उप-फ़ोल्डर में "सबफ़ोल्डर" कहा जाता है। अब आप चीजें कर सकते हैं जैसे:
  • 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


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

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

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


पायथन 3.4+ के लिए एक और बहुत पठनीय संस्करण pathlib.Path.glob का उपयोग कर रहा है:

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

अधिक विशिष्ट बनाना आसान है, उदाहरण के लिए केवल पाइथन स्रोत फ़ाइलों की तलाश करें जो प्रतीकात्मक लिंक नहीं हैं, सभी उपनिर्देशिकाओं में भी:

import os
[f for f in os.listdir(os.getcwd) if ...]

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

import os

content_list = []

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

print content_list

पायथन 3.4 में भाषा फाइलों को प्रबंधित करने के लिए एक नया मॉड्यूल प्रदान करती है:

import pathlib
path = pathlib.Path('path/to/file')
if path.is_file(): # If you want to check a directory: path.is_dir()
    # If it is true, return true on your code.




python directory