# 作用域A
a = 1

def f1():
    # 作用域B，如果函数有形参，形参也在作用域B中
    b = 1
    print(a, b)
    # 作用域B结束

def f2():
    # 作用域C，如果函数有形参，形参也在作用域C中
    a = 2
    print(a)
    try:
    	print(b)
    except Exception as e:
        print(type(e), e)
    # 作用域C结束
f1()
f2()
print(a)
# 作用域A结束

# 运行结果：
# 1 1
# 2
# <class 'NameError'> name 'b' is not defined
# 1

# 作用域A
a = 1

def f1():
    # 作用域B，如果函数有形参，形参也在作用域B中
    b = 1
    print('namespace B:', locals())
    # 作用域B结束

def f2(para):
    # 作用域C，如果函数有形参，形参也在作用域C中
    a = 2
    print('namespace C:', locals())
    # 作用域C结束
f1()
f2('instance para')
print('namespace A:', globals())
# 作用域A结束

# 运行结果：
# namespace B: {'b': 1}
# namespace C: {'para': 'instance para', 'a': 2}
# namespace A: {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000123F4CF1CD0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'd:\\Projects\\PythonManual\\04-execucation_mechanism\\namespace.py', '__cached__': None, 'a': 1, 'f1': <function f1 at 0x00000123F4D0C900>, 'f2': <function f2 at 0x00000123F4D463E0>}

>>> __name__
'__main__'
>>> import sys
>>> globals() is sys.modules['__main__'].__dict__
True

# a.py
import sys

print('__name__:', __name__)
print(globals() is sys.modules['__main__'].__dict__)

if 'a' in sys.modules:
    print(globals() is sys.modules['a'].__dict__)
else:
    print("'a' has not been imported yet.")

print(type(__builtins__.print))
print(type(__builtins__.list))
print(type(__builtins__.int))
print(str is __builtins__.str)

# 运行结果：
# <class 'builtin_function_or_method'>
# <class 'type'>
# <class 'type'>
# True

def f(set_a):
    a = set_a
    def g():
        print(a)
    return g

gg_1 = f(1)
gg_2 = f(2)
print(type(gg_1), type(gg_2))
print(gg_1 is gg_2)
gg_1()
gg_2()

f(100)()

# 运行结果：
# <class 'function'> <class 'function'>
# False
# 1
# 2
# 100

import time

# func是被装饰函数，会被proxy函数作为闭包变量携带
def perf(func):
    def proxy(*args, **kwargs):
        start = time.perf_counter_ns()
        res = func(*args, **kwargs)
        end = time.perf_counter_ns()
        print(f'time cost: {(end - start) // 10 ** 6}ms.')
        return res
    return proxy


def loop(n):
    cnt = 0
    for i in range(1, n + 1):
        # 每次循环i都会被重新赋值，所以可以在循环内直接修改i，不会对循环流程产生影响
        while i != 1:
            cnt += 1
            if i % 2:
                i = 3 * i + 1
            else:
                i //= 2
    return cnt

# 新的loop其实是perf中的proxy函数对象，旧的loop被其作为闭包变量携带
loop = perf(loop)

print(loop(3 * 10 ** 4))

# 运行结果：
# time cost: 181ms.
# 2864311

struct PyCodeObject {
    PyObject_HEAD
    int co_argcount;            /* #arguments, except *args */
    int co_posonlyargcount;     /* #positional only arguments */
    int co_kwonlyargcount;      /* #keyword only arguments */
    int co_nlocals;             /* #local variables */
    int co_stacksize;           /* #entries needed for evaluation stack */
    int co_firstlineno;         /* first source line number */
    PyObject *co_code;          /* instruction opcodes */
    PyObject *co_consts;        /* list (constants used) */
    PyObject *co_names;         /* list of strings (names used) */
    PyObject *co_varnames;      /* tuple of strings (local variable names) */
    PyObject *co_freevars;      /* tuple of strings (free variable names) */
    PyObject *co_cellvars;      /* tuple of strings (cell variable names) */
    PyObject *co_filename;      /* unicode (where it was loaded from) */
};

>>> code = compile('pi = float("3.14")', '', 'exec')
>>> type(code)
<class 'code'>
>>> type(code.co_code)
<class 'bytes'>
>>> code.co_code
b'e\x00d\x00\x83\x01Z\x01d\x01S\x00'

>>> from dis import dis
>>> dis(code.co_code)
          0 LOAD_NAME                0 (0)
          2 LOAD_CONST               0 (0)
          4 CALL_FUNCTION            1
          6 STORE_NAME               1 (1)
          8 LOAD_CONST               1 (1)
         10 RETURN_VALUE

>>> dis(code)
  1           0 LOAD_NAME                0 (float)
              2 LOAD_CONST               0 ('3.14')
              4 CALL_FUNCTION            1
              6 STORE_NAME               1 (pi)
              8 LOAD_CONST               1 (None)
             10 RETURN_VALUE

>>> code.co_consts
('3.14', None)
>>> code.co_names
('float', 'pi')

a = 1
print(a)
a = 2

//Include/pyframe.h
typedef struct _frame PyFrameObject;

//Include/cpython/frameobject.h
struct _frame {
    PyObject_VAR_HEAD
    struct _frame *f_back;      /* previous frame, or NULL */
    PyCodeObject *f_code;       /* code segment */
    PyObject *f_builtins;       /* builtin symbol table (PyDictObject) */
    PyObject *f_globals;        /* global symbol table (PyDictObject) */
    PyObject *f_locals;         /* local symbol table (any mapping) */
    PyObject **f_valuestack;    /* points after the last local */
    PyObject *f_trace;          /* Trace function */
    int f_stackdepth;           /* Depth of value stack */
    char f_trace_lines;         /* Emit per-line trace events? */
    char f_trace_opcodes;       /* Emit per-opcode trace events? */

    /* Borrowed reference to a generator, or NULL */
    PyObject *f_gen;

    int f_lasti;                /* Last instruction if called */
    int f_lineno;               /* Current line number. Only valid if non-zero */
    int f_iblock;               /* index in f_blockstack */
    PyFrameState f_state;       /* What state the frame is in */
    PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
    PyObject *f_localsplus[1];  /* locals+stack, dynamically sized */
};

import sys

main_frame = sys._getframe()
frame_exec_f = None
frame_exec_g = None

def g():
    global frame_exec_g
    frame_exec_g = sys._getframe()

def f():
    global frame_exec_f
    frame_exec_f = sys._getframe()
    g()

f()

print(frame_exec_g.f_back is frame_exec_f)
print(frame_exec_f.f_back is main_frame)

# 运行结果：
# True
# True