IlmHamroh
Python kursi/Avtomatlashtirish2/10-dars15 daqiqa
Mundarija (22)

26.2-dars: Fayllarni avtomatlashtirish

26-QISM — AVTOMATLASHTIRISH · 2-dars

1. Kirish va motivatsiya

Avtomatlashtirishning eng ko'p uchraydigan vazifasi — fayllar bilan ishlash: yuzlab fayllarni nomlash, papkalarga tartiblash, qidirish, ko'chirish, nusxalash, o'chirish. Qo'lda (Explorer/Finder bilan) — sekin, xatolarga moyil, zerikarli. Python bilan — bir skript, bir soniya. "Downloads papkasidagi barcha rasmlarni tur bo'yicha papkalarga ko'chir", "eski log fayllarni o'chir", "fayllarni sana bo'yicha nomla".

Fayllarni avtomatlashtirish — Python'ning fayl vositalari: pathlib (26.1 — yo'llar, .glob bilan qidirish), shutil (yuqori daraja — ko'chirish, nusxalash, o'chirish), os (past daraja — tizim amallari). Asosiy amallar: topish (glob — naqsh bo'yicha), nomlash (rename), ko'chirish (shutil.move), nusxalash (shutil.copy), o'chirish (unlink), papka yaratish (mkdir). Bu kundalik fayl vazifalarini avtomatlashtiradi. Fayl avtomatlashtirish — Python'ning eng amaliy ishi.

Real vaziyat. Bir fotograf har oy minglab rasmlarni sana va tur bo'yicha papkalarga tartiblardi — soatlab qo'lda. Python skript yozildi: pathlib.glob bilan rasmlarni topdi, stat bilan sanani oldi, shutil.move bilan papkalarga ko'chirdi. Soatlab ish bir daqiqada. Xatosiz, takrorlanadigan. Fayl avtomatlashtirish — vaqtni keskin tejaydi. Qo'lda ish o'rniga skript.

Bu darsda fayllarni avtomatlashtirishni o'rganamiz.

Bu darsda:

  • Fayllarni topish (glob)
  • Ko'chirish va nusxalash (shutil)
  • Nomlash (rename)
  • Papka yaratish (mkdir)
  • O'chirish (unlink)
  • Fayl ma'lumoti (stat)
  • O'qish/yozish (read_text)
  • Amaliy: fayl tartiblash

ℹ Misollarda pathlib, shutil vaqtincha papkada (tempfile) sinaladi — deterministik.

2. Nazariya — chuqur tushuntirish

2.1. Fayllarni topish (glob)

Naqsh bo'yicha fayllar:

python
from pathlib import Path
Path("papka").glob("*.csv")         # papkadagi CSV fayllar
Path("papka").glob("**/*.csv")      # ichma-ich (rekursiv)
Path("papka").iterdir()             # barcha (fayl + papka)
[p for p in Path(".").glob("*.txt")]  # ro'yxatga

Fayllarni topish (glob — 26.1, 15-qism): Path("papka").glob("*.csv") (papkadagi CSV — naqsh bilan), glob("**/*.csv") (rekursiv — ichma-ich papkalar ham), iterdir() (barcha element — fayl va papka). * (istalgan belgi), ? (bitta belgi), [abc] (to'plam). Bu ma'lum turdagi fayllarni topishning asosi (avtomatlashtirishning birinchi qadami). Natija — Path obyektlar (generator — ro'yxatga list()).

2.2. Ko'chirish va nusxalash (shutil)

Fayllarni joydan joyga:

python
import shutil
shutil.move("manba.txt", "yangi/joy.txt")     # ko'chirish (o'chiradi)
shutil.copy("manba.txt", "nusxa.txt")          # nusxalash (qoldiradi)
shutil.copytree("papka", "nusxa_papka")        # papkani nusxalash

shutil — yuqori daraja fayl amallari: move (ko'chirish — manbani o'chiradi), copy (nusxalash — manbani qoldiradi), copytree (butun papkani nusxalash), rmtree (papkani o'chirish — ehtiyot!). move/copy — fayl tartiblashda asosiy. pathlib.rename ham ko'chiradi (bir disk ichida), shutil.move (disklararo ham). Ko'chirish va nusxalash — fayl tartiblashning yuragi.

2.3. Nomlash (rename)

Fayl nomini o'zgartirish:

python
from pathlib import Path
Path("eski.txt").rename("yangi.txt")
# ko'plab nomlash (naqsh):
for i, f in enumerate(Path(".").glob("*.jpg")):
    f.rename(f"rasm_{i:03d}.jpg")    # rasm_000, rasm_001

Nomlash (Path.rename(yangi)) — fayl nomini o'zgartirish (yoki ko'chirish — yangi yo'l). Ko'plab nomlash — avtomatlashtirishning klassik vazifasi: glob bilan topib, siklda rename (rasm_{i:03d} — tartibli raqam). Bu qo'lda juda zerikarli, skriptda bir soniya. Ehtiyot: rename mavjud faylni ustiga yozadi (yo'qotish). Yangi nom noyob bo'lsin. Ko'plab nomlash — fayl avtomatlashtirishning eng foydali ishi.

2.4. Papka yaratish (mkdir)

Papkalarni yaratish:

python
from pathlib import Path
Path("yangi_papka").mkdir()                    # yaratish
Path("a/b/c").mkdir(parents=True, exist_ok=True)  # ichma-ich + mavjud OK

Papka yaratish (Path.mkdir()): mkdir() (bitta papka), parents=True (ichma-ich — a/b/c barcha daraja), exist_ok=True (mavjud bo'lsa xato bermasin — muhim!). Fayllarni tartiblashda papkalar yaratiladi (tur bo'yicha, sana bo'yicha). exist_ok=True — skript qayta ishlaganda xato bermaydi (idempotent). Papka yaratish — fayl tashkil qilishning asosi.

Fayllarni o'chirish:

python
from pathlib import Path
Path("fayl.txt").unlink()              # fayl o'chirish
Path("fayl.txt").unlink(missing_ok=True)  # yo'q bo'lsa ham OK
import shutil
shutil.rmtree("papka")                 # papka + ichi (EHTIYOT!)

O'chirish: Path.unlink() (fayl o'chirish), missing_ok=True (yo'q bo'lsa xato bermasin), shutil.rmtree(papka) (papka + barcha ichi — juda ehtiyot!). O'chirish qaytarib bo'lmaydi (savdoga tashlamaydi — butunlay) — ehtiyot bilan: avval tekshir (glob), tasdiqla, yoki savdoga ko'chir (o'chirish o'rniga). Avtomatlashtirishda o'chirish xavfli (skript ko'p faylni o'chirishi mumkin). "O'chirishdan oldin ikki marta o'yla".

2.6. Fayl ma'lumoti (stat)

Fayl haqida:

python
from pathlib import Path
p = Path("fayl.txt")
p.stat().st_size        # hajm (bayt)
p.stat().st_mtime       # o'zgartirilgan vaqt
p.is_file(); p.is_dir() # fayl/papka
p.exists()              # bormi

Fayl ma'lumoti: stat().st_size (hajm — bayt), stat().st_mtime (oxirgi o'zgarish vaqti — sana bo'yicha tartiblash), is_file()/is_dir() (fayl yoki papka), exists() (bormi). Bu fayllarni shart bo'yicha tanlashda (katta fayllar, eski fayllar) va tartiblashda (sana bo'yicha) kerak. Fayl metama'lumoti — aqlli avtomatlashtirish (nafaqat nom, balki xususiyat bo'yicha).

2.7. O'qish/yozish (read_text)

Fayl mazmuni:

python
from pathlib import Path
matn = Path("fayl.txt").read_text(encoding="utf-8")   # o'qish
Path("yangi.txt").write_text("mazmun", encoding="utf-8")  # yozish
data = Path("fayl.bin").read_bytes()                   # binar

O'qish/yozish (pathlib — 15-qism): read_text(encoding="utf-8") (matn o'qish — bir qatorda, open o'rniga), write_text(matn) (yozish), read_bytes/write_bytes (binar). encoding="utf-8" — o'zbekcha uchun. Bu fayl mazmuni bilan ishlash (nafaqat nom/joy). Avtomatlashtirishda: fayllarni o'qib qayta ishlash, hisobot yozish. pathlib — oddiy o'qish/yozish uchun qulay (katta fayl — open + sikl).

2.8. Fayl avtomatlashtirish — ehtiyot

Fayl avtomatlashtirish kuchli, lekin xavfli (ko'p faylga ta'sir): o'chirish qaytarib bo'lmaydi (avval sinab ko'r — glob natijani chop et, keyin o'chir), ko'chirish/nomlash ustiga yozadi (noyob nom), skript ko'p faylni o'zgartiradi (bir xato — ko'p zarar). Xavfsizlik: avval sinab ko'r (nima o'zgaradi — chop et, o'zgartmasdan), nusxa bilan ishla (asl saqla), exist_ok (idempotent). "Kuch bilan mas'uliyat" — fayl skripti ko'p faylni bir zumda o'zgartiradi. Avtomatlashtirish — foydali, lekin ehtiyotli.

3. Tez ma'lumotnoma

python
from pathlib import Path
import shutil

# topish (glob):
Path("papka").glob("*.csv")          # naqsh
Path("papka").glob("**/*.csv")       # rekursiv
Path("papka").iterdir()              # barcha

# ko'chirish/nusxalash (shutil):
shutil.move("a.txt", "yangi/a.txt")  # ko'chir
shutil.copy("a.txt", "b.txt")        # nusxa

# nomlash:
Path("eski.txt").rename("yangi.txt")

# papka:
Path("a/b/c").mkdir(parents=True, exist_ok=True)

# o'chirish (EHTIYOT):
Path("f.txt").unlink(missing_ok=True)
shutil.rmtree("papka")

# ma'lumot:
p.stat().st_size; p.stat().st_mtime
p.is_file(); p.is_dir(); p.exists()

# o'qish/yozish:
Path("f.txt").read_text(encoding="utf-8")
Path("f.txt").write_text("mazmun", encoding="utf-8")

Fayl avtomatlashtirish xulosasi

glob (topish, rekursiv) · shutil.move/copy (ko'chir/nusxa) · rename (nomlash)
mkdir (parents, exist_ok) · unlink/rmtree (o'chir — EHTIYOT) · stat (ma'lumot)
read_text/write_text · avval sinab ko'r (xavfli amal)

4. Batafsil misollar

Misollarda pathlib, shutil vaqtincha papkada (tempfile) sinaladi — deterministik, xavfsiz.

Misol 1 — Fayllarni topish va ma'lumot

python
"""glob (naqsh bo'yicha topish); stat (hajm); is_file — fayllarni tanlash."""

import tempfile
from pathlib import Path


def main() -> None:
    # vaqtincha papka va fayllar (deterministik)
    base = Path(tempfile.mkdtemp())
    for nom in ["a.txt", "b.csv", "c.txt", "d.csv", "e.log"]:
        (base / nom).write_text("test mazmun", encoding="utf-8")

    print("=== 1. Barcha fayllar (iterdir) ===")
    fayllar = sorted(p.name for p in base.iterdir() if p.is_file())
    print(f"  {fayllar}")

    print("\n=== 2. CSV fayllar (glob) ===")
    csv = sorted(p.name for p in base.glob("*.csv"))
    print(f"  {csv}")

    print("\n=== 3. Fayl ma'lumoti (stat) ===")
    p = base / "a.txt"
    print(f"  a.txt hajmi: {p.stat().st_size} bayt")
    print(f"  fayl-mi: {p.is_file()}, papka-mi: {p.is_dir()}")

    print("\n=== 4. Shart bo'yicha (kengaytirish) ===")
    txt = [p.name for p in base.glob("*.txt")]
    print(f"  txt fayllar: {sorted(txt)}, soni: {len(txt)}")
    print("  ⭐ glob (topish) + stat (ma'lumot) — fayllarni tanlash")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Barcha fayllar (iterdir) ===
  ['a.txt', 'b.csv', 'c.txt', 'd.csv', 'e.log']

=== 2. CSV fayllar (glob) ===
  ['b.csv', 'd.csv']

=== 3. Fayl ma'lumoti (stat) ===
  a.txt hajmi: 11 bayt
  fayl-mi: True, papka-mi: False

=== 4. Shart bo'yicha (kengaytirish) ===
  txt fayllar: ['a.txt', 'c.txt'], soni: 2
  ⭐ glob (topish) + stat (ma'lumot) — fayllarni tanlash

Nima ko'rsatdi: 2.1, 2.6-bo'limlar.

Misol 2 — Nomlash va papka yaratish

python
"""rename (nomlash, ko'plab); mkdir (papka yaratish, parents/exist_ok)."""

import tempfile
from pathlib import Path


def main() -> None:
    base = Path(tempfile.mkdtemp())
    for nom in ["photo1.jpg", "photo2.jpg", "photo3.jpg"]:
        (base / nom).write_text("rasm", encoding="utf-8")

    print("=== 1. Boshlang'ich fayllar ===")
    print(f"  {sorted(p.name for p in base.iterdir())}")

    print("\n=== 2. Ko'plab nomlash (tartibli raqam) ===")
    for i, f in enumerate(sorted(base.glob("*.jpg"))):
        f.rename(base / f"rasm_{i:03d}.jpg")
    print(f"  {sorted(p.name for p in base.iterdir())}")

    print("\n=== 3. Papka yaratish (parents, exist_ok) ===")
    yangi = base / "arxiv" / "2024"
    yangi.mkdir(parents=True, exist_ok=True)
    print(f"  yaratildi: {yangi.exists()}")

    print("\n=== 4. exist_ok (qayta yaratish xato bermaydi) ===")
    yangi.mkdir(parents=True, exist_ok=True)     # ikkinchi marta
    print(f"  qayta yaratish xatosiz: {yangi.exists()}")
    print("  ⭐ rename (ko'plab nomlash), mkdir (papka)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Boshlang'ich fayllar ===
  ['photo1.jpg', 'photo2.jpg', 'photo3.jpg']

=== 2. Ko'plab nomlash (tartibli raqam) ===
  ['rasm_000.jpg', 'rasm_001.jpg', 'rasm_002.jpg']

=== 3. Papka yaratish (parents, exist_ok) ===
  yaratildi: True

=== 4. exist_ok (qayta yaratish xato bermaydi) ===
  qayta yaratish xatosiz: True
  ⭐ rename (ko'plab nomlash), mkdir (papka)

Nima ko'rsatdi: 2.3, 2.4-bo'limlar.

Misol 3 — Ko'chirish va nusxalash

python
"""shutil.move (ko'chirish — o'chiradi); shutil.copy (nusxalash — qoldiradi)."""

import shutil
import tempfile
from pathlib import Path


def main() -> None:
    base = Path(tempfile.mkdtemp())
    for nom in ["hisobot.csv", "rasm.jpg", "matn.txt"]:
        (base / nom).write_text("data", encoding="utf-8")

    print("=== 1. Boshlang'ich ===")
    print(f"  {sorted(p.name for p in base.iterdir())}")

    print("\n=== 2. Papka yaratish va ko'chirish (move) ===")
    (base / "csv_papka").mkdir()
    shutil.move(str(base / "hisobot.csv"), str(base / "csv_papka" / "hisobot.csv"))
    print(f"  csv_papka: {[p.name for p in (base / 'csv_papka').iterdir()]}")
    print(f"  asl joyda hisobot.csv: {(base / 'hisobot.csv').exists()} (ko'chdi)")

    print("\n=== 3. Nusxalash (copy — qoldiradi) ===")
    shutil.copy(str(base / "matn.txt"), str(base / "matn_nusxa.txt"))
    print(f"  asl matn.txt: {(base / 'matn.txt').exists()}")
    print(f"  nusxa matn_nusxa.txt: {(base / 'matn_nusxa.txt').exists()}")

    print("\n=== 4. move vs copy ===")
    print("  move: manbani o'chiradi (ko'chirish)")
    print("  copy: manbani qoldiradi (nusxalash)")
    print("  ⭐ shutil — ko'chirish (move) va nusxalash (copy)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Boshlang'ich ===
  ['hisobot.csv', 'matn.txt', 'rasm.jpg']

=== 2. Papka yaratish va ko'chirish (move) ===
  csv_papka: ['hisobot.csv']
  asl joyda hisobot.csv: False (ko'chdi)

=== 3. Nusxalash (copy — qoldiradi) ===
  asl matn.txt: True
  nusxa matn_nusxa.txt: True

=== 4. move vs copy ===
  move: manbani o'chiradi (ko'chirish)
  copy: manbani qoldiradi (nusxalash)
  ⭐ shutil — ko'chirish (move) va nusxalash (copy)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 4 — Amaliy: fayllarni tur bo'yicha tartiblash

Real avtomatlashtirish: aralash fayllarni kengaytirish bo'yicha papkalarga tartiblash. Bu — fayl tashkil qilishning namunasi.

python
"""to'liq: aralash fayllarni kengaytirish bo'yicha papkalarga tartiblash (glob + mkdir + move)."""

import shutil
import tempfile
from pathlib import Path


def tartibla(papka: Path) -> dict:
    """Fayllarni kengaytirish bo'yicha papkalarga ko'chir."""
    natija: dict = {}
    for f in list(papka.iterdir()):
        if f.is_file():
            kengaytma = f.suffix[1:] or "boshqa"   # ".csv" → "csv"
            maqsad = papka / kengaytma
            maqsad.mkdir(exist_ok=True)
            shutil.move(str(f), str(maqsad / f.name))
            natija.setdefault(kengaytma, []).append(f.name)
    return natija


def main() -> None:
    base = Path(tempfile.mkdtemp())
    for nom in ["a.csv", "b.txt", "c.csv", "d.jpg", "e.txt", "f.jpg"]:
        (base / nom).write_text("data", encoding="utf-8")

    print("=== 1. Boshlang'ich (aralash) ===")
    print(f"  {sorted(p.name for p in base.iterdir())}")

    print("\n=== 2. Tur bo'yicha tartiblash ===")
    natija = tartibla(base)
    for kengaytma in sorted(natija):
        print(f"  {kengaytma}: {sorted(natija[kengaytma])}")

    print("\n=== 3. Papkalar tuzilishi ===")
    for papka in sorted(p.name for p in base.iterdir() if p.is_dir()):
        fayllar = sorted(x.name for x in (base / papka).iterdir())
        print(f"  {papka}/: {fayllar}")

    print("\n=== 4. Yakun ===")
    print(f"  {len(natija)} tur papkasi yaratildi")
    print("  ⭐ fayl tartiblash — glob + mkdir + move (avtomatik)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Boshlang'ich (aralash) ===
  ['a.csv', 'b.txt', 'c.csv', 'd.jpg', 'e.txt', 'f.jpg']

=== 2. Tur bo'yicha tartiblash ===
  csv: ['a.csv', 'c.csv']
  jpg: ['d.jpg', 'f.jpg']
  txt: ['b.txt', 'e.txt']

=== 3. Papkalar tuzilishi ===
  csv/: ['a.csv', 'c.csv']
  jpg/: ['d.jpg', 'f.jpg']
  txt/: ['b.txt', 'e.txt']

=== 4. Yakun ===
  3 tur papkasi yaratildi
  ⭐ fayl tartiblash — glob + mkdir + move (avtomatik)

Nima ko'rsatdi: 2.1–2.8-bo'limlar.

5. To'g'ri va noto'g'ri tushunishlar

Noto'g'ri fikr To'g'risi
"Fayl ishi — qo'lda" Avtomatlashtirish (skript)
"glob faqat bir papka" ** rekursiv
"move = copy" move o'chiradi, copy qoldiradi
"O'chirish — savdoga" Butunlay (qaytarib bo'lmaydi)
"rename xavfsiz" Ustiga yozadi
"mkdir mavjudda xato" exist_ok=True
"Skript kam faylga" Ko'p faylni bir zumda
"Sinash keraksiz" Avval sinab ko'r (xavfli)

6. Keng tarqalgan xatolar va yechimlari

1. O'chirishdan oldin sinamaslik

python
for f in glob("*"): f.unlink()   # ⚠️ barcha o'chdi (xato bo'lsa?)
for f in glob("*"): print(f)   # avval ko'r    # ✅ keyin o'chir

2. rename ustiga yozish

python
f.rename("mavjud.txt")   # ⚠️ mavjud yo'qoladi
# noyob nom yoki tekshir                         # ✅

3. mkdir mavjudda crash

python
Path("papka").mkdir()   # mavjud bo'lsa xato     # ⚠️
Path("papka").mkdir(exist_ok=True)                # ✅

4. rmtree ehtiyotsiz

python
shutil.rmtree(papka)   # butun papka (EHTIYOT)   # ⚠️
# avval tekshir, tasdiqla                          # ✅

5. Encoding unutish (o'qish/yozish)

python
Path("f.txt").read_text()   # ba'zan xato        # ⚠️
Path("f.txt").read_text(encoding="utf-8")         # ✅

6. glob generator (ikki marta)

python
g = Path(".").glob("*")
list(g); list(g)   # ikkinchi bo'sh              # ⚠️
fayllar = list(Path(".").glob("*"))               # ✅

7. Nisbiy yo'l (noto'g'ri papka)

python
Path("fayl.txt")   # joriy papkaga bog'liq       # ⚠️
Path("/aniq/yo'l/fayl.txt")   # aniq              # ✅ (yoki base bilan)

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 26.1-dars (o'tilgan): Skript — fayl skripti
  • 15-qism (o'tilgan): pathlib, fayl I/O
  • 24.6-dars (o'tilgan): CSV o'qish — fayllardan
  • 26.10-dars: Excel — fayl formati
  • 26.9-dars: Cron — fayl tozalash (rejalangan)

8. Eng yaxshi amaliyotlar

  1. glob bilan top (naqsh, rekursiv).

  2. shutil.move/copy (ko'chir/nusxa).

  3. mkdir(exist_ok=True) (idempotent).

  4. O'chirishdan oldin sinab ko'r (chop et).

  5. Noyob nom (rename ustiga yozadi).

  6. encoding="utf-8" (o'zbekcha).

  7. glob natijasini ro'yxatga (generator).

  8. Xavfli amalda nusxa bilan (asl saqla).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # glob nima?
2.  # ** nima?
3.  # iterdir nima?
4.  # shutil.move nima?
5.  # shutil.copy nima?
6.  # move vs copy?
7.  # rename nima?
8.  # mkdir exist_ok?
9.  # unlink nima?
10. # rmtree nima (ehtiyot)?
11. # stat nima?
12. # o'chirish qaytarib bo'ladimi?
Javoblar
  1. Naqsh bo'yicha fayl topish
  2. Rekursiv (ichma-ich papka)
  3. Papkadagi barcha element
  4. Ko'chirish (o'chiradi)
  5. Nusxalash (qoldiradi)
  6. move o'chiradi, copy qoldiradi
  7. Nom o'zgartirish
  8. Mavjud bo'lsa xato bermasin
  9. Fayl o'chirish
  10. Papka + ichi o'chirish (juda ehtiyot)
  11. Fayl ma'lumoti (hajm, vaqt)
  12. Yo'q (butunlay)

Vazifa 2: Xatolarni tuzating

python
1.  for f in glob("*"): f.unlink()   # avval sinab ko'r

2.  Path("papka").mkdir()   # mavjudda         # exist_ok

3.  Path("f.txt").read_text()                  # encoding

4.  g=glob("*"); list(g); list(g)              # ro'yxatga

5.  f.rename("mavjud.txt")                      # noyob nom
Javoblar
python
1.  for f in glob("*"): print(f)  # keyin o'chir

2.  Path("papka").mkdir(exist_ok=True)

3.  Path("f.txt").read_text(encoding="utf-8")

4.  fayllar = list(glob("*"))

5.  # noyob nom yoki tekshir

Vazifa 3: Topish

Fayllar:

  1. glob
  2. ** rekursiv
  3. iterdir
  4. stat

Vazifa 4: Nomlash/papka

Amal:

  1. rename
  2. Ko'plab nomlash
  3. mkdir
  4. exist_ok

Vazifa 5: Ko'chirish

shutil:

  1. move
  2. copy
  3. Farq
  4. Papka

Vazifa 6: Tartiblash

To'liq:

  1. Topish
  2. Papka
  3. Ko'chirish
  4. Statistika

Vazifa 7: O'ylash

Fayl avtomatlashtirish kuchli — skript ko'p faylni bir zumda o'zgartiradi. Lekin bu xavfli: o'chirish qaytarib bo'lmaydi, ko'chirish/nomlash ustiga yozadi, bir xato ko'p zarar. Nima uchun "avval sinab ko'r" (dry run — o'zgartmasdan nima o'zgaradiganini ko'rish) xavfli fayl amallarida muhim, va nega "kuch bilan mas'uliyat" avtomatlashtirishda ayniqsa amal qiladi?

Javob

Qisqa javob: Fayl avtomatlashtirish kuchli (skript ko'p faylni bir zumda o'zgartiradi) va shuning uchun xavfli: o'chirish qaytarib bo'lmaydi (savdoga emas — butunlay), ko'chirish/nomlash ustiga yozadi (yo'qotish), bir xato ko'p zarar (skript 1000 faylni noto'g'ri o'zgartiradi). "Avval sinab ko'r" (dry run — o'zgartmasdan nima o'zgaradiganini chop etish) muhim, chunki: xato mantiqni (noto'g'ri glob, noto'g'ri yo'l) oldin ko'rasiz (o'zgartmasdan), ishonch hosil qilasiz, keyin bajarasiz. "Kuch bilan mas'uliyat" avtomatlashtirishda ayniqsa amal qiladi, chunki: qo'lda bir faylni o'chirsangiz — bir xato; skript 1000 faylni o'chiradi — 1000 xato (bir zumda, qaytarib bo'lmaydi). Kuch (avtomatik, ko'p) mas'uliyat (ehtiyot, sinash, nusxa) talab qiladi. "Avtomatlashtirilgan xato — avtomatlashtirilgan zarar".

1. Fayl avtomatlashtirish kuchli va xavfli

Skript ko'p faylni bir zumda — kuch. Lekin xato ham ko'p (bir xato → 1000 fayl).

2. Nega xavfli

Amal Xavf
O'chirish Qaytarib bo'lmaydi
Ko'chirish/nomlash Ustiga yozadi
Ko'p fayl Bir xato → ko'p zarar

3. "Avval sinab ko'r" (dry run)

O'zgartmasdan nima o'zgaradiganini chop et: noto'g'ri mantiqni oldin ko'rasiz, ishonch, keyin bajar. Xatoni oldin top.

4. Kuch bilan mas'uliyat

Qo'lda — bir xato (bir fayl). Skript — 1000 xato (bir zumda). Kuch mas'uliyat talab qiladi: sinash, nusxa (asl saqla), ehtiyot (o'chirish).

5. Muhandislik saboqlari

  1. Fayl avtomatlashtirish kuchli, xavfli
  2. Avval sinab ko'r (dry run)
  3. Nusxa bilan ishla (asl saqla)
  4. Kuch bilan mas'uliyat (ko'p fayl)

6. Xulosa

  1. Skript ko'p faylni bir zumda
  2. Xato ham ko'p (qaytarib bo'lmaydi)
  3. Avval sinab ko'r (dry run)
  4. Kuch bilan mas'uliyat

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.

Xulosa

Bu darsda fayllarni avtomatlashtirishni o'rgandik.

Eng muhim uch fikr:

  1. Topish va ko'chirish/nusxalash. Fayllarni topish (glob — 26.1, 15-qism): Path("papka").glob("*.csv") (naqsh bilan), glob("**/*.csv") (rekursiv — ichma-ich), iterdir() (barcha element). Ko'chirish/nusxalash (shutil): move (ko'chirish — manbani o'chiradi), copy (nusxalash — manbani qoldiradi), copytree (papka nusxa), rmtree (papka o'chir — ehtiyot). pathlib.rename ham ko'chiradi. Bu fayl tartiblashning yuragi — topib, joydan joyga.

  2. Nomlash, papka, o'chirish, ma'lumot. Nomlash (Path.rename) — ko'plab nomlash avtomatlashtirishning klassik vazifasi (glob + siklda rename — rasm_{i:03d}). Papka yaratish (mkdir(parents=True, exist_ok=True) — ichma-ich + mavjudda xato bermasin). O'chirish (unlink(missing_ok=True), shutil.rmtree — qaytarib bo'lmaydi, ehtiyot). Fayl ma'lumoti (stat().st_size hajm, st_mtime vaqt, is_file()/is_dir(), exists() — shart bo'yicha tanlash). O'qish/yozish (read_text/write_text, encoding="utf-8").

  3. Kuch bilan mas'uliyat. Fayl avtomatlashtirish kuchli (skript ko'p faylni bir zumda o'zgartiradi) va shuning uchun xavfli: o'chirish qaytarib bo'lmaydi, ko'chirish/nomlash ustiga yozadi, bir xato ko'p zarar (1000 fayl). Xavfsizlik: avval sinab ko'r (dry run — o'zgartmasdan nima o'zgaradiganini chop et, xatoni oldin top), nusxa bilan ishla (asl saqla), exist_ok (idempotent). "Kuch bilan mas'uliyat" avtomatlashtirishda ayniqsa amal qiladi — qo'lda bir xato (bir fayl), skript 1000 xato (bir zumda). Avtomatlashtirish vaqtni keskin tejaydi (soatlab ish — daqiqada), lekin ehtiyotli. "Avtomatlashtirilgan xato — avtomatlashtirilgan zarar".

Keyingi darsda web scraping: requests ni o'rganamiz: internetdan ma'lumot yig'ish — veb sahifalarni yuklab, HTTP so'rovlar bilan ma'lumot olish — avtomatlashtirishning kuchli sohasi.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
26.2-dars: Fayllarni avtomatlashtirish — IlmHamroh