ફાઇલના નામ પહેલાં અને પછી સ્ટ્રિંગ અથવા ક્રમિક નંબર ઉમેરીને પાયથોનમાં ફાઇલનું નામ બદલો

ઓએસ મોડ્યુલ અને ગ્લોબ મોડ્યુલનો ઉપયોગ કરીને બલ્કમાં નામ બદલો.

ફાઇલના નામો પહેલાં અને પછી સ્ટ્રિંગ્સ અથવા ક્રમિક નંબરો ઉમેરીને બલ્કમાં ફોલ્ડરમાં ફાઇલના નામોને બદલવા અને તેનું નામ બદલવા માટે os મોડ્યુલ અને ગ્લોબ મોડ્યુલનો ઉપયોગ કરો.

ઉદાહરણ ફાઇલ માળખું

ઉદાહરણ તરીકે નીચેની ફાઇલ સ્ટ્રક્ચર લો. આ કિસ્સામાં, એવું માનવામાં આવે છે કે ફોલ્ડરમાં ફક્ત ફાઇલો (કોઈ ફોલ્ડર્સ નથી) છે.

.
└── testdir
    ├── a.jpg
    ├── b.jpg
    ├── c.jpg
    ├── d.jpg
    └── e.jpg

ધ્યાનમાં રાખવા જેવી બાબતો

પ્રક્રિયામાં ફાઇલનું નામ બદલવાનો સમાવેશ થતો હોવાથી, અસલ ફાઇલને અલગથી સાચવો જેથી નિષ્ફળતાના કિસ્સામાં તેને સાચવી શકાય.

ગ્લોબ મોડ્યુલ સાથે ફાઇલ સૂચિ મેળવો

ગ્લોબ મોડ્યુલ યુનિક્સ શેલ દ્વારા ઉપયોગમાં લેવાતા નિયમો અનુસાર ઉલ્લેખિત પેટર્ન સાથે મેળ ખાતા તમામ પાથનામો શોધી કાઢશે.
glob — Unix style pathname pattern expansion — Python 3.10.0 Documentation

ઉદાહરણ તરીકે, વર્તમાન ડિરેક્ટરીમાં ફાઇલ અને ડિરેક્ટરીના નામોની સૂચિ મેળવવા માટે નીચેના ફંક્શનનો ઉપયોગ કરી શકાય છે.
glob.glob('./*')
દલીલ નિરપેક્ષ માર્ગ અથવા સંબંધિત માર્ગ હોઈ શકે છે.

આ ઉદાહરણમાં, તે નીચેના જેવો દેખાશે.

import glob

print(glob.glob('./testdir/*'))
# => ['./testdir/a.jpg', './testdir/b.jpg', './testdir/c.jpg', './testdir/d.jpg', './testdir/e.jpg']

a.jpg ને બદલે, તમે દલીલ પાથ ઉમેરવા સાથે, નીચેનું મેળવી શકો છો.
./testdir/a.jpg

નીચે બતાવ્યા પ્રમાણે, તમે માત્ર ચોક્કસ એક્સ્ટેન્શન્સ મેળવવા માટે વાઇલ્ડકાર્ડ્સ (*) નો ઉપયોગ પણ કરી શકો છો.
glob.glob('./testdir/*.jpg')

નીચેની પેટર્ન મેચિંગનો ઉપયોગ કરી શકાય છે.

• *: દરેક વસ્તુ સાથે મેળ ખાય છે.
• ?કોઈપણ એક અક્ષર સાથે મેળ ખાય છે.
• [abc]: a, b, અથવા c માંથી એક અક્ષર સાથે મેળ ખાય છે.
• [!abc]: a, b, અથવા c સિવાયના એક અક્ષર સાથે મેળ ખાય છે

os.rename() સાથે નામ બદલો

os.rename(src, dst, *, src_dir_fd=None, dst_dir_fd=None)
ફાઇલ અથવા ડિરેક્ટરી src નું નામ dst માં બદલો.
os — Miscellaneous operating system interfaces — Python 3.10.0 Documentation

os મોડ્યુલના ફંક્શન rename() નો ઉપયોગ કરો, જે નામ સૂચવે છે તેમ તેનું નામ બદલશે.

import os
os.rename('./testdir/a.jpg', './testdir/a_000.jpg')

પછી, a.jpg નું નામ બદલીને a_000.jpg કરવામાં આવશે.

str.format() સાથે શૂન્ય-ભરેલા ક્રમિક નંબરો જનરેટ કરી રહ્યા છીએ

ઉદાહરણ તરીકે, ડઝનેક ફાઈલોમાં ક્રમિક નંબરો ઉમેરતી વખતે, અમે “0” અથવા “1” ને બદલે “00” અથવા “11” નો ઉપયોગ કરવા માંગીએ છીએ. જો તમે આ રીતે શૂન્ય ભરવા માંગતા હો, તો str.format() પદ્ધતિનો ઉપયોગ કરો.

str.format(args,*ક્વાર્ગ્સ)
સ્ટ્રિંગ ફોર્મેટિંગ કામગીરી કરે છે. સ્ટ્રિંગ કે જે આ પદ્ધતિનો ઉપયોગ કરે છે તેમાં સામાન્ય અક્ષરો અથવા અવેજી ક્ષેત્રો હોઈ શકે છે જે {} દ્વારા અલગ પડે છે.Built-in Types — Python 3.10.0 Documentation

ફોર્મેટ સ્પષ્ટીકરણ શબ્દમાળાઓનું સિન્ટેક્સ
ફોર્મેટિંગ સ્ટ્રિંગમાં “રિપ્લેસમેન્ટ ફીલ્ડ” સર્પાકાર કૌંસમાં બંધાયેલ છે {}.

રિપ્લેસમેન્ટ ફીલ્ડનું સિન્ટેક્સ નીચે મુજબ છે:
replacement_field ::= "{" [field_name] ["!" conversion] [":" format_spec] "}"

સરળ શબ્દોમાં, રિપ્લેસમેન્ટ ફીલ્ડ ફીલ્ડ_નામથી શરૂ થાય છે, જેના કારણે ઉલ્લેખિત ઑબ્જેક્ટનું મૂલ્ય ફોર્મેટ થાય છે અને રિપ્લેસમેન્ટ ફીલ્ડને બદલે આઉટપુટમાં દાખલ કરવામાં આવે છે. ક્ષેત્ર_નામ પછી, રૂપાંતર ક્ષેત્રને ઉદ્ગારવાચક ચિહ્ન ‘ દ્વારા અનુસરવામાં આવી શકે છે! ક્ષેત્ર_નામ પછી, રૂપાંતર ક્ષેત્રને ઉદ્ગારવાચક ચિહ્ન ‘ દ્વારા અનુસરવામાં આવી શકે છે! ફોર્મેટ_સ્પેકને અંતે કોલોન ‘:’ વડે લખી શકાય છે. આ બદલવાની કિંમતના બિન-ડિફોલ્ટ ફોર્મેટનો ઉલ્લેખ કરે છે.
string — Common string operations — Python 3.10.0 Documentation

જો તમે તેને અત્યારે 0 થી ભરવા માંગતા હો, તો નીચે મુજબ કરો.

# 3を2桁でゼロ埋め
print('{0:02d}'.format(3))
# => 03

# Fill in the zeros with three and four digits for 4 and 6, respectively.
print('{0:03d}, {1:04d}'.format(4, 6))
# => 004, 0006

ફાઇલ પહેલાં સ્ટ્રિંગ/ક્રમિક નંબર ઉમેરવા માટે કોડનું ઉદાહરણ

પ્રથમ, os.path.basename() સાથે ફાઇલનું નામ મેળવો. પછી, ફાઇલના નામની આગળ એક સ્ટ્રિંગ અથવા ક્રમિક નંબર ઉમેરો, અને તેને os.path.join() સાથે મૂળ પાથ સાથે જોડી દો.

નીચેનું ઉદાહરણ બધા ફાઇલ નામોની આગળ img_ ઉમેરે છે.

import os
import glob

path = "./testdir"
files = glob.glob(path + '/*')

for f in files:
    os.rename(f, os.path.join(path, 'img_' + os.path.basename(f)))

પરિણામ નીચે મુજબ છે.

.
└── testdir
    ├── img_a.jpg
    ├── img_b.jpg
    ├── img_c.jpg
    ├── img_d.jpg
    └── img_e.jpg

જો તમે ક્રમિક નંબરો ઉમેરવા માંગતા હો, તો સ્ટેટમેન્ટ માટે બદલો કંઈક આના જેવું કરો: સંખ્યાઓ 0 થી ક્રમમાં ગણવા માટે enumerate() કરો. આ કિસ્સામાં, સંખ્યા ત્રણ અંકોથી ભરેલી છે.

for i, f in enumerate(files):
    os.rename(f, os.path.join(path, '{0:03d}'.format(i) +
                              '_' + os.path.basename(f)))

અહીં પરિણામ છે.

.
└── testdir
    ├── 000_a.jpg
    ├── 001_b.jpg
    ├── 002_c.jpg
    ├── 003_d.jpg
    └── 004_e.jpg

જો તમે 0 ને બદલે 1 થી પ્રારંભ કરવા માંગતા હો, તો ગણતરીની બીજી દલીલ 1 પર સેટ કરો.

for i, f in enumerate(files, 1):
    os.rename(f, os.path.join(path, '{0:03d}'.format(i) +
                              '_' + os.path.basename(f)))

તે આ રીતે જાય છે.

.
└── testdir
    ├── 001_a.jpg
    ├── 002_b.jpg
    ├── 003_c.jpg
    ├── 004_d.jpg
    └── 005_e.jpg

ફાઇલ પછી સ્ટ્રિંગ/ક્રમિક નંબર ઉમેરવા માટે કોડનું ઉદાહરણ

ફાઇલને એક્સ્ટેંશન અને રૂટ પાથમાં વિભાજિત કરવા માટે os.path.splitext() નો ઉપયોગ કરો અને પછી રુટ પાથમાં સ્ટ્રિંગ્સ અથવા ક્રમિક નંબરો ઉમેરો. નીચેના ઉદાહરણમાં, બધા ફાઇલ નામો પછી _img ઉમેરવામાં આવે છે.

import os
import glob

files = glob.glob('./testdir/*')

for f in files:
    ftitle, fext = os.path.splitext(f)
    os.rename(f, ftitle + '_img' + fext)

પરિણામ આ છે.

.
└── testdir
    ├── a_img.jpg
    ├── b_img.jpg
    ├── c_img.jpg
    ├── d_img.jpg
    └── e_img.jpg

ફાઇલ પહેલાં સ્ટ્રિંગ/ક્રમિક નંબર ઉમેરવાની જેમ, ક્રમિક નંબર ઉમેરતી વખતે સ્ટેટમેન્ટ માટે બદલો.

for i, f in enumerate(files):
    ftitle, fext = os.path.splitext(f)
    os.rename(f, ftitle + '_' + '{0:03d}'.format(i) + fext)

.
└── testdir
    ├── a_000.jpg
    ├── b_001.jpg
    ├── c_002.jpg
    ├── d_003.jpg
    └── e_004.jpg