【Python】Python的一些知识

1. yield语句：yield语句是将数据产生出来并返回给调用者，同时将生成器的状态保存下来。当再次调用生成器时，它会从上一次离开的地方继续执行，并将yield语句之后的数据返回给调用者。在生成器中，yield语句只能用于产生数据，不能接收任何参数。

2. send方法：send方法与yield语句类似，也可以将数据传递给生成器。但是，与yield语句不同的是，send方法可以将数据发送给生成器中的yield语句，并重新激活生成器的执行。此外，第一次调用生成器时，必须使用next方法而不能使用send方法，因为没有yield语句可以接收send方法的参数。

简单来说，yield语句是将数据产生出来并返回给调用者，send方法是将数据发送给生成器中的yield语句并重新激活生成器的执行。使用yield语句只能将数据产生出来，使用send方法可以将数据发送给生成器并重新激活生成器的执行。

下面是一个简单的代码样例，用于说明Python生成器中yield和send的区别：

def generator():
    while True:
        value = yield
        print("Received value: ", value)

g = generator()
next(g)    # 激活生成器

# 使用yield语句产生数据
g.send(1)
g.send(2)
g.send(3)

# 输出：
# Received value:  1
# Received value:  2
# Received value:  3

在上面的代码中，定义了一个名为generator的生成器函数，其中使用了一个while循环来不断地产生数据。在生成器中，通过yield语句将数据产生出来并返回给调用者。调用方通过调用send方法将数据发送给生成器中的yield语句，并重新激活生成器的执行。

在上面的代码中，首先使用next方法来激活生成器。然后，使用send方法向生成器发送三个数据，每次发送完数据后，生成器会打印出"Received value: "和对应的值。可以看到，使用send方法可以向生成器发送数据，并重新激活生成器的执行，而yield语句只能将数据产生出来并返回给调用者。

在Python解释器中，每个线程在执行Python代码时都需要获取GIL锁。一旦某个线程获取到了GIL锁，它就可以执行Python代码。在执行过程中，如果遇到了IO操作或时间片用完等情况，线程会释放GIL锁，让其他线程有机会获取GIL锁并执行Python代码。但是，在某个线程持有GIL锁的情况下，其他线程只能等待，无法执行Python代码，因此GIL会对多线程的并行执行产生一定的限制。

由于GIL的存在，Python多线程在CPU密集型任务方面的性能并不理想，但是在IO密集型任务方面的性能表现较好，因为在IO操作中，线程会释放GIL锁，让其他线程有机会执行Python代码。

需要注意的是，GIL只是针对Python解释器而言，在使用Python扩展库时，如果扩展库中的代码是用C/C++等语言编写的，并且不依赖Python解释器的GIL锁，那么可以实现真正的并行执行。

装饰器的作用是将函数的某些行为“包裹”起来，并在执行函数时动态地修改函数的行为。常见的装饰器包括函数计时、缓存、日志记录、权限控制等。

下面是一个简单的装饰器示例，用于计算函数执行的时间：

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print("Function %s takes %f seconds to execute." % (func.__name__, end - start))
        return result
    return wrapper

@timer
def my_func(x):
    time.sleep(x)

my_func(3)

在上面的代码中，我们定义了一个名为timer的装饰器函数，它接收一个函数作为参数，并返回一个新的函数wrapper。wrapper函数负责执行原函数，并在执行前后计算函数的执行时间。最后，装饰器将wrapper函数返回给调用者，从而实现了对原函数的装饰。

在my_func函数的定义前，我们使用@timer语法将my_func函数传递给timer装饰器。这相当于将my_func函数作为参数传递给timer函数，并将返回值赋值给my_func变量。由于timer函数返回的是一个新的函数wrapper，因此最终的my_func函数实际上是wrapper函数。当我们调用my_func函数时，实际上是在调用wrapper函数，从而实现了函数计时的功能。

需要注意的是，装饰器本身并不会修改被装饰函数的代码，而是返回一个新的函数来代替原来的函数。因此，在使用装饰器时，应该注意被装饰函数的参数和返回值等信息是否会被修改。

• new 方法是用来创建一个实例对象的，通常会返回一个新的实例对象，是一个静态方法，第一个参数是 cls，代表要创建的类，其他参数用于传递给 init 方法。
• init 方法是用来初始化一个实例对象的，通常不返回任何值，是一个实例方法，第一个参数是 self，代表要初始化的对象，其他参数是 new 方法传递过来的参数。

具体来说，new 方法在对象创建之前被调用，它负责创建并返回对象，通常用于实现不可变类型的对象，比如 int、float、str 等。init 方法在对象创建之后被调用，它负责初始化对象的属性，通常用于实现可变类型的对象，比如列表、字典、自定义类等。

下面是一个简单的示例，演示了 new 和 init 方法的用法：

class Person:
    def __new__(cls, name):
        print("__new__ method is called")
        instance = super().__new__(cls)
        return instance
    
    def __init__(self, name):
        print("__init__ method is called")
        self.name = name

p = Person("Alice")
print(p.name)

在上面的代码中，我们定义了一个名为 Person 的类，它有一个参数 name，用于初始化对象的属性。在 new 方法中，我们先打印一条信息，然后调用 super() 方法创建一个新的实例对象，最后将实例对象返回。在 init 方法中，我们打印一条信息，然后将传入的参数 name 赋值给 self.name 属性。

当我们创建一个名为 Alice 的 Person 对象时，首先会调用 new 方法，创建并返回一个新的实例对象。然后，再调用 init 方法，初始化对象的属性，将参数 name 赋值给 self.name 属性。最后，打印对象的 name 属性，输出结果为 “Alice”。

需要注意的是，new 方法是一个静态方法，它不依赖于任何实例对象。因此，在 new 方法中不能访问实例属性，也不能调用实例方法。而 init 方法是一个实例方法，它只能在对象创建之后调用，并且只能访问实例属性和方法。

在 Python 中，垃圾回收（Garbage Collection，简称 GC）是自动进行的，它的主要目的是回收不再使用的内存，以便更好地利用系统资源。

Python 中的垃圾回收机制主要基于引用计数（Reference Counting）和标记清除（Mark and Sweep）两种算法。

引用计数是一种简单而有效的垃圾回收算法，它跟踪每个对象的引用计数，当引用计数变为 0 时，说明该对象不再被使用，可以被回收。Python 会自动维护每个对象的引用计数，当对象被创建、复制、作为函数参数传递、作为容器元素加入等操作时，引用计数会相应地增加或减少。

标记清除是一种更复杂的垃圾回收算法，它通过扫描对象间的引用关系来标记活动对象，并清除不再使用的对象。这种算法需要遍历整个对象图，对于大型的对象图，回收时间可能会比较长。

除了引用计数和标记清除外，Python 还支持分代回收（Generational GC），即将内存中的对象按照年龄分为几个代，每个代采用不同的回收策略。通常情况下，新创建的对象都会放到年轻代（Young Generation），当年轻代的空间满了之后，会触发一次垃圾回收，把活动对象复制到存活区（Survivor Space）中。经过多次回收后，存活时间较长的对象会被移到老年代（Old Generation），老年代中的对象可能需要使用标记清除算法进行回收。

Python 中的垃圾回收机制虽然自动进行，但也有一些问题。比如，引用计数算法可能会出现循环引用的情况，导致一些对象无法被回收；标记清除算法需要遍历整个对象图，耗费时间比较长。为了解决这些问题，Python 还引入了一些优化措施，比如延迟引用计数、增量垃圾回收等。

总之，了解 Python 的垃圾回收机制对于优化程序的性能、减少内存泄漏等问题非常重要。

Python中的反向索引（Reverse Indexing）指的是使用负数索引来访问序列中的元素，其中-1表示序列的最后一个元素，-2表示倒数第二个元素，以此类推。

例如，对于一个字符串"Hello, World!"，我们可以使用正向索引和反向索引来访问其中的元素：

s = "Hello, World!"
print(s[0])      # 'H'
print(s[7])      # 'W'
print(s[-1])     # '!'
print(s[-6])     # 'W'

需要注意的是，虽然反向索引可以方便地访问序列的最后几个元素，但是使用过多的负数索引会降低代码的可读性和可维护性，应该尽量避免。另外，对于一些可变序列（比如列表），使用负数索引还可以方便地进行切片操作。

在Python中，每个模块都有自己的命名空间，变量名和函数名默认只在本模块内部可见，无法在其他模块中直接使用。如果想要在多个模块之间共享全局变量，可以使用以下两种方法：

1. 将需要共享的变量定义在一个单独的模块中，并在其他模块中引用该模块。这种方法的优点是简单直观，可以避免出现命名冲突的问题。例如，在一个名为config.py的模块中定义全局变量：

   # config.py
   HOST = "localhost"
   PORT = 8080
   

   在其他模块中使用该变量时，只需要导入config模块即可：

   # main.py
   import config
   
   print(config.HOST)
   print(config.PORT)
   

2. 使用共享内存或者数据库等外部存储来实现全局变量的共享。这种方法的优点是可以在多个进程之间共享变量，并且支持更复杂的数据结构。但是需要考虑并发访问的问题，需要使用锁等机制来保证数据的一致性。这种方法适用于需要在多个进程或者机器之间共享数据的场景。

需要注意的是，在Python中并不鼓励使用全局变量，因为它会增加程序的复杂度和不可预测性。在实际开发中，应该尽量避免使用全局变量，而是使用参数传递和返回值来实现数据的共享和传递。