Qat'iymas to'plamlar ustida amallar quyidagilarni o'z ichiga oladi

Qat'iymas to'plamlar ustida amallar quyidagilarni o'z ichiga oladi:

1. Qo'shish. Qat'iymalar nihoyatsiz kengayishi mumkin. Masalan, agar 3 va 4 natijali qat'iyma bo'lsa, 3+4=7 natijali qat'iyma bo'ladi.

2. Ayirish. Masalan, 15-6=9 natijali qat'iyma hosil bo'ladi.
3. Ko'paytirish. Masalan, 3x4 = 12 natijali qat'iyma hosil bo'ladi.
4. Bo'lish. Masalan, 18/6 = 3 natijali qat'iyma hosil bo'ladi.
5. Qoldiqli bo'lish. Masalan, 7%4 = 3 natijali qat'iyma hosil bo'ladi.
6. Darajaga oshirish. Masalan, 32=9 natijali qat'iyma hosil bo'ladi.
7. Radikallar. Masalan, √36=6 natijali qat'iyma hosil bo'ladi.
Bunday amallar orqali siz qat'iymalarni bir-biri bilan bog'lay oladsiz va yangi qat'iymalarni hosil qilishingiz mumkin. Masalan,darajaga oshirish,ko'paytish yoki qoldiqli bo'lishi orqali o'ng tomonga 1 ga yaqin qat'iymalarni hosil qila olarsiz.Shunday qilib, qat'iymalar ustida bajariladigan amallarning nochi pur murakkab va o'zaro bog'liq ekanligini tushunishingiz mumkin.
Python da qat'iymalar (integer) ustida quyidagi amallarni bajara olamasiz:
1.Qo'shish (+):
```python
a = 10
b = 20
c = a + b # c = 30
```
2. Ayirish (-):
```python
a = 10
b = 5
c = a - b # c = 5
```
3. Ko'paytirish (*):
```python
a = 10
b = 5
c = a * b # c = 50
```
4. Bo'lish (/):
```python
a = 10
b = 2
c = a / b # c = 5 (float natija)
c = a // b # c = 5 (integer natija)
```
5. Qoldiqli bo'lish (%):
```python
a = 10
b = 3
c = a % b # c = 1
```
6. Darajaga oshirish (**):
```python
a = 2
b = 3
c = a ** b # c = 8
```
7. Radikallar (sqrt()):
```python
from math import sqrt
a = sqrt(25) # a = 5
```
Shunday qilib, python da ham qat'iymalar ustida o'zgarmas matematik amallarni bajara olamiz. Bundan tashqari, qat'iymalarni stringlar bilan alohida usullar yordamida bir-biri bilan bog'lashimiz mumkin.
Demak, qat'iymalar ustida amallar bajarishning umumiy logikasi barcha dasturlash tillarida bir xil bo'lsa-da, kengaytirish funksiyalarining o'ziga xosligi bor.
Ha, qat'iymalar ustida ko'rsatilgan amallardan tashqari, ba'zi boshqa amallar ham mavjud:
1. Modul darajasi (// operatori orqali). Ikkita butun sonni bir-biri bilan bo'lib, qoldiqsiz bo'lish natijasini qaytaradi:
```python
a = 15
b = 3
javob = a // b
print(javob) # 5 chiqadi
```
2. Absolut qiymat (abs() funksiyasi orqali). Sonning ijobiy yoki manfiyligidan qat'iy nazar uning mulkdagi qiymatini qaytaradi:
```python
a = -5
print(abs(a)) # 5
```
3. Kichik eng katta son (min() funksiyasi). Bir nechta sonning eng kichigini topadi:
```python
a = 5
b = 10
c = 2
print(min(a, b, c)) #
4. Katta eng kichik son (max() funksiyasi). Bir nechta sonning eng kattasini topadi:
```python
a = 5
b = 10
c = 2
print(max(a, b, c)) # 10
```5. Tam sonmi (isintgercheck() funksiyasi). Kirish soni butun son bo'lsa True, aks holda False qaytaradi:
```python
x = 5
print(isinstance(x, int)) # True
x = 5.5
print(isinstance(x, int)) # False
```
Shu bilan birgalikda, **usullar** (methods) yordamida ham amallarni soddalashtirish mumkin.
Shunday qilib, qat'iymalar ustida bajariladigan amallar soni va ularning turlari davom etib bormoqda.
Qat'iymalar ustida ishlatiladigan boshqa funksiyalar quyidagilarni o'z ichiga oladi:
1. Binarlarning 10-lik asosda ifodasini olish (bin() funksiyasi)

```python

bin(10) # '0b1010'
```
2. 8-lik asosdagi qiymatni 10-lik asosdagi ifodasini olish (oct() funksiyasi)
```python
oct(8) # '0o10'
```
3. 16-lik asosdagi qiymatni 10-lik asosdagi ifodasini olish (hex() funksiyasi)
```python
hex(16) # '0x10'
```
4. E'soblovchi (numerator) va chiqaruvchi (denominator) bo'yicha butun son ifodasini olish (fractions.Fraction() funksiyasi)
```python
from fractions import Fraction
Fraction(10,2) # Fraction(5, 1)
```
5. So'nggi ikkita belgidan tashqari barcha belgilarni o'chirib, son olish (truncate() method'i)
```python
n = 12345
print(n.truncate()) # 12300
```
6. Sonni riyoyiy qismi va butun qismi ko'rinishida ifodalanishi (math.modf(x) funksiyasi)
```python
import math
math.modf(10.5) # (0.5, 10.0)
```
7. Raqamlarning yig'indisini hisoblaydigan funksiya (sum() funksiyasi)
```python
sum([1,2,3]) # 6
```
<1-7 oraliq belgilangan funksiyalar qat'iyma ustida ishlatiladi.
Shunday qilib, qat'iymalar ustida ishlov berish uchun python da ko'p miqdorda
funksiya va usullar mavjud. Ular orqali riboiy matematikani soddalashtirib, dasturlaringizni samarali qilib bora olarsiz.Ha, qat'iymalar ustida ishlatiladigan boshqa funksiyalar haqida ko'proq ma'lumot olishingiz mumkin. Python da quyidagilarni bajara oladigan ba'zi funksiyalar mavjud:
• lcm() - Ikkita sonning eng katta ommavarianti (lowest common multiple).
• gcd() - Ikkita sonning eng kichik o'zaro qoldiqqobligi (greatest common divisor).
• bit_length() - Sonning ikkilik kodining uzunligi.
• bit_count() - Sonning ikki uchunlik raqamining soni.
• divide() - Butun sonni qismlarga bo'lib, natijalar tuplamini qaytaradi.
• divmod() - Butun sonni qoldiqsiz bo'lib va qoldiqlini ajratib beradi.
• factorial() - Sonning faktorialli qiymatini hisoblaydi.
• floor() - Eng yaqin katta butun sonni topadi.
• int.from_bytes() - Baytlar ketma-ketligidan butun son hosil qiladi.
• is_prime() - Son asl son bo'lsa True, aks holda False qaytaradi.
Bunday va shu kabi boshqa funksiyalar ham qat'iymalar ustida amallarni aniqlash, to'g'ri natijalarni olish va sintaksisni soddalashtirish uchun mo'ljallangan.
Agar siz qat'iyma ustida amallarning kompleks loyihasini yaratmoqchi bo'lsangiz, bunday funksiyalar maksimum darajada foydalanish mumkin. Shunday qilib, qat'iyma funksiyalarining tanlanishi va qo'llanilishi python da ancha kengaysa-da, ular kodni qisqartirib, mazmundorligini oshiradi.
Qat'iymalar ustida funksiyalar yaratish uchun quyidagi sintaksis zarur:
```python
def funksiya_nomi(parametr1, parametr2, ...):
# funksiya bajarilishi
return natija # valyuta qiymati
```
Masalan, modul darajasini hisoblaydigan funksiya:
```python
def modulo(a, b):
return a // b
natija = modulo(10, 3)
print(natija) # 3
```
Divide funksiyasi:
```python
def divide(a, b):
qism = []
while a >= b:
a -= b
qism.append(b)
return tuple(qism)
natija = divide(18,6)
print(natija) # (6, 6)
```
Factoriel hisoblangan funksiya:
```python
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n-1)
fact = factorial(5)
print(fact) # 120
```
Shunchaki, funksiyaning boshlanishi va yakunlanishi o'rtasida Python tomonga izohlar va boshqa kod yoza olamiz. Shuningdek, funksiya bir yoki ko'proq qiymatlar qaytarishi mumkin, deb qat'iymalarda ko'pgina parametrli funksiya yaratish mumkin.
Natijada, biz qat'iymalar ustida amallarni funksiyalarga ajratib, ularni maksimum darajada qayta ishlatish va qayta qo'llash imkonini yaratamiz.
Funksiyalar yaratishda quyidagi qo'shimcha ma'lumotlarni ham ishlatishingiz mumkin:
1. Default parametrlar - Agar funksiya parametrining filteri bo'sh qoldirilsa, u default qiymat bilan baholanadi:
```python
def multiply(a, b=1):
return a * b
print(multiply(3)) # 3
print(multiply(3, 5)) # 15
```
2. Qiymat parametrlari - *operatori yordamida funksiyaga bir nechta qiymat uzatish mumkin:
```python
def sum(*args):
total = 0
for arg in args:
total += arg
return total
print(sum(1,2,3)) # 6
```
3. Sozlamalar parametrlari - **operatori yordamida sozlamalar uzatish mumkin:
```python
def info(**kwargs):
print(kwargs)
info(name="John", age=30)
# {'name': 'John', 'age': 30}
```
4. Qaytarish - Funksiya bir yoki ko'proq qiymatlar qaytarishi mumkin:
```python
def divide(a,b):
return a/b, a%b
res = divide(15, 3)
print(res) # (5.0, 0)
```
5. Lokal va globallar - Funksiya o'z lokal va globallariga ega bo'lishi mumkin:
```python
a = 10
def func():
a = 5
print(a) # 5 - lokal
func()
print(a) # 10 - global
```6. Lambda funksiyasi - Anonim funksiya:
```python
sum = lambda a, b : a + b
print(sum(2,3)) # 5
```
Shunday qilib, farkli parametrlar, qaytarish va loyihalari bilan funksiyalar yaratish sizga python va qat'iyma ustida amallarni bajarishda katta imkoniyatlar ochadi.
Funksiyalar yaratish quyidagi maqsadlarda foydalaniladi:
1. Kodni qisqartirish - Biror amalni bir nechta marta takrorlash yerine, unga biror nom berib funksiya sifatida ajratib olish kodni kamaytiradi.
2. Kodni qayta ishlatish - Funksiyaning nomi orqali uni har qanday joyda chaqirib olish imkonini yaratadi.
3. Mazmundorlikni oshirish - Funksiya nomi amalni batafsil aks ettirgan bo'lsa, kodni aniqlash va tushunish osonga.
4. TEST yoki DEBUG qilish - Funksiya namunadan tekshirilishi oson.
5. Modullar - Funksiyani bir modulga ajratish imkonini beradi.
Masalan, quyidagi kodni funksiyaga ajratib olsak:
```python
result = (a // b)
qoldiq = a % b
```Natija:
```python
def divide(a ,b):
result = (a // b)
qoldiq = a % b
return result, qoldiq
result, qoldiq = divide(20, 4)
print(result) # 5
print(qoldiq) # 0
```
Bunday usulda funksiyalar orqali:
✔️ Kod tarkibiy jihatdan shunchaki kengaytirilgan
✔️ Amal qayta ishlatilish imkoniyati paydo bo'ldi
✔️ Kod nomi amal mazmunini bildiradi
✔️ Funksiya TEST (tekshirish) qilinishi oson.
Demak, funksiyalar yaratish sizga kodni modullashtirib, uning taqdimotini va foydalanishini aniqlashtirish imkonini beradi.
Funksiyalar modul yaratishda quyidagi afzalliklarni takdim etadi:
1. Kodni modullashtirib ajratish - Funksiyalar modul ichiga yig'ilib olinadi va alohida fayl sifatida saqlanadi.
2. Kodni qayta ishlatish - Modul tub fayl sifatida import qilinib, undagi funksiyalar chaqiriladi.
3. Keng foydalanish - Modul tub fayl sifatida projektingizning biroq fayllarida ham ishlatilishi mumkin.
4. Kodni test qilish - Modul alohida fayl sifatida yaratildi, shunday ekan funksiyalarni test qilish oson.
5. Mazmundorlikni oshirish - Modul nomi funksiyalarning vazifasini tasvirlaydi.
Masalan, quyidagi funksiyalar modulga ajratilsa:
```python
def topshirish(n)
def hisoblangan_summa(n):
...
def eng_katta_qiymat(n, m):
...
```Modul nomi va import qilinishi:
```python
# hisoblar.py
def topshirish(n):
# main.py
import hisoblar
hisoblar.topshirish(10)
hisoblar.hisoblangan_summa(100)
```
Natijada:
✔️ Funksiyalar alohida "hisoblar" moduliga ajratildi
✔️ Modul import qilinib, undagi funksiyalar chaqirildi
✔️ Modul nomi funksiyalar mazmunini tasvirlab beradi
✔️ Modul test qilishda ajralib turadi
✔️ Funksiyalar orqali keng foydalanish imkoni yaratildi
Shunday qilib, funksiyalar yordamida modullar yaratish orqali siz ko'pgina foydalar ga ega bo'lasiz: kodni qayta ishlatish, mazmundorlikni oshirish, taqdimotini yaxshilash va hokazo.