Print("Assalom alaykum")

# Foydalanuvchi ismi va yoshini so'rab, uning tug'ilgan yilini hisoblaydigan funksiya yozing.
def tyiltop(ism, yosh):
print(f"{ism.title()} {2020-yosh} yoshda")


tyiltop('olim',2002)
Olim 18 yoshda
In [31]:
# Foydalanuvchidan son olib, uning kvadrati va kubini konsolga chiqaruvchi funksiya yozing.
def kv_kub(son):
"""Kiritilgan sonning kvadrati va kubini konsolga chiqaruvchi funksiya"""
print(f"{son} ning kvadrati {son**2} ga, kubi {son**3} ga teng")


kv_kub(-4)
-4 ning kvadrati 16 ga, kubi -64 ga teng
In [32]:
# Foydalanuvchidan son olib, son juft yoki toqligini konsolga chiqaruvchi funksiya yozing.
def juftmi(son):
"""Kiritilgan son juft yoki toqligini konsolga chiqaruvchi funksiya"""
if son%2:
print(f"{son} toq son")
else:
print(f"{son} juft son")


juftmi(20)
juftmi(123)
20 juft son 123 toq son
In [33]:
# Foydalanuvchidan ikkita son olib, ulardan kattasini konsolga chiqaruvchi funksiya yozing.
# Agar sonlar teng bo'lsa "Sonlar teng" degan xabarni chiqaring.
def solishtir(x,y):
"""Ikki sonni solishtiruvchi funksiya"""
if x>y:
print(f"{x}>{y}")
elif x print(f"{y}>{x}")
else:
print(f"{x}={y}")


solishtir(10,20)
solishtir(-9,12)
solishtir(1223*5,5**4)
20>10 12>-9 6115>625
In [34]:
# Foydalanuvchidan x va y sonlarini olib, x^y ni konsolga chiqaruvchi funksiya yozing.
# Yuqoridagi funksiyada y uchun 2 standart qiymatini bering.
def daraja(x,y=2):
print(f"{x} ning {y}-darajasi {x**y} ga teng")


daraja(5,2)
daraja(3,3)
daraja(94,4)
daraja(6)
5 ning 2-darajasi 25 ga teng 3 ning 3-darajasi 27 ga teng 94 ning 4-darajasi 78074896 ga teng 6 ning 2-darajasi 36 ga teng
In [35]:
# Foydalanuvchidan son qabul qilib, sonni 2, 3, 4 va 5 ga qoldiqsiz bo'linishini tekshiruvchi
# funksiya yozing.
# Natijalarni konsolga chiqaring ("15 soni 3 ga qoldiqsiz bo'linadi" ko'rinishida)
def bolinish_alomatlari(son):
for n in range(2,11):
if not son%n:
print(f"{son} {n} ga qoldiqsiz bo'linadi")


bolinish_alomatlari(20)
20 2 ga qoldiqsiz bo'linadi 20 4 ga qoldiqsiz bo'linadi 20 5 ga qoldiqsiz bo'linadi 20 10 ga qoldiqsiz bo'linadi

20-DARS. QIYMAT QAYTARUVCHI FUNKSIYA
Funksiyadan qiymat qaytarishni o'rganamiz

Avvalgi darsimizda yaratgan barcha funksiyalarimiz konsolga ma'lumot chiqarayotgan edi. Aslida, aksar holatlarda bu g'ayritabiiy. Sababi, dasturchi sifatida biz konsolga chiqqan ma'lumotdan unumli foydalana olmaymiz. Konsoldagi qiymatni o'zgaruvchiga yuklab, undan kelajakda foydalanib ham bo'lmaydi. Mana shunday holatlarda, funksiyadan unumli foydalanish uchun undan biror qiymatni qaytarish maqsadga muvofiq bo'ladi.
FUNKSIYADAN ODDIY QIYMAT QAYTARISH
Keling ism va familiya degan parametrlarni olib, toliq_ism qaytaradigan sodda funksiya yasaymiz.
In [4]:
def toliq_ism_yasa(ism, familiya):
"""Toliq isma qaytaruvchi funksiya"""
toliq_ism = f"{ism} {familiya}"
return toliq_ism # qiymat qaytarish uchun return operatorini ishlatamiz
Yuqoridagi funksiyamizga ahamiyat bersangiz, uning badanida endi print() funksiyasi yo'q. Buning o'rniga, funksiyamiz return operatori yordamida toliq_ism degan o'zgaruvchining qiymatini qaytaradi.
Endi funksiyadan to'g'ri foydalanish uchun u qaytargan qiymatni biror o'zgaruvchiga yuklashimiz kerak:
In [5]:
talaba1 = toliq_ism_yasa('olim','hakimov')
In [6]:
talaba2 = toliq_ism_yasa('hakim','olimov')
Yuqoridagi kodlarni bajarganimizda konsolga hech narsa chiqmaydi. talaba1 va talaba2 o'zgaruvchilarining qiymatini ko'rish uchun esa print() funksiyasidan foydalanamiz.
In [7]:
print(f"Darsga kelmagan talabalar: {talaba1} va {talaba2}")
Darsga kelmagan talabalar: olim hakimov va hakim olimov
Demak, qiymat qaytaradigan funksiyaning afzalligi shundaki, biz bu qiymatlardan keyin ham bemalol foydalanishimiz mumkin.
Funksiya ichidagi o'zgaruvchilar mahalliy yoki ichki o'zgaruvchilar deyiladi (local variables). Ichki o'zgaruvchilar faqatgina funksiya ichida mavjud bo'ladi, ularga tashqaridan murojat qilib bo'lmaydi. Shuning uchun ham funksiya o'zgaruvchi emas qiymat qaytaradi.
IXTIYORIY ARGUMENTLAR
Avvalgi darsizmida funksiyalarga standart parametr berishni ko'rgan edik. Huddi shu usul bilan, ba'zi argumentlarni ixtiyoriy qilishimiz mumkin. Ya'ni funksiya ishlashi uchun bu agrumentarni kiritish majburiy emas, ixtiyoriy bo'ladi.
Keling avvalgi funksiyamizni o'zgartiramiz va unga yana bitta otasiningismi degan paramter qo'shamiz, lekin bu parametr ixtiyoriy bo'ladi. Buning uchun funksiya yaratishda otasining_ismi='' deb yozib ketamiz.
In [8]:
def toliq_ism_yasa(ism, familiya, otasining_ismi=''):
"""Toliq isma qaytaruvchi funksiya"""
if otasining_ismi: # otasining_ismi mavjudligini tekshiramiz
toliq_ism = f"{ism} {otasining_ismi} {familiya}"
else:
toliq_ism = f"{ism} {familiya}"
return toliq_ism.title()
Yuqoridagi funksiyani tahlil qiladigan bo'lsak, 3-qatorda biz otasiningismi parametri bo'sh yoki yo'qligini tekshiramiz. Pythonda if dan so'ng bo'sh bo'lmagan matn (string) yozsak, bu shart True qaytaradi. Demak, bu ixtiyoriy parametr kiritilgani yoki yo'qligiga qarab, funksiyamiz turlicha qiymat qaytaradi.
In [9]:
talaba1 = toliq_ism_yasa('olim','hakimov') #otasining_ismi kiritilmadi
talaba2 = toliq_ism_yasa('hakim','olimov','abrorovich')
print(f"Darsga kelmagan talabalar: {talaba1} va {talaba2}")
Darsga kelmagan talabalar: Olim Hakimov va Hakim Abrorovich Olimov
FUNKSIYADAN LUG'AT QAYTARAMIZ
Funksiyadan sodda qiymat emas, ro'yxat, lu'gat va boshqa ma'lumot turlarini ham qaytarishimiz mumkin. Quyidagi funksiya ham mashina haqidagi ma'lumotlarni jamlab, ularni lug'at ko'rinishida qaytaradi:
In [10]:
def avto_info(kompaniya, model, rangi, korobka, yili, narhi=None):
avto = {'kompaniya':kompaniya,
'model':model,
'rang':rangi,
'korobka':korobka,
'yil':yili,
'narh':narhi}
return avto
E'tibor bering, narhi nomli parametrga None standart qiymatini berib ketdik. None Pythonda mavjud emas ma'nosini beradi, va if yordamida tekshirganda False mantiqiy qiymatini qaytardi.
Quyidagi kodni tahlil qilishni sizga vazifa sifatida qoldiramiz:
In [11]:
avto1 = avto_info('GM','Malibu','Qora','Avtomat',2018)
avto2 = avto_info('GM','Gentra','Oq','Mexanika',2016,15000)
avtolar = [avto1, avto2]
print('Onlayn bozordagi mavjud avtomashinalar:')
for avto in avtolar:
if avto['narh']:
narh = avto['narh']
else:
narh = "Noma'lum"
print(f"{avto['rang']} {avto['model']}. Narhi: {narh}")
Onlayn bozordagi mavjud avtomashinalar: Qora Malibu. Narhi: Noma'lum Oq Gentra. Narhi: 15000
FUNKSIYADAN RO'YXAT QAYTARAMIZ
Biz avvalroq range() funksiyasi bilan tanishgan edik. Bu funksiya 2 ta son qabul qilib, shu ikki son orali'g'idagi sonlarni qaytaradi. Keling biz oraliq() degan yangi funksiya yaratamiz. range() dan farqli ravishda, funksiyamiz 2 son oralig'idagi sonlarni ro'yxat ko'rinishida qaytarsin.
In [12]:
def oraliq(min,max):
sonlar = [] # bo'sh ro'yxat
while min sonlar.append(min)
min += 1
return sonlar
Funksiyani tekshiramiz:
In [13]:
print(oraliq(0,10))
print(oraliq(10,21))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
Yuqoridagi funksiyaga uchinchi, qadam deb nomlangan ixtiyoriy parameterni qo'sha olasizmi?
>>> print(oraliq(0,21,2)) # 0 dan 21 gacha 2 qadam bilan
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
FUNKSIYALARNI TSIKLDA ISHLATISH
Funksiyalarni takrorlash uchun tsikldan foydalanishimiz mumkin. Quyidagi misolda biz while yordamida avvalroq yaratgan avto_info funksiyamizni bir necha bor chaqiramiz va salondagi avtolar ro'yxatini shakllantiramiz. Bunda, ro'yxatning har bir elementi avto_info funksiyasidan qaytgan lug'at bo'ladi.
In [14]:
print("Saytimizdagi avtolar ro'yxatini shakllantiramiz.")
avtolar=[] # salondagi avtolar uchun bo'sh ro'yxat
while True:
print("\nQuyidagi ma'lumotlarni kiriting",end='')
kompaniya=input("Ishlab chiqaruvchi: ")
model=input("Modeli: ")
rangi=input("Rangi: ")
korobka=input("Korobka: ")
yili=input("Ishlab chiqarilgan yili: ")
narhi=input("Narhi: ")

#Foydalanuvchi kiritdan ma'lumotlardan avto_info yordamida
#lug'at shakllantirib, har bir lug'atni ro'yxatga qo'shamiz:
avtolar.append(avto_info(kompaniya, model, rangi, korobka, yili, narhi))

# Yana avto qo'shish-qo'shmaslikni so'raymiz
javob = input("Yana avto qo'shasizmi? (yes/no): ")
if javob=='no':
break
Saytimizdagi avtolar ro'yxatini shakllantiramiz. Quyidagi ma'lumotlarni kiritingIshlab chiqaruvchi: GM Modeli: Malibu Rangi: Qora Korobka: Avtomat Ishlab chiqarilgan yili: 2020 Narhi: 45000 Yana avto qo'shasizmi? (yes/no): no
Yuqoridagi funksiyani Pythonda bajarib kor'ing. Ro'yxatga bir necha qiymatlar qo'shing. Natijalarni konsolga chiroyli qilib chiqaring:

AMALIYOT

1. 
   Foydanaluvchidan ismi, familiyasi, tug'ilgan yili, tug'ilgan joyi, email manzili va telefon raqamini qabul qilib, lug'at ko'rinishida qaytaruvchi funksiya yozing. Lug'atda foydalanuvchu yoshi ham bo'lsin. Ba'zi argumentlarni kiritishni ixtiyoriy qiling (masalan, tel.raqam, el.manzil)
   
2. 
   Yuqoridagi funksiyani while yordamida bir necha bor chaqiring, va mijozlar degan ro'yxatni shakllantiring. Ro'yxatdagi mijozlar haqidagi ma'lumotni konsolga chiqaring.
   
3. 
   Uchta son qabul qilib, ulardan eng kattasini qaytaruvchi funksiya yozing
   
4. 
   Foydalanuvchidan aylaning radiusini qabul qilib olib, uning radiusini, diametrini, perimetri va yuzini lug'at ko'rinishida qaytaruvchi funksiya yozing
   
5. 
   Berilgan oraliqdagi tub sonlar ro'yxatini qaytaruvchi funksiya yozing (tub sonlar —faqat birga va o'ziga qoldiqsiz bo'linuvchi, 1 dan katta musbat sonlar)
   
6. 
   Foydalanuvchidan son qabul qilib, shu son miqdoricha Fibonachchi ketma-ketligidagi sonlar ro'yxatni qaytaruvchi funksiya yozing. Ta’rif: Har bir hadi o’zidan oldingi ikkita hadning yig’indisiga teng bo’lgan ketma-ketlik Fibonachchi ketma-ketligi deyiladi. Bunda boshlang’ish had ko’pincha 1 deb olinadi. 1, 1, 2, 3, 5, 8, 13, 21, 34, 55,...
   

JAVOBLAR
In [15]:
def mijoz_info(ism, familiya, tyil, tjoy, email='',tel=None):
"""Mijoz haqidagi ma'lumotlarni lug'at ko'rinishida qaytaruvchi funksiya"""
mijoz = {'ism':ism,
'familiya':familiya,
'tyil':tyil,
'yoshi':2020-tyil,
'tjoy':tjoy,
'email':email,
'telefon':tel}
return mijoz


print("Mijoz haqida ma'lumotlarni kiriting.")
mijozlar =[]
while True:
ism = input("Ismi: ")
familiya = input("Familiyasi: ")
tyil = int(input("Tug'ilgan yili: "))
tjoy = input("Tug'ilgan joyi: ")
email = input("Email: ")
telefon = input("Telefon raqami: ")
mijozlar.append(mijoz_info(ism, familiya, tyil, tjoy, email, telefon))
javob = input("Davom etasizmi? (ha/yo'q)")
if javob!='ha':
break


print("Mijozlar:")
for mijoz in mijozlar:
print(f"{mijoz['ism'].title()} {mijoz['familiya'].title()},"
f"{mijoz['yoshi']} yoshda, telefoni: {mijoz['telefon']}")
Mijoz haqida ma'lumotlarni kiriting. Ismi: odil Familiyasi: olimov Tug'ilgan yili: 1998 Tug'ilgan joyi: toshkent Email: [e-mail] Telefon raqami: 9989122334455 Davom etasizmi? (ha/yo'q)ha Ismi: javoxir Familiyasi: jalolov Tug'ilgan yili: 2001 Tug'ilgan joyi: samarqanda Email: [e-mail] Telefon raqami: 998903344556 Davom etasizmi? (ha/yo'q)yo'q Mijozlar: Odil Olimov,22 yoshda, telefoni: 9989122334455 Javoxir Jalolov,19 yoshda, telefoni: 998903344556
In [16]:
def kattasi(x,y,z):
max = x
if y>=max:
max = y
if z>=max:
max = z
return max


kattasi(10,20,-5)
Out[16]:
20
In [17]:
def aylana_info(radius,pi=3.14159):
aylana = {"radius":radius,
"diametr":2*radius,
"perimetr":2*radius*pi,
"yuza":pi*radius**2}
return aylana


aylana_info(5)
Out[17]:
{'radius': 5, 'diametr': 10, 'perimetr': 31.4159, 'yuza': 78.53975}
In [20]:
def tub_sonlar_top(min,max):
tub_sonlar = []
for n in range(min,max+1):
tub = True
if (n==1):
tub = False
elif(n==2):
tub = True
else:
for x in range(2,n):
if(n%x==0):
tub = False
if tub:
tub_sonlar.append(n)

return tub_sonlar


tub_sonlar_top(1,20)
Out[20]:
[2, 3, 5, 7, 11, 13, 17, 19]
In [21]:
def fibonacci(n):
sonlar = []
for x in range(n):
if x==0 or x==1:
sonlar.append(1)
else:
sonlar.append(sonlar[x-1]+sonlar[x-2])
return sonlar


print(fibonacci(10))
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]



21-DARS. FUNKSIYA VA RO'YXAT
Funksiyaga ro'yxat uzatishni o'rganamiz

FUNKSIYAGA RO'YXAT UZATISH
Biz avvalgi darslarimizda funksiyaga parametr sifatida yagona qiymat berayotgan edik. Aslida, bu bilan cheklanmasdan, funksiyaga ro'yxat (list) ham berishimiz mumkin. Bunda, funksiya ro'yxat qiymatlariga to'g'ridan-to'g'ri murojat qila oladi.
Keling talabalarni baholaydigan funksiya yozamiz. Funksiyamiz talabalar ro'yxatini qabul qilib oladi, ro'yxatdan har bir talabani sug'urib olib (.pop()), bahosini kiritishni so'raydi. Talaba ismi va bahosini lug'atga joylab, yakuniy lug'atni foydalanuvchiga qaytaradi.
In [5]:
def bahola(ismlar):
baholar = {}
while ismlar:
ism = ismlar.pop()
baho = input(f"Talaba {ism.title()}ning bahosini kiriting: ")
baholar[ism]=baho
return baholar


talabalar = ['ali', 'vali', 'hasan', 'husan']
baholar = bahola(talabalar)
print(baholar)
Talaba Husanning bahosini kiriting: 5 Talaba Hasanning bahosini kiriting: 2 Talaba Valining bahosini kiriting: 4 Talaba Alining bahosini kiriting: 5 {'husan': '5', 'hasan': '2', 'vali': '4', 'ali': '5'}
RO'YXATGA O'ZGARTIRISH KIRITISH
Funksiyaga ro'yxat uzatganimizda, funksiya ro'yxat elementlariga to'g'ridan-to'g'ri murojat qila oladi. Ro'yxatga funksiya ichida kiritilgan o'zgartirishlar asl ro'yxatga ham ta'sir qiladi. Avvalgi misolimizga qaytaylik:
In [6]:
talabalar = ['ali', 'vali', 'hasan', 'husan']
baholar = bahola(talabalar)
print(talabalar)
Talaba Husanning bahosini kiriting: 5 Talaba Hasanning bahosini kiriting: 3 Talaba Valining bahosini kiriting: 4 Talaba Alining bahosini kiriting: 4 []
Yuqoridagi funksiya unga uzatilgan ro'yxat ichidagi talabalarning ismini .pop() yordamida sug'urib olgani uchun bizning asl ro'yxatimiz ham bo'shab qoldi. E'tibor bering, funksiya tashqarisidagi va ichidagi ro'yxatlar ikki hil nomlangan bo'lsada (talabalar va ismlar), ikkalasi ham xotiradagi bitta ro'yxatga bog'langani sabab ulardan biriga o'zgartirish kiritilishi bilan, ikkinchisi ham o'zgaradi.

ASL RO'YXATGA O'ZGARTIRISH KIRITISHNING OLDINI OLISH
Agar funksiya asl ro'yxatga o'zgartirish kiritishini istamasangiz, funksiyaga ro'yxatning o'zini emas, uning nusxasini uzatish mumkin. Buning uchun funksiya parametrini royxat_nomi[:] ko'rinishida yozish kifoya. Bunda [:] operatori ro'yxatdan nusxa olishni bildiradi:
In [7]:
talabalar = ['ali', 'vali', 'hasan', 'husan']
baholar = bahola(talabalar[:])
print(talabalar)
Talaba Husanning bahosini kiriting: 5 Talaba Hasanning bahosini kiriting: 3 Talaba Valining bahosini kiriting: 4 Talaba Alining bahosini kiriting: 3 ['ali', 'vali', 'hasan', 'husan']
AMALIYOT

• 
  Matnlardan iborat ro'yxat qabul qilib, ro'yxatdagi har bir matnning birinchi harfini katta harfga o'zgatiruvchi funksiya yozing.
  

• 
  Yuqoridagi funksiyani asl ro'yxatni o'zgartirmaydigan va yangi ro'yxat qaytaradigan qilib o'zgartiring
  

• 
  Darsimiz davomida yozgan bahola funksiyasini .pop() metodidan foydalanmasdan va asl ro'yxatga o'zgartirish kiritmasdan faqat lug'at qaytaradigan qilib yozing.
  

JAVOBLAR
In [1]:
def katta_harf(matnlar):
for i in range(len(matnlar)):
matnlar[i]=matnlar[i].title()


ismlar = ['ali', 'vali', 'hasan', 'husan']
katta_harf(ismlar)
print(ismlar)
['Ali', 'Vali', 'Hasan', 'Husan']
In [3]:
def katta_harf(matnlar):
matnlar = matnlar[:]
for i in range(len(matnlar)):
matnlar[i]=matnlar[i].title()
return matnlar


ismlar = ['ali', 'vali', 'hasan', 'husan']
yangi_ismlar = katta_harf(ismlar)
print(ismlar)
print(yangi_ismlar)
['ali', 'vali', 'hasan', 'husan'] ['Ali', 'Vali', 'Hasan', 'Husan']
In [4]:
talabalar = ['ali', 'vali', 'hasan', 'husan']


def bahola(ismlar):
baholar = {}
for ism in ismlar:
baho = input(f"Talaba {ism.title()}ning bahosini kiriting: ")
baholar[ism]=baho
return baholar

baholar = bahola(talabalar)
print(baholar)
print(talabalar)


Talaba Alining bahosini kiriting: 5 Talaba Valining bahosini kiriting: 2 Talaba Hasanning bahosini kiriting: 3 Talaba Husanning bahosini kiriting: 4 {'ali': '5', 'vali': '2', 'hasan': '3', 'husan': '4'} ['ali', 'vali', 'hasan', 'husan']

22-DARS. MOSLASHUVCHAN FUNKSIYA (*args, **kwargs)

*args va **kwargs bilan tanishamiz

MOSLASHUVCHAN FUNKSIYA

Agar funksiyangiz bir nechta argument qabul qilishi kerak bo'lsa-yu, lekin siz argumentlar sonini aniq bilmasangiz, Pythonda istalgancha qiymat qabul qiluvchi funksiya yaratish imkoniyati bor.

*args USULI

Agar funksiya qabul qiladigan parametrlar soni noaniq bo'lsa, va parametrlar yagona qiymatlar ko'rinishida uzatilsa, funksiya yaratishda argumentdan avval yulduzcha qo'yiladi (*arguments). Quyidagi misolni ko'raylik. summa()nomli funksiyamiz istalgancha sonlarni qabul qilib oladi, va ularning yi'gindisi hisoblaydi:
In [6]:
def summa(*sonlar):
"""Kiritilgan sonlar yig'indisini hisoblaydigan funksiya"""
yigindi = 0
for son in sonlar:
yigindi += son
return yigindi
Bu funksiyani istalgancha parametr bilan chaqirish mumkin:
In [7]:
print(summa(1,2))
3
In [9]:
print(summa(1,2,3,4,5))
15
*args usulida, bacha uzatilgan parametrlar (bir dona bo'lsa ham) funksiya ichida o'zgarmas ro'yxatga (tuple) joylanadi. Bundan kelib chiqib, yuqoridagi funksiyamizni yanada soddalashtirib yozishimiz mumkin:
Agar funksiya bir nechta argument qabul qilsa, *args argument doim oxirida yoziladi:
In [12]:
def summa(x,y,*sonlar):
"""Kiritilgan sonlar yig'indisini hisoblaydigan funksiya"""
return x+y+sum(sonlar)
Yuqoridagi funksiyamiz kamida 2 ta parametr qabul qiladi (x va y) va birinchi ikki argumentlar majburiy argumentlardir.
In [13]:
print(summa(2))
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) in ----> 1 print(summa(2)) TypeError: summa() missing 1 required positional argument: 'y'

**kwargs USULI

Agar funksiyaga kalit so'z - qiymat ko'rinishidagi argumentlarni uzatish talab qilinsa, va bunday parametrlar soni noma'lum bo'lsa, argument oldidan ikkita yulduzcha qo'yiladi (**kwargs).
**kwargs — keyword arguments (kalit so'zli argumentlar)
In [15]:
def avto_info(kompaniya,model,**malumotlar):
"""Avto haqidagi ma'lumotlarni lug'at ko'rinishdia qaytaruvchi funksiya"""
malumotlar['kompaniya']=kompaniya
malumotlar['model']=model
return malumotlar
Yuqoridagi funksiyamiz kompaniya va model degan ikki qiymatni qabul qiladi, undan keyin esa funksiyaga istalgancha parametr uzatish mumkin. Bunday funksiyaga parametrlar kalitso'z=qiymat ko'rinishida uzatiladi.
Funksiya ichida avval foydalanuvchi kiritgan qo'shimcha qiymatlardan iborat malumotlar deb nomlangan lug'at shakllantiriladi. Undan keyin esa majburiy parametrlarni lug'atga qo'shamiz.
In [16]:
avto1 = avto_info("GM", "malibu", rang='qora', yil=2018)
avto2 = avto_info("Kia", "K5", rang='qizil', narh=35000)
In [17]:
print(avto2)
{'rang': 'qizil', 'narh': 35000, 'kompaniya': 'Kia', 'model': 'K5'}

AMALIYOT

1. 
   Istalgancha sonlarni qabul qilib, ularning ko'paytmasini qaytaruvchi funksiya yozing
   
2. 
   Talabalar haqidagi ma'lumotlarini lug'at ko'rinishida qaytaruvchi funkisya yozing. Talabaning ismi va familiyasi majburiy argument, qolgan ma'lumotlar esa ixtiyoriy ko'rinishda istalgancha berilishi mumkin bo'lsin.
   

JAVOBLAR

GitHub

In [1]:
def multiply(*sonlar):
kopaytma = 1
for son in sonlar:
kopaytma *= son
return kopaytma


print(multiply(4,5,6))
120
In [2]:
def talaba_info(ism, familiya, **kwargs):
kwargs['ism']=ism
kwargs['familiya']=familiya
return kwargs


talaba = talaba_info('olim','olimov',tyil=1995,fakultet='IT',yonalish='AT')

23-DARS.MODUL NIMA?

Dasturni modullarga bo'lishni o'rganamiz

Funksiyaning qulayliklaridan biri, ko'p takrorlanadigan kodlarni funksiya ichida yashirishimiz va kerak bo'lgan murojat qilishimiz mumkinligida. Maqsadimiz dasturimizni ixcham va tushunarli qilib, kelajakda o'zimiz yoki boshqalar uchun ham "toza" kod qoldrisih. Bu yo'nalishda yana bir qadam qo'yib, dasturimizni modullarga ajratimshimiz mumkin.
Modul bu loyihamiz ichidagi alohida fayl bo'lib, dasturimiz davomida ishlatiladigan funskyalarni (va o'zgaruvchilarni) mana shu faylga joylab, ko'zdan yashirib qo'yishimiz mumkin. Bu bizga asosiy dasturimizdan chalg'imasdan kod yozish imkoniyatini beradi.
Modul va uning ichidagi funksiyalarni istalgan payt asosiy dasturimizga yuklab olishimiz, modullarni boshqa dasturchilar bilan ulashishimiz yoki kelajakda o'zimizning boshqa loyihalarimizda foydalanishimiz mumkin.
Umuman olganda katta dasturlar bir nech o'nlab modullardan iborat bo'lishi tabiiy hol.

MODUL YARATAMIZ

Modul yaratish uchun asosiy dasturimizdagi funksiyalarni yangi faylga ko'chiramiz xolos. Modulga oson murojat qilishimiz uchun, faylimiz asosiy dasturimiz bilan bitta papkada bo'lgani afzal. Bunda adashib ketmaslik uchun, loyihangizning (dasturning) asosiy faylini main.py deb nomlash o'rinli.
Keling, biz ham avto_info_mod.py degan fayl yaratamiz va ichiga quyidagi 3 ta funksiyalarni joylaymiz:
In [5]:
def avto_info(kompaniya, model, rangi, korobka, yili, narhi=None):
"""Avtomobil haqidagi ma'lumotlarni lug'at ko'rinishida qaytaruvchi funksiya"""
avto = {'kompaniya':kompaniya,
'model':model,
'rang':rangi,
'korobka':korobka,
'yil':yili,
'narh':narhi}
return avto


def avto_kirit():
"""Foydalanuvchiga avto_info funksiyasi yordamida bir nechta avtolar haqida ma'lumotlarni bitta ro'yxatga joylash imkonini beruvchi funksiya"""
avtolar=[] # salondagi avtolar uchun bo'sh ro'yxat
while True:
print("\nQuyidagi ma'lumotlarni kiriting",end='')
kompaniya=input("Ishlab chiqaruvchi: ")
model=input("Modeli: ")
rangi=input("Rangi: ")
korobka=input("Korobka: ")
yili=input("Ishlab chiqarilgan yili: ")
narhi=input("Narhi: ")
#Foydalanuvchi kiritdan ma'lumotlardan avto_info yordamida
#lug'at shakllantirib, har bir lug'atni ro'yxatga qo'shamiz:
avtolar.append(avto_info(kompaniya, model, rangi, korobka, yili, narhi))
# Yana avto qo'shish-qo'shmaslikni so'raymiz
javob = input("Yana avto qo'shasizmi? (yes/no): ")
if javob=='no':
break
return avtolar


def info_print(avto_info):
"""Avtomobillar haqida ma'lumotlar saqlangan lug'atni konsolga chiqaruvchi funksiya"""
print(f"{avto_info['rang'].title()} {avto_info['kompaniya'].upper()} "
f"{avto_info['model'].upper()}, {avto_info['korobka']} korobka, "
f"{avto_info['yil']}-yil, {avto_info['narh']}$")
Yuqoridagi funksiyalarga asosiy dasturdan murojat qlishning bir necha usuli bor.

MODULNI CHAQIRIB OLISH

Modul ichidagi istalgan funksiyaga murojat qilish uchun import modul_nomi komandasidan foydalanamiz. Bunda modul ichidagi istalgan funksiyaga modul_nomi.funksiya_nomi() ko'rinishida murojat qilishimiz mumkin. Ya'ni avval modul nomi undan keyin esa nuqta qo'yilib, modul ichidagi funksiya nomi yoziladi. Keling, yuqoridagi modulimizdagi avto_info() va info_print() funksiyalariga murojat qilamiz:
In [ ]:
import avto_info_mod # avto_info_mod faylini (modulini) chaqiramiz


avto1 = avto_info_mod.avto_info("GM", "Malibu", "Qora", "avtomat", 2020,40000)
avto_info_mod.info_print(avto1)
Ko'rib turganingizdek, dasturimiz qisqa, tushunarli va muhimi toza bo'ldi. 3 qator kod ortida 20 qatordan ortiq kodni yashirdik.