*args, **kwargs, ko'rinish sohasi va lambda

14-bob 21 kod bloki 1744 so'z

*args: istalgancha argument

print() ga bitta ham, o'nta ham qiymat berish mumkin. O'z funksiyamiz ham shunday bo'lishi uchun parametr oldiga * qo'yiladi:

def pitsa(*qoshimchalar):
    print(f"Pitsa: {len(qoshimchalar)} ta qo'shimcha")
    for q in qoshimchalar:
        print(f"  - {q}")

pitsa("pishloq")
pitsa("qo'ziqorin", "qalampir", "zaytun")

Pitsa: 1 ta qo'shimcha
  - pishloq
Pitsa: 3 ta qo'shimcha
  - qo'ziqorin
  - qalampir
  - zaytun

*qoshimchalar — barcha argumentlarni bitta kortejga yig'adi. Nomi istalgan bo'lishi mumkin, lekin an'anaviy nomi — *args.

Oddiy parametrlar bilan birga ishlatilsa, *args oxirida turadi:

def pitsa(olcham, *qoshimchalar):
    print(f"{olcham} sm li pitsa: {', '.join(qoshimchalar)}")

pitsa(25, "pishloq")
pitsa(35, "qo'ziqorin", "qalampir", "zaytun")

25 sm li pitsa: pishloq
35 sm li pitsa: qo'ziqorin, qalampir, zaytun

Birinchi argument olcham ga tushdi, qolganlari qoshimchalar ga yig'ildi.

def ortacha(*sonlar):
    if not sonlar:
        return 0
    return sum(sonlar) / len(sonlar)

print(ortacha(5, 4, 5))
print(ortacha(3))
print(ortacha())

4.666666666666667
3.0
0

**kwargs: istalgancha nomli argument

** — barcha nomli argumentlarni lug'atga yig'adi:

def profil(ism, familiya, **malumot):
    malumot["ism"] = ism
    malumot["familiya"] = familiya
    return malumot

p = profil("abulqosim", "rafiqov", shahar="Toshkent", soha="AI")
print(p)

{'shahar': 'Toshkent', 'soha': 'AI', 'ism': 'abulqosim', 'familiya': 'rafiqov'}

shahar va soha parametrlari funksiyada yo'q edi — ular malumot lug'atiga tushdi. An'anaviy nomi — **kwargs (keyword arguments).

Tartib qoidasi: def f(oddiy, standart=1, *args, **kwargs).

* va ** chaqiruvda: ochish

Teskari yo'nalishda ham ishlaydi: ro'yxatni * bilan, lug'atni ** bilan alohida argumentlarga ochib berish mumkin (12-bobdagi print(*r) aynan shu):

def uchburchak_perimetri(a, b, c):
    return a + b + c

tomonlar = [3, 4, 5]
print(uchburchak_perimetri(*tomonlar))
sozlama = {"a": 6, "b": 8, "c": 10}
print(uchburchak_perimetri(**sozlama))

12
24

Ko'rinish sohasi: lokal va global

Funksiya ichida yaratilgan o'zgaruvchi faqat o'sha funksiya ichida yashaydi. U lokal (local) o'zgaruvchi:

def hisobla():
    natija = 42

hisobla()
print(natija)

NameError: name 'natija' is not defined

Funksiya tugaganda natija yo'qoladi. Natija tashqarida kerak bo'lsa — return qiling (13-bob).

Funksiyadan tashqarida yaratilgan o'zgaruvchi — global. Funksiya uni o'qiy oladi:

KURS = "Python asoslari"

def sarlavha():
    print(f"=== {KURS} ===")

sarlavha()

=== Python asoslari ===

Lekin funksiya ichida xuddi shu nomga qiymat bersangiz, Python yangi lokal o'zgaruvchi yaratadi, global o'zgarmaydi:

meva = "olma"

def ozgartir():
    meva = "anor"
    print("ichkarida:", meva)

ozgartir()
print("tashqarida:", meva)

ichkarida: anor
tashqarida: olma

Globalni o'zgartirish uchun global kalit so'zi bor:

hisoblagich = 0

def bosildi():
    global hisoblagich
    hisoblagich += 1

bosildi()
bosildi()
bosildi()
print(hisoblagich)

3

def bosildi(hisoblagich):
    return hisoblagich + 1

h = 0
h = bosildi(h)
h = bosildi(h)
print(h)

2

lambda: bitta qatorli funksiya

Ba'zan funksiya juda kichik va faqat bir joyda kerak bo'ladi. Uni def bilan yozmasdan, lambda bilan joyida yasash mumkin:

kvadrat = lambda x: x * x
print(kvadrat(7))

49

lambda x: x * x — "x ni oladi, x * x ni qaytaradi". return yozilmaydi, faqat bitta ifoda bo'ladi.

lambda ning asosiy joyi — sorted(), max(), min() ning key parametri (10-bobda ko'rgan edik):

talabalar = [("Ali", 78), ("Sarvinoz", 91), ("Otabek", 85)]
print(sorted(talabalar, key=lambda t: t[1]))
print(sorted(talabalar, key=lambda t: t[1], reverse=True))
print(max(talabalar, key=lambda t: t[1]))

sozlar = ["olma", "Python", "uy", "dasturlash"]
print(sorted(sozlar, key=lambda s: len(s)))

[('Ali', 78), ('Otabek', 85), ('Sarvinoz', 91)]
[('Sarvinoz', 91), ('Otabek', 85), ('Ali', 78)]
('Sarvinoz', 91)
['uy', 'olma', 'Python', 'dasturlash']

Lug'atlar ro'yxatini tartiblash ham shunday:

talabalar = [
    {"ism": "Ali", "ball": 78},
    {"ism": "Sarvinoz", "ball": 91},
    {"ism": "Otabek", "ball": 85},
]
for t in sorted(talabalar, key=lambda t: t["ball"], reverse=True):
    print(f"{t['ism']:<10}{t['ball']}")

Sarvinoz  91
Otabek    85
Ali       78

map va filter

map() — har bir elementga funksiyani qo'llaydi, filter() — shartga mos elementlarni qoldiradi:

sonlar = [1, 2, 3, 4, 5, 6]
print(list(map(lambda x: x * 10, sonlar)))
print(list(filter(lambda x: x % 2 == 0, sonlar)))
print([x * 10 for x in sonlar])
print([x for x in sonlar if x % 2 == 0])

[10, 20, 30, 40, 50, 60]
[2, 4, 6]
[10, 20, 30, 40, 50, 60]
[2, 4, 6]

Natija bir xil. Pythonda comprehension (12-bob) odatda o'qishga osonroq hisoblanadi, lekin map va filter ni boshqalarning kodida ko'p uchratasiz. Masalan, sonlar qatorini o'qishning mashhur yo'li: list(map(int, input().split())).

def qosh(element, royxat=[]):
    royxat.append(element)
    return royxat

print(qosh("a"))
print(qosh("b"))
print(qosh("c"))

['a']
['a', 'b']
['a', 'b', 'c']

def qosh(element, royxat=None):
    if royxat is None:
        royxat = []
    royxat.append(element)
    return royxat

print(qosh("a"))
print(qosh("b"))

['a']
['b']

Xulosa

• *args — ortiqcha argumentlar kortejga, **kwargs — nomli argumentlar lug'atga.
• Chaqiruvda f(*royxat), f(**lugat) — ochib berish.
• Funksiya ichidagi o'zgaruvchi lokal; natijani return bilan chiqaring, global dan qoching.
• lambda x: ifoda — key= uchun qisqa funksiya.
• Standart qiymat sifatida [] emas, None.

Mashqlar

def ortacha(*sonlar):
    return sum(sonlar) / len(sonlar) if sonlar else 0

print(ortacha(*[float(s) for s in input().split()]))

def eng_uzun(*sozlar):
    return max(sozlar, key=len)

print(eng_uzun(*input().split()))

n = int(input())
talabalar = []
for _ in range(n):
    ism, ball = input().split()
    talabalar.append((ism, int(ball)))
for ism, ball in sorted(talabalar, key=lambda t: t[1], reverse=True):
    print(ism, ball)

print(*sorted(input().split(), key=lambda s: (len(s), s)))

def hisobot(**baholar):
    return f"{sum(baholar.values()) / len(baholar):.2f}"

juftlar = {}
for q in input().split():
    fan, baho = q.split("=")
    juftlar[fan] = int(baho)
print(hisobot(**juftlar))