input_np = input_tensor.numpy()
print(input_np.dtype)  # float32
input_np = input_np.reshape(dims)
output_np = np.zeros(input_np.shape)
print(output_np.dtype)  # float64

sudo apt update
sudo apt upgrade
pyenv install 3.9.0 -v #建议不要使用系统python，而是为虚拟环境安装独立python
# 如果上述命令失败，看看log，大概率是某个package没有安装，log 通过 去掉 ‘-v’

# 创建一个名为 ppo_me 的 virtualenv，它基于 Python 3.9.0 版本。
pyenv virtualenv 3.9.0 ppo_me

# 激活虚拟环境。在当前目录下创建一个 .python-version 文件，并将 ppo_me 写入该文件。 当你进入这个目录或其子目录时，pyenv 会自动读取 .python-version 文件，并将 Python 环境设置为 ppo_me 这个 virtualenv。
pyenv local ppo_me

# 删除ppo_me 的虚拟环境，并删除对应的Python版本。
pyenv deactivate
pyenv virtualenv-delete ppo_me
pyenv uninstall 3.10.14
rm -rf .python-version 


pyenv install 3.9.0
pyenv virtualenv 3.9.0 ppo_me
# 创建一个 .python-version 文件，指定该项目使用的虚拟环境。 当你进入项目目录时，pyenv 会自动激活该虚拟环境。
pyenv local ppo_me

$ which python
/home/junhui/.pyenv/shims/python
$ echo $PYENV_VERSION
ppo_me
$ pyenv versions
  system
  3.9.0
  3.9.0/envs/ppo_me
* ppo_me --> /home/junhui/.pyenv/versions/3.9.0/envs/ppo_me (set by PYENV_VERSION environment variable)

sudo apt install python3-poetry
poetry init # 指明python 版本是虚拟环境中的
poetry add gym torch stable-baselines3 tensorboard wandb -vvv

wget "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
# 当下载速度太慢而无法进行时，尝试下载到其他设备后通过 scp 传输到目标设备
bash Miniforge3-$(uname)-$(uname -m).sh

# 初始化到配置文件 ~/.bashrc
export PATH="~/miniforge3/bin:$PATH"
source ~/miniforge3/etc/profile.d/conda.sh

name: myenv
dependencies:
  - python=3.10.12
  - numpy
  - pandas
  - pip
  - pip:
    - requests
    - beautifulsoup4

class MyCustomError(Exception):
    def __init__(self, message="An error occurred in MyCustomError"):
        self.message = message  # 存储额外的错误信息，如错误代码
        super().__init__(message)  # 调用父类的__init__方法，传入message
        
    # 返回自定义的错误信息字符串  
    def __str__(self):
        return f"[Error: {self.message}"  

# 示例函数，该函数在特定条件下引发自定义异常  
def test_func(condition, message):  
    if condition:  
        raise MyCustomError(message)  

# 调用示例函数并捕获自定义异常  
try:
    test_func(True, "Resource not found")  
except MyCustomError as e:  
    print(e)  # 这将调用e的__str__方法

class Person:  
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):  # 重写（override）来自定义对象的字符串打印方式
        return f"Person(name={self.name}, age={self.age})"

p = Person("Alice", 30)
# 打印Person对象，将调用__str__方法 
print(p)  # 输出: Person(name=Alice, age=30)

from typing import Dict, List

class DAG:
    def __init__(self):
        self.graph: Dict[str, List[str]] = {}

    def add_node(self, node: str) -> None:
        if node not in self.graph:
            self.graph[node] = []

    def add_edge(self, from_node: str, to_node: str) -> None:
        if from_node not in self.graph:
            self.add_node(from_node)
        if to_node not in self.graph:
            self.add_node(to_node)
        self.graph[from_node].append(to_node)

    def print_graph(self) -> None:
        if not self.graph:
            print("Graph is empty!")
            return
        for node in self.graph:
            print(f"{node} -> {self.graph[node]}")

    def __topological_sort_util(self, node: str, visited: Dict[str, bool], stack: List[str]) -> None:
        print(f"node -: {node}")
        visited[node] = True
        for neighbor in self.graph[node]:
            if not visited[neighbor]:
                self.__topological_sort_util(neighbor, visited, stack)
        print(f"node +: {node}")
        stack.insert(0, node)
        print(f"stack: {stack}")

    def topological_sort(self) -> List[str]:
        visited: Dict[str, bool] = {node: False for node in self.graph}
        stack: List[str] = []
        for node in self.graph:
            print(f"{node}")
            if not visited[node]:
                self.__topological_sort_util(node, visited, stack)
        return stack


if __name__ == "__main__":
    dag = DAG()
    dag.add_edge("A", "B")
    dag.add_edge("A", "C")
    dag.add_edge("B", "D")
    dag.add_edge("C", "D")
    dag.add_edge("D", "E")

    # dag.print_graph()
    print(dag.topological_sort())

# output
"""
A
node -: A
node -: B
node -: D
node -: E
node +: E
stack: ['E']
node +: D
stack: ['D', 'E']
node +: B
stack: ['B', 'D', 'E']
node -: C
node +: C
stack: ['C', 'B', 'D', 'E']
node +: A
stack: ['A', 'C', 'B', 'D', 'E']
B
C
D
E
['A', 'C', 'B', 'D', 'E']
"""

A -> B -> D -> E
     B <- D <- E
     C
A <- C

import torch
import torch.nn as nn
# 定义一个简单的神经网络
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc1 = nn.Linear(10, 50)
        self.fc2 = nn.Linear(50, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 创建模型
model = SimpleNet()
# 将模型转换为TorchScript
scripted_model = torch.jit.script(model)
# 保存TorchScript模型
scripted_model.save("simple_net.pt")

// 需要下载和配置LibTorch，
#include <torch/script.h> // One-stop header. 通过包含一个单一的头文件，开发者可以访问库或框架的所有功能
#include <iostream>
#include <memory>

int main() {
    // 加载TorchScript模型
    std::shared_ptr<torch::jit::script::Module> module = torch::jit::load("simple_net.pt");
    // 创建输入张量
    std::vector<torch::jit::IValue> inputs;
    inputs.push_back(torch::randn({1, 10}));
    // 执行模型
    at::Tensor output = module->forward(inputs).toTensor();
    // 打印输出
    std::cout << output << std::endl;
    return 0;
}

cmdclass={
    'build': CMakeBuild,
    'custom_command': CustomCommandClass,
    }

@property
def pass_rate(self):
    """Pass rate."""
    if self.total == 0:
        return 0.0
    return round(100 * self.passed / self.total, 2)

obj = MyClass()
print(obj.pass_rate)  # 不需要括号

def compile_module_from_src(src, name):
    key = hashlib.sha256(src.encode("utf-8")).hexdigest() # 使用hashlib.sha256根据提供的源代码src生成一个MD5哈希值作为缓存键。这个哈希值用于唯一标识这段源代码，以便在缓存中查找和存储编译后的模块
    cache = get_cache_manager(key)         # 调用get_cache_manager函数，传入上一步生成的哈希值key，以获取一个缓存管理器实例
    cache_path = cache.get_file(f"{name}.so")
    if cache_path is None:
        with tempfile.TemporaryDirectory() as tmpdir:
            src_path = os.path.join(tmpdir, "main.cpp")
            with open(src_path, "w") as f:
                f.write(src)
            so = _build(name, src_path, tmpdir, library_dir, include_dir, libraries)
            with open(so, "rb") as f:
                cache_path = cache.put(f.read(), f"{name}.so", binary=True)
    import importlib.util
    spec = importlib.util.spec_from_file_location(name, cache_path)
    mod = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(mod)
    return mod

import hashlib

def get_sha256():
    data = "hello world"
    hash_object = hashlib.sha256()
    hash_object.update(data.encode('utf-8'))
    hash_digest = hash_object.hexdigest()
    print(hash_digest)

def check_file():
    def get_hash_digits(data):
        hex_dig = hashlib.sha256(data.encode()).hexdigest()
        return hex_dig

    original_data = "Hello, world! This is a test to ensure data integrity."
    original_hash = get_hash_digits(original_data)
    print(f"Original Hash: {original_hash}")

    received_data = "Hello, world! This is a test to ensure data integrity."
    received_hash = get_hash_digits(received_data)
    if original_hash == received_hash:
        print("Data is compileted, not tampered!")
    else:
        print("Alert data has been tampered!")

    tampered_data = "Hello, world! This is a test to BREAK data integrity."
    tampered_hash = get_hash_digits(tampered_data)
    if original_hash == tampered_hash:
        print("Data is compileted, not tampered!（no possible in this case）")
    else:
        print("Alert data has been tampered!")

def check_cols(target_cols, all_cols):
    diff = set(target_cols).difference(all_cols)
    if len(diff) != 0:
        raise ValueError(f"Couldn't find required columns: '{diff}' among available '{all_cols}'")

# 在调用函数的地方
check_cols(target_cols, all_cols)  # 可能会抛出异常

def check_cols(target_cols, all_cols):
    diff = set(target_cols).difference(all_cols)
    if len(diff) != 0:
        raise ValueError(f"Couldn't find required columns: '{diff}' among available '{all_cols}'")
try:
  check_cols(target_cols, all_cols)
except ValueError as e:
    print(f"Error: {e}")

def check_positive(number):
    if number <= 0:
        raise AssertionError("数字必须是正数")    # 显式地 raise AssertionError 也可以引发 AssertionError。

try:
    check_positive(-1)
except AssertionError as e:
    print(e)  # 输出: 数字必须是正数

conda list --export > miniconda_list.yml  # 其中给出了一键安装所有包, 如下
conda create --name <env> --file <this-file>

a = [1, 2]
b = [3, 4]
c = [0, a, b, 5]  # 结果为 [0, [1, 2], [3, 4], 5]
c = [0, *a, *b, 5]  # 结果为 [0, 1, 2, 3, 4, 5]

kwargs = {'a': 1, 'b': 2}
print(**kwargs)  # 相当于 print(a=1, b=2)

def func(*args):
    for arg in args:
        print(arg)

import some_module  # 假设你已经有一个名为some_module的模块

# ... 在这里可能有一些使用some_module的代码 ...

# 现在你修改了some_module.py文件的内容，并且希望在不重启Python解释器的情况下重新加载它
from importlib import reload
reload(some_module)

# 现在some_module中的代码应该是你修改后的版本

def flip_coin(seed: Union[Any, torch.Tensor], prob: Union[float, torch.Tensor]) -> Union[bool, torch.Tensor]:
    pass
def flip_coin(seed: Any, prob: Any) -> Any:
    pass

>>> a = 109641275
>>> b = torch.tensor([109641275])

>>> a / 2
54820637.5
>>> b / 2
tensor([54820636.])

>>> a / 2 * 1637
89741383587.5
>>> (b / 2 * 1637).item()
89741377536.0

pip install pybind11
git clone https://github.com/pybind/pybind11.git
mkdir build && cd build
cmake .. -DCMAKE_INSTALL_PREFIX=~/me_include
make install

# 通过-I给出pybind11的 位置，确保编译器能够找到 pybind11/pybind11.h
g++ -I~/me_include/inlclude -O3 -Wall -shared -std=c++11 -fPIC `python -m pybind11 --includes` signature.cpp -o me_signature`python3-config --extension
-suffix`

// vec_add.cpp
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <vector>

namespace py = pybind11;

std::vector<double> vec_add(const std::vector<double>& a, const std::vector<double>& b) {
    std::vector<double> result;
    result.resize(a.size());
    for (size_t i = 0; i < a.size(); ++i) {
        result[i] = a[i] + b[i];
    }
    return result;
}

PYBIND11_MODULE(vec_add_module, m) {
    m.def("vec_add", &vec_add, "Add two vectors element-wise");
}

c++ -I~/me_include/inlclude -O3 -Wall -shared -std=c++11 -fPIC `python3 -m pybind11 --includes` vec_add.cpp -o vec_add_module`python3-config --extension-suffix`

# __init__.py
from .vec_add_module import vec_add

import argparse

parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('--verbose', action='store_true', help='increase output verbosity')

args = parser.parse_args()

if args.verbose:
    print("Verbose mode is on.")
else:
    print("Verbose mode is off.")

>>> ra = random.Random(23)
>>> ra.randint(10,100)
47
>>> ra.randint(10,100)
20
>>> ra.randint(10,100)
12
>>> ra.randint(10,100)
85

>>> random.Random(23).randint(10,100)
47
>>> random.Random(23).randint(10,100)
47
>>> random.Random(23).randint(10,100)
47
>>> random.Random(23).randint(10,100)
47

ra = random.Random(23)
ra.randint(10,100)
ra.randint(10,100)
ra.randint(10,100)
ra.randint(10,100)

random.Random(23).randint(10,100)
random.Random(23).randint(10,100)
random.Random(23).randint(10,100)
random.Random(23).randint(10,100)

torch.manual_seed(42)
random_tensor_uniform = torch.rand(1, 5)
random_tensor_uniform = torch.rand(1, 5)
# 生成：
tensor([[0.8823, 0.9150, 0.3829, 0.9593, 0.3904]])
tensor([[0.6009, 0.2566, 0.7936, 0.9408, 0.1332]])

torch.manual_seed(42)
random_tensor_uniform = torch.rand(1, 5)
torch.manual_seed(42)
random_tensor_uniform = torch.rand(1, 5)
# 生成：
tensor([[0.8823, 0.9150, 0.3829, 0.9593, 0.3904]])
tensor([[0.8823, 0.9150, 0.3829, 0.9593, 0.3904]])

class LCGRandom:
    def __init__(self, seed):
        self.a = 1664525
        self.c = 1013904223
        self.m = 2**32
        self.state = seed

    def rand(self):
        self.state = (self.a * self.state + self.c) % self.m
        return self.state / self.m

seed = 42
rng = LCGRandom(seed)
print(rng.rand())  # 生成第一个随机数
print(rng.rand())  # 生成第二个随机数

def thread_func(x: int) -> int:
    return x * 2

## 方法一 多线程执行 很慢
with ThreadPoolExecutor() as executor:
    futures = [executor.submit(thread_func, i) for i in range(1 << 20)]
    print("+++++")
    res = 1
    for i in range(1<<20):
        res += i
        # 获取结果
    print(res)
    print("-----")
    results = [future.result() for future in futures]

## 方法二 单线程执行 很快
for i in range(1 << 20):
    thread_func(i)

# 一个简单的任务函数
def task(n):
    return n * n

# 创建线程池
with ThreadPoolExecutor(max_workers=4) as executor:
    # 提交任务并获取Future对象
    future = executor.submit(task, 5)

    # 做一些其他的事情，而任务在后台执行
    # ...
    # 不阻塞地检查任务是否完成
    while not future.done():
        print("Task is still running...")
        time.sleep(0.5)  # 每0.5秒检查一次

    # 获取结果，因为我们已经知道任务完成了，所以不会阻塞
    try:
        result = future.result()
        print(f"The result is: {result}")
    except Exception as e:
        print(f"An error occurred: {e}")

flags: bool = True
def set_single_value(p: int, res: torch.Tensor):
    value: float = (1.0 / 13) * (1 << (p % 3))
    if flags & 1:
        value *= 7.0
    res[p] = value

n_elements = 1 << 20
tar: torch.Tensor = torch.empty(n_elements)
for i in range(n_elements):
    set_single_value(i, tar, )

flags: bool = True
n_elements = 1 << 20
tar: torch.Tensor = torch.empty(n_elements)

# 创建一个与tar同样大小的索引张量
indices = torch.arange(n_elements)

# 向量化地 计算所有值，value也是个tensor
values = (1.0 / 13) * (1 << (indices % 3))
# 向量化地 根据 flags 的值来决定是否需要将所有的值乘以7.0
if flags & 1:
    values *= 7.0

# 向量化地 将计算好的值赋给tar
tar = values

for i in range(a):
    for j in range(b):
        for z in range(c):
            idx = i * j + z
            # other code
# ==> 如果 other code 不依赖于 i 、j 和 z 之间的嵌套关系，可以考虑使用 `itertools.product` 来生成所有可能的组合，这样可以使代码更简洁

import itertools
for i, j, z in itertools.product(range(a), range(b), range(c)):
    identifier = i * j + z

# 假设我们有一个大的数字列表，我们想要找出所有偶数的平方
numbers = range(1 << 30)

# 定义了一个生成器，该生成器迭代 numbers 中的每个数字 x。如果 x 是偶数 (x % 2 == 0)，则计算 x ** 2 并将其作为生成器的下一个值“yield”出来。
# 它只在循环中需要时才计算下一个平方偶数，而不是预先计算所有平方偶数并将其存储在内存中。这使得它能够处理非常大的数据集，而不会导致内存溢出。
squared_evens = (x ** 2 for x in numbers if x % 2 == 0)

for i, num in enumerate(squared_evens):
    if i >= 10:  # 只打印前10个
        break
    print(num)

a = range(1 << 30)
print(len(a))
# 快
sr1: Generator[int, None, None] = (x ** 2 for x in a if x % 2 == 0) # 见注释
print(type(sr1))

# 很很慢
sr2 = [x ** 2 for x in a if x % 2 == 0]
print(type(sr2))

def fibonacci():
    a, b = 0, 1
    while True:
        yield (a, b)  # 每次调用next(), 执行到yield时，a, b的值会返回，然后暂停，等待下一次next()的调用 
        a, b = b, a + b

# 使用示例：
fib_gen = fibonacci()  # 生成器对象
for i in range(10):
    print(next(fib_gen))   # 遇到next函数才会实际执行一次

def my_function(*args: Any):
    for arg in args:
        print(arg)

# 调用函数 时给出运行时的实参
my_function(1, 2, 3, 4)

def my_function(**kwargs: Any):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# 调用函数 时给出运行时的实参
my_function(a=1, b=2, c=3)

def my_function(*args: Any, **kwargs: Any):
    for arg in args:
        print(arg)
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# 调用函数
my_function(1, 2, a=3, b=4)

def my_function(**kwargs: Any):
    print(type(kwargs))  # 输出 <class 'dict'>
    for key, value in kwargs.items(): # kwargs 表示任意数量 参数字典
        print(f"{key}: {value}, type: {type(value)}")

my_function(name="Alice", age=30, city="New York")

single_element_tuple = (1,)  # 注意逗号
multiple_elements_tuple = (1, 2, 3)
tuple_without_parentheses = 1, 2, 3 # 被称为元组打包（tuple packing）
tuple_from_list = tuple([1, 2, 3])  # 使用tuple的构造函数从其他可迭代对象中创建元组

outer: int = list(itertools.accumulate(shape[:axis], lambda x, y: x * y))[-1]

# 改为
mul_func: Callable[[int, int], int] = lambda x, y: x * y
outer: int = list(itertools.accumulate(shape[:axis], mul_func))[-1]

from typing import Callable

# 使用lambda表达式创建一个可调用对象
me_func: Callable[[int], int] = lambda x: x * x

# 测试me_func
output = me_func(5)
print(output)  # 应该打印25
# 在这个例子中，lambda x: x * x是一个匿名函数，它接受一个参数x并返回x的平方。

# 使用普通函数定义
# 定义一个函数
def square(x: int) -> int:
    return x * x

# 将函数赋值给me_func
me_func: Callable[[int], int] = square

# 测试me_func
output = me_func(5)
print(output)  # 应该打印25

def parrallel():
    # ... (省略其他代码)

    def fill_chunk(idx_chunk):
        # ... (省略其他代码)
        # 引入一个错误，例如除以零
        raise ValueError("An error occurred in fill_chunk")

    # Create ThreadPoolExecutor
    with ThreadPoolExecutor() as executor:
        # Parallel loop over chunks
        futures = executor.map(fill_chunk, range(n_chunks))

        # 迭代futures以确保任何抛出的异常都被捕获
        for future in futures:
            try:
                # 这里不需要做任何事情，因为我们只是想捕获异常
                pass
            except Exception as e:
                # 打印或处理异常
                print(f"An exception occurred: {e}")

# 调用函数
parrallel()

with ThreadPoolExecutor() as executor:
    # 提交多个任务
    futures = [executor.submit(me_func, i, nums) for i in range(10)]

    # 等待每个任务完成并处理可能的异常
    for future in concurrent.futures.as_completed(futures):
        try:
            result = future.result()
            print(f"Task returned: {result}")
        except ValueError as e:
            print(f"A ValueError occurred: {e}")
        except Exception as e:
            print(f"An exception occurred: {e}")

cmake_arg = [
    f"-DPYTHON_EXECUTABLE={sys.exec}",
    "-DCMAKE_BUILD_TYPE=Debug",
]

from functools import wraps

def logit(func):
    @wraps(func)  # 保留 被装饰函数 的metadata
    def with_logging(*args, **kwargs):
        print(func.__name__ + " was called")
        return func(*args, **kwargs)
    return with_logging

@logit
def adder(x):
   return x + x


result = adder(4)
# Output: adder_function was called

def decorator(a_func):
    @wraps(a_func)
    def wrapTheFunction():
        print("AA")
        a_func()
        print("BB")
    return wrapTheFunction

def target_func():
    print("这里是目标函数本来的功能")

target_func()
#outputs: "这里是目标函数本来的功能"

target_func = decorator(target_func)
#now target_func is wrapped by wrapTheFunction()

target_func()
#outputs: AA
#         这里是目标函数本来的功能
#         BB

for key_ in all_logs:
    url = key_
    xlsx_name = all_logs[url]
    command = ["wget", "-O", "LOG", url]
    subp = subprocess.Popen(command)
    subp.wait()   # 子进程同步
    to_excel("./LOG", xlsx_name + ".xlsx")

def add_func():
    return 1 + 2
def max_func():
    return max([1, 2, 3])
def min_func():
    return min([1, 2, 3])

op = ['add', 'max', 'min']

for i in op:
    result = globals()[f"{i}_func"]()
    print(f"Result of {i}: {result}")

for name, value in globals():
    print(name, ": ", value)  # 返回 RuntimeError: dictionary changed size during iteration
## 原因是：循环 for name, value in globals(): 迭代遍历 globals() 字典。
## 然而，在循环内部，语句 print(name, ": ", value) 会隐式地修改该字典。
## 这是因为 globals() 是一个动态字典，在迭代过程中访问它可能会触发内部更新，从而导致 RuntimeError 错误。

## 解决办法：拷贝一份，然后再遍历
global_vars = dict(globals())
for name, value in global_vars.items():
    print(name, ": ", value)

from typing import Callable

def execute(func: Callable[[int, int], int], a: int, b: int) -> int:
    return func(a, b)

def add(x: int, y: int) -> int:
    return x + y

result = execute(add, 5, 7)
print(result)  # 输出: 12

def my_function():
    return "Hello, World!"

print(callable(my_function))  # 输出: True

class MyClass:
    def __call__(self):
        return "Hello, World!"

my_instance = MyClass()
print(callable(my_instance))  # 输出: True

print(callable(42))  # 输出: False

def my_function(flag):
    if flag:
        my_var = 10
    print(my_var)  # 如果flag为False，my_var在这里可能是未绑定的

my_function(False)  # 这将导致一个错误，因为my_var没有被赋值 UnboundLocalError: local variable 'xx' referenced before assignment

flag = True
if flag:
    my_var = 10  # 在if块中定义变量
else:
    my_var = 20  # 在else块中定义变量

print(my_var)  # 无论flag的值如何，my_var都可以在这里访问

## L - Local（局部作用域）
def my_function():
    local_var = "I am a local variable"  # Local scope
    print(local_var)

my_function()
# print(local_var)  # 这会引发错误，因为local_var在函数外部不可见


## E - Enclosing（外层函数作用域）
def outer_function():
    enclosing_var = "I am an enclosing variable"  # Enclosing scope
    def inner_function():
        print(enclosing_var)  # 可以访问外层函数的变量
    inner_function()

outer_function()


## G - Global（全局作用域）
global_var = "I am a global variable"  # Global scope

def my_function():
    print(global_var)  # 可以访问全局变量

my_function()
print(global_var)  # 在函数外部也可以访问


## B - Built-in（内置作用域）
print(dir(__builtins__))  # 打印所有内置变量和函数的列表

def my_function():
    print(len([1, 2, 3]))  # 使用内置的len函数

my_function()

def my_function(flag):
    if flag:
        my_var = 10
    print(my_var)  # 如果flag为False，my_var在这里可能是未绑定的

my_function(False)  # 这将导致一个错误，因为my_var没有被赋值 UnboundLocalError: local variable 'xx' referenced before assignment