A-19-魔法方法

高渐飞

1. #coding=UTF-8
   
2. 
   
3. #知识点总结
   
4. """
   
5. 1.魔法方法详解 http://bbs.fishc.org/thread-48793-1-1.html
   
6. 2.__new__(cls [, ...])： 是一个对象实例化时所调用的第一个方法， 第一个参数是类（cls）， 其他参数会直接传递给__init__方法
   
7.   __new__ 返回实例对象， 通常是参数cls这个参数的实例化对象， 也可以返回其他对象.
   
8. 
   
9. 3. __init__(self [, ...])： 当实例对象有明确的初始化步骤时改写__init__()
   
10. 4. __del__(self)： 当对象将被销毁的时候调用， 销毁指的是垃圾回收机制回收这个对象
    
11. 
    
12. 5.python3以后， int()， float()， list()， str()等工厂函数的调用实际上就是创建类的实例化对象的过程， 工厂函数就是类对象
    
13. 
    
14. 6.当对实例对象进行算术运算时， 会自动调用算术运算的魔法方法
    
15. 
    
16.       运算符                   对应的魔法方法
    
17.         +                __add__(self, other)
    
18.         -                __sub__(self, other)
    
19.         *                __mul__(self. other)
    
20.         /                __truediv__(self, other)
    
21.         //               __floordiv__(slef, other)
    
22.         %                __mod__(self, other)
    
23.         **               __pow__(self, other[, modulo])
    
24.         <<               __lshift__(self, other)
    
25.         >>               __rshift__(slef, other)
    
26.         &                __and__(self, other)
    
27.         ^                __xor__(self, other)
    
28.         |                __or__(self, other)
    
29. 
    
30. 
    
31.     例如， 当 a + b 时， 会自动调用 __add__() 方法， 可以通过修改魔法方法来自定义算术运算
    
32. """
    
33. 
    
34. 
    
35. #1.
    
36. class CapStr(str):   #定义一个继承自str的类
    
37.     def __new__(cls,string):
    
38.         string = srting.upper()
    
39.         return str.__new__(cls,string)
    
40. a=CapStr("I love you")
    
41. print(a)
    
42. 
    
43. #2.
    
44. class Rectangle:
    
45.     def __init__(self,x,y):  #重新定义初始化函数
    
46.         self.x=x
    
47.         self.y=y
    
48.     def getperi(self):
    
49.         return (self.x+self.y)*2
    
50.     def getarea(self):
    
51.         return self.x*self.y
    
52. 
    
53. rect=Rectangle(3,4)
    
54. print(rect.getperi())
    
55. print(rect.getarea())
    
56. 
    
57. #3.
    
58. class C:
    
59.     def __init__(self):
    
60.         print("我是_init_方法，我被调用了....")
    
61.     def __del__(self):
    
62.         print("我是_del_方法，我被调用了....")
    
63. c1=C()
    
64. c2=c1
    
65. c3=c2
    
66. del c3
    
67. del c2
    
68. del c1
    
69. 
    
70. #4.
    
71. class Try_int(int):
    
72.     def __add__(self, other):
    
73.         return int (self) + int(other)
    
74.     def __sub__(self, other):
    
75.         return  int(self) - int(other)
    
76. 
    
77. a=Try_int(3)
    
78. b=Try_int(5)
    
79. print(a+b)
    
80. 
    
81. #5.
    
82. class  Nint(int):
    
83.     def  __new__(cls, arg = 0):
    
84.         if  type(arg) == type(str):
    
85.             total = 0
    
86.             for each_str in arg:
    
87.                total += ord(each_str)
    
88. 
    
89.             arg = total
    
90.         return int.__new__(cls, arg)
    
91. 
    
92. 
    
93. #6. 反运算的魔法方法，当左操作数不支持相应操作时被调用
    
94. #  例如__radd__， a + b， 当a对象没有__add__方法时， b对象才会调用__radd__:
    
95. class Nint(int):
    
96.     def __radd__(self, other):
    
97.         print("__radd__ 被调用了！")
    
98.         return int.__sub__(self, other)
    
99. 
    
100. a = Nint(5)
     
101. b = Nint(3)
     
102. print(a+b)
     
103. print(1 + b) #调用__radd__(self, other),其中self为b，other为1
     
104. print(3-a)   #这是自动调用的是_sub_函数，即__sub__(3, a)
     
105. 
     
106. class Nint(int):
     
107.     def __rsub__(self, other):
     
108.         return int.__sub__(self,other)
     
109. a=Nint(5)
     
110. print(3-a)    #调用函数__rsub__(self, other)，其中self为a
     
111. 
     
112. 
     
113. #
     
114. 
     
115. 
     
116. """
     
117. #在继承的类中调用基类的方法， 使用super()
     
118. 
     
119. #对于修饰符@staticmethod， 表示紧跟的一个方法为静态方法， 静态方法不会绑定到实例对象上， 可以节省开销，
     
120. #  所以定义静态方法时不需要传入self参数， 当对象访问时也不会传入self参数， 例如：
     
121. 
     
122. class C:
     
123.         @staticmethod  # 该修饰符表示 static() 是静态方法
     
124.         def static(arg1, arg2, arg3):
     
125.                 print(arg1, arg2, arg3, arg1 + arg2 + arg3)
     
126. 
     
127.         def nostatic(self):
     
128.                 print("I'm the f**king normal method!")
     
129. c1 = C()
     
130. c2 = C()
     
131. # 静态方法只在内存中生成一个，节省开销
     
132. print(c1.static is C.static)
     
133. print(c1.nostatic is C.nostatic)
     
134. print(c1.static)
     
135. print(c2.static)
     
136. print(C.static)
     
137. 
     
138. # 普通方法每个实例对象都拥有独立的一个，开销较大
     
139. print(c1.nostatic)
     
140. print(c2.nostatic)
     
141. print(C.nostatic)
     
142. print(c1.static(1, 2, 3))
     
143. print(C.static(1, 2, 3))
     
144. 
     
145. """

复制代码