#定义两个列表
    l1 = [111, ]  # 列表[111,],引用计数+1
    l2 = [222, ]  # 列表[222,],引用计数+1

    l1.append(l2)  # l1=[值111的内存地址，l2列表的内存地址]  
    l2.append(l1)  # l2=[值222的内存地址，l1列表的内存地址]
    # 两个列表之间存在相互引用，在当将两个之间的关联解除是，但是值的引用并不会因为解除而变为0，那么就不会触发GC机制将占用的内存空间回收，例如：
    del l1  # 列表1的引用计数减1，列表1的引用计数变为1
    del l2  # 列表2的引用计数减1，列表2的引用计数变为1

class CTManager:
    def __enter__(self):
        print('__enter__被执行')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('__exit__被执行')


with CTManager() as ct:
    print('显示在上下文管理器中间')


#执行结果：
#__enter__被执行
#显示在上下文管理器中间
#__exit__被执行

from contextlib import contextmanager

class File:
    def __init__(self, filename, mode):
        self.f = open(filename, mode)

    def reads(self):
        return self.f.read()

    def closed(self):
        self.f.close()


@contextmanager
def read_file():
    print(1)
    rf = File("README.md", "rb")
    yield rf
    print(3)
    rf.closed()

with read_file() as f:
    print(2)
    f.reads()

class MyClass:
    class_attr = "Class Attribute"

    def __init__(self, instance_attr):
        self.instance_attr = instance_attr

    @classmethod
    def class_method(cls):
        print("This is a class method.")
        print(cls.class_attr)

    @staticmethod
    def static_method():
        print("This is a static method.")

# 调用类方法，不需要创建实例
MyClass.class_method()

# 调用静态方法，不需要创建实例
MyClass.static_method()

# 创建实例
my_obj = MyClass("Instance Attribute")

# 通过实例调用
[Something went wrong, please try again later.]

python
def my_generator():
    for i in range(5):
        yield i

# 使用生成器
gen = my_generator()
for item in gen:
    print(item)

列表（List）：列表是Python中最常用的数据结构之一，它是一个有序、可变的集合。列表可以包含不同类型的元素，并且可以通过索引访问和修改元素。列表使用方括号([])来表示，可以使用多种方法对列表进行操作，如添加、删除、切片等。

元组（Tuple）：元组与列表类似，也是一个有序的集合，但是元组是不可变的，即不能修改其元素。元组使用圆括号(())来表示，通常用于存储不可变的数据。

字典（Dictionary）：字典是Python中的一种键值对（key-value）映射的数据结构。字典是无序的，并且可以动态地添加、删除和修改键值对。字典使用花括号({})来表示，每个键值对由冒号(:)分隔。

集合（Set）：集合是一个无序、不重复的集合。集合提供了一些常见的集合操作，如并集、交集、差集等。集合使用花括号({})或set()函数来表示。

字符串（String）：字符串是一串字符的序列，使用引号（单引号或双引号）来定义。字符串是不可变的，即不能修改其中的字符，但可以通过切片等方式进行操作。

除了这些基本数据结构外，Python还提供了其他一些高级的数据结构，如堆（heapq）、队列（Queue）、栈（Stack）等，这些数据结构通常需要通过导入相应的模块来使用。

总而言之，Python中的基本数据结构包括列表、元组、字典、集合和字符串。这些数据结构可以满足大部分常见的数据存储和处理需求。

set()  # 是可以变集合, 只能存储不可变对象(字符串, 数字...)
a = [1, 2, 3]
set(a)
-> {1, 2, 3}

frozenset()  # 是不可变集合
a = [1, 2, 3]
frozenset(a)
-> {1, 2, 3}

filter(lamda x: x>0, [-1, 0, 1, 2, 3])
-> [1, 2, 3]

生成器 = map(函数, 可迭代对象)
需要使用next(生成器)才能获取值

a = map(lamda x: x*x, [1, 2, 3])
print(next(a))

或者进行迭代循环
for i in a:
    ...

reduce(lamda x, y:x*y, [1, 2, 3])

相当于
先计算1 * 2 = 2
再通过第一次计算的结果2 * 3 = 6
这样不断的累积计算, 返回结果

1. 所有的python代码都会被complie成一个 code object
2. python的解释器， 在运行python代码之前会建立一个frame他提供了一个程序运行的环境， 局部变量， 全局变量， 包含这段代码对应的bytecode， 还有上一个运行的bytecode。
3. 除了最开始运行python代码建立的frame之外，再之后每一次调用一次函数， 都会建立一个frame， 那你可以理解为每一个bytecode都是在一个frame里面执行的， 然后每一个frame处理最外面那个之外， 都是一个function call都是一个函数的调用。
4. 我们可以使用dis这个模块对程序运行的字节码进行打印

总结：
当你每一次调用函数或者开始运行Python的时候
会建立一个新的frame, 然后在这个frame这个环境下
会一条一条的运行bytecode， 每一条bytecode在cpython里面都有相应的代码去执行他
在每一个frame里python会维护一个栈，然后bytecode会根这个栈进行交互
当然也会和这个code object里保存的乱七八糟的东西进行交互， 接着就是进行计算， 返回结果继续。。。

def f():
    pass

# code object
print(f.__code__)

# 查看这个obj里面的所有属性
dir(f.__code__)

# 理解为真正的bytecode二进制字节玛
code.co_code

是计算机cpu调度的最小单位， 可以简单的理解为我们的程序都是运行在线程里面的， 每个线程都有属于自己的上下文。

多线程出现之初， 是在不现实 的切换任务情况下， 让cpu可以同时处理多个任务。
1. io瓶颈任务， 文件读取， 网络传输
通过多线程可以把这段闲着的时间利用起来。

当然对于io瓶颈的任务， 我们现在经常可以使用携程asyncio来完成， 携程相对多线程更轻， 而且没有竞争冒险的问题，所以在网络传输的领域用的越来越多了。
但是携程有一个问题， 必须要显示的放权， 就是必须通过await显示的把控制器交还给计算器大脑。

在一个线程情况下使用携程:
假如说有一个大量计算的问题， 而且不着急可以慢慢做， 但是又有很多其他小任务， 要在低延迟的情况下解决,
在这样的情况下如何解决这个任务的调度， 如果不做任何的处理， 就会陷入到大量计算任务中出不来， 可是如果你在计算任务中， 人工安置一些放权点，会让你这个任务看起来很奇怪， 而且需要你对这个任务足够了解。
而且当你调用的是别人的函数， 就没有办法在别人的函数里面放权的。

这种情况下使用多线程就可以方便的解决这种情况， 当然了在asyncio里面使用run_in_executor来解决这个问题， 
这个函数本质上也是使用多线程或者多进程来解决这个问题的。

进程比线程根大
每个进程有自己的内存阿之类的， 一个进程可以有好几个线程， 这些线程会共享这个进程所有的内存， 可以理解为都可以读写同样 的变量。

在c 和 c++里面我们需要显示的释放内存的， 当你光分配不释放， 内存就越来越多， 就会爆炸。
而在python里面， 我们并不需要显示的释放内存， 所以的obj, dict , list属性， 拿来直接用就可以了。我们不用做这些烦心事
是因为在Python的解释器memory management帮我们做了这件事，python是如何做到自动分配， 释放内存的呢
尤其是释放内存的， python使用的机制是 引用技术reference count
就是每一个python的obj都数着有多少 个地方用到了自己， 就把自己的引用计数+1， 如果这个地方不用了，或者没有了 引用计数就-1， 这样只要你数数数的是对的
那么我们就可以知道， 什么时候引用计数到0了， 没有人用到为了， 就把这块内存释放掉。

问题1： 竞争冒险的问题
1. 加锁GIL锁
2. 他的作用就是拿到一个全局锁， 他会保证当前线程会拿到这个GIL锁， 通过这种机制， 每一个bytecode在运行的时候， 都是拿到这个线程锁的，换言之没有bytecode可以被其他的线程打断，这样的话每个bytecode在c里面运行的程序都是线程安全的
很多人诟病说python这个GIL是阻止python前进的一个至顾，但是他最开始这样设计，肯定是有他的初衷的
2. 1 第一就是他是一个非常简单的设计
2.2 由于只有一个线程锁， 他避免了死锁的问题，当一个线程里存在两个以上的锁的时候， 就有可能造成死锁的问题，对与单线程的程序， 或者没办法并行的多线程程序， 
全局锁的性能是非常优秀的。
2.3 但是由于GIL锁的机制， 就出现了不管你有多少个线程， 实际上运行python代码的只有一条线程，这就导致了， python的多线程没有办法利用多核来优化自己的代码

最简单的就是用多进程来解决这个问题， 虽然一个进程没有办法利用多个cpu， 但是可以有多个进程， 或者可以使用一些没有GIL的一些解释器
像是Jython， IronPython都是没有GIL的
但是PyPy是有的。

一.官方解释器默认cpython
1. 速度： 由于这个传统虚拟机的架构
2.GIL: 全局解释器锁， 导致多线程是一个残废的多线程

二.pypy解释器
速度是cpython的4.5倍
由于这些解释器都是先等cpython先实现出来了， 再根据cpython的工作原理， 来现实其他的解释权， 所以就很难跟上cpython的步伐， 是个不公平的竞争。
而且很多很优秀的库， 而这些库都是先适配cpython的， 假如说, 虚拟环境...

jpython
使得python与java之间的交互变得简单

micropython
单片机上被经常用到，只实现了python的核心功能， 做的很小。

func(n):
    if n == 1:
        return n
    return n*func(n-1)

def my_decorator(func):
    def wrapper():
        print("Before function is called.")
        func()
        print("After function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello, World!")

@decorator_one
@decorator_two
def my_function():
    # Function body here

try:
    # 可能会出现异常的代码块
    # ...
except ExceptionType1:
    # 处理 ExceptionType1 类型的异常逻辑
    # ...
except ExceptionType2:
    # 处理 ExceptionType2 类型的异常逻辑
    # ...
else:
    # 没有发生异常时执行的逻辑
    # ...
finally:
    # 不论是否发生异常都会执行的逻辑
    # ...

try:
    # 可能会出现异常的代码块
    # ...
except:
    # 处理所有异常的逻辑
    # ...

微服务是一种软件架构模式，它将一个应用程序拆分为一组小型、独立部署的服务，每个服务都专注于实现特定的业务功能。这些微服务可以通过网络互相通信，并且可以使用不同的编程语言、存储技术和数据处理工具。

通常情况下，每个微服务都有自己的数据库，并且可以独立部署、升级和扩展。微服务架构的优势包括灵活性、可伸缩性和容错性，因为每个微服务都可以独立地开发和部署，而不会影响整个应用程序的其他部分。

微服务架构通常与容器化技术（如Docker）和容器编排工具（如Kubernetes）结合使用，以便更好地管理和部署大量的微服务。这种架构模式在构建大型、复杂的分布式系统时非常流行，因为它有助于降低应用程序的耦合度，并且能够更好地应对快速变化和需求的增长。

import asyncio

async def my_coroutine():
    while True:
        print("Async task running...")
        await asyncio.sleep(1)  # 等待1秒

# 创建事件循环
loop = asyncio.get_event_loop()

# 将异步任务加入事件循环
loop.create_task(my_coroutine())

# 运行事件循环，直到手动取消
try:
    loop.run_forever()
except KeyboardInterrupt:
    pass
finally:
    loop.close()