Python Data Types and Functions

Python Data Types

Basic Data Types:
- Integer (int): Whole numbers (e.g., -1, 0, 10).
- Float (float): Decimal numbers (e.g., 3.14, -0.001).
- String (str): Sequence of characters (e.g., "Hello, World!").
- Boolean (bool): Represents True or False.
Collection Data Types:
- List: Ordered, mutable collection of items (e.g., [1, 2, 3]).
- Tuple: Ordered, immutable collection (e.g., (1, 2, 3)).
- Set: Unordered collection of unique items (e.g., {1, 2, 3}).
- Dictionary (dict): Collection of key-value pairs (e.g., {'key': 'value'}).
Type Functions:
- Use type() to check the type of a variable.
- Use isinstance() to check if a variable is of a specific datatype.

Python Functions

Definition:
- A function is a block of reusable code that performs a specific task.
Defining Functions:
- Use the def keyword, followed by the function name and parentheses (e.g., def my_function():).
Parameters and Arguments:
- Parameters: Variables listed inside the parentheses in a function definition.
- Arguments: Values passed to the function when calling it.
Return Statement:
- Use return to send a result back from the function.
Function Scope:
- Variables defined inside a function have local scope, while those defined outside have global scope.
Lambda Functions:
- Anonymous, single-expression functions defined with lambda (e.g., lambda x: x + 1).
Built-in Functions:
- Commonly used built-in functions include print(), len(), max(), min(), input().
Docstrings:
- Use triple quotes to write documentation for functions (e.g., """This function does...""").
Higher-Order Functions:
- Functions that can take other functions as arguments or return them (e.g., map(), filter(), reduce()).

Python Ma'lumot Turlari

Asosiy Ma'lumot Turlari:
- Butun son (int): Butun sonlar (masalan, -1, 0, 10).
- O'nlik son (float): O'nlik sonlar (masalan, 3.14, -0.001).
- Matn (str): Belgilar ketma-ketligi (masalan, "Salom, Dunyo!").
- Mantiq (bool): True yoki False ni ifodalaydi.
To'plam Ma'lumot Turlari:
- Ro'yxat: Tartiblangan, o'zgaruvchan elementlar to'plami (masalan, [1, 2, 3]).
- To'plam: Tartiblangan, o'zgarmas elementlar to'plami (masalan, (1, 2, 3))
- To'plam: Tartibsiz, noyob elementlar to'plami (masalan, {1, 2, 3}).
- Lug'at (dict): Kalit-qiymat juftliklaridan iborat to'plam (masalan, {'kalit': 'qiymat'}).
Tur Funksiyalari:
- O'zgaruvchining turini tekshirish uchun type() dan foydalaning.
- O'zgaruvchining muayyan ma'lumot turiga tegishli ekanligini tekshirish uchun isinstance() dan foydalaning.

Python Funksiyalari

Ta'rif:
- Funksiya - bu ma'lum bir vazifani bajaruvchi qayta ishlatiladigan kod bloki.
Funksiyalarni ta'riflash:
- def kalit so'zini, keyin funksiya nomini va qavslarni (masalan, def mening_funksiyam():) ishlating.
Parametrlar va Argumentlar:
- Parametrlar: Funksiya ta'rifi ichidagi qavs ichida sanab o'tilgan o'zgaruvchilar.
- Argumentlar: Funksiyani chaqirishda funksiyaga beriladigan qiymatlar.
Qaytish bayonoti:
- Funksiyadan natijani qaytarish uchun return dan foydalaning.
Funksiya doirasini:
- Funksiya ichida aniqlangan o'zgaruvchilar mahalliy (local) doiraga ega, funksiya tashqarisida aniqlanganlar esa global doiraga ega.
Lambda Funksiyalari:
- Nomsiz, bitta ifodadan iborat funksiyalar lambda bilan aniqlanadi (masalan, lambda x: x + 1).
O'rnatilgan Funksiyalar:
- Keng tarqalgan o'rnatilgan funksiyalarga print(), len(), max(), min(), input() kiradi.
Hujjatlar:
- Funksiyalar uchun hujjat yozish uchun uch tomonlama tirnoqlardan foydalaning (masalan, """Bu funksiya...""").
Yuqori darajali funksiyalar:
- Boshqa funksiyalarni argument sifatida qabul qila oladigan yoki ularni qaytara oladigan funksiyalar (masalan, map(), filter(), reduce()).

Python-dagi Funktsiyalar

Ta'rif: Funktsiya - bu ma'lum bir vazifani bajaruvchi qayta ishlatiladigan kod blokidir.

Funktsiya yaratish:

Sintaksis:

def function_name(parametrlar):
    # bajarish uchun kod
    return qiymat

Funktsiyaga murojaat qilish:
- Funktsiyani uning nomi va kerakli argumentlarni berish orqali bajaring:
```
function_name(argumentlar)
```
Parametrlar va Argumentlar:
- Parametrlar: Funktsiya ta'rifi bilan ko'rsatilgan o'zgaruvchilar.
- Argumentlar: Funktsiyaga murojaat qilganda beriladigan qiymatlar.
Qaytarish operatori:
- Funktsiyadan chiqish va chaqiruvchiga qiymat jo'natish uchun ishlatiladi.
```
return qiymat
```
Argumentlar turlari:
- Standart argumentlar: Parametrlar uchun standart qiymatlarni belgilang.
```
def greet(name="World"):
    return f"Hello, {name}!"
```
- Kalit so'zlar argumenti: Argumentlarni parametr nomini aniqlash orqali bering.
```
greet(name="Alice")
```
- O'zgaruvchan uzunlikdagi argumentlar: *args ni kalit so'zsiz argumentlar uchun va **kwargs ni kalit so'zli argumentlar uchun ishlating.
```
def function_name(*args, **kwargs):
    # kod
```
Ko'lam:
- Mahalliy ko'lam: Funktsiyaning ichida ta'riflangan o'zgaruvchilar ushbu funktsiya uchun mahalliy hisoblanadi.
- Umumiy ko'lam: Funktsiyaning tashqarisida ta'riflangan o'zgaruvchilar umumiy hisoblanadi va funktsiyaning ichida mahalliy o'zgaruvchilar bilan soyali bo'lmasa, ularga kirish mumkin.
Lambda funktsiyalari:
- lambda kalit so'zi yordamida ta'riflangan anonim funktsiyalar.
```
add = lambda x, y: x + y
```
Yuqori darajali funktsiyalar:
- Boshqa funktsiyalarni argument sifatida qabul qiladigan yoki qaytaradigan funktsiyalar. map(), filter() va reduce() kabi misollar.
Dokumentatsiya satrlari:
- Funktsiyalarni tushuntirish uchun funktsiyaga qo'shila oladigan dokumentatsiya satrlari. Funktsiya sarlavhasining darhol ostida joylashtiriladi.
```
def function_name():
    """Bu dokumentatsiya satri."""
```
Funktsiya annotatsiyalari:
- Funktsiya parametrlari va qaytarish qiymatiga metadata biriktirish usuli.
```
def function_name(param: str) -> int:
```
Rekursiyalar:
- Funktsiya o'zini chaqira oladi. Rekursiv chaqiriqlarni to'xtatish uchun baza holati bo'lishi kerak.
Dekoratorlar:
- Funktsiyalarni ularning kodini o'zgartirmasdan, o'zgartirish yoki yaxshilash usuli. Funktsiya ta'rifi ustidagi @decorator_name sintaksisi bilan ta'riflanadi. Python-dagi funktsiyalarning ushbu jihatlarini tushunib, toza va saqlanadigan kod yaratishda samarali foydalanish mumkin.