如何使用特殊方法
模拟数值类型
在 Python 中,complex 类用于表示和操作复数。复数由实部和虚部组成,形式为 a + bj,其中 a 是实部,b 是虚部,j(或 J)表示虚数单位(即 √-1)。
python
z1 = 3 + 4j
z2 = 2.5 - 1.2j
python
z3 = complex(3, 4) # 等价于 3 + 4j
z4 = complex(2.5) # 虚部默认为 0,等价于 2.5 + 0j
z5 = complex("3+4j") # 从字符串解析复数
complex 类提供了两个属性来获取复数的实部和虚部: real:返回复数的实部 imag:返回复数的虚部
python
z = 3 + 4j
print(z.real) # 输出:3.0(注意返回的是浮点数)
print(z.imag) # 输出:4.0
conjugate():返回复数的共轭复数(将虚部的符号取反)
python
z = 3 + 4j
print(z.conjugate()) # 输出:(3-4j)
abs():返回复数的模(即到原点的距离,计算为 √(a² + b²))
python
print(abs(3 + 4j)) # 输出:5.0
cmath 模块:提供了更多复数相关的数学函数(如三角函数、对数函数等),与处理实数的 math 模块对应
python
import cmath
print(cmath.sqrt(-1)) # 输出:1j(与 math.sqrt(-1) 不同,后者会报错)
print(cmath.sin(3 + 4j)) # 计算复数的正弦值
一个简单二维向量类:
python
from math import hypot
class Vector:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
def __repr__(self):
return 'Vector(%g, %g)' % (self.x, self.y)
def __abs__(self):
return hypot(self.x, self.y)
def __bool__(self):
return bool(abs(self))
def __add__(self, other):
x = self.x + other.x
y = self.y + other.y
return Vector(x, y)
def __mul__(self, scalar):
return Vector(self.x * scalar, self.y * scalar
)
从 Python 内置的 math
模块中导入 hypot
函数,该函数用于计算直角三角形的斜边长度(即 √(x² + y²))。
2.** 类定义与初始化方法 **```python class Vector: def init (self, x=0, y=0): self.x = x self.y = y init 方法是构造函数,用于初始化向量的 x 和 y 分量,默认值都是 0
__repr__
是特殊方法,用于返回对象的字符串表示形式- 当打印向量对象或在交互环境中显示时,会以
Vector(x, y)
的形式展示,例如Vector(3, 4)
4.** 向量模长计算 **```python def abs(self): return hypot(self.x, self.y)
- 这是一个笔误,正确的方法名应该是
__bool__
__bool__
方法定义了对象在布尔上下文中的行为(如if
判断)- 当向量的模长为 0 时(即
abs(self) == 0
),返回False
;否则返回True
6.** 向量加法 **```python def add(self, other): x = self.x + other.x y = self.y + other.y return Vector(x, y)
__mul__
是特殊方法,用于实现*
运算符- 实现了向量与标量(数字)的乘法:将向量的每个分量乘以标量,返回一个新的
Vector
对象 - 例如
v * 3
会返回Vector(v.x*3, v.y*3)
使用示例:
python
v1 = Vector(2, 4)
v2 = Vector(3, 1)
print(v1 + v2) # 输出: Vector(5, 5)
print(v1 * 2) # 输出: Vector(4, 8)
print(abs(v1)) # 输出: 4.472135955... (即 √(2²+4²))
print(bool(v1)) # 输出: True (因为模长不为0)
不使用类的方法也能实现类似的向量功能,我们可以通过函数来操作表示向量的数据结构(如元组或列表)。以下是使用函数式编程实现与上述 Vector 类相同功能的示例:
python
from math import hypot
# 创建向量
def vector(x=0, y=0):
return (x, y)
# 向量的字符串表示
def vector_repr(v):
return f"Vector({v[0]}, {v[1]})"
# 计算向量模长
def vector_abs(v):
return hypot(v[0], v[1])
# 判断向量是否非零
def vector_bool(v):
return bool(vector_abs(v))
# 向量加法
def vector_add(v1, v2):
return (v1[0] + v2[0], v1[1] + v2[1])
# 向量与标量乘法
def vector_mul(v, scalar):
return (v[0] * scalar, v[1] * scalar)
# 使用示例
v1 = vector(2, 4)
v2 = vector(3, 1)
print(vector_repr(v1)) # 输出: Vector(2, 4)
print(vector_repr(vector_add(v1, v2))) # 输出: Vector(5, 5)
print(vector_repr(vector_mul(v1, 2))) # 输出: Vector(4, 8)
print(vector_abs(v1)) # 输出: 4.472135955...
print(vector_bool(v1)) # 输出: True
两种方式的对比: 类方法的优势: 封装性更好,将数据(向量的 x、y 分量)和操作(加法、乘法等)捆绑在一起 可以使用直观的运算符(+、*、abs()),代码更简洁易读 便于扩展更多功能,维护性更强 函数式方法的优势: 实现简单直接,不需要理解类和特殊方法的概念 适合简单场景,代码量可能更少 更灵活,不需要遵循类的结构约束
字符串表现形式
repr() 是 Python 的内置函数,用于返回对象的字符串表示形式,主要用途是为开发者提供一个清晰、准确的对象描述,便于调试和理解对象的状态。
python
x = 123
print(repr(x)) # 输出: '123'
s = "hello"
print(repr(s)) # 输出: "'hello'" (包含引号,明确表示这是字符串)
lst = [1, 2, 3]
print(repr(lst)) # 输出: '[1, 2, 3]'
核心特点 面向开发者:返回的字符串通常包含对象的类型和关键信息,便于调试时识别对象。 尽可能精确:理想情况下,repr(obj) 的结果应该是一段可以直接执行的 Python 代码,执行后能重建出与原对象相似的实例。
python
# 示例:通过 repr 结果重建列表
lst = [1, 2, 3]
lst_str = repr(lst) # 得到 '[1, 2, 3]'
new_lst = eval(lst_str) # 执行字符串,重建列表
print(new_lst == lst) # 输出: True
与 str() 的区别: str(obj) 用于返回用户友好的字符串表示(侧重可读性) repr(obj) 用于返回开发者友好的字符串表示(侧重精确性)
python
from datetime import datetime
dt = datetime(2023, 10, 1)
print(str(dt)) # 输出: '2023-10-01 00:00:00' (用户易读)
print(repr(dt)) # 输出: 'datetime.datetime(2023, 10, 1, 0, 0)' (可用于重建对象)
内容由 AI 生成 clickable Avatar: undefined 讲解一下python的complex类 在 Python 中,complex 类用于表示和操作复数。复数由实部和虚部组成,形式为 a + bj,其中 a 是实部,b 是虚部,j(或 J)表示虚数单位(即 √-1)。
- 创建复数 可以通过以下几种方式创建复数: 直接使用复数字面量: python 运行 z1 = 3 + 4j z2 = 2.5 - 1.2j 使用 complex() 构造函数: python 运行 z3 = complex(3, 4) # 等价于 3 + 4j z4 = complex(2.5) # 虚部默认为 0,等价于 2.5 + 0j z5 = complex("3+4j") # 从字符串解析复数
- 复数的属性 complex 类提供了两个属性来获取复数的实部和虚部: real:返回复数的实部 imag:返回复数的虚部 python 运行 z = 3 + 4j print(z.real) # 输出:3.0(注意返回的是浮点数) print(z.imag) # 输出:4.0
- 复数的方法 complex 类主要有一个常用方法: conjugate():返回复数的共轭复数(将虚部的符号取反) python 运行 z = 3 + 4j print(z.conjugate()) # 输出:(3-4j)
- 复数的运算 Python 支持复数的各种基本运算: 加法:z1 + z2 减法:z1 - z2 乘法:z1 * z2 除法:z1 / z2 幂运算:z1 **z2 python 运行 z1 = 3 + 4j z2 = 1 + 2j
print(z1 + z2) # (4+6j) print(z1 * z2) # (31 - 4 2) + (41 + 32)j = (-5+10j) 5. 与复数相关的内置函数 abs():返回复数的模(即到原点的距离,计算为 √(a² + b²)) python 运行 print(abs(3 + 4j)) # 输出:5.0 cmath 模块:提供了更多复数相关的数学函数(如三角函数、对数函数等),与处理实数的 math 模块对应 python 运行 import cmath print(cmath.sqrt(-1)) # 输出:1j(与 math.sqrt(-1) 不同,后者会报错) print(cmath.sin(3 + 4j)) # 计算复数的正弦值 注意事项 复数不能参与位运算(如 &、|、<< 等) 复数不能用于 round()、int()、float() 等类型转换(除非虚部为 0,可通过 z.real 转换实部) 比较运算(==、!=)可以用于复数,但大小比较(>、< 等)不支持 通过 complex 类,Python 提供了对复数的完整支持,使其在科学计算、工程领域等需要处理复数的场景中非常方便。 math模块是内置的吗 是的,math 是 Python 的内置模块(标准库模块),不需要额外安装即可使用。 只需在代码中通过 import math 语句导入后,就可以使用其提供的数学函数,例如: python 运行 import math
print(math.pi) # 圆周率 π print(math.sqrt(2)) # 计算平方根 print(math.sin(math.pi/2)) # 计算正弦值 math 模块主要提供对实数的基本数学运算支持,包括三角函数、指数对数、取整函数等。如果需要处理复数相关的数学运算,则需要使用同样是内置模块的 cmath。 这些模块属于 Python 标准库的一部分,只要安装了 Python 环境,就可以直接使用,无需通过 pip 等工具额外安装。 解释代码 from math import hypot class Vector: def init(self, x=0, y=0): self.x = x self.y = y
python
def __repr__(self):
return 'Vector(%g, %g)' % (self.x, self.y)
def __abs__(self):
return hypot(self.x, self.y)
def __boof__(self):
return bool(abs(self))
def __add__(self, other):
x = self.x + other.x
y = self.y + other.y
return Vector(x, y)
def __mul__(self, scalar):
return Vector(self.x * scalar, self.y * scalar
) 这段代码定义了一个 Vector 类,用于表示二维向量并实现了一些基本操作。让我们逐部分解释: 1.** 导入函数 **```pythonfrom math import hypot plaintext 从 Python 内置的 math
模块中导入 hypot
函数,该函数用于计算直角三角形的斜边长度(即 √(x² + y²))。
2.** 类定义与初始化方法 **python class Vector: def __init__(self, x=0, y=0): self.x = x self.y = y 定义了 Vector 类,表示二维向量(有 x 和 y 两个分量) __init__ 方法是构造函数,用于初始化向量的 x 和 y 分量,默认值都是 0 3.** 字符串表示方法 **
pythondef repr(self):return 'Vector(%g, %g)' % (self.x, self.y) plaintext
__repr__
是特殊方法,用于返回对象的字符串表示形式- 当打印向量对象或在交互环境中显示时,会以
Vector(x, y)
的形式展示,例如Vector(3, 4)
4.** 向量模长计算 **python def __abs__(self): return hypot(self.x, self.y) __abs__ 是特殊方法,当使用 abs() 函数时会被调用 用于计算向量的模长(即向量的长度),通过 hypot(self.x, self.y) 实现,等价于 √(x² + y²) 5.** 布尔值判断(注意代码中有笔误)**
pythondef boof(self): # 这里应该是 bool 而不是 boofreturn bool(abs(self)) plaintext
- 这是一个笔误,正确的方法名应该是
__bool__
__bool__
方法定义了对象在布尔上下文中的行为(如if
判断)- 当向量的模长为 0 时(即
abs(self) == 0
),返回False
;否则返回True
6.** 向量加法 **python def __add__(self, other): x = self.x + other.x y = self.y + other.y return Vector(x, y) __add__ 是特殊方法,用于实现 + 运算符 实现了两个向量的加法:将对应分量相加,返回一个新的 Vector 对象 例如 v1 + v2 会调用此方法,返回一个新向量 Vector(v1.x+v2.x, v1.y+v2.y) 7.** 向量与标量乘法 **
pythondef mul(self, scalar):return Vector(self.x * scalar, self.y * scalar) plaintext
__mul__
是特殊方法,用于实现*
运算符- 实现了向量与标量(数字)的乘法:将向量的每个分量乘以标量,返回一个新的
Vector
对象 - 例如
v * 3
会返回Vector(v.x*3, v.y*3)
使用示例:
python
v1 = Vector(2, 4)
v2 = Vector(3, 1)
print(v1 + v2) # 输出: Vector(5, 5)
print(v1 * 2) # 输出: Vector(4, 8)
print(abs(v1)) # 输出: 4.472135955... (即 √(2²+4²))
print(bool(v1)) # 输出: True (因为模长不为0)
这段代码通过 Python 的特殊方法(也称为 "魔术方法"),让 Vector 类的实例可以像内置类型一样使用运算符(+、*)和函数(abs()),使代码更直观易懂。
不用类的方法是不是也可以得到符合上面条件的向量
是的,不使用类的方法也能实现类似的向量功能,我们可以通过函数来操作表示向量的数据结构(如元组或列表)。以下是使用函数式编程实现与上述 Vector 类相同功能的示例:
```python
from math import hypot
# 创建向量
def vector(x=0, y=0):
return (x, y)
# 向量的字符串表示
def vector_repr(v):
return f"Vector({v[0]}, {v[1]})"
# 计算向量模长
def vector_abs(v):
return hypot(v[0], v[1])
# 判断向量是否非零
def vector_bool(v):
return bool(vector_abs(v))
# 向量加法
def vector_add(v1, v2):
return (v1[0] + v2[0], v1[1] + v2[1])
# 向量与标量乘法
def vector_mul(v, scalar):
return (v[0] * scalar, v[1] * scalar)
# 使用示例
v1 = vector(2, 4)
v2 = vector(3, 1)
print(vector_repr(v1)) # 输出: Vector(2, 4)
print(vector_repr(vector_add(v1, v2))) # 输出: Vector(5, 5)
print(vector_repr(vector_mul(v1, 2))) # 输出: Vector(4, 8)
print(vector_abs(v1)) # 输出: 4.472135955...
print(vector_bool(v1)) # 输出: True
两种方式的对比: 类方法的优势: 封装性更好,将数据(向量的 x、y 分量)和操作(加法、乘法等)捆绑在一起 可以使用直观的运算符(+、*、abs()),代码更简洁易读 便于扩展更多功能,维护性更强 函数式方法的优势: 实现简单直接,不需要理解类和特殊方法的概念 适合简单场景,代码量可能更少 更灵活,不需要遵循类的结构约束 在处理简单向量操作时,两种方式都能满足需求。但随着功能复杂度增加(如需要添加向量减法、点积计算等),使用类的方式会更便于管理和扩展。 讲解内置函数repr repr() 是 Python 的内置函数,用于返回对象的字符串表示形式,主要用途是为开发者提供一个清晰、准确的对象描述,便于调试和理解对象的状态。 基本用法
python
x = 123
print(repr(x)) # 输出: '123'
s = "hello"
print(repr(s)) # 输出: "'hello'" (包含引号,明确表示这是字符串)
lst = [1, 2, 3]
print(repr(lst)) # 输出: '[1, 2, 3]'
核心特点 面向开发者:返回的字符串通常包含对象的类型和关键信息,便于调试时识别对象。 尽可能精确:理想情况下,repr(obj) 的结果应该是一段可以直接执行的 Python 代码,执行后能重建出与原对象相似的实例。
python
# 示例:通过 repr 结果重建列表
lst = [1, 2, 3]
lst_str = repr(lst) # 得到 '[1, 2, 3]'
new_lst = eval(lst_str) # 执行字符串,重建列表
print(new_lst == lst) # 输出: True
与 str() 的区别:
str(obj) 用于返回用户友好的字符串表示(侧重可读性)
repr(obj) 用于返回开发者友好的字符串表示(侧重精确性)
python
from datetime import datetime
dt = datetime(2023, 10, 1)
print(str(dt)) # 输出: '2023-10-01 00:00:00' (用户易读)
print(repr(dt)) # 输出: 'datetime.datetime(2023, 10, 1, 0, 0)' (可用于重建对象)
自定义对象的 repr 行为 通过在类中定义 repr 方法,可以自定义对象的 repr() 输出:
python
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
# 自定义 repr 输出
def __repr__(self):
return f"Person(name='{self.name}', age={self.age})"
p = Person("Alice", 30)
print(repr(p)) # 输出: Person(name='Alice', age=30)