Python的基本数据类型
Python3 中有六个标准的数据类型：
- Number（数字）(包括整型、浮点型、复数、布尔型等)
- String（字符串）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
Python3 的六个标准数据类型中：
- 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
- 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
什么是自省
自省是运行时判断一个对象类型的能力。
python一切皆对象，用type, id, isinstance获取对象类型信息。
自省，也可以说是反射，自省在计算机编程中通常指这种能力：检查某些事物以确定它是什么、它知道什么以及它能做什么。
与其相关的主要方法:
- hasattr(object, name)检查对象是否具体 name 属性。返回 bool.
- getattr(object, name, default)获取对象的name属性。
- setattr(object, name, default)给对象设置name属性
- delattr(object, name)给对象删除name属性
- dir([object])获取对象大部分的属性
- isinstance(name, object)检查name是不是object对象
- type(object)查看对象的类型
- callable(object)判断对象是否是可调用对象
python 传递参数
准确地说，Python 的参数传递是赋值传递 （pass by assignment），或者叫作对象的引用传递（pass by object reference）。Python 里所有的数据类型都是对象，所以参数传递时，只是让新变量与原变量指向相同的对象而已，并不存在值传递或是引用传递一说。
根据对象的引用来传递，根据对象是可变对象还是不可变对象，得到两种不同的结果。如果是可变对象，则直接修改。如果是不可变对象，则生产新对象，让形参指向新对象
def fstr(s):
print(id(s)) # 和入参ss的id相同
s += "a"
print(id(s)) # 和入参ss的id不同，每次打印结果不相同
print(s)
ss = "sun"
# print(id(ss))
fstr(ss) # suna
fstr(ss) # suna. 这段代码为什么不是输出suna. suanaa
详细解释
-
字符串的不可变性：
-
在 Python 中，字符串是不可变的（immutable）。这意味着一旦一个字符串被创建，它的内容就不能被修改。任何对字符串的修改操作（如
+=）都会创建一个新的字符串对象。 -
id函数： -
id函数返回对象的唯一标识符（通常是内存地址）。对于不可变对象（如字符串），每次修改都会创建一个新的对象，因此id也会不同。 -
代码执行过程：
-
第一次调用
fstr(ss)：s是"sun"的引用，id(s)与id(ss)相同。s += "a"创建了一个新的字符串"suna"，id(s)现在指向这个新字符串。- 打印
s，输出"suna"。
-
第二次调用
fstr(ss)：s仍然是"sun"的引用，id(s)与id(ss)相同。s += "a"再次创建了一个新的字符串"suna"，id(s)现在指向这个新字符串。- 打印
s，输出"suna"。
-
为什么不修改外部的
ss？ -
字符串的不可变性：由于字符串是不可变的，任何修改操作都会创建一个新的字符串对象，而不会修改原始字符串。
- 变量作用域：在函数内部，
s是一个局部变量。当s += "a"时，s被重新赋值为一个新的字符串对象，但这不会影响外部的ss。 - 参数传递：Python 的参数传递是按对象引用传递的，但对于不可变对象，重新赋值只会影响局部变量，而不会影响外部变量。
为什么不是 suna. suanaa？
- 每次调用
fstr(ss)时，s都是从ss（即"sun"）开始的。s += "a"只是在函数内部创建了一个新的字符串"suna"，但并没有修改外部的ss。 - 因此，每次调用
fstr(ss)都会输出"suna"，而不是在之前的结果上继续追加"a"。
def clear_list(l):
l = [] # 尝试将 l 指向一个新的空列表
ll = [1, 2, 3]
clear_list(ll)
print(ll) # 输出 [1, 2, 3]，而不是 []
详细解释
- Python 中的参数传递：
- Python 中的参数传递是按对象引用传递（pass-by-object-reference）。这意味着函数接收的是实际对象的引用（可以理解为指针），而不是对象的副本。
- 对于可变对象（如列表），如果在函数内部修改对象的内容（例如添加、删除元素），这些修改会反映到函数外部的对象上。
- 但是，如果在函数内部将一个参数重新赋值（例如
l = []），这只会让参数l指向一个新的对象，而不会影响函数外部的对象。 - 代码执行过程：
- 调用
clear_list(ll)时，l是ll的引用，即l和ll都指向同一个列表[1, 2, 3]。 - 在函数内部，执行
l = []时，l被重新赋值为一个新的空列表[]，但ll仍然指向原来的列表[1, 2, 3]。 - 因此，函数外部的
ll并没有被修改，仍然是[1, 2, 3]。
为什么结果是 [1, 2, 3] 而不是 []？
- 在函数内部，
l = []只是让局部变量l指向一个新的空列表，而不会影响外部的ll。 - 如果想要修改外部的列表，需要直接操作列表的内容，而不是重新赋值。
如何正确清空列表？
如果你希望清空外部的列表 ll，可以通过以下方式实现：
方法 1：直接修改列表内容
使用 clear() 方法清空列表内容：
python
复制
def clear_list(l):
l.clear() # 清空列表内容
ll = [1, 2, 3]
clear_list(ll)
print(ll) # 输出 []
方法 2：使用切片赋值
通过切片赋值清空列表内容：
python
复制
def clear_list(l):
l[:] = [] # 清空列表内容
ll = [1, 2, 3]
clear_list(ll)
print(ll) # 输出 []
方法 3：直接修改外部变量
如果你希望函数返回一个新的空列表，可以这样做：
python
复制
def clear_list(l):
return [] # 返回一个新的空列表
ll = [1, 2, 3]
ll = clear_list(ll) # 将 ll 指向新的空列表
print(ll) # 输出 []
总结
- 在 Python 中，函数参数是按对象引用传递的。
- 如果参数是可变对象（如列表），可以通过修改对象内容来影响外部变量。
- 如果是不可变，如str ，如果进行了修改，+= or replace,会创建一个新的对象，在一个函数内部进行修改，则不会影响外部的变量，
- 但如果对参数重新赋值（如
l = []），只会影响局部变量，而不会影响外部变量。 - 要清空外部列表，可以使用
clear()方法或切片赋值（l[:] = []）。
Python中的 *args 和 **kwargs
用来处理可变参数，*args被打包成tuple，**kwargs被打包成dict
我们看一些代码例子：
def print_multiple_args(*args):
print(type(args), args)
for idx, val in enumerate(args): # enumerate()枚举函数
print(idx, val)
print_multiple_args('a', 'b', 'c')
# 通过将列表前加*打包成关键字参数，指明了接收值参数必须是*args
print_multiple_args(*['a', 'b', 'c'])
def print_kwargs(**kwargs):
print(type(kwargs), kwargs)
for k, v in kwargs.items():
print('{}: {}'.format(k, v))
print_kwargs(a=1, b=2)
# 给字典前加**打包成关键字参数,指明接收值的参数必须是**kwargs
print_kwargs(**dict(a=1, b=2))
def print_all(a, *args, **kwargs):
print(a)
if args:
print(args)
if kwargs:
print(kwargs)
print_all('hello', 'world', name='monki')
python 异常
1. 异常的基本概念
- 异常（Exception）：程序在运行过程中发生的错误或意外情况。例如，除以零、访问不存在的文件、类型错误等。
- 异常处理：通过捕获和处理异常，程序可以在出现错误时继续执行，而不是直接崩溃。
2. 异常处理的语法
Python 使用 try、except、else 和 finally 关键字来处理异常。
基本语法：
try:
# 可能引发异常的代码
result = 10 / 0
except ZeroDivisionError:
# 捕获特定异常并处理
print("不能除以零！")
else:
# 如果没有异常发生，执行此代码块
print("计算结果：", result)
finally:
# 无论是否发生异常，都会执行此代码块
print("执行完毕")
try块：包含可能引发异常的代码。except块：捕获并处理特定类型的异常。else块：当try块中的代码没有引发异常时执行。finally块：无论是否发生异常，都会执行的代码块，通常用于释放资源（如关闭文件）。
3. 常见的异常类型
Python 内置了许多异常类型，以下是一些常见的异常：
| 异常类型 | 描述 |
|---|---|
ZeroDivisionError |
除以零错误 |
TypeError |
类型错误（如对字符串和整数进行加法运算） |
ValueError |
值错误（如将非数字字符串转换为整数） |
IndexError |
索引超出范围 |
KeyError |
字典中不存在的键 |
FileNotFoundError |
文件未找到 |
AttributeError |
访问不存在的属性 |
ImportError |
导入模块失败 |
NameError |
访问未定义的变量 |
SyntaxError |
语法错误 |
4. 捕获多个异常
可以使用多个 except 块来捕获不同类型的异常，或者在一个 except 块中捕获多个异常。
示例：
try:
num = int(input("请输入一个整数："))
result = 10 / num
print("结果是：", result)
except ValueError:
print("输入的不是整数！")
except ZeroDivisionError:
print("不能除以零！")
except Exception as e:
print("发生了未知错误：", e)
5. 捕获所有异常
可以使用 except Exception 捕获所有异常，但通常不推荐这样做，因为它会隐藏潜在的错误。
示例：
try:
risky_code()
except Exception as e:
print("发生了错误：", e)
6. 自定义异常
Python 允许通过继承 Exception 类来创建自定义异常。
示例：
class MyCustomError(Exception):
def __init__(self, message):
self.message = message
super().__init__(self.message)
try:
raise MyCustomError("这是一个自定义异常！")
except MyCustomError as e:
print(e)
7. 抛出异常
使用 raise 关键字可以手动抛出异常。
示例：
def divide(a, b):
if b == 0:
raise ZeroDivisionError("除数不能为零！")
return a / b
try:
result = divide(10, 0)
except ZeroDivisionError as e:
print(e)
8. 异常链
在捕获异常后，可以使用 raise 将异常重新抛出，或者抛出一个新的异常并保留原始异常的上下文。
示例：
try:
risky_code()
except ValueError as e:
raise RuntimeError("处理值时出错") from e
9. 最佳实践
- 明确捕获异常：尽量捕获具体的异常类型，而不是捕获所有异常。
- 避免空的
except块：空的except块会隐藏错误，导致调试困难。 - 使用
finally释放资源：确保在finally块中释放资源（如关闭文件、数据库连接等）。 - 记录异常信息：使用日志记录异常信息，便于调试和分析。
- 自定义异常：在复杂的项目中，使用自定义异常可以提高代码的可读性和可维护性。
10. 面试常见问题
以下是一些关于 Python 异常机制的常见面试问题：
try、except、else和finally的执行顺序是什么？- 先执行
try块，如果发生异常则执行except块，否则执行else块，最后无论是否发生异常都会执行finally块。 - 如何捕获多个异常？
- 可以使用多个
except块，或者在一个except块中用元组列出多个异常类型。 - 如何自定义异常？
- 通过继承
Exception类来创建自定义异常。 finally块的作用是什么？finally块用于执行无论是否发生异常都必须执行的代码，通常用于释放资源。- 如何手动抛出异常？
- 使用
raise关键字手动抛出异常。 - 捕获所有异常有什么风险？
- 捕获所有异常可能会隐藏潜在的错误，导致调试困难。
python 的类中的以__开头的函数的具体作用是什么
在 Python 中，以双下划线 __ 开头和结尾的函数（如 __init__、__str__ 等）被称为魔法方法（Magic Methods）或特殊方法（Special Methods）。这些方法是 Python 类的核心特性之一，用于定义类的行为，例如初始化对象、字符串表示、运算符重载等。
下面我们将详细讲解这些魔法方法的作用、常见用法以及实际应用场景。
1. 魔法方法的作用
魔法方法的主要作用是让开发者能够自定义类的行为。Python 解释器会在特定的场景下自动调用这些方法，例如：
- 创建对象时调用
__init__。 - 打印对象时调用
__str__。 - 使用运算符时调用
__add__、__eq__等。
2. 常见的魔法方法
以下是一些常用的魔法方法及其作用：
1. __init__
-
作用：构造函数，用于初始化对象。
-
调用时机：在创建对象时自动调用。
-
示例：
```python class MyClass: def init(self, value): self.value = value
obj = MyClass(10) print(obj.value) # 输出 10 ```
2. __str__
-
作用：定义对象的字符串表示形式。
-
调用时机：当使用
print()或str()时调用。 -
示例：
```python class MyClass: def str(self): return "MyClass object"
obj = MyClass() print(obj) # 输出 "MyClass object" ```
3. __repr__
-
作用：定义对象的官方字符串表示形式，通常用于调试。
-
调用时机：当使用
repr()或在交互式环境中直接输入对象时调用。 -
示例：
```python class MyClass: def repr(self): return "MyClass()"
obj = MyClass() print(repr(obj)) # 输出 "MyClass()" ```
4. __len__
-
作用：定义对象的长度。
-
调用时机：当使用
len()时调用。 -
示例：
```python class MyList: def init(self, data): self.data = data
def __len__(self):
return len(self.data)
my_list = MyList([1, 2, 3]) print(len(my_list)) # 输出 3 ```
5. __getitem__
-
作用：定义通过索引访问对象元素的行为。
-
调用时机：当使用
obj[index]时调用。 -
示例：
```python class MyList: def init(self, data): self.data = data
def __getitem__(self, index):
return self.data[index]
my_list = MyList([1, 2, 3]) print(my_list[1]) # 输出 2 ```
6. __setitem__
-
作用：定义通过索引设置对象元素的行为。
-
调用时机：当使用
obj[index] = value时调用。 -
示例：
```python class MyList: def init(self, data): self.data = data
def __setitem__(self, index, value):
self.data[index] = value
my_list = MyList([1, 2, 3]) my_list[1] = 10 print(my_list[1]) # 输出 10 ```
7. __add__
-
作用：定义加法运算的行为。
-
调用时机：当使用
+运算符时调用。 -
示例：
```python class Point: def init(self, x, y): self.x = x self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
p1 = Point(1, 2) p2 = Point(3, 4) p3 = p1 + p2 print(p3.x, p3.y) # 输出 4, 6 ```
8. __eq__
-
作用：定义相等性比较的行为。
-
调用时机：当使用
==运算符时调用。 -
示例：
```python class Point: def init(self, x, y): self.x = x self.y = y
def __eq__(self, other):
return self.x == other.x and self.y == other.y
p1 = Point(1, 2) p2 = Point(1, 2) print(p1 == p2) # 输出 True ```
9. __call__
-
作用：使对象可以像函数一样被调用。
-
调用时机：当使用
obj()时调用。 -
示例：
```python class Adder: def call(self, a, b): return a + b
adder = Adder() print(adder(1, 2)) # 输出 3 ```
10. __enter__ 和 __exit__
-
作用：定义上下文管理器的行为，通常用于
with语句。 -
调用时机：进入和退出
with块时调用。 -
示例：
```python class MyContextManager: def enter(self): print("进入上下文") return self
def __exit__(self, exc_type, exc_value, traceback):
print("退出上下文")
with MyContextManager() as cm: print("在上下文中") ```
3. 实际应用场景
- 自定义数据结构：通过实现
__getitem__、__setitem__等方法，可以创建类似列表或字典的自定义数据结构。 - 运算符重载：通过实现
__add__、__eq__等方法，可以定义对象之间的运算行为。 - 上下文管理：通过实现
__enter__和__exit__，可以创建资源管理类（如文件操作、数据库连接等）。 - 对象表示：通过实现
__str__和__repr__，可以定义对象的字符串表示形式，便于调试和日志记录。
4. 面试常见问题
__init__和__new__的区别是什么？__new__用于创建对象，__init__用于初始化对象。- 如何使对象支持
for循环？ - 实现
__iter__()和__next__()方法。 - 如何使对象支持
with语句？ - 实现
__enter__()和__exit__()方法。 __str__和__repr__的区别是什么？__str__用于用户友好的字符串表示，__repr__用于开发者调试。- 如何使对象支持加法运算？
- 实现
__add__()方法。
python中的闭包
闭包（Closure） 是 Python 中一个非常重要的概念，它结合了函数和其相关的引用环境（即函数定义时的作用域）。闭包允许函数访问其定义时的作用域中的变量，即使函数在其定义的作用域之外执行。
闭包的核心思想是：函数可以“记住”它定义时的环境。这种特性使得闭包在 Python 中非常强大，常用于实现装饰器、回调函数、函数工厂等高级功能。
1. 闭包的定义
闭包是一个函数对象，它满足以下两个条件：
- 函数嵌套：闭包是一个嵌套函数（即函数内部定义了另一个函数）。
- 引用外部变量：内部函数引用了外部函数的变量（即自由变量）。
闭包的关键在于，即使外部函数已经执行完毕，内部函数仍然可以访问外部函数的变量。
2. 闭包的示例
以下是一个简单的闭包示例：
def outer_function(x): # 外部函数
def inner_function(y): # 内部函数
return x + y # 内部函数引用了外部函数的变量 x
return inner_function # 返回内部函数
closure = outer_function(10) # 调用外部函数，返回内部函数
print(closure(5)) # 调用内部函数，输出 15
解释：
outer_function是外部函数，它接受一个参数x。inner_function是内部函数，它引用了外部函数的变量x。- 当
outer_function(10)被调用时，它返回了inner_function，并且inner_function记住了x = 10。 - 调用
closure(5)时，inner_function使用x = 10和y = 5计算结果15。
3. 闭包的工作原理
闭包的核心在于 自由变量 和 作用域链：
- 自由变量：在内部函数中引用但未在内部函数中定义的变量（如
x）。 - 作用域链：Python 会通过作用域链查找自由变量的值。即使外部函数已经执行完毕，内部函数仍然可以通过作用域链访问外部函数的变量。
示例：
def outer():
x = 10 # 外部函数的局部变量
def inner():
print(x) # 内部函数引用了外部函数的变量 x
return inner
closure = outer() # 调用外部函数，返回内部函数
closure() # 调用内部函数，输出 10
- 即使
outer()已经执行完毕，inner()仍然可以访问x，因为x被闭包“记住”了。
4. 闭包的实际应用
闭包在 Python 中有很多实际应用场景，以下是几个常见的例子：
1. 函数工厂
闭包可以用于创建动态函数。例如，创建一个根据参数生成不同功能的函数：
def power_function(exponent):
def inner(base):
return base ** exponent
return inner
square = power_function(2) # 创建一个计算平方的函数
cube = power_function(3) # 创建一个计算立方的函数
print(square(4)) # 输出 16
print(cube(4)) # 输出 64
2. 装饰器
装饰器是闭包的一个典型应用。装饰器本质上是一个函数，它接受一个函数作为参数，并返回一个新的函数。
def decorator(func):
def wrapper(*args, **kwargs):
print("函数执行前")
result = func(*args, **kwargs)
print("函数执行后")
return result
return wrapper
@decorator
def say_hello(name):
print(f"Hello, {name}!")
say_hello("Alice")
回调函数
闭包可以用于实现回调函数。例如，在事件驱动编程中，闭包可以记住事件触发时的上下文。
def on_button_click(message):
def callback():
print(message)
return callback
click_handler = on_button_click("按钮被点击了！")
click_handler() # 输出 "按钮被点击了！"
4. 数据隐藏
闭包可以用于隐藏数据，避免直接暴露给外部。
```python def counter(): count = 0 def increment(): nonlocal count count += 1 return count return increment
counter1 = counter() print(counter1()) # 输出 1 print(counter1()) # 输出 2
1. \**变量作用域**：
- 如果内部函数需要修改外部函数的变量，必须使用 `nonlocal` 关键字。
- 示例：
```python
def outer():
x = 10
def inner():
nonlocal x
x += 1
print(x)
return inner
closure = outer()
closure() # 输出 11
```
2. **内存消耗**：
- 闭包会保留外部函数的变量，因此可能会增加内存消耗。
- 如果闭包不再需要，应及时释放。
3. **循环中的闭包**：
- 在循环中创建闭包时，需要注意变量的绑定问题。
- 示例：
```python
def create_closures():
closures = []
for i in range(3):
def inner():
print(i)
closures.append(inner)
return closures
closures = create_closures()
for closure in closures:
closure() # 输出 2, 2, 2
```
- 解决方法：使用默认参数绑定变量。
```python
def create_closures():
closures = []
for i in range(3):
def inner(i=i): # 使用默认参数绑定变量
print(i)
closures.append(inner)
return closures
closures = create_closures()
for closure in closures:
closure() # 输出 0, 1, 2
```
#### 6. 面试常见问题
1. **什么是闭包？**
- 闭包是一个函数对象，它引用了外部函数的变量，并且可以在外部函数执行完毕后继续访问这些变量。
2. **闭包的作用是什么？**
- 闭包可以用于实现函数工厂、装饰器、回调函数等功能。
3. **如何判断一个函数是否是闭包？**
- 使用 `__closure__` 属性。如果函数是闭包，则 `__closure__` 是一个包含自由变量的元组。
- 示例：
```python
def outer():
x = 10
def inner():
print(x)
return inner
closure = outer()
print(closure.__closure__) # 输出 (<cell at 0x...: int object at 0x...>,)
```
4. **闭包和普通函数有什么区别？**
- 闭包可以访问其定义时的作用域中的变量，而普通函数只能访问其局部变量和全局变量。
### 类变量，实例变量，类方法，普通方法，静态方法的使用
在 Python 中，**类变量**、**实例变量**、**类方法**、**普通方法** 和 **静态方法** 是面向对象编程的核心概念。它们分别用于不同的场景，理解它们的区别和使用方法对于编写高质量的 Python 代码非常重要。
下面我们将详细讲解这些概念的定义、区别以及使用场景。
#### 1. 类变量（Class Variable）
- **定义**：类变量是属于类本身的变量，而不是类的实例。所有实例共享同一个类变量。
- **使用场景**：用于存储类的全局状态或共享数据。
- **定义方式**：在类中直接定义，通常放在类的顶部。
- **访问方式**：可以通过类名或实例访问。
#### 示例：
```python
class MyClass:
class_var = 10 # 类变量
print(MyClass.class_var) # 通过类名访问，输出 10
obj1 = MyClass()
obj2 = MyClass()
print(obj1.class_var) # 通过实例访问，输出 10
print(obj2.class_var) # 通过实例访问，输出 10
# 修改类变量
MyClass.class_var = 20
print(obj1.class_var) # 输出 20
print(obj2.class_var) # 输出 20
2. 实例变量（Instance Variable）
- 定义：实例变量是属于类的实例的变量，每个实例都有自己独立的实例变量。
- 使用场景：用于存储实例的特定状态或数据。
- 定义方式：通常在
__init__方法中定义。 - 访问方式：只能通过实例访问。
示例：
class MyClass:
def __init__(self, value):
self.instance_var = value # 实例变量
obj1 = MyClass(10)
obj2 = MyClass(20)
print(obj1.instance_var) # 输出 10
print(obj2.instance_var) # 输出 20
# 修改实例变量
obj1.instance_var = 30
print(obj1.instance_var) # 输出 30
print(obj2.instance_var) # 输出 20
3. 普通方法（Instance Method）
- 定义：普通方法是类的实例方法，必须通过实例调用。它的第一个参数是
self，表示当前实例。 - 使用场景：用于操作实例变量或实例状态。
- 定义方式：在类中定义，第一个参数为
self。
示例：
class MyClass:
def __init__(self, value):
self.instance_var = value
def instance_method(self): # 普通方法
return self.instance_var
obj = MyClass(10)
print(obj.instance_method()) # 输出 10
4. 类方法（Class Method）
- 定义：类方法是属于类的方法，而不是实例。它的第一个参数是
cls，表示当前类。 - 使用场景：用于操作类变量或执行与类相关的操作。
- 定义方式：使用
@classmethod装饰器定义，第一个参数为cls。
示例：
class MyClass:
class_var = 10
@classmethod
def class_method(cls): # 类方法
return cls.class_var
print(MyClass.class_method()) # 输出 10
5. 静态方法（Static Method）
- 定义：静态方法与类和实例无关，它只是一个普通的函数，但定义在类的命名空间中。
- 使用场景：用于实现与类相关但不需要访问类或实例状态的工具函数。
- 定义方式：使用
@staticmethod装饰器定义，没有self或cls参数。
示例：
class MyClass:
@staticmethod
def static_method(): # 静态方法
return "This is a static method."
print(MyClass.static_method()) # 输出 "This is a static method."
6. 对比总结
| 特性 | 类变量 | 实例变量 | 普通方法 | 类方法 | 静态方法 |
|---|---|---|---|---|---|
| 定义位置 | 类中直接定义 | __init__ 方法中定义 |
类中定义 | 类中定义，使用 @classmethod |
类中定义，使用 @staticmethod |
| 访问方式 | 类名或实例访问 | 实例访问 | 实例访问 | 类名或实例访问 | 类名或实例访问 |
| 参数 | 无 | 无 | self（当前实例） |
cls（当前类） |
无 |
| 使用场景 | 存储类的全局状态或共享数据 | 存储实例的特定状态或数据 | 操作实例变量或实例状态 | 操作类变量或执行类相关操作 | 实现与类相关的工具函数 |
7. 综合示例
以下是一个综合示例，展示了类变量、实例变量、普通方法、类方法和静态方法的使用：
class MyClass:
class_var = 0 # 类变量
def __init__(self, value):
self.instance_var = value # 实例变量
def instance_method(self): # 普通方法
return f"Instance method: {self.instance_var}"
@classmethod
def class_method(cls): # 类方法
return f"Class method: {cls.class_var}"
@staticmethod
def static_method(): # 静态方法
return "Static method: This is a utility function."
# 使用类变量
print(MyClass.class_var) # 输出 0
# 创建实例
obj1 = MyClass(10)
obj2 = MyClass(20)
# 使用实例变量
print(obj1.instance_var) # 输出 10
print(obj2.instance_var) # 输出 20
# 使用普通方法
print(obj1.instance_method()) # 输出 "Instance method: 10"
# 使用类方法
print(MyClass.class_method()) # 输出 "Class method: 0"
# 使用静态方法
print(MyClass.static_method()) # 输出 "Static method: This is a utility function."
8. 面试常见问题
- 类变量和实例变量的区别是什么？
- 类变量属于类，所有实例共享；实例变量属于实例，每个实例独立。
- 普通方法和类方法的区别是什么？
- 普通方法操作实例变量，第一个参数是
self；类方法操作类变量，第一个参数是cls。 - 静态方法和类方法的区别是什么？
- 静态方法与类和实例无关，没有
self或cls参数；类方法操作类变量，第一个参数是cls。 - 什么时候使用静态方法？
- 当方法不需要访问类或实例状态时，可以使用静态方法。
- 如何修改类变量？
- 通过类名或实例访问并修改类变量。
9. 总结
- 类变量：用于存储类的全局状态，所有实例共享。
- 实例变量：用于存储实例的特定状态，每个实例独立。
- 普通方法：用于操作实例变量，第一个参数是
self。 - 类方法：用于操作类变量，第一个参数是
cls。 - 静态方法：用于实现与类相关的工具函数，不需要访问类或实例状态。
