7.12-dars: map, filter, reduce
7-QISM — FUNKSIYALAR · 12-dars
1. Kirish va motivatsiya
Uch klassik funksional vosita:
map(f, r) # har elementga f ni qo'llash
filter(p, r) # shartga mos elementlar
reduce(f, r) # ketma-ketlikni bitta qiymatgalist(map(str.upper, ["a", "b"])) # ['A', 'B']
list(filter(str.isdigit, "a1b2")) # ['1', '2']
reduce(operator.add, [1, 2, 3, 4]) # 10Lekin Pythonda ular ko'pincha generatorlar bilan almashtiriladi:
list(map(lambda x: x * 2, r)) # ⚠️
[x * 2 for x in r] # ✅ tezroq va o'qilishi yaxshi
list(filter(lambda x: x > 0, r)) # ⚠️
[x for x in r if x > 0] # ✅Va reduce Python 3 da ichki nomlardan olib tashlangan:
reduce(...) # ❌ NameError (Python 3)
from functools import reduce # ✅Guido buni ataylab qilgan. Nega?
Bu darsda:
map,filter— sintaksis, dangasa hisoblash- Qachon generator yaxshiroq (deyarli har doim)
reduceva nega u tavsiya etilmaydi- Muqobillar:
sum,math.prod,any,all,itertools.accumulate - Tezlik solishtirilishi
- Funksional dasturlash Pythonda
2. Nazariya — chuqur tushuntirish
2.1. map
map(funksiya, iterable, ...)Dangasa — iterator qaytaradi (Python 3):
m = map(str.upper, ["a", "b"])
type(m) # <class 'map'>
list(m) # ['A', 'B']
list(m) # [] ⚠️ tugaganBir necha iterable:
list(map(pow, [2, 3, 4], [3, 2, 1])) # [8, 9, 4]
list(map(max, [1, 5], [3, 2])) # [3, 5] Eng qisqasida to'xtaydi (zip kabi):
list(map(add, [1, 2, 3], [10, 20])) # [11, 22] — uchinchi tashlanadiitertools.zip_longest bilan:
from itertools import zip_longest
[a + b for a, b in zip_longest([1, 2, 3], [10, 20], fillvalue=0)]map(None, ...) — Python 2 da zip edi, 3 da yo'q:
list(map(None, [1, 2])) # ❌ TypeError (Python 3)
list(zip([1, 2], [3, 4])) # ✅2.2. filter
filter(funksiya, iterable)list(filter(str.isdigit, "a1b2")) # ['1', '2']
list(filter(lambda x: x > 0, [-1, 2])) # [2] filter(None, r) — rostlik bo'yicha:
list(filter(None, [0, 1, "", "a", [], [1], None]))
# [1, 'a', [1]]None — "elementning o'zini bool sifatida ishlat" degani. Bu — filter ning eng foydali shakli.
itertools.filterfalse — teskarisi:
from itertools import filterfalse
list(filterfalse(lambda x: x > 0, [-1, 2, -3])) # [-1, -3]2.3. Generator vs map/filter
PEP 202 (list comprehension) va PEP 289 (generator expression) dan keyin map/filter ko'pincha ortiqcha.
| Vazifa | map/filter |
Generator |
|---|---|---|
| Transformatsiya | map(lambda x: x*2, r) |
(x*2 for x in r) |
| Filtrlash | filter(lambda x: x>0, r) |
(x for x in r if x>0) |
| Ikkalasi | map(f, filter(p, r)) |
(f(x) for x in r if p(x)) |
| Tayyor funksiya | map(str.upper, r) |
(s.upper() for s in r) |
| Bir necha iterable | map(f, a, b) |
(f(x,y) for x,y in zip(a,b)) |
| Rostlik filtri | filter(None, r) |
(x for x in r if x) |
Qoida:
lambdayozish kerak → generator- Tayyor funksiya bor →
map/filterham yaxshi filter(None, r)→ idiomatik
Tezlik:
[x * 2 for x in r] # ~1.0x ⭐
list(map(lambda x: x * 2, r)) # ~1.4x
list(map(operator.mul, r, repeat(2))) # ~1.1x
[s.upper() for s in r] # ~1.1x
list(map(str.upper, r)) # ~1.0x ⭐Sabab: lambda — Python freym yaratadi (qimmat). Tayyor C funksiyasi — yo'q.
Xotira:
map(f, r) # ~50 bayt — dangasa
[f(x) for x in r] # O(n)
(f(x) for x in r) # ~200 bayt — dangasamap va generator ifodasi ikkalasi ham dangasa.
2.4. reduce
from functools import reduce
reduce(funksiya, iterable[, boshlangich])Qanday ishlaydi:
reduce(f, [a, b, c, d])
# ≡ f(f(f(a, b), c), d)reduce(operator.add, [1, 2, 3, 4]) # 10
reduce(operator.add, [1, 2, 3, 4], 100) # 110
reduce(operator.mul, [1, 2, 3, 4]) # 24Bo'sh ketma-ketlik:
reduce(add, []) # ❌ TypeError
reduce(add, [], 0) # ✅ 0Python 3 da ichki nomlardan olib tashlangan.
Guido van Rossum (2005, "The fate of reduce() in Python 3000"):
"So now
reduce(). This is actually the one I've always hated most, because, apart from a few examples involving+or*, almost every time I see areduce()call with a non-trivial function argument, I need to grab pen and paper to diagram what's actually being fed into that function before I understand what thereduce()is supposed to do."
Muqobillar:
reduce |
Muqobil |
|---|---|
reduce(add, r) |
sum(r) |
reduce(mul, r) |
math.prod(r) (3.8+) |
reduce(max, r) |
max(r) |
reduce(or_, toplamlar) |
set().union(*toplamlar) |
reduce(and_, r) |
all(r) (bool uchun) |
reduce(lambda a,b: a+[b], r, []) |
list(r) yoki generator |
reduce(operator.concat, satrlar) |
"".join(satrlar) |
| Oraliq natijalar | itertools.accumulate |
Qachon reduce haqiqatan foydali:
# Maxsus birlashtirish amali
reduce(chuqur_birlashtir, lugatlar)
# Matritsalar ko'paytmasi
reduce(matritsa_kopaytir, matritsalar)
# Funksiyalar kompozitsiyasi
reduce(lambda f, g: lambda x: f(g(x)), funksiyalar)
# Assotsiativ maxsus amal
reduce(gcd, sonlar)Ya'ni: tayyor muqobil bo'lmagan assotsiativ amal.
2.5. itertools.accumulate
reduce ning oraliq natijalar beruvchi versiyasi:
from itertools import accumulate
list(accumulate([1, 2, 3, 4])) # [1, 3, 6, 10]
list(accumulate([1, 2, 3, 4], operator.mul)) # [1, 2, 6, 24]
list(accumulate([1, 2, 3], initial=100)) # [100, 101, 103, 106]reduce vs accumulate:
reduce(add, [1, 2, 3, 4]) # 10 — faqat oxirgi
accumulate([1, 2, 3, 4]) # 1,3,6,10 — hammasi (dangasa)
list(accumulate(r))[-1] # reduce bilan bir xilAmaliy:
# Yugurib boruvchi maksimum
list(accumulate(narxlar, max))
# Kumulyativ yig'indi
list(accumulate(sotuvlar))
# Balans tarixi
list(accumulate(tranzaksiyalar, initial=boshlangich_balans))2.6. Boshqa agregatlar
sum(r, start=0) # yig'indi
math.prod(r, start=1) # ko'paytma (3.8+)
min(r), max(r) # ekstremum
any(r), all(r) # mantiqiy
len(r) # soni
sorted(r) # saralash
statistics.mean/median/mode(r) # statistika Ular reduce dan tezroq — C da yozilgan:
sum(range(1_000_000)) # ~8 ms
reduce(operator.add, range(1_000_000)) # ~45 ms sum satrlar uchun sekin:
sum(satrlar, "") # ❌ O(n²)
"".join(satrlar) # ✅ O(n)Python buni ataylab taqiqlaydi:
sum(["a", "b"], "")
# TypeError: sum() can't sum strings [use ''.join(seq) instead]any/all — erta to'xtash:
any(f(x) for x in katta) # birinchi True da to'xtaydi ⭐
all(f(x) for x in katta) # birinchi False da2.7. Funksional dasturlash Pythonda
Python — ko'p paradigmali til. Funksional uslub qo'llab-quvvatlanadi, lekin asosiy emas.
Nima bor:
map, filter, reduce
functools (partial, reduce, wraps, lru_cache, singledispatch)
itertools (accumulate, chain, groupby, ...)
operator (add, itemgetter, ...)
lambda, yopilmalar
generatorlarNima yo'q:
Quyruqli rekursiya optimallashtirishi (tail call)
O'zgarmas ma'lumot tuzilmalari (frozenset, tuple dan tashqari)
Naqsh moslashtirish (match/case — cheklangan)
Kompozitsiya operatori (|>, >>)
Curry (partial — qisman)
Monadalar, funktorlarPythonning pozitsiyasi:
Guido: "Python is not a functional language" — lekin funksional g'oyalar (birinchi darajali funksiyalar, generatorlar, map/filter) foydali.
Amaliy uslub:
# ✅ Pythonik funksional
natija = [f(x) for x in r if p(x)]
jami = sum(x.summa for x in buyurtmalar)
eng_katta = max(r, key=attrgetter("summa"))
# ⚠️ "Haddan tashqari funksional"
natija = list(map(f, filter(p, r)))
jami = reduce(add, map(attrgetter("summa"), buyurtmalar))Ikkinchisi ishlaydi, lekin Pythonik emas.
3. Tez ma'lumotnoma
map
map(f, r) dangasa iterator
map(f, a, b) bir necha iterable (eng qisqasida to'xtaydi)
list(map(...)) ro'yxatga
⭐ map(str.upper, r) tayyor funksiya — yaxshi
⚠️ map(lambda x: ..., r) → generator yaxshiroqfilter
filter(p, r) shartga mos
filter(None, r) ⭐ rostlik bo'yicha (idiomatik)
itertools.filterfalse teskarisi
⚠️ filter(lambda x: ..., r) → generator yaxshiroqreduce
from functools import reduce ⚠️ Python 3 da import kerak
reduce(f, r) f(f(f(a,b),c),d)
reduce(f, r, boshlangich)
reduce(f, []) ❌ TypeError (boshlangich siz)
⭐ Muqobillar:
reduce(add, r) → sum(r)
reduce(mul, r) → math.prod(r)
reduce(max, r) → max(r)
reduce(or_, toplam) → set().union(*toplam)
concat satrlar → "".join(r)
oraliq natijalar → itertools.accumulateQachon nima
lambda kerak → generator ifodasi
Tayyor funksiya → map/filter
Bir necha iterable → map(f, a, b)
Rostlik filtri → filter(None, r)
Yig'indi/ko'paytma → sum / math.prod
Oraliq natijalar → accumulate
Maxsus assotsiativ amal → reduceTezlik
[f(x) for x in r] ⭐ eng tez (lambda bo'lsa)
map(C_funksiya, r) ⭐ eng tez (tayyor funksiya bo'lsa)
sum(r) ⭐ reduce(add, r) dan ~5x tez4. Batafsil misollar
Misol 1 — map va filter
"""map va filter — barcha shakllar."""
import operator
import sys
from itertools import filterfalse, zip_longest, repeat
print("=== 1. map asoslari ===")
MALUMOT = [1, 2, 3, 4, 5]
SOZLAR = ["olma", "anor", "behi"]
NAMUNALAR = [
("map(str, r)", list(map(str, MALUMOT))),
("map(str.upper, sozlar)", list(map(str.upper, SOZLAR))),
("map(len, sozlar)", list(map(len, SOZLAR))),
("map(abs, [-1, 2, -3])", list(map(abs, [-1, 2, -3]))),
("map(lambda x: x**2, r)", list(map(lambda x: x ** 2, MALUMOT))),
]
for kod, natija in NAMUNALAR:
print(f" {kod:<30} → {natija}")
print(f"\n ⭐ Dangasa (Python 3):")
m = map(str, MALUMOT)
print(f" type(map(...)) = {type(m).__name__}")
print(f" sys.getsizeof = {sys.getsizeof(m)} bayt")
print(f" list(m) = {list(m)}")
print(f" list(m) = {list(m)} ⚠️ tugagan")
print("\n=== 2. Bir necha iterable ===")
A, B, C = [1, 2, 3], [10, 20, 30], [100, 200, 300]
KOP = [
("map(add, a, b)", list(map(operator.add, A, B))),
("map(pow, a, b)", list(map(pow, [2, 3, 4], [3, 2, 1]))),
("map(max, a, b)", list(map(max, [1, 5, 3], [3, 2, 9]))),
("map(lambda x,y,z: x+y+z, a,b,c)",
list(map(lambda x, y, z: x + y + z, A, B, C))),
]
for kod, natija in KOP:
print(f" {kod:<36} → {natija}")
print(f"\n ⚠️ Eng qisqasida to'xtaydi:")
print(f" map(add, [1,2,3], [10,20]) → "
f"{list(map(operator.add, [1, 2, 3], [10, 20]))}")
print(f" ⚠️ Uchinchi element tashlandi\n")
print(f" ✅ zip_longest bilan:")
natija = [a + b for a, b in zip_longest([1, 2, 3], [10, 20], fillvalue=0)]
print(f" zip_longest(..., fillvalue=0) → {natija}")
print(f"\n ⚠️ map(None, ...) — Python 2 da zip edi:")
try:
list(map(None, [1, 2]))
except TypeError as e:
print(f" map(None, [1,2]) → ❌ {e}")
print(f" list(zip([1,2],[3,4])) → {list(zip([1, 2], [3, 4]))} ✅")
print("\n=== 3. filter asoslari ===")
ARALASH = [0, 1, "", "a", [], [1], None, False, True, 0.0, "0"]
FILTRLAR = [
("filter(None, r)", list(filter(None, ARALASH))),
("filter(bool, r)", list(filter(bool, ARALASH))),
("filter(lambda x: x>2, [1..5])",
list(filter(lambda x: x > 2, MALUMOT))),
("filter(str.isdigit, 'a1b2')", list(filter(str.isdigit, "a1b2"))),
("filterfalse(None, r)", list(filterfalse(None, ARALASH))),
]
print(f" Aralash: {ARALASH}\n")
for kod, natija in FILTRLAR:
print(f" {kod:<32} → {natija}")
print(f"""
⭐ filter(None, r) — eng foydali shakl:
"elementning o'zini bool sifatida ishlat"
Bo'sh qiymatlarni olib tashlaydi:
0, "", [], {{}}, None, False, 0.0
""")
print("\n=== 4. ⭐ map/filter vs generator ===")
import timeit
SOZLASH = """
import operator
from itertools import repeat
r = list(range(1000))
sozlar = ['salom'] * 1000
"""
SINOVLAR = [
("Transformatsiya (lambda)", [
("[x*2 for x in r]", "[x*2 for x in r]"),
("list(map(lambda x: x*2, r))", "list(map(lambda x: x*2, r))"),
("list(map(operator.mul, r, repeat(2)))",
"list(map(operator.mul, r, repeat(2)))"),
]),
("Transformatsiya (tayyor funksiya)", [
("[s.upper() for s in sozlar]", "[s.upper() for s in sozlar]"),
("list(map(str.upper, sozlar))", "list(map(str.upper, sozlar))"),
]),
("Filtrlash", [
("[x for x in r if x % 2]", "[x for x in r if x % 2]"),
("list(filter(lambda x: x%2, r))", "list(filter(lambda x: x%2, r))"),
]),
("Rostlik filtri", [
("[x for x in r if x]", "[x for x in r if x]"),
("list(filter(None, r))", "list(filter(None, r))"),
]),
("Ikkalasi", [
("[x*2 for x in r if x%2]", "[x*2 for x in r if x%2]"),
("list(map(lambda x: x*2, filter(lambda x: x%2, r)))",
"list(map(lambda x: x*2, filter(lambda x: x%2, r)))"),
]),
]
for guruh, sinovlar in SINOVLAR:
print(f"\n {guruh}:\n")
natijalar = []
for nom, kod in sinovlar:
vaqt = timeit.timeit(kod, setup=SOZLASH, number=5000)
natijalar.append((nom, vaqt))
eng_tez = min(v for _, v in natijalar)
for nom, vaqt in natijalar:
belgi = "⭐" if vaqt == eng_tez else " "
print(f" {belgi} {nom:<46} {vaqt:.3f} s {vaqt / eng_tez:>5.2f}x")
print("""
⭐ Xulosa:
lambda kerak → generator TEZROQ
Tayyor C funksiyasi → map biroz tezroq
filter(None, r) → map/filter tezroq
""")
print("\n=== 5. Xotira ===")
N = 1_000_000
r_royxat = [x * 2 for x in range(N)]
r_gen = (x * 2 for x in range(N))
r_map = map(lambda x: x * 2, range(N))
r_filter = filter(None, range(N))
print(f" {N:,} element:\n")
print(f" {'Usul':<28} {'Xotira'}")
print(" " + "─" * 44)
for nom, o in [
("[x*2 for x in r]", r_royxat),
("(x*2 for x in r)", r_gen),
("map(f, r)", r_map),
("filter(None, r)", r_filter),
]:
print(f" {nom:<28} {sys.getsizeof(o):>10,} bayt")
del r_royxat
print(f"\n ⭐ map, filter va generator ifodasi — hammasi DANGASA")
print("\n=== 6. Zanjirlash ===")
MALUMOT = [" 42 ", "", "abc", " 17", "0", " ", "99"]
print(f" Ma'lumot: {MALUMOT}\n")
print(f" ⚠️ map/filter zanjiri:")
natija1 = list(map(int, filter(str.isdigit, map(str.strip, MALUMOT))))
print(f" list(map(int, filter(str.isdigit, map(str.strip, r))))")
print(f" → {natija1}")
print(f" ⚠️ Ichkaridan tashqariga o'qish kerak")
print(f"\n ✅ Generator:")
natija2 = [int(q) for x in MALUMOT if (q := x.strip()).isdigit()]
print(f" [int(q) for x in r if (q := x.strip()).isdigit()]")
print(f" → {natija2}")
print(f" ✅ Chapdan o'ngga o'qiladi")
print(f"\n ✅ Bosqichma-bosqich generator (eng aniq):")
tozalangan = (x.strip() for x in MALUMOT)
sonlar = (q for q in tozalangan if q.isdigit())
natija3 = [int(q) for q in sonlar]
print(f" tozalangan = (x.strip() for x in r)")
print(f" sonlar = (q for q in tozalangan if q.isdigit())")
print(f" natija = [int(q) for q in sonlar]")
print(f" → {natija3}")
print(f"\n Uchalasi bir xil: {natija1 == natija2 == natija3}")
print("\n=== 7. Qachon map/filter yaxshiroq ===")
HOLATLAR = [
("map(str.upper, r)", "✅", "tayyor metod — qisqa"),
("map(int, satrlar)", "✅", "tayyor funksiya"),
("map(f, a, b)", "✅", "bir necha iterable"),
("filter(None, r)", "✅", "idiomatik"),
("map(lambda x: x*2, r)", "❌", "generator tezroq va o'qiladi"),
("filter(lambda x: x>0, r)", "❌", "generator"),
("map(f, filter(p, r))", "❌", "ichkaridan o'qish kerak"),
("list(map(...))", "⚠️", "generator ifodasi yetarli bo'lsa"),
]
print(f" {'Ifoda':<32} {'':<4} Izoh")
print(" " + "─" * 68)
for ifoda, belgi, izoh in HOLATLAR:
print(f" {ifoda:<32} {belgi:<4} {izoh}")Natijaning muhim qismi:
=== 3. filter asoslari ===
Aralash: [0, 1, '', 'a', [], [1], None, False, True, 0.0, '0']
filter(None, r) → [1, 'a', [1], True, '0']
filter(bool, r) → [1, 'a', [1], True, '0']
=== 4. ⭐ map/filter vs generator ===
Transformatsiya (lambda):
⭐ [x*2 for x in r] 0.142 s 1.00x
list(map(lambda x: x*2, r)) 0.198 s 1.39x
list(map(operator.mul, r, repeat(2))) 0.156 s 1.10x
Transformatsiya (tayyor funksiya):
[s.upper() for s in sozlar] 0.184 s 1.12x
⭐ list(map(str.upper, sozlar)) 0.164 s 1.00x
Rostlik filtri:
[x for x in r if x] 0.098 s 1.31x
⭐ list(filter(None, r)) 0.075 s 1.00xNima ko'rsatdi: 2.1, 2.2, 2.3-bo'limlar.
Misol 2 — reduce va muqobillari
"""reduce — qachon kerak, qachon yo'q."""
import math
import operator
import timeit
from functools import reduce
from itertools import accumulate
print("=== 1. reduce qanday ishlaydi ===")
MALUMOT = [1, 2, 3, 4, 5]
def kuzatuvchi_add(a, b):
print(f" add({a}, {b}) = {a + b}")
return a + b
print(f" reduce(add, {MALUMOT}):\n")
natija = reduce(kuzatuvchi_add, MALUMOT)
print(f" → {natija}")
print(f"\n reduce(add, {MALUMOT}, 100):\n")
natija = reduce(kuzatuvchi_add, MALUMOT, 100)
print(f" → {natija}")
print(f"""
⭐ reduce(f, [a,b,c,d]) ≡ f(f(f(a,b),c),d)
reduce(f, [a,b,c], x) ≡ f(f(f(x,a),b),c)
""")
print(f" Bo'sh ketma-ketlik:")
try:
reduce(operator.add, [])
except TypeError as e:
print(f" reduce(add, []) → ❌ {e}")
print(f" reduce(add, [], 0) → {reduce(operator.add, [], 0)} ✅")
print("\n=== 2. ⭐ Muqobillar ===")
R = list(range(1, 11))
SATRLAR = ["a", "b", "c"]
TOPLAMLAR = [{1, 2}, {2, 3}, {3, 4}]
MUQOBILLAR = [
("Yig'indi",
"reduce(add, r)", reduce(operator.add, R),
"sum(r)", sum(R)),
("Ko'paytma",
"reduce(mul, r)", reduce(operator.mul, R),
"math.prod(r)", math.prod(R)),
("Maksimum",
"reduce(max, r)", reduce(max, R),
"max(r)", max(R)),
("Minimum",
"reduce(min, r)", reduce(min, R),
"min(r)", min(R)),
("Satrlarni birlashtirish",
"reduce(concat, s)", reduce(operator.concat, SATRLAR),
'"".join(s)', "".join(SATRLAR)),
("To'plamlar birlashmasi",
"reduce(or_, t)", reduce(operator.or_, TOPLAMLAR),
"set().union(*t)", set().union(*TOPLAMLAR)),
("To'plamlar kesishmasi",
"reduce(and_, t)", reduce(operator.and_, TOPLAMLAR),
"set.intersection(*t)", set.intersection(*TOPLAMLAR)),
("Barchasi rostmi",
"reduce(and_, b)", reduce(operator.and_, [True, True, False]),
"all(b)", all([True, True, False])),
]
print(f" {'Vazifa':<26} {'reduce':<24} {'Muqobil':<24} {'Teng'}")
print(" " + "─" * 84)
for vazifa, r_kod, r_natija, m_kod, m_natija in MUQOBILLAR:
teng = "✅" if r_natija == m_natija else "❌"
print(f" {vazifa:<26} {r_kod:<24} {m_kod:<24} {teng}")
print(f"\n ⚠️ sum() satrlar uchun taqiqlangan:")
try:
sum(["a", "b"], "")
except TypeError as e:
print(f" sum(['a','b'], '') → ❌ {e}")
print(f" ⭐ Python o'zi to'g'ri yechimni aytadi")
print("\n=== 3. Tezlik ===")
SOZLASH = """
import math, operator
from functools import reduce
r = list(range(1, 100001))
"""
SINOVLAR = [
("sum(r)", "sum(r)"),
("reduce(add, r)", "reduce(operator.add, r)"),
("reduce(lambda a,b: a+b, r)", "reduce(lambda a, b: a + b, r)"),
("math.prod(r[:20])", "math.prod(r[:20])"),
("reduce(mul, r[:20])", "reduce(operator.mul, r[:20])"),
("max(r)", "max(r)"),
("reduce(max, r)", "reduce(max, r)"),
]
natijalar = []
for nom, kod in SINOVLAR:
n = 100 if "r)" in kod and "20" not in kod else 10000
vaqt = timeit.timeit(kod, setup=SOZLASH, number=n) / n * 1_000_000
natijalar.append((nom, vaqt))
print(f" Bir chaqiruv vaqti (µs):\n")
print(f" {'Ifoda':<32} {'Vaqt':>12}")
print(" " + "─" * 48)
for nom, vaqt in natijalar:
print(f" {nom:<32} {vaqt:>9.1f} µs")
print("""
⭐ sum, max, math.prod — C da yozilgan, reduce dan ~5x tez.
reduce har element uchun Python funksiyasini chaqiradi.
""")
print("\n=== 4. itertools.accumulate ===")
MALUMOT = [3, 1, 4, 1, 5, 9, 2, 6]
print(f" Ma'lumot: {MALUMOT}\n")
AKKUMULYATSIYALAR = [
("Yig'indilar", list(accumulate(MALUMOT))),
("Ko'paytmalar", list(accumulate(MALUMOT, operator.mul))),
("Maksimumlar", list(accumulate(MALUMOT, max))),
("Minimumlar", list(accumulate(MALUMOT, min))),
("Boshlang'ich=100", list(accumulate(MALUMOT, initial=100))),
]
for nom, natija in AKKUMULYATSIYALAR:
print(f" {nom:<20} {natija}")
print(f"\n ⭐ reduce vs accumulate:")
print(f" reduce(add, r) = {reduce(operator.add, MALUMOT)}")
print(f" list(accumulate(r))[-1] = {list(accumulate(MALUMOT))[-1]}")
print(f" accumulate — DANGASA va ORALIQ natijalarni beradi")
print(f"\n Amaliy misollar:")
NARXLAR = [100, 105, 98, 110, 107, 115]
print(f"\n Narxlar: {NARXLAR}")
print(f" Yugurib boruvchi maksimum: {list(accumulate(NARXLAR, max))}")
print(f" Kumulyativ o'zgarish: "
f"{list(accumulate([b - a for a, b in zip(NARXLAR, NARXLAR[1:])]))}")
TRANZAKSIYALAR = [500, -200, 1000, -150, -300]
print(f"\n Tranzaksiyalar: {TRANZAKSIYALAR}")
print(f" Balans tarixi: "
f"{list(accumulate(TRANZAKSIYALAR, initial=1000))}")
print(f"\n Faktoriallar: {list(accumulate(range(1, 8), operator.mul))}")
print("\n=== 5. Qachon reduce KERAK ===")
def chuqur_birlashtir(a: dict, b: dict) -> dict:
"""Ichma-ich lug'atlarni rekursiv birlashtiradi."""
natija = dict(a)
for k, v in b.items():
if k in natija and isinstance(natija[k], dict) and isinstance(v, dict):
natija[k] = chuqur_birlashtir(natija[k], v)
else:
natija[k] = v
return natija
LUGATLAR = [
{"baza": {"host": "localhost", "port": 5432}, "debug": False},
{"baza": {"host": "db.uz"}, "log": "INFO"},
{"baza": {"ssl": True}, "debug": True},
]
print(f" 1. Maxsus birlashtirish amali:\n")
natija = reduce(chuqur_birlashtir, LUGATLAR)
print(f" reduce(chuqur_birlashtir, lugatlar)")
for k, v in natija.items():
print(f" {k}: {v}")
print(f"\n 2. Funksiyalar kompozitsiyasi:\n")
def ikkilash(x): return x * 2
def qoshish(x): return x + 1
def kvadrat(x): return x ** 2
kompozitsiya = reduce(
lambda f, g: lambda x: f(g(x)),
[kvadrat, ikkilash, qoshish],
)
print(f" reduce(lambda f,g: lambda x: f(g(x)), [kvadrat, ikkilash, qoshish])")
print(f" kompozitsiya(3) = {kompozitsiya(3)} ← ((3+1)*2)²")
print(f"\n 3. EKUB (assotsiativ amal):\n")
SONLAR = [48, 64, 32, 96]
print(f" reduce(math.gcd, {SONLAR}) = {reduce(math.gcd, SONLAR)}")
print(f" reduce(math.lcm, {SONLAR}) = {reduce(math.lcm, SONLAR)}")
print(f"\n 4. Matritsalar ko'paytmasi:\n")
def matritsa_kopaytir(a, b):
return [[sum(a[i][k] * b[k][j] for k in range(len(b)))
for j in range(len(b[0]))]
for i in range(len(a))]
MATRITSALAR = [
[[1, 0], [0, 1]],
[[2, 1], [1, 2]],
[[1, 1], [0, 1]],
]
natija = reduce(matritsa_kopaytir, MATRITSALAR)
print(f" reduce(matritsa_kopaytir, matritsalar)")
for qator in natija:
print(f" {qator}")
print("""
⭐ reduce KERAK bo'lgan holatlar:
• Tayyor muqobil YO'Q
• Amal ASSOTSIATIV (a∘(b∘c) == (a∘b)∘c)
• Natija bitta qiymat (oraliq kerak emas)
""")
print("\n=== 6. ⚠️ reduce ni suiiste'mol ===")
R = [1, 2, 3, 4, 5]
SUIISTEMOL = [
("Ro'yxat qurish",
"reduce(lambda a,b: a+[b], r, [])",
reduce(lambda a, b: a + [b], R, []),
"list(r)",
list(R)),
("Filtrlash",
"reduce(lambda a,b: a+[b] if b>2 else a, r, [])",
reduce(lambda a, b: a + [b] if b > 2 else a, R, []),
"[x for x in r if x>2]",
[x for x in R if x > 2]),
("Transformatsiya",
"reduce(lambda a,b: a+[b*2], r, [])",
reduce(lambda a, b: a + [b * 2], R, []),
"[x*2 for x in r]",
[x * 2 for x in R]),
("Sanash",
"reduce(lambda a,b: a+1, r, 0)",
reduce(lambda a, b: a + 1, R, 0),
"len(r)",
len(R)),
]
print(f" {'Vazifa':<18} {'reduce bilan (❌)':<44} {'To`g`ri (✅)'}")
print(" " + "─" * 88)
for vazifa, r_kod, r_natija, m_kod, m_natija in SUIISTEMOL:
teng = "✅" if r_natija == m_natija else "❌"
print(f" {vazifa:<18} {r_kod:<44} {m_kod}")
print(f"\n ⚠️ reduce bilan ro'yxat qurish — O(n²)!")
SOZLASH2 = "from functools import reduce\nr = list(range(2000))"
for nom, kod in [
("reduce(lambda a,b: a+[b], r, [])", "reduce(lambda a, b: a + [b], r, [])"),
("list(r)", "list(r)"),
]:
vaqt = timeit.timeit(kod, setup=SOZLASH2, number=20)
print(f" {nom:<40} {vaqt:.4f} s")
print("""
⭐ Guido (2005):
"Almost every time I see a reduce() call with a non-trivial
function argument, I need to grab pen and paper to diagram
what's actually being fed into that function before I
understand what the reduce() is supposed to do."
Shuning uchun Python 3 da reduce ICHKI NOMLARDAN olib tashlangan.
""")Natijaning muhim qismi:
=== 1. reduce qanday ishlaydi ===
reduce(add, [1, 2, 3, 4, 5]):
add(1, 2) = 3
add(3, 3) = 6
add(6, 4) = 10
add(10, 5) = 15
→ 15
=== 3. Tezlik ===
Bir chaqiruv vaqti (µs):
Ifoda Vaqt
────────────────────────────────────────────────
sum(r) 842.1 µs
reduce(add, r) 4218.4 µs
reduce(lambda a,b: a+b, r) 6841.2 µs
max(r) 1912.3 µs
reduce(max, r) 8124.7 µs
=== 6. ⚠️ reduce ni suiiste'mol ===
⚠️ reduce bilan ro'yxat qurish — O(n²)!
reduce(lambda a,b: a+[b], r, []) 1.8421 s
list(r) 0.0004 sNima ko'rsatdi: 2.4, 2.5, 2.6-bo'limlar.
Misol 3 — Agregatlar va itertools
"""Tayyor agregatlar va itertools vositalari."""
import math
import operator
import statistics
from itertools import (accumulate, chain, groupby, starmap,
compress, dropwhile, takewhile, tee)
from functools import reduce
print("=== 1. Ichki agregatlar ===")
MALUMOT = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]
AGREGATLAR = [
("len(r)", len(MALUMOT)),
("sum(r)", sum(MALUMOT)),
("sum(r, 100)", sum(MALUMOT, 100)),
("min(r)", min(MALUMOT)),
("max(r)", max(MALUMOT)),
("math.prod(r)", math.prod(MALUMOT)),
("any(r)", any(MALUMOT)),
("all(r)", all(MALUMOT)),
("sorted(r)", sorted(MALUMOT)),
("statistics.mean(r)", round(statistics.mean(MALUMOT), 2)),
("statistics.median(r)", statistics.median(MALUMOT)),
("statistics.mode(r)", statistics.mode(MALUMOT)),
("statistics.stdev(r)", round(statistics.stdev(MALUMOT), 2)),
]
print(f" Ma'lumot: {MALUMOT}\n")
for kod, natija in AGREGATLAR:
print(f" {kod:<26} → {natija}")
print("\n=== 2. any / all — erta to'xtash ===")
chaqiruvlar = [0]
def qimmat_shart(x):
chaqiruvlar[0] += 1
return x > 5
KATTA = list(range(100))
chaqiruvlar[0] = 0
natija = any(qimmat_shart(x) for x in KATTA)
any_gen = chaqiruvlar[0]
chaqiruvlar[0] = 0
natija = any([qimmat_shart(x) for x in KATTA])
any_royxat = chaqiruvlar[0]
chaqiruvlar[0] = 0
natija = all(qimmat_shart(x) for x in KATTA)
all_gen = chaqiruvlar[0]
print(f" {len(KATTA)} element, 7-chisida shart bajariladi:\n")
print(f" any(f(x) for x in r) → {any_gen:>4} chaqiruv ⭐")
print(f" any([f(x) for x in r]) → {any_royxat:>4} chaqiruv ❌")
print(f" all(f(x) for x in r) → {all_gen:>4} chaqiruv ⭐ (birinchi False)")
print(f"""
⭐ any/all generator bilan ERTA TO'XTAYDI.
Ro'yxat bilan HAMMASI hisoblanadi.
""")
print(f" Bo'sh ketma-ketlik:")
print(f" any([]) = {any([])} (hech biri rost emas)")
print(f" all([]) = {all([])} (hech biri yolg'on emas — vacuous truth)")
print("\n=== 3. itertools.accumulate ===")
SOTUVLAR = [1200, 850, 2100, 450, 1800, 950]
print(f" Sotuvlar: {SOTUVLAR}\n")
AKKUMULYATSIYA = [
("Kumulyativ yig'indi", list(accumulate(SOTUVLAR))),
("Yugurib boruvchi max", list(accumulate(SOTUVLAR, max))),
("Yugurib boruvchi min", list(accumulate(SOTUVLAR, min))),
]
for nom, natija in AKKUMULYATSIYA:
print(f" {nom:<24} {natija}")
print(f"\n Grafik (kumulyativ):")
kumulyativ = list(accumulate(SOTUVLAR))
eng_katta = max(kumulyativ)
for i, (sotuv, jami) in enumerate(zip(SOTUVLAR, kumulyativ), 1):
chiziq = "█" * int(jami / eng_katta * 34)
print(f" {i}. {sotuv:>5,} → {jami:>6,} {chiziq}")
print("\n=== 4. Boshqa itertools vositalari ===")
MALUMOT = [1, 2, 3, 4, 5, 6, 7, 8]
VOSITALAR = [
("takewhile(x<5, r)",
list(takewhile(lambda x: x < 5, MALUMOT)),
"shart buzilguncha"),
("dropwhile(x<5, r)",
list(dropwhile(lambda x: x < 5, MALUMOT)),
"shart buzilgandan boshlab"),
("compress(r, maska)",
list(compress(MALUMOT, [1, 0, 1, 0, 1, 0, 1, 0])),
"maska bo'yicha"),
("chain(a, b)",
list(chain([1, 2], [3, 4])),
"birlashtirish"),
("chain.from_iterable(m)",
list(chain.from_iterable([[1, 2], [3, 4]])),
"tekislash"),
("starmap(pow, juftliklar)",
list(starmap(pow, [(2, 3), (3, 2)])),
"argumentlarni ochish"),
]
print(f" Ma'lumot: {MALUMOT}\n")
print(f" {'Vosita':<28} {'Natija':<24} Izoh")
print(" " + "─" * 70)
for kod, natija, izoh in VOSITALAR:
print(f" {kod:<28} {str(natija):<24} {izoh}")
print(f"\n ⭐ starmap vs map:")
JUFTLIKLAR = [(2, 3), (3, 2), (4, 1)]
print(f" map(lambda t: pow(*t), juftliklar) → "
f"{list(map(lambda t: pow(*t), JUFTLIKLAR))}")
print(f" starmap(pow, juftliklar) → "
f"{list(starmap(pow, JUFTLIKLAR))} ⭐ soddaroq")
print("\n=== 5. groupby ===")
from operator import itemgetter
XODIMLAR = [
{"ism": "Aziz", "bolim": "IT", "maosh": 7_000_000},
{"ism": "Bobur", "bolim": "HR", "maosh": 5_000_000},
{"ism": "Aziza", "bolim": "IT", "maosh": 8_000_000},
{"ism": "Dilnoza", "bolim": "Moliya", "maosh": 6_000_000},
{"ism": "Eldor", "bolim": "IT", "maosh": 9_000_000},
]
print(f" ⚠️ groupby SARALANGAN ma'lumot talab qiladi:\n")
print(f" Saralanmagan:")
for bolim, guruh in groupby(XODIMLAR, key=itemgetter("bolim")):
ismlar = [x["ism"] for x in guruh]
print(f" {bolim:<10} {ismlar}")
print(f"\n ✅ Saralangan:")
saralangan = sorted(XODIMLAR, key=itemgetter("bolim"))
for bolim, guruh in groupby(saralangan, key=itemgetter("bolim")):
xodimlar = list(guruh)
jami = sum(x["maosh"] for x in xodimlar)
print(f" {bolim:<10} {[x['ism'] for x in xodimlar]} jami={jami:,}")
print(f"\n ⭐ Muqobil — defaultdict (saralash kerak emas):")
from collections import defaultdict
guruhlar = defaultdict(list)
for x in XODIMLAR:
guruhlar[x["bolim"]].append(x["ism"])
for bolim, ismlar in guruhlar.items():
print(f" {bolim:<10} {ismlar}")
print("\n=== 6. Funksional quvur ===")
XOM = [
" 42 ", "", "# izoh", "abc", " 17", "0", "-5", " ", "99", "3.14",
]
print(f" Xom ma'lumot: {XOM}\n")
print(f" 1️⃣ To'liq funksional (map/filter/reduce):")
natija1 = reduce(
operator.add,
map(int, filter(str.isdigit, map(str.strip, XOM))),
0,
)
print(f" reduce(add, map(int, filter(isdigit, map(strip, r))), 0)")
print(f" → {natija1}")
print(f" ⚠️ Ichkaridan tashqariga o'qish kerak")
print(f"\n 2️⃣ Generator + sum:")
natija2 = sum(int(q) for x in XOM if (q := x.strip()).isdigit())
print(f" sum(int(q) for x in r if (q := x.strip()).isdigit())")
print(f" → {natija2}")
print(f" ✅ Bir qatorda, chapdan o'ngga")
print(f"\n 3️⃣ Bosqichma-bosqich (eng aniq):")
tozalangan = (x.strip() for x in XOM)
sonlar = (q for q in tozalangan if q.isdigit())
natija3 = sum(int(q) for q in sonlar)
print(f" tozalangan = (x.strip() for x in r)")
print(f" sonlar = (q for q in tozalangan if q.isdigit())")
print(f" natija = sum(int(q) for q in sonlar)")
print(f" → {natija3}")
print(f"\n Uchalasi teng: {natija1 == natija2 == natija3}")
import timeit
SOZLASH = f"""
import operator
from functools import reduce
XOM = {XOM!r}
"""
print(f"\n Tezlik:")
for nom, kod in [
("map/filter/reduce",
"reduce(operator.add, map(int, filter(str.isdigit, map(str.strip, XOM))), 0)"),
("Generator + sum",
"sum(int(q) for x in XOM if (q := x.strip()).isdigit())"),
]:
vaqt = timeit.timeit(kod, setup=SOZLASH, number=100_000)
print(f" {nom:<24} {vaqt:.3f} s")
print("\n=== 7. Qaror jadvali ===")
print("""
┌────────────────────────────┬──────────────────────────────────┐
│ Vazifa │ Tavsiya │
├────────────────────────────┼──────────────────────────────────┤
│ Transformatsiya + lambda │ [f(x) for x in r] ⭐ │
│ Transformatsiya + funksiya │ map(f, r) yoki generator │
│ Filtrlash │ [x for x in r if p(x)] ⭐ │
│ Rostlik filtri │ filter(None, r) ⭐ │
│ Bir necha iterable │ map(f, a, b) ⭐ │
│ Argumentlarni ochish │ starmap(f, juftliklar) ⭐ │
│ Yig'indi │ sum(r) ⭐ │
│ Ko'paytma │ math.prod(r) ⭐ │
│ Min/max │ min(r) / max(r) ⭐ │
│ Mantiqiy │ any(r) / all(r) ⭐ │
│ Oraliq natijalar │ accumulate(r, f) ⭐ │
│ Maxsus assotsiativ amal │ reduce(f, r) ⭐ │
│ Guruhlash │ defaultdict ⭐ (yoki groupby) │
│ Satrlarni birlashtirish │ "".join(r) ⭐ │
└────────────────────────────┴──────────────────────────────────┘
""")Natijaning muhim qismi:
=== 2. any / all — erta to'xtash ===
100 element, 7-chisida shart bajariladi:
any(f(x) for x in r) → 7 chaqiruv ⭐
any([f(x) for x in r]) → 100 chaqiruv ❌
all(f(x) for x in r) → 1 chaqiruv ⭐ (birinchi False)
Bo'sh ketma-ketlik:
any([]) = False (hech biri rost emas)
all([]) = True (hech biri yolg'on emas — vacuous truth)
=== 5. groupby ===
⚠️ groupby SARALANGAN ma'lumot talab qiladi:
Saralanmagan:
IT ['Aziz']
HR ['Bobur']
IT ['Aziza']
Moliya ['Dilnoza']
IT ['Eldor']Nima ko'rsatdi: 2.5, 2.6-bo'limlar.
Misol 4 — Amaliy: ma'lumot tahlili
"""map/filter/reduce va muqobillari — real vazifada."""
import math
import operator
import statistics
from collections import Counter, defaultdict
from dataclasses import dataclass
from functools import reduce
from itertools import accumulate, groupby, starmap
from operator import attrgetter, itemgetter
print("=== Sotuvlar tahlili ===\n")
@dataclass(frozen=True)
class Sotuv:
oy: str
shahar: str
mahsulot: str
soni: int
narx: int
@property
def summa(self) -> int:
return self.soni * self.narx
SOTUVLAR = [
Sotuv("2026-07", "Toshkent", "non", 1200, 5_000),
Sotuv("2026-07", "Toshkent", "sut", 800, 12_000),
Sotuv("2026-07", "Samarqand", "non", 950, 4_800),
Sotuv("2026-08", "Toshkent", "non", 1400, 5_200),
Sotuv("2026-08", "Samarqand", "sut", 700, 11_500),
Sotuv("2026-08", "Buxoro", "non", 600, 4_900),
Sotuv("2026-09", "Toshkent", "sut", 900, 12_500),
Sotuv("2026-09", "Samarqand", "non", 1100, 5_100),
Sotuv("2026-09", "Buxoro", "sut", 550, 11_800),
]
print("=== 1. Asosiy agregatlar ===\n")
summalar = [s.summa for s in SOTUVLAR]
AGREGATLAR = [
("Jami summa", f"{sum(summalar):,}"),
("O'rtacha", f"{statistics.mean(summalar):,.0f}"),
("Mediana", f"{statistics.median(summalar):,.0f}"),
("Eng katta", f"{max(summalar):,}"),
("Eng kichik", f"{min(summalar):,}"),
("Standart og'ish", f"{statistics.stdev(summalar):,.0f}"),
("Jami dona", f"{sum(s.soni for s in SOTUVLAR):,}"),
]
for nom, qiymat in AGREGATLAR:
print(f" {nom:<20} {qiymat:>14}")
print(f"\n ⭐ Barchasi generator ifodasi bilan — reduce kerak emas")
print("\n\n=== 2. Filtrlash ===\n")
FILTRLAR = [
("Toshkent",
[s for s in SOTUVLAR if s.shahar == "Toshkent"]),
("Non",
[s for s in SOTUVLAR if s.mahsulot == "non"]),
("Katta (>6M)",
[s for s in SOTUVLAR if s.summa > 6_000_000]),
("Sentyabr",
[s for s in SOTUVLAR if s.oy == "2026-09"]),
]
print(f" {'Filtr':<16} {'Soni':>5} {'Jami summa':>16}")
print(" " + "─" * 40)
for nom, natija in FILTRLAR:
jami = sum(s.summa for s in natija)
print(f" {nom:<16} {len(natija):>5} {jami:>16,}")
print(f"\n ⚠️ map/filter bilan (kamroq o'qiladi):")
toshkent = list(filter(lambda s: s.shahar == "Toshkent", SOTUVLAR))
jami = reduce(operator.add, map(attrgetter("summa"), toshkent), 0)
print(f" reduce(add, map(attrgetter('summa'), filter(...)), 0)")
print(f" → {jami:,}")
print(f"\n ✅ Generator bilan:")
print(f" sum(s.summa for s in SOTUVLAR if s.shahar == 'Toshkent')")
print(f" → {sum(s.summa for s in SOTUVLAR if s.shahar == 'Toshkent'):,}")
print("\n\n=== 3. Guruhlash ===\n")
def guruhla(malumot, kalit):
"""defaultdict bilan — saralash kerak emas."""
natija = defaultdict(list)
for x in malumot:
natija[kalit(x)].append(x)
return dict(natija)
GURUHLASHLAR = [
("Shahar bo'yicha", attrgetter("shahar")),
("Oy bo'yicha", attrgetter("oy")),
("Mahsulot bo'yicha", attrgetter("mahsulot")),
]
for nom, kalit in GURUHLASHLAR:
guruhlar = guruhla(SOTUVLAR, kalit)
print(f" {nom}:")
print(f" {'Guruh':<12} {'Soni':>5} {'Jami':>16} {'O`rtacha':>14}")
print(" " + "─" * 50)
for k in sorted(guruhlar):
sotuvlar = guruhlar[k]
jami = sum(s.summa for s in sotuvlar)
print(f" {k:<12} {len(sotuvlar):>5} {jami:>16,} "
f"{jami // len(sotuvlar):>14,}")
print()
print("=== 4. Kumulyativ tahlil (accumulate) ===\n")
oylar = sorted({s.oy for s in SOTUVLAR})
oy_summalari = [
sum(s.summa for s in SOTUVLAR if s.oy == oy)
for oy in oylar
]
kumulyativ = list(accumulate(oy_summalari))
maksimum = list(accumulate(oy_summalari, max))
osish = [
round((b - a) / a * 100, 1)
for a, b in zip(oy_summalari, oy_summalari[1:])
]
print(f" {'Oy':<10} {'Summa':>14} {'Kumulyativ':>16} {'O`sish':>9} Grafik")
print(" " + "─" * 70)
eng_katta = max(kumulyativ)
for i, oy in enumerate(oylar):
o = f"{osish[i-1]:+.1f}%" if i > 0 else "—"
chiziq = "█" * int(kumulyativ[i] / eng_katta * 20)
print(f" {oy:<10} {oy_summalari[i]:>14,} {kumulyativ[i]:>16,} "
f"{o:>9} {chiziq}")
print(f"\n Yugurib boruvchi maksimum: {[f'{x:,}' for x in maksimum]}")
print("\n\n=== 5. starmap va bir necha iterable ===\n")
NARXLAR = [5_000, 12_000, 4_800]
SONLAR = [1200, 800, 950]
CHEGIRMALAR = [0.05, 0.10, 0.0]
print(f" Narxlar: {NARXLAR}")
print(f" Sonlar: {SONLAR}")
print(f" Chegirmalar: {CHEGIRMALAR}\n")
print(f" 1. map bir necha iterable bilan:")
summalar = list(map(operator.mul, NARXLAR, SONLAR))
print(f" map(mul, narxlar, sonlar) → {[f'{x:,}' for x in summalar]}")
print(f"\n 2. Uch iterable:")
def yakuniy(narx, soni, chegirma):
return round(narx * soni * (1 - chegirma))
natija = list(map(yakuniy, NARXLAR, SONLAR, CHEGIRMALAR))
print(f" map(yakuniy, narxlar, sonlar, chegirmalar)")
print(f" → {[f'{x:,}' for x in natija]}")
print(f"\n 3. starmap (juftliklar bilan):")
JUFTLIKLAR = list(zip(NARXLAR, SONLAR, CHEGIRMALAR))
natija2 = list(starmap(yakuniy, JUFTLIKLAR))
print(f" starmap(yakuniy, zip(...)) → {[f'{x:,}' for x in natija2]}")
print(f"\n 4. Generator bilan:")
natija3 = [yakuniy(n, s, c) for n, s, c in zip(NARXLAR, SONLAR, CHEGIRMALAR)]
print(f" [yakuniy(n,s,c) for n,s,c in zip(...)]")
print(f" → {[f'{x:,}' for x in natija3]}")
print(f"\n Uchalasi teng: {natija == natija2 == natija3}")
print(f"\n ⭐ map bir necha iterable bilan — generatordan qisqaroq")
print("\n\n=== 6. reduce KERAK bo'lgan holat ===\n")
def hisobot_birlashtir(a: dict, b: dict) -> dict:
"""Ikki hisobotni birlashtiradi (maxsus mantiq)."""
natija = {}
for kalit in set(a) | set(b):
av, bv = a.get(kalit), b.get(kalit)
if av is None:
natija[kalit] = bv
elif bv is None:
natija[kalit] = av
elif isinstance(av, dict):
natija[kalit] = hisobot_birlashtir(av, bv)
elif isinstance(av, (int, float)):
natija[kalit] = av + bv
else:
natija[kalit] = [av, bv]
return natija
OYLIK_HISOBOTLAR = [
{"summa": 15_000_000, "soni": 3, "shaharlar": {"Toshkent": 2, "Samarqand": 1}},
{"summa": 12_000_000, "soni": 3, "shaharlar": {"Toshkent": 1, "Buxoro": 2}},
{"summa": 18_000_000, "soni": 3, "shaharlar": {"Samarqand": 2, "Buxoro": 1}},
]
print(f" Uch oylik hisobot:\n")
for i, h in enumerate(OYLIK_HISOBOTLAR, 1):
print(f" {i}. {h}")
yakuniy_hisobot = reduce(hisobot_birlashtir, OYLIK_HISOBOTLAR)
print(f"\n reduce(hisobot_birlashtir, hisobotlar):")
for k, v in yakuniy_hisobot.items():
print(f" {k:<12} {v}")
print(f"""
⭐ Bu yerda reduce TO'G'RI:
• Amal assotsiativ (birlashtirish tartibi ahamiyatsiz)
• Tayyor muqobil yo'q
• Natija — bitta qiymat
""")
print("\n=== 7. Yakuniy solishtirish ===\n")
print(" Bir vazifa — uch yondashuv:\n")
print(""" Vazifa: Toshkentdagi non sotuvlarining jami summasi
1️⃣ To'liq funksional:
reduce(
operator.add,
map(attrgetter("summa"),
filter(lambda s: s.shahar == "Toshkent" and s.mahsulot == "non",
SOTUVLAR)),
0,
)""")
n1 = reduce(
operator.add,
map(attrgetter("summa"),
filter(lambda s: s.shahar == "Toshkent" and s.mahsulot == "non",
SOTUVLAR)),
0,
)
print(f" → {n1:,}")
print("""
2️⃣ Generator + sum (⭐ Pythonik):
sum(s.summa for s in SOTUVLAR
if s.shahar == "Toshkent" and s.mahsulot == "non")""")
n2 = sum(s.summa for s in SOTUVLAR
if s.shahar == "Toshkent" and s.mahsulot == "non")
print(f" → {n2:,}")
print("""
3️⃣ Bosqichma-bosqich (aniq nomlar):
toshkent_non = [s for s in SOTUVLAR
if s.shahar == "Toshkent" and s.mahsulot == "non"]
jami = sum(s.summa for s in toshkent_non)""")
toshkent_non = [s for s in SOTUVLAR
if s.shahar == "Toshkent" and s.mahsulot == "non"]
n3 = sum(s.summa for s in toshkent_non)
print(f" → {n3:,}")
print(f"\n Uchalasi teng: {n1 == n2 == n3}")
print("""
⭐ Tavsiya:
• Oddiy holat → 2️⃣ generator + sum
• Murakkab → 3️⃣ bosqichma-bosqich, nomlar bilan
• 1️⃣ — faqat funksional dasturlash o'rganishda
""")Natijaning muhim qismi:
=== 4. Kumulyativ tahlil (accumulate) ===
Oy Summa Kumulyativ O`sish Grafik
──────────────────────────────────────────────────────────────────────
2026-07 20,160,000 20,160,000 — ██████
2026-08 18,270,000 38,430,000 -9.4% ████████████
2026-09 23,350,000 61,780,000 +27.8% ████████████████████
=== 7. Yakuniy solishtirish ===
1️⃣ To'liq funksional:
→ 13,280,000
2️⃣ Generator + sum (⭐ Pythonik):
→ 13,280,000
Uchalasi teng: TrueNima ko'rsatdi: 2.3, 2.5, 2.6, 2.7-bo'limlar.
5. To'g'ri va noto'g'ri tushunishlar
| Noto'g'ri fikr | To'g'risi |
|---|---|
"map ro'yxat qaytaradi" |
Python 3 da iterator (dangasa) |
"map/filter generatordan tezroq" |
lambda bilan sekinroq |
"reduce ichki funksiya" |
Python 3 da functools dan import |
"reduce(add, r) — normal" |
sum(r) ~5x tezroq |
"filter(None, r) — hech narsa filtrlamaydi" |
Rostlik bo'yicha filtrlaydi |
"map eng uzun iterable gacha" |
Eng qisqasida to'xtaydi |
"all([]) — False" |
True (vacuous truth) |
"groupby avtomatik guruhlaydi" |
Saralangan ma'lumot talab qiladi |
"sum satrlar uchun ishlaydi" |
TypeError — "".join kerak |
6. Keng tarqalgan xatolar va yechimlari
1. map/filter natijasini qayta ishlatish
m = map(f, r)
list(m); list(m) # ⚠️ ikkinchisi bo'sh
r2 = list(map(f, r)) # ✅2. lambda bilan map
list(map(lambda x: x * 2, r)) # ❌
[x * 2 for x in r] # ✅3. reduce(add, r)
reduce(operator.add, r) # ❌ sekin
sum(r) # ✅4. reduce bilan ro'yxat qurish
reduce(lambda a, b: a + [b], r, []) # ❌ O(n²)
list(r) # ✅5. any/all da ortiqcha qavs
any([f(x) for x in katta]) # ❌ hammasi hisoblanadi
any(f(x) for x in katta) # ✅ erta to'xtaydi6. groupby saralamasdan
groupby(malumot, key=k) # ❌ qo'shni guruhlar bo'linadi
groupby(sorted(malumot, key=k), key=k) # ✅
defaultdict(list) # ✅ soddaroq7. sum satrlar uchun
sum(satrlar, "") # ❌ TypeError
"".join(satrlar) # ✅8. map bir necha iterable uzunligi
map(f, a, b) # ⚠️ eng qisqasida to'xtaydi
zip_longest(a, b, fillvalue=0) # ✅ aniq7. Integratsiya — bu bilim qayerda kerak bo'ladi
- 6.15, 6.17-darslar (o'tilgan): generatorlar
- 7.10, 7.11-darslar (o'tilgan):
lambda, funksiya-obyekt - 10, 15-qismlar:
functools,itertools, funksional dasturlash - 6.3-dars (o'tilgan):
key=,sorted - 6.11-dars (o'tilgan):
Counter,defaultdict - 24-qism:
numpy— vektorlashtirilganmap
8. Eng yaxshi amaliyotlar
lambdakerak bo'lsa — generator.[f(x) for x in r]tezroq va o'qiladi.Tayyor funksiya bilan
mapyaxshi.map(str.upper, r),map(int, r).filter(None, r)— idiomatik. Bo'sh qiymatlarni olib tashlaydi.reduceo'rniga tayyor agregat.sum,math.prod,max,"".join.Oraliq natijalar —
accumulate.reducefaqat oxirgisini beradi.any/allni generator bilan. Erta to'xtash.Guruhlash —
defaultdict.groupbysaralash talab qiladi.Uzun zanjir o'rniga bosqichma-bosqich. Nomlar mantiqni tushuntiradi.
9. Amaliy topshiriq
Vazifa 1: Natijani bashorat qiling
from functools import reduce
import operator
r = [1, 2, 3, 4]
1. print(type(map(str, r)))
2. m = map(str, r); print(list(m), list(m))
3. print(list(map(operator.add, [1,2,3], [10,20])))
4. print(list(filter(None, [0, 1, "", "a", None])))
5. print(reduce(operator.add, r))
6. print(reduce(operator.add, r, 100))
7. reduce(operator.add, [])
8. print(sum(r), math.prod(r))
9. print(any([]), all([]))
10. print(list(accumulate(r)))
11. print(list(accumulate(r, operator.mul)))
12. sum(["a", "b"], "")Javoblar
<class 'map'>['1', '2', '3', '4'] []— iterator tugadi[11, 22]— eng qisqasida to'xtadi[1, 'a']10110-
TypeError— bo'sh, boshlang'ich yo'q 10 24False True— vacuous truth[1, 3, 6, 10][1, 2, 6, 24]-
TypeError: sum() can't sum strings
Vazifa 2: Xatolarni tuzating
1. list(map(lambda x: x * 2, r))
2. list(filter(lambda x: x > 0, r))
3. reduce(operator.add, r)
4. reduce(lambda a, b: a + [b], r, [])
5. any([qimmat(x) for x in katta])
6. groupby(malumot, key=f)
7. sum(satrlar, "")
8. m = map(f, r); a = list(m); b = list(m)Javoblar
1. [x * 2 for x in r]
2. [x for x in r if x > 0]
3. sum(r)
4. list(r)
5. any(qimmat(x) for x in katta)
6. groupby(sorted(malumot, key=f), key=f) yoki defaultdict
7. "".join(satrlar)
8. natija = list(map(f, r)); a = natija; b = natijaVazifa 3: reduce ni almashtiring
Har bir reduce uchun muqobil toping:
1. reduce(operator.add, r)
2. reduce(operator.mul, r)
3. reduce(max, r)
4. reduce(operator.or_, toplamlar)
5. reduce(operator.concat, satrlar)
6. reduce(lambda a, b: a if a > b else b, r)
7. reduce(lambda a, b: a + 1, r, 0)
8. reduce(lambda a, b: {**a, **b}, lugatlar)
9. reduce(math.gcd, sonlar)
10. reduce(lambda a, b: a * 10 + b, raqamlar)Vazifa 4: Funksional quvur
Yozing:
Quvursinfi —xarita,filtrla,yigindi,guruhla- Dangasa (generator asosida)
__iter__,__len__(agar mumkin bo'lsa)map/filterversiyasi bilan solishtiring- Tezlik va xotira o'lchovi
- Zanjirlash:
Quvur(r).xarita(f).filtrla(p).yigindi()
Vazifa 5: accumulate qo'llanmalari
Dastur yozing:
- Balans tarixi (tranzaksiyalardan)
- Yugurib boruvchi o'rtacha (
dequebilan) - Maksimal pasayish (max drawdown)
- Kumulyativ foiz
- Har biri uchun grafik (
█bilan) reducebilan solishtiring
Vazifa 6: Tezlik tadqiqoti
O'lchang va grafik chizing:
[f(x) for x in r]vslist(map(f, r))— turlifbilanlambdavs tayyor funksiya vsoperatorsumvsreduce(add)vs qo'lda siklfilter(None, r)vs[x for x in r if x]- Ma'lumot hajmiga bog'liqlik
- Xotira sarfi
Vazifa 7: O'ylash
Nega Guido reduce ni Python 3 da ichki nomlardan olib tashladi, lekin map va filter ni qoldirdi?
Javob
Chunki map/filter o'qiladi, reduce esa ko'pincha yo'q.
Guido ning asl rejasi (2005):
Guido "Python 3000" da to'rttasini ham olib tashlashni rejalashtirgan edi:
"I think dropping
filter()andmap()is pretty uncontroversial;filter(P, S)is almost always written clearer as[x for x in S if P(x)], and this has the huge advantage that the most common usages involve predicates that are comparisons, e.g.x==42, and defining a lambda for that just requires much more effort for the reader."
Lekin:
"
reduce()is the one I've always hated most."
Nega reduce yomonroq:
1. O'qish uchun qog'oz kerak.
reduce(lambda a, b: a + [b] if b > 0 else a, r, [])Bu nima qiladi? Tushunish uchun:
a— akkumulyator,b— joriy element- Boshlang'ich
[] - Har qadamda... qog'ozga chizish kerak
Generator esa darhol o'qiladi:
[b for b in r if b > 0]2. Ko'p holatda tayyor muqobil bor.
reduce |
Muqobil |
|---|---|
reduce(add, r) |
sum(r) |
reduce(mul, r) |
math.prod(r) |
reduce(max, r) |
max(r) |
reduce(concat, r) |
"".join(r) |
reduce(or_, r) |
set().union(*r) |
Amalda reduce ning 95% qo'llanishi — shu ro'yxatdan.
3. Sekin.
Har element uchun Python funksiyasi chaqiriladi. sum — C tsikli.
Nega map/filter qoldirildi:
1. Ba'zan haqiqatan yaxshiroq:
map(str.upper, sozlar) # ✅ qisqa, tez
map(f, a, b) # ✅ bir necha iterable
filter(None, r) # ✅ idiomatik2. Jamoa qarshilik ko'rsatdi.
Guido ning taklifi python-dev da keskin muhokama qilindi. Argumentlar:
map(f, a, b)uchun generator ekvivalenti uzunroqfilter(None, r)— juda idiomatik- Mavjud kodning katta qismi buziladi
- Ba'zi holatlarda
maptezroq
3. Kompromis:
map,filter— qoldirildi, lekin dangasa qilindi (iterator qaytaradi)reduce—functoolsga ko'chirildi (import kerak)apply,coerce,intern— olib tashlandi
reduce ni functools ga ko'chirish — nozik xabar:
Bu — "taqiqlamaymiz, lekin oson emas qilamiz" strategiyasi:
from functools import reduce # bir qator qo'shimchaBu bir qator dasturchini o'ylashga majbur qiladi: "haqiqatan reduce kerakmi, yoki sum yetarlimi?"
Natija:
Zamonaviy Python kodda:
sum,max,min,any,all— juda ko'p- Generator ifodalari — juda ko'p
map(tayyor_funksiya, r)— o'rtachafilter(None, r)— o'rtachamap(lambda ...)— kam (linterlar ogohlantiradi)reduce— juda kam
Linterlar ham qo'llab-quvvatlaydi:
ruff C417: Unnecessary map usage (rewrite using a comprehension)
ruff C411: Unnecessary list call within list comprehension
pylint W0141: bad-builtin (map/filter)Boshqa tillar:
Funksional tillarda reduce (yoki fold) — markaziy:
foldr (+) 0 [1,2,3] -- Haskelllist.reduce(_ + _) // ScalaChunki u yerda:
- Sintaksis qisqaroq (operator sektsiyalari)
- Tayyor agregatlar kamroq
- Dasturchilar
foldga o'rganib qolgan
Pythonda esa sum(r) — qisqaroq va aniqroq.
Xulosa: bu — Pythonning "bitta aniq yo'l" tamoyili. Agar sum(r) bor bo'lsa, reduce(add, r) — ikkinchi yo'l, va u yomonroq. map/filter esa ba'zi holatlarda yagona qisqa yo'l bo'lib qoldi — shuning uchun saqlandi.
Nimani mustahkamlaydi: 2.3, 2.4, 2.7-bo'limlar.
Xulosa
Bu darsda map, filter, reduce ni o'rgandik.
Eng muhim uch fikr:
lambdakerak bo'lsa — generator ifodasi.[x*2 for x in r]list(map(lambda x: x*2, r))dan tezroq va o'qilishi yaxshiroq.map/filterfaqat tayyor funksiya bilan (map(str.upper, r)), bir necha iterable bilan (map(f, a, b)) yokifilter(None, r)shaklida yaxshi.reduceo'rniga tayyor agregat.sum,math.prod,max,min,any,all,"".join,set().union(*r)— hammasi C da yozilgan va ~5x tezroq.reducefaqat tayyor muqobili yo'q assotsiativ amal uchun.Oraliq natijalar kerak bo'lsa —
itertools.accumulate. U dangasa va har qadamdagi natijani beradi: kumulyativ yig'indi, balans tarixi, yugurib boruvchi maksimum.
Keyingi darsda rekursiyani ko'ramiz: o'zini chaqiruvchi funksiyalar, chuqurlik chegarasi, memoizatsiya va qachon sikl yaxshiroq.
Izohlar · 0
Izoh yozish uchun kiring.