പൈത്തൺ ഉപയോഗിച്ച് ഒരു ഡയറക്‌ടറിയിലെ എല്ലാ ഫയലുകളും ലിസ്റ്റുചെയ്യുന്നതും അവയെ ഒരു ലിസ്റ്റിൽ ചേർക്കുന്നതും എങ്ങനെ

പൈത്തണിലെ ഡയറക്ടറി ഫയൽ ലിസ്റ്റിംഗ്

നിങ്ങൾ ഫയലുകൾ ഓർഗനൈസുചെയ്യുകയോ ഡാറ്റ പ്രോസസ്സ് ചെയ്യുകയോ ടാസ്‌ക്കുകൾ ഓട്ടോമേറ്റ് ചെയ്യുകയോ ചെയ്യുകയാണെങ്കിൽ, ഒരു ഡയറക്‌ടറിയിലെ എല്ലാ ഫയലുകളും ലിസ്റ്റുചെയ്യുന്നത് പൈത്തൺ പ്രോഗ്രാമിംഗിലെ ഒരു സാധാരണ ജോലിയാണ്. ഇത് എളുപ്പത്തിലും കാര്യക്ഷമമായും പൂർത്തിയാക്കാൻ പൈത്തൺ നിരവധി മാർഗങ്ങൾ നൽകുന്നു.

ഈ ലേഖനത്തിൽ, പൈത്തൺ ഉപയോഗിച്ച് ഒരു ഡയറക്‌ടറിയിലെ എല്ലാ ഫയലുകളും ലിസ്റ്റുചെയ്യുന്നതിനുള്ള വിവിധ മാർഗങ്ങളും അവ ഒരു ലിസ്റ്റിലേക്ക് എങ്ങനെ ചേർക്കാമെന്നും ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. അവസാനത്തോടെ, നിങ്ങളുടെ പൈത്തൺ പ്രോജക്‌റ്റുകളിൽ ഡയറക്‌ടറി ഉള്ളടക്കങ്ങൾ പ്രോഗ്രാമാമാറ്റിക് ആയി എങ്ങനെ കൈകാര്യം ചെയ്യാം എന്നതിനെക്കുറിച്ച് നിങ്ങൾക്ക് വ്യക്തമായ ധാരണ ലഭിക്കും.

പൈത്തണിലെ ഡയറക്ടറി ലിസ്റ്റിംഗ് സ്ക്രിപ്റ്റുകൾ മനസ്സിലാക്കുന്നു

ആദ്യ സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുന്നു os മൊഡ്യൂൾ, പ്രത്യേകിച്ച് os.walk(directory_path) ഡയറക്‌ടറി ട്രീയിലൂടെ സഞ്ചരിക്കാൻ ഫംഗ്‌ഷൻ. ഈ ഫംഗ്‌ഷൻ ഒരു ഡയറക്‌ടറി ട്രീയിൽ ഫയൽ നാമങ്ങൾ ജനറേറ്റുചെയ്യുന്നു, മുകളിലെ ഡയറക്‌ടറി മുതൽ ഇല ഡയറക്‌ടറികൾ വരെ. ഈ ലൂപ്പിനുള്ളിൽ, ഞങ്ങൾ ഉപയോഗിക്കുന്നു os.path.join(root, file) ഡയറക്‌ടറി പാത്തും ഫയലിൻ്റെ പേരും ശരിയായി സംയോജിപ്പിക്കുന്നതിന്, ഓപ്പറേറ്റിംഗ് സിസ്റ്റം പരിഗണിക്കാതെ തന്നെ അന്തിമ പാത സാധുതയുള്ളതാണെന്ന് ഉറപ്പാക്കുന്നു. എല്ലാ ഫയലുകളുടേയും പാഥുകൾ പിന്നീട് അനുബന്ധമായി ചേർക്കുന്നു files_list ലിസ്റ്റ്, അത് ഫംഗ്‌ഷൻ്റെ അവസാനം തിരികെ നൽകും. ഫയലുകൾ ക്രമാനുഗതമായി പ്രോസസ്സ് ചെയ്യുന്നതിനാൽ വലിയ ഡയറക്ടറി ഘടനകൾക്ക് ഈ രീതി ഫലപ്രദമാണ്.

രണ്ടാമത്തെ സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുന്നു pathlib ഫയൽസിസ്റ്റവുമായി സംവദിക്കുന്നതിന് ഒബ്ജക്റ്റ്-ഓറിയൻ്റഡ് ഇൻ്റർഫേസ് നൽകുന്ന ലൈബ്രറി. ഒരു സൃഷ്ടിച്ചുകൊണ്ട് ഞങ്ങൾ ആരംഭിക്കുന്നു Path തന്നിരിക്കുന്ന ഡയറക്‌ടറിക്കുള്ള ഒബ്‌ജക്റ്റ്. ദി path.rglob('*') തന്നിരിക്കുന്ന പാറ്റേണുമായി പൊരുത്തപ്പെടുന്ന എല്ലാ ഫയലുകളും ആവർത്തിച്ച് കണ്ടെത്തുന്നതിന് രീതി ഉപയോഗിക്കുന്നു. ദി file.is_file() കണ്ടെത്തിയ ഓരോ പാതയും ഒരു സാധാരണ ഫയലാണോ എന്ന് രീതി പരിശോധിക്കുന്നു. അങ്ങനെയാണെങ്കിൽ, ഞങ്ങൾ അതിനെ പരിവർത്തനം ചെയ്യുന്നു Path ഉപയോഗിക്കുന്ന ഒരു സ്ട്രിംഗിനെ ഒബ്ജക്റ്റ് ചെയ്യുക str(file) എന്നതിലേക്ക് ചേർക്കുക files_list. ഈ സമീപനം കൂടുതൽ ആധുനികവും പലപ്പോഴും അതിൻ്റെ വായനാക്ഷമതയ്ക്കും ഉപയോഗത്തിൻ്റെ എളുപ്പത്തിനും മുൻഗണന നൽകുന്നു. ഇത് വ്യത്യസ്‌ത തരം പാതകളും (സിംലിങ്കുകൾ പോലെ) കൂടുതൽ ഭംഗിയായി കൈകാര്യം ചെയ്യുന്നു.

import os

def list_files_in_directory(directory_path):
    files_list = []
    for root, dirs, files in os.walk(directory_path):
        for file in files:
            files_list.append(os.path.join(root, file))
    return files_list

# Example usage
directory_path = '/path/to/directory'
files = list_files_in_directory(directory_path)
print(files)

from pathlib import Path

def list_files(directory_path):
    path = Path(directory_path)
    files_list = [str(file) for file in path.rglob('*') if file.is_file()]
    return files_list

# Example usage
directory_path = '/path/to/directory'
files = list_files(directory_path)
print(files)

പൈത്തണിലെ ഡയറക്‌ടറി ഫയൽ ലിസ്റ്റിംഗിനുള്ള വിപുലമായ സാങ്കേതിക വിദ്യകൾ

മുമ്പ് ചർച്ച ചെയ്ത രീതികൾക്ക് പുറമേ, ഒരു ഡയറക്ടറിയിൽ ഫയലുകൾ ലിസ്റ്റുചെയ്യുന്നതിനുള്ള മറ്റൊരു ശക്തമായ സമീപനം ഉപയോഗിക്കുന്നത് ഉൾപ്പെടുന്നു os.scandir() പ്രവർത്തനം. ഈ രീതി ഒരു ഇറ്ററേറ്റർ നൽകുന്നു os.DirEntry ഫയലുകളെയും ഡയറക്‌ടറികളെയും കുറിച്ചുള്ള വിവരങ്ങൾ ഉൾക്കൊള്ളുന്ന ഒബ്‌ജക്‌റ്റുകൾ. ഇത് കൂടുതൽ കാര്യക്ഷമമാണ് os.listdir() അഥവാ os.walk() കാരണം ഇത് ഒരൊറ്റ സിസ്റ്റം കോളിൽ ഡയറക്ടറി എൻട്രികളും അവയുടെ ആട്രിബ്യൂട്ടുകളും വീണ്ടെടുക്കുന്നു. വലിയ ഡയറക്‌ടറികൾ കൈകാര്യം ചെയ്യുമ്പോൾ അല്ലെങ്കിൽ വലുപ്പം അല്ലെങ്കിൽ പരിഷ്‌ക്കരണ സമയം പോലുള്ള അവയുടെ ആട്രിബ്യൂട്ടുകളെ അടിസ്ഥാനമാക്കി ഫയലുകൾ ഫിൽട്ടർ ചെയ്യേണ്ടിവരുമ്പോൾ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാകും.

മറ്റൊരു നൂതന സാങ്കേതികത ഉപയോഗിക്കുന്നത് ഉൾപ്പെടുന്നു glob പാത്ത് നെയിം പാറ്റേൺ വിപുലീകരണത്തിനായി ഒരു ഫംഗ്ഷൻ നൽകുന്ന മൊഡ്യൂൾ. ദി glob.glob() ഫംഗ്ഷൻ ഒരു നിർദ്ദിഷ്ട പാറ്റേണുമായി പൊരുത്തപ്പെടുന്ന പാതകളുടെ ഒരു ലിസ്റ്റ് നൽകുന്നു. ആവർത്തന ഫയൽ ലിസ്റ്റിംഗിനായി, glob.iglob() കൂടെ ഉപയോഗിക്കാം recursive=True പരാമീറ്റർ. ലളിതമായ പാറ്റേൺ പൊരുത്തപ്പെടുത്തലിന് ഈ രീതി വളരെ കാര്യക്ഷമമാണ്, കൂടാതെ നിർദ്ദിഷ്ട ഫയൽ തരങ്ങൾ പ്രോസസ്സ് ചെയ്യേണ്ട ഡാറ്റ പ്രോസസ്സിംഗ് പൈപ്പ്ലൈനുകളിൽ ഇത് പലപ്പോഴും ഉപയോഗിക്കുന്നു. കൂടാതെ, ഈ രീതികൾ സമാന്തര പ്രോസസ്സിംഗ് ലൈബ്രറികളുമായി സമന്വയിപ്പിക്കുന്നു concurrent.futures മൾട്ടി-കോർ പ്രോസസറുകൾ പ്രയോജനപ്പെടുത്തുന്നതിലൂടെ ഫയൽ സിസ്റ്റം പ്രവർത്തനങ്ങൾ ഗണ്യമായി വേഗത്തിലാക്കാൻ കഴിയും.