Advanced Python

Python-ga chuqurroq sho'ng'ing va kodlash mahoratingizni oshiring.

Python generatori:

''' 
Iterator
''' 
import time
def answer():
 result = []
 time.sleep(3)
 result.append(14)
 time.sleep(3)
 result.append(44)
 time.sleep(3)
 result.append(75)
 return result
for x in answer():
 print(x)

'''
Generator
'''
import time
def answer():
 time.sleep(3)
 yield 14
 time.sleep(3)
 yield 44
 time.sleep(3)
 yield 75
for x in answer():
 print(x)

'''
Generator range()
'''
import time
# def answer():
# while True:
# time.sleep(3)
# yield 75
#
#
# for x in answer():
# print(x * x)
def reverse(nums: list):
 n = len(nums)
 for x in range(n - 1, -1, -1):
 yield nums[x]
# for x in reverse([1, 2, 3]):
# print(x)
# print(list(reverse([1, 2, 3])))
iterator = iter(reverse([1, 2, 3, 4, 5]))
while True:
 try:
 n = next(iterator)
 except StopIteration:
 break
 print(n)
for r in reverse([1, 2, 3, 4, 5]):
 print(r)
for x in range(100000000): # range() generator
 time.sleep(1)
 print(x)

Decorator

Dekoratorlar yuqori darajadagi funktsiyalarni chaqirish uchun oddiy sintaksisni ta'minlaydi. Ta'rifga ko'ra, dekorator boshqa funktsiyani qabul qiladigan va ikkinchi funktsiyaning harakatini aniq o'zgartirmasdankengaytiradigan funktsiyadir.Bu chalkash tuyuladi, lekin aslida unday emas, ayniqsa dekorativlar qanday ishlashiga oid bir nechta misollarni ko'rganingizdan keyin. Ushbu maqoladagi barcha misollarni bu erda topishingiz mumkin.

 def hello(name):
 # ichki funksiya
 def get_name():
 return f"Hello, {name}!"
 # ichki funksiyani qaytarish
 return get_name
hello_func = hello("Sarvar")
print(hello_func())

Decorator funksiya argument sifatida funksiya qabul qiladi.

 def make_decorator(func):
 def inner():
 # Ichki funksiya orqali func xususiyatlarini o'zgartirishimiz mumkin
 print("Dekorator ishlayapti")
 func()
 # Ichki funksiya qaytariladi
 return inner
def my_func():
 print("Dekorator uchun ishlatiladigan funksiya")
decorated_func = make_decorator(my_func)
decorated_func()
# Dekorator ishlayapti
# Dekorator uchun ishlatiladigan funksiya

Bitta funksiyada bir nechta decorator ishlatishimiz ham mumkin, bunda birinchisidan boshlab decoratorlar ishlab keladi.

def divide_decorator(func):
 def divide_inner(a, b):
 try:
 return func(a, b)
 except ZeroDivisionError:
 print("Nolga bo'lish mumkin emas!")
 return divide_inner
def second_zero(func): # zero 0 - > 1 function
 def inner(a, b):
 if b == 0:
 b += 1
 return func(a, b)
 return inner
@second_zero
@divide_decorator
def divider(a, b):
 return a / b
print(divider(10, 5)) # 2.0
print(divider(10, 0)) # 10.0

'''
Decorator
'''
import time
# def add(a, b):
# return a + b
#
#
# # print(add.__call__(1, 2))
# # print(add(1, 2))
#
#
# def calc(func, a, b):
# return func(a, b)
#
#
# result = calc(add, 1, 4)
# print(result)
# def adder(n):
# def inner(m):
# return 5 + m
# return inner
#
#
# add_5 = adder(5)
# def func():
# def another_func():
# return 1
# return another_func
#
# print(func()())
# def do():
# started = time.time()
# print(started)
# time.sleep(3)
# print("done")
# finished = time.time()
# print(finished)
# print(f"took {finished - started} seconds")
#
#
# do()
# def do1():
# started = time.time()
# print(started)
# time.sleep(3)
# print("done")
# finished = time.time()
# print(finished)
# print(f"took {finished - started} seconds")
#
#
# do1()
# def timer(func):
# started = time.time()
# func()
# fnished = time.time()
# print(f"took {fnished - started} seconds")
#
# timer(do())
# timer(do2())
# not called
# def timer(func):
# def inner():
# started = time.time()
# func()
# fnished = time.time()
# print(f"took {fnished - started} seconds")
#
# return inner
#
#
# # do = timer(do())
# # do2 timer(do2())
#
# do()
# do2()
# @timer
# def dos():
# time.sleep(3)
# print("done")
# def star(func):
# def inner():
# print("*" * 12)
# func()
# print("*" * 12)
#
# return inner
# def presnet(func):
# def inner():
# print("%" * 12)
# func()
# print("%" * 12)
#
# return inner
#
# @star
# @presnet
# def hello():
# print("Hello World")
#
#
# hello()
# def wrap(char):
# def wrapper(func):
# def inner():
# print(char * 12)
# func()
# print(char * 12)
#
# return inner
#
# return wrapper
#
#
# @wrap("%")
# @wrap("*")
# def hello():
# print("Hello World")
#
#
# hello()
'''
log nomli dekorator yarating, u qaysi funksiya qachon chaqirilganini va qachon funksiya tugagani vaqtnini ekranga chiqarsin. Vaqtni formatlashni https://strftime.org/ saytidan ko'rishingiz mumkin.


Misol:
@log
def hello():
 print("hello")

hello()

Output:
- called function: hello at 8:43:35
hello
- finished function: hello at 8:43:36

'''

Context Mangers

'''Context Managers
'''
# with open('file.txt', 'w') as file:
# file.write("Hello")
#
# file = open('file,txt', 'w')
# file.write('All Nc')
# file.close()
# class FileOpener:
# def __init__(self, filename, mode='r'):
# self.filename = filename,
# self.mode = mode
# self.opened_file = None
#
# def __enter__(self):
# print("Entered")
# return 1
#
# def __exit__(self, exc_type, exc_val, exc_tb):
# print('Exited')
#
#
# with FileOpener('file,txt', 'w') as file:
# print('file', file)
# print('nima_dir boldi')
# class FileOpener:
# def __init__(self, filename, mode='r'):
# self.filename = filename
# self.mode = mode
# self.opened_file = None
#
# def __enter__(self):
# print("Entered")
# self.opened_file = open(self.filename, self.mode)
# return self.opened_file
#
# def __exit__(self, exc_type, exc_val, exc_tb):
# print('Exited')
# if self.opened_file:
# self.opened_file.close()
#
#
# with FileOpener('file.txt', 'w') as file:
# print('file', file)
# file.write('All Nc')
# raise Exception
# print('nima_dir boldi')
from contextlib import contextmanager
@contextmanager
def file_opener(filename, mode):
 file = open(filename, mode)
 print('open file')
 try:
 yield file
 finally:
 file.close()
 print('closed file')
with file_opener('files.txt', 'w') as file:
 print('file', file)
 raise Exception
'''
log nomli kontekst meneger yarating, u qaysi kontext qachon ochilganini va qachon kontext yopilganini vaqtnini ekranga chiqarsin.

Misol:

with log():
 print("hello")

Output:
- context manager opened at 8:43:35
hello
- context manager closed at 8:43:36
'''

Typing modul

Asosiy turlar

Ro'yxatlar va Lug'atlar

Union

O'zgaruvchining bir nechta turda bo'lishi mumkinligini belgilash uchun Union dan foydalaniladi.

from typing import Union
def foo(x: Union[int, str]) -> None:
 print(x)

Optional

O'zgaruvchi ma'lum bir turda yoki None bo'lishi mumkinligini belgilash uchun Optional dan foydalaniladi.

from typing import Optional
def foo(x: Optional[int]) -> None:
 print(x)

Tuple

Aniq uzunlikdagi va ma'lum turlardagi elementlardan iborat tuple belgilash uchun Tuple dan foydalaniladi.

from typing import Tuple
def foo(x: Tuple[int, float, str]) -> None:
 print(x)

Any

Har qanday turdagi bo'lishi mumkin bo'lgan o'zgaruvchi belgilash uchun Any dan foydalaniladi.

from typing import Any
def foo(x: Any) -> None:
 print(x)

Type Aliases

Murakkab turlarni o'qilishi osonroq qilish uchun tur ta'riflari ishlatilishi mumkin.

from typing import List
Vector = List[float]
def foo(v: Vector) -> None:
 print(v)

Misol

from typing import List, Dict, Union, Optional
def process_data(data: List[Dict[str, Union[int, float]]]) -> Optional[float]:
 if not data:
 return None
 return sum(item['value'] for item in data) / len(data)

Xulosa

typing moduli Python kodlaringizni tushunarliroq, qulayroq va xatolarni kamaytirish uchun juda foydali. Bu modul bilan yozilgan kodlar kelajakdagi o'zgarishlar uchun yanada aniqroq tuzilmani ta'minlaydi.

Unpacking and packing

Unpacking va packing - Python dasturlash tilida juda foydali texnikalar bo‘lib, ular ob’ektlarni ochish va yig‘ish jarayonlarini osonlashtiradi.

Unpacking

Unpacking ob’ektni bir necha qismlarga ajratish va har bir qismni alohida o‘zgaruvchiga tayinlash imkonini beradi. Bu ko‘pincha ro‘yxatlar va tuple (to‘plam)lar bilan ishlatiladi.

Tuple bilan unpacking

my_tuple = (1, 2, 3)
a, b, c = my_tuple
print(a) # 1
print(b) # 2
print(c) # 3

Ro'yxat bilan unpacking

my_list = [4, 5, 6]
x, y, z = my_list
print(x) # 4
print(y) # 5
print(z) # 6

Funksiya chaqirilishi natijasini unpacking qilish

def get_coordinates():
 return (50.4501, 30.5234)
lat, lon = get_coordinates()
print(f"Latitude: {lat}, Longitude: {lon}")

Packing

Packing esa aksincha, bir nechta qiymatlarni bitta tuple yoki ro‘yxatga yig‘ish imkonini beradi.

Tuple bilan packing

a, b, c = 1, 2, 3
my_tuple = (a, b, c)
print(my_tuple) # (1, 2, 3)

Ro'yxat bilan packing

x, y, z = 4, 5, 6
my_list = [x, y, z]
print(my_list) # [4, 5, 6]

Funksiya orqali packing

def create_point(x, y, z):
 return (x, y, z)
point = create_point(7, 8, 9)
print(point) # (7, 8, 9)

*args va **kwargs bilan ishlash

Unpacking va packing ko‘pincha *args va **kwargs bilan birgalikda ishlatiladi.

- *args funksiyaga kiritilgan argumentlarni tuple ko‘rinishida qabul qiladi,

- **kwargs esa kalit-qiymat juftliklarini dictionary ko‘rinishida qabul qiladi.

def my_function(*args, **kwargs):
 print(args)
 print(kwargs)
my_function(1, 2, 3, name="Alice", age=30)
# (1, 2, 3)
# {'name': 'Alice', 'age': 30}

Unpacking va packingni birgalikda ishlatish

def calculate_sum(a, b, c):
 return a + b + c
my_numbers = [1, 2, 3]
result = calculate_sum(*my_numbers)
print(result) # 6
# **kwargs bilan unpacking # noqa
def print_info(name, age):
 print(f"Name: {name}, Age: {age}")
info = {"name": "Alice", "age": 30}
print_info(**info)
# Name: Alice, Age: 30

Python'da hashable va unhashable tushunchalari muhim ahamiyatga ega, ayniqsa, ma'lumotlar tuzilmalari va lug'atlar bilan ishlashda.

Hashable (Hashlanadigan)

Hashable obyektlar:

hash(42) # Integer hashable
hash("hello") # String hashable
hash((1, 2, 3)) # Tuple hashable

Unhashable (Hashlanmaydigan)

Unhashable obyektlar:

hash([1, 2, 3]) # List unhashable
hash({1: "one", 2: "two"}) # Dictionary unhashable
hash({1, 2, 3}) # Set unhashable

Nima uchun bu muhim?

Django'da select_related va prefetch_related optimizatsiya metodlari bo'lib, ular ORM (Object-Relational Mapping) so'rovlarining samaradorligini oshirish uchun ishlatiladi.

select_related

Model example

class Author(models.Model):
 name = models.CharField(max_length=100)
class Book(models.Model):
 title = models.CharField(max_length=100)
 author = models.ForeignKey(Author, on_delete=models.CASCADE)
# Query with select_related
books = Book.objects.select_related('author').all()
for book in books:
 print(book.author.name) # Author ma'lumotlari bitta JOIN so'rovda keladi

prefetch_related

Model example

class Book(models.Model):
 title = models.CharField(max_length=100)
 authors = models.ManyToManyField(Author)
#Query with prefetch_related
books = Book.objects.prefetch_related('authors').all()
for book in books:
 for author in book.authors.all():
 print(author.name) # Authors alohida so'rovda yuklab olinadi

Xulosa

Python Queue Example

import queue
import threading
import time
# Telegram botiga yuborilayotgan buyruqlar navbati (queue)
command_queue = queue.Queue()
# Bu funksiya botga kelayotgan buyruqlarni navbatga qo'shadi
def add_command_to_queue(command):
 print(f"Buyruq qo'shildi: {command}")
 command_queue.put(command)
# Bu funksiya navbatdagi buyruqlarni ketma-ket bajaradi
def process_commands():
 while True:
 # Navbatdan buyruqni olish
 command = command_queue.get()
 if command is None:
 break
 print(f"Buyruqni bajarish: {command}")
 time.sleep(2) # Buyruqni bajarishga sarflanadigan vaqt
 command_queue.task_done()
 print(f"Buyruq bajarildi: {command}")
# Buyruqlarni qabul qilish uchun yangi threading
threading.Thread(target=process_commands, daemon=True).start()
# Botga kelayotgan buyruqlar
add_command_to_queue("/start")
add_command_to_queue("/help")
add_command_to_queue("/settings")
# Buyruqlar navbatda bajarilguncha kutish
command_queue.join()
print("Barcha buyruqlar bajarildi!")```