પાયથોનનો ઉપયોગ કરીને ડિરેક્ટરીમાં બધી ફાઇલોને કેવી રીતે સૂચિબદ્ધ કરવી અને તેમને સૂચિમાં ઉમેરો

પાયથોનમાં ડિરેક્ટરી ફાઇલ લિસ્ટિંગ

પાયથોન પ્રોગ્રામિંગમાં ડાયરેક્ટરીમાં બધી ફાઈલોની યાદી બનાવવી એ એક સામાન્ય કાર્ય છે, પછી ભલે તમે ફાઈલો ગોઠવી રહ્યાં હોવ, ડેટાની પ્રક્રિયા કરી રહ્યાં હોવ અથવા કાર્યોને સ્વચાલિત કરી રહ્યાં હોવ. પાયથોન આને સરળતાથી અને અસરકારક રીતે પૂર્ણ કરવા માટે ઘણી પદ્ધતિઓ પ્રદાન કરે છે.

આ લેખમાં, અમે પાયથોનનો ઉપયોગ કરીને ડિરેક્ટરીમાં બધી ફાઇલોને સૂચિબદ્ધ કરવાની વિવિધ રીતોનું અન્વેષણ કરીશું અને તેમને સૂચિમાં કેવી રીતે ઉમેરવું. અંત સુધીમાં, તમને તમારા પાયથોન પ્રોજેક્ટ્સમાં ડાયરેક્ટરી સામગ્રીને પ્રોગ્રામેટિક રીતે કેવી રીતે મેનેજ કરવી તેની સ્પષ્ટ સમજણ હશે.

પાયથોનમાં ડિરેક્ટરી લિસ્ટિંગ સ્ક્રિપ્ટને સમજવી

પ્રથમ સ્ક્રિપ્ટનો ઉપયોગ કરે છે 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 મલ્ટી-કોર પ્રોસેસર્સનો લાભ લઈને ફાઈલ સિસ્ટમની કામગીરીને નોંધપાત્ર રીતે ઝડપી બનાવી શકે છે.