python基础31[__XXX__函数]

本文详细介绍了Python中的特殊方法,这些方法具有特定的功能和用途,类似于CSharp和Java中的接口。内容覆盖了构造器、解构器、字符串表示、对象比较等各个方面,并提供了详细的示例说明。

 

不断跟新中,欢迎补充!

 

python中所有的__XXX__方法都有一定的含义,代表一定的协议,相当于CSharp和Java中的接口。

 

特殊方法 描述
基本定制型
C.__init__(self[, arg1, ...]) 构造器(带一些可选的参数)
C.__new__(self[, arg1, ...]) 构造器(带一些可选的参数);通常用在设置不变数据类
型的子类。
C.__del__(self) 解构器
C.__str__(self) 可打印的字符输出;内建str()及print 语句
C.__repr__(self) 运行时的字符串输出;内建repr() 和‘‘ 操作符
C.__unicode__(self)b Unicode 字符串输出;内建unicode()

C.__call__(self, *args) 表示可调用的实例
C.__nonzero__(self) 为object 定义False 值;内建bool() (从2.2 版开始)
C.__len__(self) “长度”(可用于类);内建len()

特殊方法 描述
对象(值)比较c
C.__cmp__(self, obj) 对象比较;内建cmp()
C.__lt__(self, obj) and 小于/小于或等于;对应<及<=操作符
C.__gt__(self, obj) and 大于/大于或等于;对应>及>=操作符
C.__eq__(self, obj) and 等于/不等于;对应==,!=及<>操作符
属性
C.__getattr__(self, attr) 获取属性;内建getattr();仅当属性没有找到时调用
C.__setattr__(self, attr, val) 设置属性
C.__delattr__(self, attr) 删除属性
C.__getattribute__(self, attr) 获取属性;内建getattr();总是被调用
C.__get__(self, attr) (描述符)获取属性
C.__set__(self, attr, val)  (描述符)设置属性
C.__delete__(self, attr)  (描述符)删除属性
定制类/模拟类型
数值类型:二进制操作符
C.__*add__(self, obj) 加;+操作符
C.__*sub__(self, obj) 减;-操作符
C.__*mul__(self, obj) 乘;*操作符
C.__*div__(self, obj) 除;/操作符
C.__*truediv__(self, obj)  True 除;/操作符
C.__*floordiv__(self, obj)  Floor 除;//操作符
C.__*mod__(self, obj) 取模/取余;%操作符
C.__*divmod__(self, obj) 除和取模;内建divmod()
C.__*pow__(self, obj[, mod]) 乘幂;内建pow();**操作符
C.__*lshift__(self, obj) 左移位;<<操作符
特殊方法 描述
定制类/模拟类型
数值类型:二进制操作符

C.__*rshift__(self, obj) 右移;>>操作符
C.__*and__(self, obj) 按位与;&操作符
C.__*or__(self, obj) 按位或;|操作符
C.__*xor__(self, obj) 按位与或;^操作符
数值类型:一元操作符
C.__neg__(self) 一元负
C.__pos__(self) 一元正
C.__abs__(self) 绝对值;内建abs()
C.__invert__(self) 按位求反;~操作符
数值类型:数值转换
C.__complex__(self, com) 转为complex(复数);内建complex()
C.__int__(self) 转为int;内建int()
C.__long__(self) 转为long;内建long()
C.__float__(self) 转为float;内建float()
数值类型:基本表示法(String)
C.__oct__(self) 八进制表示;内建oct()
C.__hex__(self) 十六进制表示;内建hex()
数值类型:数值压缩
C.__coerce__(self, num) 压缩成同样的数值类型;内建coerce()
C.__index__(self)g 在有必要时,压缩可选的数值类型为整型(比如:用于切片
索引等等

序列类型
C.__len__(self) 序列中项的数目
C.__getitem__(self, ind) 得到单个序列元素
C.__setitem__(self, ind,val) 设置单个序列元素
C.__delitem__(self, ind) 删除单个序列元素
特殊方法 描述
序列类型
C.__getslice__(self, ind1,ind2) 得到序列片断
C.__setslice__(self, i1, i2,val) 设置序列片断
C.__delslice__(self, ind1,ind2) 删除序列片断
C.__contains__(self, val) f 测试序列成员;内建in 关键字
C.__*add__(self,obj) 串连;+操作符
C.__*mul__(self,obj) 重复;*操作符
C.__iter__(self)  创建迭代类;内建iter()

映射类型
C.__len__(self) mapping 中的项的数目
C.__hash__(self) 散列(hash)函数值
C.__getitem__(self,key) 得到给定键(key)的值
C.__setitem__(self,key,val) 设置给定键(key)的值
C.__delitem__(self,key) 删除给定键(key)的值
C.__missing__(self,key) 给定键如果不存在字典中,则提供一个默认值

 

可以使用with关键字的类型,需要实现:

__enter__ 和 __exit__

 

iterator迭代器对象必须实现:

__iter__ 和 next()

 

 

参考:

http://hi.baidu.com/kxw102/blog/item/7adf054bc91abc2c08f7efa9.html

 

完!

 

<think>我们正在讨论Python中所有双下划线开头和结尾的属性和方法。这类名称在Python中被称为“魔术方法”(Magic Methods)或“特殊方法”(Special Methods)。它们由Python语言定义,用于实现对象的特定行为。根据引用[1][2][4]的内容,这些方法在特定的操作中被Python解释器自动调用。 关键点: 1. 双下划线开头和结尾(如`__init__`, `__str__`)的方法是Python内置的特殊方法,用于重载运算符或定义对象的特定行为。 2. 这些方法不是普通的函数,必须定义在类中。 3. 双下划线开头和结尾的变量(属性)也是特殊用途的,但相对较少,通常用于表示一些特殊含义(如模块的`__name__`,类的`__doc__`等)。 我们将从以下几个方面进行说明: 一、常见的特殊方法(魔术方法) 二、特殊属性 三、使用场景和注意事项 一、常见的特殊方法(魔术方法) 根据引用[1]和[4],以下是一些常见的魔术方法: 1. 对象创建和初始化: - `__new__(cls, ...)`: 创建实例时调用的静态方法(第一个参数是类),返回实例对象。 - `__init__(self, ...)`: 初始化实例,在`__new__`之后调用。 2. 字符串表示: - `__str__(self)`: 定义对象的“非正式”字符串表示,用于`str(obj)`和`print(obj)`。 - `__repr__(self)`: 定义对象的“正式”字符串表示,通常用于交互式解释器和调试,应尽可能返回一个可以用于重建对象的字符串表达式。 3. 运算符重载: - 算术运算符:`__add__(self, other)`, `__sub__(self, other)`, `__mul__(self, other)`, `__truediv__(self, other)`, `__mod__(self, other)`等。 - 比较运算符:`__eq__(self, other)`, `__ne__(self, other)`, `__lt__(self, other)`, `__le__(self, other)`, `__gt__(self, other)`, `__ge__(self, other)`。 - 其他运算符:`__invert__(self)`(按位取反`~`),`__neg__(self)`(负号`-`),`__pos__(self)`(正号`+`)等。 4. 容器和序列操作: - `__len__(self)`: 返回容器长度,用于`len(obj)`。 - `__getitem__(self, key)`: 获取索引对应的元素,用于`obj[key]`。 - `__setitem__(self, key, value)`: 设置索引对应的元素,用于`obj[key]=value`。 - `__delitem__(self, key)`: 删除索引对应的元素,用于`del obj[key]`。 - `__contains__(self, item)`: 定义`in`操作符的行为。 5. 迭代器协议: - `__iter__(self)`: 返回一个迭代器对象,通常用于`for`循环。 - `__next__(self)`: 迭代器对象需要实现的方法,返回下一个元素。 6. 上下文管理(`with`语句): - `__enter__(self)`: 进入上下文时调用,返回的对象赋值给`as`后面的变量。 - `__exit__(self, exc_type, exc_value, traceback)`: 离开上下文时调用,用于处理异常和清理资源。 7. 属性访问控制: - `__getattr__(self, name)`: 当访问不存在的属性时调用。 - `__setattr__(self, name, value)`: 设置属性时调用(包括直接赋值和`setattr`函数)。 - `__delattr__(self, name)`: 删除属性时调用。 - `__getattribute__(self, name)`: 访问任何属性时都会调用(包括存在的和不存在的)。 8. 描述符(Descriptor)协议(用于实现属性、方法绑定等高级特性): - `__get__(self, instance, owner)`: 当描述符被读取时调用。 - `__set__(self, instance, value)`: 当描述符被设置时调用。 - `__delete__(self, instance)`: 当描述符被删除时调用。 二、特殊属性 除了方法,Python也有一些双下划线开头和结尾的特殊属性: 1. `__name__`:对象的名字,如模块、类、函数的名字。 2. `__doc__`:对象的文档字符串(docstring)。 3. `__module__`:定义对象的模块名。 4. `__class__`:对象的类。 5. `__dict__`:对象属性的字典(参见之前的问题)。 6. `__slots__`:限制实例可以拥有的属性(用于内存优化)。 7. `__annotations__`:包含类型注解的字典(Python 3.6+)。 8. `__bases__`:类的基类元组。 三、使用场景和注意事项 1. 特殊方法通常由Python解释器隐式调用,不建议直接调用(除非你知道自己在做什么)。 2. 特殊属性由Python内部设置,通常只读(除了`__dict__`等少数可写)。 3. 自定义类中实现特殊方法可以实现运算符重载、对象行为定制等高级功能。 4. 引用[3]指出:双下划线开头并结尾的变量(如`__var__`)会继承给子类,类似于普通属性。而双下划线开头但没有结尾(如`__var`)的变量是私有变量,会触发名称修饰(Name Mangling),即变成`_类名__var`的形式,这样可以避免子类中的命名冲突[^3][^4][^5]。 5. 模块级别的特殊属性:模块也有`__name__`、`__file__`、`__package__`等属性。 示例代码: 定义一个类,展示几个特殊方法的使用: ```python class Vector: def __init__(self, x, y): self.x = x self.y = y def __str__(self): return f'Vector({self.x}, {self.y})' def __add__(self, other): return Vector(self.x + other.x, self.y + other.y) def __eq__(self, other): return self.x == other.x and self.y == other.y # 使用 v1 = Vector(2, 4) v2 = Vector(3, 1) print(v1 + v2) # 调用__add__,然后调用__str__:Vector(5, 5) print(v1 == v2) # 调用__eq__:False ``` 关于特殊属性,我们可以查看上面Vector类的属性: ```python print(Vector.__name__) # 输出 'Vector' print(Vector.__module__) # 输出 '__main__'(如果是直接运行) ``` 注意:在模块级别,我们也可以定义一些特殊属性(比如`__doc__`用于模块文档),但通常不建议在模块级别定义太多自己的双下划线属性,以免与Python内置的特殊属性冲突。 总结: 双下划线开头和结尾的名称是Python中用于特殊目的的标识符,它们赋予了类特殊的能力,使得自定义类可以像内置类型一样行为。同时,Python也提供了一些特殊属性用于获取对象的元信息。 §§相关问题§§ 1. 名称修饰(Name Mangling)的具体规则是什么?私有变量如何访问? 2. 描述符协议(Descriptor Protocol)在实际开发中有哪些应用场景? 3. 除了常见的魔术方法,Python中还有哪些较少用但功能强大的特殊方法? </think>### Python 双下划线开头和结尾的属性方法详解(`__xxx__`) 在 Python 中,以双下划线开头和结尾的标识符(如 `__init__`, `__str__`)被称为**特殊方法**或**魔术方法**(Magic Methods)。它们由 Python 语言定义,用于实现对象的特定行为,在特定操作时会被解释器自动调用[^1][^4]。以下是完整分类和说明: #### 一、核心功能分类 1. **对象生命周期方法** ```python __new__(cls) # 创建实例时调用(构造函数之前) __init__(self) # 对象初始化(最常用)[^1] __del__(self) # 对象销毁时调用(析构函数) ``` 2. **字符串表示方法** ```python __str__(self) # 定义 print(obj) 的输出[^1] __repr__(self) # 定义解释器直接显示的对象表示 __format__(self) # 定义 format() 函数的格式化行为 ``` 3. **运算符重载方法** ```python __add__(self, other) # 实现 + 运算 (a + b) __sub__(self, other) # 实现 - 运算 (a - b)[^1] __mul__(self, other) # 实现 * 运算 __eq__(self, other) # 实现 == 比较 __lt__(self, other) # 实现 < 比较 ``` 4. **容器类型方法** ```python __len__(self) # 定义 len(obj) 的行为 __getitem__(self, key) # 定义 obj[key] 的访问 __setitem__(self, key, value) # 定义 obj[key]=value __contains__(self, item) # 定义 in 运算符行为 ``` 5. **调用与上下文管理** ```python __call__(self) # 使对象可调用(如 obj()) __enter__(self) # with 语句进入时调用 __exit__(self) # with 语句退出时调用 ``` #### 二、特殊属性(只读) | 属性 | 说明 | |------|------| | `__name__` | 对象名称(函数/类/模块)[^4] | | `__doc__` | 对象的文档字符串 | | `__module__` | 定义对象的模块名 | | `__class__` | 对象所属的类 | | `__dict__` | 对象属性的字典[^4] | | `__slots__` | 限定类允许的属性 | | `__annotations__` | 类型注解字典 | #### 三、关键特性 1. **自动触发机制** 特殊方法由 Python 解释器隐式调用: ```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) # 自动调用 __init__ p2 = Point(3, 4) p3 = p1 + p2 # 自动触发 __add__ ``` 2. **命名规范约束** - `__xxx__` 是 Python 保留命名空间[^4] - 自定义属性**禁止**使用此格式(可能导致与未来 Python 特性冲突) 3. **与私有变量的区别** | 类型 | 示例 | 可继承性 | 访问性 | |------|------|----------|--------| | 特殊方法 | `__init__` | 可继承 | 公有 | | 私有变量 | `__name` | 不可继承[^3] | 需通过 `_ClassName__name` 访问[^5] | #### 四、使用示例 ```python class Vector: def __init__(self, x, y): self.x = x self.y = y def __str__(self): return f"Vector({self.x}, {self.y})" # 自定义输出格式 def __add__(self, other): return Vector(self.x + other.x, self.y + other.y) # 向量加法 v1 = Vector(2, 3) v2 = Vector(4, 5) print(v1) # 输出: Vector(2, 3)(调用 __str__) v3 = v1 + v2 # 输出: Vector(6, 8)(调用 __add__) ``` #### 五、注意事项 1. 避免在自定义属性中使用 `__xxx__` 格式 2. 直接调用魔术方法可能破坏封装性(如 `obj.__init__()`) 3. 内置类型(如 `list`, `dict`)已实现大量特殊方法 4. 通过 `dir(obj)` 可查看对象的所有特殊方法 > 特殊方法是 Python **面向对象编程的基石**,它们使得自定义对象能像内置类型一样支持运算符、迭代等核心操作[^1][^4]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值