Joylangan funksiyalar

#Tayyor asboblar qutisi

Python örnatilganda u bilan birga önlab tayyor funksiyalar keladi. Ularni heç narsa import qilmasdan işlatiş mumkin — şuning uçun ular joylangan (built-in) funksiyalar deyiladi. print(), len(), type(), range() bilan allaqaçon tanişsiz.

Bu bobda maʼlumotlar töplamini qayta işlaşda eng köp kerak böladigan funksiyalarni körib çiqamiz. Ularni yaxşi biliş önlab qatorli tsikllarni bir-ikki qatorga qisqartiriş imkonini beradi.

#map(): har bir elementga funksiya qöllaş

map(funksiya, toʻplam) töplamning har bir elementiga funksiyani qöllaydi:

narxlar_str = ["12000", "4500", "31000"]

narxlar = list(map(int, narxlar_str))
print(narxlar)

dollarda = list(map(lambda s: round(s / 12_800, 2), narxlar))
print(dollarda)

ismlar = ["aziz", "LOLA", "şerzod"]
print(list(map(str.title, ismlar)))

Natija:

[12000, 4500, 31000]
[0.94, 0.35, 2.42]
['Aziz', 'Lola', 'Şerzod']

map() darhol röyxat qaytarmaydi — u dangasa obyekt (iterator) qaytaradi, elementlarni söralgandagina hisoblaydi. Şuning uçun natijani köriş uçun list() ga öradik.

#filter(): saralab oliş

filter(funksiya, toʻplam) funksiya rost qiymat qaytargan elementlarnigina qoldiradi:

ballar = [45, 88, 72, 30, 95, 61]

otganlar = list(filter(lambda b: b >= 60, ballar))
print(otganlar)

sozlar = ["olma", "", "nok", "", "anor"]
print(list(filter(None, sozlar)))   # None - "rost" elementlarni qoldiradi

Natija:

[88, 72, 95, 61]
['olma', 'nok', 'anor']

#Comprehension — map va filter örnini bosuvçi

10-bobda örgangan comprehension köpinça map() va filter() işini aniqroq bajaradi. Soliştiring:

ballar = [45, 88, 72, 30, 95, 61]

# map + filter
a = list(map(lambda b: b + 5, filter(lambda b: b >= 60, ballar)))

# comprehension
b = [b + 5 for b in ballar if b >= 60]

print(a)
print(b)
print(a == b)

Natija:

[93, 77, 100, 66]
[93, 77, 100, 66]
True

Natija bir xil, lekin comprehension çapdan öngga oddiy jumla kabi öqiladi. Umumiy tavsiya: tayyor funksiya bor bölsa (map(int, ...), map(str.upper, ...)), map() qisqa va çiroyli; lambda kerak bölsa — comprehension afzal.

#functools.reduce(): bitta qiymatga yiğiş

reduce() töplamni çapdan öngga "yiğib" boradi: avval 1- va 2-elementga funksiyani qöllaydi, keyin natija bilan 3-elementga va hokazo. U joylangan emas, functools modulidan import qilinadi:

from functools import reduce

sonlar = [2, 3, 4, 5]

kopaytma = reduce(lambda acc, x: acc * x, sonlar)
print(kopaytma)   # ((2 * 3) * 4) * 5

eng_uzun = reduce(lambda a, b: a if len(a) >= len(b) else b,
                  ["Qarşi", "Toşkent", "Urganç", "Nukus"])
print(eng_uzun)

Natija:

120
Toşkent

#zip(): töplamlarni juftlaş

zip() bir neçta töplamni "çaqmoq" kabi birlaştiradi: birinçi elementlarni bir juftga, ikkinçilarini boşqa juftga va hokazo:

fanlar = ["Matematika", "Fizika", "Ingliz tili"]
ballar = [92, 78, 85]

for fan, ball in zip(fanlar, ballar):
    print(f"{fan:<12} {ball}")

jadval = dict(zip(fanlar, ballar))
print(jadval)

Natija:

Matematika   92
Fizika       78
Ingliz tili  85
{'Matematika': 92, 'Fizika': 78, 'Ingliz tili': 85}

Agar töplamlar uzunligi har xil bölsa, zip() eng qisqasi tugaganda jimgina töxtaydi. Bu yaşirin xatolarga olib kelişi mumkin. Python 3.10 dan boşlab strict=True parametri bor — uzunliklar farq qilsa, xato beradi:

ismlar = ["Ali", "Vali", "Hasan"]
yoshlar = [20, 22]

print(list(zip(ismlar, yoshlar)))

try:
    print(list(zip(ismlar, yoshlar, strict=True)))
except ValueError as xato:
    print("Xato:", xato)

Natija:

[('Ali', 20), ('Vali', 22)]
Xato: zip() argument 2 is shorter than argument 1

try/except haqida xatolar bilan işlaş bobida batafsil gaplaşamiz.

#enumerate(): tartib raqami bilan

Element bilan birga uning raqami ham kerak bölsa, enumerate() işlating. start parametri sanoqni qaysi sondan boşlaşni belgilaydi:

goliblar = ["Şahzoda", "Islom", "Ravşan"]

for orin, ism in enumerate(goliblar, start=1):
    print(f"{orin}-örin: {ism}")

print(list(enumerate("abc")))

Natija:

1-örin: Şahzoda
2-örin: Islom
3-örin: Ravşan
[(0, 'a'), (1, 'b'), (2, 'c')]

range(len(goliblar)) va goliblar[i] yozişdan köra enumerate() ança toza va xatoga kamroq moyil.

#all() va any(): umumiy tekşiruv

• all(toʻplam) — barça elementlar rost bölsa True.
• any(toʻplam) — kamida bitta element rost bölsa True.

Ular odatda comprehension (aniqroği, generator ifodasi — qavssiz comprehension) bilan birga işlatiladi:

ballar = [72, 88, 65, 91]

print(all(b >= 60 for b in ballar))   # hamma ötdimi?
print(any(b >= 90 for b in ballar))   # a'loçi bormi?

parol = "Bahor2025"
yaxshi = (len(parol) >= 8
          and any(c.isdigit() for c in parol)
          and any(c.isupper() for c in parol))
print("Parol kuçli" if yaxshi else "Parol kuçsiz")

print(all([]), any([]))

Natija:

True
True
Parol kuçli
True False

Oxirgi qatorga eʼtibor bering: böş töplam uçun all() — True ("buzadigan element yöq"), any() — False ("rost element yöq").

#sorted(): tartiblaş va key parametri

sorted() istalgan töplamdan yangi tartiblangan röyxat qaytaradi, asl töplam özgarmaydi (röyxatning sort() metodidan farqi şu). reverse=True teskari tartib beradi, key esa nimaga qarab tartiblaşni aytadi:

shaharlar = ["Xiva", "Andijon", "Termiz", "Buxoro"]

print(sorted(shaharlar))
print(sorted(shaharlar, key=len))
print(sorted(shaharlar, key=len, reverse=True))

talabalar = [("Sevara", 88), ("Bekzod", 95), ("Umid", 88), ("Laylo", 70)]
# avval ball böyiça kamayiş, teng bölsa ism böyiça alifbo
print(sorted(talabalar, key=lambda t: (-t[1], t[0])))

Natija:

['Andijon', 'Buxoro', 'Termiz', 'Xiva']
['Xiva', 'Termiz', 'Buxoro', 'Andijon']
['Andijon', 'Termiz', 'Buxoro', 'Xiva']
[('Bekzod', 95), ('Sevara', 88), ('Umid', 88), ('Laylo', 70)]

key funksiyasi har bir element uçun bir marta çaqiriladi va tartiblaş ana şu natijalar böyiça böladi. Kortej qaytarsangiz, avval birinçi qiymat, teng bölsa ikkinçisi soliştiriladi.

#min() va max() ham key oladi

narxlar = {"bozor": 14500, "supermarket": 13900, "mahalla dökoni": 14200}

print(min(narxlar.values()))
arzon = min(narxlar, key=narxlar.get)
print(f"Eng arzon: {arzon} ({narxlar[arzon]:,} söm)")

sozlar = ["kitob", "daftar", "qalam", "çizğiç"]
print(max(sozlar, key=len))
print(max([], default="böş"))

Natija:

13900
Eng arzon: supermarket (13,900 söm)
daftar
böş

key=narxlar.get — luğat kalitlarini ularning qiymati böyiça soliştiriş usuli. default esa töplam böş bölganda xato örniga qaytariladigan qiymat.

#abs(), round() va sum()

Bu uçtasi kiçik, lekin har kuni kerak böladi:

print(abs(-15000))           # modul (işorasiz qiymat)
print(round(3.14159, 2))
print(round(1_234_567, -3))  # mingliklarga yaxlitlaş
print(round(2.5), round(3.5))

xarajatlar = [12000, 8500, 43000]
print(sum(xarajatlar))
print(sum(xarajatlar, 100000))   # boşlanğiç qiymat bilan

Natija:

15000
3.14
1235000
2 4
63500
163500

#Amaliyot: tranzaksiyalarni tahlil qiliş

Endi barça asboblarni birga işlatamiz. Bizda bir haftalik karta tranzaksiyalari bor: musbat summa — kirim, manfiy — çiqim (sömda).

from functools import reduce

kunlar = ["Du", "Se", "Ch", "Pa", "Ju", "Sh", "Ya"]
tranzaksiyalar = [
    ("Du", "maoş", 6_500_000),
    ("Du", "bozor", -230_000),
    ("Se", "taksi", -28_000),
    ("Ch", "kommunal", -410_000),
    ("Ch", "kafe", -95_000),
    ("Ju", "bozor", -185_000),
    ("Sh", "qarz qaytdi", 300_000),
    ("Ya", "kitob", -120_000),
    ("Ya", "kafe", -60_000),
]

summalar = [s for _, _, s in tranzaksiyalar]
kirim = sum(s for s in summalar if s > 0)
chiqim = sum(filter(lambda s: s < 0, summalar))
print(f"Kirim:  {kirim:>12,} söm")
print(f"Çiqim: {chiqim:>12,} söm")
print(f"Qoldiq: {kirim + chiqim:>12,} söm")

# Eng katta xarajat
eng_katta = min(tranzaksiyalar, key=lambda t: t[2])
print(f"\nEng katta xarajat: {eng_katta[1]} ({abs(eng_katta[2]):,} söm)")

# Toifalar böyiça xarajatlar
toifalar = {}
for _, toifa, summa in tranzaksiyalar:
    if summa < 0:
        toifalar[toifa] = toifalar.get(toifa, 0) + abs(summa)

print("\nToifalar (kamayiş tartibida):")
for orin, (toifa, summa) in enumerate(
        sorted(toifalar.items(), key=lambda x: x[1], reverse=True), start=1):
    print(f"  {orin}. {toifa:<9} {summa:>9,}")

# Kunlik xarajat
kunlik = [sum(-s for k, _, s in tranzaksiyalar if k == kun and s < 0) for kun in kunlar]
print("\nKunlik xarajat:")
for kun, x in zip(kunlar, kunlik, strict=True):
    print(f"  {kun}: {x:>8,}")

print("\nXarajatsiz kun bormi?", any(x == 0 for x in kunlik))
print("Har kuni 500 mingdan kam sarflandimi?", all(x < 500_000 for x in kunlik))

# reduce bilan hafta oxiridagi balans (boşlanğiç balans 1 mln)
balans = reduce(lambda b, t: b + t[2], tranzaksiyalar, 1_000_000)
print(f"Hafta oxiridagi balans: {balans:,} söm")

Natija:

Kirim:     6,800,000 söm
Çiqim:   -1,128,000 söm
Qoldiq:    5,672,000 söm

Eng katta xarajat: kommunal (410,000 söm)

Toifalar (kamayiş tartibida):
  1. bozor       415,000
  2. kommunal    410,000
  3. kafe        155,000
  4. kitob       120,000
  5. taksi        28,000

Kunlik xarajat:
  Du:  230,000
  Se:   28,000
  Ch:  505,000
  Pa:        0
  Ju:  185,000
  Sh:        0
  Ya:  180,000

Xarajatsiz kun bormi? True
Har kuni 500 mingdan kam sarflandimi? False
Hafta oxiridagi balans: 6,672,000 söm

Bu dasturda deyarli heç qanday murakkab tsikl yozmadik: sum(), filter(), min(), sorted(), enumerate(), zip(), any()/all() va reduce() işning asosiy qismini bajardi. Oxiridagi reduce() ga uçinçi argument — boşlanğiç qiymat berilganiga eʼtibor bering.

#Xulosa

• map() har bir elementga funksiya qöllaydi, filter() şart böyiça saralaydi; ikkalasi ham dangasa iterator qaytaradi.
• Comprehension köpinça map()/filter() + lambda dan öqişga qulayroq.
• functools.reduce() töplamni bitta qiymatga yiğadi; iloji bölsa sum(), max(), math.prod() ni afzal köring.
• zip() töplamlarni juftlaydi; uzunliklar teng bölişi şart bölsa strict=True qöşing.
• enumerate(..., start=1) tartib raqami bilan aylaniş uçun.
• all()/any() — umumiy tekşiruv; sorted(), min(), max() — key parametri bilan juda kuçli.
• abs(), round() (bankir yaxlitlaşi!) va sum() — kundalik hisob-kitob uçun.

#Maşqlar

1. ["3", "15", "8", "42"] satrlar röyxatini map() yordamida sonlarga aylantiring va ularning yiğindisini toping.

qatorlar = ["3", "15", "8", "42"]
print(sum(map(int, qatorlar)))

1. Ikki röyxat berilgan: mahsulot nomlari va narxlari. zip() yordamida narxi 20 000 sömdan qimmat mahsulotlarni çiqaring.

nomlar = ["non", "pişloq", "sut", "qahva"]
narxlar = [4000, 65000, 12000, 48000]

for nom, narx in zip(nomlar, narxlar, strict=True):
    if narx > 20000:
        print(f"{nom}: {narx:,} söm")

1. Sözlar röyxatini avval uzunligi böyiça, uzunligi teng bölsa alifbo böyiça tartiblang.

sozlar = ["uzum", "olma", "anor", "nok", "şaftoli", "gilos"]
print(sorted(sozlar, key=lambda s: (len(s), s)))

1. Talabalar luğatidan eng yuqori ball olgan talabani max() va key yordamida toping, keyin all() bilan hamma 50 dan yuqori olganini tekşiring.

ballar = {"Nigora": 84, "Temur": 97, "Zarina": 76, "Akmal": 58}

eng_yaxshi = max(ballar, key=ballar.get)
print(f"Eng yaxşi: {eng_yaxshi} ({ballar[eng_yaxshi]})")
print("Hamma 50 dan yuqori:", all(b > 50 for b in ballar.values()))

1. reduce() yordamida raqamlar röyxatidan son yasang: [2, 0, 2, 5] → 2025.

from functools import reduce

raqamlar = [2, 0, 2, 5]
son = reduce(lambda acc, r: acc * 10 + r, raqamlar)
print(son)