පයිතන් හි ඇති නාමාවලියක සියලුම ගොනු ලැයිස්තුගත කර ඒවා a ට එකතු කරන්නේ listකෙසේද?

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()කරන සෑම ඩිරෙක්ටරියක් සඳහාම ලැයිස්තු දෙකක් ලබා දෙනු ඇත - ඔබ වෙනුවෙන් ලිපිගොනු සහ ඩිරර් වලට බෙදීම . ඔබට අවශ්‍ය වන්නේ ඉහළ නාමාවලිය පමණක් නම් එය ලැබෙන පළමු අවස්ථාව බිඳ දැමිය හැකිය

from os import walk

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

globරටා ගැලපීම හා පුළුල් කිරීම මෙන් මොඩියුලය භාවිතා කිරීමට මම කැමැත්තෙමි .

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

විමසූ ලිපිගොනු සමඟ එය ලැයිස්තුවක් නැවත ලබා දෙනු ඇත:

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

පයිතන් 2 සහ 3 සහිත ලිපිගොනු ලැයිස්තුවක් ලබා ගන්න

os.listdir()

වත්මන් නාමාවලියෙහි ඇති සියලුම ලිපිගොනු (සහ නාමාවලි) ලබා ගන්නේ කෙසේද (පයිතන් 3)

පහත දැක්වෙන්නේ පයිතන් 3 හි වත්මන් ඩිරෙක්ටරියේ ගොනු පමණක් ලබා ගැනීම os සහ භාවිතා කිරීම සහ listdir()ක්‍රියාකාරීත්වය ය. ඇවිදීම භාවිතා කළ හැකිය - පසුව සාකච්ඡා කරනු ලැබේ).

 import os
 arr = os.listdir()
 print(arr)

 >>> ['$RECYCLE.BIN', 'work.txt', '3ebooks.txt', 'documents']

glob

එකම වර්ගයේ හෝ පොදු දෙයක් සමඟ ගොනුව තෝරා ගැනීමට ග්ලෝබ් පහසු බව මට පෙනී ගියේය. පහත උදාහරණය දෙස බලන්න:

import glob

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

glob ලැයිස්තු අවබෝධය සමඟ

import glob

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

glob ශ්‍රිතයක් සමඟ

ශ්‍රිතය තර්කයේ දී දී ඇති දිගුවේ (.txt, .docx ecc.) ලැයිස්තුවක් ලබා දෙයි

import glob

def filebrowser(ext=""):
    "Returns files with an extension"
    return [f for f in glob.glob(f"*{ext}")]

x = filebrowser(".txt")
print(x)

>>> ['example.txt', 'fb.txt', 'intro.txt', 'help.txt']

glob පෙර කේතය දිගු කිරීම

ශ්‍රිතය දැන් ඔබ තර්කයක් ලෙස සම්මත කරන ලද නූලට ගැලපෙන ගොනු ලැයිස්තුවක් ලබා දෙයි

import glob

def filesearch(word=""):
    """Returns a list with all files with the word/extension in it"""
    file = []
    for f in glob.glob("*"):
        if word[0] == ".":
            if f.endswith(word):
                file.append(f)
                return file
        elif word in f:
            file.append(f)
            return file
    return file

lookfor = "example", ".py"
for w in lookfor:
    print(f"{w:10} found => {filesearch(w)}")

ප්‍රතිදානය

example    found => []
.py        found => ['search.py']

සමඟ සම්පූර්ණ මාර්ග නාමය ලබා ගැනීම os.path.abspath

ඔබ දුටු පරිදි, ඉහත කේතයේ ගොනුවේ සම්පූර්ණ මාර්ගය ඔබට නොමැත. ඔබ සත්ය මාර්ගය ඇති කිරීමට අවශ්ය නම්, ඔබ තවත් ක්රියාව භාවිත කල හැක os.pathනමින් මොඩියුලය _getfullpathnameඔබට ලබා දී ඇති බවයි ගොනුව දමා, os.listdir()තර්කයක් ලෙස. සම්පූර්ණ මාර්ගය ලබා ගැනීම සඳහා වෙනත් ක්‍රම තිබේ, අපි පසුව පරීක්ෂා කර බලමු (මෙක්ස්මේක්ස් යෝජනා කළ පරිදි, මම ප්‍රතිස්ථාපනය කළෙමි, _getfullpathname සමඟ abspath).

 import os
 files_path = [os.path.abspath(x) for x in os.listdir()]
 print(files_path)

 >>> ['F:\\documenti\applications.txt', 'F:\\documenti\collections.txt']

සමඟ ඇති සියලුම උප බහලුම් වලට ගොනුවක සම්පූර්ණ මාර්ග නාමය ලබා ගන්න walk

බොහෝ නාමාවලිවල ඇති දේවල් සොයා ගැනීමට මෙය ඉතා ප්‍රයෝජනවත් බව මට පෙනී ගිය අතර, එය මට නම මතක නැති ගොනුවක් සොයා ගැනීමට උපකාරී විය:

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 file.endswith(".docx"):
            print(os.path.join(r, file))

os.listdir(): වත්මන් නාමාවලියෙහි ගොනු ලබා ගන්න (පයිතන් 2)

Python 2 හි, ඔබට වත්මන් නාමාවලියෙහි ඇති ගොනු ලැයිස්තුවක් අවශ්‍ය නම්, ඔබට තර්කය '' ලෙස ලබා දිය යුතුය. හෝ os.getcwd () os.listdir ක්‍රමයේදී.

 import os
 arr = os.listdir('.')
 print(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')
 print(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]
 print(arr)

 >>> ['5bs_Turismo1.pdf', '5bs_Turismo1.pptx', 'esperienza.txt']

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

>>> F:\\_python\\dict_class.py
>>> F:\\_python\\programmi.txt

next(os.walk('F:\\') - සම්පූර්ණ මාර්ගය ලබා ගන්න - ලැයිස්තු අවබෝධය

 [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]
print(x)

>>> ['F:\\_python\\dict.py', 'F:\\_python\\progr.txt', 'F:\\_python\\readl.py']

os.listdir() - ටෙක්ස්ට් ලිපිගොනු පමණක් ලබා ගන්න

 arr_txt = [x for x in os.listdir() if x.endswith(".txt")]
 print(arr_txt)

 >>> ['work.txt', '3ebooks.txt']

globලිපිගොනු වල සම්පූර්ණ මාර්ගය ලබා ගැනීම සඳහා භාවිතා කිරීම

මට ලිපිගොනු වල නිරපේක්ෂ මාර්ගය අවශ්‍ය නම්:

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

os.path.isfileලැයිස්තුවේ ඇති නාමාවලි මඟ හැරීම සඳහා භාවිතා කිරීම

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

>>> ['a simple game.py', 'data.txt', 'decorator.py']

pathlibපයිතන් 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

සමග list comprehension:

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)
print(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]
 print(x)

 >>> ['calculator.bat','calculator.py']

ඊළඟට ඇති නාමාවලි පමණක් ලබාගෙන නාමාවලියක ගමන් කරන්න

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

 >>> ['python3','others']

සියලුම උපසිරැසි නම් ලබා ගන්න walk

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()]
print(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"))

>>> 'F:\\\python' : 12057 files'

උදා .2: සියලුම ලිපිගොනු නාමාවලියක සිට වෙනත් ස්ථානයකට පිටපත් කරන්නේ කෙසේද?

ඔබේ පරිගණකයේ ඇණවුම් කිරීමට ස්ක්‍රිප්ටයක් වර්ගයක සියලුම ගොනු (පෙරනිමි: pptx) සොයාගෙන ඒවා නව ෆෝල්ඩරයක පිටපත් කිරීම.

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('-' * 30)
        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
>>> ------------------------
>>> ==> Found in: `_compiti18` : 3 files

උදා. 3: සියලුම ලිපිගොනු 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)

උදාහරණය: දෘ drive තැටියේ සියලුම ලිපිගොනු සමඟ ටෙක්ස්ට් කරන්න

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

C: of හි සියලුම ගොනුව එක් පෙළ ගොනුවක

මෙය පෙර කේතයේ කෙටි අනුවාදයකි. ඔබට වෙනත් ස්ථානයකින් ආරම්භ කිරීමට අවශ්‍ය නම් ලිපිගොනු සොයා ගැනීම ආරම්භ කළ යුතු ස්ථානය ෆෝල්ඩරය වෙනස් කරන්න. මෙම කේතය මගේ පරිගණකයේ පෙළ ගොනුවේ 50 mb අඩු අගයක් ජනනය කරයි.

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

වර්ගයක ෆෝල්ඩරයක සියලුම මාර්ග සහිත ගොනුවක් ලියන්නේ කෙසේද

මෙම ශ්‍රිතය සමඟින් ඔබ සොයන ආකාරයේ ගොනුවක නමක් ඇති txt ගොනුවක් නිර්මාණය කළ හැකිය (උදා: pngfile.txt) එම වර්ගයේ සියලුම ලිපිගොනු වල සම්පූර්ණ මාර්ගය සමඟ. සමහර විට එය ප්‍රයෝජනවත් විය හැකිය, මම සිතමි.

import os

def searchfiles(extension='.ttf', folder='H:\\'):
    "Create a txt file with all the file of a type"
    with open(extension[1:] + "file.txt", "w", encoding="utf-8") as filewrite:
        for r, d, f in os.walk(folder):
            for file in f:
                if file.endswith(extension):
                    filewrite.write(f"{r + file}\n")

# looking for png file (fonts) in the hard disk H:\
searchfiles('.png', 'H:\\')

>>> H:\4bs_18\Dolphins5.png
>>> H:\4bs_18\Dolphins6.png
>>> H:\4bs_18\Dolphins7.png
>>> H:\5_18\marketing html\assets\imageslogo2.png
>>> H:\7z001.png
>>> H:\7z002.png

(නව) සියලුම ලිපිගොනු සොයාගෙන ඒවා tkinter GUI සමඟ විවෘත කරන්න

මට අවශ්‍ය වූයේ මෙම 2019 දී කුඩා යෙදුමක් එක් කිරීමට අවශ්‍ය වන අතර සියලුම ලිපිගොනු සෙවීම සඳහා ලැයිස්තුවේ ඇති ගොනුවේ නම දෙවරක් ක්ලික් කිරීමෙන් ඒවා විවෘත කළ හැකිය.

import tkinter as tk
import os

def searchfiles(extension='.txt', folder='H:\\'):
    "insert all files in the listbox"
    for r, d, f in os.walk(folder):
        for file in f:
            if file.endswith(extension):
                lb.insert(0, r + "\\" + file)

def open_file():
    os.startfile(lb.get(lb.curselection()[0]))

root = tk.Tk()
root.geometry("400x400")
bt = tk.Button(root, text="Search", command=lambda:searchfiles('.png', 'H:\\'))
bt.pack()
lb = tk.Listbox(root)
lb.pack(fill="both", expand=1)
lb.bind("<Double-Button>", lambda x: open_file())
root.mainloop()

import os
os.listdir("somedirectory")

"somedirectory" හි ඇති සියලුම ලිපිගොනු සහ නාමාවලි ලැයිස්තුවක් නැවත ලබා දෙනු ඇත.

ලිපිගොනු ලැයිස්තුවක් පමණක් ලබා ගැනීම සඳහා එක්-පේළියේ විසඳුමක් (උප බහලුම් නොමැත):

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

PEP 428 ට අනුව , pathlibපුස්තකාලයේ පරමාර්ථය වන්නේ ගොනු පද්ධති මාර්ග හැසිරවීම සඳහා පන්තිවල සරල ධූරාවලියක් සැපයීම සහ ඒවා භාවිතා කරන්නන් භාවිතා කරන පොදු මෙහෙයුම් ය.

os.scandir(): 3.5 අනුවාදයේ නව.

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

os.walk()භාවිතා කරන සටහනos.scandir()os.listdir()3.5 අනුවාදය වෙනුවට , සහ PEP 471 ට අනුව එහි වේගය 2-20 ගුණයකින් වැඩි විය .

ෂැඩෝ රේන්ජර්ගේ අදහස පහතින් කියවීමට මම නිර්දේශ කරමි.

මූලික සටහන්

• ගොනුව සහ නාමාවලිය අතර පැහැදිලි වෙනසක් ඇතත්ප්‍රශ්න පෙළෙහි පද , නාමාවලි ඇත්ත වශයෙන්ම විශේෂ ලිපිගොනු යැයි සමහරු තර්ක කරති
• ප්රකාශය: " නාමාවලියක සියලුම ගොනු " ආකාර දෙකකින් අර්ථ දැක්විය හැකිය:
  1. සියලුම සෘජු (හෝ 1 මට්ටමේ) පැවත එන්නන් පමණි
  2. සමස්ත ඩිරෙක්ටරි ගසෙහි සියලුම පැවත එන්නන් (උප නාමාවලිවල අය ඇතුළුව)

• ප්රශ්නය ඇසූ විට, මම සිතන්නේ පයිතන් 2 , එල්ටීඑස් අනුවාදය, කෙසේ වෙතත් කේත සාම්පල පයිතන් 3 ( .5 ) විසින් ක්රියාත්මක කරනු ඇත (මම ඒවා හැකි තරම් පයිතන් 2 අනුකූල ලෙස තබා ගන්නෙමි ; එසේම ඕනෑම කේතයක් අයත් වේ. මම පළ කිරීමට යන පයිතන් v3.5.4 සිට වේ - වෙනත් ආකාරයකින් දක්වා නොමැති නම්). එමඟින් ප්‍රශ්නයේ තවත් මූල පදයක් හා සම්බන්ධ ප්‍රතිවිපාක ඇත: " ඒවා ලැයිස්තුවකට එක් කරන්න ":

  • පෙර පයිතන් 2.2 හි අනුවාද වල, අනුක්‍රමයන් (අනුක්‍රමික) බොහෝ දුරට ලැයිස්තු මගින් නිරූපණය කරන ලදි (ටුපල්, කට්ටල, ...)
  • දී Python 2.2 , සංකල්පය ජනකය ( [Python.Wiki]: ඡෙනරේටර් ) - අනුග්රහයෙනි [Python 3]: ඵලදාව ප්රකාශයක් ) - හඳුන්වා දෙන ලදී. කාලය ගෙවී යත්ම, ලැයිස්තු සමඟ නැවත / වැඩ කළ කාර්යයන් සඳහා උත්පාදක සගයන් පෙනී සිටීමට පටන් ගත්තේය
  • දී Python 3 , උත්පාදක සැකසුම් හැසිරීම වේ
  • ලැයිස්තුවක් ආපසු ලබා දීම තවමත් අනිවාර්යදැයි විශ්වාස නැත (නැතහොත් උත්පාදක යන්ත්රයක් ද එසේ කරයි), නමුත් ජනක යන්ත්‍රයක් ලැයිස්තු සාදන්නා වෙත යැවීමෙන් එයින් ලැයිස්තුවක් නිර්මාණය වනු ඇත (එසේම එය පරිභෝජනය කරයි). පහත උදාහරණයෙන් දැක්වෙන්නේ [පයිතන් 3] හි ඇති වෙනස්කම් ය : සිතියම ( ශ්‍රිතය, ක්‍රියාකාරී, ... )

  >>> import sys
  >>> sys.version
  '2.7.10 (default, Mar  8 2016, 15:02:46) [MSC v.1600 64 bit (AMD64)]'
  >>> m = map(lambda x: x, [1, 2, 3])  # Just a dummy lambda function
  >>> m, type(m)
  ([1, 2, 3], <type 'list'>)
  >>> len(m)
  3

  
  

  >>> import sys
  >>> sys.version
  '3.5.4 (v3.5.4:3f56838, Aug  8 2017, 02:17:05) [MSC v.1900 64 bit (AMD64)]'
  >>> m = map(lambda x: x, [1, 2, 3])
  >>> m, type(m)
  (<map object at 0x000001B4257342B0>, <class 'map'>)
  >>> len(m)
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: object of type 'map' has no len()
  >>> lm0 = list(m)  # Build a list from the generator
  >>> lm0, type(lm0)
  ([1, 2, 3], <class 'list'>)
  >>>
  >>> lm1 = list(m)  # Build a list from the same generator
  >>> lm1, type(lm1)  # Empty list now - generator already consumed
  ([], <class 'list'>)

• උදාහරණ පහත දැක්වෙන ව්‍යුහය සහිත root_dir නම් නාමාවලිය මත පදනම් වනු ඇත (මෙම උදාහරණය Win සඳහා වේ , නමුත් මම Lnx හි එකම ගස භාවිතා කරමි ):

  E:\Work\Dev\StackOverflow\q003207219>tree /f "root_dir"
  Folder PATH listing for volume Work
  Volume serial number is 00000029 3655:6FED
  E:\WORK\DEV\STACKOVERFLOW\Q003207219\ROOT_DIR
  ¦   file0
  ¦   file1
  ¦
  +---dir0
  ¦   +---dir00
  ¦   ¦   ¦   file000
  ¦   ¦   ¦
  ¦   ¦   +---dir000
  ¦   ¦           file0000
  ¦   ¦
  ¦   +---dir01
  ¦   ¦       file010
  ¦   ¦       file011
  ¦   ¦
  ¦   +---dir02
  ¦       +---dir020
  ¦           +---dir0200
  +---dir1
  ¦       file10
  ¦       file11
  ¦       file12
  ¦
  +---dir2
  ¦   ¦   file20
  ¦   ¦
  ¦   +---dir20
  ¦           file200
  ¦
  +---dir3

විසඳුම්

වැඩසටහන්මය ප්‍රවේශයන්:

1. [පයිතන් 3]: os. listdir ( path = '.' )

   මාර්ගය මඟින් ලබා දී ඇති නාමාවලියෙහි ඇතුළත් කිරීම්වල නම් ඇතුළත් ලැයිස්තුවක් ආපසු එවන්න. ලැයිස්තුව අත්තනෝමතික අනුපිළිවෙලින් පවතින අතර විශේෂ ඇතුළත් කිරීම් '.'සහ '..'...

   
   

   >>> import os
   >>> root_dir = "root_dir"  # Path relative to current dir (os.getcwd())
   >>>
   >>> os.listdir(root_dir)  # List all the items in root_dir
   ['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']
   >>>
   >>> [item for item in os.listdir(root_dir) if os.path.isfile(os.path.join(root_dir, item))]  # Filter items and only keep files (strip out directories)
   ['file0', 'file1']

   වඩාත් සවිස්තරාත්මක උදාහරණයක් ( code_os_listdir.py ):

   import os
   from pprint import pformat
   
   
   def _get_dir_content(path, include_folders, recursive):
       entries = os.listdir(path)
       for entry in entries:
           entry_with_path = os.path.join(path, entry)
           if os.path.isdir(entry_with_path):
               if include_folders:
                   yield entry_with_path
               if recursive:
                   for sub_entry in _get_dir_content(entry_with_path, include_folders, recursive):
                       yield sub_entry
           else:
               yield entry_with_path
   
   
   def get_dir_content(path, include_folders=True, recursive=True, prepend_folder_name=True):
       path_len = len(path) + len(os.path.sep)
       for item in _get_dir_content(path, include_folders, recursive):
           yield item if prepend_folder_name else item[path_len:]
   
   
   def _get_dir_content_old(path, include_folders, recursive):
       entries = os.listdir(path)
       ret = list()
       for entry in entries:
           entry_with_path = os.path.join(path, entry)
           if os.path.isdir(entry_with_path):
               if include_folders:
                   ret.append(entry_with_path)
               if recursive:
                   ret.extend(_get_dir_content_old(entry_with_path, include_folders, recursive))
           else:
               ret.append(entry_with_path)
       return ret
   
   
   def get_dir_content_old(path, include_folders=True, recursive=True, prepend_folder_name=True):
       path_len = len(path) + len(os.path.sep)
       return [item if prepend_folder_name else item[path_len:] for item in _get_dir_content_old(path, include_folders, recursive)]
   
   
   def main():
       root_dir = "root_dir"
       ret0 = get_dir_content(root_dir, include_folders=True, recursive=True, prepend_folder_name=True)
       lret0 = list(ret0)
       print(ret0, len(lret0), pformat(lret0))
       ret1 = get_dir_content_old(root_dir, include_folders=False, recursive=True, prepend_folder_name=False)
       print(len(ret1), pformat(ret1))
   
   
   if __name__ == "__main__":
       main()

   සටහන් :

   • ක්‍රියාත්මක කිරීම් දෙකක් තිබේ:
     • උත්පාදක යන්ත්ර භාවිතා කරන එකක් (ඇත්ත වශයෙන්ම මෙහි නිෂ් less ල බවක් පෙනේ, මන්ද මම වහාම ප්රති result ලය ලැයිස්තුවකට පරිවර්තනය කරමි)
     • සම්භාව්‍ය එක (ශ්‍රිත නාම _old වලින් අවසන් වේ )
   • පුනරාවර්තනය භාවිතා කරයි (උප බහලුම් වලට පිවිසීමට)
   • එක් එක් ක්‍රියාත්මක කිරීම සඳහා කාර්යයන් දෙකක් ඇත:
     • යටි ඉරි වලින් ආරම්භ වන ( _ ): "පුද්ගලික" (කෙලින්ම කැඳවිය යුතු නැත) - එය සියලු වැඩ කරයි
     • පොදු එක (පෙරට වඩා එතීම): එය ආපසු එවූ ප්‍රවේශයන්ගෙන් ආරම්භක මාර්ගයෙන් (අවශ්‍ය නම්) ඉවත් කරයි. එය අවලස්සන ක්‍රියාත්මක කිරීමකි, නමුත් මේ මොහොතේ මට පැමිණිය හැකි එකම අදහස එයයි
   • කාර්ය සාධනය අනුව, උත්පාදක යන්ත්ර සාමාන්‍යයෙන් ටිකක් වේගවත් වේ ( නිර්මාණය හා පුනරාවර්තනය යන දෙකම සැලකිල්ලට ගනිමින් වේලාවන් ), නමුත් මම ඒවා පුනරාවර්තන කාර්යයන් වලදී පරීක්‍ෂා නොකළ අතර, අභ්‍යන්තර උත්පාදක යන්ත්ර හරහා මම ක්රියාකාරිත්වය තුළ නැවත ධාවනය කරමි - කාර්ය සාධනය කෙසේ දැයි නොදනී මිත්රශීලී එය එයයි
   • විවිධ ප්‍රති .ල ලබා ගැනීම සඳහා තර්ක සමඟ සෙල්ලම් කරන්න

   
   

   ප්‍රතිදානය :

   (py35x64_test) E:\Work\Dev\StackOverflow\q003207219>"e:\Work\Dev\VEnvs\py35x64_test\Scripts\python.exe" "code_os_listdir.py"
   <generator object get_dir_content at 0x000001BDDBB3DF10> 22 ['root_dir\\dir0',
    'root_dir\\dir0\\dir00',
    'root_dir\\dir0\\dir00\\dir000',
    'root_dir\\dir0\\dir00\\dir000\\file0000',
    'root_dir\\dir0\\dir00\\file000',
    'root_dir\\dir0\\dir01',
    'root_dir\\dir0\\dir01\\file010',
    'root_dir\\dir0\\dir01\\file011',
    'root_dir\\dir0\\dir02',
    'root_dir\\dir0\\dir02\\dir020',
    'root_dir\\dir0\\dir02\\dir020\\dir0200',
    'root_dir\\dir1',
    'root_dir\\dir1\\file10',
    'root_dir\\dir1\\file11',
    'root_dir\\dir1\\file12',
    'root_dir\\dir2',
    'root_dir\\dir2\\dir20',
    'root_dir\\dir2\\dir20\\file200',
    'root_dir\\dir2\\file20',
    'root_dir\\dir3',
    'root_dir\\file0',
    'root_dir\\file1']
   11 ['dir0\\dir00\\dir000\\file0000',
    'dir0\\dir00\\file000',
    'dir0\\dir01\\file010',
    'dir0\\dir01\\file011',
    'dir1\\file10',
    'dir1\\file11',
    'dir1\\file12',
    'dir2\\dir20\\file200',
    'dir2\\file20',
    'file0',
    'file1']

2. [පයිතන් 3]: os. scandir ( path = '.' ) ( Python 3.5 +, backport: [PyPI]: scandir )

   මාර්ගයෙන් ලබා දී ඇති නාමාවලියෙහි ඇතුළත් කිරීම් වලට අනුරූපව os.DirEntry වස්තූන්ගේ අනුකාරකයක් නැවත ලබා දෙන්න . සටහන් අත්තනෝමතික සඳහා, එකකින්, සහ විශේෂ සටහන් හා ඇතුලත් කර නැත.'.''..'

   භාවිතා scandir () වෙනුවට listdir () සැලකිය යුතු නිසා ද, ගොනු වර්ගය හෝ ගොනුව විශේෂණය තොරතුරු අවශ්ය බව කේතය කාර්ය සාධනය වැඩි විය හැකි os.DirEntry මෙහෙයුම් පද්ධතිය නාමාවලියක් ස්කෑන් විට එය මඟින් නම් මෙම තොරතුරු හෙළිදරව් විරුද්ධව සිටී. සියළුම os.DirEntry ක්‍රම මඟින් පද්ධති ඇමතුමක් ලබා දිය හැකි නමුත් is_dir () සහ is_file () සඳහා සාමාන්‍යයෙන් අවශ්‍ය වන්නේ සංකේතාත්මක සම්බන්ධතා සඳහා පද්ධති ඇමතුමක් පමණි; os.DirEntry.stat () සෑම විටම යුනික්ස් හි පද්ධති ඇමතුමක් අවශ්‍ය නමුත් වින්ඩෝස් හි සංකේතාත්මක සම්බන්ධතා සඳහා එකක් පමණක් අවශ්‍ය වේ.

   
   

   >>> import os
   >>> root_dir = os.path.join(".", "root_dir")  # Explicitly prepending current directory
   >>> root_dir
   '.\\root_dir'
   >>>
   >>> scandir_iterator = os.scandir(root_dir)
   >>> scandir_iterator
   <nt.ScandirIterator object at 0x00000268CF4BC140>
   >>> [item.path for item in scandir_iterator]
   ['.\\root_dir\\dir0', '.\\root_dir\\dir1', '.\\root_dir\\dir2', '.\\root_dir\\dir3', '.\\root_dir\\file0', '.\\root_dir\\file1']
   >>>
   >>> [item.path for item in scandir_iterator]  # Will yield an empty list as it was consumed by previous iteration (automatically performed by the list comprehension)
   []
   >>>
   >>> scandir_iterator = os.scandir(root_dir)  # Reinitialize the generator
   >>> for item in scandir_iterator :
   ...     if os.path.isfile(item.path):
   ...             print(item.name)
   ...
   file0
   file1

   සටහන් :

   • එය සමාන ය os.listdir
   • නමුත් එය වඩාත් නම්‍යශීලී වේ (සහ වැඩි ක්‍රියාකාරීත්වයක් ලබා දෙයි), වැඩි පයිතන් අයිසී (සහ සමහර අවස්ථාවල වේගවත්)

3. [පයිතන් 3]: os. walk ( ඉහළ, topdown = සත්‍ය, onerror = කිසිවක් නැත, followlinks = අසත්‍යය )

   ගස ඉහළ සිට පහළට හෝ පහළට ගමන් කිරීමෙන් නාමාවලි ගසක ගොනු නාම ජනනය කරන්න. ගස බහලුම මුල් බැස එක් එක් බහලුම සඳහා ඉහළ (ඇතුළු ඉහළ ම), එය 3-tuple හික්මුණු ( dirpath, dirnames, filenames).

   
   

   >>> import os
   >>> root_dir = os.path.join(os.getcwd(), "root_dir")  # Specify the full path
   >>> root_dir
   'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir'
   >>>
   >>> walk_generator = os.walk(root_dir)
   >>> root_dir_entry = next(walk_generator)  # First entry corresponds to the root dir (passed as an argument)
   >>> root_dir_entry
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir', ['dir0', 'dir1', 'dir2', 'dir3'], ['file0', 'file1'])
   >>>
   >>> root_dir_entry[1] + root_dir_entry[2]  # Display dirs and files (direct descendants) in a single list
   ['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']
   >>>
   >>> [os.path.join(root_dir_entry[0], item) for item in root_dir_entry[1] + root_dir_entry[2]]  # Display all the entries in the previous list by their full path
   ['E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir1', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir2', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir3', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\file0', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\file1']
   >>>
   >>> for entry in walk_generator:  # Display the rest of the elements (corresponding to every subdir)
   ...     print(entry)
   ...
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0', ['dir00', 'dir01', 'dir02'], [])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir00', ['dir000'], ['file000'])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir00\\dir000', [], ['file0000'])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir01', [], ['file010', 'file011'])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir02', ['dir020'], [])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir02\\dir020', ['dir0200'], [])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir02\\dir020\\dir0200', [], [])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir1', [], ['file10', 'file11', 'file12'])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir2', ['dir20'], ['file20'])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir2\\dir20', [], ['file200'])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir3', [], [])

   සටහන් :

   • දර්ශන යටතේ, එය භාවිතා කරයි os.scandir( os.listdirපැරණි අනුවාද වල)
   • එය උප ෆෝල්ඩරවල පුනරාවර්තනය වීමෙන් බර ඉසිලීම සිදු කරයි

4. [පයිතන් 3]: ග්ලෝබ්. glob ( pathname, *, recursive = False ) ( [Python 3]: glob. iglob ( pathname , *, recursive = False ) )

   තරගයේ මාර්ගය නම් වූ හැකි, හිස්-ලැයිස්තුව නැවත pathname , මාර්ගය පිරිවිතර අඩංගු වැලක් විය යුතුය. pathname (වගේ එක්කෝ නිරපේක්ෂ විය යුතුයි /usr/src/Python-1.5/Makefile(වැනි) හෝ සාපේක්ෂ ../../Tools/*/*.gif), සහ ෂෙල් ආකාරයේ ආදේශක අඩංගු විය හැක. ප්‍රති results ලවල (කවචයේ මෙන්) කැඩුණු සමමුහුර්ත කිරීම් ඇතුළත් වේ.
   ...
   3.5 අනුවාදයේ වෙනස් කර ඇත : “ **” භාවිතා කරමින් පුනරාවර්තන ග්ලෝබ් සඳහා සහාය .

   
   

   >>> import glob, os
   >>> wildcard_pattern = "*"
   >>> root_dir = os.path.join("root_dir", wildcard_pattern)  # Match every file/dir name
   >>> root_dir
   'root_dir\\*'
   >>>
   >>> glob_list = glob.glob(root_dir)
   >>> glob_list
   ['root_dir\\dir0', 'root_dir\\dir1', 'root_dir\\dir2', 'root_dir\\dir3', 'root_dir\\file0', 'root_dir\\file1']
   >>>
   >>> [item.replace("root_dir" + os.path.sep, "") for item in glob_list]  # Strip the dir name and the path separator from begining
   ['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']
   >>>
   >>> for entry in glob.iglob(root_dir + "*", recursive=True):
   ...     print(entry)
   ...
   root_dir\
   root_dir\dir0
   root_dir\dir0\dir00
   root_dir\dir0\dir00\dir000
   root_dir\dir0\dir00\dir000\file0000
   root_dir\dir0\dir00\file000
   root_dir\dir0\dir01
   root_dir\dir0\dir01\file010
   root_dir\dir0\dir01\file011
   root_dir\dir0\dir02
   root_dir\dir0\dir02\dir020
   root_dir\dir0\dir02\dir020\dir0200
   root_dir\dir1
   root_dir\dir1\file10
   root_dir\dir1\file11
   root_dir\dir1\file12
   root_dir\dir2
   root_dir\dir2\dir20
   root_dir\dir2\dir20\file200
   root_dir\dir2\file20
   root_dir\dir3
   root_dir\file0
   root_dir\file1

   සටහන් :

   • භාවිතයන් os.listdir
   • විශාල ගස් සඳහා (විශේෂයෙන් පුනරාවර්තන සක්‍රීය නම්), ඉග්ලොබ් වඩාත් සුදුසු වේ
   • නම මත පදනම්ව උසස් පෙරහන් කිරීමට ඉඩ දෙන්න (ආදේශක කාඩ්පත නිසා)

5. [පයිතන් 3]: පන්ති පාත් ලිබ්. මාර්ගය ( * මාර්ග සැකසුම් ) ( පයිතන් 3.4 +, පසුපෙළ : [PyPI]: pathlib2 )

   >>> import pathlib
   >>> root_dir = "root_dir"
   >>> root_dir_instance = pathlib.Path(root_dir)
   >>> root_dir_instance
   WindowsPath('root_dir')
   >>> root_dir_instance.name
   'root_dir'
   >>> root_dir_instance.is_dir()
   True
   >>>
   >>> [item.name for item in root_dir_instance.glob("*")]  # Wildcard searching for all direct descendants
   ['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']
   >>>
   >>> [os.path.join(item.parent.name, item.name) for item in root_dir_instance.glob("*") if not item.is_dir()]  # Display paths (including parent) for files only
   ['root_dir\\file0', 'root_dir\\file1']

   සටහන් :

   • මෙය අපගේ ඉලක්කය සපුරා ගැනීමේ එක් ක්‍රමයකි
   • එය මාර්ග හැසිරවීමේ OOP විලාසයයි
   • ක්‍රියාකාරීත්වයන් රාශියක් ඉදිරිපත් කරයි

6. [පයිතන් 2]: dircache.listdir (මාර්ගය) ( පයිතන් 2 පමණි)

   • එහෙත්, අනුව [GitHub]: පිඹුරා / cpython - (2.7) cpython / lib / dircache.py , එය පුරා පමණක් (සිහින්) දවටනය තියෙන්නේ os.listdirකල ගබඩා සමග

   
   

   def listdir(path):
       """List directory contents, using cache."""
       try:
           cached_mtime, list = cache[path]
           del cache[path]
       except KeyError:
           cached_mtime, list = -1, []
       mtime = os.stat(path).st_mtime
       if mtime != cached_mtime:
           list = os.listdir(path)
           list.sort()
       cache[path] = mtime, list
       return list

7. [man7]: OPENDIR (3) / [man7]: READDIR (3) / [man7]: CLOSEDIR (3) හරහා [Python 3]: ctypes - Python සඳහා විදේශ ක්රියා පුස්තකය ( POSIX විශේෂිත)

   ctypes යනු පයිතන් සඳහා වන විදේශීය ශ්‍රිත පුස්තකාලයකි. එය සී අනුකූල දත්ත වර්ග සපයන අතර ඩීඑල්එල් හෝ හවුල් පුස්තකාලවල ඇමතුම් කාර්යයන් සඳහා ඉඩ ලබා දේ. මෙම පුස්තකාල පිරිසිදු පයිතන් වලින් ඔතා තැබීමට එය භාවිතා කළ හැකිය.

   code_ctypes.py :

   #!/usr/bin/env python3
   
   import sys
   from ctypes import Structure, \
       c_ulonglong, c_longlong, c_ushort, c_ubyte, c_char, c_int, \
       CDLL, POINTER, \
       create_string_buffer, get_errno, set_errno, cast
   
   
   DT_DIR = 4
   DT_REG = 8
   
   char256 = c_char * 256
   
   
   class LinuxDirent64(Structure):
       _fields_ = [
           ("d_ino", c_ulonglong),
           ("d_off", c_longlong),
           ("d_reclen", c_ushort),
           ("d_type", c_ubyte),
           ("d_name", char256),
       ]
   
   LinuxDirent64Ptr = POINTER(LinuxDirent64)
   
   libc_dll = this_process = CDLL(None, use_errno=True)
   # ALWAYS set argtypes and restype for functions, otherwise it's UB!!!
   opendir = libc_dll.opendir
   readdir = libc_dll.readdir
   closedir = libc_dll.closedir
   
   
   def get_dir_content(path):
       ret = [path, list(), list()]
       dir_stream = opendir(create_string_buffer(path.encode()))
       if (dir_stream == 0):
           print("opendir returned NULL (errno: {:d})".format(get_errno()))
           return ret
       set_errno(0)
       dirent_addr = readdir(dir_stream)
       while dirent_addr:
           dirent_ptr = cast(dirent_addr, LinuxDirent64Ptr)
           dirent = dirent_ptr.contents
           name = dirent.d_name.decode()
           if dirent.d_type & DT_DIR:
               if name not in (".", ".."):
                   ret[1].append(name)
           elif dirent.d_type & DT_REG:
               ret[2].append(name)
           dirent_addr = readdir(dir_stream)
       if get_errno():
           print("readdir returned NULL (errno: {:d})".format(get_errno()))
       closedir(dir_stream)
       return ret
   
   
   def main():
       print("{:s} on {:s}\n".format(sys.version, sys.platform))
       root_dir = "root_dir"
       entries = get_dir_content(root_dir)
       print(entries)
   
   
   if __name__ == "__main__":
       main()

   සටහන් :

   • එය libc වෙතින් කාර්යයන් තුන පටවන අතර (වර්තමාන ක්‍රියාවලියේදී පටවා ඇත) ඒවා අමතයි (වැඩි විස්තර සඳහා පරීක්ෂා කරන්න [SO]: ව්‍යතිරේකයකින් තොරව ගොනුවක් තිබේදැයි පරීක්ෂා කරන්නේ කෙසේද? (Rist ක්‍රිස්ටිෆාතිගේ පිළිතුර) - # 4 වන අයිතමයේ අවසාන සටහන් . ). එමඟින් මෙම ප්‍රවේශය පයිතන් / සී දාරයට ඉතා ආසන්නව තබනු ඇත
   • LinuxDirent64 යනු ctypes නියෝජනය struct dirent64 සිට dirent.h (0P): [man7] (එම නිසා ය DT_ මගේ පරිගණකයට සිට නියත): Ubtu 16 x64 ( 4.10.0-40-Generic බලපත්රය යටතේ අවසර ලබා ඇත හා libc6-dev: AMD64 ). වෙනත් රසයන් / සංස්කරණ වලදී, ව්‍යුහාත්මක අර්ථ දැක්වීම වෙනස් විය හැකි අතර, එසේ නම්, සයිටයිප් අන්වර්ථය යාවත්කාලීන කළ යුතුය, එසේ නොවුවහොත් එය නිර්වචනය නොකළ හැසිරීමක් ලබා දෙනු ඇත
   • එය දත්ත os.walkආකෘතියෙන් ලබා දෙයි. එය පුනරාවර්තනය කිරීමට මම කරදර වූයේ නැත, නමුත් පවතින කේතයෙන් ආරම්භ කිරීම තරමක් සුළු කාර්යයකි
   • සෑම දෙයක්ම වින් මත කළ හැකි ය, දත්ත (පුස්තකාල, කාර්යයන්, ව්‍යුහයන්, නියතයන්, ...) වෙනස් වේ

   
   

   ප්‍රතිදානය :

   [cfati@cfati-ubtu16x64-0:~/Work/Dev/StackOverflow/q003207219]> ./code_ctypes.py
   3.5.2 (default, Nov 12 2018, 13:43:14)
   [GCC 5.4.0 20160609] on linux
   
   ['root_dir', ['dir2', 'dir1', 'dir3', 'dir0'], ['file1', 'file0']]

8. [ActiveState.Docs]: win32file.FindFilesW ( නිශ්චිත ජය )

   වින්ඩෝස් යුනිකෝඩ් ඒපීඅයි භාවිතා කරමින් ගැලපෙන ගොනු නාම ලැයිස්තුවක් ලබා ගනී. API FindFirstFileW / FindNextFileW / සමීප කාර්යයන් සොයා ගැනීම සඳහා අතුරු මුහුණතක්.

   
   

   >>> import os, win32file, win32con
   >>> root_dir = "root_dir"
   >>> wildcard = "*"
   >>> root_dir_wildcard = os.path.join(root_dir, wildcard)
   >>> entry_list = win32file.FindFilesW(root_dir_wildcard)
   >>> len(entry_list)  # Don't display the whole content as it's too long
   8
   >>> [entry[-2] for entry in entry_list]  # Only display the entry names
   ['.', '..', 'dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']
   >>>
   >>> [entry[-2] for entry in entry_list if entry[0] & win32con.FILE_ATTRIBUTE_DIRECTORY and entry[-2] not in (".", "..")]  # Filter entries and only display dir names (except self and parent)
   ['dir0', 'dir1', 'dir2', 'dir3']
   >>>
   >>> [os.path.join(root_dir, entry[-2]) for entry in entry_list if entry[0] & (win32con.FILE_ATTRIBUTE_NORMAL | win32con.FILE_ATTRIBUTE_ARCHIVE)]  # Only display file "full" names
   ['root_dir\\file0', 'root_dir\\file1']

   සටහන් :

   • win32file.FindFilesWකොටසක් [GitHub]: mhammond / pywin32 - Windows සඳහා පයිතන් (pywin32) දිගු ය, එය Python කට දවටනය WINAPI ගේ
   • ප්‍රලේඛන සබැඳිය ඇක්ටිව්ස්ටේට් වෙතින් වන අතර , මට කිසිදු පයිවින් 32 නිල ලියකියවිලි හමු නොවීය

9. උපක්‍රමය කරන (වෙනත්) තෙවන පාර්ශවීය පැකේජයක් ස්ථාපනය කරන්න
   • බොහෝ දුරට, ඉහත සඳහන් එකක් (හෝ වැඩි ගණනක්) මත රඳා පවතී (සමහර විට සුළු අභිරුචිකරණයන් සහිතව)

සටහන් :

• කේතය යනු අතේ ගෙන යා හැකි ය (නිශ්චිත ප්‍රදේශයක් ඉලක්ක කරගත් ස්ථාන හැර - සලකුණු කර ඇති) හෝ හරස්:

  • වේදිකාව ( නික්ස් , වින් ,)
  • පයිතන් අනුවාදය (2, 3,)

• ඉහත සඳහන් ප්‍රභේද හරහා බහු මාර්ග ශෛලීන් (නිරපේක්ෂ, relatives ාතීන්) භාවිතා කරන ලදී, භාවිතා කරන “මෙවලම්” මෙම දිශාවට නම්යශීලී බව පැහැදිලි කිරීම සඳහා

• os.listdirහා os.scandirභාවිතය opendir / readdir / closedir ( [MS.Docs]: FindFirstFileW කාර්යය / [MS.Docs]: FindNextFileW කාර්යය / [MS.Docs]: FindClose කාර්යය ) (හරහා [GitHub]: පිඹුරා / cpython - (ස්වාමියා) cpython / මොඩියුල / posixmodule.c )

• win32file.FindFilesWඑම ( වින් විශේෂිත) කාර්යයන් ද භාවිතා කරයි ( [GitHub] හරහා : mhammond / pywin32 - (මාස්ටර්) pywin32 / win32 / src / win32file.i )

• _get_dir_content ( අංක 1 සිට ) මෙම ඕනෑම ප්‍රවේශයක් භාවිතා කර ක්‍රියාත්මක කළ හැකිය (සමහර ඒවාට වැඩි වැඩක් අවශ්‍ය වන අතර සමහරක් අඩු වේ)

  • සමහර උසස් පෙරහන් (හුදෙක් ගොනුව එදිරිව dir වෙනුවට ) කළ හැකිය: උදා: include_folders තර්කය වෙනත් එකක් මගින් ප්‍රතිස්ථාපනය කළ හැකිය (උදා: filter_func ) එය තර්කයක් ලෙස මාවතක් ගෙන යන ශ්‍රිතයක් වනු ඇත: filter_func=lambda x: True(මෙය ඉවත් නොවේ ඕනෑම දෙයක්) සහ ඇතුළත _get_dir_content වැනි දෙයක්: if not filter_func(entry_with_path): continue(එක් ප්‍රවේශයක් සඳහා ශ්‍රිතය අසමත් වුවහොත් එය මඟ හැරෙනු ඇත), නමුත් කේතය වඩාත් සංකීර්ණ වන තරමට එය ක්‍රියාත්මක කිරීමට වැඩි කාලයක් ගතවනු ඇත

• නොටා බෙන්! පුනරාවර්තනය භාවිතා කරන බැවින්, මම මගේ ලැප්ටොප් පරිගණකයේ ( වින් 10 x64 ) යම් යම් පරීක්ෂණ සිදු කළ බවත්, මෙම ගැටළුවට මුළුමනින්ම සම්බන්ධ නැති බවත්, පුනරාවර්තන මට්ටම (990 .. 1000) පරාසයේ කොතැනක හෝ අගයන් කරා ළඟා වන විට (990 .. 1000) ( recursionlimit 1000 - (පෙරනිමි)), මට StackOverflow ලැබුණි :). නාමාවලි ගස එම සීමාව ඉක්මවා ගියහොත් (මම එෆ්එස් විශේෂ expert යෙක් නොවෙමි, එබැවින් එය කළ හැකිදැයි මම නොදනිමි), එය ගැටළුවක් විය හැකිය. ප්‍රදේශයේ අත්දැකීම් නොමැති නිසා මම පුනරාවර්තන සීමාව
  වැඩි කිරීමට උත්සාහ නොකළ බව ද සඳහන් කළ යුතුය (තොගය වැඩි කිරීමට පෙර මට එය කොපමණ වැඩි කළ හැකිද? මෙහෙයුම් පද්ධතියේමට්ටම), නමුත් න්‍යායිකව සෑම විටම අසමත් වීමේ හැකියාව පවතී, dir ගැඹුර හැකි උපරිම පුනරාවර්තන සීමාවට වඩා විශාල නම් (එම යන්ත්‍රයේ)

• කේත සාම්පල නිරූපණ අරමුණු සඳහා පමණි. ඒ කියන්නේ මම දෝෂ හැසිරවීම සැලකිල්ලට නොගත් බව (මම හිතන්නේ නැහැ වෙන උත්සාහයක් / හැර / වෙනත් / අවසාන වශයෙන් අවහිර), එබැවින් කේතය ශක්තිමත් නොවේ (හේතුව: එය හැකි තරම් සරල හා කෙටි ලෙස තබා ගැනීම ). සඳහා නිෂ්පාදනය , දෝෂ හැසිරවීම මෙන්ම එකතු කළ යුතුය

වෙනත් ප්‍රවේශයන්:

1. පයිතන් එතීම ලෙස පමණක් භාවිතා කරන්න

   • සෑම දෙයක්ම වෙනත් තාක්ෂණයක් භාවිතයෙන් සිදු කෙරේ
   • එම තාක්‍ෂණය ක්‍රියාත්මක වේ පයිතන් වේ

   • මා දන්නා වඩාත් ප්‍රසිද්ධ රසය නම් මම එය හඳුන්වන දෙයයි පද්ධති පරිපාලක ප්‍රවේශය ලෙස :

     • භාවිතය Python ක්රියාත්මක කිරීම සඳහා (හෝ ඒ සඳහා කිසිදු ක්රමලේඛන භාෂාව) ෂෙල් විධාන (සහ ඒවායේ ප්රතිදානයන් විග්රහ කළ)
     • සමහරු මෙය පිළිකුල් සහගත ලෙස සලකති
     • මට තව කොර සලසන වක් මගක් (වගේ එය සලකා gainarie අවතක්සේරුවට ක්රියාව සිට සිදු කෙරේ ලෙස,) ෂෙල් ( cmd මෙම නඩුවේ), හා ඒ නිසා කිසි දෙයකට නොවේ Python .
     • පෙරීම ( grep/ findstr) හෝ ප්‍රතිදාන හැඩතල ගැන්වීම දෙපසම කළ හැකි නමුත් මම එය අවධාරනය නොකරමි. ඒ වගේම මම හිතාමතාම os.systemඒ වෙනුවට භාවිතා subprocess.Popenකළා.

     (py35x64_test) E:\Work\Dev\StackOverflow\q003207219>"e:\Work\Dev\VEnvs\py35x64_test\Scripts\python.exe" -c "import os;os.system(\"dir /b root_dir\")"
     dir0
     dir1
     dir2
     dir3
     file0
     file1

   පොදුවේ ගත් කල මෙම ප්‍රවේශය වළක්වා ගත යුතුය, මන්දයත් සමහර විධාන ප්‍රතිදාන ආකෘතිය OS අනුවාද / රසයන් අතර තරමක් වෙනස් නම් , විග්‍රහ කිරීමේ කේතයද අනුගත විය යුතුය; ස්ථාන අතර වෙනස්කම් සඳහන් නොකල යුතුය).

එකම නමේ මොඩියුලයෙන් ඔබ භාවිතා කරන ලෙස යෝජනා කරමින් ඇඩම්ක්ගේ පිළිතුරට මම ඇත්තෙන්ම කැමතියි glob(). *S සමඟ රටා ගැලපීමට මෙය ඔබට ඉඩ සලසයි .

නමුත් වෙනත් පුද්ගලයින් අදහස් දැක්වීමේදී පෙන්වා දී ඇති පරිදි, glob()නොගැලපෙන කප්පාදු දිශාවන්ට හසු විය හැකිය. සමග උදව් කරන්න, මම ඔබ භාවිතා යෝජනා join()හා expanduser()කාර්යයන් ඉටු කිරීමට os.pathමොඩියුලය, සහ සමහර විට getcwd()ක්රියාත්මක වීos මෙන්ම මොඩියුලය.

උදාහරණ ලෙස:

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 

ඔබ සොයා ගැනීම සඳහා පයිතන් ක්‍රියාත්මක කිරීමක් සොයන්නේ නම් , මෙය මම නිතර භාවිතා කරන වට්ටෝරුවකි:

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

ඒ නිසා මම එයින් PyPI පැකේජයක් සාදා ඇති අතර GitHub ගබඩාවක් ද ඇත. මෙම කේතය සඳහා යමෙකු එය ප්‍රයෝජනවත් යැයි සිතයි.

වැඩි ප්‍රති results listdir()ල සඳහා , ඔබට ක්‍රමවේදය භාවිතා කළ හැකියos ජනක යන්ත්‍රයක් සමඟ මොඩියුලයේ (උත්පාදක යන්ත්රය යනු එහි තත්වය පවත්වා ගෙන යන ප්‍රබල ක්‍රියාකාරකයෙකි, මතකද?). පහත කේතය අනුවාද දෙකම සමඟ හොඳින් ක්‍රියා කරයි: පයිතන් 2 සහ පයිතන් 3.

මෙන්න කේතයක්:

import os

def files(path):  
    for file in os.listdir(path):
        if os.path.isfile(os.path.join(path, file)):
            yield file

for file in files("."):  
    print (file)

එම listdir() ක්‍රමය මඟින් ලබා දී ඇති නාමාවලිය සඳහා ඇතුළත් කිරීම් ලැයිස්තුව නැවත ලබා දේ. ලබා දී ඇති ප්‍රවේශය ගොනුවක් නම් ක්‍රමය os.path.isfile()නැවත පැමිණේ True. තවද yieldක්‍රියාකරු විසින් විනෝදය අත්හරින නමුත් එහි වර්තමාන තත්වය පවත්වා ගෙන යන අතර එය නැවත ලබා දෙන්නේ ගොනුවක් ලෙස අනාවරණය කරගත් ප්‍රවේශයේ නම පමණි. ඉහත සියල්ලම අපට උත්පාදක ක්‍රියාකාරිත්වය ඉක්මවා යාමට ඉඩ දෙයි.

නිරපේක්ෂ ගොනු මාර්ග ලැයිස්තුවක් නැවත ලබා දීම, උප බහලුම් වෙත යොමු නොවේ

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

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

මෙන්න මම පුනරාවර්තන ව්‍යුහයක් භාවිතා කරමි.

බුද්ධිමත් ගුරුවරයෙක් වරක් මට මෙසේ පැවසීය.

යමක් කිරීමට ස්ථාපිත ක්‍රම කිහිපයක් ඇති විට, ඒ කිසිවක් සෑම අවස්ථාවකටම හොඳ නැත.

මේ අනුව මම ගැටලුවේ උප කුලකයක් සඳහා විසඳුමක් එක් කරමි : බොහෝ විට අපට අවශ්‍ය වන්නේ උප බහලුම් වෙත නොගොස් ගොනුවක් ආරම්භක නූලකට හා අවසන් නූලකට ගැලපේද යන්න පරීක්ෂා කිරීමයි. ගොනු නාම ලැයිස්තුවක් ලබා දෙන ශ්‍රිතයකට අපි කැමතියි, වැනි:

filenames = dir_filter('foo/baz', radical='radical', extension='.txt')

ඔබ මුලින් කාර්යයන් දෙකක් ප්‍රකාශ කිරීමට කැමති නම්, මෙය කළ හැකිය:

def file_filter(filename, radical='', extension=''):
    "Check if a filename matches a radical and extension"
    if not filename:
        return False
    filename = filename.strip()
    return(filename.startswith(radical) and filename.endswith(extension))

def dir_filter(dirname='', radical='', extension=''):
    "Filter filenames in directory according to radical and extension"
    if not dirname:
        dirname = '.'
    return [filename for filename in os.listdir(dirname)
                if file_filter(filename, radical, extension)]

නිත්‍ය ප්‍රකාශන සමඟ මෙම විසඳුම පහසුවෙන් සාමාන්‍යකරණය කළ හැකිය ( patternඔබේ රටා සෑම විටම ගොනු නාමයේ ආරම්භයට හෝ අවසානයට ඇලී සිටීමට ඔබට අවශ්‍ය නැතිනම් ඔබට තර්කයක් එක් කිරීමට අවශ්‍ය විය හැකිය ).

ජනක යන්ත්‍ර භාවිතා කිරීම

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)

පයිතන් 3.4+ සඳහා ඉතා කියවිය හැකි තවත් ප්‍රභේදයක් වන්නේ pathlib.Path.glob භාවිතා කිරීමයි:

from pathlib import Path
folder = '/foo'
[f for f in Path(folder).glob('*') if f.is_file()]

වඩාත් නිශ්චිත කිරීම සරල ය, උදා: සංකේතාත්මක සබැඳි නොවන පයිතන් ප්‍රභව ගොනු සඳහා පමණක් බලන්න, සියලු උප බහලුම්වල:

[f for f in Path(folder).glob('**/*.py') if not f.is_symlink()]

මෙන්න මේ සඳහා මගේ පොදු කාර්ය කාර්යය. එය වඩාත් ප්‍රයෝජනවත් බව මා සොයාගත් බැවින් එය ගොනු නාමවලට ​​වඩා ගොනු මාර්ග ලැයිස්තුවක් ලබා දෙයි. එය බහුකාර්ය බවට පත් කරන විකල්ප තර්ක කිහිපයක් ඇත. උදාහරණයක් ලෙස, මම බොහෝ විට එය භාවිතා කරන්නේ pattern='*.txt'හෝ වැනි තර්ක සමඟ ය subfolders=True.

import os
import fnmatch

def list_paths(folder='.', pattern='*', case_sensitive=False, subfolders=False):
    """Return a list of the file paths matching the pattern in the specified 
    folder, optionally including files inside subfolders.
    """
    match = fnmatch.fnmatchcase if case_sensitive else fnmatch.fnmatch
    walked = os.walk(folder) if subfolders else [next(os.walk(folder))]
    return [os.path.join(root, f)
            for root, dirnames, filenames in walked
            for f in filenames if match(f, pattern)]

ප්‍රභව මාර්ග සහ ගොනු වර්ගය ආදානය ලෙස සැපයිය හැකි නියැදි එක් ලයිනර් එකක් මම ලබා දෙන්නෙමි. කේතය csv දිගුව සහිත ගොනු නාම ලැයිස්තුවක් ලබා දෙයි. භාවිතා කරන්න . සියලුම ලිපිගොනු ආපසු ලබා දිය යුතු නම්. මෙය ද උප බහලුම් පුනරාවර්තනය කරයි.

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

අවශ්‍ය පරිදි ගොනු දිගු සහ ප්‍රභව මාර්ගය වෙනස් කරන්න.

Python2 සඳහා: නල ස්ථාපනය rglob

import rglob
file_list=rglob.rglob("/home/base/dir/", "*")
print file_list

dircache "2.6 අනුවාදයෙන් ඉවත් කර ඇත: පයිතන් 3.0 හි dircache මොඩියුලය ඉවත් කර ඇත."

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