Python八股文

python return 和yield区别

在Python中，return 和 yield 是用于从函数中返回值的两种关键字，但它们之间有着很大的区别。

1. return：return 语句用于从函数中返回一个值，并终止函数的执行。当函数执行到 return 语句时，它会立即返回指定的值，并且不再执行函数的其他部分。一个函数可以包含多个 return 语句，但只有其中一个会被执行，因为执行到一个 return 语句后函数就会退出。
2. yield：yield 关键字用于定义生成器函数，它允许函数暂停执行，并返回一个中间值。每次调用生成器函数时，它会从上次暂停的地方继续执行，直到遇到下一个 yield 语句。yield 语句可以多次出现在一个生成器函数中，每次调用生成器函数时，它会执行到下一个 yield 语句，然后暂停，直到再次被调用。生成器函数的执行状态会被保存，这使得它可以生成一个序列而不需要一次性将所有值存储在内存中。

def generate_numbers():
    for i in range(5):
        yield i

numbers = generate_numbers()
for num in numbers:
    print(num)
#输出: 0 1 2 3 4

生成器函数：生成器函数是一种特殊的函数，它可以通过 yield 关键字来生成一系列值，而不是一次性返回所有结果。生成器函数可以在需要时生成值，这样可以节省内存，并允许以一种惰性的方式产生数据。在上文中numbers = generate_numbers() 只运行了一次，但它创建了一个生成器对象 numbers。当你使用 for num in numbers: 循环迭代生成器对象时，每次迭代都会触发生成器函数的执行，从上次暂停的地方继续执行，直到遇到下一个 yield 语句暂停。这样就会产生多个值，每次迭代都会生成一个新的值。

什么是闭包closure

闭包（Closure）是一种编程语言的特性，指的是一个函数（或者称为内部函数）能够访问其外部函数中的变量，并将该函数及其相关的环境打包成一个整体，形成一个闭包。闭包允许函数在定义时捕获其所在作用域的状态，即使在其定义作用域外被调用时也可以访问和修改这些状态。

下面是一个简单的实例：

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

closure = outer_function(5)
result = closure(3)
print(result)  # 输出: 8

在这个示例中，outer_function 是外部函数，它接受一个参数 x，并返回了一个内部函数 inner_function。inner_function 中引用了 outer_function 中的变量 x，形成了闭包。当 outer_function(5) 调用时，会返回 inner_function，此时 x 被绑定为 5。然后通过 closure(3) 调用返回的闭包，此时 x 保持为 5，然后与 y 相加得到结果 8。

闭包的优点和应用包括：

1. 保持状态：闭包可以在函数调用之间保持状态，而不需要使用全局变量。
2. 封装性：闭包可以封装私有数据和操作，并将其作为单个单元暴露给外部。
3. 代码复用：可以利用闭包来封装通用的功能，并在不同的上下文中复用。
4. 回调函数：闭包常用于创建回调函数，在事件发生时执行特定的逻辑。

需要注意的是，闭包可能导致内存泄漏，因为闭包中包含了对外部作用域的引用，使得外部作用域中的变量无法被垃圾回收。因此，当不再需要闭包时，最好手动解除对其的引用，以释放资源。

类方法、实例方法和静态方法

1. 类方法 (Class Methods):

类方法是与类相关联的方法，而不是与实例相关联。通过装饰器 @classmethod 来声明，第一个参数通常是 cls，代表类本身。类方法可以访问类的属性和方法，但不能直接访问实例的属性和方法。类方法通常用于创建、操作或者是在类级别上进行操作，而不涉及特定的实例。

class MyClass:
    class_variable = 0
    
    @classmethod
    def increment_class_variable(cls):
        cls.class_variable += 1
        
    @classmethod
    def get_class_variable(cls):
        return cls.class_variable

# 调用类方法
MyClass.increment_class_variable()
print(MyClass.get_class_variable())  # 输出: 1

2. 实例方法 (Instance Methods):

实例方法是与类的实例相关联的方法。在方法定义中，第一个参数通常是 self，代表实例本身。实例方法可以访问实例的属性和方法，也可以访问类的属性和方法。实例方法通常用于实例的初始化、操作和处理实例的状态。

class MyClass:
    def __init__(self, value):
        self.value = value
    
    def add_value(self, num):
        self.value += num
        
    def get_value(self):
        return self.value

# 创建实例
obj = MyClass(5)
# 调用实例方法
obj.add_value(3)
print(obj.get_value())  # 输出: 8

3. 静态方法 (Static Methods):

静态方法与类或实例无关，与普通函数类似，但是定义在类的内部。通过装饰器 @staticmethod 来声明，没有默认的第一个参数。静态方法不能访问类的属性和方法，也不能访问实例的属性和方法。静态方法通常用于在类的范围内提供一些功能，这些功能与特定的实例或类无关。

class MyClass:
    @staticmethod
    def multiply(x, y):
        return x * y

# 调用静态方法
result = MyClass.multiply(3, 4)
print(result)  # 输出: 12

这些不同类型的方法可以根据需要在类中混合使用。调用这些方法的方式也不同：类方法通过类名调用，实例方法通过实例调用，而静态方法可以通过类名或实例名调用。

多线程和多进程区别

1. 多线程 (Multithreading):多线程是在同一进程内执行的多个线程，每个线程共享相同的地址空间和其他资源。多线程适合于I/O密集型任务和轻量级的并发操作，因为线程之间的切换开销较小。多线程的优势在于线程之间可以共享内存，因此数据共享和通信相对容易实现。线程之间的同步和互斥操作通常需要额外的锁机制，以防止竞态条件和数据不一致的问题。
2. 多进程 (Multiprocessing):多进程是在不同的进程中执行的多个进程，每个进程有自己独立的地址空间和资源。多进程适合于CPU密集型任务和需要更高级别的并行性的应用程序，因为进程之间的切换开销较大。多进程的优势在于进程之间的隔离性，每个进程有自己独立的内存空间，因此数据共享和通信相对复杂。进程之间的通信通常使用消息传递机制，如队列、管道等，或者使用共享内存来实现数据共享。

总的来说，多线程适用于轻量级的并发任务，而多进程更适用于需要更高级别并行性和更好隔离性的任务。选择使用哪种方式取决于具体的应用场景和需求。

*arg 和**karg的区别是什么

*args 和 **kwargs 是 Python 中用于处理函数参数的特殊语法，它们用于接收不定数量的参数，其中 *args 用于接收位置参数，而 **kwargs 用于接收关键字参数。

*args：*args 是一个元组（tuple），用于接收不定数量的位置参数。

• 当你不确定函数会接收多少个位置参数时，可以使用 *args 来接收。
• 在函数定义时，将 *args 放在参数列表中，表示该函数可以接收任意数量的位置参数。
• 在函数调用时，可以传递任意数量的位置参数给 *args，它们会被自动打包成一个元组传递给函数。

**kwargs：**kwargs 是一个字典（dictionary），用于接收不定数量的关键字参数。

• 当你不确定函数会接收多少个关键字参数时，可以使用 **kwargs 来接收。
• 在函数定义时，将 **kwargs 放在参数列表中，表示该函数可以接收任意数量的关键字参数。
• 在函数调用时，可以传递任意数量的关键字参数给 **kwargs，它们会被自动打包成一个字典传递给函数，其中键是参数名，值是对应的参数值。

def example_function(*args, **kwargs):
    print("Positional arguments (args):", args)
    print("Keyword arguments (kwargs):", kwargs)

# 测试
example_function(1, 2, 3, name="Alice", age=30)

在这个示例中，example_function() 函数接收了三个位置参数和两个关键字参数。*args 接收了位置参数 1, 2, 3，它们被打包成一个元组；**kwargs 接收了关键字参数 name="Alice" 和 age=30，它们被打包成一个字典。

python的内存管理方式

Python的内存管理机制涉及多个方面，包括对象的分配和释放、垃圾回收机制、内存池管理等。以下是对这些方面的详细介绍：

1. 内存分配和释放

Python使用动态内存分配来管理对象的内存，这意味着内存的分配和释放都是在运行时进行的。Python通过一个名为PyObject的结构体来管理对象的引用计数，以此来追踪对象的使用情况。

2. 引用计数

Python使用引用计数（Reference Counting）作为其主要的内存管理机制。每个对象都有一个引用计数器，记录有多少个引用指向该对象。当一个新的引用指向对象时，引用计数器加1；当引用被删除时，引用计数器减1。引用计数器为0时，表示该对象不再被使用，其占用的内存可以被回收。

import sys
a = []
print(sys.getrefcount(a))  # 初始引用计数
b = a
print(sys.getrefcount(a))  # 引用计数增加
del b
print(sys.getrefcount(a))  # 引用计数减少

3. 垃圾回收机制

除了引用计数，Python还实现了一个垃圾回收（Garbage Collection, GC）机制来处理循环引用的问题。Python的垃圾回收机制使用了分代回收算法，将对象分为三代（generation），新创建的对象属于第0代，存活时间较长的对象会逐渐移动到第1代和第2代。垃圾回收器会优先检查第0代对象，逐渐向更高代次推进。

垃圾回收器的工作流程包括以下几步：

1. 标记：标记所有活动的对象。
2. 清除：清除未被标记的对象。
3. 整理：有时会整理内存以减少碎片。

import gc
gc.collect()  # 手动触发垃圾回收

4. 内存池管理

为了提高内存分配和释放的效率，Python使用了一种称为内存池（Memory Pool）的技术。内存池将小对象（小于256字节）的内存分配委托给一个名为pymalloc的专用分配器，而不是直接使用操作系统提供的内存分配函数（如malloc）。这种方式减少了内存碎片，提高了内存分配和释放的效率。

5. 内存泄漏检测

尽管Python的内存管理机制较为完善，但在某些情况下仍可能发生内存泄漏，特别是在使用外部扩展模块时。为了检测内存泄漏，可以使用Python标准库中的gc模块和tracemalloc模块。

import tracemalloc
tracemalloc.start()
# 代码运行
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')
for stat in top_stats[:10]:
    print(stat)

6. 使用工具监控内存

开发过程中，可以使用一些第三方工具来监控和分析Python程序的内存使用情况。例如：

• objgraph：可以生成对象引用图，帮助分析对象间的引用关系。
• memory_profiler：可以按行监控内存使用情况。
• guppy3：可以提供详细的内存使用报告。

from memory_profiler import profile
@profile
def my_func():
    a = [1] * (10 ** 6)
    b = [2] * (2 * 10 ** 7)
    del b
    return a
my_func()

Python通过引用计数和垃圾回收机制实现了自动内存管理，并通过内存池技术优化了小对象的内存分配和释放。这些机制共同作用，使得开发者能够专注于业务逻辑，而不必过多担心内存管理的细节

python的继承机制是什么样的

1. 单继承与多继承：单继承：一个子类只能继承一个父类。多继承：一个子类可以继承多个父类。
2. 继承的层次结构：继承关系可以形成多层次的继承结构，即一个类可以继承另一个类，而这个类又可以继承另一个类。
3. 方法重载与重写：方法重载（Overloading）：Python不直接支持方法重载，即不能定义同名的多个方法，只能通过默认参数等方式实现类似效果。方法重写（Overriding）：子类可以重写父类的方法。通过调用super()函数，子类可以调用被重写的父类方法。
4. 继承内置类：Python允许自定义类继承内置类，如list、dict等，从而扩展其功能。

下面是一些具体的例子来说明如何实现继承及其相关特点：

单继承

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        print(f"{self.name} makes a sound")

class Dog(Animal):
    def speak(self):
        print(f"{self.name} barks")

# 使用子类
dog = Dog("Buddy")
dog.speak()  # 输出: Buddy barks

多继承

class Flyer:
    def fly(self):
        print("Flying")

class Swimmer:
    def swim(self):
        print("Swimming")

class Duck(Flyer, Swimmer):
    pass

# 使用子类
duck = Duck()
duck.fly()   # 输出: Flying
duck.swim()  # 输出: Swimming

方法重写与super()

class Parent:
    def greet(self):
        print("Hello from Parent")

class Child(Parent):
    def greet(self):
        super().greet()  # 调用父类的方法
        print("Hello from Child")

# 使用子类
child = Child()
child.greet()  # 输出: Hello from Parent
               #      Hello from Child

继承内置类

class MyList(list):
    def append(self, item):
        print(f"Adding {item} to the list")
        super().append(item)

# 使用自定义类
my_list = MyList()
my_list.append(1)  # 输出: Adding 1 to the list
print(my_list)     # 输出: [1]