12.2-dars: dis moduli bilan bytecode o'qish

LOAD_FAST        self
LOAD_ATTR        jami        ← 1. o'qish
LOAD_FAST        summa
BINARY_OP        +=          ← 2. qo'shish
...
STORE_ATTR       jami        ← 3. yozish

import dis

dis.dis(funksiya)                         # chop etish
dis.dis(funksiya, adaptive=True)          # ixtisoslashgan ko'rinish (12.8-dars)
dis.get_instructions(funksiya)            # Instruction obyektlari iteratori
dis.Bytecode(funksiya)                    # iteratsiya + .dis() + .info()
dis.code_info(funksiya)                   # kod obyekti xulosasi
dis.stack_effect(opcode, oparg)           # instruksiya stekni qanchaga o'zgartiradi
dis.opmap["BINARY_OP"], dis.opname[n]     # nom ↔ raqam

  3           LOAD_FAST_BORROW_LOAD_FAST_BORROW 1 (narx, soni)
              BINARY_OP                5 (*)
              STORE_FAST               2 (jami)

  4           LOAD_FAST_BORROW         2 (jami)
              LOAD_CONST               0 (1000)
              COMPARE_OP             148 (bool(>))
              POP_JUMP_IF_FALSE       10 (to L1)
  │   │       │                        │   │
  │   │       instruksiya          arg   argrepr
  │   yorliq (sakrash manzili: L1:)
  manba qatori

x and y or 0
                        stek
LOAD_FAST x             [x]                +1
COPY 1                  [x, x]             +1
TO_BOOL                 [x, bool(x)]        0
POP_JUMP_IF_FALSE L1    [x]                -1   ← yolg'on bo'lsa: x qoladi
POP_TOP                 []                 -1
LOAD_FAST y             [y]                +1
...

  22           NOP                          ← try: — hech narsa
  23   L1:     LOAD_FAST d
               LOAD_CONST 'a'
               BINARY_OP []                 ← d["a"]
       L2:     RETURN_VALUE

  --   L3:     PUSH_EXC_INFO                ← faqat istisno bo'lganda shu yerga
  24           LOAD_GLOBAL KeyError
               CHECK_EXC_MATCH
               ...
ExceptionTable:
  L1 to L2 -> L3 [0]                        ← "L1–L2 oralig'ida istisno bo'lsa, L3 ga o't"

LOAD_FAST_AND_CLEAR  n       ← tashqi n ni vaqtincha saqlash
BUILD_LIST 0
FOR_ITER ...
LIST_APPEND 2
...
STORE_FAST n                 ← tashqi n qaytariladi

dis.dis(f[, adaptive=True, show_caches=True])
for i in dis.get_instructions(f): i.opname, i.argval, i.argrepr, i.offset, i.line_number
dis.Bytecode(f).info()     dis.stack_effect(op, arg)     f.__code__.co_exceptiontable

LOAD_/STORE_ FAST(_BORROW) GLOBAL NAME DEREF ATTR CONST SMALL_INT
BINARY_OP  COMPARE_OP  IS_OP  CONTAINS_OP  TO_BOOL  UNARY_*
POP_JUMP_IF_*  JUMP_FORWARD/BACKWARD  GET_ITER FOR_ITER END_FOR
CALL  MAKE_FUNCTION  BUILD_*  FORMAT_SIMPLE  RETURN_VALUE  RESUME
PUSH_EXC_INFO CHECK_EXC_MATCH RERAISE + ExceptionTable

x += 1          → 3 qadam (atomar emas)
x in [..]       → kortej konstanta;  x in {..} → frozenset
a, b = b, a     → super-instruksiyalar, kortej yo'q
[.. for ..]     → inlining (3.12+);  (.. for ..) → alohida kod obyekti
try             → NOP + istisnolar jadvali

"""get_instructions bilan jadval: nisbiy qator, yorliq, instruksiya, argument, stek effekti va chuqurligi; Instruction maydonlari."""

import dis
import types


def argument(i):
    if isinstance(i.argval, types.CodeType):
        return f"<kod {i.argval.co_name}>"
    if i.argrepr:
        return i.argrepr
    return "" if i.arg is None else str(i.argval)


def jadval(funksiya):
    kod = funksiya.__code__
    chuqurlik = eng_chuqur = 0
    print(f"  {'qator':>5} {'offset':>6}  {'instruksiya':34} {'argument':18} {'effekt':>6} {'stek':>4}")
    for i in dis.get_instructions(funksiya):
        effekt = dis.stack_effect(i.opcode, i.arg, jump=False) if i.opcode >= dis.HAVE_ARGUMENT else dis.stack_effect(i.opcode, jump=False)
        chuqurlik += effekt
        eng_chuqur = max(eng_chuqur, chuqurlik)
        qator = f"+{i.line_number - kod.co_firstlineno}" if i.starts_line else ""
        yorliq = "→" if i.is_jump_target else " "
        print(f"  {qator:>5} {i.offset:>6} {yorliq}{i.opname:34} {argument(i):18} {effekt:>+6} {chuqurlik:>4}")
    print(f"  simulyatsiya: eng chuqur {eng_chuqur}, co_stacksize {kod.co_stacksize}")


def buyurtma(narx, soni):
    jami = narx * soni
    if jami > 1_000_000:
        jami = jami * 0.9
    return round(jami, 2)


print("=== 1. buyurtma() ===")
jadval(buyurtma)

print("\n=== 2. Bitta Instruction ===")
i = next(i for i in dis.get_instructions(buyurtma) if i.opname == "COMPARE_OP")
for maydon in ["opname", "opcode", "arg", "argval", "argrepr", "offset", "is_jump_target", "baseopname"]:
    print(f"  {maydon:15} {getattr(i, maydon)!r}")
print(f"  {'positions':15} qator +{i.positions.lineno - buyurtma.__code__.co_firstlineno}, ustunlar {i.positions.col_offset}–{i.positions.end_col_offset}")
manba_qatori = "    if jami > 1_000_000:"
print(f"  ustunlar manbada: {manba_qatori[i.positions.col_offset:i.positions.end_col_offset]!r}")

print("\n=== 3. opcode jadvali ===")
print(f"  jami instruksiya nomlari: {len(dis.opmap)}, argumentli chegara HAVE_ARGUMENT = {dis.HAVE_ARGUMENT}")
print(f"  BINARY_OP raqami {dis.opmap['BINARY_OP']}, 3.14 dagi LOAD_FAST_BORROW bor: {'LOAD_FAST_BORROW' in dis.opmap}")
print(f"  bayt-kod hajmi: {len(buyurtma.__code__.co_code)} bayt, instruksiyalar: {len(list(dis.get_instructions(buyurtma)))}")
print("  (har instruksiya 2 bayt + ba'zilari uchun ixtisoslashuv keshlari)")

=== 1. buyurtma() ===
  qator offset  instruksiya                        argument           effekt stek
     +0      0  RESUME                             0                      +0    0
     +1      2  LOAD_FAST_BORROW_LOAD_FAST_BORROW  narx, soni             +2    2
             4  BINARY_OP                          *                      -1    1
            16  STORE_FAST                         jami                   -1    0
     +2     18  LOAD_FAST_BORROW                   jami                   +1    1
            20  LOAD_CONST                         1000000                +1    2
            22  COMPARE_OP                         bool(>)                -1    1
            26  POP_JUMP_IF_FALSE                  to L1                  -1    0
            30  NOT_TAKEN                                                 +0    0
     +3     32  LOAD_FAST_BORROW                   jami                   +1    1
            34  LOAD_CONST                         0.9                    +1    2
            36  BINARY_OP                          *                      -1    1
            48  STORE_FAST                         jami                   -1    0
     +4     50 →LOAD_GLOBAL                        round + NULL           +2    2
            60  LOAD_FAST_BORROW                   jami                   +1    3
            62  LOAD_SMALL_INT                     2                      +1    4
            64  CALL                               2                      -3    1
            72  RETURN_VALUE                                              +0    1
  simulyatsiya: eng chuqur 4, co_stacksize 4

=== 2. Bitta Instruction ===
  opname          'COMPARE_OP'
  opcode          56
  arg             148
  argval          '>'
  argrepr         'bool(>)'
  offset          22
  is_jump_target  False
  baseopname      'COMPARE_OP'
  positions       qator +2, ustunlar 7–23
  ustunlar manbada: 'jami > 1_000_000'

=== 3. opcode jadvali ===
  jami instruksiya nomlari: 154, argumentli chegara HAVE_ARGUMENT = 43
  BINARY_OP raqami 44, 3.14 dagi LOAD_FAST_BORROW bor: True
  bayt-kod hajmi: 74 bayt, instruksiyalar: 18
  (har instruksiya 2 bayt + ba'zilari uchun ixtisoslashuv keshlari)

"""if/and/or, while-else va break, for, try/except/finally va with — bayt-kod naqshlari va istisnolar jadvali."""

import dis
import types


def qisqa(funksiya, faqat=None):
    natija = []
    for i in dis.get_instructions(funksiya):
        if i.opname in ("RESUME", "NOT_TAKEN", "CACHE"):
            continue
        if faqat and not any(i.opname.startswith(f) for f in faqat):
            continue
        arg = f"<kod {i.argval.co_name}>" if isinstance(i.argval, types.CodeType) else i.argrepr
        natija.append(f"{'→' if i.is_jump_target else ''}{i.opname}{f'({arg})' if arg else ''}")
    return natija


def mantiq(x, y):
    return x and y or "sukut"


def qidir(sonlar, maqsad):
    i = 0
    while i < len(sonlar):
        if sonlar[i] == maqsad:
            break
        i += 1
    else:
        return -1
    return i


def yig(royxat):
    s = 0
    for x in royxat:
        s += x
    return s


def xavfsiz_bolish(a, b):
    try:
        natija = a / b
    except ZeroDivisionError:
        natija = None
    finally:
        tugadi = True
    return natija, tugadi


def oqi(yol):
    with open(yol) as f:
        return f.read()


print("=== 1. x and y or 'sukut' ===")
print(f"  {' → '.join(qisqa(mantiq))}")
for x, y in [(0, 5), (3, 0), (3, 5)]:
    print(f"  mantiq({x}, {y}) = {mantiq(x, y)!r}")

print("\n=== 2. while ... else + break ===")
print(f"  sakrashlar: {qisqa(qidir, faqat=['POP_JUMP', 'JUMP'])}")
print(f"  qidir([4, 7, 9], 7) = {qidir([4, 7, 9], 7)}, qidir([4, 7, 9], 8) = {qidir([4, 7, 9], 8)}")

print("\n=== 3. for ===")
print(f"  {' → '.join(qisqa(yig))}")

print("\n=== 4. try/except/finally ===")
kod = xavfsiz_bolish.__code__
oddiy_yol = []
for i in dis.get_instructions(xavfsiz_bolish):
    if i.opname == "PUSH_EXC_INFO":
        break
    if i.opname not in ("RESUME", "CACHE"):
        oddiy_yol.append(i.opname)
print(f"  istisnosiz yo'l: {oddiy_yol}")
print(f"  try: o'rnida faqat NOP: {oddiy_yol[0] == 'NOP'}, istisnosiz yo'lda ishlovchi instruksiyalari yo'q: "
      f"{not any(op in oddiy_yol for op in ('PUSH_EXC_INFO', 'CHECK_EXC_MATCH'))}")
print(f"  co_exceptiontable: {len(kod.co_exceptiontable)} bayt")
jadval = dis.Bytecode(xavfsiz_bolish).dis().split("ExceptionTable:")[1].strip().splitlines()
print(f"  jadval yozuvlari: {len(jadval)}, birinchisi: {jadval[0].strip()}")
print(f"  istisno bo'lsa ishlaydigan qism: {qisqa(xavfsiz_bolish, faqat=['PUSH_EXC', 'CHECK_EXC', 'POP_EXCEPT', 'RERAISE'])}")

print("\n=== 5. with ===")
print(f"  {qisqa(oqi, faqat=['LOAD_SPECIAL', 'CALL', 'PUSH_EXC', 'WITH'])}")
print(f"  istisnolar jadvali ham bor: {len(oqi.__code__.co_exceptiontable) > 0}")

=== 1. x and y or 'sukut' ===
  LOAD_FAST(x) → COPY → TO_BOOL → POP_JUMP_IF_FALSE(to L1) → POP_TOP → LOAD_FAST(y) → COPY → TO_BOOL → POP_JUMP_IF_TRUE(to L2) → →POP_TOP → LOAD_CONST('sukut') → →RETURN_VALUE
  mantiq(0, 5) = 'sukut'
  mantiq(3, 0) = 'sukut'
  mantiq(3, 5) = 5

=== 2. while ... else + break ===
  sakrashlar: ['POP_JUMP_IF_FALSE(to L3)', 'POP_JUMP_IF_FALSE(to L2)', 'JUMP_BACKWARD(to L1)']
  qidir([4, 7, 9], 7) = 1, qidir([4, 7, 9], 8) = -1

=== 3. for ===
  LOAD_SMALL_INT → STORE_FAST(s) → LOAD_FAST_BORROW(royxat) → GET_ITER → →FOR_ITER(to L2) → STORE_FAST(x) → LOAD_FAST_BORROW_LOAD_FAST_BORROW(s, x) → BINARY_OP(+=) → STORE_FAST(s) → JUMP_BACKWARD(to L1) → →END_FOR → POP_ITER → LOAD_FAST_BORROW(s) → RETURN_VALUE

=== 4. try/except/finally ===
  istisnosiz yo'l: ['NOP', 'LOAD_FAST_BORROW_LOAD_FAST_BORROW', 'BINARY_OP', 'STORE_FAST', 'LOAD_CONST', 'STORE_FAST', 'LOAD_FAST_BORROW_LOAD_FAST_BORROW', 'BUILD_TUPLE', 'RETURN_VALUE']
  try: o'rnida faqat NOP: True, istisnosiz yo'lda ishlovchi instruksiyalari yo'q: True
  co_exceptiontable: 24 bayt
  jadval yozuvlari: 6, birinchisi: L1 to L2 -> L3 [0]
  istisno bo'lsa ishlaydigan qism: ['PUSH_EXC_INFO', 'CHECK_EXC_MATCH', 'POP_EXCEPT', '→RERAISE', 'POP_EXCEPT', 'RERAISE', 'PUSH_EXC_INFO', 'RERAISE', 'POP_EXCEPT', 'RERAISE']

=== 5. with ===
  ['CALL', 'LOAD_SPECIAL(__exit__)', 'LOAD_SPECIAL(__enter__)', 'CALL', 'CALL', 'CALL', 'PUSH_EXC_INFO', 'WITH_EXCEPT_START']
  istisnolar jadvali ham bor: True

"""+= atomar emas (qadamma-qadam simulyatsiya); in-literal konstantalari; global va lokal; almashtirish; metod chaqiruvi; comprehension inlining."""

import dis
import types


def nomlar(funksiya):
    natija = []
    for i in dis.get_instructions(funksiya):
        if i.opname in ("RESUME", "NOT_TAKEN", "CACHE"):
            continue
        arg = f"<kod {i.argval.co_name}>" if isinstance(i.argval, types.CodeType) else i.argrepr
        natija.append(f"{i.opname}({arg})" if arg else i.opname)
    return natija


class Hisob:
    def __init__(self):
        self.jami = 0

    def qosh(self, summa):
        self.jami += summa


print("=== 1. self.jami += summa ===")
print(f"  {nomlar(Hisob.qosh)}")


def ip_simulyatsiya(tartib):
    """Ikki 'ip': har biri O'QI → QO'SH → YOZ. Tartib — qaysi ip qaysi qadamni bajarishi."""
    hisob = {"jami": 100}
    lokal = {"A": {}, "B": {}}
    qadamlar = {"A": iter(["oqi", "qosh", "yoz"]), "B": iter(["oqi", "qosh", "yoz"])}
    for ip in tartib:
        qadam = next(qadamlar[ip])
        if qadam == "oqi":
            lokal[ip]["qiymat"] = hisob["jami"]
        elif qadam == "qosh":
            lokal[ip]["qiymat"] += 10
        else:
            hisob["jami"] = lokal[ip]["qiymat"]
    return hisob["jami"]


print(f"  ketma-ket  A A A B B B → {ip_simulyatsiya('AAABBB')} (kutilgan 120)")
print(f"  aralash    A B A B A B → {ip_simulyatsiya('ABABAB')} ⚠️ bitta qo'shish yo'qoldi")


def literallar(x):
    return x in [1, 2, 3], x in {1, 2, 3}, x in ("a", "b")


print("\n=== 2. in literal — har safar quriladimi ===")
print(f"  {[n for n in nomlar(literallar) if n.startswith(('LOAD_CONST', 'BUILD'))]}")


SOLIQ = 0.12


def global_bilan(summalar):
    return [s * SOLIQ for s in summalar]


def lokal_bilan(summalar, soliq=SOLIQ):
    return [s * soliq for s in summalar]


print("\n=== 3. Global va lokal ===")
print(f"  global: {[n for n in nomlar(global_bilan) if 'SOLIQ' in n or 'soliq' in n]}")
print(f"  lokal:  {[n for n in nomlar(lokal_bilan) if 'SOLIQ' in n or 'soliq' in n]}")


def almashtir(a, b):
    a, b = b, a
    return a


def metod(matn):
    return matn.upper()


print("\n=== 4. Almashtirish va metod chaqiruvi ===")
print(f"  a, b = b, a: {nomlar(almashtir)}")
print(f"  matn.upper(): {nomlar(metod)}")


def royxat_comp(nomlar_):
    return [n.title() for n in nomlar_]


def generator_ifoda(sonlar):
    return sum(x * x for x in sonlar)


print("\n=== 5. Comprehension va generator ifodasi ===")
rc = nomlar(royxat_comp)
gi = nomlar(generator_ifoda)
print(f"  list comprehension: alohida kod obyekti {any('<kod' in n for n in rc)}, LOAD_FAST_AND_CLEAR {any('AND_CLEAR' in n for n in rc)}")
print(f"  generator ifodasi:  alohida kod obyekti {any('<kod' in n for n in gi)}, MAKE_FUNCTION {'MAKE_FUNCTION' in gi}")
ichki = next(c for c in generator_ifoda.__code__.co_consts if isinstance(c, types.CodeType))
print(f"  generator kodi: nom {ichki.co_name!r}, bayroqlar {[n for b, n in dis.COMPILER_FLAG_NAMES.items() if ichki.co_flags & b]}")

print("\n=== 6. f-string ===")


def fstring(ism, ball):
    return f"{ism}: {ball:.1f} ball"


print(f"  {nomlar(fstring)}")

=== 1. self.jami += summa ===
  ['LOAD_FAST_BORROW(self)', 'COPY', 'LOAD_ATTR(jami)', 'LOAD_FAST_BORROW(summa)', 'BINARY_OP(+=)', 'SWAP', 'STORE_ATTR(jami)', 'LOAD_CONST(None)', 'RETURN_VALUE']
  ketma-ket  A A A B B B → 120 (kutilgan 120)
  aralash    A B A B A B → 110 ⚠️ bitta qo'shish yo'qoldi

=== 2. in literal — har safar quriladimi ===
  ['LOAD_CONST((1, 2, 3))', 'LOAD_CONST(frozenset({1, 2, 3}))', "LOAD_CONST(('a', 'b'))", 'BUILD_TUPLE']

=== 3. Global va lokal ===
  global: ['LOAD_GLOBAL(SOLIQ)']
  lokal:  ['LOAD_FAST_BORROW(soliq)']

=== 4. Almashtirish va metod chaqiruvi ===
  a, b = b, a: ['LOAD_FAST_LOAD_FAST(b, a)', 'STORE_FAST_STORE_FAST(b, a)', 'LOAD_FAST_BORROW(a)', 'RETURN_VALUE']
  matn.upper(): ['LOAD_FAST_BORROW(matn)', 'LOAD_ATTR(upper + NULL|self)', 'CALL', 'RETURN_VALUE']

=== 5. Comprehension va generator ifodasi ===
  list comprehension: alohida kod obyekti False, LOAD_FAST_AND_CLEAR True
  generator ifodasi:  alohida kod obyekti True, MAKE_FUNCTION True
  generator kodi: nom '<genexpr>', bayroqlar ['OPTIMIZED', 'NEWLOCALS', 'NESTED', 'GENERATOR']

=== 6. f-string ===
  ['LOAD_FAST_BORROW(ism)', 'FORMAT_SIMPLE', "LOAD_CONST(': ')", 'LOAD_FAST_BORROW(ball)', "LOAD_CONST('.1f')", 'FORMAT_WITH_SPEC', "LOAD_CONST(' ball')", 'BUILD_STRING', 'RETURN_VALUE']

"""Manba satri → compile → barcha ichki kod obyektlari; instruksiyalar bo'yicha 4 xil tekshiruv; qator raqamlari bilan hisobot."""

import dis
import types
import warnings
from collections import Counter

MANBA = '''
import os, pickle

NARXLAR = {"olma": 12000, "nok": 15000}

def hisobot(buyurtmalar):
    jami = 0
    for b in buyurtmalar:
        jami += NARXLAR[b["mahsulot"]] * b["soni"]
        if len(NARXLAR) > 100:
            print("katta katalog")
    return jami

def sozlama_yukla(matn, fayl):
    if matn is "":
        return {}
    qiymat = eval(matn)
    os.system("cp " + fayl + " /tmp")
    return pickle.loads(qiymat)

class Xizmat:
    def ishga_tushir(self):
        try:
            self.ulan()
        except Exception:
            pass
        return [exec(x) for x in self.skriptlar]
'''

XAVFLI = {("eval",), ("exec",), ("os", "system"), ("pickle", "loads"), ("subprocess", "call")}


def kod_obyektlari(kod):
    yield kod
    for c in kod.co_consts:
        if isinstance(c, types.CodeType):
            yield from kod_obyektlari(c)


def tekshir(kod):
    topilmalar = []
    instr = [i for i in dis.get_instructions(kod) if i.opname != "CACHE"]

    for n, i in enumerate(instr):
        if i.opname in ("LOAD_GLOBAL", "LOAD_NAME") and (i.argval,) in XAVFLI:
            topilmalar.append((i.line_number, "xavfli chaqiruv", i.argval))
        if i.opname in ("LOAD_GLOBAL", "LOAD_NAME") and n + 1 < len(instr) and instr[n + 1].opname == "LOAD_ATTR":
            juft = (i.argval, instr[n + 1].argval)
            if juft in XAVFLI:
                topilmalar.append((i.line_number, "xavfli chaqiruv", ".".join(juft)))
        if i.opname == "IS_OP" and n > 0 and instr[n - 1].opname in ("LOAD_CONST", "LOAD_SMALL_INT") and instr[n - 1].argval is not None:
            topilmalar.append((i.line_number, "is bilan literal", repr(instr[n - 1].argval)))

    for n, i in enumerate(instr):
        if i.opname == "JUMP_BACKWARD":
            boshi = i.argval
            sikl = [x for x in instr if boshi <= x.offset <= i.offset]
            globallar = Counter(x.argval for x in sikl if x.opname == "LOAD_GLOBAL")
            for nom, soni in globallar.items():
                topilmalar.append((sikl[0].line_number, "siklda global", f"{nom} ×{soni}"))

    for n, i in enumerate(instr):
        if i.opname == "CHECK_EXC_MATCH" and n > 0 and instr[n - 1].argval in ("Exception", "BaseException"):
            keyingi = [x.opname for x in instr[n + 1:n + 6]]
            if "POP_EXCEPT" in keyingi and not any(op.startswith(("CALL", "LOAD_GLOBAL", "RAISE")) for op in keyingi):
                topilmalar.append((i.line_number, "yutilgan istisno", instr[n - 1].argval))
    return topilmalar


with warnings.catch_warnings():
    warnings.simplefilter("ignore", SyntaxWarning)       # 'matn is ""' kompilyatorning o'zi ogohlantiradi
    modul = compile(MANBA, "<xizmat.py>", "exec")
print("=== Hisobot ===")
jami = Counter()
for kod in kod_obyektlari(modul):
    for qator, tur, tafsilot in sorted(set(tekshir(kod))):
        jami[tur] += 1
        print(f"  {kod.co_qualname:22} qator {qator:>2}  {tur:18} {tafsilot}")
print(f"\n  jami: {dict(jami)}")
print(f"  tekshirilgan kod obyektlari: {[k.co_qualname for k in kod_obyektlari(modul)]}")

=== Hisobot ===
  hisobot                qator  8  siklda global      NARXLAR ×2
  hisobot                qator  8  siklda global      len ×1
  hisobot                qator  8  siklda global      print ×1
  sozlama_yukla          qator 15  is bilan literal   ''
  sozlama_yukla          qator 17  xavfli chaqiruv    eval
  sozlama_yukla          qator 18  xavfli chaqiruv    os.system
  sozlama_yukla          qator 19  xavfli chaqiruv    pickle.loads
  Xizmat.ishga_tushir    qator 25  yutilgan istisno   Exception
  Xizmat.ishga_tushir    qator 27  siklda global      exec ×1
  Xizmat.ishga_tushir    qator 27  xavfli chaqiruv    exec

  jami: {'siklda global': 4, 'is bilan literal': 1, 'xavfli chaqiruv': 4, 'yutilgan istisno': 1}
  tekshirilgan kod obyektlari: ['<module>', 'hisobot', 'sozlama_yukla', 'Xizmat', 'Xizmat.ishga_tushir']

self.jami += summa                        # ❌ ko'p ipda qo'shishlar yo'qolishi mumkin
with self._qulf:
    self.jami += summa                    # ✅

if instr.opname == "LOAD_FAST": ...       # ❌ 3.14 da LOAD_FAST_BORROW ham bor
if instr.opname.startswith("LOAD_FAST"): ...   # ⚠️ yaxshiroq, lekin baribir versiyaga bog'liq

if "BINARY_OP" in capture(dis.dis, f): ...   # ❌ mo'rt
any(i.opname == "BINARY_OP" for i in dis.get_instructions(f))   # ✅

def f(royxat, _len=len): ...              # ⚠️ o'qilishi yomonlashadi, 3.11+ da foyda kichik

if holat is "faol": ...                   # ❌ IS_OP + LOAD_CONST — SyntaxWarning
if holat == "faol": ...                   # ✅ COMPARE_OP

for k in kalitlar:
    try:
        jami += d[k]
    except KeyError:                      # ⚠️ kalitlarning ko'pi yo'q bo'lsa — har safar qimmat yo'l
        pass
jami = sum(d.get(k, 0) for k in kalitlar) # ✅ istisno kam bo'lmasa

dis.dis(compile("x = 1\ny = x + 1", "<m>", "exec"))   # LOAD_NAME — modul darajasida lug'at

sum([x * x for x in sonlar])              # inlining, lekin butun ro'yxat xotirada
sum(x * x for x in sonlar)                # alohida kod obyekti, xotira tejamkor

import dis
def ops(f):
    return [i.opname for i in dis.get_instructions(f) if i.opname not in ("RESUME", "NOT_TAKEN")]
1.  def a(x):
        return x + 1
    print("BINARY_OP" in ops(a))
2.  def b(x):
        return x in [1, 2]
    print("BUILD_LIST" in ops(b))
3.  def c(x):
        return x is None
    print("IS_OP" in ops(c))
4.  def d(n):
        return [i for i in range(n)]
    print("MAKE_FUNCTION" in ops(d))
5.  def e(n):
        return list(i for i in range(n))
    print("MAKE_FUNCTION" in ops(e))
6.  def f():
        try:
            return 1
        except ValueError:
            return 2
    print(ops(f)[0])
7.  def g(s):
        return s.upper()
    print("LOAD_ATTR" in ops(g), "CALL" in ops(g))
8.  def h():
        return len
    print(ops(h))
9.  print(dis.opname[dis.opmap["RETURN_VALUE"]])
10. def k(a, b):
        a, b = b, a
    print("BUILD_TUPLE" in ops(k))
11. def m(x):
        return -x
    print([o for o in ops(m) if o.startswith("UNARY")])
12. def n(x, y):
        return x < y
    print(ops(n)[-2])

1.  def binar_opmi(f):
        import io, contextlib
        buf = io.StringIO()
        with contextlib.redirect_stdout(buf):
            dis.dis(f)
        return "BINARY_OP" in buf.getvalue()

2.  def lokal_yuklashlar(f):
        return [i.argval for i in dis.get_instructions(f) if i.opname == "LOAD_FAST"]

3.  class Hisoblagich:
        def __init__(self):
            self.n = 0
        def oshir(self):
            self.n += 1          # 8 ta ip chaqiradi

4.  def satr_qatorlari(f):
        return {i.offset: i.starts_line for i in dis.get_instructions(f)}

5.  def jami(royxat):
        s = 0
        for x in royxat:
            try:
                s += int(x)
            except ValueError:
                pass
        return s                 # royxatning 90% i son emas