12.1-dars: Kod qanday bajariladi: manba → bytecode → VM

 app.py (baytlar)
    │  1. Dekodlash       — UTF-8 (yoki # -*- coding -*-)
    ▼
 matn
    │  2. Tokenizator     — NAME, OP, NUMBER, NEWLINE, INDENT ...
    ▼
 tokenlar
    │  3. Parser (PEG)    — grammatika bo'yicha daraxt
    ▼
 AST (abstrakt sintaksis daraxti)
    │  4. Symtable        — har nom: local, global, free, cell
    ▼
 AST + ko'rinish sohalari
    │  5. Kompilyator     — boshqaruv oqimi grafi → optimallashtiruvchi → bayt-kod
    ▼
 kod obyekti (code)       ← .pyc ga shu saqlanadi (marshal)
    │  6. Virtual mashina — baholash sikli (ceval), freymlar
    ▼
 natija

def tashqi():
    x = 1
    def ichki():
        return x + y      # x — free (closure, 10.12-dars), y — global
    return ichki

narx * soni          LOAD_FAST narx    stek: [narx]
                     LOAD_FAST soni    stek: [narx, soni]
                     BINARY_OP *       stek: [natija]

tokenize.generate_tokens(io.StringIO(src).readline)
ast.dump(ast.parse(src), indent=2)
symtable.symtable(src, "<nom>", "exec")
code = compile(src, "<nom>", "exec" | "eval" | "single", optimize=-1|0|1|2)
dis.dis(code)          exec(code, globals_dict)

co_code co_consts co_names co_varnames co_freevars co_cellvars
co_argcount co_stacksize co_flags co_qualname co_firstlineno
co_lines() co_positions() code.replace(...)

__pycache__/modul.cpython-314[.opt-N].pyc
sarlavha 16 bayt: magic | bayroqlar | mtime+hajm yoki xesh
python -m compileall [--invalidation-mode checked-hash] papka
-B / PYTHONDONTWRITEBYTECODE   PYTHONPYCACHEPREFIX

"""Bitta manba: tokenlar, AST, symtable ko'rinish sohalari, kod obyekti va bajarish."""

import ast
import io
import symtable
import tokenize

MANBA = '''NARX = 12_000

def hisobla(soni, chegirma=0.1):
    """Buyurtma summasi."""
    def yakuniy(qiymat):
        return qiymat * (1 - chegirma)
    return yakuniy(soni * NARX)

natija = hisobla(3)
'''

print("=== 1. Tokenlar ===")
tokenlar = list(tokenize.generate_tokens(io.StringIO(MANBA).readline))
print(f"  jami: {len(tokenlar)}")
for t in tokenlar[:9]:
    print(f"  {tokenize.tok_name[t.type]:8} {t.string!r:12} qator {t.start[0]}, ustun {t.start[1]}")
turlar = {}
for t in tokenlar:
    turlar[tokenize.tok_name[t.type]] = turlar.get(tokenize.tok_name[t.type], 0) + 1
print(f"  turlar bo'yicha: {dict(sorted(turlar.items()))}")

print("\n=== 2. AST ===")
daraxt = ast.parse(MANBA)
print(f"  modul tanasi: {[type(n).__name__ for n in daraxt.body]}")
print(f"  birinchi statement: {ast.dump(daraxt.body[0])}")
funksiya = daraxt.body[1]
print(f"  hisobla: parametrlar {[a.arg for a in funksiya.args.args]}, sukut {[ast.unparse(d) for d in funksiya.args.defaults]}")
print(f"  return ifodasi: {ast.dump(funksiya.body[-1].value)}")
print(f"  ast.unparse — daraxtdan qayta manba: {ast.unparse(funksiya.body[-1])}")

print("\n=== 3. Symtable: nom qayerga tegishli ===")


def turi(belgi):
    if belgi.is_free():
        return "free"
    if belgi.is_parameter():
        return "parametr"
    if belgi.is_global():
        return "global"
    if belgi.is_local():
        return "local"
    return "?"


def aylan(jadval, chuqurlik=0):
    if jadval.get_type() == symtable.SymbolTableType.ANNOTATION:
        return
    belgilar = ", ".join(f"{b.get_name()}:{turi(b)}" for b in jadval.get_symbols())
    print(f"  {'  ' * chuqurlik}{jadval.get_type().value} {jadval.get_name()!r}: {belgilar}")
    for bola in jadval.get_children():
        aylan(bola, chuqurlik + 1)


aylan(symtable.symtable(MANBA, "<buyurtma>", "exec"))

print("\n=== 4. Kod obyekti va bajarish ===")
kod = compile(MANBA, "<buyurtma>", "exec")
print(f"  turi: {type(kod).__name__}, co_names: {kod.co_names}")
print(f"  konstantalar: {[f'<kod {c.co_name}>' if hasattr(c, 'co_code') else c for c in kod.co_consts]}")
muhit = {}
exec(kod, muhit)
print(f"  exec dan keyin natija = {muhit['natija']}, hisobla.__code__ is ichki kod obyekti: "
      f"{muhit['hisobla'].__code__ is next(c for c in kod.co_consts if hasattr(c, 'co_code'))}")

print("\n=== 5. Kompilyatsiya va ish vaqti xatolari ===")
buzuq = "print('birinchi qator bajariladimi?')\ndef f(:\n    pass\n"
try:
    compile(buzuq, "<buzuq>", "exec")
except SyntaxError as xato:
    print(f"  SyntaxError: {xato.msg}, qator {xato.lineno} — birinchi qator ham bajarilmadi")
kod = compile("print(yoq_ozgaruvchi)", "<nom>", "exec")
print(f"  mavjud bo'lmagan nom kompilyatsiyadan o'tdi: co_names = {kod.co_names}")
try:
    exec(kod, {})
except NameError as xato:
    print(f"  ish vaqtida: NameError: {xato}")
try:
    compile("def f():\n    x = 1\n    global x\n", "<nom>", "exec")
except SyntaxError as xato:
    print(f"  symtable bosqichidagi xato: {xato.msg}")

=== 1. Tokenlar ===
  jami: 55
  NAME     'NARX'       qator 1, ustun 0
  OP       '='          qator 1, ustun 5
  NUMBER   '12_000'     qator 1, ustun 7
  NEWLINE  '\n'         qator 1, ustun 13
  NL       '\n'         qator 2, ustun 0
  NAME     'def'        qator 3, ustun 0
  NAME     'hisobla'    qator 3, ustun 4
  OP       '('          qator 3, ustun 11
  NAME     'soni'       qator 3, ustun 12
  turlar bo'yicha: {'DEDENT': 2, 'ENDMARKER': 1, 'INDENT': 2, 'NAME': 17, 'NEWLINE': 7, 'NL': 2, 'NUMBER': 4, 'OP': 19, 'STRING': 1}

=== 2. AST ===
  modul tanasi: ['Assign', 'FunctionDef', 'Assign']
  birinchi statement: Assign(targets=[Name(id='NARX', ctx=Store())], value=Constant(value=12000))
  hisobla: parametrlar ['soni', 'chegirma'], sukut ['0.1']
  return ifodasi: Call(func=Name(id='yakuniy', ctx=Load()), args=[BinOp(left=Name(id='soni', ctx=Load()), op=Mult(), right=Name(id='NARX', ctx=Load()))])
  ast.unparse — daraxtdan qayta manba: return yakuniy(soni * NARX)

=== 3. Symtable: nom qayerga tegishli ===
  module 'top': NARX:global, hisobla:global, natija:global
    function 'hisobla': soni:parametr, chegirma:parametr, yakuniy:local, NARX:global
      function 'yakuniy': qiymat:parametr, chegirma:free

=== 4. Kod obyekti va bajarish ===
  turi: code, co_names: ('NARX', 'hisobla', 'natija')
  konstantalar: [12000, '<kod hisobla>', None, (0.1,)]
  exec dan keyin natija = 32400.0, hisobla.__code__ is ichki kod obyekti: True

=== 5. Kompilyatsiya va ish vaqti xatolari ===
  SyntaxError: invalid syntax, qator 2 — birinchi qator ham bajarilmadi
  mavjud bo'lmagan nom kompilyatsiyadan o'tdi: co_names = ('print', 'yoq_ozgaruvchi')
  ish vaqtida: NameError: name 'yoq_ozgaruvchi' is not defined
  symtable bosqichidagi xato: name 'x' is assigned to before global declaration

"""Kod obyekti atributlari; funksiya va kod obyekti farqi; co_lines; code.replace; compile rejimlari va optimize darajalari."""

import dis


def buyurtma_summasi(narx, soni, *, chegirma=0.0):
    """Chegirmali summa."""
    assert soni > 0, "soni musbat bo'lsin"
    oraliq = narx * soni
    return round(oraliq * (1 - chegirma), 2)


kod = buyurtma_summasi.__code__

print("=== 1. Atributlar ===")
for nom in ["co_name", "co_qualname", "co_argcount", "co_kwonlyargcount", "co_varnames",
            "co_names", "co_consts", "co_stacksize", "co_firstlineno"]:
    print(f"  {nom:18} {getattr(kod, nom)!r}")
bayroqlar = [nom for bit, nom in dis.COMPILER_FLAG_NAMES.items() if kod.co_flags & bit]
print(f"  {'co_flags':18} {bayroqlar}")
print(f"  {'len(co_code)':18} {len(kod.co_code)} bayt")

print("\n=== 2. Bayt-kod ↔ qatorlar ===")
for bosh, oxir, qator in kod.co_lines():
    if qator is not None:
        print(f"  baytlar {bosh:>3}–{oxir:<3} → qator +{qator - kod.co_firstlineno}")

print("\n=== 3. Funksiya ≠ kod obyekti ===")
yaratilgan = []
for foiz in (5, 10):
    def chegirma(summa, foiz=foiz):
        return summa * (100 - foiz) / 100
    yaratilgan.append(chegirma)
print(f"  ikki funksiya bitta obyektmi: {yaratilgan[0] is yaratilgan[1]}, kodi bitta obyektmi: {yaratilgan[0].__code__ is yaratilgan[1].__code__}")
print(f"  farq faqat __defaults__ da: {yaratilgan[0].__defaults__}, {yaratilgan[1].__defaults__}")
nusxa = type(buyurtma_summasi)(kod, {"round": round}, "nusxa")
try:
    nusxa(100, 3)
except TypeError as xato:
    print(f"  kod obyektidan yangi funksiya, sukutlarsiz: TypeError: {xato}")
print(f"  sukutlar funksiyada, kodda emas: __kwdefaults__ {buyurtma_summasi.__kwdefaults__} va {nusxa.__kwdefaults__}")
print(f"  chegirma berilsa: {nusxa.__name__}(100, 3, chegirma=0.1) = {nusxa(100, 3, chegirma=0.1)}")

print("\n=== 4. code.replace ===")


def salomlash():
    return "Assalomu alaykum"


eski = salomlash.__code__
salomlash.__code__ = eski.replace(co_consts=tuple("Xush kelibsiz" if c == "Assalomu alaykum" else c for c in eski.co_consts))
print(f"  konstanta almashtirildi: {salomlash()}")
salomlash.__code__ = eski

print("\n=== 5. compile rejimlari ===")
print(f"  eval: {eval(compile('2 ** 10 + 24', '<e>', 'eval'))}")
muhit = {}
print(f"  exec: {exec(compile('x = 2 ** 10', '<x>', 'exec'), muhit)}, x = {muhit['x']}")
print("  single (REPL kabi, ifoda qiymatini o'zi chop etadi):")
exec(compile("2 ** 10 + 24", "<s>", "single"))
try:
    compile("x = 1", "<e>", "eval")
except SyntaxError as xato:
    print(f"  eval rejimida statement: SyntaxError: {xato.msg}")

print("\n=== 6. optimize darajalari ===")
MANBA = '''def f(soni):
    """Hujjat satri."""
    assert soni > 0
    if __debug__:
        tekshiruv = "debug"
    return soni
'''
for daraja in (0, 1, 2):
    muhit = {}
    exec(compile(MANBA, "<opt>", "exec", optimize=daraja), muhit)
    f = muhit["f"]
    try:
        f(-1)
        assert_holati = "o'chirildi"
    except AssertionError:
        assert_holati = "ishladi"
    print(f"  optimize={daraja}: bayt-kod {len(f.__code__.co_code):>2} bayt, assert {assert_holati:10}, "
          f"__doc__ {f.__doc__!r}, 'debug' konstantada: {'debug' in f.__code__.co_consts}")

=== 1. Atributlar ===
  co_name            'buyurtma_summasi'
  co_qualname        'buyurtma_summasi'
  co_argcount        2
  co_kwonlyargcount  1
  co_varnames        ('narx', 'soni', 'chegirma', 'oraliq')
  co_names           ('round',)
  co_consts          ('Chegirmali summa.', "soni musbat bo'lsin")
  co_stacksize       5
  co_firstlineno     6
  co_flags           ['OPTIMIZED', 'NEWLOCALS', 'HAS_DOCSTRING']
  len(co_code)       98 bayt

=== 2. Bayt-kod ↔ qatorlar ===
  baytlar   0–2   → qator +0
  baytlar   2–30  → qator +2
  baytlar  30–46  → qator +3
  baytlar  46–98  → qator +4

=== 3. Funksiya ≠ kod obyekti ===
  ikki funksiya bitta obyektmi: False, kodi bitta obyektmi: True
  farq faqat __defaults__ da: (5,), (10,)
  kod obyektidan yangi funksiya, sukutlarsiz: TypeError: buyurtma_summasi() missing 1 required keyword-only argument: 'chegirma'
  sukutlar funksiyada, kodda emas: __kwdefaults__ {'chegirma': 0.0} va None
  chegirma berilsa: nusxa(100, 3, chegirma=0.1) = 270.0

=== 4. code.replace ===
  konstanta almashtirildi: Xush kelibsiz

=== 5. compile rejimlari ===
  eval: 1048
  exec: None, x = 1024
  single (REPL kabi, ifoda qiymatini o'zi chop etadi):
1048
  eval rejimida statement: SyntaxError: invalid syntax

=== 6. optimize darajalari ===
  optimize=0: bayt-kod 30 bayt, assert ishladi   , __doc__ 'Hujjat satri.', 'debug' konstantada: True
  optimize=1: bayt-kod  8 bayt, assert o'chirildi, __doc__ 'Hujjat satri.', 'debug' konstantada: False
  optimize=2: bayt-kod  8 bayt, assert o'chirildi, __doc__ None, 'debug' konstantada: False

"""py_compile bilan .pyc; 16 baytli sarlavhani o'qish; marshal bilan kod obyektini tiklash; xesh rejimi; import keshni ishlatishi."""

import importlib
import importlib.util
import marshal
import pathlib
import py_compile
import struct
import sys
import tempfile

papka = pathlib.Path(tempfile.mkdtemp())
manba = papka / "narxlar.py"
manba.write_bytes(b'KURS = 12_650\n\ndef som(dollar):\n    return dollar * KURS\n\nprint("narxlar moduli bajarildi")\n')


def nisbiy(yol):
    return pathlib.Path(yol).relative_to(papka).as_posix()


print("=== 1. Kesh fayl nomi ===")
print(f"  cache_tag: {sys.implementation.cache_tag}")
print(f"  oddiy: {nisbiy(importlib.util.cache_from_source(manba))}")
print(f"  -OO:   {nisbiy(importlib.util.cache_from_source(manba, optimization=2))}")

print("\n=== 2. Sarlavha (vaqt belgisi rejimi) ===")
pyc = pathlib.Path(py_compile.compile(manba, doraise=True))
baytlar = pyc.read_bytes()
magic = baytlar[:4]
bayroqlar, mtime, hajm = struct.unpack("<III", baytlar[4:16])
print(f"  fayl: {nisbiy(pyc)}, jami {len(baytlar)} bayt")
print(f"  magic {magic!r} == MAGIC_NUMBER: {magic == importlib.util.MAGIC_NUMBER}")
print(f"  bayroqlar: {bayroqlar}, mtime mos: {mtime == int(manba.stat().st_mtime)}, hajm {hajm} == manba {manba.stat().st_size}")

print("\n=== 3. marshal: kod obyektini tiklash ===")
kod = marshal.loads(baytlar[16:])
print(f"  turi: {type(kod).__name__}, co_names: {kod.co_names}")
muhit = {"__name__": "narxlar"}
exec(kod, muhit)
print(f"  manbasiz bajarildi: som(3) = {muhit['som'](3):,}")

print("\n=== 4. Xesh rejimi ===")
pyc = pathlib.Path(py_compile.compile(manba, doraise=True, invalidation_mode=py_compile.PycInvalidationMode.CHECKED_HASH))
baytlar = pyc.read_bytes()
bayroqlar = struct.unpack("<I", baytlar[4:8])[0]
print(f"  bayroqlar: {bayroqlar} (xesh: {bool(bayroqlar & 1)}, manbani tekshirish: {bool(bayroqlar & 2)})")
print(f"  sarlavhadagi xesh == source_hash(manba): {baytlar[8:16] == importlib.util.source_hash(manba.read_bytes())}")

print("\n=== 5. import keshni ishlatadi ===")
py_compile.compile(manba, doraise=True)
sys.path.insert(0, str(papka))
sys.dont_write_bytecode = False
import narxlar
print(f"  narxlar.__cached__: {nisbiy(narxlar.__cached__)}")
pyc_yol = pathlib.Path(narxlar.__cached__)
oldingi = pyc_yol.stat().st_mtime_ns
del sys.modules["narxlar"]
importlib.import_module("narxlar")
print(f"  qayta import: .pyc qayta yozilmadi — {pyc_yol.stat().st_mtime_ns == oldingi}")
pyc_yol.write_bytes(b"\x00\x00\x00\x00" + pyc_yol.read_bytes()[4:])
del sys.modules["narxlar"]
importlib.import_module("narxlar")
print(f"  buzilgan magic: Python .pyc ni e'tiborsiz qoldirib, qayta kompilyatsiya qildi — {pyc_yol.read_bytes()[:4] == importlib.util.MAGIC_NUMBER}")
sys.path.remove(str(papka))

=== 1. Kesh fayl nomi ===
  cache_tag: cpython-314
  oddiy: __pycache__/narxlar.cpython-314.pyc
  -OO:   __pycache__/narxlar.cpython-314.opt-2.pyc

=== 2. Sarlavha (vaqt belgisi rejimi) ===
  fayl: __pycache__/narxlar.cpython-314.pyc, jami 370 bayt
  magic b'+\x0e\r\n' == MAGIC_NUMBER: True
  bayroqlar: 0, mtime mos: True, hajm 92 == manba 92

=== 3. marshal: kod obyektini tiklash ===
  turi: code, co_names: ('KURS', 'som', 'print')
narxlar moduli bajarildi
  manbasiz bajarildi: som(3) = 37,950

=== 4. Xesh rejimi ===
  bayroqlar: 3 (xesh: True, manbani tekshirish: True)
  sarlavhadagi xesh == source_hash(manba): True

=== 5. import keshni ishlatadi ===
narxlar moduli bajarildi
  narxlar.__cached__: __pycache__/narxlar.cpython-314.pyc
narxlar moduli bajarildi
  qayta import: .pyc qayta yozilmadi — True
narxlar moduli bajarildi
  buzilgan magic: Python .pyc ni e'tiborsiz qoldirib, qayta kompilyatsiya qildi — True

"""Formula: ast bilan tekshiruv (oq ro'yxat), compile bir marta, kesh; har qatorda eval bilan solishtirish; xavfli formulalarni rad etish."""

import ast
import math
import time
from functools import lru_cache

RUXSAT_TUGUNLAR = (ast.Expression, ast.BinOp, ast.UnaryOp, ast.Constant, ast.Name, ast.Load,
                   ast.Add, ast.Sub, ast.Mult, ast.Div, ast.Pow, ast.Mod, ast.USub, ast.UAdd,
                   ast.Call, ast.Compare, ast.Gt, ast.Lt, ast.GtE, ast.LtE, ast.Eq, ast.IfExp)
FUNKSIYALAR = {"round": round, "min": min, "max": max, "abs": abs, "sqrt": math.sqrt}


class FormulaXatosi(ValueError):
    pass


@lru_cache(maxsize=256)
def kompilyatsiya(formula, ustunlar):
    try:
        daraxt = ast.parse(formula, mode="eval")
    except SyntaxError as xato:
        raise FormulaXatosi(f"sintaksis: {xato.msg}") from None
    for tugun in ast.walk(daraxt):
        if not isinstance(tugun, RUXSAT_TUGUNLAR):
            raise FormulaXatosi(f"ruxsat etilmagan: {type(tugun).__name__}")
        if isinstance(tugun, ast.Name) and tugun.id not in ustunlar and tugun.id not in FUNKSIYALAR:
            raise FormulaXatosi(f"noma'lum nom: {tugun.id}")
        if isinstance(tugun, ast.Call) and not (isinstance(tugun.func, ast.Name) and tugun.func.id in FUNKSIYALAR):
            raise FormulaXatosi("faqat ruxsat etilgan funksiyalar")
    return compile(daraxt, f"<formula: {formula}>", "eval")


def hisobla(formula, qatorlar):
    kod = kompilyatsiya(formula, tuple(sorted(qatorlar[0])))
    muhit = {"__builtins__": {}, **FUNKSIYALAR}
    return [eval(kod, muhit, qator) for qator in qatorlar]


QATORLAR = [{"narx": 10_000.0 + i, "soni": i % 7, "chegirma": (i % 4) * 0.05} for i in range(30_000)]
FORMULA = "round(narx * soni * (1 - chegirma), 2)"

print("=== 1. Natija ===")
natija = hisobla(FORMULA, QATORLAR)
print(f"  birinchi 4: {natija[:4]}, jami: {sum(natija):,.2f}")
print(f"  kesh: {kompilyatsiya.cache_info()}")
hisobla(FORMULA, QATORLAR[:10])
print(f"  ikkinchi chaqiruv: {kompilyatsiya.cache_info()}")

print("\n=== 2. Har qatorda manbadan eval va bir marta compile ===")


def har_safar(formula, qatorlar):
    muhit = {"__builtins__": {}, **FUNKSIYALAR}
    return [eval(formula, muhit, qator) for qator in qatorlar]


def eng_yaxshi(f, *args, takror=3):
    vaqtlar = []
    for _ in range(takror):
        bosh = time.perf_counter()
        f(*args)
        vaqtlar.append(time.perf_counter() - bosh)
    return min(vaqtlar)


sekin = eng_yaxshi(har_safar, FORMULA, QATORLAR)
tez = eng_yaxshi(hisobla, FORMULA, QATORLAR)
print(f"  natijalar teng: {har_safar(FORMULA, QATORLAR) == natija}")
print(f"  bir marta kompilyatsiya kamida 5 barobar tez: {sekin / tez > 5}")

print("\n=== 3. Xavfli va xato formulalar ===")
for yomon in ["__import__('os').system('rm -rf /')", "narx.__class__", "[x for x in range(10**9)]",
              "narx * (soni", "narx * foyda", "open('parol.txt')", "soni ** 2 if soni > 3 else -soni"]:
    try:
        kompilyatsiya(yomon, ("chegirma", "narx", "soni"))
        print(f"  ✅ {yomon!r}")
    except FormulaXatosi as xato:
        print(f"  ❌ {yomon!r}: {xato}")

=== 1. Natija ===
  birinchi 4: [0.0, 9500.95, 18003.6, 25507.65], jami: 2,081,119,756.75
  kesh: CacheInfo(hits=0, misses=1, maxsize=256, currsize=1)
  ikkinchi chaqiruv: CacheInfo(hits=1, misses=1, maxsize=256, currsize=1)

=== 2. Har qatorda manbadan eval va bir marta compile ===
  natijalar teng: True
  bir marta kompilyatsiya kamida 5 barobar tez: True

=== 3. Xavfli va xato formulalar ===
  ❌ "__import__('os').system('rm -rf /')": faqat ruxsat etilgan funksiyalar
  ❌ 'narx.__class__': ruxsat etilmagan: Attribute
  ❌ '[x for x in range(10**9)]': ruxsat etilmagan: ListComp
  ❌ 'narx * (soni': sintaksis: '(' was never closed
  ❌ 'narx * foyda': noma'lum nom: foyda
  ❌ "open('parol.txt')": faqat ruxsat etilgan funksiyalar
  ✅ 'soni ** 2 if soni > 3 else -soni'

COPY . /app                                     # ⚠️ har pod ishga tushishda kompilyatsiya
RUN python -m compileall -q /app                # ✅ obraz yig'ilganda

assert summa > 0, "summa musbat bo'lsin"         # ❌ -O bilan yo'qoladi
if summa <= 0:
    raise ValueError("summa musbat bo'lsin")     # ✅

for qator in qatorlar:
    eval(formula, {}, qator)                     # ❌ har safar parse + compile
kod = compile(formula, "<f>", "eval")
for qator in qatorlar:
    eval(kod, {}, qator)                         # ✅

eval(request.args["formula"])                    # ❌ istalgan kod bajariladi

__pycache__/                                     # ✅ har doim .gitignore da
*.pyc

python -m compileall app && rm app/*.py          # ⚠️ dekompilyatorlar va dis bilan o'qiladi, versiyaga bog'liq

ENV PYTHONDONTWRITEBYTECODE=1                    # ⚠️ o'zi yetarli emas — har ishga tushish sekin
RUN python -m compileall -q /app /usr/local/lib/python3.14   # ✅ oldindan

try:
    def f(: pass                                 # ❌ butun fayl kompilyatsiyadan o'tmaydi
except SyntaxError:
    ...

import ast
1.  kod = compile("1 + 2", "<t>", "eval")
    print(eval(kod))
2.  print(type(compile("x = 1", "<t>", "exec")).__name__)
3.  try:
        compile("x = 1", "<t>", "eval")
    except SyntaxError:
        print("SyntaxError")
4.  kod = compile("print(nomalum)", "<t>", "exec")
    print("kompilyatsiya bo'ldi")
5.  print(type(ast.parse("a + b").body[0]).__name__)
6.  print(type(ast.parse("a + b", mode="eval").body).__name__)
7.  def f(a, b=2, *, c=3):
        d = a + b
        return d
    print(f.__code__.co_argcount, f.__code__.co_kwonlyargcount)
8.  print(f.__code__.co_varnames)
9.  fs = [lambda: 1 for _ in range(2)]
    print(fs[0] is fs[1], fs[0].__code__ is fs[1].__code__)
10. m = {}
    exec(compile('def g():\n    """doc"""\n    return 1', "<t>", "exec", optimize=2), m)
    print(m["g"].__doc__)
11. print(ast.unparse(ast.parse("x=(1+2)*3")))
12. exec(compile("5 * 5", "<t>", "single"))

1.  def filtrla(yozuvlar, shart):
        return [y for y in yozuvlar if eval(shart, {}, y)]

2.  def yosh_tekshir(yosh):
        assert 0 < yosh < 150, "noto'g'ri yosh"
        return yosh

3.  def sozlama_oqi(matn):
        return eval(matn)          # "{'port': 8080, 'debug': True}"

4.  # Dockerfile
    FROM python:3.14-slim
    ENV PYTHONDONTWRITEBYTECODE=1
    COPY app /app
    CMD ["python", "-m", "app"]

5.  try:
        import yangi_modul
    except SyntaxError:
        yangi_modul = None