Modullar va paketlar

#Modul nima va u nega kerak?

Dasturingiz kattalaşgan sari barça kodni bitta faylda saqlaş noqulay bölib qoladi: kerakli funksiyani topiş qiyinlaşadi, bir xil kod turli joylarda takrorlanadi. Şu muammoni hal qiliş uçun Python kodni modullarga böladi.

Modul — bu oddiy .py fayl. Uning içidagi funksiyalar, özgaruvçilar va sinflarni boşqa fayllarda qayta işlatiş mumkin. Masalan, hisob.py degan fayl yozsangiz, u hisob nomli modulga aylanadi.

Paket esa bir neçta modulni öz içiga olgan papka. Kutubxonalar odatda paket körinişida tarqatiladi. Masalan, json — bu standart kutubxonadagi paket, uning içida bir neçta modul bor.

Python bilan birga yuzlab tayyor modul keladi — bunga standart kutubxona deyiladi. Ular allaqaçon kompyuteringizda bor, faqat ularni import qiliş kifoya. Python dunyosida buni köpinça "batareyalar içida" (batteries included) deb ataydilar.

Modullarning foydasi:

• Tartib: boğliq kod bir joyda turadi.
• Qayta işlatiş: bir marta yozgan funksiyangizni önlab dasturda işlatasiz.
• Nomlar töqnaşmaydi: har bir modulning öz nomlar maydoni bor, şuning uçun math.sqrt va boşqa moduldagi sqrt bir-biriga xalaqit bermaydi.

#import qiliş usullari

#import modul

Eng oddiy va eng köp tavsiya etiladigan usul — butun modulni import qiliş. Keyin uning içidagi narsalarga nuqta orqali murojaat qilasiz.

import math

radius = 3
yuza = math.pi * radius ** 2
print(f"Doira yuzasi: {yuza:.2f}")
print(f"16 ning ildizi: {math.sqrt(16)}")

Natija:

Doira yuzasi: 28.27
16 ning ildizi: 4.0

Bu usulning afzalligi — kodni öqigan odam sqrt qayerdan kelganini darhol köradi: math modulidan.

#import modul as qisqa_nom

Agar modul nomi uzun bölsa yoki jamoada qabul qilingan qisqartma bölsa, as kalit sözi bilan unga taxallus beriş mumkin.

import statistics as st

baholar = [85, 92, 78, 90, 88]
print("Örtaça:", st.mean(baholar))
print("Mediana:", st.median(baholar))

Natija:

Örtaça: 86.6
Mediana: 88

Amaliyotda maşhur taxalluslar bor: import numpy as np, import pandas as pd. Ularni köp kodda uçratasiz.

#from modul import nom

Agar moduldan faqat bir-ikkita narsa kerak bölsa, ularni töğridan-töğri import qiliş mumkin. Şunda nuqtasiz işlatasiz.

from math import floor, ceil
from datetime import date

narx = 12_499.75
print("Pastga yaxlitlaş:", floor(narx))
print("Yuqoriga yaxlitlaş:", ceil(narx))
print("Yil:", date(2025, 3, 21).year)

Natija:

Pastga yaxlitlaş: 12499
Yuqoriga yaxlitlaş: 12500
Yil: 2025

#Nega from modul import * dan qoçiş kerak?

from math import * yozuvi modul içidagi hamma nomni sizning faylingizga tökib yuboradi. Bu xavfli, çunki:

• Qaysi nom qayerdan kelgani noaniq bölib qoladi.
• Modul içidagi nom sizning özgaruvçingizni bildirmasdan almaştirib yuborişi mumkin.

e = "elektron poçta"   # bizning özgaruvçimiz
from math import *      # math içida ham e bor!
print(e)

Natija:

2.718281828459045

Kördingizmi? Bizning e özgaruvçimiz jimgina math.e soni bilan almaşib qoldi. Şuning uçun yulduzçali importdan foydalanmang.

#math moduli bilan tanişuv

math — matematik amallar uçun standart modul. Eng köp işlatiladigan imkoniyatlari:

import math

# Töğri burçakli uçburçakning gipotenuzasi
a, b = 6, 8
print("Gipotenuza:", math.hypot(a, b))

# 30 gradusning sinusi
print("sin(30°):", round(math.sin(math.radians(30)), 2))

# 10 nafar talabadan 3 kişilik guruh neça xil usulda tuziladi?
print("Kombinatsiyalar soni:", math.comb(10, 3))

# Ikki sonning EKUBi va EKUKi
print("EKUB:", math.gcd(24, 36), "EKUK:", math.lcm(24, 36))

Natija:

Gipotenuza: 10.0
sin(30°): 0.5
Kombinatsiyalar soni: 120
EKUB: 12 EKUK: 72

Modul içida nimalar borligini biliş uçun dir() va help() funksiyalaridan foydalaning:

import math

nomlar = [n for n in dir(math) if not n.startswith("_")]
print(len(nomlar), "ta nom bor. Birinçi 8 tasi:")
print(nomlar[:8])

Natija:

61 ta nom bor. Birinçi 8 tasi:
['acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt']

#random moduli

random tasodifiy sonlar va tanlovlar bilan işlaydi. Öyinlar, test maʼlumotlari, lotereya, savollarni aralaştiriş — hammasi uçun kerak böladi.

• random.randint(a, b) — a va b oraliğidagi butun son (ikkala çegara ham kiradi).
• random.choice(royxat) — röyxatdan bitta tasodifiy element.
• random.shuffle(royxat) — röyxatni joyida aralaştiradi (yangi röyxat qaytarmaydi!).
• random.sample(royxat, k) — takrorlanmaydigan k ta element tanlaydi.
• random.random() — 0 va 1 oraliğidagi kasr son.

#seed — takrorlanadigan tasodif

Kompyuterdagi "tasodif" aslida maxsus formula bilan hisoblanadi. random.seed() ga bir xil son bersangiz, har safar bir xil "tasodifiy" ketma-ketlik olasiz. Bu test yozişda va natijani boşqalarga körsatişda juda qulay.

import random

random.seed(42)  # natija har doim bir xil bölişi uçun

mevalar = ["olma", "anor", "uzum", "şaftoli", "gilos"]
print("Bugungi meva:", random.choice(mevalar))
print("Zar taşlandi:", random.randint(1, 6))

savollar = [1, 2, 3, 4, 5, 6]
random.shuffle(savollar)
print("Aralaşgan savollar:", savollar)

talabalar = ["Aziz", "Dilnoza", "Jasur", "Malika", "Sardor", "Zarina"]
print("Navbatçilar:", random.sample(talabalar, 2))

Natija:

Bugungi meva: olma
Zar taşlandi: 1
Aralaşgan savollar: [4, 5, 1, 2, 3, 6]
Navbatçilar: ['Zarina', 'Aziz']

seed(42) qatorini öçirib, kodni bir neça marta işga tuşirib köring — har safar boşqa natija çiqadi.

import secrets
import string

belgilar = string.ascii_letters + string.digits
parol = "".join(secrets.choice(belgilar) for _ in range(12))
print("Parol uzunligi:", len(parol))

Natija:

Parol uzunligi: 12

#Öz modulingizni yoziş

Endi eng qiziq qismi — özimizning modulimizni yaratamiz. Tasavvur qiling, siz valyuta kursi bilan işlaydigan bir neçta dastur yozyapsiz. Konvertatsiya funksiyalarini alohida faylga çiqaramiz.

Birinçi fayl — valyuta.py:

# valyuta.py
"""Söm va boşqa valyutalar orasida konvertatsiya."""

KURSLAR = {"USD": 12_650, "EUR": 13_700, "TRY": 370}


def somga(miqdor: float, valyuta: str) -> float:
    """Çet el valyutasini sömga aylantiradi."""
    return miqdor * KURSLAR[valyuta]


def somdan(miqdor: float, valyuta: str) -> float:
    """Sömni çet el valyutasiga aylantiradi."""
    return miqdor / KURSLAR[valyuta]


if __name__ == "__main__":
    # Bu qism faqat fayl töğridan-töğri işga tuşirilganda bajariladi
    print("Modul sinovi:")
    print("100 USD =", somga(100, "USD"), "söm")

Ikkinçi fayl — xuddi şu papkadagi dokon.py:

# dokon.py
import valyuta

narx_som = 1_265_000
print(f"Narx dollarda: {valyuta.somdan(narx_som, 'USD'):.2f} USD")
print("Kurslar:", valyuta.KURSLAR)

dokon.py ni işga tuşirsangiz:

Narx dollarda: 100.00 USD
Kurslar: {'USD': 12650, 'EUR': 13700, 'TRY': 370}

Eʼtibor bering: Modul sinovi: degan yozuv çiqmadi. Buning sababi — if __name__ == "__main__": şarti.

#__name__ özgaruvçisi nima?

Python har bir faylga avtomatik ravişda __name__ degan özgaruvçi beradi:

• Faylni töğridan-töğri işga tuşirsangiz (python valyuta.py), __name__ qiymati "__main__" böladi.
• Faylni boşqa joydan import qilsangiz, __name__ modul nomiga teng böladi, yaʼni "valyuta".

Şu sababli if __name__ == "__main__": bloki içidagi kod faqat fayl "asosiy dastur" sifatida işlaganda bajariladi. Modulni import qilgan odam esa keraksiz sinov xabarlarini körmaydi. Bu Python dasturlarida juda keng tarqalgan andoza.

def salomlash(ism: str) -> str:
    return f"Salom, {ism}!"


print("Bu faylning nomi:", __name__)

if __name__ == "__main__":
    print(salomlash("Nodira"))

Natija:

Bu faylning nomi: __main__
Salom, Nodira!

#Oddiy paket tuzilişi

Modullar köpaygaç, ularni papkaga yiğiş mumkin:

dokon/
├── main.py
└── hisob/
    ├── __init__.py
    ├── valyuta.py
    └── çegirma.py

__init__.py fayli papkani paket ekanini bildiradi (u böş bölişi ham mumkin). Endi main.py içida şunday yozasiz:

from hisob import valyuta
from hisob.chegirma import chegirma_hisobla

print(valyuta.somga(50, "EUR"))

#pip va taşqi kutubxonalar

Standart kutubxonadan taşqari, butun dunyo dasturçilari yozgan yuz minglab paketlar PyPI saytida joylaşgan. Ularni örnatiş uçun pip dasturidan foydalaniladi.

# paketni oʻrnatish
pip install requests

# aniq versiyani oʻrnatish
pip install requests==2.32.3

# oʻrnatilgan paketlar roʻyxati
pip list

# paketni oʻchirish
pip uninstall requests

Baʼzi tizimlarda (macOS, Linux) buyruq pip3 yoki python3 -m pip körinişida yoziladi. Eng işonçli usul — python -m pip install ..., çunki u aynan siz işlatayotgan Python uçun örnatadi.

Paket örnatilgaç, uni oddiy modul kabi import qilasiz:

import requests

javob = requests.get("https://api.github.com")
print(javob.status_code)

#Virtual muhitlar (venv)

Tasavvur qiling: bir loyihangizga kutubxonaning 1-versiyasi, boşqasiga 2-versiyasi kerak. Agar hammasini kompyuterga umumiy örnatsangiz, ular töqnaşadi. Virtual muhit har bir loyiha uçun alohida "quti" yaratadi: öz Python nusxasi va öz paketlari bilan.

# 1. Loyiha papkasida virtual muhit yaratish
python -m venv .venv

# 2. Faollashtirish (macOS / Linux)
source .venv/bin/activate

# 2. Faollashtirish (Windows)
.venv\Scripts\activate

# 3. Endi pip faqat shu muhitga oʻrnatadi
pip install requests

# 4. Kerakli paketlar roʻyxatini faylga yozish
pip freeze > requirements.txt

# 5. Boshqa kompyuterda xuddi shu paketlarni oʻrnatish
pip install -r requirements.txt

# 6. Muhitdan chiqish
deactivate

Muhit faollaşganda terminal boşida (.venv) yozuvi paydo böladi. .venv papkasini git ga qöşmang — uning örniga requirements.txt faylini saqlang.

#Amaliy loyiha: Sonni top öyini

Örganganlarimizni birlaştiramiz: kompyuter 1 dan 100 gaça son öylaydi, öyinçi esa uni topişga harakat qiladi. Kompyuter har safar "kattaroq" yoki "kiçikroq" deb javob beradi.

Öyin mantiğini alohida funksiyaga çiqaramiz. Taxminni qayerdan oliş esa parametr orqali beriladi: taxmin_ol funksiyasi oldingi maslahatni ("kattaroq", "kiçikroq" yoki None) oladi va yangi sonni qaytaradi. Şu tufayli öyinni ham odam, ham avtomatik öyinçi bilan öynaş mumkin.

import random


def sonni_top(taxmin_ol, eng_kichik=1, eng_katta=100, urinishlar=7):
    sir = random.randint(eng_kichik, eng_katta)
    print(f"Men {eng_kichik} dan {eng_katta} gaça son öyladim. {urinishlar} ta imkoniyatingiz bor.")
    maslahat = None
    for urinish in range(1, urinishlar + 1):
        taxmin = taxmin_ol(maslahat)
        if taxmin < sir:
            maslahat = "kattaroq"
        elif taxmin > sir:
            maslahat = "kiçikroq"
        else:
            print(f"{urinish}) {taxmin} — Topdingiz! Tabriklayman!")
            return True
        print(f"{urinish}) {taxmin} — {maslahat} son ayting.")
    print(f"Afsus, imkoniyatlar tugadi. Javob: {sir}")
    return False


# Avtomatik öyinçi: har safar qolgan oraliqning örtasini aytadi
holat = {"past": 1, "yuqori": 100, "oxirgi": 0}

def aqlli_oyinchi(maslahat):
    if maslahat == "kattaroq":
        holat["past"] = holat["oxirgi"] + 1
    elif maslahat == "kiçikroq":
        holat["yuqori"] = holat["oxirgi"] - 1
    holat["oxirgi"] = (holat["past"] + holat["yuqori"]) // 2
    return holat["oxirgi"]


random.seed(7)
sonni_top(aqlli_oyinchi)

Natija:

Men 1 dan 100 gaça son öyladim. 7 ta imkoniyatingiz bor.
1) 50 — kiçikroq son ayting.
2) 25 — kattaroq son ayting.
3) 37 — kattaroq son ayting.
4) 43 — kiçikroq son ayting.
5) 40 — kattaroq son ayting.
6) 41 — kattaroq son ayting.
7) 42 — Topdingiz! Tabriklayman!

Avtomatik öyinçi "ikkiga böliş" usulidan foydalanadi: har bir taxmin qolgan oraliqni yarmiga qisqartiradi. Şuning uçun 1 dan 100 gaça istalgan sonni köpi bilan 7 urinişda topadi (çunki 2 ning 7-darajasi 128 > 100).

Endi özingiz öynaş uçun faqat taxmin oluvçi funksiyani almaştiring — sonni_top funksiyasiga tegiş şart emas:

def odam_oyinchi(maslahat):
    while True:
        matn = input("Taxminingiz: ")
        if matn.isdigit():
            return int(matn)
        print("Iltimos, butun son kiriting.")


sonni_top(odam_oyinchi)

Bu yerda modul bilan işlaşning yana bir foydasi körinadi: sonni_top funksiyasini oyin.py fayliga joylab, istalgan dasturdan from oyin import sonni_top deb çaqiriş mumkin.

#Xulosa

• Modul — bu .py fayl, paket — __init__.py fayli bor modullar papkasi.
• import modul eng aniq usul; as bilan taxallus beriladi; from modul import nom faqat kerakli nomlarni oladi.
• from modul import * nomlarni çalkaştirib yuboradi — undan foydalanmang.
• math matematik funksiyalar, random esa tasodifiy tanlovlar uçun; seed() natijani takrorlanadigan qiladi.
• if __name__ == "__main__": bloki faqat fayl töğridan-töğri işga tuşirilganda bajariladi.
• Taşqi paketlar pip bilan örnatiladi, har bir loyiha uçun esa venv bilan alohida virtual muhit yaratiladi.

#Maşqlar

1. math modulidan foydalanib, radiusi r bölgan şarning hajmini (4/3 · π · r³) hisoblaydigan shar_hajmi(r) funksiyasini yozing va r = 5 uçun natijani 2 xona aniqlikda çiqaring.

import math


def shar_hajmi(r: float) -> float:
    return 4 / 3 * math.pi * r ** 3


print(f"{shar_hajmi(5):.2f}")

1. random yordamida 6 xonali tasodifiy tasdiqlaş kodini (masalan, SMS kodi) yaratadigan funksiya yozing. Natija takrorlanişi uçun seed(2024) işlating.

import random


def tasdiq_kodi(uzunlik: int = 6) -> str:
    return "".join(str(random.randint(0, 9)) for _ in range(uzunlik))


random.seed(2024)
print(tasdiq_kodi())
print(tasdiq_kodi())

1. Sinfdagi 8 nafar öquvçini random.shuffle yordamida aralaştirib, 4 ta juftlikka ajrating va har bir juftlikni çiqaring.

import random

random.seed(1)
oquvchilar = ["Ali", "Bobur", "Gulnora", "Diyor", "Elyor", "Feruza", "Hilola", "Islom"]
random.shuffle(oquvchilar)
for i in range(0, len(oquvchilar), 2):
    print(f"{i // 2 + 1}-juftlik: {oquvchilar[i]} va {oquvchilar[i + 1]}")

1. geometriya.py nomli modul yozing: unda törtburçak yuzasini hisoblovçi turtburchak_yuzasi(a, b) va doira_yuzasi(r) funksiyalari bölsin, if __name__ == "__main__": blokida esa ularni sinab köring.

# geometriya.py
import math


def turtburchak_yuzasi(a: float, b: float) -> float:
    return a * b


def doira_yuzasi(r: float) -> float:
    return math.pi * r ** 2


if __name__ == "__main__":
    print(turtburchak_yuzasi(3, 4))      # 12
    print(round(doira_yuzasi(1), 2))     # 3.14

1. "Sonni top" öyinini özgartiring: öyin tugagaç, neçta urinişda topilganini qaytarsin (topilmasa 0). Avtomatik öyinçi bilan seed(3) va seed(10) uçun natijani çiqaring.

import random


def sonni_top(taxmin_ol, eng_kichik=1, eng_katta=100, urinishlar=7):
    sir = random.randint(eng_kichik, eng_katta)
    maslahat = None
    for urinish in range(1, urinishlar + 1):
        taxmin = taxmin_ol(maslahat)
        if taxmin == sir:
            return urinish
        maslahat = "kattaroq" if taxmin < sir else "kiçikroq"
    return 0


def yangi_oyinchi():
    holat = {"past": 1, "yuqori": 100, "oxirgi": 0}

    def oyinchi(maslahat):
        if maslahat == "kattaroq":
            holat["past"] = holat["oxirgi"] + 1
        elif maslahat == "kiçikroq":
            holat["yuqori"] = holat["oxirgi"] - 1
        holat["oxirgi"] = (holat["past"] + holat["yuqori"]) // 2
        return holat["oxirgi"]

    return oyinchi


for seed_qiymat in (3, 10):
    random.seed(seed_qiymat)
    print(f"seed={seed_qiymat}: {sonni_top(yangi_oyinchi())} ta uriniş")