## main.py
def Fun1():
    print("Python 是解释型语言吗？")

if __name__ == '__main__':
    Fun1()

## code.py
def Fun2():
    print("code.py 中的 Fun2 函数")

## main.py
import code
def Fun1():
    print("Python 是解释型语言吗？")
    code.Fun2()

if __name__ == '__main__':
    Fun1()

def Fun3():
    print("sleep now")
    sleep(5)

Fun3()

global_val = 1
global_val_not_use = global_val
class A():
    class_val = 2
    class_val_not_use = class_val
    def f1(self, f1_arg1, f1_arg2, f1_arg3, *, f1_arg4, f1_arg5):
        f1_local1 = 3
        f1_local2 = global_val
        f1_local3 = class_val
        f1_local4 = f1_arg1
        f1_local5 = f1_local4
        def f2(f2_arg1):
            f2_local1 = 5
            f2_local2 = f1_local1
            f2_local3 = global_val
        return f2

global_val = 1
def fun1():
    # global global_val 
    fun1_local = global_val

    
# 经过编译之后，输出字节码（注：忽略无关字节码）
  5           0 LOAD_GLOBAL              0 (global_val)
              2 STORE_FAST               0 (fun1_local)

# 屏蔽1：
global_val = 1
def fun1():
    global_val = 2
    fun1_local = global_val
    
# 屏蔽2：这种方式容易出错
# 1) 正常代码，使用的是全局变量
global_val = 1
def fun1():
    v = global_val + 2
    fun1_local = v

# 2) 异常代码，使用的是未定义的局部变量
global_val = 1
def fun1():
    v = global_val + 2
    global_val = 2
    fun1_local = v

global_val = 1
def fun1():
    global global_val
    v = global_val + 2
    global_val = 2
    fun1_local = v

# 字节码，使用的是 LOAD_GLOBAL
  5           0 LOAD_GLOBAL              0 (global_val)
              2 LOAD_CONST               1 (1)

def _get_supported_file_loaders():
    """Returns a list of file-based module loaders.

    Each item is a tuple (loader, suffixes).
    """
    extensions = ExtensionFileLoader, _imp.extension_suffixes() # 动态库
    source = SourceFileLoader, SOURCE_SUFFIXES # .py 文件
    bytecode = SourcelessFileLoader, BYTECODE_SUFFIXES # .pyc 文件
    return [extensions, source, bytecode]

class SourceLoader(_LoaderBasics):

    def get_code(self, fullname):
        """Concrete implementation of InspectLoader.get_code.

        Reading of bytecode requires path_stats to be implemented. To write
        bytecode, set_data must also be implemented.

        """
        source_path = self.get_filename(fullname)
        source_mtime = None
        try:
            bytecode_path = cache_from_source(source_path) # 根据文件名计算出实际的文件路径
        except NotImplementedError:
            bytecode_path = None
        else:
            try:
                st = self.path_stats(source_path) # 一个字典结构，包含文件上次修改的时间或者源文件的大小，在这里默认会抛出IOError
            except IOError:
                pass
            else:
                # ...忽略代码
                
        source_bytes = self.get_data(source_path) # 从文件路径中读取出文件内容
        code_object = self.source_to_code(source_bytes, source_path) # 调用"compile"系统调函数，得到模块的 PyCodeObject 对象
        _bootstrap._verbose_message('code object from {}', source_path)
        if (not sys.dont_write_bytecode and bytecode_path is not None and
                            source_mtime is not None):
            data = _code_to_bytecode(code_object, source_mtime,
                                                     len(source_bytes)) # 将PyCodeObject对象序列化为.pyc文件的内容
            try:
                self._cache_bytecode(source_path, bytecode_path, data) # 调用 set_data 函数，将.pyc文件内容持久化到磁盘，实际上调用的是底层文件IO接口
                _bootstrap._verbose_message('wrote {!r}', bytecode_path)
            except NotImplementedError:
                pass
        return code_object

def _code_to_bytecode(code, mtime=0, source_size=0):
    """Compile a code object into bytecode for writing out to a byte-compiled
    file."""
    data = bytearray(MAGIC_NUMBER) # magic值
    data.extend(_w_long(mtime)) # 修改时间
    data.extend(_w_long(source_size)) # 源文件大小
    data.extend(marshal.dumps(code)) # PyCodeObject序列化
    return data

class SourcelessFileLoader(FileLoader, _LoaderBasics):

    """Loader which handles sourceless file imports."""

    def get_code(self, fullname):
        path = self.get_filename(fullname) 
        data = self.get_data(path) #从文件路径中读取出文件内容
        bytes_data = _validate_bytecode_header(data, name=fullname, path=path) #检查.pyc文件的合法性
        return _compile_bytecode(bytes_data, name=fullname, bytecode_path=path)

def _validate_bytecode_header(data, source_stats=None, name=None, path=None): 
    """
    data：从pyc文件中加载出来的字节串，即格式为b'xxx'
    source_stats：源文件信息，当同时存在py文件时，则此处不为None
    name：文件名
    path：文件路径
    """
    
    # data是字节串，即 b'xxxxx'

    exc_details = {}
    if name is not None:
        exc_details['name'] = name
    else:
        # To prevent having to make all messages have a conditional name.
        name = '<bytecode>'
    if path is not None:
        exc_details['path'] = path
    magic = data[:4] # 读取magic值
    raw_timestamp = data[4:8] # 读取上次修改时间
    raw_size = data[8:12] # 读取源文件大小
    if magic != MAGIC_NUMBER: # 当magic值对不上，则抛出异常
        message = 'bad magic number in {!r}: {!r}'.format(name, magic)
        _bootstrap._verbose_message('{}', message)
        raise ImportError(message, **exc_details)
    elif len(raw_timestamp) != 4: # 时间序列长度不对
        message = 'reached EOF while reading timestamp in {!r}'.format(name)
        _bootstrap._verbose_message('{}', message)
        raise EOFError(message)
    elif len(raw_size) != 4: # 源文件大小的长度不对
        message = 'reached EOF while reading size of source in {!r}'.format(name)
        _bootstrap._verbose_message('{}', message)
        raise EOFError(message)
    if source_stats is not None:
        try:
            source_mtime = int(source_stats['mtime'])
        except KeyError:
            pass
        else:
            if _r_long(raw_timestamp) != source_mtime: # 校验pyc文件时间和源文件修改时间
                message = 'bytecode is stale for {!r}'.format(name)
                _bootstrap._verbose_message('{}', message)
                raise ImportError(message, **exc_details)
        try:
            source_size = source_stats['size'] & 0xFFFFFFFF
        except KeyError:
            pass
        else:
            if _r_long(raw_size) != source_size: # 校验源文件大小
                raise ImportError('bytecode is stale for {!r}'.format(name),
                                  **exc_details)
    return data[12:] # 校验成功，则返回剩余的字节串

def _compile_bytecode(data, name=None, bytecode_path=None, source_path=None):
    """Compile bytecode as returned by _validate_bytecode_header()."""
    code = marshal.loads(data) # 调用 marshal.loads 函数进行反序列化
    if isinstance(code, _code_type):
        _bootstrap._verbose_message('code object from {!r}', bytecode_path)
        if source_path is not None:
            _imp._fix_co_filename(code, source_path)
        return code
    else:
        raise ImportError('Non-code object in {!r}'.format(bytecode_path),
                          name=name, path=bytecode_path)

    else if (PyBytes_CheckExact(v)) {
        W_TYPE(TYPE_STRING, p);
        w_pstring(PyBytes_AS_STRING(v), PyBytes_GET_SIZE(v), p); #字节序列内容+长度
    }