一.Python中的装饰器是什么?如何使用?

装饰器(Decorator):是一种用于修改或扩展函数或方法行为的高阶函数。装饰器本质上是一个函数，它接受一个函数作为参数并返回另一个函数。

def my_decorator(func):
    def wrapper():
        print("在函数执行之前做一些事情")
        func()
        print("在函数执行之后做一些事情")
    return wrapper
@my_decorator
def say_hello():
    print("Hello!")
    
say_hello()
# 输出:
#在函数执行之前做一些事情
# Hello!
#在函数执行之后做一些事情

二.Python中的列表和元组有什么区别?

• 列表(List):是可变的(mutable)，即可以修改、添加或删除元素。列表使用方括号[定义。
• ·元组(Tuple):是不可变的(immutable)，即一旦创建就不能修改。元组使用圆括号()定义。

# 列表示例
my_list=[1,2,3]
my_list.append(4)# 添加元素
my_list[0]= 10# 修改元素
#输出:[10，2，3，4]print(my_list)
# 元组示例
my_tuple =(1,2,3)
#my_tuple[0]=10 # 这行会报错，因为元组不可变
print(my_tuple)#输出:(1，2，3)

三.Python中的生成器是什么?如何使用?

生成器(Generator):是Python中用于按需生成值的工具，它通过yield关键字实现。生成器的核心特点是惰性计算，即只有在需要时才会生成值，从而节省内存。

def my_generator():
    yield 1
    yield 2
    yield 3
gen = my_generator()
print(next(gen))#输出:1
print(next(gen))# 输出:2
print(next(gen))#输出:3

四.Python中的with语句是如何工作的?

with语句:用于简化资源管理，确保在使用完资源后正确释放。它通常用于文件操作、数据库连接等场景。with语句会自动调用对象的enter和exit方法。

with open('example.txt','r')as file:
    content = file.read()
    print(content)
#文件会在with块结束后自动关闭

五.Python中的*args和**kwargs是什么?

• *args 用于接收任意数量的位置参数(非关键字参数)，通常以元组形式传递
• **kwargs 用于接收任意数量的关键字参数(键值对形式的参数)，通常以字典形式传递。

注意：

• 一个:用于处理位置参数，表示将多个位置参数打包成一个元组
• 两个*:用于处理关键字参数，表示将多个关键字参数打包成一个字典。

def my_function(*args, **kwargs):
    print("args:",args)
    print("kwargs:",kwargs)
my_function(1,2,3,name="Alice",age=25)
# 输出:
# args:(1，2，3)
# kwargs:{'name':Alice','age': 25}

六.Python中的GIL(全局解释器锁)是什么?

• GIL(GlobalInterpreter Lock):是CPython解释器中的一个互斥锁，确保同一时间只有一个线程执行Python字节码。GIL是CPython 解释器(Python 的默认实现)特有的机制，其他实现(如 Jython、lronPython)没有 GIL
• 作用:GIL 的主要作用是保护 Python 内部数据结构(如对象引用计数)的线程安全。由于Python 使用引用计数来管理内存，多个线程同时修改引用计数可能会导致内存泄漏或错误。GIL 通过强制同一时间只有一个线程执行 Python 字节码来避免这些问题。

工作原理:

• GIL 是一个全局锁，每个线程在执行 Python 字节码之前必须先获取 GIL。
• 当一个线程获取 GIL后，其他线程必须等待该线程释放 G儿L 才能继续执行。

优点:

• 简化内存管理:GIL 避免了多线程环境下引用计数的竞争条件，简化了CPython 的内存管理。提高单线程性能:由于 GIL 的存在，单线程程序的性能通常更好，因为不需要频繁地获取和释放锁。

缺点

• 限制多线程并行:GIL导致 Python 的多线程程序无法充分利用多核 CPU 的并行计算能力。影响 CPU 密集型任务:对于 CPU 密集型任务(如科学计算、图像处理)，多线程程序性能可能不如单线程程序。

如何绕过GIL

• 使用多进程:Python 的 multiprocessing 模块可以创建多个进程，每个进程有独立的Python 解释器和内存空间，从而充分利用多核 CPU。
• 使用 C 扩展:在 C 扩展模块中释放 GIL，允许其他线程执行 Python 代码。
• 使用其他 Python 实现:如 Jython(基于 JVM)或 lronPython(基于 .NET)，它们没有 GIL。

import threading
def worker():
    print("Worker thread")   
threads = []
for i in range(5):
    t= threading.Thread(target=worker)
    threads.append(t)
    t.start()
for t in threads:
    t.join()    

七.Python中的_init 和new 有什么区别?

• _init_ :是实例初始化方法，用于初始化对象的属性。
• _new_ :是实例创建方法，用于创建并返回一个新的实例。它的调用发生在_init_() 之前。
• 大多数情况下，你不需要重写_new_()。但在以下场景中，可能需要自定义_new_():
  • 实现单例模式:确保一个类只有一个实例。
  • 返回子类实例:在父类的_new_()中返回子类的实例。
  • 修改实例创建逻辑:例如，根据条件返回不同类型的实例

class MyClass:
    def __new__(cls,*args,**kwargs):
        print("Creating instance")
        instance =super(MyClass,cls).__new__(cls)
        return instance
    def __init__(self,value):
        print("Initializing instance")
        self.value = value
obj = MyClass(10)
# 输出:
# Creating instance
# Initializing instance

八.Python中的lambda函数是什么?如何使用?

• lambda函数:是一种匿名函数，通常用于简单的操作。它可以接受任意数量的参数，但只能有一个表达式。
• lambda 函数的基本语法
  • lambda 是关键字，表示定义一个匿名函数。
  • 参数1, 参数2,… 是函数的参数，可以有多个，用逗号分隔。
  • 表达式 是函数的返回值，lambda 函数会计算并返回这个表达式的值。
• lambda 参数1，参数2，…:表达式
• lambda 函数的特点
  • 匿名性:lambda 函数没有名字，通常用于一次性使用的场景
  • 简洁性:lambda 函数通常只包含一个表达式，代码简洁。
  • 局限性:lambda 函数不能包含复杂的逻辑(如多行语句或条件判断)，只能返回一个表达式的值。

#示例1
add = lambda x,y:x+ y
print(add(2,3)) # 输出:5
# 示例2
#使用 sorted()对列表中的元组按第二个元素排序
pairs =[(1,3),(2,1),(4,2)]
sorted_pairs = sorted(pairs, key=lambda x: x[1])
print(sorted_pairs) #输出:[(2，1)，(4，2)，(1，3)]
#示例3
result =["apple","banana","cherry","date","fig","grape"]
sorted_result =sorted(result, key=lambda x:(len(x),x))
# lambda x:(len(x)，x)是一个匿名函数，
#它接受一个参数 x(即列表中的每个元素),并返回一个元组(len(x),x)# 
#排序规则:1.首先按长度排序:len(x)表示元素的长度，列表会先按元素的长度从小到大排序。
#2.长度相同则按字典序排序:如果两个元素的长度相同，则按元素本身的字典序(即字母或数字的顺序)排序。
print(sorted_result)#输出:['fig','date','apple','grape''banana', 'cherry']

九.Python中的map、filter和reduce函数是什么?如何使用?

• map:对可迭代对象中的每个元素应用一个函数，并返回一个迭代器。。语法:map(function,iterable….)
• filter:根据条件过滤可迭代对象中的元素，并返回一个迭代器。
• reduce:对可迭代对象中的元素进行累积操作，返回一个单一的值。

from functools import reduce
numbers =[1,2,3,4,5]
# map示例
squared =map(lambda x:x** 2,numbers)
print(list(squared))#输出:[1，4，9，16，25]
# filter示例
evens = filter(lambda x: x % 2==0,numbers)
print(list(evens))#输出:[2，4]
# reduce示例
total =reduce(lambda x,y:x+y,numbers)
print(total)#输出:15

十.Python中的__slots__ 是什么?如何使用?

• __slots__-:是一个类变量，用于限制类的实例可以拥有的属性。使用__slots__可以节省内存，因为它阻止了实例字典的创建。

class MyClass:
    __slots__=['name', 'age']
    
    def __init__ (self, name, age):
        self.name = name
        self.age = age
        
obj = MyClass("Alice",25)
# obj.address ="123 Street'
# 这行会报错，因为address不在_slots中