ਬੈਚ ਫਾਈਲ ਨਾਮ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਇੱਕ ਸਤਰ ਜਾਂ ਕ੍ਰਮਵਾਰ ਨੰਬਰ ਜੋੜ ਕੇ ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਫਾਈਲ ਨਾਮ ਬਦਲਦਾ ਹੈ

OS ਮੋਡੀਊਲ ਅਤੇ ਗਲੋਬ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਲਕ ਵਿੱਚ ਨਾਮ ਬਦਲੋ।

ਫਾਈਲ ਨਾਮਾਂ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਸਤਰ ਜਾਂ ਕ੍ਰਮਵਾਰ ਨੰਬਰਾਂ ਨੂੰ ਜੋੜ ਕੇ ਬਲਕ ਵਿੱਚ ਇੱਕ ਫੋਲਡਰ ਵਿੱਚ ਫਾਈਲ ਨਾਮਾਂ ਨੂੰ ਬਦਲਣ ਅਤੇ ਨਾਮ ਬਦਲਣ ਲਈ 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