13. Lambda funksiyalar va funksional dasturlash¶

Python'da funksiyalarni oddiy kod bloklari sifatida emas, balki boshqa funksiyalarga beriladigan yoki ulardan qaytariladigan qiymatlar sifatida ham ishlatish mumkin.

Bunday yondashuv funksional dasturlash deb ataladi.

Bu bobda quyidagilarni o‘rganamiz:

lambda
map()
filter()
reduce()
sorted()
key
funksional dasturlash uslubi

Lambda nima?¶

lambda — kichik va odatda bir qatorli anonim funksiya yaratish uchun ishlatiladi.

Oddiy funksiya:

def qoshish(
    birinchi_son,
    ikkinchi_son
):

    return (
        birinchi_son
        + ikkinchi_son
    )

Xuddi shu funksiyani lambda bilan:

qoshish = lambda birinchi_son, ikkinchi_son: (
    birinchi_son + ikkinchi_son
)

chaqirish mumkin:

natija = qoshish(
    10,
    20
)

print(
    f"Natija: {natija}"
)

Natija:

Natija: 30

Lambda sintaksisi¶

Umumiy ko‘rinish:

lambda parametrlar: ifoda

Masalan:

kvadrat = lambda son: son * son

Foydalanish:

natija = kvadrat(
    5
)

print(
    f"Kvadrat: {natija}"
)

Natija:

Kvadrat: 25

Lambda va `return`¶

Lambda ichida alohida return yozilmaydi.

Noto‘g‘ri:

kvadrat = lambda son:
    return son * son

To‘g‘ri:

kvadrat = lambda son: son * son

Lambda ifodaning natijasini avtomatik qaytaradi.

Bir nechta parametr¶

Lambda bir nechta parametr qabul qilishi mumkin.

kopaytirish = lambda birinchi_son, ikkinchi_son: (
    birinchi_son * ikkinchi_son
)

Foydalanish:

natija = kopaytirish(
    6,
    7
)

print(
    f"Natija: {natija}"
)

Natija:

Natija: 42

Shartli lambda¶

Lambda ichida shartli ifodadan foydalanish mumkin.

katta_son = lambda birinchi_son, ikkinchi_son: (
    birinchi_son
    if birinchi_son > ikkinchi_son
    else ikkinchi_son
)

Foydalanish:

natija = katta_son(
    25,
    18
)

print(
    f"Katta son: {natija}"
)

Natija:

Katta son: 25

Lambda qachon ishlatiladi?¶

Lambda odatda qisqa va oddiy funksiyalar kerak bo‘lganda ishlatiladi.

Masalan:

sonlar = [
    1,
    2,
    3,
    4,
    5
]

kvadratlar = list(
    map(
        lambda son: son * son,
        sonlar
    )
)

print(
    f"Kvadratlar: {kvadratlar}"
)

Natija:

Kvadratlar: [1, 4, 9, 16, 25]

`map()`¶

map() berilgan funksiyani ketma-ketlikdagi har bir elementga qo‘llaydi.

Umumiy ko‘rinish:

map(
    funksiya,
    ketma_ketlik
)

Masalan:

sonlar = [
    1,
    2,
    3,
    4,
    5
]

kvadratlar = map(
    lambda son: son * son,
    sonlar
)

print(
    list(kvadratlar)
)

Natija:

[1, 4, 9, 16, 25]

`map()` qanday ishlaydi?¶

Quyidagi:

kvadratlar = map(
    lambda son: son * son,
    sonlar
)

mantiqan:

natijasini hosil qiladi.

`map()` va oddiy `for`¶

Quyidagi kod:

sonlar = [
    1,
    2,
    3,
    4,
    5
]

kvadratlar = []

for son in sonlar:

    kvadratlar.append(
        son * son
    )

map() yordamida:

sonlar = [
    1,
    2,
    3,
    4,
    5
]

kvadratlar = list(
    map(
        lambda son: son * son,
        sonlar
    )
)

Ikkala kod ham bir xil natija beradi.

`map()` bilan matnlar¶

ismlar = [
    "ali",
    "vali",
    "sami"
]

katta_ismlar = list(
    map(
        lambda ism: ism.upper(),
        ismlar
    )
)

print(
    katta_ismlar
)

Natija:

['ALI', 'VALI', 'SAMI']

`map()` bilan bir nechta ketma-ketlik¶

map() bir nechta ketma-ketlik bilan ham ishlashi mumkin.

birinchi_sonlar = [
    10,
    20,
    30
]

ikkinchi_sonlar = [
    1,
    2,
    3
]

natijalar = list(
    map(
        lambda birinchi_son, ikkinchi_son: (
            birinchi_son + ikkinchi_son
        ),
        birinchi_sonlar,
        ikkinchi_sonlar
    )
)

print(
    natijalar
)

Natija:

[11, 22, 33]

`filter()`¶

filter() berilgan shartga mos keladigan elementlarni tanlab oladi.

Umumiy ko‘rinish:

filter(
    funksiya,
    ketma_ketlik
)

Masalan, juft sonlarni ajratamiz:

sonlar = [
    1,
    2,
    3,
    4,
    5,
    6
]

juft_sonlar = list(
    filter(
        lambda son: son % 2 == 0,
        sonlar
    )
)

print(
    f"Juft sonlar: {juft_sonlar}"
)

Natija:

Juft sonlar: [2, 4, 6]

`filter()` qanday ishlaydi?¶

Quyidagi:

lambda son: son % 2 == 0

har bir son uchun True yoki False qaytaradi.

1 → False
2 → True
3 → False
4 → True
5 → False
6 → True

Faqat True bo‘lgan elementlar saqlanadi.

Musbat sonlarni tanlash¶

sonlar = [
    -5,
    10,
    -3,
    8,
    0,
    15
]

musbat_sonlar = list(
    filter(
        lambda son: son > 0,
        sonlar
    )
)

print(
    f"Musbat sonlar: {musbat_sonlar}"
)

Natija:

Musbat sonlar: [10, 8, 15]

Matnlarni filtrlash¶

ismlar = [
    "Ali",
    "Vali",
    "Sami",
    "Aziz",
    "Bobur"
]

uzun_ismlar = list(
    filter(
        lambda ism: len(ism) > 4,
        ismlar
    )
)

print(
    f"Uzun ismlar: {uzun_ismlar}"
)

Natija:

Uzun ismlar: ['Vali', 'Sami', 'Aziz', 'Bobur']

Bu misolda len(ism) > 4 sharti ishlatilmoqda.

`map()` va `filter()` birga¶

Ularni birlashtirish mumkin.

sonlar = [
    1,
    2,
    3,
    4,
    5,
    6,
    7,
    8
]

juft_sonlar = filter(
    lambda son: son % 2 == 0,
    sonlar
)

kvadratlar = map(
    lambda son: son * son,
    juft_sonlar
)

natija = list(
    kvadratlar
)

print(
    f"Natija: {natija}"
)

Natija:

Natija: [4, 16, 36, 64]

Avval:

juft sonlar

tanlandi.

Keyin:

ularning kvadratlari

hisoblandi.

`reduce()`¶

reduce() ketma-ketlikdagi elementlarni bosqichma-bosqich birlashtirib, yakuniy bitta qiymat hosil qiladi.

reduce() funksiyasi functools modulida joylashgan.

from functools import reduce

Masalan:

sonlar = [
    1,
    2,
    3,
    4,
    5
]

yigindi = reduce(
    lambda birinchi_son, ikkinchi_son: (
        birinchi_son + ikkinchi_son
    ),
    sonlar
)

print(
    f"Yig‘indi: {yigindi}"
)

Natija:

Yig‘indi: 15

`reduce()` qanday ishlaydi?¶

Quyidagi:

mantiqan:

1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15

natijasini beradi.

`reduce()` bilan ko‘paytirish¶

from functools import reduce


sonlar = [
    1,
    2,
    3,
    4,
    5
]

kopaytma = reduce(
    lambda birinchi_son, ikkinchi_son: (
        birinchi_son * ikkinchi_son
    ),
    sonlar
)

print(
    f"Ko‘paytma: {kopaytma}"
)

Natija:

Ko‘paytma: 120

`reduce()` uchun boshlang‘ich qiymat¶

Uchinchi argument orqali boshlang‘ich qiymat berish mumkin.

from functools import reduce


sonlar = [
    10,
    20,
    30
]

yigindi = reduce(
    lambda birinchi_son, ikkinchi_son: (
        birinchi_son + ikkinchi_son
    ),
    sonlar,
    100
)

print(
    f"Natija: {yigindi}"
)

Natija:

Natija: 160

Hisoblash:

100 + 10 + 20 + 30 = 160

`sorted()`¶

sorted() ketma-ketlikni tartiblaydi.

sonlar = [
    50,
    10,
    40,
    20,
    30
]

tartiblangan_sonlar = sorted(
    sonlar
)

print(
    f"Tartiblangan sonlar: {tartiblangan_sonlar}"
)

Natija:

Tartiblangan sonlar: [10, 20, 30, 40, 50]

Teskari tartiblash¶

reverse=True yordamida kamayish tartibida tartiblash mumkin.

sonlar = [
    10,
    50,
    20,
    40,
    30
]

tartiblangan_sonlar = sorted(
    sonlar,
    reverse=True
)

print(
    f"Teskari tartib: {tartiblangan_sonlar}"
)

Natija:

Teskari tartib: [50, 40, 30, 20, 10]

`sorted()` va `sort()`¶

Ikkalasi o‘xshash bo‘lsa ham, farqi bor.

sort() listning o‘zini o‘zgartiradi:

sonlar = [
    30,
    10,
    20
]

sonlar.sort()

print(
    sonlar
)

sorted() esa yangi tartiblangan obyekt qaytaradi:

sonlar = [
    30,
    10,
    20
]

tartiblangan_sonlar = sorted(
    sonlar
)

print(
    tartiblangan_sonlar
)

print(
    sonlar
)

Natija:

[10, 20, 30]
[30, 10, 20]

`key`¶

sorted()ning eng foydali imkoniyatlaridan biri key parametridir.

Masalan, ismlarni uzunligiga qarab tartiblaymiz:

ismlar = [
    "Ali",
    "Softromeda",
    "Vali",
    "Sardor",
    "Bobur"
]

tartiblangan_ismlar = sorted(
    ismlar,
    key=lambda ism: len(ism)
)

print(
    f"Tartiblangan ismlar: {tartiblangan_ismlar}"
)

Natija:

Tartiblangan ismlar: ['Ali', 'Vali', 'Bobur', 'Sardor', 'Softromeda']

`key` qanday ishlaydi?¶

Quyidagi:

key=lambda ism: len(ism)

har bir element uchun tartiblash qiymatini hisoblaydi.

Masalan:

Ali        → 3
Vali       → 4
Bobur      → 5
Sardor     → 6
Softromeda → 10

Keyin shu qiymatlar bo‘yicha tartiblanadi.

Lug‘atlarni tartiblash¶

Quyidagi foydalanuvchilar ro‘yxatini olaylik:

foydalanuvchilar = [
    {
        "ism": "Ali",
        "yosh": 30
    },
    {
        "ism": "Vali",
        "yosh": 22
    },
    {
        "ism": "Sami",
        "yosh": 27
    }
]

Yosh bo‘yicha tartiblash:

tartiblangan_foydalanuvchilar = sorted(
    foydalanuvchilar,
    key=lambda foydalanuvchi: foydalanuvchi["yosh"]
)

for foydalanuvchi in tartiblangan_foydalanuvchilar:

    print(
        f"{foydalanuvchi['ism']} - "
        f"{foydalanuvchi['yosh']} yosh"
    )

Natija:

Vali - 22 yosh
Sami - 27 yosh
Ali - 30 yosh

Yosh bo‘yicha kamayish tartibi¶

tartiblangan_foydalanuvchilar = sorted(
    foydalanuvchilar,
    key=lambda foydalanuvchi: foydalanuvchi["yosh"],
    reverse=True
)

for foydalanuvchi in tartiblangan_foydalanuvchilar:

    print(
        f"{foydalanuvchi['ism']} - "
        f"{foydalanuvchi['yosh']} yosh"
    )

Natija:

Ali - 30 yosh
Sami - 27 yosh
Vali - 22 yosh

`key` bilan `max()`¶

key faqat sorted() bilan ishlatilmaydi.

max() bilan ham foydalanish mumkin.

foydalanuvchilar = [
    {
        "ism": "Ali",
        "yosh": 30
    },
    {
        "ism": "Vali",
        "yosh": 22
    },
    {
        "ism": "Sami",
        "yosh": 27
    }
]

eng_katta_foydalanuvchi = max(
    foydalanuvchilar,
    key=lambda foydalanuvchi: foydalanuvchi["yosh"]
)

print(
    f"Eng katta foydalanuvchi: "
    f"{eng_katta_foydalanuvchi['ism']}"
)

Natija:

Eng katta foydalanuvchi: Ali

`key` bilan `min()`¶

eng_kichik_foydalanuvchi = min(
    foydalanuvchilar,
    key=lambda foydalanuvchi: foydalanuvchi["yosh"]
)

print(
    f"Eng kichik foydalanuvchi: "
    f"{eng_kichik_foydalanuvchi['ism']}"
)

Natija:

Eng kichik foydalanuvchi: Vali

Funksiyani boshqa funksiyaga berish¶

Python'da funksiya oddiy qiymat kabi boshqa funksiyaga uzatilishi mumkin.

def qoshish(
    birinchi_son,
    ikkinchi_son
):

    return (
        birinchi_son
        + ikkinchi_son
    )


def amal_bajarish(
    funksiya,
    birinchi_son,
    ikkinchi_son
):

    return funksiya(
        birinchi_son,
        ikkinchi_son
    )


natija = amal_bajarish(
    qoshish,
    10,
    20
)

print(
    f"Natija: {natija}"
)

Natija:

Natija: 30

Funksiyani qaytarish¶

Funksiya boshqa funksiyani ham qaytarishi mumkin.

def kopaytiruvchi_yaratish(
    kopaytiruvchi
):

    def kopaytirish(
        son
    ):

        return son * kopaytiruvchi

    return kopaytirish

Endi:

ikki_baravar = kopaytiruvchi_yaratish(
    2
)

uch_baravar = kopaytiruvchi_yaratish(
    3
)

print(
    f"Ikki baravar: {ikki_baravar(10)}"
)

print(
    f"Uch baravar: {uch_baravar(10)}"
)

Natija:

Ikki baravar: 20
Uch baravar: 30

Birinchi darajali funksiyalar¶

Python'da funksiyalar birinchi darajali obyektlar hisoblanadi.

Bu quyidagilarni anglatadi:

funksiyani o‘zgaruvchiga biriktirish mumkin
funksiyani argument sifatida berish mumkin
funksiyani boshqa funksiyadan qaytarish mumkin
funksiyani ma’lumotlar tuzilmasida saqlash mumkin

Masalan:

def salomlash():

    print(
        "Salom, Softromeda!"
    )


amal = salomlash

amal()

Natija:

Salom, Softromeda!

Funksiyalarni ro‘yxatda saqlash¶

def qoshish(
    birinchi_son,
    ikkinchi_son
):

    return (
        birinchi_son
        + ikkinchi_son
    )


def ayirish(
    birinchi_son,
    ikkinchi_son
):

    return (
        birinchi_son
        - ikkinchi_son
    )


def kopaytirish(
    birinchi_son,
    ikkinchi_son
):

    return (
        birinchi_son
        * ikkinchi_son
    )


amallar = [
    qoshish,
    ayirish,
    kopaytirish
]

for amal in amallar:

    natija = amal(
        10,
        5
    )

    print(
        f"Natija: {natija}"
    )

Natija:

Natija: 15
Natija: 5
Natija: 50

Funksional dasturlash¶

Funksional dasturlash — dastur mantig‘ini funksiyalar yordamida tashkil qilishga e’tibor beradigan dasturlash uslubidir.

Asosiy g‘oyalar:

funksiyalar
sof funksiyalar
o‘zgarmas ma’lumotlarga intilish
funksiyalarni qiymat sifatida ishlatish
ma’lumotlarni transformatsiya qilish

Sof funksiya¶

Sof funksiya bir xil argumentlar uchun doimo bir xil natija qaytaradi va tashqi holatni o‘zgartirmaydi.

Masalan:

def kvadrat(
    son
):

    return son * son

Bu sof funksiyaga yaxshi misol.

print(
    kvadrat(5)
)

print(
    kvadrat(5)
)

Har ikkala natija ham:

bo‘ladi.

Tashqi holatga bog‘liq funksiya¶

Quyidagi funksiya tashqi o‘zgaruvchiga bog‘liq:

soliq = 0.12


def narxni_hisoblash(
    narx
):

    return narx + (
        narx * soliq
    )

Bu funksiya tashqi soliq qiymatidan foydalanmoqda.

Agar soliq o‘zgarsa, funksiya natijasi ham o‘zgaradi.

Ma’lumotni o‘zgartirmaslik¶

Funksional dasturlashda mavjud ma’lumotni bevosita o‘zgartirish o‘rniga yangi qiymat yaratish ko‘pincha qulayroq.

Masalan:

sonlar = [
    1,
    2,
    3,
    4
]

kvadratlar = list(
    map(
        lambda son: son * son,
        sonlar
    )
)

print(
    f"Asl sonlar: {sonlar}"
)

print(
    f"Kvadratlar: {kvadratlar}"
)

Natija:

Asl sonlar: [1, 2, 3, 4]
Kvadratlar: [1, 4, 9, 16]

Asl ro‘yxat o‘zgarmadi.

`map()`, `filter()` va `reduce()` birgalikda¶

Murakkabroq misol:

from functools import reduce


sonlar = [
    1,
    2,
    3,
    4,
    5,
    6,
    7,
    8,
    9,
    10
]

juft_sonlar = filter(
    lambda son: son % 2 == 0,
    sonlar
)

kvadratlar = map(
    lambda son: son * son,
    juft_sonlar
)

yigindi = reduce(
    lambda birinchi_son, ikkinchi_son: (
        birinchi_son + ikkinchi_son
    ),
    kvadratlar
)

print(
    f"Natija: {yigindi}"
)

Natija:

Natija: 220

Jarayon:

1, 2, 3, ..., 10
        ↓
juft sonlar
        ↓
2, 4, 6, 8, 10
        ↓
kvadratlar
        ↓
4, 16, 36, 64, 100
        ↓
yig‘indi
        ↓
220

Lambda bilan `sorted()` va `filter()`¶

Amaliy misol:

foydalanuvchilar = [
    {
        "ism": "Ali",
        "yosh": 17
    },
    {
        "ism": "Vali",
        "yosh": 25
    },
    {
        "ism": "Sami",
        "yosh": 31
    },
    {
        "ism": "Aziz",
        "yosh": 19
    }
]

voyaga_yetganlar = filter(
    lambda foydalanuvchi: foydalanuvchi["yosh"] >= 18,
    foydalanuvchilar
)

tartiblangan_foydalanuvchilar = sorted(
    voyaga_yetganlar,
    key=lambda foydalanuvchi: foydalanuvchi["yosh"]
)

for foydalanuvchi in tartiblangan_foydalanuvchilar:

    print(
        f"{foydalanuvchi['ism']} - "
        f"{foydalanuvchi['yosh']} yosh"
    )

Natija:

Aziz - 19 yosh
Vali - 25 yosh
Sami - 31 yosh

Lambda'dan haddan tashqari foydalanish¶

Lambda foydali bo‘lsa ham, uni har joyda ishlatish kerak emas.

Masalan:

natija = lambda birinchi_son, ikkinchi_son, uchinchi_son: (
    (
        birinchi_son * ikkinchi_son
    )
    + uchinchi_son
)

Bu juda murakkablashsa, oddiy funksiya yaxshiroq:

def hisoblash(
    birinchi_son,
    ikkinchi_son,
    uchinchi_son
):

    kopaytma = (
        birinchi_son
        * ikkinchi_son
    )

    return (
        kopaytma
        + uchinchi_son
    )

Qisqa qoida:

oddiy amal
    → lambda

murakkab mantiq
    → def

Funksional uslub va `for`¶

Ba’zi vazifalarda map() va filter() kodni ixchamlashtiradi.

Masalan:

sonlar = [
    1,
    2,
    3,
    4,
    5
]

natija = list(
    map(
        lambda son: son * 10,
        sonlar
    )
)

Oddiy for bilan:

sonlar = [
    1,
    2,
    3,
    4,
    5
]

natija = []

for son in sonlar:

    natija.append(
        son * 10
    )

Ikkala yondashuv ham to‘g‘ri.

Qaysi biri tushunarliroq bo‘lsa, o‘sha variantni tanlash kerak.

List comprehension bilan taqqoslash¶

Python'da map() va filter() o‘rniga ko‘pincha list comprehension ham ishlatiladi.

map():

sonlar = [
    1,
    2,
    3,
    4,
    5
]

kvadratlar = list(
    map(
        lambda son: son * son,
        sonlar
    )
)

List comprehension:

sonlar = [
    1,
    2,
    3,
    4,
    5
]

kvadratlar = [
    son * son
    for son in sonlar
]

Ko‘p hollarda ikkinchi variant Python dasturchilari uchun tabiiyroq ko‘rinadi.

`filter()` va list comprehension¶

filter():

juft_sonlar = list(
    filter(
        lambda son: son % 2 == 0,
        sonlar
    )
)

List comprehension:

juft_sonlar = [
    son
    for son in sonlar
    if son % 2 == 0
]

Bu yerda ham ikkala usuldan foydalanish mumkin.

Qachon funksional uslubdan foydalanish kerak?¶

Funksional uslub ayniqsa quyidagi holatlarda foydali:

ma’lumotlarni o‘zgartirish
ma’lumotlarni filtrlash
tartiblash
funksiyalarni boshqa funksiyalarga uzatish
ketma-ket hisoblash

Masalan:

mahsulotlar = [
    {
        "nom": "Noutbuk",
        "narx": 800
    },
    {
        "nom": "Telefon",
        "narx": 500
    },
    {
        "nom": "Quloqchin",
        "narx": 100
    }
]

qimmat_mahsulotlar = list(
    filter(
        lambda mahsulot: mahsulot["narx"] > 300,
        mahsulotlar
    )
)

nomlar = list(
    map(
        lambda mahsulot: mahsulot["nom"],
        qimmat_mahsulotlar
    )
)

print(
    f"Qimmat mahsulotlar: {nomlar}"
)

Natija:

Qimmat mahsulotlar: ['Noutbuk', 'Telefon']

Amaliy loyiha — Softromeda mahsulot tahlili¶

Quyidagi dastur mahsulotlarni filtrlab, narxlarni o‘zgartiradi va tartiblaydi.

mahsulotlar = [
    {
        "nom": "Noutbuk",
        "narx": 800,
        "omborda": True
    },
    {
        "nom": "Telefon",
        "narx": 500,
        "omborda": True
    },
    {
        "nom": "Quloqchin",
        "narx": 100,
        "omborda": False
    },
    {
        "nom": "Monitor",
        "narx": 300,
        "omborda": True
    }
]

mavjud_mahsulotlar = list(
    filter(
        lambda mahsulot: mahsulot["omborda"],
        mahsulotlar
    )
)

narxlar = list(
    map(
        lambda mahsulot: mahsulot["narx"],
        mavjud_mahsulotlar
    )
)

tartiblangan_narxlar = sorted(
    narxlar,
    reverse=True
)

print(
    f"Mavjud mahsulotlar soni: "
    f"{len(mavjud_mahsulotlar)}"
)

print(
    f"Narxlar: {tartiblangan_narxlar}"
)

Natija:

Mavjud mahsulotlar soni: 3
Narxlar: [800, 500, 300]

Amaliy mashqlar¶

Mashq 1¶

lambda yordamida sonning kubini hisoblang.

3 → 27
5 → 125

Mashq 2¶

map() yordamida quyidagi sonlarning kvadratlarini toping:

1, 2, 3, 4, 5, 6

Mashq 3¶

filter() yordamida 10 dan katta sonlarni ajrating.

Mashq 4¶

filter() yordamida manfiy sonlarni ajrating.

Mashq 5¶

reduce() yordamida quyidagi sonlarning yig‘indisini toping:

10, 20, 30, 40, 50

Mashq 6¶

reduce() yordamida quyidagi sonlarning ko‘paytmasini toping:

2, 3, 4, 5

Mashq 7¶

sorted() va key yordamida ismlarni uzunligi bo‘yicha tartiblang.

Mashq 8¶

Foydalanuvchilarni yosh bo‘yicha tartiblang.

Mashq 9¶

Mahsulotlarni narxi bo‘yicha kamayish tartibida tartiblang.

Mashq 10¶

filter() va map()ni birgalikda ishlatib, faqat juft sonlarning kvadratlarini hisoblang.

Bob xulosasi¶

Bu bobda funksional dasturlashning asosiy vositalarini o‘rgandik.

`lambda`¶

Qisqa anonim funksiyalar:

kvadrat = lambda son: son * son

`map()`¶

Har bir elementga funksiya qo‘llaydi:

map(
    lambda son: son * 2,
    sonlar
)

`filter()`¶

Shartga mos elementlarni tanlaydi:

filter(
    lambda son: son > 0,
    sonlar
)

`reduce()`¶

Elementlarni ketma-ket birlashtirib, bitta natija hosil qiladi:

reduce(
    lambda birinchi_son, ikkinchi_son: (
        birinchi_son + ikkinchi_son
    ),
    sonlar
)

`sorted()` va `key`¶

Ma’lumotlarni kerakli mezon bo‘yicha tartiblaydi:

sorted(
    foydalanuvchilar,
    key=lambda foydalanuvchi: foydalanuvchi["yosh"]
)

Eng muhim tushuncha — Python'da funksiyalar ham qiymat sifatida ishlatilishi mumkin.

Keyingi bobda 14. Regular Expression — muntazam ifodalar mavzusini o‘rganamiz.

Tugmalar	Amal
`?`	Yordam oynasini ochish
`n`	Keyingi sahifa
`p`	Oldingi sahifa
`s`	Izlash

13. Lambda funksiyalar va funksional dasturlash¶

Lambda nima?¶

Lambda sintaksisi¶

Lambda va return¶

Bir nechta parametr¶

Shartli lambda¶

Lambda qachon ishlatiladi?¶

map()¶

map() qanday ishlaydi?¶

map() va oddiy for¶

map() bilan matnlar¶

map() bilan bir nechta ketma-ketlik¶

filter()¶

filter() qanday ishlaydi?¶

Musbat sonlarni tanlash¶

Matnlarni filtrlash¶

map() va filter() birga¶

reduce()¶

reduce() qanday ishlaydi?¶

reduce() bilan ko‘paytirish¶

reduce() uchun boshlang‘ich qiymat¶

sorted()¶

Teskari tartiblash¶

sorted() va sort()¶

key¶

key qanday ishlaydi?¶

Lug‘atlarni tartiblash¶

Yosh bo‘yicha kamayish tartibi¶

key bilan max()¶

key bilan min()¶

Funksiyani boshqa funksiyaga berish¶

Funksiyani qaytarish¶

Birinchi darajali funksiyalar¶

Funksiyalarni ro‘yxatda saqlash¶

Funksional dasturlash¶

Sof funksiya¶

Tashqi holatga bog‘liq funksiya¶

Ma’lumotni o‘zgartirmaslik¶

map(), filter() va reduce() birgalikda¶

Lambda bilan sorted() va filter()¶

Lambda'dan haddan tashqari foydalanish¶

Funksional uslub va for¶

List comprehension bilan taqqoslash¶

filter() va list comprehension¶

Qachon funksional uslubdan foydalanish kerak?¶

Amaliy loyiha — Softromeda mahsulot tahlili¶

Amaliy mashqlar¶

Mashq 1¶

Mashq 2¶

Mashq 3¶

Mashq 4¶

Mashq 5¶

Mashq 6¶

Mashq 7¶

Mashq 8¶

Mashq 9¶

Mashq 10¶

Bob xulosasi¶

lambda¶

map()¶

filter()¶

reduce()¶

sorted() va key¶

Lambda va `return`¶

`map()`¶

`map()` qanday ishlaydi?¶

`map()` va oddiy `for`¶

`map()` bilan matnlar¶

`map()` bilan bir nechta ketma-ketlik¶

`filter()`¶

`filter()` qanday ishlaydi?¶

`map()` va `filter()` birga¶

`reduce()`¶

`reduce()` qanday ishlaydi?¶

`reduce()` bilan ko‘paytirish¶

`reduce()` uchun boshlang‘ich qiymat¶

`sorted()`¶

`sorted()` va `sort()`¶

`key`¶

`key` qanday ishlaydi?¶

`key` bilan `max()`¶

`key` bilan `min()`¶

`map()`, `filter()` va `reduce()` birgalikda¶

Lambda bilan `sorted()` va `filter()`¶

Funksional uslub va `for`¶

`filter()` va list comprehension¶

`lambda`¶

`map()`¶

`filter()`¶

`reduce()`¶

`sorted()` va `key`¶