🚀 Database Indexing — tezkor qidiruv siri

Indeks nima?
➡️ Indeks — bu jadvaldagi ma’lumotlarni tezroq topish uchun yaratiladigan maxsus tuzilma.
📖 Kitobdagi “mundarija” kabi o‘ylang: indeks bo‘lsa, kerakli sahifani varaqlamasdan topasiz.

🔹 Indekssiz qidiruv

SELECT * FROM users WHERE email = 'ali@example.com';

❌ Jadvalni boshidan oxirigacha tekshiradi (Full Table Scan). Millionlab yozuv bo‘lsa — juda sekin.

🔹 Indeks bilan qidiruv

CREATE INDEX idx_users_email ON users(email);

✅ Endi DB email bo‘yicha maxsus daraxt tuzilmasidan foydalanadi. Qidiruv 10 baravar tezroq bo‘lishi mumkin.

🔹 Indeks turlari

• B-Tree → eng ko‘p ishlatiladi, tartiblangan qidiruv uchun.
• Hash → faqat = taqqoslash uchun.
• Unique → takroriy qiymatlarga ruxsat bermaydi.
• Composite → bir nechta ustunga indeks.
• Full-Text → matn bo‘yicha qidiruv.

⚠️ Indeksning kamchiliklari

• INSERT/UPDATE/DELETE sekinlashadi → chunki indeks ham yangilanadi.
• Disk joyini ko‘proq oladi.

👉 Shuning uchun:

• Ko‘p o‘qiladigan ustunlarga indeks qo‘ying.
• Ko‘p yoziladigan ustunlarda ehtiyot bo‘ling.

📌 Xulosa

• Indeks = tez qidiruv
• Afzallik → SELECT tezlashadi
• Kamchilik → yozish amallari sekinlashadi

🔑 Qoida: ko‘p qidiriladigan ustunlarga indeks qo‘yish, boshqa joylarda esa ehtiyotkor bo‘lish.

📌 RabbitMQ – Message Broker nima va nima uchun kerak? 🐇📩

🔹 RabbitMQ — bu xabar vositachisi bo‘lib, dasturlar o‘rtasida xabarlarni uzatishni osonlashtiradi. Ya’ni, Producer (jo‘natuvchi) xabar yuboradi, Consumer (qabul qiluvchi) esa uni oladi. Xabarlar esa Queue (navbat) orqali saqlanadi va tarqatiladi.

✅ Asosiy tushunchalar:

• Producer – xabar yuboradi.
• Exchange – qaysi queue’ga xabar tushishini belgilaydi.
• Queue – xabarlarni vaqtincha saqlaydi.
• Consumer – xabarlarni qabul qilib, ishlov beradi.

💡 Qayerda qo‘llanadi?

• Mikroservislar o‘rtasida aloqa qilishda 🔗
• Fon vazifalarni bajarishda (background jobs) ⚙️
• Real-time xabar almashishda (chat, monitoring) 📡
• Katta hajmdagi ma’lumotlarni navbat bilan qayta ishlashda 📊

🐍 Python misol (pika bilan):

📤 Xabar yuborish (Producer):

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')

channel.basic_publish(exchange='', routing_key='hello', body='Salom, RabbitMQ!')
print("✅ Xabar yuborildi!")
connection.close()

📥 Xabar olish (Consumer):

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')

def callback(ch, method, properties, body):
    print("📩 Xabar keldi:", body.decode())

channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=True)
print('⌛️ Kutilyapti...')
channel.start_consuming()

🚀 Xulosa: RabbitMQ dasturiy ta’minotlar o‘rtasida mustaqil va ishonchli xabar almashish imkonini beradi. Bu ayniqsa mikroservis arxitekturasi uchun juda muhim.

O'rnatish bo'yicha komentariyada👇

🥕 Celery nima o‘zi?

Tasavvur qiling, siz web dastur tuzyapsiz.
Foydalanuvchi ro‘yxatdan o‘tsa, unga email yuborish kerak.
Agar siz bu emailni asosiy dasturda yuborsangiz — foydalanuvchi kutib qoladi 😕

Lekin siz “email yuborish” ishini orqa fonda bajarishni xohlasangiz,
sizga Celery yordam beradi 🚀

☘️ Oddiy qilib aytganda:

Celery — bu sizning dasturingizda og‘ir ishlarni orqa fonda bajaradigan yordamchi.

Masalan:
• Email yuborish 📧
• Rasmni qayta ishlash 🖼
• Hisobot tayyorlash 📊

Dastur esa foydalanuvchiga darhol javob beradi ⚡️
Celery esa fonida tinchgina ishni bajaradi 😎

🔧 Celery’ning qisqa tavsifi:
• Celery - Fon vazifalarni boshqaruvchi tizim
• Worker - Orqa fonda ishlovchi “ishchi”
• Broker (Redis/RabbitMQ) - Vazifalar ro‘yxati (navbat)
• Backend - Natijalarni saqlovchi joy

Xullas, Celery — bu sizga yordamchi barista ☕️
Siz buyurtma berasiz, u esa orqa fonda bajaradi!

⚙️ Komentariyada 👇:

👉 “Celery qanday ishlaydi?”
👉 “Broker va Worker nima o‘zi?”
👉 “Celeryni qachon ishlatish kerak?”

🪄 Python Magiyasi #1

Kodga qarang 👇

print(True + True + False)

🤔 Sizningcha, bu kodning natijasi nima chiqadi? Javoblaringizni izohlarda kutib qolamiz!

🎯 FastStream — Pythonda asinxron xabar almashish (message broker) uchun qulay freymvork

FastStream yordamida Kafka, RabbitMQ yoki Redis bilan producer / consumer (ya’ni yuboruvchi va qabul qiluvchi) kod yozish juda oson bo‘ladi.

🧩 O‘rnatish:

# faqat asosiy qismi
pip install faststream

# RabbitMQ uchun:
pip install "faststream[rabbit]"

# Kafka uchun:
pip install "faststream[kafka]"

⚙️ Oddiy misol (RabbitMQ bilan):

from faststream import FastStream
from faststream.rabbit import RabbitBroker

broker = RabbitBroker("amqp://guest:guest@localhost:5672/")
app = FastStream(broker)

@broker.subscriber("hello")
async def handle(msg):
    print("📩 Qabul qilindi:", msg)

@app.after_startup
async def send():
    await broker.publish("Salom FastStream!", "hello")

🏃 Ishga tushirish:

faststream run app:app

🔹 Bu kod RabbitMQ orqali xabar yuboradi va shu zahoti uni qayta o‘qib, ekranga chiqaradi.
🔹 Asinxron ishlaydi (async/await), Pydantic bilan validatsiya ham qo‘llab-quvvatlanadi.

💡 Qisqacha:
FastStream — bu FastAPI singari, lekin xabar brokerlari uchun.
U mikroxizmatlar orasida tez, typed va oson aloqa o‘rnatish imkonini beradi.

🪄 Python Magic #2

📜 Kod parcha:

a = [1, 2, 3]
b = a
a.append(4)
print(b)

❓Savol: Natija nima chiqadi?
🎯 Javobni izohlarda yozing 👇
🧐 Nima uchun shunday chiqadi deb o‘ylaysiz?

Bir obyektmi yoki yangi nusxami? Pythonda aniqlab olaylik

Ko‘p odamlarni chalkashtiradigan mavzu — a = b bilan .copy() yoki deepcopy() o‘rtasidagi farq.

🔹 1. = — bu havola

a = [1, 2, 3]
b = a
a.append(4)
print(b)  # [1, 2, 3, 4]

➡️ bu yerda b yangi ro‘yxat emas. Ikkalasi bir obyektga qaraydi (ikkalasi ham bitta obyekt).
Shuning uchun a o‘zgarsa, b ham o‘zgaradi.

🔹 2. .copy() — 1-darajali (shallow) nusxa

a = [[1, 2, 3]]
b = a.copy()
a[0].append(4)
print(b)  # [[1, 2, 3, 4]]

➡️ bu funksiya eng tashqi qavatdan yangi nusxa oladi lekin agar ichki qavatlarda obyekt bo'lsa,
undan havola orqali foydalanadi. Demak, nested (ichma-ich) strukturada bu ham xavfli.

🔹 3. copy.deepcopy() — to‘liq mustaqil nusxa

import copy
a = [[1, 2, 3]]
b = copy.deepcopy(a)
a[0].append(4)
print(b)  # [[1, 2, 3]]

➡️ Barcha ichki obyektlar ham yangi yaratiladi.
a o‘zgarsa, b o‘zgarmaydi ✅

🔹 4. += vs = a + [...]

a = [1, 2, 3]
b = a
a += [4]       # joyida o‘zgartiradi
a = a + [5]    # yangi obyekt yaratadi

➡️ += obyektni joyida o‘zgartiradi,
a = a + [...] esa yangi obyekt qiladi.

💡 Xulosa:

• = — havola beradi.
• .copy() — sirtqi nusxa.
• copy.deepcopy() — to‘liq nusxa (deep).
• In-place amallar (+=, .append()) — asl obyektni o‘zgartiradi.

🧠 Pythonda Falsy va Truthy tushunchalari

Dasturlashda har bir obyekt mantiqiy qiymat (bool() orqali) baholanishi mumkin.
Pythonda har qanday obyekt mantiqiy True yoki False qiymatlardan biri sifatida olinishi mumkin.
Shu asosda obyektlar ikki turga bo‘linadi 👇

1. 🔹 Truthy — “rost” qiymatlar

if yoki while shartlarida True deb baholanadi.

Masalan:

if "Hello":
    print("Truthy!")  # ✅

2. 🔸 Falsy — “yolg‘on” qiymatlar

if yoki while shartlarida False deb baholanadi.

Masalan:

if "":
    print("Bu chiqmaydi ❌")

🧾 Pythonda Falsy qiymatlar ro‘yxati:

• False - Mantiqan yolg‘on
• None - Hech qanday qiymat yo‘q
• 0, 0.0, 0j - Nol
• '' - Bo‘sh string
• [] - Bo‘sh ro‘yxat
• {} - Bo‘sh lug‘at
• set() - Bo‘sh to‘plam
• () - Bo‘sh tuple
• range(0) - Bo‘sh diapazon

💡 Misol:

values = [None, 0, '', [], {}, set(), False, [1, 2]]

for v in values:
    if v:
        print(f"{v} → Truthy ✅")
    else:
        print(f"{v} → Falsy ❌")

Natija:

None → Falsy ❌
0 → Falsy ❌
 → Falsy ❌
[] → Falsy ❌
{} → Falsy ❌
set() → Falsy ❌
False → Falsy ❌
[1, 2] → Truthy ✅

🧩 Xulosa:

• Falsy — bool(value) → False
• Truthy — bool(value) → True

Shuning uchun shartlarda (if, while) bevosita obyektning o‘zini tekshirish kifoya:

if my_list:  # Bo‘sh emasmi?
    print("Ma'lumot bor ✅")

🧠 Kichik sir:
Ko‘p hollarda if something: yoki if not something: deb yozish —
if len(something) > 0: yozishdan ancha “pythonic” hisoblanadi 🐍

📌 Python kutubxonasi: Emot
🔍 Emodzilarni aniqlash va tahlil qilish

Matndagi emoji va emotikonlarni avtomatik aniqlash kerakmi? Unda Emot kutubxonasi aynan siz uchun!

🛠 Emot nima qiladi?
Bu kutubxona Python dasturlaringizda matndan emodzilarni topish, ularni o‘rganish yoki kerak bo‘lsa olib tashlash imkonini beradi.

💡 Qachon foydali?

• Matnli ma’lumotlarni tozalashda (preprocessing)
• NLP (Natural Language Processing) loyihalarida
• Emodzilarning semantikaga ta’sirini o‘rganishda

📥 Foydalanish juda oddiy:

from emot import emot

text = "Bugun kayfiyat ajoyib 😄🔥"
result = emot().emoji(text)
print(result)

📌 Natijada sizga emodzilar ro‘yxati va ularning pozitsiyasi bilan lug‘at qaytariladi.

{'value': ['😄', '🔥'], 'location': [[22, 23], [23, 24]], 'mean': [':grinning_face_with_smiling_eyes:', ':fire:'], 'flag': True}

o'rnatish:

pip install emot

🧠 response.get("object", []) vs response.get("object") or [] farqi

Pythonda dict.get() metodidan foydalanayotganda bu ikki yozuv o‘xshash ko‘rinsa ham, asosan None qiymatlarda farq qiladi.

🔹 Misol:

response = {"object": None}

print(response.get("object", []))  # ➜ None 😬
print(response.get("object") or [])  # ➜ [] ✅

🔍 Nima bo‘ldi?
1) .get("object", [])
• agar kalit ("object") yo'q bo'lsa - [] qaytaradi
• agar kalit bor lekin qiymati None bo'lsa - None qaytaradi ❌
• agar kalit bor va qiymati [] bo'lsa - [] qaytaradi
• agar kalit bor va qiymati [1,2] bo'lsa - [1,2] qaytaradi

2) .get("object") or []
• agar kalit ("object") yo'q bo'lsa - [] qaytaradi
• agar kalit bor lekin qiymati None bo'lsa - [] qaytaradi ✅
• agar kalit bor va qiymati [] bo'lsa - [] qaytaradi
• agar kalit bor va qiymati [1,2] bo'lsa - [1,2] qaytaradi

💡 Xulosa:
• Agar serverdan kelgan javobda "object" kaliti bo‘lishi ham, qiymati None bo‘lishi ham mumkin bo‘lsa,
response.get("object") or [] — xavfsizroq variant ✅

Shunda for item in response.get("object") or []: deb bemalol yozsangiz,
hech qachon ❌TypeError: 'NoneType' object is not iterable xatosi chiqmaydi 😉


🧩 Esda tuting:
• .get("key", default) — faqat kalit yo‘q bo‘lganda default qaytaradi,
• .get("key") or default esa kalit mavjud lekin qiymati falsy (None, [], "", 0) bo‘lsa ham defaultni qaytaradi.

SOLID nima?

SOLID — bu obyektga yo‘naltirilgan dasturlash (OOP) da yaxshi arxitektura yaratish uchun ishlatiladigan beshta asosiy prinsip to‘plami.

SOLID so‘zining har bir harfi quyidagilarni anglatadi:

• S — Single Responsibility Principle
• O — Open/Closed Principle
• L — Liskov Substitution Principle
• I — Interface Segregation Principle
• D — Dependency Inversion Principle

Keyingi 5 ta postda sizlar bilan yuqoridagi 5 ta prinsip va ularning nega muhimligi haqida gaplashamiz.
Bugun biz S — Single Responsibility Principle ni to‘liq ko‘rib chiqamiz.

🎯1. Single Responsibility Principle (SRP) ta’rifi

Robert C. Martin (Uncle Bob) quyidagicha ta’rif bergan:

“A class should have only one reason to change.”
Ya’ni: Har bir klass faqat bitta sababga ko‘ra o‘zgarishi kerak.

💡 2. Oddiy so‘zlar bilan

Biror klass (yoki modul, funksional bo‘lim) faqat bitta vazifani bajarishi kerak.
Agar bitta klass bir nechta vazifa bajarayotgan bo‘lsa — bu SRP ga zid.

📦 3. Misol (SRP buzilgan holat)

Faraz qilaylik, bizda Report nomli klass bor va u hisobot bilan bog'liq bo'lgan barcha ishni bajaryapti:

class Report:
    def __init__(self, data):
        self.data = data

    def calculate_statistics(self):
        # Hisobot uchun statistika hisoblash
        return sum(self.data) / len(self.data)

    def print_report(self):
        # Natijani konsolga chiqarish
        print(f"Report: {self.calculate_statistics()}")

    def save_to_file(self, filename):
        # Hisobotni faylga yozish
        with open(filename, 'w') as f:
            f.write(str(self.calculate_statistics()))

Bu yerda Report klassi:
• Statistika hisoblayapti ✅
• Natijani chop etayapti ❌
• Faylga saqlayapti ❌

👉 Demak, bu klass 3 xil sababga ko‘ra o‘zgarishi mumkin, chunki u 3 ta vazifani bajaryapti:
• Hisoblash usuli o‘zgarsa
• Natijani chiqarish formati o‘zgarsa
• Faylga yozish usuli o‘zgarsa

Bu SRP ni buzadi.

Bu holatdagi muammo shundaki, yuqoridagi 3 ta vazifadan (hisoblash, natijani chiqarish va faylga yozish) qaysidir biri o'zgarsa bo'lgani, biz butun klashni o'zgartirishga majbur bo'lamiz. Bu esa dastur kattalashgan sari qiyinlashib boradi va chalkashliklarni ko'paytiradi.

✅ 4. To‘g‘rilangan SRP varianti
Yuqoridagi Report klassini har bir vazifasi uchun alohida klass yozamiz va 3 ta klassga ajratamiz:

class ReportData:
    def __init__(self, data):
        self.data = data

    def calculate_statistics(self):
        return sum(self.data) / len(self.data)


class ReportPrinter:
    def print_report(self, statistics):
        print(f"Report: {statistics}")


class ReportSaver:
    def save_to_file(self, statistics, filename):
        with open(filename, 'w') as f:
            f.write(str(statistics))

Endi nima o'zgardi:
• ReportData — faqat hisoblash uchun mas’ul
• ReportPrinter — faqat chiqarish uchun mas’ul
• ReportSaver — faqat saqlash uchun mas’ul

👉 Har biri bitta sabab bilan o‘zgaradi. Ya'ni qaysi vazifa o'zgarsa o'sha vazifani bajaradigan klassni o'zgartiramiz xalos.

🧩5. Nega bu muhim?

Afzalliklari:
• Kod tushunarli va qo‘llab-quvvatlash oson
• Testlash oson (har bir klass alohida test qilinadi)
• O‘zgarishlar boshqa qismga ta’sir qilmaydi
• Qayta foydalanish oson

Bu afzalliklar kichik loyihalarda bilinmasligi mumkin lekin katta loyihalar qilsangiz, tilla tanga topgandek bo'lasiz🔥.

⚠️ 6. Real hayotdagi o‘xshatish

Tasavvur qiling, sizning kafeyingizda bir inson bor:
• Ham oshpaz 🍳
• Ham ofitsiant 🍽
• Ham buxgalter 💰

Bu inson ishini o‘zgartirmoqchi bo‘lsa (masalan, yangi retsept qo‘shmoqchi bo‘lsa), u boshqa rollarini ham o‘zgartirishga majbur bo‘ladi.
Yaxshisi, har bir ishni alohida mutaxassis bajarishi kerak — bu SRP!

🧠 7. Yakuniy xulosa

Single Responsibility Principle — bu “bitta klass — bitta mas’uliyat” degan tamoyil.
🔹 Har bir klass bitta ishni bajarsin.
🔹 Agar klass bir nechta sabab bilan o‘zgarishi mumkin bo‘lsa, uni bo‘lish kerak.
🔹 Natijada kod modulli, testlanadigan, va barqaror bo‘ladi.

🎯 #SOLID — 2️⃣ OCP: Open/Closed Principle

🔹 “Kod kengaytirishga ochiq, lekin o‘zgartirishga yopiq bo‘lishi kerak.”
Bu prinsip shuni anglatadiki — agar tizimga yangi xatti-harakat (funksiya, qoidalar, logika) qo‘shmoqchi bo‘lsak, mavjud kodni o‘zgartirmasdan kengaytirishimiz kerak ✅

💡 Oddiy tushuntirish:

Tasavvur qiling — sizda Shape klassi bor, va siz doira ham, to‘g‘ri to‘rtburchak ham chizmoqchisiz 🟠🟩
Agar siz draw() funksiyasida if-else orqali shaklni ajratsangiz — yangi shakl qo‘shganingizda eski kodni ham o‘zgartirasiz ❌
Bu OCPga zid.

❌ Yomon yechim (OCP buzilgan):

class ShapeDrawer:
    def draw(self, shape_type):
        if shape_type == "circle":
            print("Chizilyapti: doira")
        elif shape_type == "square":
            print("Chizilyapti: kvadrat")

➡️ Yangi shakl qo‘shmoqchimisiz?
Demak ifga yana shart qo‘shasiz. Bu — mavjud kodni o‘zgartirish degani 😬

✅ To‘g‘ri yechim (OCPga mos):

class Shape:
    def draw(self):
        pass

class Circle(Shape):
    def draw(self):
        print("Chizilyapti: doira")

class Square(Shape):
    def draw(self):
        print("Chizilyapti: kvadrat")

def render(shape: Shape):
    shape.draw()

Endi yangi shakl qo‘shmoqchimisiz?
Fakat yangi klass yozasiz, eski kodni o'zgartirishingizga xojat yo'q🔥

📘 Xulosa:

✅ Yangi funksionallik qo‘shish — o‘zgartirishsiz kengaytirish orqali bo‘lishi kerak
❌ Eski kodni tahrir qilish — xatolik xavfini oshiradi
🔹 OCP — kodni barqaror va kengaytiriladigan qiladi


🧱 SOLID #2 — OCP (Open/Closed Principle)
"Be open for extension, but closed for modification."

📌 Python darsi: insort() — tartibni buzmasdan qo‘shish!

Ko‘p hollarda bizda tartiblangan ro‘yxat bo‘ladi, va biz unga yangi element qo‘shmoqchimiz.
Ammo append() yoki insert() dan foydalansak — tartib buziladi, keyin yana sort() qilishga to‘g‘ri keladi 😩

Shunda yordamga bisect.insort() keladi 🚀

🧩 Misol:

from bisect import insort

numbers = [1, 3, 5, 7]
insort(numbers, 4)
print(numbers)

🟢 Natija:

[1, 3, 4, 5, 7]

➡️ insort() — yangi elementni ro‘yxat ichidagi to‘g‘ri joyiga joylashtiradi.
Ya’ni ro‘yxat tartiblangan holatda qoladi, sort() chaqirish shart emas ✅

📚 Qisqacha tushuncha:
• insort(list, element) — elementni joylashtiradi (ro‘yxat tartibini saqlaydi)
• bisect_left() va bisect_right() esa qaysi joyga joylashtirish kerakligini topadi.

⚙️ Yana bir misol:

from bisect import bisect_left, insort

nums = [1, 2, 4, 5]
pos = bisect_left(nums, 3)
print(pos)   # 2

insort(nums, 3)
print(nums)  # [1, 2, 3, 4, 5]

💡 Afzalligi:
• Har safar sort() chaqirishga hojat yo‘q
• insort — O(n) vaqt oladi, sort() esa O(n log n)
• Kichik, lekin samarali optimizatsiya 🔥

#️⃣ Xulosa:
• insort() — bu ro‘yxatni qayta sort qilmasdan, yangi elementni tartibga mos joyga qo‘shishning eng toza yo‘li 🧠

🧵 Modul: bisect
🔍 Funktsiya: insort(list, value)
⚡️ Ishlatish: from bisect import insort

📘 #Python | Walrus operatori (:=)

Python 3.8 versiyasidan boshlab yangi operator — walrus operatori (:=) paydo bo‘lgan.
U orqali biz biror o‘zgaruvchiga qiymat berish va shu qiymatdan darhol foydalanish imkoniga egamiz 😎

🔹 Oddiy holat

x = int(input("Son kiriting: "))
natija = x + x**2
print(natija)

Bu yerda avval x ga qiymat beramiz, keyin undan alohida foydalanamiz.

🔹 Walrus operatori bilan

natija = (x := int(input("Son kiriting: "))) + x**2
print(natija)

Bu ifoda bir qatorning o‘zida:
1. int(input()) orqali foydalanuvchi kiritgan sonni oladi,
2. shu qiymatni x ga yozadi,
3. va shu qiymatdan yana ifoda ichida foydalanadi (x**2 qismida).

🔍 Misol: agar foydalanuvchi 5 kiritsa,
(x := 5) → x = 5 bo‘ladi,
so‘ng 5 + 5**2 = 30 chiqadi.

🔹 Yana bir misol (ko‘p ishlatiladigan holat)

# 0 kiritilgunga qadar sonlarni yig‘ish
total = 0
while (x := int(input("Son kiriting (0 - stop): "))) != 0:
    total += x

print("Yig‘indi:", total)

Bu yerda (x := int(input())) qiymatni oladi, x ga yozadi va while shartida ham foydalanadi — bitta qatorda! 🔁

⚠️ Eslatma:
• Walrus operatori faqat Python 3.8+ versiyalarida ishlaydi.
• Juda foydali, lekin haddan ortiq ishlatish kodingizni o‘qish qiyinlashtirishi mumkin — balansni saqlang 😉

✨ Xulosa:
1. := — qiymatni o‘zgaruvchiga yozish va uni darhol ishlatish imkonini beradi
2. Kodni ixcham, chiroyli va “pythonic” qiladi
3. Ayniqsa while sikllari, shartlar va bitta ifoda ichida hisoblashlarda juda qulay

📘 #Python | (A, B)[shart] — noodatiy ifoda

Ba’zan kodingizda shartga qarab 2 xil qiymatdan birini tanlash kerak bo‘ladi.
Masalan:

x = 12
natija = "katta" if x > 10 else "kichik"
print(natija)

Natija: katta

🔹 Lekin buni “hiyla” orqali ham yozish mumkin 😎

x = 12
natija = ("kichik", "katta")[x > 10]
print(natija)

💡 Bu yerda:
• ("kichik", "katta") — tuple
• [x > 10] esa indeks sifatida ishlatiladi (True → 1, False → 0)

Demak:
• agar x > 10 → True → [1] → "katta"
• agar x > 10 → False → [0] → "kichik"

🔍 Yana bir misol:

son = int(input("Son kiriting: "))
natija = ("juft", "toq")[son % 2]
print(natija)

➡️ Foydalanuvchi 7 kiritsa → son % 2 = 1 → "toq"
➡️ Agar 8 kiritsa → son % 2 = 0 → "juft"

⚠️ Lekin ehtiyot bo‘ling:
Garchi (A, B)[shart] ishlasa ham, bu tavsiya etilmaydi ❌

Sabablari:
• Har doim ikkala elementni ham (ya'ni tuple ichidagi element yoki ifodani) hisoblaydi — if else esa faqat keraklisini.
• Kodingizni o‘qish qiyinlashadi.
• Katta loyihalarda bu ifoda chalkashlik keltirib chiqaradi.

✅ To‘g‘ri, toza usul:

natija = "katta" if x > 10 else "kichik"

Bu ancha o‘qilishi oson, “pythonic” va xavfsiz.

✨ Xulosa:
• (A, B)[shart] — shartga qarab 0 yoki 1 indeksni tanlaydi
• Lekin bu faqat “hiyla” sifatida yaxshi, amalda — if ... else ... ishlating 💪

🧪 Dasturlashda testlash nima uchun juda muhim?

Testlash — bu dastur to‘g‘ri ishlayotganini tekshirish jarayoni. U kodni ishonchli, barqaror va xatolarsiz qiladi.

🔹 Nima uchun test yozish kerak?
• Xatolarni erta topadi 🐞
• Kodni o‘zgartirishdan qo‘rqmaysiz 💪
• Loyihani boshqalar ham oson tushunadi 📘
• Tizim ishonchli ishlaydi ⚙️

🔹 Test yozish va qo‘lda (manual) testlash farqi
Test yozish (avtomatik):
• Kod bilan yoziladi, tez bajariladi
• Har safar avtomatik ishlaydi
• Kam xato
• CI/CD tizimiga ulanadi

Qo'lda testlash:
• Inson qo‘lda tekshiradi 👩‍💻
• Har safar qayta bajarish kerak
• Inson xatosi bo‘lishi mumkin
• Mustaqil ishlanadi (CI/CD tizimiga ulanmaydi)

🔹 Kichik va katta loyihalarda farqi
• Kichik loyiha: faqat muhim joylarni testlab qo‘yish ham yetadi.
• Katta loyiha: avtomatlashtirilgan testlarsiz iloji yo‘q — hammasi tizimga ulanadi.

⏱️ Vaqt sarfida avtomatik testlashning foydasi
• Boshlanishida test yozish vaqt oladi, lekin keyin bu vaqtni ko‘p marotaba tejaydi.
• Bir marta yozilgan test — har safar dastur o‘zgarganda siz uchun avtomatik tekshiruvchi bo‘ladi.

✅ Xulosa
• Test yozish — bu kodni tekshirish emas, uni ishonch bilan rivojlantirish uchun asosdir.
• Manual testlash — ko‘rish, his qilish uchun kerak;
• Avtomatik testlar esa — ishonchli ishlash kafolati.

Shunday ekan avtomatik test yozishni o'rganib qo'yavering, axir siz katta-katta loyihalar qilishingiz kerak😄

🐍 Pythonda Dekorator nima?

Dekorator — bu funksiya bo‘lib, u boshqa funksiyani argument sifatida qabul qiladi va yangi (o‘ralgan) funksiyani qaytaradi. 🎁

Oddiy qilib aytganda — funksiyani bezovchi funksiya 😊

🔹 Misol:

def dekorator(func):
    def orovchi():
        print("Oldin")
        func()
        print("Keyin")
    return orovchi

@dekorator
def salom():
    print("Salom, dunyo!")

salom()

📤 Natija:

Oldin
Salom, dunyo!
Keyin

💡 Dekoratorlardan foydalanish joylari:
• 🔍 Loglash (funksiya chaqirilganini yozib borish)
• ⏱️ Vaqt o‘lchash
• 🔐 Avtorizatsiya tekshiruvi
• 🧩 Kesh (cache) mexanizmi
• 🧰 Kod takrorlanishini kamaytirish

🧠 Xulosa:
Dekorator — “funksiyani qabul qilib, funksiya qaytaruvchi funksiya”.
Kodga qo‘shimcha imkoniyat qo‘shish uchun ishlatiladi 🔧

Batafsil ma'lumotni komentariya topishingiz mumkin👇