🌀 Generator nima?

Generator — bu maxsus funksiya bo‘lib, u katta hajmdagi ma’lumotlarni bitta-bitta (navbatma-navbat) yaratadi. U yield kalit so‘zi yordamida ishlaydi.

Bu xuddi televizordan tomosha qilish o‘rniga, bir vaqtning o‘zida faqat bir sahifasini chiqaradigan kitobga o‘xshaydi. Har safar kerak bo‘lganda navbatdagi sahifa (qiymat) chiqariladi.

🎯 Nega generator kerak?

Oddiy funksiya:

def list_numbers():
    return [1, 2, 3]

print(list_numbers())

Bu funksiya butun ro‘yxatni birdan qaytaradi va xotirada saqlaydi. Katta ro‘yxat bo‘lsa — xotira ko‘p ishlatiladi.

Generator:

def gen_numbers():
    yield 1
    yield 2
    yield 3

for num in gen_numbers():
    print(num)

Bu funksiya esa har safar bittadan qiymat chiqaradi va xotirani tejaydi.

Agar generatorni kimgadir oddiy tilda tushuntirishim qiziq bo'lsa reksiya qoldirsin, hech bo'lmaganda bitta odam uchun foydali bo'lsa tushuntirib beraman, oddiy tilda o'xshatish orqali 👍

🔁 yield nima?

• return funksiyani to‘xtatadi va qiymatni beradi.

• yield esa bir marta qiymat beradi, ammo funksiyani to‘xtatmaydi.

• Keyingi safar chaqirilganda, yield dan keyingi qatorlardan davom etadi.

🔧 Oddiy generator misoli

def sonlar():
    print("1 chi son")
    yield 1
    print("2 chi son")
    yield 2
    print("3 chi son")
    yield 3

for s in sonlar():
    print("Chiqarildi:", s)

Natija:

1 chi son
Chiqarildi: 1
2 chi son
Chiqarildi: 2
3 chi son
Chiqarildi: 3

📦 Generator qanday foydali?

Masalan, 1 millionta sonni chiqarish:

def million():
    for i in range(1_000_000):
        yield i

# Bu juda katta ro'yxat bo'lishi mumkin, ammo generator xotirani tejaydi
for i in million():
    if i == 5:
        break
    print(i)

Bu yerda xotirada 1 millionta son saqlanmaydi (oddiy ro'yxatda bo'lsa 1 millionta son operativ xotirada saqlanib turadi), faqat kerakli sonlar yaratiladi.

🧪 Generator expression (generator ifodasi)
Bu generatorning qisqa yozilish usuli:

gen = (x * x for x in range(3))
for i in gen:
    print(i)

Natija:

0
1
4

Bu list comprehension ga o‘xshaydi: [x*x for x in range(3)], lekin generator xotirani tejaydi.

Bitta bo'lsa ham reaksiya qoldirilibdi, shuning uchun o'xshatish:

1. oddiy ro'yxat va generatorni farqi haqida:

oddiy ro'yxat bizga kerakli qiymatlarni hammasini bittada olib keladi, generator esa bizga kerakli qiymatlar to'plamini bittadan olib keladi (tashiydi)

Tasavvur qiling siz qurilish qilyapsiz va devor uryapsiz, sizga 1000 ta g'isht kerak, ro'yxat shu g'ishlarni bittada olib keladi, generator esa bittadan olib keladi (albatta g'isht uyumi uncha uzoqda emas)

2. generator nimaga xotirani tejaydi?

keltirgan misolimizda sizni g'isht qo'yadigan joyingiz chekli sondagi g'isht qo'yishga moslashtirilgan, ya'ni xotira chekli

o'sha joyga ro'yxat bittada 1000 ta g'ishtni olib kirib qo'ydi va sizni g'isht qo'yadigan joyingizdan ko'proq joy egalladi, ya'niki xotiradan

generator esa sizga bitta g'isht olib keldi siz uni ishlatasiz keyin yana bitta g'isht olib keladi, g'isht qo'yadigan joydan juda kam joy oladi, ya'niki xotiradan

3. qachon ro'yxat ishlatish kerak, qachon generator? qaysi biri tez ishlaydi?

To'g'ri sizga mingta g'isht kerak bo'lsa ro'yxat xotiradan ozginagina ko'p joy olgani bilan, 1000 ta g'ishtni hammasi srazi yonida bo'lgan odam tezroq ishlaydi va bu holatda ro'yxat afzal,

Lekin tasavvur qiling sizga millionta g'isht kerak va ro'yxat uni sizga hammasini bittada olib kelib berdi, birinchidan u juda ko'p joy oladi (ya'niki xotiradan), ikkinchidan ishlashga xalaqit qiladi, bu holatda generator afzal va tezroq ishlaydi

Hamma postlarimga o'zim layk bosim chiqsammikin a, keyin ko'zim ko'rib quvonardim layk bosilibdi deb😁

Layk bosgan yaxshi insonga raxmat🫡

Context Managers (Kontekst menejerlari)

Context Manager — bu with operatori orqali blok ichida resursni ochib-yopishni boshqaruvchi obyekt. Masalan, fayl ochish va avtomatik yopish.

Misol:

with open('file.txt', 'r') as f:
    data = f.read()
# Fayl avtomatik yopiladi

O‘zimiz context manager yozish (klass bilan):

class MyContext:
    def __enter__(self):
        print("Kontekstga kirildi")
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Kontekstdan chiqildi")

with MyContext():
    print("Ichkarida ishlayapti")

Yoki funksiya bilan (contextlib):

from contextlib import contextmanager

@contextmanager
def my_context():
    print("Boshlanmoqda")
    yield
    print("Tugallanmoqda")

with my_context():
    print("Ichida ishlayapti")

Context Managers haqida batafsil yoritmoqchiman, qarshimasmisizlar?🧐

Context managerni tushunishdan oldin biz with operatorini tushunib olishimiz zarur bo'ladi.

🧠 with operatori nima?

with — bu Pythondagi maxsus operator bo'lib, u faqat context manager deb ataladigan obyektlar bilan ishlaydi.

Bu degani siz qayerdadir withni ishlatyapsizmi, demak siz o'zingiz bilib yoki bilmay context managerdan foydalanyapsiz! (manabunisi surpriz deganlar nechtamiz🤓)

🎯 withning asosiy maqsadi:
Resurs (masalan fayl, ulanish, lock, va h.k.) bilan ishlashni xavfsiz va toza qilish: ya’ni avtomatik ochish va tozalash/yopishni boshqarish.

Agar siz with ishlatmasangiz resurs bilanishlaganingizda, masalan fayl bilan ishlaganingizda birinchi uni ochasiz, nimadir ish bajarasiz va keyin uni yopasiz, ikkita amal orasida qandaydir xatolik chiqishi mumkinligini hisobga olib try - finally ishlatishingiz kerak, bo'lmasa qandaydir xatoliklar chiqishi mumkin. Shuningdek fayl ochib keyin yopish esingizdan chiqishi oqibatida xatoliklar chiqishi mumkin.

Shunaqa muammolar chiqmasligini xoxlasangiz bu ishlarni withga topshirasiz, va u bu ishlarni siz uchun o'zi amalga oshiradi.

🔁 Foydalanish sxemasi:

with <context_manager> as <variable>:
    # shu yerda ish bajariladi

Eng keng tarqalgan misol:

with open("data.txt", "r") as f:
    content = f.read()

❓ with faqat context manager bilan ishlaydi. Ya’ni, with bilan ishlatilayotgan bu obyektlar:

1. __enter__() metodiga ega bo'lishi kerak (blok boshlanishida chaqiriladi)
2. __exit__() metodiga ega bo'lishi kerak (blok tugaganda avtomatik chaqiriladi)

Bir kod tahlili:

with open("data.txt", "r") as f:
    content = f.read()

🔍 Bu kodda nimalar sodir bo‘ladi?

with operatori — bu context managerni chaqiradi.

1️⃣ Qadam: open("data.txt", "r")
• open() funksiyasi faylni ochadi va TextIOWrapper nomli fayl obyektini qaytaradi.
• Bu obyekt __enter__ va __exit__ metodlariga ega — ya’ni context manager sifatida ishlay oladi.

2️⃣ Qadam: __enter__() chaqiriladi
• Python avtomatik f = open(...).enter() deb chaqiradi.
• Bu metod faylni ochib, uning obyektini f o‘zgaruvchisiga beradi.

3️⃣ Qadam: f.read()
• Fayldan butun mazmuni content o‘zgaruvchisiga o‘qiladi.

4️⃣ Qadam: __exit__() chaqiriladi
• with blokidan chiqishda (hatto xatolik bo‘lsa ham!), Python:

f.__exit__(exc_type, exc_val, exc_tb)

metodini chaqiradi.

Bu metod faylni avtomatik yopadi.

🟦 Ya'ni, yuqorida keltirgan kodimiz aslida quyidagiga teng:

f = open("data.txt", "r")
try:
    content = f.read()
finally:
    f.close()

✅ Farqi shundaki, with versiyasi:

• Xatolarga nisbatan xavfsiz
• Toza, tushunarli, qisqa kod
• Har doim faylni yopishni kafolatlaydi

Bir kod tahlili:

Biz ishlatadigan kod:

with my_obj as var:
    # blok

Bu kod python tomonidan quyidagi kodga aylantiriladi va bajariladi, lekin bizning ko'zimizga ko'rsatilmaydi:

var = my_obj.__enter__()
try:
    # blok  ← bu kod `__enter__` ichida EMAS
finally:
    my_obj.__exit__(exc_type, exc_value, traceback)

Bosqichlar:

• __enter__() — resursni tayyorlash bosqichi
• # blok — asosiy ishlar bajariladi
• __exit__() — resurs tozalash bosqichi


Xulosa qiladigan bo'lsak, har qanday obyekt Pythonda context manager bo‘la oladi, agar u quyidagi ikkita metodga ega bo‘lsa:

1. __enter__(self)
2. __exit__(self, exc_type, exc_value, traceback)

with operatorini qo'llaganimizda esa bu metodlarni avtomatik bajarib beradi.


Siz aytishingiz mumkin siz keltirgan postlarda, quyidagi context manager yaratish kodi bor, lekin unda __enter__ va __exit__ metodlari yo'q deb:

from contextlib import contextmanager

@contextmanager
def my_context():
    print("Boshlanmoqda")
    yield
    print("Tugallanmoqda")

with my_context():
    print("Ichida ishlayapti")

🔍 @contextmanager dekoratori nima qiladi?
1. Siz generator funksiyasini (log_block) aniqlaysiz, unda:

• yielddan oldingi qism = __enter__ ishini bajaradi
• yielddan keyingi qism = __exit__ ishini bajaradi

2. @contextmanager o‘zi bu generatorni enter va exit metodlari bor maxsus obyektga o‘rab beradi.

• chaqirilganda __enter__() — generatorni ishga tushiradi va yieldgacha boradi, qiymat (yoki None) qaytaradi
• blok tugagach __exit__() — generatorga istalgan istisno ma’lumotlarini yuboradi va tozalash kodini (yielddan keyingilarni) ishga tushiradi

asyncio — Asinxron dasturlash

Tavsif:

• asyncio — bu asinxron I/O (input/output) asosida ishlaydigan kutubxona.
• async va await kalit so‘zlari orqali ishlaydi.
• Bir nechta vazifalarni (masalan, tarmoq so‘rovlari) bitta ip (thread) ichida navbatma-navbat boshqaradi.
• Tezkor, lekin CPU-intensiv vazifalar uchun emas, balki I/O-intensiv (masalan: fayl o‘qish, tarmoq, kutish) vazifalar uchun juda samarali.

Afzalliklari:

• Yengil resurs iste'moli.
• Ko‘p ulanishli web-serverlar yoki API mijozlari uchun ideal.

Misol:

import asyncio

async def salom_ber(name):
    await asyncio.sleep(1)
    print(f"Salom, {name}!")

async def main():
    await asyncio.gather(
        salom_ber("Ali"),
        salom_ber("Vali"),
    )

asyncio.run(main())

threading — Ko‘p ipli (multi-threaded) dasturlash

Tavsif:

• Har bir vazifa alohida ip (thread) ichida ishlaydi.
• Python Global Interpreter Lock (GIL) sababli haqiqiy parallel CPU ishlashi cheklangan (bir vaqtning o‘zida faqat bitta ip interpreterni egallaydi).
• Biroq I/O-intensiv ishlar (masalan, web so‘rovlar) uchun foydali bo‘lishi mumkin.

Afzalliklari:

• Kodni yozish nisbatan oson.
• Kutishli vazifalarda samarali.

Kamchiliklari:
• GIL sababli CPU-intensiv ishlar samarali emas.
• thread larni boshqarish va sinxronlashda murakkabliklar (deadlock, race condition) bo'lishi mumkin.

Misol:

import threading
import time

def salom_ber(name):
    time.sleep(1)
    print(f"Salom, {name}!")

t1 = threading.Thread(target=salom_ber, args=("Ali",))
t2 = threading.Thread(target=salom_ber, args=("Vali",))

t1.start()
t2.start()

t1.join()
t2.join()

multiprocessing — Ko‘p jarayonli (multi-process) dasturlash

Tavsif:

• Har bir vazifa yangi jarayon (process) sifatida ishga tushadi.
• Har bir jarayon o‘zining alohida Python interpreter va xotira maydoni bilan ishlaydi — bu GIL muammosini chetlab o‘tadi.
• CPU-intensiv (masalan: matematik hisob-kitoblar, katta ma'lumotlarni qayta ishlash) ishlar uchun ideal.

Afzalliklari:

• To‘liq parallel ishlash (ko‘p yadroli CPU dan to‘liq foydalanish mumkin).
• GIL muammosi yo‘q.

Kamchiliklari:

• Resurslar ko‘proq sarflanadi.
• Har bir jarayon alohida bo‘lgani uchun ma’lumot almashinuvi murakkab.

Misol:

from multiprocessing import Process
import time

def salom_ber(name):
    time.sleep(1)
    print(f"Salom, {name}!")

if __name__ == '__main__':
    p1 = Process(target=salom_ber, args=("Ali",))
    p2 = Process(target=salom_ber, args=("Vali",))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

Yuqoridagilarga o'xshatish:

CPU yadrosi -> oshpaz
bitta ip (thread) -> ofitsiant

1. oddiy dasturlash:

• oshpaz bitta, ofitsiant bitta
• bitta ofitsiant bitta mizojga vaqt ajratadi va to u turib ketmaguncha boshqa mijozga qaramaydi
• lekin juda kam mijoz keladigan oshxonaga bo'laveradi


2. asyncio — Asinxron dasturlash:

• oshpaz bitta, ofitsiant bitta
• bitta ofitsiant biror mijozga xizmat ko'rsatayotgan vaqtda boshqa mijoz kelsa, birinchi mijozdan bo'sh vaqtida qolgan mijozlarga ham xizmat qilaveradi
• natijada ofitsiantdan unumli foydalanib ishlarni tezlashtiramiz
• ish maksimum oshpazni imkoniyati qadar tezlashadi, lekin oshpazga bog'liq bo'lmagan ishlar ancha tezlashadi

3. threading — Ko‘p ipli (multi-threaded) dasturlash

• oshpaz bitta, ofitsiant ko'p
• har bir ofitsiant bittada mijozga xizmat qiladi, natijada ish tezlashadi
• ish maksium oshpaz imkoniyati qadar oshadi, chunki asyncio kabi oshpaz bitta, va bir vaqtda oshpaz bitta ofitsiant bilan ishlay oladi xalos
• oshpazga bog'liq bo'lmagan ishlarda, asyncio tezroq ishlaydi, sabibi yangi ofitsiant yo'llashning o'ziga yarasha qo'shimcha ishlari bor va xarajati yuqori
• 64-bitlik pythonda 10 000 tagacha ofitsiant yo'llashingiz mumkin, kompyuter kuchidan kelib chiqib

4. multiprocessing — Ko‘p jarayonli (multi-process) dasturlash

• oshpaz ko'p, ofitsiant ko'p
• xuddiki bir nechta oshxonangiz bor va mijozlarni ularga taqsimlayapsiz, ular bir-biridan butkul mustaqil
• agar ishingiz asosan oshpazga bog'liq bo'lsa, bu qolgan turlardan ko'ra juda tez ishlaydi, lekin sizda oshpazga bog'liq bo'lmagan ishlar (masalan: idish yuvish) ko'p bo'lsa yangi oshxonalar ochishingizga arzimaydi. yangi oshxona ochish va hamma oshxonalardan habardor bo'lib turish ko'p energiya talab qiladi.
• yana shuni bilish kerakki, sizda 8 ta oshxona bo'lsa, siz maksimum bir vaqtda 8 ta oshpaz ishlatasiz, va qolgan oshpazlar oshxonalar uchun navbatda turadi

I/O ishlar uchun asyncio odatda threading dan tezroq va samaraliroq bo‘ladi.

🧪 Nima uchun asyncio tezroq?

1. Bitta ip (thread) — resurs tejamkor

• asyncio bitta ipda ishlaydi, ya’ni thread yaratish, boshqarish, kontekst o‘zgartirish (context switch) xarajatlari yo‘q.
• threading esa har bir ish uchun alohida ip ochadi — bu esa tizimda ortiqcha yuk keltiradi.

2. Kontekst almashtirish (context switching) kam

• asyncio vazifalarni event loop orqali navbatma-navbat bajaradi.
• threading esa OS yordamida iplar orasida doimiy kontekst o‘zgarishiga sabab bo‘ladi (sekinroq).

3. Ko‘p ulanishli serverlar uchun ideal

• Masalan, 10 000 HTTP so‘rovni qayta ishlash kerak bo‘lsa:
• asyncio buni bitta ipda qiladi.
• threading da bu 10 000 ip yaratish degani bo‘lishi mumkin — tizim yiqiladi.

📊 Tezlik solishtiruvi (oddiy misol bilan):
asyncio bilan:

import asyncio
import time

async def fake_io():
    await asyncio.sleep(1)

async def main():
    start = time.time()
    await asyncio.gather(*[fake_io() for _ in range(100)])
    print("Asyncio:", time.time() - start)

asyncio.run(main())

threading bilan:

import threading
import time

def fake_io():
    time.sleep(1)

start = time.time()
threads = []

for _ in range(100):
    t = threading.Thread(target=fake_io)
    t.start()
    threads.append(t)

for t in threads:
    t.join()

print("Threading:", time.time() - start)

👉 Natijada:

• asyncio — ~1.1 sekund.
• threading — ~1.5-2.5 sekund (va ko‘proq xotira ishlatiladi).

Python dasturlash tilida o‘zgaruvchi (variable) nomlarini yozishda turli nomlash uslublari (naming conventions) mavjud, va ularning har biri ma'lum holatlarda ishlatiladi. Quyida wariable_name, variableName, va VariableName shakllarining qachon ishlatilishini tushunishga harakat qilamiz.

✅ 1. snake_case → variable_name
Eng keng tarqalgan Python uslubi.

🔹 Qayerda ishlatiladi:

• Oddiy o‘zgaruvchilar
• Funktsiyalar nomlari
• Modullar nomlari

user_name = "Ali"
total_price = calculate_total()

📌 PEP8 — Python rasmiiy uslub qo‘llanmasi, snake_case ni tavsiya qiladi.

✅ 2. camelCase → variableName
Pythonda odatda ishlatilmaydi, lekin boshqa tillardan o‘rganilgan odat sifatida ko‘rinishi mumkin (masalan, JavaScript, Java).

🔹 Qayerda ishlatilishi mumkin:

• Boshqa tillardan kelgan API'larda (masalan, jsonData.userName)
• Django model metodlarida kamdan-kam
• Shaxsiy uslubda, lekin Python’da bu tavsiya qilinmaydi.

# Python uslubiga to‘g‘ri kelmaydi:
userName = "Ali"

✅ 3. PascalCase → VariableName
Klass nomlari uchun ishlatiladi.

🔹 Qayerda ishlatiladi:

• Class nomlari
• Exception nomlari

class UserProfile:
    pass

class LoginError(Exception):
    pass

✅ 4. UPPER_CASE → CONSTANT_NAME
Doimiy (o‘zgarmas) qiymatlar uchun ishlatiladi.

MAX_RETRIES = 5
DEFAULT_TIMEOUT = 10

🧠 Xulosa (Qisqacha):
Uslub Misol Qayerda ishlatiladi
snake_case user_name O‘zgaruvchi, funksiya nomi
camelCase userName Pythonda tavsiya etilmaydi
PascalCase UserProfile Class nomlari
UPPER_CASE MAX_SIZE Konstantalar (o‘zgarmas qiymatlar)

camelCase Python'da tavsiya qilinmaydi, chunki bu Python’ning rasmiy kod yozish standarti — PEP8 ga zid keladi.

🔍 Sabablari:
1. PEP8 standarti snake_case ni belgilagan
Pythonning rasmiy ko‘rsatmasida funksiya va o‘zgaruvchi nomlari uchun faqat snake_case ishlatish belgilangan:

# To'g'ri (PEP8):
user_name = "Ali"
def calculate_total():
    ...

# Noto'g'ri (camelCase):
userName = "Ali"
def calculateTotal():
    ...

PEP8 — bu jamoaviy kodlashda konsistentlik (birxillik) yaratish uchun yaratilgan. Barcha Python kutubxonalari (masalan, Django, Flask, Pandas, NumPy) ham snake_case ishlatadi.

2. O‘qish osonligi
snake_case so‘zlar orasini aniq ajratadi:

calculate_total_price  # Aniq, tez o'qiladi
calculateTotalPrice    # Ko'z uchun biroz yukliroq

3. Boshqa Python kodlari bilan uyg‘unlik
Pythonning standart kutubxonasi (masalan, os.path, json, datetime) hamma joyda snake_case ishlatadi. Agar siz camelCase ishlatsangiz, boshqa kodlar bilan uyg‘unlik buziladi.

4. Yangi Pythonchilar chalkashadi
Yangi o‘rganuvchilar JavaScript yoki Java’dan kelgan bo‘lsa, ular camelCase ishlatishga odatlangan bo‘ladi. Ammo bu Python'da noaniqlik keltiradi va yomon tajriba hisoblanadi.

💡 Qachon camelCase ishlatilsa bo‘ladi?
• Boshqa tillardan yoki tashqi APIlardan (JavaScript, Java, C#) kelayotgan kod bilan ishlaganda:

# JavaScript'dan kelgan JSON
json_data = {"userName": "Ali"}
user_name = json_data["userName"]

• C++/Java integratsiyasi qilinayotgan hollarda (masalan, PyQt, Qt metodlari):

self.setWindowTitle("App")  # Qt: camelCase metod nomlari

✅ Xulosa:
Usul Python’da tavsiya etiladimi? Sababi
snake_case ✅ Ha PEP8 standarti, o‘qish oson
camelCase ❌ Yo'q Standartga zid, chalkashlik