एक्सटेंशन वाली सभी फाइलों को पायथन में .txt के साथ खोजें

Question

मैं एक निर्देशिका में सभी फाइलों .txtको पायथन में एक्सटेंशन कैसे पा सकता हूं ?

Answer 1

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

import glob, os
os.chdir("/mydir")
for file in glob.glob("*.txt"):
    print(file)

या बस os.listdir:

import os
for file in os.listdir("/mydir"):
    if file.endswith(".txt"):
        print(os.path.join("/mydir", file))

या यदि आप निर्देशिका को पीछे हटाना चाहते हैं, तो उपयोग करें os.walk:

import os
for root, dirs, files in os.walk("/mydir"):
    for file in files:
        if file.endswith(".txt"):
             print(os.path.join(root, file))

Comments

समाधान # 2 का उपयोग करते हुए, आप उस जानकारी के साथ एक फ़ाइल या सूची कैसे बनाएंगे?

— मर्लिन

@ ghostdog74: मेरी राय में इसे और अधिक लिखने के लिए उचित होगा for file in fके लिए की तुलना में for files in fके बाद से क्या चर में है एक भी फ़ाइल नाम है। और भी बेहतर बदलने के लिए किया जाएगा fकरने के लिए filesऔर फिर छोरों के लिए बन सकता है for file in files।

— मार्टिन

@computermacgyver: नहीं, fileएक आरक्षित शब्द नहीं है, बस एक पूर्वनिर्धारित फ़ंक्शन का नाम है, इसलिए इसे अपने स्वयं के कोड में एक चर नाम के रूप में उपयोग करना काफी संभव है। हालांकि यह सच है कि आम तौर पर किसी को इस तरह के टकराव से बचना चाहिए, fileयह एक विशेष मामला है क्योंकि इसका उपयोग करने के लिए शायद ही कभी कोई आवश्यकता होती है, इसलिए इसे अक्सर दिशानिर्देश के अपवाद माना जाता है। यदि आप ऐसा नहीं करना चाहते हैं, तो PEP8 ऐसे नामों से एकल अंडरस्कोर को लागू करने की अनुशंसा करता है, अर्थात file_, जिसे आपको सहमत होना होगा, अभी भी काफी पठनीय है।

— मार्टीन्यू

धन्यवाद, मार्टिन, आप बिल्कुल सही हैं। मैं निष्कर्ष पर बहुत जल्दी कूद गया।

— computermacgyver

# 2 के लिए एक अधिक पायथोनिक तरीका फ़ाइल में [f के लिए os.listdir ('/ mydir') में हो सकता है अगर f.endwith ('txt')):

— ozgur

Answer 2

ग्लोब का प्रयोग करें ।

>>> import glob
>>> glob.glob('./*.txt')
['./outline.txt', './pip-log.txt', './test.txt', './testingvim.txt']

Comments

न केवल यह आसान है, बल्कि यह असंवेदनशील भी है। (कम से कम, यह विंडोज पर है, जैसा कि यह होना चाहिए। मैं अन्य ओएस के बारे में निश्चित नहीं हूं।)

— जॉन कोम्ब्स

सावधान रहें कि यदि आपके अजगर 3.5 वर्ष से कम globनहीं है, तो पुनरावर्ती रूप से फाइलें नहीं पा सकते हैं । अधिक जानकारी

— qun

सबसे अच्छी बात यह है कि आप नियमित अभिव्यक्ति टेस्ट * .txt

— एलेक्स पुन्नन

@ जोंकब्स नोप। कम से कम लिनक्स पर नहीं।

— करुहांगा

Answer 3

कुछ ऐसा काम करना चाहिए

for root, dirs, files in os.walk(directory):
    for file in files:
        if file.endswith('.txt'):
            print file

Comments

के root, dirs, filesबजाय अपने चरों के नामकरण के लिए +1 r, d, f। बहुत अधिक पठनीय।

— क्लेमेंट

ध्यान दें कि यह केस संवेदी (.txt या .txt से मेल नहीं खाएगी) है, तो आप शायद के लिए करना चाहेंगे अगर file.lower () endswith ( 'txt।'):।

— जॉन Coombs

आपका उत्तर उपनिर्देशिका से संबंधित है।

— सैम लियाओ

Answer 4

कुछ इस तरह काम करेगा:

>>> import os
>>> path = '/usr/share/cups/charmaps'
>>> text_files = [f for f in os.listdir(path) if f.endswith('.txt')]
>>> text_files
['euc-cn.txt', 'euc-jp.txt', 'euc-kr.txt', 'euc-tw.txt', ... 'windows-950.txt']

Comments

मैं text_files के लिए रास्ता कैसे बचाऊँगा? [ 'पथ / euc-cn.txt', ... 'पथ / windows-950.txt']

— IceQueeny

आप के os.path.joinप्रत्येक तत्व पर उपयोग कर सकते हैं text_files। यह कुछ इस तरह हो सकता है text_files = [os.path.join(path, f) for f in os.listdir(path) if f.endswith('.txt')]।

— सेठ

Answer 5

आप कर सकते हैं बस उपयोग pathlibरों ¹ :glob

import pathlib

list(pathlib.Path('your_directory').glob('*.txt'))

या एक लूप में:

for txt_file in pathlib.Path('your_directory').glob('*.txt'):
    # do something with "txt_file"

यदि आप इसे पुनरावर्ती चाहते हैं तो आप उपयोग कर सकते हैं .glob('**/*.txt)

---

¹pathlib मॉड्यूल अजगर 3.4 में मानक पुस्तकालय में शामिल किया गया था। लेकिन आप पुराने पाइथन संस्करणों (यानी उपयोग condaया pip): pathlibऔर पर भी उस मॉड्यूल के बैक-पोर्ट स्थापित कर सकते हैं pathlib2।

Comments

**/*.txtपुराने अजगर संस्करणों द्वारा समर्थित नहीं है। क्या मैंने इसके साथ हल किया: foundfiles= subprocess.check_output("ls **/*.txt", shell=True) for foundfile in foundfiles.splitlines(): print foundfile

— रोमन

@ रमन हां, यह सिर्फ एक प्रदर्शन था जो pathlibमैं कर सकता हूं और मैंने पहले से ही पायथन संस्करण आवश्यकताओं को शामिल किया है। :) लेकिन अगर आपका दृष्टिकोण पहले से ही पोस्ट नहीं किया गया है तो इसे केवल दूसरे उत्तर के रूप में क्यों न जोड़ें?

— MSeifert

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

— रोमन

ध्यान दें कि rglobयदि आप पुनरावर्ती रूप से आइटम देखना चाहते हैं, तो आप इसका उपयोग भी कर सकते हैं उदा.rglob('*.txt')

— ब्रैम वानरो

Answer 6

import os

path = 'mypath/path' 
files = os.listdir(path)

files_txt = [i for i in files if i.endswith('.txt')]

Answer 7

मुझे os.walk () पसंद है :

import os

for root, dirs, files in os.walk(dir):
    for f in files:
        if os.path.splitext(f)[1] == '.txt':
            fullpath = os.path.join(root, f)
            print(fullpath)

या जनरेटर के साथ:

import os

fileiter = (os.path.join(root, f)
    for root, _, files in os.walk(dir)
    for f in files)
txtfileiter = (f for f in fileiter if os.path.splitext(f)[1] == '.txt')
for txt in txtfileiter:
    print(txt)

Answer 8

यहाँ उसी के अधिक संस्करण दिए गए हैं जो थोड़ा अलग परिणाम देते हैं:

glob.iglob ()

import glob
for f in glob.iglob("/mydir/*/*.txt"): # generator, search immediate subdirectories 
    print f

glob.glob1 ()

print glob.glob1("/mydir", "*.tx?")  # literal_directory, basename_pattern

fnmatch.filter ()

import fnmatch, os
print fnmatch.filter(os.listdir("/mydir"), "*.tx?") # include dot-files

Comments

जिज्ञासु के लिए, मॉड्यूल glob1()में एक सहायक कार्य है globजो पायथन प्रलेखन में सूचीबद्ध नहीं है। स्रोत फ़ाइल में यह क्या करता है, यह वर्णन करते हुए कुछ इनलाइन टिप्पणियां हैं, देखें .../Lib/glob.py।

— मार्टीन्यू

@martineau: glob.glob1()सार्वजनिक नहीं है लेकिन यह पायथन 2.4-2.7; 3.0-3.2 पर उपलब्ध है; PyPy; jython github.com/zed/test_glob1

— jfs

धन्यवाद, यह एक मॉड्यूल में एक अनिर्दिष्ट निजी समारोह का उपयोग करने का निर्णय लेते समय अच्छी जानकारी है। ;-) यहाँ थोड़ा और अधिक है। पायथन 2.7 संस्करण केवल 12 लाइनों लंबा है और ऐसा लगता है कि इसे आसानी से globमॉड्यूल से निकाला जा सकता है ।

— 0

Answer 9

path.py एक और विकल्प है: https://github.com/jaraco/path.py

from path import path
p = path('/path/to/the/directory')
for f in p.files(pattern='*.txt'):
    print f

Comments

कूल, यह पैटर्न में भी नियमित अभिव्यक्ति को स्वीकार करता है। मैं for f in p.walk(pattern='*.txt')हर सबफ़ोल्डर के माध्यम से जाने का उपयोग कर रहा हूं

— कोस्टानोस

हां वहां पाथलीब भी है। आप कुछ इस तरह कर सकते हैं: list(p.glob('**/*.py'))

— user2233949

Answer 10

पायथन v3.5 +

पुनरावर्ती फ़ंक्शन में os.scandir का उपयोग करते हुए तेज़ विधि। फ़ोल्डर और उप-फ़ोल्डरों में एक निर्दिष्ट एक्सटेंशन के साथ सभी फ़ाइलों की खोज करता है।

import os

def findFilesInFolder(path, pathList, extension, subFolders = True):
    """  Recursive function to find all files of an extension type in a folder (and optionally in all subfolders too)

    path:        Base directory to find files
    pathList:    A list that stores all paths
    extension:   File extension to find
    subFolders:  Bool.  If True, find files in all subfolders under path. If False, only searches files in the specified folder
    """

    try:   # Trapping a OSError:  File permissions problem I believe
        for entry in os.scandir(path):
            if entry.is_file() and entry.path.endswith(extension):
                pathList.append(entry.path)
            elif entry.is_dir() and subFolders:   # if its a directory, then repeat process as a nested function
                pathList = findFilesInFolder(entry.path, pathList, extension, subFolders)
    except OSError:
        print('Cannot access ' + path +'. Probably a permissions error')

    return pathList

dir_name = r'J:\myDirectory'
extension = ".txt"

pathList = []
pathList = findFilesInFolder(dir_name, pathList, extension, True)

अप्रैल 2019 को अपडेट करें

यदि आप उन निर्देशिकाओं को खोज रहे हैं जिनमें 10,000 फाइलें शामिल हैं, तो सूची में जोड़ना अक्षम हो जाता है। 'उपज' परिणाम एक बेहतर समाधान है। मैंने आउटपुट को पंडों के डेटाफ़्रेम में बदलने के लिए एक फ़ंक्शन भी शामिल किया है।

import os
import re
import pandas as pd
import numpy as np


def findFilesInFolderYield(path,  extension, containsTxt='', subFolders = True, excludeText = ''):
    """  Recursive function to find all files of an extension type in a folder (and optionally in all subfolders too)

    path:               Base directory to find files
    extension:          File extension to find.  e.g. 'txt'.  Regular expression. Or  'ls\d' to match ls1, ls2, ls3 etc
    containsTxt:        List of Strings, only finds file if it contains this text.  Ignore if '' (or blank)
    subFolders:         Bool.  If True, find files in all subfolders under path. If False, only searches files in the specified folder
    excludeText:        Text string.  Ignore if ''. Will exclude if text string is in path.
    """
    if type(containsTxt) == str: # if a string and not in a list
        containsTxt = [containsTxt]

    myregexobj = re.compile('\.' + extension + '$')    # Makes sure the file extension is at the end and is preceded by a .

    try:   # Trapping a OSError or FileNotFoundError:  File permissions problem I believe
        for entry in os.scandir(path):
            if entry.is_file() and myregexobj.search(entry.path): # 

                bools = [True for txt in containsTxt if txt in entry.path and (excludeText == '' or excludeText not in entry.path)]

                if len(bools)== len(containsTxt):
                    yield entry.stat().st_size, entry.stat().st_atime_ns, entry.stat().st_mtime_ns, entry.stat().st_ctime_ns, entry.path

            elif entry.is_dir() and subFolders:   # if its a directory, then repeat process as a nested function
                yield from findFilesInFolderYield(entry.path,  extension, containsTxt, subFolders)
    except OSError as ose:
        print('Cannot access ' + path +'. Probably a permissions error ', ose)
    except FileNotFoundError as fnf:
        print(path +' not found ', fnf)

def findFilesInFolderYieldandGetDf(path,  extension, containsTxt, subFolders = True, excludeText = ''):
    """  Converts returned data from findFilesInFolderYield and creates and Pandas Dataframe.
    Recursive function to find all files of an extension type in a folder (and optionally in all subfolders too)

    path:               Base directory to find files
    extension:          File extension to find.  e.g. 'txt'.  Regular expression. Or  'ls\d' to match ls1, ls2, ls3 etc
    containsTxt:        List of Strings, only finds file if it contains this text.  Ignore if '' (or blank)
    subFolders:         Bool.  If True, find files in all subfolders under path. If False, only searches files in the specified folder
    excludeText:        Text string.  Ignore if ''. Will exclude if text string is in path.
    """

    fileSizes, accessTimes, modificationTimes, creationTimes , paths  = zip(*findFilesInFolderYield(path,  extension, containsTxt, subFolders))
    df = pd.DataFrame({
            'FLS_File_Size':fileSizes,
            'FLS_File_Access_Date':accessTimes,
            'FLS_File_Modification_Date':np.array(modificationTimes).astype('timedelta64[ns]'),
            'FLS_File_Creation_Date':creationTimes,
            'FLS_File_PathName':paths,
                  })

    df['FLS_File_Modification_Date'] = pd.to_datetime(df['FLS_File_Modification_Date'],infer_datetime_format=True)
    df['FLS_File_Creation_Date'] = pd.to_datetime(df['FLS_File_Creation_Date'],infer_datetime_format=True)
    df['FLS_File_Access_Date'] = pd.to_datetime(df['FLS_File_Access_Date'],infer_datetime_format=True)

    return df

ext =   'txt'  # regular expression 
containsTxt=[]
path = 'C:\myFolder'
df = findFilesInFolderYieldandGetDf(path,  ext, containsTxt, subFolders = True)

Answer 11

पायथन के पास ऐसा करने के लिए सभी उपकरण हैं:

import os

the_dir = 'the_dir_that_want_to_search_in'
all_txt_files = filter(lambda x: x.endswith('.txt'), os.listdir(the_dir))

Comments

यदि आप एक सूची में all_txt_files चाहते हैं:all_txt_files = list(filter(lambda x: x.endswith('.txt'), os.listdir(the_dir)))

— Ena

Answer 12

पायथोनिक तरीके से सूची के रूप में 'डेटापाथ' फ़ोल्डर के अंदर सभी '.txt' फ़ाइल नाम पाने के लिए:

from os import listdir
from os.path import isfile, join
path = "/dataPath/"
onlyTxtFiles = [f for f in listdir(path) if isfile(join(path, f)) and  f.endswith(".txt")]
print onlyTxtFiles

Answer 13

यह कोशिश करो कि यह आपकी सभी फ़ाइलों को पुन: प्राप्त कर लेगा:

import glob, os
os.chdir("H:\\wallpaper")# use whatever directory you want

#double\\ no single \

for file in glob.glob("**/*.txt", recursive = True):
    print(file)

Comments

पुनरावर्ती संस्करण के साथ नहीं (डबल स्टार:) **। केवल अजगर में उपलब्ध 3. जो मुझे पसंद नहीं है वह chdirहिस्सा है। उसकी कोई ज़रूरत नहीं।

— जीन फ़्राँस्वा Fabre

ठीक है, आप रास्ते में शामिल होने के लिए ओएस लाइब्रेरी का उपयोग कर सकते हैं, उदाहरण के लिए, filepath = os.path.join('wallpaper')और फिर इसका उपयोग करें glob.glob(filepath+"**/*.psd", recursive = True), जो समान परिणाम प्राप्त करेगा।

— मिताली राव

Answer 14

import os
import sys 

if len(sys.argv)==2:
    print('no params')
    sys.exit(1)

dir = sys.argv[1]
mask= sys.argv[2]

files = os.listdir(dir); 

res = filter(lambda x: x.endswith(mask), files); 

print res

Answer 15

मैंने एक परीक्षण (पायथन 3.6.4, W7x64) किया, यह देखने के लिए कि कौन सा समाधान एक फ़ोल्डर के लिए सबसे तेज़ है, कोई उपनिर्देशिका नहीं, एक विशिष्ट एक्सटेंशन के साथ फ़ाइलों के लिए पूर्ण फ़ाइल पथों की सूची प्राप्त करने के लिए।

इसे छोटा करने के लिए, इस कार्य os.listdir()के लिए सबसे तेज़ है और अगले सबसे अच्छे के रूप में 1.7x तेज़ है : os.walk()(एक ब्रेक के साथ!), 2.7x जितना तेज़ pathlib, 3.2x से अधिक os.scandir()और 3.3x तेज़ी से glob।
कृपया ध्यान रखें, कि जब आपको पुनरावर्ती परिणामों की आवश्यकता होगी, तो वे परिणाम बदल जाएंगे। यदि आप नीचे एक विधि कॉपी / पेस्ट करते हैं, तो कृपया .lower () जोड़ें अन्यथा .ext की खोज के दौरान .xt नहीं मिलेगा।

import os
import pathlib
import timeit
import glob

def a():
    path = pathlib.Path().cwd()
    list_sqlite_files = [str(f) for f in path.glob("*.sqlite")]

def b(): 
    path = os.getcwd()
    list_sqlite_files = [f.path for f in os.scandir(path) if os.path.splitext(f)[1] == ".sqlite"]

def c():
    path = os.getcwd()
    list_sqlite_files = [os.path.join(path, f) for f in os.listdir(path) if f.endswith(".sqlite")]

def d():
    path = os.getcwd()
    os.chdir(path)
    list_sqlite_files = [os.path.join(path, f) for f in glob.glob("*.sqlite")]

def e():
    path = os.getcwd()
    list_sqlite_files = [os.path.join(path, f) for f in glob.glob1(str(path), "*.sqlite")]

def f():
    path = os.getcwd()
    list_sqlite_files = []
    for root, dirs, files in os.walk(path):
        for file in files:
            if file.endswith(".sqlite"):
                list_sqlite_files.append( os.path.join(root, file) )
        break



print(timeit.timeit(a, number=1000))
print(timeit.timeit(b, number=1000))
print(timeit.timeit(c, number=1000))
print(timeit.timeit(d, number=1000))
print(timeit.timeit(e, number=1000))
print(timeit.timeit(f, number=1000))

परिणाम:

# Python 3.6.4
0.431
0.515
0.161
0.548
0.537
0.274

Comments

पायथन 3.6.5 दस्तावेज़ीकरण बताता है: कई सामान्य उपयोग के मामलों के लिए os.scandir () फ़ंक्शन फ़ाइल विशेषताओं की जानकारी के साथ निर्देशिका प्रविष्टियाँ देता है, बेहतर प्रदर्शन [os.listdir () की तुलना में)।

— बिल Oldroyd

मुझे इस परीक्षण की स्केलिंग याद आ रही है कि आपने इस परीक्षण में कितनी फ़ाइलों का उपयोग किया है? यदि आप संख्या को ऊपर / नीचे करते हैं तो वे कैसे तुलना करते हैं?

— N4ppeL

Answer 16

यह कोड मेरे जीवन को सरल बनाता है।

import os
fnames = ([file for root, dirs, files in os.walk(dir)
    for file in files
    if file.endswith('.txt') #or file.endswith('.png') or file.endswith('.pdf')
    ])
for fname in fnames: print(fname)

Answer 17

Fnmatch का उपयोग करें: https://docs.python.org/2/library/fnmatch.html

import fnmatch
import os

for file in os.listdir('.'):
    if fnmatch.fnmatch(file, '*.txt'):
        print file

Answer 18

उसी निर्देशिका में "डेटा" नामक फ़ोल्डर से ".txt" फ़ाइल नामों की एक सरणी प्राप्त करने के लिए, मैं आमतौर पर कोड की इस सरल रेखा का उपयोग करता हूं:

import os
fileNames = [fileName for fileName in os.listdir("data") if fileName.endswith(".txt")]

Answer 19

मेरा सुझाव है कि आप fnmatch और ऊपरी विधि का उपयोग करें। इस तरह आप निम्नलिखित में से कोई भी पा सकते हैं:

1. नाम। txt ;
2. नाम। TXT ;
3. नाम। टेक्स्ट

।

import fnmatch
import os

    for file in os.listdir("/Users/Johnny/Desktop/MyTXTfolder"):
        if fnmatch.fnmatch(file.upper(), '*.TXT'):
            print(file)

Answer 20

यहाँ एक के साथ है extend()

types = ('*.jpg', '*.png')
images_list = []
for files in types:
    images_list.extend(glob.glob(os.path.join(path, files)))

Comments

साथ उपयोग के लिए नहीं .txt:)

— Efreeto

Answer 21

उप-निर्देशिकाओं के साथ कार्यात्मक समाधान:

from fnmatch import filter
from functools import partial
from itertools import chain
from os import path, walk

print(*chain(*(map(partial(path.join, root), filter(filenames, "*.txt")) for root, _, filenames in walk("mydir"))))

Comments

क्या यह कोड आप लंबे समय तक बनाए रखना चाहते हैं?

— शिमोन विसेर

Answer 22

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

def yield_files_with_extensions(folder_path, file_extension):
   for _, _, files in os.walk(folder_path):
       for file in files:
           if file.endswith(file_extension):
               yield file

विकल्प A: Iterate

for f in yield_files_with_extensions('.', '.txt'): 
    print(f)

विकल्प बी: सभी प्राप्त करें

files = [f for f in yield_files_with_extensions('.', '.txt')]

Answer 23

भूत-प्रेत के समान एक कॉपी-पेस्ट करने योग्य समाधान:

def get_all_filepaths(root_path, ext):
    """
    Search all files which have a given extension within root_path.

    This ignores the case of the extension and searches subdirectories, too.

    Parameters
    ----------
    root_path : str
    ext : str

    Returns
    -------
    list of str

    Examples
    --------
    >>> get_all_filepaths('/run', '.lock')
    ['/run/unattended-upgrades.lock',
     '/run/mlocate.daily.lock',
     '/run/xtables.lock',
     '/run/mysqld/mysqld.sock.lock',
     '/run/postgresql/.s.PGSQL.5432.lock',
     '/run/network/.ifstate.lock',
     '/run/lock/asound.state.lock']
    """
    import os
    all_files = []
    for root, dirs, files in os.walk(root_path):
        for filename in files:
            if filename.lower().endswith(ext):
                all_files.append(os.path.join(root, filename))
    return all_files

Answer 24

विशिष्ट एक्सटेंशन वाली फ़ाइलों को खोजने के लिए पायथन ओएस मॉड्यूल का उपयोग करें।

सरल उदाहरण यहाँ है:

import os

# This is the path where you want to search
path = r'd:'  

# this is extension you want to detect
extension = '.txt'   # this can be : .jpg  .png  .xls  .log .....

for root, dirs_list, files_list in os.walk(path):
    for file_name in files_list:
        if os.path.splitext(file_name)[-1] == extension:
            file_name_path = os.path.join(root, file_name)
            print file_name
            print file_name_path   # This is the full path of the filter file

Answer 25

कई उपयोगकर्ताओं ने जवाब के साथ os.walkजवाब दिया है, जिसमें सभी फाइलें शामिल हैं, लेकिन सभी निर्देशिकाएं और उपनिर्देशिकाएं और उनकी फाइलें भी शामिल हैं।

import os


def files_in_dir(path, extension=''):
    """
       Generator: yields all of the files in <path> ending with
       <extension>

       \param   path       Absolute or relative path to inspect,
       \param   extension  [optional] Only yield files matching this,

       \yield              [filenames]
    """


    for _, dirs, files in os.walk(path):
        dirs[:] = []  # do not recurse directories.
        yield from [f for f in files if f.endswith(extension)]

# Example: print all the .py files in './python'
for filename in files_in_dir('./python', '*.py'):
    print("-", filename)

या एक बंद के लिए जहां आपको जनरेटर की आवश्यकता नहीं है:

path, ext = "./python", ext = ".py"
for _, _, dirfiles in os.walk(path):
    matches = (f for f in dirfiles if f.endswith(ext))
    break

for filename in matches:
    print("-", filename)

यदि आप किसी और चीज़ के लिए मैचों का उपयोग करने जा रहे हैं, तो आप इसे जनरेटर अभिव्यक्ति के बजाय एक सूची बनाना चाहते हैं:

    matches = [f for f in dirfiles if f.endswith(ext)]

Answer 26

forलूप का उपयोग करके एक सरल विधि :

import os

dir = ["e","x","e"]

p = os.listdir('E:')  #path

for n in range(len(p)):
   name = p[n]
   myfile = [name[-3],name[-2],name[-1]]  #for .txt
   if myfile == dir :
      print(name)
   else:
      print("nops")

हालांकि इसे और अधिक सामान्यीकृत किया जा सकता है।

Comments

एक एक्सटेंशन की जाँच करने का बहुत ही निराला तरीका। असुरक्षित भी। यदि नाम बहुत छोटा है तो क्या होगा? और पात्रों की सूची का उपयोग क्यों नहीं किया और तार नहीं?

— जीन फ़्राँस्वा Fabre