Python kursi7.12-dars: map, filter, reduce
Python kursi · Funksiyalar

7.12-dars: map, filter, reduce

36 daqiqa12/14-dars

7-QISM — FUNKSIYALAR · 12-dars


1. Kirish va motivatsiya

Uch klassik funksional vosita:

python
map(f, r)                       # har elementga f ni qo'llash
filter(p, r)                    # shartga mos elementlar
reduce(f, r)                    # ketma-ketlikni bitta qiymatga
python
list(map(str.upper, ["a", "b"]))        # ['A', 'B']
list(filter(str.isdigit, "a1b2"))       # ['1', '2']
reduce(operator.add, [1, 2, 3, 4])      # 10

Lekin Pythonda ular ko'pincha generatorlar bilan almashtiriladi:

python
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:

python
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)
  • reduce va nega u tavsiya etilmaydi
  • Muqobillar: sum, math.prod, any, all, itertools.accumulate
  • Tezlik solishtirilishi
  • Funksional dasturlash Pythonda

2. Nazariya — chuqur tushuntirish

2.1. map

python
map(funksiya, iterable, ...)

Dangasa — iterator qaytaradi (Python 3):

python
m = map(str.upper, ["a", "b"])
type(m)                         # <class 'map'>
list(m)                         # ['A', 'B']
list(m)                         # []  ⚠️ tugagan

Bir necha iterable:

python
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):

python
list(map(add, [1, 2, 3], [10, 20]))     # [11, 22]  — uchinchi tashlanadi

itertools.zip_longest bilan:

python
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:

python
list(map(None, [1, 2]))         # ❌ TypeError (Python 3)
list(zip([1, 2], [3, 4]))       # ✅

2.2. filter

python
filter(funksiya, iterable)
python
list(filter(str.isdigit, "a1b2"))       # ['1', '2']
list(filter(lambda x: x > 0, [-1, 2]))  # [2]

filter(None, r) — rostlik bo'yicha:

python
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:

python
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:

  • lambda yozish kerak → generator
  • Tayyor funksiya bor → map/filter ham yaxshi
  • filter(None, r) → idiomatik

Tezlik:

python
[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:

python
map(f, r)                       # ~50 bayt — dangasa
[f(x) for x in r]               # O(n)
(f(x) for x in r)               # ~200 bayt — dangasa

map va generator ifodasi ikkalasi ham dangasa.

2.4. reduce

python
from functools import reduce

reduce(funksiya, iterable[, boshlangich])

Qanday ishlaydi:

python
reduce(f, [a, b, c, d])
# ≡ f(f(f(a, b), c), d)
python
reduce(operator.add, [1, 2, 3, 4])          # 10
reduce(operator.add, [1, 2, 3, 4], 100)     # 110
reduce(operator.mul, [1, 2, 3, 4])          # 24

Bo'sh ketma-ketlik:

python
reduce(add, [])                 # ❌ TypeError
reduce(add, [], 0)              # ✅ 0

Python 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 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."

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:

python
# 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:

python
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:

python
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 xil

Amaliy:

python
# 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

python
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:

python
sum(range(1_000_000))                       # ~8 ms
reduce(operator.add, range(1_000_000))      # ~45 ms

sum satrlar uchun sekin:

python
sum(satrlar, "")                # ❌ O(n²)
"".join(satrlar)                # ✅ O(n)

Python buni ataylab taqiqlaydi:

python
sum(["a", "b"], "")
# TypeError: sum() can't sum strings [use ''.join(seq) instead]

any/all — erta to'xtash:

python
any(f(x) for x in katta)        # birinchi True da to'xtaydi ⭐
all(f(x) for x in katta)        # birinchi False da

2.7. Funksional dasturlash Pythonda

Python — ko'p paradigmali til. Funksional uslub qo'llab-quvvatlanadi, lekin asosiy emas.

Nima bor:

python
map, filter, reduce
functools (partial, reduce, wraps, lru_cache, singledispatch)
itertools (accumulate, chain, groupby, ...)
operator (add, itemgetter, ...)
lambda, yopilmalar
generatorlar

Nima yo'q:

python
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, funktorlar

Pythonning pozitsiyasi:

Guido: "Python is not a functional language" — lekin funksional g'oyalar (birinchi darajali funksiyalar, generatorlar, map/filter) foydali.

Amaliy uslub:

python
# ✅ 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

python
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 yaxshiroq

filter

python
filter(p, r)            shartga mos
filter(None, r)         ⭐ rostlik bo'yicha (idiomatik)
itertools.filterfalse   teskarisi

⚠️ filter(lambda x: ..., r) → generator yaxshiroq

reduce

python
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.accumulate

Qachon 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 → reduce

Tezlik

[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 tez

4. Batafsil misollar

Misol 1 — map va filter

python
"""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:

text
=== 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.00x

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

Misol 2 — reduce va muqobillari

python
"""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:

text
=== 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 s

Nima ko'rsatdi: 2.4, 2.5, 2.6-bo'limlar.

Misol 3 — Agregatlar va itertools

python
"""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:

text
=== 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

python
"""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:

text
=== 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: True

Nima 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

python
m = map(f, r)
list(m); list(m)                    # ⚠️ ikkinchisi bo'sh
r2 = list(map(f, r))                # ✅

2. lambda bilan map

python
list(map(lambda x: x * 2, r))       # ❌
[x * 2 for x in r]                  # ✅

3. reduce(add, r)

python
reduce(operator.add, r)             # ❌ sekin
sum(r)                              # ✅

4. reduce bilan ro'yxat qurish

python
reduce(lambda a, b: a + [b], r, []) # ❌ O(n²)
list(r)                             # ✅

5. any/all da ortiqcha qavs

python
any([f(x) for x in katta])          # ❌ hammasi hisoblanadi
any(f(x) for x in katta)            # ✅ erta to'xtaydi

6. groupby saralamasdan

python
groupby(malumot, key=k)             # ❌ qo'shni guruhlar bo'linadi
groupby(sorted(malumot, key=k), key=k)      # ✅
defaultdict(list)                   # ✅ soddaroq

7. sum satrlar uchun

python
sum(satrlar, "")                    # ❌ TypeError
"".join(satrlar)                    # ✅

8. map bir necha iterable uzunligi

python
map(f, a, b)                        # ⚠️ eng qisqasida to'xtaydi
zip_longest(a, b, fillvalue=0)      # ✅ aniq

7. 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 — vektorlashtirilgan map

8. Eng yaxshi amaliyotlar

  1. lambda kerak bo'lsa — generator. [f(x) for x in r] tezroq va o'qiladi.

  2. Tayyor funksiya bilan map yaxshi. map(str.upper, r), map(int, r).

  3. filter(None, r) — idiomatik. Bo'sh qiymatlarni olib tashlaydi.

  4. reduce o'rniga tayyor agregat. sum, math.prod, max, "".join.

  5. Oraliq natijalar — accumulate. reduce faqat oxirgisini beradi.

  6. any/all ni generator bilan. Erta to'xtash.

  7. Guruhlash — defaultdict. groupby saralash talab qiladi.

  8. Uzun zanjir o'rniga bosqichma-bosqich. Nomlar mantiqni tushuntiradi.


9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python
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
  1. <class 'map'>
  2. ['1', '2', '3', '4'] [] — iterator tugadi
  3. [11, 22] — eng qisqasida to'xtadi
  4. [1, 'a']
  5. 10
  6. 110
  7. TypeError — bo'sh, boshlang'ich yo'q
  8. 10 24
  9. False True — vacuous truth
  10. [1, 3, 6, 10]
  11. [1, 2, 6, 24]
  12. TypeError: sum() can't sum strings

Vazifa 2: Xatolarni tuzating

python
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
python
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 = natija

Vazifa 3: reduce ni almashtiring

Har bir reduce uchun muqobil toping:

python
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:

  1. Quvur sinfi — xarita, filtrla, yigindi, guruhla
  2. Dangasa (generator asosida)
  3. __iter__, __len__ (agar mumkin bo'lsa)
  4. map/filter versiyasi bilan solishtiring
  5. Tezlik va xotira o'lchovi
  6. Zanjirlash: Quvur(r).xarita(f).filtrla(p).yigindi()

Vazifa 5: accumulate qo'llanmalari

Dastur yozing:

  1. Balans tarixi (tranzaksiyalardan)
  2. Yugurib boruvchi o'rtacha (deque bilan)
  3. Maksimal pasayish (max drawdown)
  4. Kumulyativ foiz
  5. Har biri uchun grafik (█ bilan)
  6. reduce bilan solishtiring

Vazifa 6: Tezlik tadqiqoti

O'lchang va grafik chizing:

  1. [f(x) for x in r] vs list(map(f, r)) — turli f bilan
  2. lambda vs tayyor funksiya vs operator
  3. sum vs reduce(add) vs qo'lda sikl
  4. filter(None, r) vs [x for x in r if x]
  5. Ma'lumot hajmiga bog'liqlik
  6. 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() and map() 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.

python
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:

python
[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:

python
map(str.upper, sozlar)          # ✅ qisqa, tez
map(f, a, b)                    # ✅ bir necha iterable
filter(None, r)                 # ✅ idiomatik

2. Jamoa qarshilik ko'rsatdi.

Guido ning taklifi python-dev da keskin muhokama qilindi. Argumentlar:

  • map(f, a, b) uchun generator ekvivalenti uzunroq
  • filter(None, r) — juda idiomatik
  • Mavjud kodning katta qismi buziladi
  • Ba'zi holatlarda map tezroq

3. Kompromis:

  • map, filter — qoldirildi, lekin dangasa qilindi (iterator qaytaradi)
  • reduce — functools ga ko'chirildi (import kerak)
  • apply, coerce, intern — olib tashlandi

reduce ni functools ga ko'chirish — nozik xabar:

Bu — "taqiqlamaymiz, lekin oson emas qilamiz" strategiyasi:

python
from functools import reduce      # bir qator qo'shimcha

Bu 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'rtacha
  • filter(None, r) — o'rtacha
  • map(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:

haskell
foldr (+) 0 [1,2,3]         -- Haskell
scala
list.reduce(_ + _)          // Scala

Chunki u yerda:

  • Sintaksis qisqaroq (operator sektsiyalari)
  • Tayyor agregatlar kamroq
  • Dasturchilar fold ga 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:

  1. lambda kerak bo'lsa — generator ifodasi. [x*2 for x in r] list(map(lambda x: x*2, r)) dan tezroq va o'qilishi yaxshiroq. map/filter faqat tayyor funksiya bilan (map(str.upper, r)), bir necha iterable bilan (map(f, a, b)) yoki filter(None, r) shaklida yaxshi.

  2. reduce o'rniga tayyor agregat. sum, math.prod, max, min, any, all, "".join, set().union(*r) — hammasi C da yozilgan va ~5x tezroq. reduce faqat tayyor muqobili yo'q assotsiativ amal uchun.

  3. 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.

Funksiyalar · 12-dars yakunlandi

7.12-dars: map, filter, reduce

36 daqvaqt
0belgi
Keyingi dars: 7.13-dars: Rekursiya
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0