个人python面试准备的一些题型

胡图

Python类方法vs静态方法

类方法（Class Methods）

类方法使用@classmethod装饰器定义，它们的第一个参数通常命名为cls，代表类本身。
特点：

• 可以访问和修改类的状态
  
• 不能访问实例的状态
  
• 可以用来定义替代构造器
  

示例：

1. class MyClass:
2.     class_variable = 0
4.     @classmethod
5.     def increment_class_variable(cls):
6.         cls.class_variable += 1
8.     @classmethod
9.     def from_string(cls, string_param):
10.         # 替代构造器
11.         return cls(int(string_param))
13. # 使用类方法
14. MyClass.increment_class_variable()
15. obj = MyClass.from_string("10")

复制代码

静态方法（Static Methods）

静态方法使用@staticmethod装饰器定义，它们不接收任何特殊的第一个参数。
特点：

• 不能访问或修改类的状态
  
• 不能访问实例的状态
  
• 主要用于将功能逻辑组织到类中
  

示例：

1. class MathOperations:
2.     @staticmethod
3.     def add(x, y):
4.         return x + y
6.     @staticmethod
7.     def multiply(x, y):
8.         return x * y
10. # 使用静态方法
11. result = MathOperations.add(5, 3)

复制代码

主要区别

• 参数：类方法接收类作为隐式第一个参数，静态方法不接收特殊参数。
  
• 访问类属性：类方法可以访问和修改类属性，静态方法不能。
  
• 使用场景：
  
  
  
  • 类方法通常用于需要访问类状态的操作，如替代构造器。
    
  • 静态方法用于与类相关但不需要访问类状态的操作。
    
  
  
• 继承行为：子类继承类方法时，cls参数会指向子类。静态方法的行为在继承时不变。
  

选择使用哪种方法

• 如果方法需要访问类属性或者修改类状态，使用类方法。
  
• 如果方法不需要访问类或实例状态，只是提供一些相关功能，使用静态方法。
  
• 如果方法既不需要访问类状态也不需要访问实例状态，但从逻辑上属于类，使用静态方法。
  

Python中的深拷贝与浅拷贝

在Python中，当我们复制对象时，有两种主要的方式：深拷贝（Deep Copy）和浅拷贝（Shallow Copy）。理解这两者的区别对于正确处理复杂数据结构非常重要。
浅拷贝（Shallow Copy）

浅拷贝创建一个新对象，但是它包含的元素是原始对象中元素的引用。
特点：

• 创建一个新对象
  
• 新对象中的元素是原始对象元素的引用
  
• 只复制对象的第一层
  

实现方式：

• 使用切片操作 [:]
  
• 使用 copy() 方法
  
• 使用 copy 模块的 copy() 函数
  

示例：

1. import copy
3. original = [1, [2, 3], 4]
4. shallow = copy.copy(original)
6. # 修改浅拷贝中的嵌套列表
7. shallow[1][0] = 'X'
9. print(original)  # 输出: [1, ['X', 3], 4]
10. print(shallow)   # 输出: [1, ['X', 3], 4]

复制代码

在这个例子中，修改浅拷贝中的嵌套列表也会影响原始列表。
深拷贝（Deep Copy）

深拷贝创建一个新对象，并递归地复制原始对象中的所有嵌套对象。
特点：

• 创建一个全新的对象
  
• 递归地复制所有嵌套的对象
  
• 原始对象和拷贝对象完全独立
  

实现方式：

• 使用 copy 模块的 deepcopy() 函数
  

示例：

1. import copy
3. original = [1, [2, 3], 4]
4. deep = copy.deepcopy(original)
6. # 修改深拷贝中的嵌套列表
7. deep[1][0] = 'X'
9. print(original)  # 输出: [1, [2, 3], 4]
10. print(deep)      # 输出: [1, ['X', 3], 4]

复制代码

在这个例子中，修改深拷贝中的嵌套列表不会影响原始列表。
主要区别

• 复制深度：浅拷贝只复制对象的第一层，而深拷贝递归地复制所有层。
  
• 内存使用：深拷贝通常比浅拷贝使用更多的内存，因为它创建了所有嵌套对象的副本。
  
• 性能：深拷贝通常比浅拷贝慢，特别是对于大型或复杂的数据结构。
  
• 独立性：深拷贝创建的对象与原始对象完全独立，而浅拷贝创建的对象与原始对象共享部分数据。
  

使用场景

• 使用浅拷贝：当您只需要复制对象的顶层，而且嵌套对象可以共享时。
  
• 使用深拷贝：当您需要创建一个完全独立的副本，包括所有嵌套对象时。
  

注意事项

• 对于不可变对象（如元组），浅拷贝和深拷贝的行为是相同的。
  
• 循环引用可能会导致深拷贝出现问题，deepcopy() 函数有处理这种情况的机制。
  
• 自定义类可以通过实现 __copy__() 和 __deepcopy__() 方法来控制复制行为。
  

Python装饰器详解

装饰器是Python中的一种高级功能，允许您修改或增强函数或类的行为，而无需直接修改其源代码。
基本概念

装饰器本质上是一个函数，它接受一个函数作为参数，并返回一个新的函数。
基本语法

1. @decorator_function
2. def target_function():
3.     pass

复制代码

这等同于：

1. def target_function():
2.     pass
3. target_function = decorator_function(target_function)

复制代码

简单装饰器示例

1. 函数装饰器

1. def uppercase_decorator(func):
2.     def wrapper():
3.         result = func()
4.         return result.upper()
5.     return wrapper
7. @uppercase_decorator
8. def greet():
9.     return "hello, world!"
11. print(greet())  # 输出：HELLO, WORLD!

复制代码

2. 带参数的装饰器

1. def repeat_decorator(times):
2.     def decorator(func):
3.         def wrapper(*args, **kwargs):
4.             for _ in range(times):
5.                 result = func(*args, **kwargs)
6.             return result
7.         return wrapper
8.     return decorator
10. @repeat_decorator(3)
11. def greet(name):
12.     print(f"Hello, {name}!")
14. greet("Alice")  # 将打印 3 次 "Hello, Alice!"

复制代码

装饰器的高级用法

1. 类作为装饰器

1. class CountCalls:
2.     def __init__(self, func):
3.         self.func = func
4.         self.num_calls = 0
5.    
6.     def __call__(self, *args, **kwargs):
7.         self.num_calls += 1
8.         print(f"Call {self.num_calls} of {self.func.__name__!r}")
9.         return self.func(*args, **kwargs)
11. @CountCalls
12. def say_hello():
13.     print("Hello!")
15. say_hello()
16. say_hello()

复制代码

2. 保留原函数的元数据

使用 functools.wraps 装饰器来保留被装饰函数的元数据：

1. from functools import wraps
3. def my_decorator(func):
4.     @wraps(func)
5.     def wrapper(*args, **kwargs):
6.         """Wrapper function"""
7.         print('Before call')
8.         result = func(*args, **kwargs)
9.         print('After call')
10.         return result
11.     return wrapper
13. @my_decorator
14. def greet(name):
15.     """Greet someone"""
16.     print(f"Hello, {name}!")
18. print(greet.__name__)  # 输出：greet
19. print(greet.__doc__)   # 输出：Greet someone

复制代码

装饰器的常见应用

• 日志记录
  
• 性能测量
  
• 访问控制和认证
  
• 缓存
  
• 错误处理和重试逻辑
  

注意事项

• 装饰器在函数定义时就会执行，而不是在函数调用时。
  
• 多个装饰器可以堆叠使用，执行顺序是从下到上。
  
• 装饰器可能会影响函数的性能，特别是在频繁调用的情况下。
  
• 使用 functools.wraps 可以保留被装饰函数的元数据。
  

装饰器的实现原理

装饰器的实现原理涉及到Python的几个重要概念：函数是一等公民、闭包、以及Python的语法糖。让我们逐步分解装饰器的实现过程：
1. 函数作为一等公民

在Python中，函数是一等公民，这意味着函数可以：

• 赋值给变量
  
• 作为参数传递给其他函数
  
• 作为其他函数的返回值
  

这是装饰器实现的基础。
2. 闭包

闭包是一个函数，它记住了创建它时的环境。在Python中，内部函数可以访问外部函数的变量，这就创建了一个闭包。
3. 装饰器的基本实现

让我们通过一个简单的例子来说明装饰器的实现：

1. def simple_decorator(func):
2.     def wrapper():
3.         print("Something is happening before the function is called.")
4.         func()
5.         print("Something is happening after the function is called.")
6.     return wrapper
8. def say_hello():
9.     print("Hello!")
11. say_hello = simple_decorator(say_hello)

复制代码

在这个例子中：

• simple_decorator 是一个函数，它接受一个函数作为参数。
  
• 在 simple_decorator 内部，我们定义了一个新的函数 wrapper。
  
• wrapper 函数在调用原始函数前后添加了一些行为。
  
• simple_decorator 返回 wrapper 函数。
  
• 最后，我们用 simple_decorator 返回的新函数替换了原始的 say_hello 函数。
  

4. 语法糖

Python提供了一个语法糖（@符号）来简化装饰器的使用：

1. @simple_decorator
2. def say_hello():
3.     print("Hello!")

复制代码

这等同于前面的例子，但更加简洁和易读。
5. 带参数的装饰器

带参数的装饰器实际上是一个返回装饰器的函数：

1. def repeat(times):
2.     def decorator(func):
3.         def wrapper(*args, **kwargs):
4.             for _ in range(times):
5.                 result = func(*args, **kwargs)
6.             return result
7.         return wrapper
8.     return decorator
10. @repeat(3)
11. def say_hello(name):
12.     print(f"Hello, {name}!")

复制代码

这里，repeat 函数返回一个装饰器，该装饰器然后被应用到 say_hello 函数上。
6. 类装饰器

类装饰器利用了Python的 __call__ 方法，使得类的实例可以像函数一样被调用：

1. class CountCalls:
2.     def __init__(self, func):
3.         self.func = func
4.         self.num_calls = 0
5.    
6.     def __call__(self, *args, **kwargs):
7.         self.num_calls += 1
8.         return self.func(*args, **kwargs)
10. @CountCalls
11. def say_hello():
12.     print("Hello!")

复制代码

7. 装饰器的执行时机

重要的是要理解，装饰器在函数定义时就会执行，而不是在函数调用时。这意味着装饰器可以在模块导入时就改变函数的行为。
8. 多个装饰器

当多个装饰器应用到一个函数上时，它们的执行顺序是从下到上的：

1. @decorator1
2. @decorator2
3. def func():
4.     pass

复制代码

这等同于：

1. func = decorator1(decorator2(func))

复制代码

通过理解这些原理，我们可以看到装饰器如何利用Python的函数特性和语法来实现强大而灵活的代码修改和增强功能。
Python中变量在内存中的存储方式

Python的内存管理是一个复杂的主题，但了解它可以帮助我们写出更高效的代码。让我们逐步探讨Python中变量的存储方式。
1. 变量和对象的关系

在Python中，变量本质上是对对象的引用。当我们创建一个变量时，我们实际上是在内存中创建了一个对象，然后将变量名与该对象的内存地址关联起来。

1. x = 5

复制代码

在这个例子中，Python在内存中创建了一个整数对象5，然后将变量名x与这个对象的地址关联起来。
2. 对象的内存表示

Python中的每个对象至少包含三个部分：

• 类型标识符（告诉Python这个对象是什么类型）
  
• 引用计数（用于垃圾回收）
  
• 值
  

3. 不同类型对象的存储

小整数

Python对小整数（通常是-5到256）进行了优化。这些整数被预先创建并缓存，所有对这些值的引用都指向同一个对象。

1. a = 5
2. b = 5
3. print(a is b)  # 输出：True

复制代码

大整数

对于大整数，每次赋值都会创建一个新的对象。

1. a = 1000
2. b = 1000
3. print(a is b)  # 输出：False

复制代码

字符串

Python也对字符串进行了优化。相同内容的字符串通常会指向同一个对象（这被称为字符串驻留）。

1. a = "hello"
2. b = "hello"
3. print(a is b)  # 输出：True

复制代码

可变对象（如列表）

可变对象每次创建时都会在内存中分配新的空间。

1. a = [1, 2, 3]
2. b = [1, 2, 3]
3. print(a is b)  # 输出：False

复制代码

4. 变量赋值

当我们进行变量赋值时，我们实际上是改变变量引用的对象。

1. x = 5  # x 引用整数对象 5
2. x = 10  # x 现在引用整数对象 10，而不是修改原来的 5

复制代码

5. 引用计数和垃圾回收

Python使用引用计数来进行内存管理。每个对象都有一个引用计数，表示有多少个变量引用了这个对象。当引用计数降为0时，对象就会被垃圾回收器回收。

1. x = 5  # 创建整数对象 5，引用计数为 1
2. y = x  # y 也引用同一个对象，引用计数增加到 2
3. del x  # 删除 x，引用计数减少到 1
4. # y 仍然引用这个对象

复制代码

6. 内存视图

我们可以使用id()函数来查看对象的内存地址：

1. x = 5
2. print(id(x))  # 输出对象的内存地址

复制代码

7. 可变对象vs不可变对象

• 不可变对象（如整数、字符串、元组）：当这些对象的"值"改变时，实际上是创建了一个新对象。
  
• 可变对象（如列表、字典）：这些对象可以在原地修改，不需要创建新对象。
  

1. # 不可变对象
2. x = 5
3. print(id(x))
4. x += 1
5. print(id(x))  # 地址会改变
7. # 可变对象
8. lst = [1, 2, 3]
9. print(id(lst))
10. lst.append(4)
11. print(id(lst))  # 地址不会改变

复制代码

理解Python的内存管理和变量存储方式可以帮助我们写出更高效的代码，并避免一些常见的陷阱。

来源:https://www.cnblogs.com/TsayDust/p/18287433
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！