1. 魔法方法 magic methods
(1) 魔法方法总是被双下划线包围，如 __init__
(2) 魔法方法是面向对象的python的一切
(3) 魔法方法的魔力体现在能够在适当的时候被调用
魔法方法汇总：
__init__(self[, ...])
功能：初始化类对象(根据需求决定是否增加属性参数)
返回值： None
举例：
>>> class Rectangle: #矩形类，需要长和宽，所以重写__init__
def __init__(self, x, y):
self.x = x
self.y = y
def getPeri(self): #获得周长
return (self.x + self.y) * 2
def getArea(self): #获得面积
return self.x * self.y
>>> rect = Rectangle(3, 4)
>>> rect.getPeri()
14
>>> rect.getArea()
12
__new__(class[, ...])
功能：创建一个类对象
返回值：返回一个对象
(1) 在__init__方法之前被调用，属于类创建时第一个被调用的方法
举例：
>>> class CapStr(str): #继承一个不可改变的类型str
def __new__(cls, string): #使用new将类型的功能进行转换
string = string.upper()
return str.__new__(cls, string) #把重写后的str中的new方法带传代餐返回
>>> a = CapStr("I love M.")
>>> a
'I LOVE M.'
__del__(self)
功能：对象将要被销毁的时候，自动调用，属于自动垃圾回收方法
注意：del x != x.__del__()
举例：
>>> class C:
def __init__(self):
print('我是init方法，我被调用了！')
def __del__(self):
print('我是del方法，我被调用了！')
>>> c1 = C()
我是init方法，我被调用了！
>>> c2 = c1 #对象的赋值不会调用__init__
>>> c3 = c2
>>> del c3
>>> del c2
>>> del c1 #其他的赋值对象del时不会调用__del__ (c2和c3只是c1的一份拷贝)
结果：我是del方法，我被调用了！
2. 算术运算魔法方法
__add__(self, other) 加法：+
__sub__(self, other) 减法：-
__mul__(self, other) 乘法：*
__truediv__(self, other) 真除法：/
__floordiv__(self, other) 整数除法：//
__mod__(self, other) 取模算法：%
__divmod__(self, other) divmod()调用时的行为
__pow__(self, other[, modulo]) power()调用或 ** 运算时的行为
__lshift__(self, other) 按位左移：<<
__rshift__(self, other) 按位右移：>>
__and__(self, other) 按位与：&
__xor__(self, other) 按位异或：^
__or__(self, other) 按位或：
举例：
>>> class New_int(int):
def __add__(self, other):
return int.__sub__(self, other)
def __sub__(self, other):
return int.__add__(self, other)
>>> a = New_int(3)
>>> b = New_int(5)
>>> a + b
-2
>>> a - b
8
>>> class Try_int(int):
def __add__(self, other):
return int(self) + int(other)
def __sub__(self, other):
return int(self) - int(other)
>>> a = Try_int(3)
>>> b = Try_int(5)
>>> a + b
8
__radd__是自定义的类操作符，执行“右加”。当python解释器执行到a+b这样的语句时，首先在查找a中有没有__add__操作符，如果a中没有定义，那么就在b中查找并执行__radd__。
3. 类定制的计时器
(1) 定制一个计时器的类
(2) start和stop方法代表启动计时和停止计时
(3) 假设计时器对象t1，print(t1)和直接调用t1均显示结果
(4) 当计时器未启动或已经停止计时，调用stop方法会给与温馨的提示
(5) 两个计时器对象可以进行相加：t1 + t2
需要的资源：
(1) 使用time模块的localtime方法获取时间
(2) __str__ 方法 __repr__ 方法可用来打印文字
time 模块
详解链接：http://bbs.fishc.com/forum.php?mod=viewthread&tid=51326&extra=page%3D1%26filter%3Dtypeid%26typeid%3D403
类定制计时器代码：http://blog.youkuaiyun.com/sinat_36184075/article/details/77806778
#代码示例(原)：
import time as t
class MyTimer():
def __init__(self):
self.unit = ['年', '月', '日', '小时', '分', '秒'] #单位
self.prompt = '未开始计时！'
self.lasted = []
self.begin = 0
self.end = 0
def __str__(self):
return self.prompt
__repr__ = __str__ #赋值起到相同的def定义作用
def __add__(self, other):
prompt = '总共运行了'
result = []
for index in range(6):
result.append(self.lasted[index] + other.lasted[index])
if result[index]:
prompt += (str(result[index]) + self.unit[index])
return prompt
#开始计时
def start(self):
self.begin = t.localtime()
self.prompt = '提示：请先调用 stop() 停止计时！'
print('计时开始...')
print(self.begin) #time.struct_time()元组
#停止计时
def stop(self):
if not self.begin:
print('提示：请先调用 start() 进行计时！')
else:
self.end = t.localtime()
print(self.end) #time.struct_time()元组
self._calc()
print('计时结束...')
#内部方法：计算运行时间
def _calc(self):
self.lasted = []
self.prompt = '总共运行了'
for index in range(6): #控制循环次数6次
self.lasted.append(self.end[index] - self.begin[index])
if self.lasted[index]:
self.prompt += (str(self.lasted[index]) + self.unit[index])
#为下一轮计时初始化类的属性变量
self.begin = 0
self.end = 0
print(self.prompt)
运行：
>>> t1 = MyTimer()
>>> t1
未开始计时！
>>> t1.start()
计时开始...
>>> t1.stop()
总共运行了4秒
计时结束...
>>> t1
总共运行了4秒
>>> t1
总共运行了4秒
>>> t1 = MyTimer()
>>> t1.stop()
提示：请先调用 start() 进行计时！
>>> t1.start()
计时开始...
>>> t2 = MyTimer()
>>> t2.start()
计时开始...
>>> t1.stop()
总共运行了1分-41秒 #[bug] 当时间有进位时，目前代码写法中直接相减得不到正确结果。
计时结束...
>>> t2.stop()
总共运行了13秒
计时结束...
#代码示例(优化后)：
import time as t
#时间系数的常量定义
d_sec = 60 * 60 * 24
h_sec = 60 * 60
m_sec = 60
s_sec = 1
class MyTimer():
def __init__(self):
#self.unit = ['年', '月', '日', '小时', '分', '秒'] #单位
self.unit = ['秒', '分', '小时', '日'] #单位
self.prompt = '未开始计时！'
self.lasted = []
self.begin = 0
self.end = 0
def __str__(self):
return self.prompt
__repr__ = __str__ #赋值起到相同的def定义作用
def __add__(self, other):
prompt = '总共运行了'
result = []
for index in range(6):
result.append(self.lasted[index] + other.lasted[index])
if result[index]:
prompt += (str(result[index]) + self.unit[index])
return prompt
#开始计时
def start(self):
#精度范围：日时分秒 (月份不均故暂不做精度)
time_ss = t.localtime()
self.begin = time_ss.tm_mday * d_sec + time_ss.tm_hour * h_sec + time_ss.tm_min * m_sec + time_ss.tm_sec * s_sec
self.prompt = '提示：请先调用 stop() 停止计时！'
print('计时开始...')
print(self.begin) #秒数
#停止计时
def stop(self):
if not self.begin:
print('提示：请先调用 start() 进行计时！')
else:
#精度范围：日时分秒 (月份不均故暂不做精度)
time_tt = t.localtime()
self.end = time_tt.tm_mday * d_sec + time_tt.tm_hour * h_sec + time_tt.tm_min * m_sec + time_tt.tm_sec * s_sec
print(self.end) #秒数
self._calc()
print('计时结束...')
#内部方法：计算运行时间
def _calc(self):
self.lasted = []
self.prompt = '总共运行了'
ran = 0 #控制遍历单位的进位，如从分钟进位到小时
sec_diff = self.end - self.begin
min_diff = sec_diff // 60
sec_diff %= 60
if sec_diff > 0:
self.lasted.append(sec_diff)
print('sec_diff: %d' % sec_diff)
ran = 1
hou_diff = min_diff // 60
min_diff %= 60
if min_diff > 0:
self.lasted.append(min_diff)
print('min_diff: %d' % min_diff)
ran = 2
day_diff = hou_diff // 24
hou_diff %= 24
if hou_diff > 0:
self.lasted.append(hou_diff)
print('hou_diff: %d' % hou_diff)
ran = 3
for index in range(ran):
if self.lasted[index]:
self.prompt += (str(self.lasted[index]) + self.unit[index])
## for index in range(6): #控制循环次数6次
## self.lasted.append(self.end[index] - self.begin[index])
## if self.lasted[index]:
## self.prompt += (str(self.lasted[index]) + self.unit[index])
#为下一轮计时初始化类的属性变量
self.begin = 0
self.end = 0
print(self.prompt)
运行：
>>> t1= MyTimer()
>>> t2= MyTimer()
>>> t1.start()
计时开始...
255002
>>> t2.start()
计时开始...
255004
>>> t1.stop()
255109
sec_diff: 47
min_diff: 1
总共运行了47秒1分 #顺序暂时没调整，这个不在话下，次序问题
计时结束...
>>> t2.stop()
255111
sec_diff: 47
min_diff: 1
总共运行了47秒1分
计时结束...
struct_time元组
time.struct_time(tm_year=2017, tm_mon=9, tm_mday=2, tm_hour=12, tm_min=18, tm_sec=55, tm_wday=5, tm_yday=245, tm_isdst=0)
4. 属性访问
__getattribute__(self, name) #定义当该类的属性被访问时的行为
__getattr__(self, name) #定义当用户试图获取一个不存在的属性时的行为
__setattr__(self, name, value) #定义当一个属性被设置(包括初始化)时的行为
__delattr__(self, name) #定义一个属性被删除时的行为
举例：
>>> class C:
def __getattribute__(self, name):
print('getattribute')
return super().__getattribute__(name)
def __getattr__(self, name):
print('getattr')
def __setattr__(self, name, value):
print('setattr')
super().__setattr__(name, value)
def __delattr__(self, name):
print('delattr')
super().__delattr__(name)
>>> c = C()
>>> c.x
getattribute
getattr
>>> c.x = 1
setattr #初始化时自动调用setattr
>>> c.x
getattribute
1
>>> del c.x
delattr
举例：属性访问时的严重问题，无限递归
class Rectangle: #矩形
def __init__(self, width=0, height=0): #宽高不相等，长方形
self.width = width
self.height = height
def __setattr__(self, name, value):
if name == 'square': #宽高相等，正方形
self.width = value
self.height = value
else:
#self.name = value #会导致类无限递归自己
super().__setattr__(name, value) #解决办法①：super() 推荐。
#self.__dict__[name] = value #解决办法②：字典
def getArea(self):
return self.width * self.height
运行：
>>> r1 = Rectangle(4, 5)
>>> r1.getArea()
20
>>> r1.square = 10 #正方形
>>> r1.width
10
>>> r1.height
10
>>> r1.getArea()
100
>>> r1.__dict__ #以字典的形式查看类中的属性和值
{'width': 10, 'height': 10}
5. 描述符 decriptor
描述符就是将某种特殊类型的类的实例指派给另一个类的属性。
__get__(self, instance, owner) #用于访问属性，返回属性的值
__set__(self, instance, value) #将在属性分配操作中调用，不返回任何内容
__delete__(self, instance) #控制删除操作，不返回任何内容
@self, 描述符类本身的类实例
@instance, 拥有者的类实例
@owner, 拥有者类本身
@value, 所赋的值
举例：
>>> class MyDecriptor:
def __get__(self, instance, owner):
print('getting: ', self, instance, owner)
def __set__(self, instance, value):
print('setting: ', self, instance, value)
def __delete__(self, instance):
print('deleting: ', self, instance)
>>> class Test:
x = MyDecriptor()
>>> #MyDecriptor是x的描述符类
>>> test = Test() #实例化Test()类
>>> test.x
getting: <__main__.MyDecriptor object at 0x000002164DC31FD0> <__main__.Test object at 0x000002164DBB6F28> <class '__main__.Test'>
>>> test
<__main__.Test object at 0x000002164DBB6F28>
>>> test.x = 'X-man'
setting: <__main__.MyDecriptor object at 0x000002164DC31FD0> <__main__.Test object at 0x000002164DBB6F28> X-man
>>> del test.x
deleting: <__main__.MyDecriptor object at 0x000002164DC31FD0> <__main__.Test object at 0x000002164DBB6F28>
自定义的描述符
>>> class MyProperty:
def __init__(self, fget=None, fset=None, fdel=None):
self.fget = fget
self.fset = fset
self.fdel = fdel
def __get__(self, instance, owner):
return self.fget(instance) #instance拥有者的实例对象
def __set__(self, instance, value):
self.fset(instance, value)
def __delete__(self, instance):
self.fdel(instance)
>>> class C:
def __init__(self):
self._x = None
def getX(self):
return self._x
def setX(self, value):
self._x = value
def delX(self):
del self._x
x = MyProperty(getX, setX, delX)
>>> c = C()
>>> c.x = 'X-man'
>>> c.x
'X-man' #使用x影响_x的值
>>> c._x
'X-man'
>>> del c.x #删除后，c.x和c._x都不存在
练习：温度转换
定义一个温度类，然后定义两个描述符类用于描述摄氏度和华氏度两个属性。
要求两个属性会自动进行转换，也就是说可以给摄氏度这个属性赋值，打印华氏度是自动转换后的结果。
代码：
class Celsius:
def __init__(self, value = 26.0):
self.value = float(value)
def __get__(self, instance, owner):
return self.value
def __set__(self, instance, value):
self.value = float(value)
class Fahrenheit:
def __get__(self, instance, owner): #instance就是Temperature(属性:cel, fah)
return instance.cel * 1.8 + 32
def __set__(self, instance, value):
#instance.cel = ('%.1f' % ((float(value) - 32) / 1.8))
#控制精度方法1
instance.cel = round((float(value) - 32) / 1.8, 1)
#控制精度方法2
class Temperature:
cel = Celsius() #摄氏度
fah = Fahrenheit() #华氏度, fah在实例对象中被赋值时调用对应类的__set__
运行：
>>> temp = Temperature()
>>> temp.cel
26.0
>>> temp.cel = 30
>>> temp.fah
86.0
>>> temp.fah = 100
>>> temp.cel
37.8
扫一扫
584
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
