IlmHamroh
Python kursi/Avtomatlashtirish1/10-dars16 daqiqa
Mundarija (22)

26.1-dars: Skript yozish tamoyillari

26-QISM — AVTOMATLASHTIRISH · 1-dars

1. Kirish va motivatsiya

Python'ning eng amaliy kuchi — avtomatlashtirish: qo'lda qiladigan takroriy ishlarni (fayllarni tartiblash, ma'lumot yig'ish, hisobot yaratish, xabar yuborish) skript bilan avtomatik qilish. Bir marta yozasiz — ming marta ishlaydi. Lekin yaxshi skript oddiy koddan farq qiladi: argumentlar (moslashuvchan — har xil fayl), xatolarni boshqarish (nozik holatlar), log (nima bo'ldi), qayta ishlatiladigan (funksiyalar).

Skript yozish tamoyillari — professional avtomatlashtirish skripti: if __name__ == "__main__" (import va ishga tushirish ajratish — 07-qism), argparse (buyruq qatori argumentlari — moslashuvchan), chiqish kodlari (0 muvaffaqiyat, 0 emas xato — Bash bilan), logging (print emas — daraja, fayl), pathlib (fayl yo'llari — 15-qism). Bu skriptni ishonchli, moslashuvchan, qayta ishlatiladigan qiladi. Avtomatlashtirish — Python'ning kundalik qiymati.

Real vaziyat. Bir jamoa har kuni qo'lda 50 ta fayl nomini o'zgartirardi — 30 daqiqa, xatolarga moyil. Python skript yozildi: argparse bilan papka va naqsh argumentlari, pathlib bilan fayllar, logging bilan hisobot. Bir buyruqda, bir soniyada. Xatosiz, takrorlanadigan. Skript — 30 daqiqalik ishni avtomatlashtirdi. Yaxshi skript — moslashuvchan va ishonchli.

Bu darsda professional skript yozish tamoyillarini o'rganamiz.

Bu darsda:

  • Skript tuzilishi (main guard)
  • Buyruq qatori argumentlari (argparse)
  • Chiqish kodlari (exit codes)
  • Logging (print emas)
  • Fayl yo'llari (pathlib)
  • Xatolarni boshqarish
  • Qayta ishlatiladigan funksiyalar
  • Amaliy: avtomatlashtirish skripti

ℹ Misollarda argparse, pathlib, sys bilan sinaladi.

2. Nazariya — chuqur tushuntirish

2.1. Skript tuzilishi (main guard)

Skriptning to'g'ri tuzilishi:

python
def main() -> int:
    # asosiy mantiq
    return 0     # chiqish kodi

if __name__ == "__main__":
    import sys
    sys.exit(main())

Skript tuzilishi: if __name__ == "__main__" (07-qism — skript to'g'ridan ishga tushirilganda bajariladi, import qilinganda emas), main() funksiya (asosiy mantiq — qayta ishlatiladigan, testlanadigan), sys.exit(main()) (chiqish kodi). Bu skriptni modul ham (import) va skript ham (ishga tushirish) qiladi. Mantiq mainda (global emas — toza, testlanadigan). Professional skript asosi.

2.2. Buyruq qatori argumentlari (argparse)

Moslashuvchan skript — argumentlar:

python
import argparse
parser = argparse.ArgumentParser(description="Fayl qayta ishlash")
parser.add_argument("--input", required=True)       # majburiy
parser.add_argument("--count", type=int, default=1) # ixtiyoriy
parser.add_argument("--verbose", action="store_true")  # bayroq
args = parser.parse_args()
# python skript.py --input data.csv --count 3 --verbose

argparse — buyruq qatori argumentlarini boshqarish (skriptni moslashuvchan qiladi): add_argument("--input", required=True) (majburiy argument), type=int (tur), default (standart qiymat), action="store_true" (bayroq — bor/yo'q). parse_args() — argumentlarni o'qiydi. Foydalanuvchi python skript.py --input data.csv bilan chaqiradi. Avtomatik yordam (--help), xato tekshirish. Skript kod o'zgartmasdan har xil kirishda ishlaydi.

2.3. Chiqish kodlari (exit codes)

Skript natijasini bildirish:

python
import sys
sys.exit(0)      # muvaffaqiyat
sys.exit(1)      # xato
# Bash: skript.py && echo "OK"  (0 bo'lsa bajariladi)

Chiqish kodlari (exit codes) — skript natijasini operatsiya tizimiga bildiradi: 0 (muvaffaqiyat), 0 emas (xato — 1, 2, ...). sys.exit(kod) yoki main() dan qaytarish. Sabab: boshqa skript/Bash skript natijani tekshiradi (skript.py && keyingi — 0 bo'lsa davom). Bu avtomatlashtirish zanjiri (bir skript ikkinchini chaqiradi) uchun muhim. "0 — yaxshi, boshqa — yomon" (Unix an'anasi).

2.4. Logging (print emas)

Nima bo'lganini yozish:

python
import logging
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
logging.info("Fayl qayta ishlandi")
logging.warning("Bo'sh qatorlar o'tkazib yuborildi")
logging.error("Fayl topilmadi")

Logging (logging moduli) — skript nima qildini yozish (print o'rniga): daraja (info, warning, error, debug — muhimlik), format (vaqt, daraja), fayl (log faylga yozish). printdan farq: daraja bilan filtrlash (faqat xato ko'rsatish), faylga yozish, o'chirish oson. Avtomatlashtirishda muhim: skript avtomatik ishlaydi (odam ko'rmaydi) — log nima bo'lganini yozadi. Nosozlikni topish, kuzatish uchun. "print — sinash, logging — ishlab chiqarish".

2.5. Fayl yo'llari (pathlib)

Fayllar bilan ishlash:

python
from pathlib import Path
p = Path("data/file.csv")
p.name        # "file.csv"
p.suffix      # ".csv"
p.stem        # "file"
p.parent      # "data"
p.exists()    # bormi
for f in Path("papka").glob("*.csv"):   # fayllarni top
    ...

pathlib (15-qism) — fayl yo'llari bilan ishlash (matn o'rniga obyekt): Path("yo'l"), .name/.suffix/.stem/.parent (qismlar), .exists(), .glob("*.csv") (fayllarni topish — 15-qism). Matn yo'l ("data/file.csv") o'rniga Path obyekt — tizimga mos (Windows \, Linux /), qulay metodlar. Avtomatlashtirish ko'pincha fayllar bilan (nomlash, ko'chirish, qidirish). pathlib — zamonaviy fayl yo'li.

2.6. Xatolarni boshqarish

Nozik holatlar:

python
try:
    natija = process(fayl)
except FileNotFoundError:
    logging.error(f"Fayl yo'q: {fayl}")
    return 1
except Exception as e:
    logging.error(f"Kutilmagan xato: {e}")
    return 1

Xatolarni boshqarish (09-qism) — skript nozik holatlarga tayyor bo'lsin: try/except (fayl yo'q, ruxsat yo'q, format xato), aniq xato turi (FileNotFoundError), log + chiqish kodi. Avtomatlashtirish skripti avtomatik ishlaydi — xato bo'lsa to'xtamasdan (yoki aniq to'xtab) boshqarish kerak. "Kutilmaganga tayyor bo'l" — real ma'lumot, real fayllar kutilmagan (bo'sh, buzilgan). Ishonchli skript — xatolarni boshqaradi.

2.7. Qayta ishlatiladigan funksiyalar

Toza, modulli kod:

python
def read_files(papka: Path) -> list: ...
def process(data: list) -> list: ...
def save(natija: list, yol: Path) -> None: ...
def main() -> int:
    data = read_files(...)
    natija = process(data)
    save(natija, ...)
    return 0

Qayta ishlatiladigan funksiyalar (07-qism) — skriptni kichik, aniq funksiyalarga bo'lish (bir funksiya — bir ish): read, process, save. Afzallik: testlanadigan (17-qism — har funksiya alohida), qayta ishlatiladigan (boshqa skriptda), o'qiluvchan (main — umumiy oqim). Bir katta funksiya o'rniga kichiklari. Bu 27-qism (toza kod) tamoyili. Skript ham dastur — toza tuzilma.

2.8. Skript — kichik dastur

Skript — kichik dastur (bir marta yoziladi, ko'p ishlaydi), shuning uchun dastur tamoyillari qo'llanadi: tuzilma (main, funksiyalar), moslashuvchanlik (argparse), ishonchlilik (xato boshqarish), kuzatiladigan (logging). "Bir martalik skript" degan narsa yo'q — yaxshi skript qayta ishlatiladi, kengaytiriladi. Avtomatlashtirish — Python'ning eng amaliy qiymati (fayllar, ma'lumot, hisobot, integratsiya — 26-qism). Yaxshi skript vaqtni tejaydi va xatolarni kamaytiradi. "Takroriy ishni avtomatlashtir".

3. Tez ma'lumotnoma

python
import argparse
import logging
import sys
from pathlib import Path

# argparse:
parser = argparse.ArgumentParser(description="...")
parser.add_argument("--input", required=True)
parser.add_argument("--count", type=int, default=1)
parser.add_argument("--verbose", action="store_true")
args = parser.parse_args()

# logging:
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
logging.info("..."); logging.error("...")

# pathlib:
p = Path("data/file.csv")
p.name; p.suffix; p.stem; p.parent
for f in Path("papka").glob("*.csv"): ...

# main guard + exit code:
def main() -> int:
    try:
        ...
        return 0
    except Exception as e:
        logging.error(e)
        return 1

if __name__ == "__main__":
    sys.exit(main())

Skript xulosasi

main guard (import/run) · argparse (argumentlar) · exit code (0/xato)
logging (print emas) · pathlib (fayl yo'l) · try/except (nozik)
Funksiyalar (toza, testlanadigan) · skript — kichik dastur

4. Batafsil misollar

Misollarda argparse, pathlib, sys bilan sinaladi. parse_args ga argumentlar aniq beriladi (deterministik).

Misol 1 — argparse (argumentlar)

python
"""argparse: majburiy/ixtiyoriy argument, tur, bayroq — moslashuvchan skript."""

import argparse


def make_parser() -> argparse.ArgumentParser:
    p = argparse.ArgumentParser(description="Fayl qayta ishlash")
    p.add_argument("--input", required=True, help="Kirish fayl")
    p.add_argument("--count", type=int, default=1, help="Takror soni")
    p.add_argument("--verbose", action="store_true", help="Batafsil")
    return p


def main() -> None:
    parser = make_parser()

    print("=== 1. To'liq argumentlar ===")
    args = parser.parse_args(["--input", "data.csv", "--count", "3", "--verbose"])
    print(f"  input: {args.input}, count: {args.count}, verbose: {args.verbose}")

    print("\n=== 2. Faqat majburiy (default) ===")
    args2 = parser.parse_args(["--input", "test.txt"])
    print(f"  input: {args2.input}, count: {args2.count} (default), verbose: {args2.verbose}")

    print("\n=== 3. Tur o'zgartirish (str → int) ===")
    args3 = parser.parse_args(["--input", "x", "--count", "10"])
    print(f"  count: {args3.count}, turi: {type(args3.count).__name__}")

    print("\n=== 4. Bayroq (store_true) ===")
    args4 = parser.parse_args(["--input", "x"])
    print(f"  verbose (bayroqsiz): {args4.verbose}")
    print("  ⭐ argparse — moslashuvchan skript (argumentlar)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. To'liq argumentlar ===
  input: data.csv, count: 3, verbose: True

=== 2. Faqat majburiy (default) ===
  input: test.txt, count: 1 (default), verbose: False

=== 3. Tur o'zgartirish (str → int) ===
  count: 10, turi: int

=== 4. Bayroq (store_true) ===
  verbose (bayroqsiz): False
  ⭐ argparse — moslashuvchan skript (argumentlar)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 2 — pathlib va chiqish kodlari

python
"""pathlib: fayl yo'l qismlari (name/suffix/stem/parent); exit code (0/1)."""

from pathlib import Path


def process_ok(qiymat: int) -> int:
    return 0 if qiymat > 0 else 1


def main() -> None:
    print("=== 1. Fayl yo'l qismlari (pathlib) ===")
    p = Path("data/hisobot/fayl.csv")
    print(f"  name: {p.name}")
    print(f"  suffix: {p.suffix}")
    print(f"  stem: {p.stem}")
    print(f"  parent: {p.parent.name}")

    print("\n=== 2. Yo'l birlashtirish ===")
    yangi = Path("papka") / "kichik" / "fayl.txt"
    print(f"  {yangi.as_posix()}")

    print("\n=== 3. Chiqish kodi (exit code) ===")
    print(f"  process_ok(5): {process_ok(5)} (muvaffaqiyat)")
    print(f"  process_ok(-1): {process_ok(-1)} (xato)")

    print("\n=== 4. Kod ma'nosi ===")
    print("  0 — muvaffaqiyat (Bash: && davom)")
    print("  0 emas — xato (to'xta)")
    print("  ⭐ pathlib (fayl yo'l), exit code (natija bildirish)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Fayl yo'l qismlari (pathlib) ===
  name: fayl.csv
  suffix: .csv
  stem: fayl
  parent: hisobot

=== 2. Yo'l birlashtirish ===
  papka/kichik/fayl.txt

=== 3. Chiqish kodi (exit code) ===
  process_ok(5): 0 (muvaffaqiyat)
  process_ok(-1): 1 (xato)

=== 4. Kod ma'nosi ===
  0 — muvaffaqiyat (Bash: && davom)
  0 emas — xato (to'xta)
  ⭐ pathlib (fayl yo'l), exit code (natija bildirish)

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

Misol 3 — Xatolarni boshqarish va funksiyalar

python
"""xato boshqarish (try/except + exit code); qayta ishlatiladigan funksiyalar (main oqimi)."""

from pathlib import Path


def read_data(fayl: str) -> list:
    """O'qish (soxta — deterministik)."""
    if fayl == "yoq.csv":
        raise FileNotFoundError(fayl)
    return [1, 2, 3, 4, 5]


def process(data: list) -> list:
    """Qayta ishlash."""
    return [x * 2 for x in data]


def run(fayl: str) -> int:
    """main mantiqi — xato boshqarish bilan."""
    try:
        data = read_data(fayl)
        natija = process(data)
        return 0     # muvaffaqiyat
    except FileNotFoundError as e:
        return 1     # xato


def main() -> None:
    print("=== 1. read → process (funksiyalar) ===")
    data = read_data("bor.csv")
    natija = process(data)
    print(f"  o'qildi: {data}")
    print(f"  qayta ishlandi: {natija}")

    print("\n=== 2. Muvaffaqiyatli oqim ===")
    print(f"  run('bor.csv') → exit kod: {run('bor.csv')}")

    print("\n=== 3. Xato boshqarish (fayl yo'q) ===")
    print(f"  run('yoq.csv') → exit kod: {run('yoq.csv')}")

    print("\n=== 4. Funksiyalar afzalligi ===")
    print("  read/process/run — kichik, testlanadigan")
    print("  xato boshqariladi (skript to'xtamaydi)")
    print("  ⭐ funksiyalar + xato boshqarish — ishonchli skript")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. read → process (funksiyalar) ===
  o'qildi: [1, 2, 3, 4, 5]
  qayta ishlandi: [2, 4, 6, 8, 10]

=== 2. Muvaffaqiyatli oqim ===
  run('bor.csv') → exit kod: 0

=== 3. Xato boshqarish (fayl yo'q) ===
  run('yoq.csv') → exit kod: 1

=== 4. Funksiyalar afzalligi ===
  read/process/run — kichik, testlanadigan
  xato boshqariladi (skript to'xtamaydi)
  ⭐ funksiyalar + xato boshqarish — ishonchli skript

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

Misol 4 — Amaliy: fayl tartiblash skripti

Real avtomatlashtirish: fayllarni turi bo'yicha tartiblash — argparse, pathlib, funksiyalar, exit code. Bu — avtomatlashtirish skriptining namunasi.

python
"""to'liq skript: fayllarni kengaytirish bo'yicha guruhlash (argparse + pathlib + funksiyalar)."""

import argparse
from pathlib import Path


def guruhla(fayllar: list) -> dict:
    """Fayllarni kengaytirish bo'yicha guruhla."""
    guruhlar: dict = {}
    for f in fayllar:
        kengaytma = Path(f).suffix or "(yo'q)"
        guruhlar.setdefault(kengaytma, []).append(Path(f).name)
    return guruhlar


def make_parser() -> argparse.ArgumentParser:
    p = argparse.ArgumentParser(description="Fayllarni tartiblash")
    p.add_argument("--papka", default=".")
    p.add_argument("--verbose", action="store_true")
    return p


def main() -> int:
    args = make_parser().parse_args(["--papka", "hujjatlar", "--verbose"])

    # soxta fayllar ro'yxati (deterministik)
    fayllar = ["a.csv", "b.txt", "c.csv", "d.py", "e.txt", "f.py"]

    print(f"=== 1. Papka: {args.papka} ===")
    print(f"  fayllar soni: {len(fayllar)}")

    print("\n=== 2. Kengaytirish bo'yicha guruhlash ===")
    guruhlar = guruhla(fayllar)
    for kengaytma, nomlar in sorted(guruhlar.items()):
        print(f"  {kengaytma}: {nomlar}")

    print("\n=== 3. Statistika ===")
    for kengaytma, nomlar in sorted(guruhlar.items()):
        print(f"  {kengaytma}: {len(nomlar)} ta")

    print("\n=== 4. Yakun ===")
    print(f"  {len(guruhlar)} tur, {len(fayllar)} fayl tartiblandi")
    print("  ⭐ skript — argparse + pathlib + funksiyalar + exit code")
    return 0


if __name__ == "__main__":
    import sys
    sys.exit(main())

Natijaning muhim qismi:

text
=== 1. Papka: hujjatlar ===
  fayllar soni: 6

=== 2. Kengaytirish bo'yicha guruhlash ===
  .csv: ['a.csv', 'c.csv']
  .py: ['d.py', 'f.py']
  .txt: ['b.txt', 'e.txt']

=== 3. Statistika ===
  .csv: 2 ta
  .py: 2 ta
  .txt: 2 ta

=== 4. Yakun ===
  3 tur, 6 fayl tartiblandi
  ⭐ skript — argparse + pathlib + funksiyalar + exit code

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
"Skript — oddiy kod" Kichik dastur (tuzilma)
"argumentlar kodda" argparse (moslashuvchan)
"print yetarli" logging (ishlab chiqarish)
"Exit kod keraksiz" Bash, zanjir uchun
"Xato — to'xta" Boshqarish (try/except)
"Bir katta funksiya" Kichik, qayta ishlatiladigan
"Matn yo'l yetarli" pathlib (obyekt)
"Bir martalik skript" Qayta ishlatiladi

6. Keng tarqalgan xatolar va yechimlari

1. main guard yo'q

python
# global kod (import'da ishga tushadi)             # ⚠️
if __name__ == "__main__": main()                   # ✅

2. Argumentlar kodga qattiq yozilgan

python
fayl = "data.csv"   # o'zgartirish — kod tahrir      # ⚠️
argparse (--input)   # moslashuvchan                  # ✅

3. print (logging o'rniga)

python
print("xato")   # filtrlab bo'lmaydi                  # ⚠️
logging.error("xato")   # daraja, fayl                 # ✅

4. Exit kodni qaytarmaslik

python
def main(): ...   # kod yo'q                          # ⚠️
def main() -> int: return 0                            # ✅

5. Xato boshqarilmagan

python
data = read(fayl)   # fayl yo'q — crash               # ⚠️
try: read(fayl) except FileNotFoundError: ...          # ✅

6. Matn yo'l (pathlib o'rniga)

python
yo'l = "data" + "/" + "fayl"   # tizimga bog'liq       # ⚠️
Path("data") / "fayl"   # mos                           # ✅

7. Bir katta main

python
def main(): 100 qator                                 # ⚠️
def main(): read(); process(); save()                  # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 07-qism (o'tilgan): Funksiyalar — skript tuzilma
  • 09-qism (o'tilgan): Xatolar — boshqarish
  • 15-qism (o'tilgan): pathlib, logging
  • 26.2-dars: Fayllarni avtomatlashtirish
  • 26.9-dars: Cron — skriptni rejalashtirish

8. Eng yaxshi amaliyotlar

  1. main() + main guard (import/run).

  2. argparse (argumentlar — moslashuvchan).

  3. Exit kod (0/xato).

  4. logging (print emas).

  5. pathlib (matn yo'l emas).

  6. Xatolarni boshqar (try/except).

  7. Kichik funksiyalar (testlanadigan).

  8. Skript — kichik dastur (jiddiy yoz).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # skript tuzilishi?
2.  # main guard nima?
3.  # argparse nima?
4.  # required argument?
5.  # action="store_true"?
6.  # exit code nima?
7.  # 0 va 1 farqi?
8.  # logging vs print?
9.  # pathlib nima?
10. # .suffix nima?
11. # nega funksiyalar?
12. # skript — kichik dasturmi?
Javoblar
  1. main + funksiyalar + guard
  2. import/run ajratish
  3. Buyruq qatori argumentlari
  4. Majburiy argument
  5. Bayroq (bor/yo'q)
  6. Skript natijasi (OS ga)
  7. 0 muvaffaqiyat, 1 xato
  8. logging — daraja, fayl; print — oddiy
  9. Fayl yo'llari (obyekt)
  10. Fayl kengaytirish (.csv)
  11. Testlanadigan, qayta ishlatiladigan
  12. Ha (tuzilma, ishonchlilik)

Vazifa 2: Xatolarni tuzating

python
1.  # global kod (guard yo'q)          # main guard

2.  fayl = "data.csv"                  # argparse

3.  print("xato")                       # logging

4.  data = read(fayl)  # crash          # try/except

5.  "data" + "/" + "fayl"               # pathlib
Javoblar
python
1.  if __name__ == "__main__": main()

2.  argparse (--input)

3.  logging.error("xato")

4.  try: read(fayl) except: ...

5.  Path("data") / "fayl"

Vazifa 3: argparse

Argumentlar:

  1. Majburiy
  2. Ixtiyoriy (default)
  3. Tur
  4. Bayroq

Vazifa 4: pathlib/exit

Skript:

  1. Yo'l qismlari
  2. Birlashtirish
  3. Exit kod
  4. Ma'no

Vazifa 5: Xato/funksiyalar

Ishonchli:

  1. try/except
  2. Funksiyalar
  3. Exit kod
  4. Oqim

Vazifa 6: To'liq skript

Avtomatlashtirish:

  1. argparse
  2. pathlib
  3. Funksiyalar
  4. Exit kod

Vazifa 7: O'ylash

"Bir martalik skript" degan narsa yo'q — yaxshi skript qayta ishlatiladi, kengaytiriladi. Shuning uchun skript ham kichik dastur — dastur tamoyillari (tuzilma, moslashuvchanlik, ishonchlilik, log) qo'llanadi. Nima uchun "tez, iflos skript" (quick and dirty) ko'pincha xato, va nega ozroq vaqt sarflab yaxshi skript (argparse, log, xato boshqarish) yozish uzoq muddatda tejaydi — avtomatlashtirish nega jiddiy yondashuvni talab qiladi?

Javob

Qisqa javob: "Bir martalik skript" degan narsa kam — yaxshi skript qayta ishlatiladi (keyingi oyda yana kerak), kengaytiriladi (yangi talab), boshqalar ishlatadi. "Tez, iflos skript" (argparse yo'q — kod tahrir; log yo'q — nima bo'lgani noma'lum; xato boshqarilmagan — crash) ko'pincha xato, chunki: real ma'lumot kutilmagan (bo'sh fayl, xato format) → crash; moslashuvchan emas → har o'zgarishda kod tahrir; kuzatilmaydi → nosozlik topib bo'lmaydi. Ozroq vaqt sarflab yaxshi skript uzoq muddatda tejaydi: qayta ishlatiladi (kod tahrirsiz — argparse), ishonchli (xato boshqariladi), kuzatiladi (log). Avtomatlashtirish jiddiy yondashuv talab qiladi, chunki skript avtomatik ishlaydi (odam ko'rmaydi — xato jimgina yuz beradi) va takror ishlaydi (bir xato ming marta). "Sekin-tez" (slow is smooth, smooth is fast) — yaxshi yozsang, keyin tez.

1. Bir martalik skript kam

Yaxshi skript qayta ishlatiladi (keyingi oy), kengaytiriladi (yangi talab), boshqalar ishlatadi. "Bir martalik" — kamdan-kam.

2. Tez, iflos skript xatolari

Iflos Muammo
argparse yo'q Har o'zgarishda kod tahrir
log yo'q Nima bo'lgani noma'lum
xato boshqarilmagan Crash (kutilmagan ma'lumot)
bir katta funksiya Test/o'zgartirish qiyin

3. Nega yaxshi skript tejaydi

  • Qayta ishlatiladi (argparse — kod tahrirsiz)
  • Ishonchli (xato boshqariladi)
  • Kuzatiladi (log — nosozlik topiladi)
  • Kengaytiriladi (funksiyalar)

4. Avtomatlashtirish jiddiy

Skript avtomatik (odam ko'rmaydi — xato jimgina), takror (bir xato ming marta). Shuning uchun ishonchlilik muhim.

5. Muhandislik saboqlari

  1. Bir martalik skript kam (qayta ishlatiladi)
  2. Iflos skript — xato (kutilmagan, crash)
  3. Yaxshi skript uzoq muddatda tejaydi
  4. Avtomatlashtirish jiddiy yondashuv

6. Xulosa

  1. Skript — kichik dastur
  2. Iflos skript ko'pincha xato
  3. Yaxshi skript tejaydi (uzoq muddat)
  4. Sekin-tez (yaxshi yoz, keyin tez)

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.

Xulosa

Bu darsda professional skript yozish tamoyillarini o'rgandik.

Eng muhim uch fikr:

  1. Skript tuzilishi va argparse. Skript tuzilishi: if __name__ == "__main__" (07-qism — skript ishga tushirilganda bajariladi, import qilinganda emas), main() funksiya (asosiy mantiq — qayta ishlatiladigan, testlanadigan), sys.exit(main()). argparse — buyruq qatori argumentlarini boshqarish (moslashuvchan): add_argument("--input", required=True) (majburiy), type=int (tur), default (standart), action="store_true" (bayroq). Foydalanuvchi python skript.py --input data.csv bilan chaqiradi — kod o'zgartmasdan har xil kirishda ishlaydi.

  2. Exit code, logging, pathlib. Chiqish kodlari (exit codes): 0 (muvaffaqiyat), 0 emas (xato) — sys.exit(kod); Bash/zanjir natijani tekshiradi (skript.py && keyingi). Logging (logging) — skript nima qildini yozish (print o'rniga): daraja (info/warning/error), format, fayl — avtomatik ishlaydigan skript uchun muhim (odam ko'rmaydi). pathlib (15-qism) — fayl yo'llari obyekt sifatida: .name/.suffix/.stem/.parent, .glob("*.csv") — tizimga mos, qulay. Xatolarni boshqarish (try/except) — nozik holatlar (fayl yo'q, format xato).

  3. Skript — kichik dastur. Skriptni kichik, aniq funksiyalarga bo'lish (read/process/save — testlanadigan, qayta ishlatiladigan, o'qiluvchan). "Bir martalik skript" kam — yaxshi skript qayta ishlatiladi, kengaytiriladi. Shuning uchun skript ham dastur — tamoyillari qo'llanadi (tuzilma, moslashuvchanlik, ishonchlilik, log). "Tez, iflos skript" ko'pincha xato (real ma'lumot kutilmagan — crash; moslashuvchan emas; kuzatilmaydi). Yaxshi skript uzoq muddatda tejaydi (qayta ishlatiladi, ishonchli, kuzatiladi). Avtomatlashtirish jiddiy yondashuvni talab qiladi (avtomatik — xato jimgina; takror — bir xato ming marta). Avtomatlashtirish — Python'ning eng amaliy qiymati (fayllar, ma'lumot, hisobot — 26-qism).

Keyingi darsda fayllarni avtomatlashtirish ni o'rganamiz: fayllarni ko'plab qayta ishlash — nomlash, ko'chirish, qidirish, tartiblash — pathlib, shutil, os bilan kundalik fayl vazifalarini avtomatlashtirish.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
26.1-dars: Skript yozish tamoyillari — IlmHamroh