Python kursi/Malumot tuzilmalari1/18-dars31 daqiqa

Mundarija (23)

6.1-dars: `list` — yaratish va indeks

6-QISM — MA'LUMOT TUZILMALARI · 1-dars

1. Kirish va motivatsiya

Shu paytgacha biz bitta qiymat bilan ishladik: son, satr, mantiqiy qiymat. Endi ma'lumot to'plamlariga o'tamiz.

list (ro'yxat) — Pythonda eng ko'p ishlatiladigan to'plam turi:

python

talabalar = ["Ali", "Vali", "Guli"]
ballar = [85, 92, 78]
aralash = [1, "matn", True, None, [1, 2]]

Sodda ko'rinadi. Lekin ro'yxatlar bilan bir necha muhim jihat bor:

python

a = [1, 2, 3]
b = a
b.append(4)
print(a)                        # [1, 2, 3, 4] — nega?!

python

jadval = [[0] * 3] * 3
jadval[0][0] = 1
print(jadval)                   # [[1,0,0], [1,0,0], [1,0,0]] — nega?!

python

royxat = [1, 2, 3]
print(royxat[5])                # ❌ IndexError
print(royxat[1:5])              # [2, 3] — xato yo'q

Bu darsda:

Ro'yxat yaratishning barcha usuli
Indekslash va kesimlar — chuqur
Yorliq modeli — nega b = a nusxa emas
[[0]*3]*3 tuzog'i
Ro'yxat va boshqa to'plamlar farqi

2. Nazariya — chuqur tushuntirish

2.1. Ro'yxat nima

Ro'yxat — tartiblangan, o'zgaruvchan, indekslanadigan obyektlar to'plami.

python

royxat = [1, 2, 3]

print(type(royxat))             # <class 'list'>
print(len(royxat))              # 3
print(royxat[0])                # 1

Asosiy xususiyatlari:

Xususiyat	`list`
Tartiblangan	Ha — kiritish tartibi saqlanadi
O'zgaruvchan	Ha — element qo'shish/o'chirish mumkin
Indekslanadigan	Ha — `royxat[0]`
Takrorlar	Ruxsat etiladi
Xeshlanadi	Yo'q — lug'at kaliti bo'la olmaydi
Turlar	Aralash bo'lishi mumkin

Aralash turlar:

python

aralash = [1, "matn", 3.14, True, None, [1, 2], {"a": 1}]
print(aralash)

Bu — texnik jihatdan mumkin, lekin amaliyotda kamdan-kam ishlatiladi. Odatda ro'yxat bir turdagi elementlardan iborat bo'ladi.

Tur ishoralari bilan (7-qism):

python

sonlar: list[int] = [1, 2, 3]
ismlar: list[str] = ["Ali", "Vali"]
aralash: list[int | str] = [1, "a"]

2.2. Ro'yxat yaratish

1. Literal:

python

bosh = []
sonlar = [1, 2, 3]
kop_qatorli = [
    "birinchi",
    "ikkinchi",
    "uchinchi",                 # ← oxirgi vergul ruxsat etiladi
]

Oxirgi vergul — yaxshi amaliyot. Git farqlari toza bo'ladi (3.14-dars).

2. list() konstruktori:

python

print(list())                   # []
print(list("abc"))              # ['a', 'b', 'c']
print(list((1, 2, 3)))          # [1, 2, 3]
print(list({1, 2, 3}))          # [1, 2, 3]
print(list({"a": 1, "b": 2}))   # ['a', 'b']  ← KALITLAR
print(list(range(5)))           # [0, 1, 2, 3, 4]
print(list(enumerate("ab")))    # [(0, 'a'), (1, 'b')]

list() har qanday iteratsiya qilinadigan obyektni qabul qiladi (5.6-dars).

3. Ko'paytirish:

python

print([0] * 5)                  # [0, 0, 0, 0, 0]
print(["a", "b"] * 3)           # ['a','b','a','b','a','b']
print([None] * 3)               # [None, None, None]

Ichma-ich ro'yxatlarda tuzoq — 2.6-bo'limda.

4. Ro'yxat generatori (15-dars):

python

print([x * 2 for x in range(5)])        # [0, 2, 4, 6, 8]
print([x for x in range(10) if x % 2])  # [1, 3, 5, 7, 9]

5. Boshqa usullar:

python

matn = "a,b,c"
print(matn.split(","))          # ['a', 'b', 'c']  (4.5-dars)

print(sorted([3, 1, 2]))        # [1, 2, 3]
print(list(reversed([1, 2, 3])))# [3, 2, 1]
print(list(zip([1, 2], "ab")))  # [(1, 'a'), (2, 'b')]

Bo'sh ro'yxat — [] yoki list()?

python

bosh1 = []                      # ✅ tezroq va idiomatik
bosh2 = list()                  # ⚠️ funksiya chaqiruvi

[] — tezroq, chunki bytecode darajasida to'g'ridan-to'g'ri yaratiladi.

2.3. Indekslash

python

royxat = ["a", "b", "c", "d", "e"]

#          a   b   c   d   e
#          0   1   2   3   4      ← musbat
#         -5  -4  -3  -2  -1      ← manfiy

print(royxat[0])                # 'a'
print(royxat[4])                # 'e'
print(royxat[-1])               # 'e'
print(royxat[-5])               # 'a'

Manfiy indeks formulasi (4.1-dars):

text

royxat[-i]  ≡  royxat[len(royxat) - i]

Chegaradan chiqish:

python

print(royxat[5])                # ❌ IndexError: list index out of range
print(royxat[-6])               # ❌ IndexError

Xavfsiz olish:

python

# 1. Tekshirish bilan
if 0 <= i < len(royxat):
    x = royxat[i]

# 2. Kesim bilan (xavfsiz)
x = royxat[i:i+1]               # bo'sh ro'yxat yoki bir elementli

# 3. try/except (9-qism)
try:
    x = royxat[i]
except IndexError:
    x = None

# 4. Funksiya
def xavfsiz(royxat, i, sukut=None):
    return royxat[i] if -len(royxat) <= i < len(royxat) else sukut

Element o'zgartirish:

python

royxat = [1, 2, 3]
royxat[0] = 10
print(royxat)                   # [10, 2, 3]

royxat[-1] = 30
print(royxat)                   # [10, 2, 30]

Satrlardan farqli o'laroq (4.12-dars), ro'yxat o'zgaruvchan.

Element o'chirish:

python

royxat = [1, 2, 3, 4]

del royxat[0]
print(royxat)                   # [2, 3, 4]

del royxat[-1]
print(royxat)                   # [2, 3]

2.4. Kesimlar

4.2-darsda satrlar uchun o'rgandik. Ro'yxatlarda bir xil ishlaydi:

python

royxat = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(royxat[2:5])              # [2, 3, 4]
print(royxat[:5])               # [0, 1, 2, 3, 4]
print(royxat[5:])               # [5, 6, 7, 8, 9]
print(royxat[::2])              # [0, 2, 4, 6, 8]
print(royxat[::-1])             # [9, 8, ..., 0]
print(royxat[-3:])              # [7, 8, 9]

Kesim — YANGI ro'yxat:

python

a = [1, 2, 3]
b = a[:]

print(a == b)                   # True  — mazmuni bir xil
print(a is b)                   # False — BOSHQA obyekt

b.append(4)
print(a)                        # [1, 2, 3] — o'zgarmadi ✅

Bu — satrdan farqi:

python

matn = "abc"
print(matn[:] is matn)          # True — satr o'zgarmas, nusxa kerak emas

royxat = [1, 2, 3]
print(royxat[:] is royxat)      # False — yangi ro'yxat

Kesim bilan o'zlashtirish — ro'yxatning noyob imkoniyati:

python

royxat = [0, 1, 2, 3, 4, 5]

# Oddiy kesim — uzunlik o'zgarishi MUMKIN
royxat[1:3] = [9, 9, 9]
print(royxat)                   # [0, 9, 9, 9, 3, 4, 5]

royxat[1:4] = []                # o'chirish
print(royxat)                   # [0, 3, 4, 5]

# Kengaytirilgan kesim — uzunlik MOS bo'lishi kerak
royxat = [0, 1, 2, 3, 4, 5]
royxat[::2] = [10, 20, 30]      # 3 o'rin, 3 qiymat
print(royxat)                   # [10, 1, 20, 3, 30, 5]

# royxat[::2] = [1, 2]          # ❌ ValueError

Amaliy foydalanish:

python

# Joyida almashtirish (havolani saqlab)
royxat[:] = [x for x in royxat if shart(x)]     # ✅ (5.6-dars)

# Boshiga qo'shish
royxat[:0] = [-1, 0]

# Oxiriga qo'shish
royxat[len(royxat):] = [10, 11]         # extend bilan bir xil

# Butun ro'yxatni almashtirish
royxat[:] = [1, 2, 3]

del kesim bilan:

python

royxat = [0, 1, 2, 3, 4, 5]
del royxat[1:3]
print(royxat)                   # [0, 3, 4, 5]

del royxat[::2]
print(royxat)                   # [3, 5]

2.5. Yorliq modeli — eng muhim tushuncha

3.1-darsda o'rgandik: Pythonda o'zgaruvchi — yorliq, quti emas.

python

a = [1, 2, 3]
b = a                           # YANGI ro'yxat EMAS — ikkinchi yorliq

print(a is b)                   # True — bitta obyekt
b.append(4)
print(a)                        # [1, 2, 3, 4] — a ham o'zgardi!

Vizual model:

text

   a ──────┐
           ↓
       ┌─────────────┐
       │ [1, 2, 3]   │
       └─────────────┘
           ↑
   b ──────┘

Nusxa olish — to'rt usul:

python

a = [1, 2, 3]

b = a[:]                        # kesim
c = a.copy()                    # metod (3.3+)
d = list(a)                     # konstruktor
import copy
e = copy.copy(a)                # copy moduli

for x in [b, c, d, e]:
    print(x == a, x is a)       # True False

Bularning hammasi — SAYOZ nusxa (shallow copy):

python

a = [[1, 2], [3, 4]]
b = a.copy()

b[0].append(99)                 # ichki ro'yxatni o'zgartirish
print(a)                        # [[1, 2, 99], [3, 4]] — a ham o'zgardi!

Sayoz nusxa tashqi ro'yxatni nusxalaydi, ichkilarini havola sifatida qoldiradi.

Chuqur nusxa (18-dars):

python

import copy

a = [[1, 2], [3, 4]]
b = copy.deepcopy(a)

b[0].append(99)
print(a)                        # [[1, 2], [3, 4]] — o'zgarmadi ✅

Funksiyaga uzatish:

python

def qosh(royxat):
    royxat.append(99)           # ❌ tashqaridagi ro'yxat o'zgaradi


asl = [1, 2]
qosh(asl)
print(asl)                      # [1, 2, 99]


def qosh_xavfsiz(royxat):
    return royxat + [99]        # ✅ yangi ro'yxat


asl = [1, 2]
yangi = qosh_xavfsiz(asl)
print(asl, yangi)               # [1, 2] [1, 2, 99]

2.6. `[[0]3]3` tuzog'i

python

jadval = [[0] * 3] * 3
print(jadval)                   # [[0,0,0], [0,0,0], [0,0,0]]

jadval[0][0] = 1
print(jadval)                   # [[1,0,0], [1,0,0], [1,0,0]]  ← hammasi!

Nima bo'ldi?

text

[[0] * 3] * 3
= [ichki] * 3
= [ichki, ichki, ichki]         ← BIR XIL obyektga uchta havola

python

jadval = [[0] * 3] * 3
print(jadval[0] is jadval[1])   # True — bitta obyekt!
print([id(q) for q in jadval])  # uchtasi ham bir xil

To'g'ri usullar:

python

# 1. Ro'yxat generatori (eng idiomatik)
jadval = [[0] * 3 for _ in range(3)]

# 2. Sikl bilan
jadval = []
for _ in range(3):
    jadval.append([0] * 3)

# 3. copy bilan
ichki = [0] * 3
jadval = [ichki[:] for _ in range(3)]

Tekshirish:

python

jadval = [[0] * 3 for _ in range(3)]
print(jadval[0] is jadval[1])   # False ✅
jadval[0][0] = 1
print(jadval)                   # [[1,0,0], [0,0,0], [0,0,0]] ✅

Bir o'lchovli ro'yxatda muammo yo'q:

python

royxat = [0] * 5                # ✅ xavfsiz
royxat[0] = 1
print(royxat)                   # [1, 0, 0, 0, 0]

Chunki int — o'zgarmas (4.12-dars). royxat[0] = 1 yangi obyektga yorliq qo'yadi.

Qoida:

* n bilan ko'paytirishda elementlar o'zgaruvchan bo'lsa — havola nusxalanadi.

Element	`* n` xavfsizmi
`int`, `str`, `tuple`, `None`	Ha (o'zgarmas)
`list`, `dict`, `set`	Yo'q
Sinf namunasi	Yo'q (odatda)

2.7. Ro'yxat va boshqa to'plamlar

python

royxat = [1, 2, 3]              # list  — o'zgaruvchan, tartiblangan
juftlik = (1, 2, 3)             # tuple — o'zgarmas, tartiblangan
toplam = {1, 2, 3}              # set   — o'zgaruvchan, tartibsiz, noyob
lugat = {"a": 1}                # dict  — kalit-qiymat

	`list`	`tuple`	`set`	`dict`
Tartiblangan				(3.7+)
O'zgaruvchan
Indekslanadi				Kalit bilan
Takrorlar				Kalitlar noyob
Xeshlanadi		*
`in` tezligi	O(n)	O(n)	O(1)	O(1)

* faqat elementlari xeshlanadigan bo'lsa

Qachon qaysi biri:

python

# list — tartib muhim, o'zgaradi
vazifalar = ["a", "b", "c"]
vazifalar.append("d")

# tuple — o'zgarmas ma'lumot, lug'at kaliti
koordinata = (10, 20)
lugat[(1, 2)] = "qiymat"

# set — noyoblik, tez tekshiruv
korilgan = set()
if x not in korilgan:           # O(1)
    korilgan.add(x)

# dict — kalit bo'yicha qidirish
narxlar = {"olma": 5000, "anor": 12000}

in tezligi — eng muhim farq (3.11-dars):

python

import time

katta_royxat = list(range(100_000))
katta_toplam = set(katta_royxat)

# O(n)
boshlandi = time.perf_counter()
99_999 in katta_royxat
vaqt_royxat = time.perf_counter() - boshlandi

# O(1)
boshlandi = time.perf_counter()
99_999 in katta_toplam
vaqt_toplam = time.perf_counter() - boshlandi

2.8. Solishtirish va tekshirish

Tenglik:

python

print([1, 2, 3] == [1, 2, 3])   # True  — mazmuni bir xil
print([1, 2, 3] is [1, 2, 3])   # False — turli obyekt
print([1, 2] == (1, 2))         # False — turli tur

Tartib bo'yicha (3.11-dars):

python

print([1, 2, 3] < [1, 2, 4])    # True  — 3-element
print([1, 2] < [1, 2, 3])       # True  — qisqasi oldin
print([2] > [1, 9, 9])          # True  — 1-element hal qiladi

Solishtirish element-element, chapdan o'ngga.

Aralash turlar:

python

print([1, "a"] == [1, "a"])     # True
# print([1, "a"] < [1, "b"])    # ❌ TypeError — int va str

Bo'shligini tekshirish (3.5-dars):

python

if royxat:                      # ✅ idiomatik
if not royxat:                  # ✅
if len(royxat) > 0:             # ⚠️ ortiqcha
if royxat != []:                # ❌

Element bormi:

python

print(3 in [1, 2, 3])           # True
print(4 not in [1, 2, 3])       # True

O(n) — sekin. Ko'p tekshiruv kerak bo'lsa set ishlating.

2.9. Xotira va tezlik

python

import sys

print(sys.getsizeof([]))                # 56 bayt
print(sys.getsizeof([1]))               # 64
print(sys.getsizeof([1, 2]))            # 72
print(sys.getsizeof(list(range(1000)))) # 8056

Formula (CPython, 64-bit):

text

56 bayt (sarlavha) + 8 bayt × elementlar soni

Bu — faqat havolalar hajmi. Elementlarning o'zi alohida:

python

royxat = ["a" * 1000 for _ in range(100)]

print(sys.getsizeof(royxat))            # ~920 — faqat havolalar
haqiqiy = sys.getsizeof(royxat) + sum(sys.getsizeof(x) for x in royxat)
print(haqiqiy)                          # ~105,000

Ortiqcha joy (over-allocation):

python

royxat = []
oldingi = sys.getsizeof(royxat)

for i in range(20):
    royxat.append(i)
    joriy = sys.getsizeof(royxat)
    if joriy != oldingi:
        print(f"  {len(royxat):>3} element → {joriy} bayt")
        oldingi = joriy

text

    1 element → 88 bayt
    5 element → 120 bayt
    9 element → 184 bayt
   17 element → 256 bayt

CPython ortiqcha joy ajratadi, shuning uchun append odatda O(1).

Amallar tezligi:

Amal	Murakkablik
`royxat[i]`	O(1)
`royxat[i] = x`	O(1)
`royxat.append(x)`	O(1) amortizatsiyalangan
`royxat.pop()`	O(1)
`royxat.pop(0)`	O(n)
`royxat.insert(0, x)`	O(n)
`x in royxat`	O(n)
`royxat.remove(x)`	O(n)
`len(royxat)`	O(1)
`royxat[a:b]`	O(b-a)
`royxat.sort()`	O(n log n)

Boshiga qo'shish/o'chirish — O(n). Ko'p bo'lsa collections.deque ishlating:

python

from collections import deque

navbat = deque([1, 2, 3])
navbat.appendleft(0)            # O(1) ✅
navbat.popleft()                # O(1) ✅

3. Tez ma'lumotnoma

Yaratish

python

[]                          bo'sh (tezroq)
list()                      bo'sh
[1, 2, 3]                   literal
list("abc")                 ['a','b','c']
list(range(5))              [0,1,2,3,4]
[0] * 5                     [0,0,0,0,0]
[x*2 for x in range(5)]     generator

Indeks va kesim

python

royxat[0]       birinchi
royxat[-1]      oxirgi
royxat[a:b]     kesim — YANGI ro'yxat
royxat[a:b] = x kesim bilan o'zlashtirish
del royxat[a:b] o'chirish
royxat[5]       IndexError
royxat[5:6]     [] — xavfsiz

Yorliq modeli

python

b = a           ❌ nusxa EMAS — ikkinchi yorliq
b = a[:]        ✅ sayoz nusxa
b = a.copy()    ✅ sayoz nusxa
b = list(a)     ✅ sayoz nusxa
deepcopy(a)     ✅ chuqur nusxa

Tuzoqlar

python

[[0]*3]*3               ❌ bitta ro'yxatga 3 havola
[[0]*3 for _ in range(3)]   ✅

a = [1,2]; b = a; b.append(3)   → a ham o'zgardi

Tezlik

text

royxat[i]           O(1)
append, pop()       O(1)
pop(0), insert(0,x) O(n)  ⚠️ deque ishlating
x in royxat         O(n)  ⚠️ set ishlating

4. Batafsil misollar

Misol 1 — Yaratish va indekslash

python

"""Ro'yxat yaratishning barcha usuli."""

import sys

print("=== 1. Yaratish usullari ===")

usullar = [
    ("[]",                      []),
    ("list()",                  list()),
    ("[1, 2, 3]",               [1, 2, 3]),
    ("list('abc')",             list("abc")),
    ("list((1, 2))",            list((1, 2))),
    ("list({1, 2, 3})",         list({1, 2, 3})),
    ("list({'a': 1, 'b': 2})",  list({"a": 1, "b": 2})),
    ("list(range(5))",          list(range(5))),
    ("list(enumerate('ab'))",   list(enumerate("ab"))),
    ("[0] * 5",                 [0] * 5),
    ("['a', 'b'] * 2",          ["a", "b"] * 2),
    ("[x*2 for x in range(4)]", [x * 2 for x in range(4)]),
    ("'a,b,c'.split(',')",      "a,b,c".split(",")),
    ("sorted([3, 1, 2])",       sorted([3, 1, 2])),
    ("list(reversed([1,2,3]))", list(reversed([1, 2, 3]))),
]

for kod, natija in usullar:
    print(f"  {kod:<26} → {natija}")

print("\n  ⚠️ list(lugat) — KALITLARNI beradi")


print("\n\n=== 2. [] vs list() tezligi ===")

import timeit

vaqt_bracket = timeit.timeit("[]", number=5_000_000)
vaqt_list = timeit.timeit("list()", number=5_000_000)

print(f"  []      {vaqt_bracket:.3f} s")
print(f"  list()  {vaqt_list:.3f} s  ({vaqt_list / vaqt_bracket:.1f}x sekinroq)")
print("\n  ⭐ [] tezroq — bytecode darajasida to'g'ridan-to'g'ri")


print("\n\n=== 3. Indekslash ===")

royxat = ["a", "b", "c", "d", "e"]

print(f"  Ro'yxat: {royxat}\n")
print(f"  {'Indeks':>8} {'Qiymat':>8}   {'Manfiy':>8} {'Qiymat':>8}")
print("  " + "─" * 40)
for i in range(len(royxat)):
    manfiy = i - len(royxat)
    print(f"  {i:>8} {royxat[i]!r:>8}   {manfiy:>8} {royxat[manfiy]!r:>8}")

print("\n  Chegaradan chiqish:")
for i in [5, -6]:
    try:
        royxat[i]
    except IndexError as x:
        print(f"    royxat[{i}] → IndexError: {x}")

print(f"\n  Kesim xavfsiz:")
print(f"    royxat[5:6]  → {royxat[5:6]}")
print(f"    royxat[10:20] → {royxat[10:20]}")


print("\n\n=== 4. Xavfsiz olish ===")


def xavfsiz(royxat, i, sukut=None):
    """Indeks bo'yicha xavfsiz olish."""
    return royxat[i] if -len(royxat) <= i < len(royxat) else sukut


for i in [0, 4, 5, -1, -6]:
    print(f"  xavfsiz(royxat, {i:>3}) → {xavfsiz(royxat, i)!r}")


print("\n\n=== 5. Kesim bilan o'zlashtirish ===")

print("  Oddiy kesim — uzunlik o'zgarishi mumkin:")
r = [0, 1, 2, 3, 4, 5]
print(f"    Asl:              {r}")

r[1:3] = [9, 9, 9]
print(f"    r[1:3] = [9,9,9]  {r}")

r[1:4] = []
print(f"    r[1:4] = []       {r}")

r[:0] = [-1]
print(f"    r[:0] = [-1]      {r}")

print("\n  Kengaytirilgan kesim — uzunlik MOS bo'lishi kerak:")
r = [0, 1, 2, 3, 4, 5]
print(f"    Asl:              {r}")

r[::2] = [10, 20, 30]
print(f"    r[::2] = [10,20,30] {r}")

try:
    r[::2] = [1, 2]
except ValueError as x:
    print(f"    r[::2] = [1,2]    → ValueError: {x}")


print("\n\n=== 6. del bilan o'chirish ===")

r = [0, 1, 2, 3, 4, 5]
print(f"  Asl:           {r}")

del r[0]
print(f"  del r[0]:      {r}")

del r[-1]
print(f"  del r[-1]:     {r}")

del r[1:3]
print(f"  del r[1:3]:    {r}")

r = [0, 1, 2, 3, 4, 5]
del r[::2]
print(f"  del r[::2]:    {r}")


print("\n\n=== 7. Xotira ===")

print(f"  {'Elementlar':>12} {'Xotira':>10} {'Element/bayt':>14}")
print("  " + "─" * 40)
for n in [0, 1, 10, 100, 1000, 10000]:
    r = list(range(n))
    hajm = sys.getsizeof(r)
    per = (hajm - 56) / n if n else 0
    print(f"  {n:>12,} {hajm:>10,} {per:>14.1f}")

print("\n  Formula: 56 bayt (sarlavha) + 8 bayt × elementlar")
print("  ⚠️ Bu — faqat HAVOLALAR hajmi, elementlar alohida")


print("\n\n=== 8. Ortiqcha joy (over-allocation) ===")

r = []
oldingi = sys.getsizeof(r)
print(f"  {'Elementlar':>12} {'Xotira':>10}")
print("  " + "─" * 24)
print(f"  {0:>12} {oldingi:>10}")

for i in range(35):
    r.append(i)
    joriy = sys.getsizeof(r)
    if joriy != oldingi:
        print(f"  {len(r):>12} {joriy:>10}")
        oldingi = joriy

print("\n  ⭐ CPython ortiqcha joy ajratadi → append odatda O(1)")

Natijaning muhim qismi:

text

=== 2. [] vs list() tezligi ===
  []      0.087 s
  list()  0.312 s  (3.6x sekinroq)

=== 5. Kesim bilan o'zlashtirish ===
  Oddiy kesim — uzunlik o'zgarishi mumkin:
    Asl:              [0, 1, 2, 3, 4, 5]
    r[1:3] = [9,9,9]  [0, 9, 9, 9, 3, 4, 5]
    r[1:4] = []       [0, 3, 4, 5]
    r[:0] = [-1]      [-1, 0, 3, 4, 5]

  Kengaytirilgan kesim — uzunlik MOS bo'lishi kerak:
    r[::2] = [10,20,30] [10, 1, 20, 3, 30, 5]
    r[::2] = [1,2]    → ValueError: attempt to assign sequence of size 2 to extended slice of size 3

=== 8. Ortiqcha joy (over-allocation) ===
    Elementlar     Xotira
  ────────────────────────
             0         56
             1         88
             5        120
             9        184
            17        248
            25        312
            33        376

Nima ko'rsatdi: 2.2, 2.3, 2.4, 2.9-bo'limlar.

Misol 2 — Yorliq modeli

python

"""Nusxa va havola — eng muhim tushuncha."""

import copy

print("=== 1. ❌ b = a nusxa EMAS ===")

a = [1, 2, 3]
b = a

print(f"  a = {a}")
print(f"  b = a")
print(f"  a is b: {a is b}  ← BITTA obyekt")
print(f"  id(a) = {id(a)}")
print(f"  id(b) = {id(b)}")

b.append(4)
print(f"\n  b.append(4) dan keyin:")
print(f"    a = {a}  ← a ham o'zgardi!")
print(f"    b = {b}")


print("\n\n=== 2. ✅ Nusxa olishning 4 usuli ===")

a = [1, 2, 3]

usullar = [
    ("a[:]",              a[:]),
    ("a.copy()",          a.copy()),
    ("list(a)",           list(a)),
    ("copy.copy(a)",      copy.copy(a)),
]

print(f"  a = {a}\n")
print(f"  {'Usul':<20} {'Teng?':>8} {'Bir xil obyekt?':>18}")
print("  " + "─" * 50)
for kod, nusxa in usullar:
    print(f"  {kod:<20} {str(nusxa == a):>8} {str(nusxa is a):>18}")

print("\n  Barchasi — SAYOZ nusxa")


print("\n\n=== 3. ⚠️ Sayoz nusxa cheklovi ===")

a = [[1, 2], [3, 4]]
b = a.copy()

print(f"  a = {a}")
print(f"  b = a.copy()")
print(f"    a is b:       {a is b}  ← turli obyekt ✅")
print(f"    a[0] is b[0]: {a[0] is b[0]}  ← ICHKI ro'yxat BIR XIL ⚠️")

b[0].append(99)
print(f"\n  b[0].append(99) dan keyin:")
print(f"    a = {a}  ← a ham o'zgardi!")
print(f"    b = {b}")

print("\n  ✅ Chuqur nusxa (18-dars):")
a = [[1, 2], [3, 4]]
b = copy.deepcopy(a)
b[0].append(99)
print(f"    a = {a}  ← o'zgarmadi ✅")
print(f"    b = {b}")


print("\n\n=== 4. ⭐ [[0]*3]*3 tuzog'i ===")

print("  ❌ Noto'g'ri:")
jadval = [[0] * 3] * 3
print(f"    jadval = [[0]*3]*3")
print(f"    {jadval}")
print(f"    jadval[0] is jadval[1]: {jadval[0] is jadval[1]}  ← BIR XIL!")
print(f"    id lar: {[id(q) for q in jadval]}")

jadval[0][0] = 1
print(f"\n    jadval[0][0] = 1 dan keyin:")
print(f"    {jadval}  ← HAMMASI o'zgardi!")

print("\n  ✅ To'g'ri:")
jadval = [[0] * 3 for _ in range(3)]
print(f"    jadval = [[0]*3 for _ in range(3)]")
print(f"    jadval[0] is jadval[1]: {jadval[0] is jadval[1]}  ← turli ✅")

jadval[0][0] = 1
print(f"\n    jadval[0][0] = 1 dan keyin:")
print(f"    {jadval}  ✅")


print("\n\n=== 5. * n qachon xavfsiz ===")

print(f"  {'Element turi':<20} {'* n xavfsizmi':>16} {'Sabab'}")
print("  " + "─" * 60)

sinovlar = [
    ("int", [0] * 3, "o'zgarmas"),
    ("str", ["a"] * 3, "o'zgarmas"),
    ("None", [None] * 3, "o'zgarmas"),
    ("tuple", [(1, 2)] * 3, "o'zgarmas"),
    ("list", [[0]] * 3, "O'ZGARUVCHAN ⚠️"),
    ("dict", [{}] * 3, "O'ZGARUVCHAN ⚠️"),
]

for nom, royxat, sabab in sinovlar:
    xavfsiz = royxat[0] is not royxat[1] or not hasattr(royxat[0], "__setitem__")
    belgi = "✅" if xavfsiz else "❌"
    print(f"  {nom:<20} {belgi:>16} {sabab}")

print("\n  Tekshirish:")
r = [0] * 3
r[0] = 1
print(f"    [0]*3, r[0]=1  → {r}  ✅ (int o'zgarmas)")

r = [[0]] * 3
r[0][0] = 1
print(f"    [[0]]*3, r[0][0]=1 → {r}  ❌")


print("\n\n=== 6. Funksiyaga uzatish ===")


def ozgartiradi(royxat):
    royxat.append(99)


def ozgartirmaydi(royxat):
    return royxat + [99]


def ozgartirmaydi2(royxat):
    royxat = royxat + [99]      # mahalliy yorliq
    return royxat


asl = [1, 2]
ozgartiradi(asl)
print(f"  ozgartiradi([1,2])   → asl = {asl}  ❌")

asl = [1, 2]
yangi = ozgartirmaydi(asl)
print(f"  ozgartirmaydi([1,2]) → asl = {asl}, yangi = {yangi}  ✅")

asl = [1, 2]
yangi = ozgartirmaydi2(asl)
print(f"  ozgartirmaydi2       → asl = {asl}, yangi = {yangi}  ✅")


print("\n\n=== 7. Joyida almashtirish ===")

a = [1, 2, 3, 4]
b = a
print(f"  a = {a}, b = a")

a = [x for x in a if x % 2]
print(f"\n  a = [x for x in a if x % 2]")
print(f"    a = {a}")
print(f"    b = {b}  ← b o'zgarmadi ❌")

a = [1, 2, 3, 4]
b = a
a[:] = [x for x in a if x % 2]
print(f"\n  a[:] = [x for x in a if x % 2]")
print(f"    a = {a}")
print(f"    b = {b}  ← b ham o'zgardi ✅")

print("\n  ⭐ [:] — havolani saqlab, mazmunni almashtiradi")

Natijaning muhim qismi:

text

=== 4. ⭐ [[0]*3]*3 tuzog'i ===
  ❌ Noto'g'ri:
    jadval = [[0]*3]*3
    [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
    jadval[0] is jadval[1]: True  ← BIR XIL!
    id lar: [1127389314752, 1127389314752, 1127389314752]

    jadval[0][0] = 1 dan keyin:
    [[1, 0, 0], [1, 0, 0], [1, 0, 0]]  ← HAMMASI o'zgardi!

  ✅ To'g'ri:
    jadval = [[0]*3 for _ in range(3)]
    jadval[0] is jadval[1]: False  ← turli ✅
    [[1, 0, 0], [0, 0, 0], [0, 0, 0]]  ✅

=== 7. Joyida almashtirish ===
  a[:] = [x for x in a if x % 2]
    a = [1, 3]
    b = [1, 3]  ← b ham o'zgardi ✅

Nima ko'rsatdi: 2.5, 2.6-bo'limlar.

Misol 3 — To'plamlarni solishtirish

python

"""list, tuple, set, dict — qachon qaysi biri."""

import sys
import time

print("=== 1. Xususiyatlar jadvali ===")

print(f"  {'Xususiyat':<18} {'list':>8} {'tuple':>8} {'set':>8} {'dict':>8}")
print("  " + "─" * 54)

xususiyatlar = [
    ("Tartiblangan",    "✅", "✅", "❌", "✅"),
    ("O'zgaruvchan",    "✅", "❌", "✅", "✅"),
    ("Indekslanadi",    "✅", "✅", "❌", "kalit"),
    ("Takrorlar",       "✅", "✅", "❌", "❌"),
    ("Xeshlanadi",      "❌", "✅*", "❌", "❌"),
    ("in tezligi",      "O(n)", "O(n)", "O(1)", "O(1)"),
]

for nom, *qiymatlar in xususiyatlar:
    print(f"  {nom:<18}" + "".join(f"{q:>9}" for q in qiymatlar))

print("\n  * tuple xeshlanadi — elementlari xeshlanadigan bo'lsa")


print("\n\n=== 2. Xotira ===")

N = 10_000
malumot = list(range(N))

turlar = [
    ("list", list(malumot)),
    ("tuple", tuple(malumot)),
    ("set", set(malumot)),
    ("dict", {x: None for x in malumot}),
]

print(f"  {N:,} element:\n")
print(f"  {'Tur':<10} {'Xotira':>14} {'Nisbat':>9}")
print("  " + "─" * 36)

eng_kichik = min(sys.getsizeof(x) for _, x in turlar)
for nom, obyekt in turlar:
    hajm = sys.getsizeof(obyekt)
    print(f"  {nom:<10} {hajm:>14,} {hajm / eng_kichik:>8.1f}x")


print("\n\n=== 3. `in` tezligi ===")

N = 200_000
royxat = list(range(N))
juftlik = tuple(royxat)
toplam = set(royxat)
lugat = {x: None for x in royxat}

QIDIRUV = N - 1
MARTA = 1000

natijalar = []
for nom, konteyner in [("list", royxat), ("tuple", juftlik),
                       ("set", toplam), ("dict", lugat)]:
    boshlandi = time.perf_counter()
    for _ in range(MARTA):
        QIDIRUV in konteyner
    natijalar.append((nom, time.perf_counter() - boshlandi))

eng_tez = min(v for _, v in natijalar)
print(f"  {MARTA:,} ta tekshiruv, {N:,} elementli konteynerda:\n")
print(f"  {'Tur':<10} {'Vaqt':>12} {'Nisbat':>12}")
print("  " + "─" * 38)
for nom, vaqt in sorted(natijalar, key=lambda x: x[1]):
    print(f"  {nom:<10} {vaqt * 1000:>9.3f} ms {vaqt / eng_tez:>11,.0f}x")


print("\n\n=== 4. Amallar tezligi ===")

N = 50_000

print(f"  Ro'yxat amallari ({N:,} element):\n")

# append
r = []
boshlandi = time.perf_counter()
for i in range(N):
    r.append(i)
vaqt_append = time.perf_counter() - boshlandi

# insert(0)
r = []
boshlandi = time.perf_counter()
for i in range(N // 10):        # 10x kam, chunki sekin
    r.insert(0, i)
vaqt_insert = (time.perf_counter() - boshlandi) * 10

# pop()
r = list(range(N))
boshlandi = time.perf_counter()
for _ in range(N):
    r.pop()
vaqt_pop = time.perf_counter() - boshlandi

# pop(0)
r = list(range(N // 10))
boshlandi = time.perf_counter()
for _ in range(N // 10):
    r.pop(0)
vaqt_pop0 = (time.perf_counter() - boshlandi) * 10

print(f"  {'Amal':<20} {'Vaqt':>10} {'Murakkablik':>14}")
print("  " + "─" * 46)
print(f"  {'append(x)':<20} {vaqt_append * 1000:>7.1f} ms {'O(1)':>14}")
print(f"  {'pop()':<20} {vaqt_pop * 1000:>7.1f} ms {'O(1)':>14}")
print(f"  {'pop(0)':<20} {vaqt_pop0 * 1000:>7.1f} ms {'O(n)':>14}")
print(f"  {'insert(0, x)':<20} {vaqt_insert * 1000:>7.1f} ms {'O(n)':>14}")


print("\n\n=== 5. deque — boshiga qo'shish uchun ===")

from collections import deque

N = 50_000

# list
r = []
boshlandi = time.perf_counter()
for i in range(N // 10):
    r.insert(0, i)
vaqt_list = (time.perf_counter() - boshlandi) * 10

# deque
d = deque()
boshlandi = time.perf_counter()
for i in range(N):
    d.appendleft(i)
vaqt_deque = time.perf_counter() - boshlandi

print(f"  {N:,} marta boshiga qo'shish:\n")
print(f"    list.insert(0, x):  {vaqt_list * 1000:>9.1f} ms   O(n)")
print(f"    deque.appendleft(): {vaqt_deque * 1000:>9.1f} ms   O(1)")
print(f"    Tezlik farqi:       {vaqt_list / vaqt_deque:>9.0f}x")


print("\n\n=== 6. Qachon qaysi biri ===")

print(f"""
  {'Vaziyat':<40} {'Yechim'}
  {'─' * 60}
  {'Tartib muhim, oʻzgaradi':<40} list
  {'Oʻzgarmas maʻlumot':<40} tuple
  {'Lugʻat kaliti':<40} tuple
  {'Noyoblik kerak':<40} set
  {'Tez `in` tekshiruvi':<40} set
  {'Kalit → qiymat':<40} dict
  {'Boshiga tez qoʻshish':<40} deque
  {'Ikki tomondan navbat':<40} deque
  {'Sobit uzunlik, tez':<40} array / numpy
""")


print("=== 7. Solishtirish ===")

print("  Tenglik:")
print(f"    [1,2,3] == [1,2,3]  → {[1, 2, 3] == [1, 2, 3]}")
print(f"    [1,2,3] is [1,2,3]  → {[1, 2, 3] is [1, 2, 3]}")
print(f"    [1,2] == (1,2)      → {[1, 2] == (1, 2)}  ← turli tur")
print(f"    [1,2] == {{1,2}}      → {[1, 2] == {1, 2}}")

print("\n  Tartib (element-element):")
print(f"    [1,2,3] < [1,2,4]   → {[1, 2, 3] < [1, 2, 4]}")
print(f"    [1,2] < [1,2,3]     → {[1, 2] < [1, 2, 3]}")
print(f"    [2] > [1,9,9]       → {[2] > [1, 9, 9]}")

print("\n  ⚠️ Aralash turlar:")
try:
    [1, "a"] < [1, "b"]
except TypeError as x:
    print(f"    [1,'a'] < [1,'b'] → TypeError: {x}")

Natijaning muhim qismi:

text

=== 3. `in` tezligi ===
  1,000 ta tekshiruv, 200,000 elementli konteynerda:

  Tur            Vaqt       Nisbat
  ──────────────────────────────────────
  set           0.048 ms           1x
  dict          0.051 ms           1x
  list       1847.230 ms      38,484x
  tuple      1823.410 ms      37,988x

=== 5. deque — boshiga qo'shish uchun ===
  50,000 marta boshiga qo'shish:

    list.insert(0, x):     284.3 ms   O(n)
    deque.appendleft():      3.1 ms   O(1)
    Tezlik farqi:             92x

Nima ko'rsatdi: 2.7, 2.8, 2.9-bo'limlar.

Misol 4 — Amaliy: ro'yxat bilan ishlash

python

"""Ro'yxatlar bilan tipik vazifalar."""

from dataclasses import dataclass

print("=== 1. Matritsa yaratish ===")


def matritsa(qatorlar: int, ustunlar: int, sukut=0) -> list[list]:
    """Xavfsiz matritsa yaratish."""
    return [[sukut] * ustunlar for _ in range(qatorlar)]


m = matritsa(3, 4)
print(f"  matritsa(3, 4):")
for q in m:
    print(f"    {q}")

m[0][0] = 1
m[1][1] = 2
m[2][2] = 3
print(f"\n  Diagonal to'ldirilgandan keyin:")
for q in m:
    print(f"    {q}")

print("\n  ❌ Noto'g'ri usul:")
yomon = [[0] * 4] * 3
yomon[0][0] = 1
for q in yomon:
    print(f"    {q}")


print("\n\n=== 2. Kesim bilan amallar ===")

r = list(range(10))
print(f"  Asl: {r}\n")

amallar = [
    ("Birinchi 3",          r[:3]),
    ("Oxirgi 3",            r[-3:]),
    ("Ikkalasisiz",         r[1:-1]),
    ("Har ikkinchisi",      r[::2]),
    ("Teskari",             r[::-1]),
    ("Teskari, har 3-si",   r[::-3]),
    ("O'rtasi",             r[3:7]),
]

for nom, natija in amallar:
    print(f"  {nom:<20} {natija}")


print("\n\n=== 3. Bo'laklarga bo'lish ===")


def boklarga_bol(royxat: list, hajm: int) -> list[list]:
    """Ro'yxatni teng bo'laklarga bo'ladi."""
    return [royxat[i:i + hajm] for i in range(0, len(royxat), hajm)]


r = list(range(1, 11))
print(f"  Asl: {r}\n")
for hajm in [2, 3, 4]:
    print(f"  hajm={hajm}: {boklarga_bol(r, hajm)}")


print("\n\n=== 4. Aylantirish ===")


def aylantir(royxat: list, n: int) -> list:
    """Ro'yxatni n pozitsiyaga aylantiradi."""
    if not royxat:
        return royxat[:]
    n %= len(royxat)
    return royxat[n:] + royxat[:n]


r = ["a", "b", "c", "d", "e"]
print(f"  Asl: {r}\n")
for n in [0, 1, 2, -1, -2, 5, 7]:
    print(f"  aylantir(r, {n:>3}) → {aylantir(r, n)}")


print("\n\n=== 5. Amaliy: talabalar jadvali ===")


@dataclass
class Talaba:
    ism: str
    ballar: list[int]

    @property
    def ortacha(self) -> float:
        return sum(self.ballar) / len(self.ballar) if self.ballar else 0.0

    @property
    def eng_yuqori(self) -> int:
        return max(self.ballar) if self.ballar else 0

    @property
    def eng_past(self) -> int:
        return min(self.ballar) if self.ballar else 0


TALABALAR = [
    Talaba("Sarvarbek", [88, 92, 85, 90]),
    Talaba("Aziza", [95, 98, 91, 94]),
    Talaba("Bekzod", [72, 68, 75, 80]),
    Talaba("Dilnoza", [91, 85, 88, 93]),
]

w = max(len(t.ism) for t in TALABALAR)

print(f"  {'Talaba':<{w}}  {'Ballar':<20} {'Oʻrtacha':>9} "
      f"{'Max':>5} {'Min':>5}")
print("  " + "─" * (w + 44))

for t in TALABALAR:
    ballar = ", ".join(str(b) for b in t.ballar)
    print(f"  {t.ism:<{w}}  {ballar:<20} {t.ortacha:>9.1f} "
          f"{t.eng_yuqori:>5} {t.eng_past:>5}")

# Umumiy statistika
barcha_ballar = [b for t in TALABALAR for b in t.ballar]      # tekislash
print("  " + "─" * (w + 44))
print(f"  {'JAMI':<{w}}  {len(barcha_ballar)} ta ball        "
      f"{sum(barcha_ballar) / len(barcha_ballar):>9.1f} "
      f"{max(barcha_ballar):>5} {min(barcha_ballar):>5}")


print("\n\n=== 6. Ichma-ich ro'yxatni tekislash ===")

ichma_ich = [[1, 2], [3, 4, 5], [6], [], [7, 8]]
print(f"  Asl: {ichma_ich}\n")

# Generator bilan
tekis1 = [x for qator in ichma_ich for x in qator]
print(f"  Generator:        {tekis1}")

# itertools.chain bilan
from itertools import chain
tekis2 = list(chain(*ichma_ich))
print(f"  chain(*):         {tekis2}")
print(f"  chain.from_iterable: {list(chain.from_iterable(ichma_ich))}")

# sum bilan (⚠️ sekin)
tekis3 = sum(ichma_ich, [])
print(f"  sum(x, []):       {tekis3}  ← ⚠️ O(n²), ishlatmang")

assert tekis1 == tekis2 == tekis3


print("\n\n=== 7. Xavfsiz amallar ===")


def xavfsiz_olish(royxat, i, sukut=None):
    return royxat[i] if -len(royxat) <= i < len(royxat) else sukut


def birinchi(royxat, sukut=None):
    return royxat[0] if royxat else sukut


def oxirgi(royxat, sukut=None):
    return royxat[-1] if royxat else sukut


def ortacha(royxat, sukut=0.0):
    return sum(royxat) / len(royxat) if royxat else sukut


sinovlar = [[1, 2, 3], []]

print(f"  {'Roʻyxat':<12} {'birinchi':>10} {'oxirgi':>10} "
      f"{'[5]':>8} {'ortacha':>10}")
print("  " + "─" * 54)
for r in sinovlar:
    print(f"  {str(r):<12} {str(birinchi(r)):>10} {str(oxirgi(r)):>10} "
          f"{str(xavfsiz_olish(r, 5)):>8} {ortacha(r):>10.1f}")

Natijaning muhim qismi:

text

=== 1. Matritsa yaratish ===
  Diagonal to'ldirilgandan keyin:
    [1, 0, 0, 0]
    [0, 2, 0, 0]
    [0, 0, 3, 0]

  ❌ Noto'g'ri usul:
    [1, 0, 0, 0]
    [1, 0, 0, 0]
    [1, 0, 0, 0]

=== 5. Amaliy: talabalar jadvali ===
  Talaba     Ballar                Oʻrtacha   Max   Min
  ──────────────────────────────────────────────────────
  Sarvarbek  88, 92, 85, 90            88.8    92    85
  Aziza      95, 98, 91, 94            94.5    98    91
  Bekzod     72, 68, 75, 80            73.8    80    68
  Dilnoza    91, 85, 88, 93            89.2    93    85
  ──────────────────────────────────────────────────────
  JAMI       16 ta ball                86.6    98    68

Nima ko'rsatdi: 2.4, 2.6-bo'limlar amaliyotda.

5. To'g'ri va noto'g'ri tushunishlar

Noto'g'ri fikr	To'g'risi
"`b = a` nusxa yaratadi"	Ikkinchi yorliq. `a[:]` yoki `.copy()`
"`[[0]3]3` matritsa yaratadi"	Bitta ro'yxatga uchta havola
"`.copy()` to'liq nusxa"	Sayoz — ichki obyektlar havola bo'lib qoladi
"`royxat[:] is royxat`"	`False` — yangi ro'yxat. Satrda esa `True`
"`in` tez"	O(n). Ko'p tekshiruv uchun `set`
"`insert(0, x)` va `append(x)` bir xil"	`insert(0)` — O(n), `append` — O(1)
"`[]` va `list()` bir xil"	`[]` tezroq
"`sum(ichma_ich, [])` yaxshi usul"	O(n²). `chain.from_iterable` ishlating

6. Keng tarqalgan xatolar va yechimlari

1. Nusxa o'rniga yorliq

python

nusxa = asl                     # ❌
nusxa = asl[:]                  # ✅
nusxa = asl.copy()              # ✅ aniqroq

2. [[0]*n]*m

python

jadval = [[0] * 3] * 3                  # ❌
jadval = [[0] * 3 for _ in range(3)]    # ✅

3. Sayoz nusxa ichma-ich ro'yxatda

python

b = a.copy()                    # ⚠️ ichki ro'yxatlar umumiy
import copy
b = copy.deepcopy(a)            # ✅

4. IndexError

python

x = royxat[i]                   # ❌ chegara tekshirilmagan
x = royxat[i] if i < len(royxat) else None      # ✅
x = royxat[i:i+1]               # ✅ kesim xavfsiz

5. Iteratsiya paytida o'zgartirish (5.6-dars)

python

for x in royxat:
    royxat.remove(x)            # ❌

royxat[:] = [x for x in royxat if shart(x)]     # ✅

6. insert(0) siklda

python

for x in malumot:
    royxat.insert(0, x)         # ❌ O(n²)

from collections import deque   # ✅
d = deque()
for x in malumot:
    d.appendleft(x)

7. in bilan O(n²)

python

for x in katta_a:
    if x in katta_b:            # ❌ O(n²)
        ...

b_set = set(katta_b)            # ✅ O(n)
for x in katta_a:
    if x in b_set:
        ...

8. Funksiyada ro'yxatni o'zgartirish

python

def f(royxat):
    royxat.append(1)            # ❌ tashqarida ham o'zgaradi

def f(royxat):
    return royxat + [1]         # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

6.2-dars: list metodlari — append, pop, remove
6.4-dars: ro'yxat va xotira — chuqur
6.18-dars: copy va deepcopy
3.1-dars (o'tilgan): yorliq modeli
4.2-dars (o'tilgan): kesimlar
5.6-dars (o'tilgan): iteratsiya, o'zgartirish tuzog'i
7-qism: funksiyaga ro'yxat uzatish, sukut argument
31-qism: ma'lumot tuzilmalari va algoritmlar

8. Eng yaxshi amaliyotlar

b = a nusxa emas. Nusxa uchun .copy() — u niyatni aniq bildiradi.
[[0]*n for _ in range(m)] ishlating. [[0]*n]*m — tuzoq.
Bo'sh ro'yxat uchun []. list() dan tezroq.
Kesim — yangi ro'yxat. royxat[:] bilan nusxa oling, royxat[:] = ... bilan joyida almashtiring.
in uchun set. Sikl ichida ro'yxatda qidirish — O(n²).
Boshiga qo'shish uchun deque. insert(0, x) — O(n).
Funksiyada ro'yxatni o'zgartirmang. Yangi ro'yxat qaytaring.
Tur ishorasi yozing. list[int] — kod hujjatlashadi (7-qism).

9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python

1.  a = [1,2,3]; b = a; b.append(4); print(a)
2.  a = [1,2,3]; b = a[:]; b.append(4); print(a)
3.  print([[0]*2]*2)
4.  j = [[0]*2]*2; j[0][0]=1; print(j)
5.  j = [[0]*2 for _ in range(2)]; j[0][0]=1; print(j)
6.  print([0]*3 == [0,0,0])
7.  r = [1,2,3]; print(r[:] is r)
8.  print(list({"a":1, "b":2}))
9.  r = [0,1,2,3]; r[1:3] = [9]; print(r)
10. print(len([1,2,3] + [4]))

Javoblar

[1, 2, 3, 4]
[1, 2, 3]
[[0, 0], [0, 0]]
[[1, 0], [1, 0]] — tuzoq
[[1, 0], [0, 0]] —
True
False
['a', 'b'] — kalitlar
[0, 9, 3]
4

Vazifa 2: Xatolarni tuzatish

python

1.  nusxa = asl
2.  jadval = [[None] * 5] * 3
3.  for x in royxat:
        if shart(x): royxat.remove(x)
4.  for x in katta_a:
        if x in katta_b: natija.append(x)
5.  natija = []
    for x in malumot:
        natija.insert(0, x)

Javoblar

python

1.  nusxa = asl.copy()
2.  jadval = [[None] * 5 for _ in range(3)]
3.  royxat[:] = [x for x in royxat if not shart(x)]
4.  b_set = set(katta_b)
    natija = [x for x in katta_a if x in b_set]
5.  natija = list(reversed(malumot))
    # yoki: deque + appendleft

Vazifa 3: Matritsa kutubxonasi

Funksiyalar yozing:

matritsa(q, u, sukut=0) — xavfsiz yaratish
birlik(n) — birlik matritsa
nusxa(m) — chuqur nusxa (deepcopy siz)
teng(a, b) — solishtirish
chiqar(m) — chiroyli chiqarish

Vazifa 4: Xavfsiz ro'yxat

Funksiyalar yozing (barchasi bo'sh ro'yxatda ham ishlasin):

birinchi(r, sukut=None)
oxirgi(r, sukut=None)
olish(r, i, sukut=None)
ortacha(r, sukut=0.0)
eng_katta(r, sukut=None)
bolaklar(r, n) — n ta teng bo'lakka bo'lish

Vazifa 5: Tekislash

tekisla(ichma_ich, chuqurlik=None) funksiyasini yozing:

chuqurlik=None — to'liq tekislash (rekursiv)
chuqurlik=1 — faqat bir daraja
Satrlarni tekislamasin

python

tekisla([1, [2, [3, [4]]]])         # [1, 2, 3, 4]
tekisla([1, [2, [3, [4]]]], 1)      # [1, 2, [3, [4]]]
tekisla(["ab", ["cd"]])             # ['ab', 'cd']  — satr tekislanmaydi

Vazifa 6: Xotira tahlili

Dastur yozing:

Turli hajmdagi ro'yxatlar uchun xotirani o'lchang
Ortiqcha joy (over-allocation) naqshini toping
list, tuple, set, dict ni solishtiring
Ichma-ich ro'yxatlar uchun haqiqiy xotirani hisoblang

Vazifa 7: O'ylash

Nega [[0]*3]*3 uchta bir xil ro'yxat beradi, lekin [0]*3 uchta bir xil 0 bermaydi?

Javob

Aslida beradi — lekin bu muhim emas.

python

r = [0] * 3
print(r[0] is r[1])             # True — bitta 0 obyekti!

0 — kichik son, CPython uni keshlaydi (3.1-dars). Ikkalasida ham bir xil obyektga havola nusxalanadi.

Farq — o'zgaruvchanlikda:

python

# int — O'ZGARMAS
r = [0] * 3
r[0] = 1                        # ✅ yangi obyektga YORLIQ qo'yildi
print(r)                        # [1, 0, 0]

# list — O'ZGARUVCHAN
j = [[0]] * 3
j[0][0] = 1                     # ❌ OBYEKTNI o'zgartirdi
print(j)                        # [[1], [1], [1]]

Kalit farq:

text

r[0] = 1        → YORLIQ ni o'zgartiradi (0-indeksdagi havola)
j[0][0] = 1     → OBYEKT ni o'zgartiradi (barcha havola ko'radi)

r[0] = 1 ro'yxatning 0-katagiga yangi havola yozadi. Boshqa kataklar ta'sirlanmaydi.

j[0][0] = 1 esa 0-katakdagi obyektni o'zgartiradi — va 1, 2-kataklar ham shu obyektga ishora qiladi.

Umumiy qoida:

* n bilan ko'paytirishda havolalar nusxalanadi. Elementlar o'zgarmas bo'lsa muammo yo'q, o'zgaruvchan bo'lsa — tuzoq.

Nimani mustahkamlaydi: 2.2, 2.3, 2.5, 2.6, 2.9-bo'limlar.

Xulosa

Bu darsda ro'yxatlar bilan tanishdik.

Eng muhim uch fikr:

b = a nusxa yaratmaydi. Bu — ikkinchi yorliq bir xil obyektga. Nusxa uchun .copy(), [:] yoki list(). Va bular sayoz nusxa — ichki obyektlar umumiy qoladi.
[[0]*3]*3 — matritsa emas. U bitta ro'yxatga uchta havola yaratadi. To'g'ri usul: [[0]*3 for _ in range(3)].
Amallar tezligi turlicha. append va royxat[i] — O(1); insert(0), pop(0) va in — O(n). Boshiga qo'shish uchun deque, tez tekshiruv uchun set.

Keyingi darsda list metodlarini o'rganamiz: append, extend, insert, remove, pop, clear, index, count va ularning nozik jihatlari.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

Hozircha izoh yo'q. Birinchi bo'ling!

6.1-dars: list — yaratish va indeks

1. Kirish va motivatsiya

2. Nazariya — chuqur tushuntirish

2.1. Ro'yxat nima

2.2. Ro'yxat yaratish

2.3. Indekslash

2.4. Kesimlar

2.5. Yorliq modeli — eng muhim tushuncha

2.6. [[0]*3]*3 tuzog'i

2.7. Ro'yxat va boshqa to'plamlar

2.8. Solishtirish va tekshirish

2.9. Xotira va tezlik

3. Tez ma'lumotnoma

4. Batafsil misollar

Misol 1 — Yaratish va indekslash

Misol 2 — Yorliq modeli

Misol 3 — To'plamlarni solishtirish

Misol 4 — Amaliy: ro'yxat bilan ishlash

5. To'g'ri va noto'g'ri tushunishlar

6. Keng tarqalgan xatolar va yechimlari

7. Integratsiya — bu bilim qayerda kerak bo'ladi

8. Eng yaxshi amaliyotlar

9. Amaliy topshiriq

Xulosa

Izohlar (0)

6.1-dars: `list` — yaratish va indeks

2.6. `[[0]3]3` tuzog'i