IlmHamroh
Python kursi/Avtomatlashtirish9/10-dars18 daqiqa
Mundarija (22)

26.9-dars: Rejalashtirilgan vazifalar (cron)

26-QISM — AVTOMATLASHTIRISH · 9-dars

1. Kirish va motivatsiya

Ba'zi ishlar muntazam takrorlanadi: har kuni ertalab hisobot, har soatda zaxira nusxa, har hafta tozalash, har oy hisob-kitob. Bularni qo'lda bajarish — zerikarli va unutiladi. Rejalashtirilgan vazifa (scheduled task) — skript avtomatik vaqtda ishga tushadi: siz vaqtni belgilaysiz (har kuni 09:00), tizim o'zi ishga tushiradi. Odam kutmaydi — mashina eslaydi. Bu avtomatlashtirishning vaqt o'lchami: nafaqat "avtomatik", balki "avtomatik kerakli vaqtda".

cron — Unix'ning rejalashtirish tizimi: cron ifodasi (5 maydon — daqiqa, soat, kun, oy, hafta kuni) bilan vaqt belgilanadi, cron demoni skriptni o'sha vaqtda ishga tushiradi. Windows'da — Task Scheduler. Python'da — schedule, APScheduler kutubxonalari (dastur ichida rejalashtirish). cron ifodasi: 0 9 * * * (har kuni 09:00), */15 * * * * (har 15 daqiqa), 0 0 * * 1 (har dushanba yarim tunda). Rejalashtirish — davriy avtomatlashtirish: bir marta sozlang, doimiy ishlaydi.

Real vaziyat. Bir loyihada har kuni ertalab foydalanuvchilarga hisobot yuborish kerak edi. Avval qo'lda: har ertalab skript ishga tushiriladi (unutiladi, kechikadi). Keyin cron: 0 8 * * * — har kuni 08:00 avtomatik. Skript o'zi ishladi, hisobot yuborildi, hech kim eslamadi ham. Bir yil ishladi — uzilishsiz. Sozladik va unutdik (yaxshi ma'noda). Cron — ishonchli vaqt xizmati.

Bu darsda rejalashtirilgan vazifalar (cron) ni o'rganamiz.

Bu darsda:

  • Rejalashtirilgan vazifa nima
  • cron ifodasi (5 maydon)
  • cron misollari
  • Windows Task Scheduler
  • Python: schedule, APScheduler
  • Idempotentlik va xatolar
  • Loglar va monitoring
  • Amaliy: scheduler mantigi

ℹ Misollarda cron ifodasi sof Python bilan (deterministik) tahlil qilinadi; real cron demoni/Task Scheduler operatsion tizim talab qiladi.

2. Nazariya — chuqur tushuntirish

2.1. Rejalashtirilgan vazifa nima

Vaqtda avtomatik ishga tushish:

Skript + vaqt jadvali → tizim (cron/scheduler)
   → belgilangan vaqtda avtomatik ishga tushiradi
Har kuni 09:00, har soatda, har dushanba...

Rejalashtirilgan vazifa (scheduled task, cron job) — skript oldindan belgilangan vaqtda avtomatik ishga tushadi: siz jadvalni belgilaysiz (har kuni 09:00, har 15 daqiqa), tizim (cron demoni yoki scheduler) o'sha vaqtda skriptni chaqiradi. Odam ishtiroki yo'q — mashina vaqtni kuzatadi. Bu davriy (takrorlanuvchi) avtomatlashtirish: hisobot, zaxira, tozalash, tekshirish. Bir marta sozlang — doimiy ishlaydi. Vaqt — avtomatlashtirishning o'lchami.

2.2. cron ifodasi (5 maydon)

Vaqtni belgilash:

┌─ daqiqa (0-59)
│ ┌─ soat (0-23)
│ │ ┌─ oy kuni (1-31)
│ │ │ ┌─ oy (1-12)
│ │ │ │ ┌─ hafta kuni (0-6, 0=yakshanba)
│ │ │ │ │
* * * * *   → har daqiqa
0 9 * * *   → har kuni 09:00

cron ifodasi — 5 maydondan iborat (bo'shliq bilan ajratilgan): daqiqa (0–59), soat (0–23), oy kuni (1–31), oy (1–12), hafta kuni (0–6, 0=yakshanba). Har maydonda: * (har), 5 (aniq qiymat), 1,15 (ro'yxat), 9-17 (oraliq), */15 (har 15 — qadam). Masalan 0 9 * * * = daqiqa 0, soat 9, har kun, har oy, har hafta kuni = har kuni 09:00. cron ifodasi — vaqt jadvalini ixcham yozish. 5 maydon — vaqtni to'liq belgilaydi.

2.3. cron misollari

Amaliy ifodalar:

Ifoda Ma'nosi
* * * * * Har daqiqa
0 * * * * Har soat (00 daqiqada)
0 9 * * * Har kuni 09:00
*/15 * * * * Har 15 daqiqa
0 0 * * 1 Har dushanba 00:00
0 0 1 * * Har oy 1-kuni 00:00

cron ifodalari — amaliy jadvallar: */15 * * * * (har 15 daqiqa — tez-tez tekshirish), 0 9 * * * (har kuni ertalab — hisobot), 0 0 * * 1 (har hafta — dushanba tozalash), 0 0 1 * * (har oy — hisob-kitob). Qadam (*/N), oraliq (9-17), ro'yxat (1,15) birlashtiriladi: 0 9-17 * * 1-5 (ish kunlari 09:00–17:00 har soat). cron ifodasi — kuchli va ixcham. Onlayn tekshirgichlar (crontab.guru) yordam beradi.

2.4. Windows Task Scheduler

Windows'da rejalashtirish:

Task Scheduler (Vazifalar rejalashtirgichi):
- GUI (grafik) yoki schtasks (buyruq)
- Trigger (vaqt) + Action (skript)
schtasks /create /tn "hisobot" /tr "py skript.py" /sc daily /st 09:00

Windows Task Scheduler — Windows'ning rejalashtirish tizimi (cron'ning Windows muqobili): Trigger (qachon — vaqt, hodisa) + Action (nima — skript ishga tushirish). GUI (grafik interfeys) yoki schtasks buyruq. Unix cron sintaksisidan farq qiladi, lekin g'oya bir xil: vaqt + amal. Ko'p Python kutubxonalari (APScheduler) ikkala platformada ishlaydi (portativ). Platforma farqi — cron (Unix/Linux server) yoki Task Scheduler (Windows).

2.5. Python: schedule va APScheduler

Dastur ichida rejalashtirish:

python
# schedule (oddiy):
import schedule
schedule.every().day.at("09:00").do(hisobot)
schedule.every(15).minutes.do(tekshir)
while True:
    schedule.run_pending()
    time.sleep(1)
# APScheduler — kuchli (cron ifoda, fon)

Python kutubxonalari: schedule — oddiy, o'qiladigan (schedule.every().day.at("09:00").do(job)) — kichik skript ichida; APScheduler — kuchli (cron ifoda, oraliq, fon vazifa, doimiy saqlash) — katta ilova. Farqi cron'dan: bu dastur ichida ishlaydi (Python jarayoni kerak), cron — operatsion tizim darajasida (mustaqil). Kichik loyiha — schedule; server — cron yoki APScheduler. Kutubxona — kod ichida jadval.

2.6. Idempotentlik va xatolar

Takrorlanishga chidamli:

python
# vazifa bir necha marta ishlashi mumkin (qayta urinish)
# idempotent: bir xil natija (zarar yo'q)
if not already_done(sana):     # tekshir
    process(sana)
    mark_done(sana)

Idempotentlik — vazifa bir necha marta ishlasa ham bir xil natija (qo'shimcha zarar yo'q): cron vazifa qayta ishlashi mumkin (qayta urinish, ikki demon). Masalan hisobot ikki marta yuborilmasin — "bugun yuborildimi?" tekshirish. Xato boshqarish: vazifa yiqilsa — log, ogohlantirish (email); qayta urinish; keyingi ishga ta'sir qilmasin. Rejalashtirilgan vazifa nazoratsiz ishlaydi (odam yo'q) — shuning uchun mustahkam bo'lishi kerak. Idempotentlik — ishonchlilik.

2.7. Loglar va monitoring

Ishlaganini bilish:

python
import logging
logging.info(f"vazifa boshlandi: {datetime.now()}")
# ... ish ...
logging.info(f"vazifa tugadi: {n} qator")
# monitoring: vazifa ishlamasa — ogohlantir

Log va monitoring — rejalashtirilgan vazifa ko'rinmaydi (fonda, odam kutmaydi), shuning uchun log (nima bo'ldi — boshlandi, tugadi, xato) va monitoring (ishlayaptimi — "dead man's switch": vazifa ishlamasa ogohlantir) zarur. Loglar: qachon ishladi, qancha vaqt, natija, xato. Monitoring: kutilgan vaqtda ishlamasa xabar (masalan Healthchecks.io — vazifa "men tirikman" signali yuboradi). Ko'rinmas jarayon — log bilan ko'rinadi. Log — nazoratsiz ishning ko'zi.

2.8. Rejalashtirish — avtomatlashtirishning vaqti

Rejalashtirish — avtomatlashtirishga vaqt o'lchami qo'shadi: skript 26.1-bob nima qilishni, cron qachon qilishni belgilaydi. Davriy ishlar: zaxira (kunlik), hisobot (kunlik/haftalik), tozalash (o'chirish), sinxronizatsiya (API — 26.7), tekshirish (monitoring). Sozlash joyi: cron (Linux server — crontab -e), Task Scheduler (Windows), APScheduler (ilova ichida), bulut (GitHub Actions, cloud scheduler). "Bir marta sozla — doimiy ishla" — avtomatlashtirishning kuchi. Rejalashtirish — vaqtni boshqarish (odam o'rniga mashina eslaydi).

3. Tez ma'lumotnoma

cron ifodasi (5 maydon):
  daqiqa(0-59) soat(0-23) oy-kuni(1-31) oy(1-12) hafta-kuni(0-6)
  * = har · 5 = aniq · 1,15 = ro'yxat · 9-17 = oraliq · */15 = qadam

Misollar:
  0 9 * * *      har kuni 09:00
  */15 * * * *   har 15 daqiqa
  0 0 * * 1      har dushanba 00:00
  0 9-17 * * 1-5 ish kunlari har soat (9-17)
python
# Linux: crontab -e  →  0 9 * * * py /yol/skript.py
# Windows: schtasks /create /sc daily /st 09:00 ...

# Python schedule:
import schedule, time
schedule.every().day.at("09:00").do(job)
while True: schedule.run_pending(); time.sleep(1)

# APScheduler (cron ifoda):
from apscheduler.schedulers.blocking import BlockingScheduler
sched = BlockingScheduler()
sched.add_job(job, "cron", hour=9, minute=0)
sched.start()

# idempotent: if not done(sana): process(); mark(sana)
# log: logging.info(...) · monitoring: dead man's switch

Rejalashtirilgan vazifa xulosasi

cron: 5 maydon (daqiqa soat kun oy hafta) · vaqtda avtomatik
Windows: Task Scheduler · Python: schedule, APScheduler
idempotent (qayta urinish) · log + monitoring (ko'rinmas)

4. Batafsil misollar

Misollarda cron ifodasi sof Python bilan (deterministik) tahlil qilinadi — real cron demoni operatsion tizim talab qiladi. Sana belgilangan (deterministik).

Misol 1 — cron maydonlarini tahlil qilish

python
"""cron maydon tahlili: *, aniq, ro'yxat, oraliq, qadam."""


def parse_field(field: str, lo: int, hi: int) -> set:
    if field == "*":
        return set(range(lo, hi + 1))
    vals: set = set()
    for part in field.split(","):
        if "/" in part:
            base, step = part.split("/")
            boshi = lo if base == "*" else int(base.split("-")[0])
            vals |= set(range(boshi, hi + 1, int(step)))
        elif "-" in part:
            a, b = part.split("-")
            vals |= set(range(int(a), int(b) + 1))
        else:
            vals.add(int(part))
    return vals


def main() -> None:
    print("=== 1. '*' (har) ===")
    print(f"  daqiqa '*' (0-59) soni: {len(parse_field('*', 0, 59))}")

    print("\n=== 2. Qadam '*/15' ===")
    print(f"  daqiqa '*/15': {sorted(parse_field('*/15', 0, 59))}")

    print("\n=== 3. Oraliq '9-17' ===")
    print(f"  soat '9-17': {sorted(parse_field('9-17', 0, 23))}")

    print("\n=== 4. Ro'yxat '1,15' ===")
    print(f"  kun '1,15': {sorted(parse_field('1,15', 1, 31))}")
    print("  ⭐ cron maydon: * / aniq / ro'yxat / oraliq / qadam")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. '*' (har) ===
  daqiqa '*' (0-59) soni: 60

=== 2. Qadam '*/15' ===
  daqiqa '*/15': [0, 15, 30, 45]

=== 3. Oraliq '9-17' ===
  soat '9-17': [9, 10, 11, 12, 13, 14, 15, 16, 17]

=== 4. Ro'yxat '1,15' ===
  kun '1,15': [1, 15]
  ⭐ cron maydon: * / aniq / ro'yxat / oraliq / qadam

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

Misol 2 — Keyingi ishga tushish vaqtlari

python
"""cron moslik: berilgan ifodaga keyingi ishga tushish vaqtlari."""
from datetime import datetime, timedelta


def parse_field(field: str, lo: int, hi: int) -> set:
    if field == "*":
        return set(range(lo, hi + 1))
    vals: set = set()
    for part in field.split(","):
        if "/" in part:
            base, step = part.split("/")
            vals |= set(range(lo, hi + 1, int(step)))
        elif "-" in part:
            a, b = part.split("-")
            vals |= set(range(int(a), int(b) + 1))
        else:
            vals.add(int(part))
    return vals


def matches(expr: str, dt: datetime) -> bool:
    m, h, dom, mon, dow = expr.split()
    return (
        dt.minute in parse_field(m, 0, 59)
        and dt.hour in parse_field(h, 0, 23)
        and dt.day in parse_field(dom, 1, 31)
        and dt.month in parse_field(mon, 1, 12)
        and (dt.weekday() + 1) % 7 in parse_field(dow, 0, 6)
    )


def next_runs(expr: str, start: datetime, n: int) -> list:
    res, cur = [], start.replace(second=0, microsecond=0)
    while len(res) < n:
        cur += timedelta(minutes=1)
        if matches(expr, cur):
            res.append(cur)
    return res


def main() -> None:
    start = datetime(2026, 1, 1, 0, 0)   # payshanba

    print("=== 1. Har kuni 09:00 ('0 9 * * *') ===")
    r = next_runs("0 9 * * *", start, 3)
    print(f"  keyingi 3: {[d.strftime('%m-%d %H:%M') for d in r]}")

    print("\n=== 2. Har 30 daqiqa ('*/30 * * * *') ===")
    r = next_runs("*/30 * * * *", start, 3)
    print(f"  keyingi 3: {[d.strftime('%H:%M') for d in r]}")

    print("\n=== 3. Har dushanba 08:00 ('0 8 * * 1') ===")
    r = next_runs("0 8 * * 1", start, 2)
    print(f"  keyingi 2: {[d.strftime('%m-%d %H:%M') for d in r]}")
    print("  (2026-01-05 va 01-12 — dushanbalar)")
    print("  ⭐ cron — keyingi ishga tushish vaqtlari")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Har kuni 09:00 ('0 9 * * *') ===
  keyingi 3: ['01-01 09:00', '01-02 09:00', '01-03 09:00']

=== 2. Har 30 daqiqa ('*/30 * * * *') ===
  keyingi 3: ['00:30', '01:00', '01:30']

=== 3. Har dushanba 08:00 ('0 8 * * 1') ===
  keyingi 2: ['01-05 08:00', '01-12 08:00']
  (2026-01-05 va 01-12 — dushanbalar)
  ⭐ cron — keyingi ishga tushish vaqtlari

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

Misol 3 — Scheduler simulyatsiyasi

python
"""scheduler simulyatsiya: belgilangan vaqtda vazifa ishga tushadi (mock soat)."""
from datetime import datetime, timedelta


def parse_field(field: str, lo: int, hi: int) -> set:
    if field == "*":
        return set(range(lo, hi + 1))
    if "/" in field:
        step = int(field.split("/")[1])
        return set(range(lo, hi + 1, step))
    return {int(field)}


def matches(expr: str, dt: datetime) -> bool:
    m, h, dom, mon, dow = expr.split()
    return dt.minute in parse_field(m, 0, 59) and dt.hour in parse_field(h, 0, 23)


def main() -> None:
    log: list = []

    def hisobot() -> None:
        log.append("hisobot yuborildi")

    # mock soat: 08:58 dan 09:02 gacha (5 daqiqa) simulyatsiya
    clock = datetime(2026, 1, 1, 8, 58)
    print("=== 1. Simulyatsiya (08:58 → 09:02) ===")
    for _ in range(5):
        clock += timedelta(minutes=1)
        ishladi = matches("0 9 * * *", clock)
        if ishladi:
            hisobot()
        belgi = "ISHLADI" if ishladi else "-"
        print(f"  {clock.strftime('%H:%M')} {belgi}")

    print("\n=== 2. Natija ===")
    print(f"  vazifa necha marta ishladi: {len(log)}")

    print("\n=== 3. Har 2 daqiqa vazifa ===")
    log2: list = []
    clock = datetime(2026, 1, 1, 10, 0)
    for _ in range(6):
        if matches("*/2 * * * *", clock):
            log2.append(clock.strftime("%H:%M"))
        clock += timedelta(minutes=1)
    print(f"  ishga tushgan vaqtlar: {log2}")

    print("\n=== 4. Xulosa ===")
    print("  scheduler: har daqiqa tekshiradi, moslikda ishga tushiradi")
    print("  ⭐ scheduler — vaqt kuzatadi, vazifani chaqiradi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Simulyatsiya (08:58 → 09:02) ===
  08:59 -
  09:00 ISHLADI
  09:01 -
  09:02 -
  09:03 -

=== 2. Natija ===
  vazifa necha marta ishladi: 1

=== 3. Har 2 daqiqa vazifa ===
  ishga tushgan vaqtlar: ['10:00', '10:02', '10:04']

=== 4. Xulosa ===
  scheduler: har daqiqa tekshiradi, moslikda ishga tushiradi
  ⭐ scheduler — vaqt kuzatadi, vazifani chaqiradi

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

Misol 4 — Idempotentlik (takrorlanishga chidamli)

python
"""idempotentlik: vazifa qayta ishlasa ham bir xil natija (ikki marta yubormaydi)."""


class HisobotVazifasi:
    def __init__(self) -> None:
        self.yuborilgan: set = set()   # qaysi kunlar yuborildi
        self.jurnal: list = []

    def bajar(self, sana: str) -> str:
        # idempotent tekshirish: bugun yuborildimi?
        if sana in self.yuborilgan:
            self.jurnal.append(f"{sana}: o'tkazib yuborildi (allaqachon)")
            return "skip"
        # ish
        self.yuborilgan.add(sana)
        self.jurnal.append(f"{sana}: hisobot yuborildi")
        return "sent"


def main() -> None:
    v = HisobotVazifasi()

    print("=== 1. Birinchi marta ===")
    print(f"  2026-01-01 → {v.bajar('2026-01-01')}")

    print("\n=== 2. Qayta urinish (bir xil kun) ===")
    print(f"  2026-01-01 → {v.bajar('2026-01-01')}  (takror emas!)")

    print("\n=== 3. Keyingi kun ===")
    print(f"  2026-01-02 → {v.bajar('2026-01-02')}")

    print("\n=== 4. Jurnal ===")
    for satr in v.jurnal:
        print(f"  {satr}")
    print(f"  yuborilgan kunlar: {len(v.yuborilgan)}")
    print("  ⭐ idempotent — qayta urinish zararsiz (bir xil natija)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Birinchi marta ===
  2026-01-01 → sent

=== 2. Qayta urinish (bir xil kun) ===
  2026-01-01 → skip  (takror emas!)

=== 3. Keyingi kun ===
  2026-01-02 → sent

=== 4. Jurnal ===
  2026-01-01: hisobot yuborildi
  2026-01-01: o'tkazib yuborildi (allaqachon)
  2026-01-02: hisobot yuborildi
  yuborilgan kunlar: 2
  ⭐ idempotent — qayta urinish zararsiz (bir xil natija)

Nima ko'rsatdi: 2.6-bo'lim.

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

Noto'g'ri fikr To'g'risi
"cron murakkab" 5 maydon (vaqt)
"Faqat Linux" Windows Task Scheduler ham
"Vazifa bir marta" Davriy (takror)
"Xato bo'lmaydi" Idempotent, log kerak
"Log keraksiz" Ko'rinmas — log zarur
"schedule = cron" schedule dastur ichida
"Bir marta ishla" Qayta urinish mumkin
"Sozla va unut" Monitoring kerak

6. Keng tarqalgan xatolar va yechimlari

1. cron maydon xato

0 9 * * *   # daqiqa soat kun oy hafta (5 maydon)   # ✅
9 0 * * *   # ⚠️ soat 0 daqiqa 9 = 00:09 (adashdi)

2. Idempotent emas (ikki marta)

python
process(sana)                              # ⚠️ qayta = ikki marta
if not done(sana): process(sana)           # ✅

3. Xato boshqarilmagan

python
job()   # yiqilsa jim o'ladi                # ⚠️
try: job() except: log_error()             # ✅ log

4. Log yo'q (ko'rinmas)

python
# ishlaganini hech kim bilmaydi             # ⚠️
logging.info("boshlandi/tugadi")           # ✅

5. Muhit farqi (cron minimal PATH)

py skript.py    # cron'da py topilmaydi     # ⚠️
/full/path/py /full/path/skript.py         # ✅ to'liq yo'l

6. Vaqt mintaqasi (timezone)

0 9 * * *   # server UTC? mahalliy?         # ⚠️
# timezone aniqla (APScheduler timezone=)  # ✅

7. Monitoring yo'q (jim yiqiladi)

# vazifa ishlamasa hech kim sezmaydi        # ⚠️
# dead man's switch (Healthchecks.io)      # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 26.1-dars (o'tilgan): Skript — cron nima ishga tushiradi
  • 26.2-dars (o'tilgan): Fayl avtomatlashtirish — davriy
  • 26.7-dars (o'tilgan): API — davriy sinxronizatsiya
  • 28-qism: Infratuzilma — server cron
  • 09-dars (o'tilgan): Xatolar — vazifa mustahkamligi

8. Eng yaxshi amaliyotlar

  1. cron ifodasini tekshir (crontab.guru).

  2. To'liq yo'l ishlat (cron minimal muhit).

  3. Idempotent yoz (qayta urinish zararsiz).

  4. Xato boshqar (try/except, log).

  5. Log yoz (ko'rinmas jarayon).

  6. Monitoring (dead man's switch).

  7. Timezone aniqla.

  8. Vazifa qisqa (uzun bo'lsa — navbat).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # rejalashtirilgan vazifa nima?
2.  # cron nima?
3.  # cron necha maydon?
4.  # maydonlar qaysi?
5.  # '0 9 * * *' nima?
6.  # '*/15' nima?
7.  # Windows'da nima?
8.  # schedule nima?
9.  # APScheduler nima?
10. # idempotentlik nima?
11. # nega log?
12. # dead man's switch nima?
Javoblar
  1. Skript belgilangan vaqtda avtomatik ishga tushadi
  2. Unix rejalashtirish tizimi
  3. 5 maydon
  4. Daqiqa, soat, oy-kuni, oy, hafta-kuni
  5. Har kuni 09:00
  6. Har 15 (qadam)
  7. Task Scheduler
  8. Oddiy Python rejalashtirish kutubxonasi
  9. Kuchli rejalashtirish (cron ifoda)
  10. Qayta ishlasa bir xil natija
  11. Ko'rinmas — nima bo'ldi bilish
  12. Vazifa ishlamasa ogohlantirish

Vazifa 2: Xatolarni tuzating

python
1.  9 0 * * *   # har kuni 09:00 xohladi

2.  process(sana)  # qayta = ikki marta

3.  job()  # yiqilsa jim

4.  # log yo'q

5.  py skript.py  # cron'da
Javoblar
python
1.  0 9 * * *   # daqiqa soat (0 9)

2.  if not done(sana): process(sana)

3.  try: job() except: log_error()

4.  logging.info("boshlandi/tugadi")

5.  /full/path/py /full/path/skript.py

Vazifa 3: cron ifoda

Yozing:

  1. Har soat
  2. Har kuni 18:00
  3. Har dushanba
  4. Har 10 daqiqa

Vazifa 4: Moslik

Aniqlang:

  1. 0 9 * * *
  2. */15
  3. 0 0 * * 1
  4. Keyingi vaqt

Vazifa 5: Scheduler

Simulyatsiya:

  1. Mock soat
  2. Moslik
  3. Ishga tushirish
  4. Log

Vazifa 6: Idempotentlik

Chidamli:

  1. Tekshir
  2. Belgila
  3. Qayta = skip
  4. Bir xil natija

Vazifa 7: O'ylash

Rejalashtirilgan vazifa nazoratsiz ishlaydi — odam kutmaydi, ko'rmaydi (fonda, belgilangan vaqtda). Nima uchun bu "ko'rinmaslik" idempotentlik, log va monitoringni oddiy skriptdan ko'ra muhimroq qiladi, va nega "bir marta sozla — doimiy ishla" ham kuch, ham xavf (jim yiqilish)?

Javob

Qisqa javob: "Ko'rinmaslik" idempotentlik, log, monitoringni muhimroq qiladi, chunki: rejalashtirilgan vazifa odamsiz ishlaydi (kimse kutmaydi, tekshirmaydi) — muammo jim yuz beradi (skript qo'lda ishga tushirilsa, odam natijani ko'radi; cron'da — yo'q). Idempotentlik muhim: cron vazifa qayta ishlashi mumkin (qayta urinish, ikki demon, qo'lda takror) — idempotent bo'lmasa, ikki marta zarar (ikki hisobot, ikki to'lov). Log muhim: ko'rinmas jarayon — log yagona "ko'z" (nima bo'ldi, qachon, xato). Monitoring muhim: vazifa jim yiqilsa (server o'chdi, xato) hech kim sezmaydi — dead man's switch ogohlantiradi. "Bir marta sozla — doimiy ishla" kuch: inson mehnatini abadiy avtomatlashtiradi (bir yil, o'n yil ishlaydi); xavf: unutiladi (sozlab qo'yildi, e'tibordan chiqdi) — jim yiqilsa yoki noto'g'ri ishlasa, uzoq vaqt sezilmaydi (eski hisobot, to'lganib qolgan disk). Yechim: ko'rinmas jarayonni ko'rinadigan qilish (log, monitoring, ogohlantirish) — mashina eslaydi, lekin odam nazorat qiladi.

1. Ko'rinmaslik — jim muammo

Skript (qo'lda): odam natijani ko'radi. cron: odam yo'q — muammo jim (sezilmas).

2. Idempotentlik (qayta ishlash)

cron qayta ishlashi mumkin. Idempotent bo'lmasa — ikki marta zarar (hisobot, to'lov).

3. Log — yagona ko'z

Nima Nega
Boshlandi/tugadi Ishladimi
Vaqt Qachon, qancha
Xato Nima yiqildi

4. Monitoring — jim yiqilish

Vazifa yiqilsa hech kim sezmaydi. Dead man's switch ogohlantiradi.

5. Kuch va xavf

  • Kuch: bir marta sozla — abadiy avtomatik (inson mehnati yo'q)
  • Xavf: unutiladi — jim yiqilsa uzoq sezilmaydi

6. Xulosa

  1. Ko'rinmaslik — muammo jim (odam yo'q)
  2. Idempotent (qayta = zararsiz), log (ko'z), monitoring (ogohlantirish)
  3. Kuch: doimiy avtomatik; xavf: jim yiqilish
  4. Ko'rinmas jarayonni ko'rinadigan qil (nazorat)

Nimani mustahkamlaydi: 2.6, 2.7-bo'limlar.

Xulosa

Bu darsda rejalashtirilgan vazifalar (cron) ni o'rgandik.

Eng muhim uch fikr:

  1. Rejalashtirilgan vazifa va cron ifodasi. Rejalashtirilgan vazifa — skript belgilangan vaqtda avtomatik ishga tushadi (har kuni 09:00, har 15 daqiqa): siz jadvalni belgilaysiz, tizim (cron demoni/scheduler) o'sha vaqtda chaqiradi — odamsiz, davriy avtomatlashtirish. cron ifodasi — 5 maydon: daqiqa (0–59), soat (0–23), oy-kuni (1–31), oy (1–12), hafta-kuni (0–6). Har maydonda * (har), aniq (5), ro'yxat (1,15), oraliq (9-17), qadam (*/15). 0 9 * * * = har kuni 09:00; */15 * * * * = har 15 daqiqa; 0 0 * * 1 = har dushanba.

  2. Sozlash joylari va idempotentlik. Rejalashtirish: cron (Linux server — crontab -e), Windows Task Scheduler (Trigger + Action, schtasks), Python schedule (oddiy — every().day.at("09:00")) yoki APScheduler (kuchli — cron ifoda, fon) — dastur ichida. Idempotentlik — vazifa qayta ishlasa ham bir xil natija (qo'shimcha zarar yo'q): cron qayta ishlashi mumkin (qayta urinish) — "bugun bajarildimi?" tekshirish (ikki hisobot/to'lov emas). Idempotentlik — nazoratsiz ishning ishonchliligi.

  3. Log, monitoring va nazorat. Rejalashtirilgan vazifa ko'rinmaydi (fonda, odam kutmaydi) — shuning uchun log (boshlandi, tugadi, xato — nima bo'ldi) va monitoring ("dead man's switch" — vazifa jim yiqilsa ogohlantir) zarur. Keng xatolar: cron maydon adashish (9 0 vs 0 9), idempotent emaslik, to'liq yo'l bermaslik (cron minimal PATH), timezone. "Bir marta sozla — doimiy ishla" — kuch (inson mehnatini abadiy avtomatlashtiradi), lekin xavf (unutiladi, jim yiqilish) — ko'rinmas jarayonni log/monitoring bilan ko'rinadigan qilish. Rejalashtirish — avtomatlashtirishga vaqt o'lchami: skript nima qilishni, cron qachon qilishni. Mashina eslaydi — odam nazorat qiladi.

Keyingi darsda Excel va hujjatlar bilan ishlash ni o'rganamiz: Python bilan Excel (openpyxl), Word, PDF hujjatlarni o'qish, yozish va avtomatik yaratish — ofis avtomatlashtirishi.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!