Ro'yxatlar va tuple'lar

bo_sh = []
sonlar = [3, 1, 4, 1, 5]
aralash = [1, "ikki", 3.0, None, [5, 6]]     # turli tiplar mumkin (lekin odatda yaxshi g'oya emas)
harflar = list("salom")                      # ['s', 'a', 'l', 'o', 'm']
juftlar = list(range(0, 10, 2))              # [0, 2, 4, 6, 8]

lst = [10, 20, 30, 40, 50]
lst[0] = 99              # [99, 20, 30, 40, 50]
lst[1:3] = [0, 0, 0]     # [99, 0, 0, 0, 40, 50] — slice'ni boshqa uzunlikdagi ro'yxat bilan almashtirish
del lst[0]               # [0, 0, 0, 40, 50]
del lst[-2:]             # [0, 0, 0]

lst = [3, 1, 2]
lst.append(4)          # [3, 1, 2, 4]
lst.extend([5, 6])     # [3, 1, 2, 4, 5, 6]
lst.insert(0, 0)       # [0, 3, 1, 2, 4, 5, 6]
oxirgi = lst.pop()     # 6, lst = [0, 3, 1, 2, 4, 5]
lst.remove(3)          # [0, 1, 2, 4, 5]

a = [1, 2]
a.append([3, 4])       # [1, 2, [3, 4]] — ro'yxat BITTA element sifatida
b = [1, 2]
b.extend([3, 4])       # [1, 2, 3, 4]

[1, 2] + [3]           # [1, 2, 3] — yangi ro'yxat
[0] * 4                # [0, 0, 0, 0]
2 in [1, 2, 3]         # True
len([1, 2, 3])         # 3
min(lst), max(lst), sum(lst)

a = [1, 2, 3]
b = a.copy()       # yoki list(a), yoki a[:]
b.append(4)
print(a)           # [1, 2, 3] — a daxlsiz

a = [[1, 2], [3, 4]]
b = a.copy()
b[0].append(99)    # ichki ro'yxatni o'zgartirish
b.append([5])      # tashqi ro'yxatga qo'shish
print(a)           # [[1, 2, 99], [3, 4]]       ← ichki o'zgarish ko'rindi!
print(b)           # [[1, 2, 99], [3, 4], [5]]

import copy
 
a = [[1, 2], [3, 4]]
c = copy.deepcopy(a)    # hamma darajani rekursiv nusxalaydi
c[0].append(7)
print(a)                # [[1, 2], [3, 4]] — to'liq daxlsiz

grid = [[0] * 3] * 3        # 3x3 matritsa... shundaymi?
grid[0][0] = 1
print(grid)                 # [[1, 0, 0], [1, 0, 0], [1, 0, 0]]  ← uchala qator o'zgardi!

grid = [[0] * 3 for _ in range(3)]    # har qator — yangi ro'yxat
grid[0][0] = 1
print(grid)                           # [[1, 0, 0], [0, 0, 0], [0, 0, 0]]

lst = [3, 1, 2]
yangi = sorted(lst)    # yangi ro'yxat qaytaradi, lst o'zgarmaydi; HAR QANDAY iterable'ni qabul qiladi
lst.sort()             # joyida saralaydi, None qaytaradi; faqat list uchun

so_zlar = ["banana", "Olma", "nok", "anor"]
 
sorted(so_zlar)                          # ['Olma', 'anor', 'banana', 'nok'] — katta harf oldin!
sorted(so_zlar, key=str.lower)           # ['anor', 'banana', 'nok', 'Olma']
sorted(so_zlar, key=len)                 # ['nok', 'Olma', 'anor', 'banana']
sorted(so_zlar, key=len, reverse=True)   # eng uzunidan

talabalar = [("Ali", 85), ("Vali", 92), ("Gani", 85), ("Soli", 70)]
 
# ball bo'yicha kamayish, teng bo'lsa ism bo'yicha o'sish
sorted(talabalar, key=lambda t: (-t[1], t[0]))
# [('Vali', 92), ('Ali', 85), ('Gani', 85), ('Soli', 70)]

from operator import itemgetter
 
sorted(talabalar, key=itemgetter(1), reverse=True)
max(talabalar, key=itemgetter(1))      # ('Vali', 92) — min/max ham key qabul qiladi

import bisect
 
chegaralar = [60, 75, 90]          # baho chegaralari
baholar = ["F", "C", "B", "A"]
 
def baho(ball: int) -> str:
    return baholar[bisect.bisect_right(chegaralar, ball)]
 
print([baho(b) for b in [45, 60, 74, 89, 95]])   # ['F', 'C', 'C', 'B', 'A']

nuqta = (3, 4)
rgb = 255, 128, 0          # qavssiz ham tuple
bitta = (5,)               # BITTA elementli tuple — vergul shart!
emas = (5)                 # bu shunchaki int 5
bo_sh = ()

def statistika(sonlar: list[float]) -> tuple[float, float, float]:
    return min(sonlar), max(sonlar), sum(sonlar) / len(sonlar)
 
kichik, katta, ortacha = statistika([4, 8, 15, 16, 23, 42])

t = ([1, 2], 3)
t[0].append(3)       # ruxsat! Tuple o'zgarmadi — u hamon o'sha ro'yxatga ishora qiladi
print(t)             # ([1, 2, 3], 3)
t[0] = [9]           # TypeError — havolani almashtirib bo'lmaydi

x, y = (3, 4)
ism, yosh, shahar = ["Ali", 25, "Toshkent"]
 
birinchi, *qolgan = [1, 2, 3, 4]        # 1, [2, 3, 4]
*boshi, oxirgi = [1, 2, 3, 4]           # [1, 2, 3], 4
bosh, *orta, oxir = range(6)            # 0, [1, 2, 3, 4], 5
 
x, (y, z) = 1, (2, 3)                   # ichma-ich
 
for ism, ball in [("Ali", 85), ("Vali", 92)]:   # siklda ochish
    ...
 
_, ikkinchi, _ = (1, 2, 3)              # kerakmas qiymatlar uchun _

a = [1, 2]
b = [3, 4]
birlashgan = [*a, *b, 5]           # [1, 2, 3, 4, 5]
print(*a)                          # print(1, 2) — argument sifatida ochish

m = [[1, 2, 3],
     [4, 5, 6]]
t = [list(qator) for qator in zip(*m)]
# [[1, 4], [2, 5], [3, 6]]

juftlar = [("Ali", 85), ("Vali", 92), ("Gani", 78)]
ismlar, ballar = zip(*juftlar)
# ismlar = ('Ali', 'Vali', 'Gani'), ballar = (85, 92, 78)

lst = [5, 3, 8, 1]
 
any(x > 7 for x in lst)       # True — kamida bittasi
all(x > 0 for x in lst)       # True — hammasi
sum(x for x in lst if x > 2)  # 16
max(lst, default=None)        # bo'sh ro'yxat uchun xato o'rniga default
 
list(reversed(lst))           # [1, 8, 3, 5]
lst[::-1]                     # [1, 8, 3, 5]
 
# Dublikatlarni tartibni saqlab olib tashlash
unikal = list(dict.fromkeys([3, 1, 3, 2, 1]))   # [3, 1, 2]
 
# Ro'yxatni teng bo'laklarga (batch) bo'lish
def batched(items: list, size: int) -> list[list]:
    return [items[i:i + size] for i in range(0, len(items), size)]
 
batched(list(range(7)), 3)    # [[0, 1, 2], [3, 4, 5], [6]]

Message = dict[str, str]
 
history: list[Message] = [
    {"role": "user", "content": "Salom!"},
    {"role": "assistant", "content": "Salom! Qanday yordam bera olaman?"},
    {"role": "user", "content": "Python nima?"},
    {"role": "assistant", "content": "Python — dasturlash tili..."},
]
 
 
def add_turn(history: list[Message], user: str, assistant: str) -> list[Message]:
    """Yangi ro'yxat qaytaradi — asl tarix o'zgarmaydi."""
    return [*history, {"role": "user", "content": user}, {"role": "assistant", "content": assistant}]
 
 
def last_turns(history: list[Message], n: int) -> list[Message]:
    """Oxirgi n ta savol-javob juftligi (kontekst oynasini tejash uchun)."""
    return history[-2 * n:] if n > 0 else []
 
 
def total_chars(history: list[Message]) -> int:
    return sum(len(m["content"]) for m in history)
 
 
print(len(last_turns(history, 1)), total_chars(history))