1.多继承
当继承的类有同种方法的时候,只会继承前面一个的方法。调用父类方法super()
#1.多继承
class Base:
def play(self):
print('这是Base')
class A(Base):
def play(self):
print(type(self))
print('这是A')
class B(Base):
def play(self):
print('这是B')
class C(A,B):
#子类调用父类方法
def play(self):
#A.play(self) #第一种方法
#B.play(self)
#super().play() #第二种方法,默认调用第一个父类方法
#super(C,self).play() #括号不写,默认(C,self)
#super(A,self).play() # Base
#super(B,self).play() # A , 上一层
#super(Base,self).play()
print('这是C')
c = C() # (B,A) C -> B -> A -> Base ->object
# (A,B) C -> A -> B -> Base ->object
C().__class__.mro()
'''
super, 上一层
1.super(), (自己类名,自己实例) 例:( C,c )
2. 谁调用我,我就以你为基准。 建立一张调用顺序表
‘(B,A) C -> B -> A -> Base ->object ’
‘''
2.类的特殊方法
#类属性:
__dict__ # 类的属性(包含一个字典,由类的数据属性组成)
__doc__ # 类的文档字符串
#类方法:
__init__ # 初始化
__repr__ # 直接返回这个对象 repr() 函数就是调用对象的这个方法
__str__ # print(obj) 如果类里面定义了__repr__,没有定义__str__ print(obj)也会返回__repr__的内容,或者说__repr__的优先级更高
__call__ # Obj() 使实例可被调用
#运算符方法
__add__(self,other) #x+y
__sub__(self,other) #x-y
__mul__(self,other) #x*y
__mod__(self,other) #x%y
__iadd__(self,other) #x+=y
__isub__(self,other) #x-=y
__radd__(self,other) #y+x
__rsub__(self,other) #y-x
__imul__(self,other) #x*=y
__imod__(self,other) #x%=y
#和类有关的几个函数
delattr() # 删除对象属性
getattr() # 得到某个属性值
setattr() # 给对象添加某个属性值
hasattr() # 判断对象object是否包含名为name的特性
isinstance() # 检查对象是否是类的对象,返回True或False
issubclass() # 检查一个类是否是另一个类的子类。返回True或False
'''
不仅仅是属性,更多是方法
'''
class Rectangle:
'''这是一个长方形类,它可以计算面积'''
aaa = 1
def __init__(self,length,width): #构造方法
if isinstance(length,(int,float)) and isinstance(width,(int,float)):
self.length = length
self.width = width
else:
print('请输入int or float')
def area(self):
return self.length * self.width
## def __str__(self):
## return '这个长方形的面积%s'%self.area()
def __repr__(self):
return '长:%s 宽:%s'%(self.length,self.width)
def __call__(self):
return '我这是一个Rectangle 类,你要干嘛'
def __add__(self,other):
return self.area() + other.area()
def __sub__(self,other):
return '不可以相减'
r = Rectangle(2,3)
#类属性
#__dict__
r.__dict__ # 打印实例里面的属性 ,{'length': 2, 'width': 3}
#注意 ,共有属性。当不修改时,默认引用(源类 Rectangle ),
# 修改之后,就会定义在 实例里面
r.aaa = 22
r.__dict__
#__doc__
r.__doc__
#类方法
#__str__
#print(r)
#__repr__
r
'%s'%'ssss'
'%r'%'rrrr'
#print 默认调用__str__ ,没有时__repr__
#### __call__
#r()
r() # '我这是一个Rectangle 类,你要干嘛'
def dd():
print('dd')
dir(dd) #'__call__'
r1 = Rectangle(2,4)
r2 = Rectangle(3,5)
# __add__(self,other)
#__sub__(self,other) #x-y
####
'''
delattr() # 删除对象属性
getattr() # 得到某个属性值
setattr() # 给对象添加某个属性值
hasattr() # 判断对象object是否包含名为name的特性
isinstance() # 检查对象是否是类的对象,返回True或False
issubclass() # 检查一个类是否是另一个类的子类。返回True或Fals
'''
3.装饰器
装饰器(deco):
装饰函数的参数是被装饰的函数对象,返回原函数对象装饰器本质上是一个Python函数,它可以让其他函数在不需要做任何代码变动的前提下增加额外功能,装饰器的返回值也是一个函数对象
概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能。
###3.装饰器 ,添加附加功能
#闭包
def fx(x):
x += 1
def fy(y):
return x*y
return fy
'''
fx(1)(2)
temp = fx(1)
temp(2)
'''
def f1(func):
print('f1 running')
def f2(y):
print('f2 running')
return func(y)+1
return f2
def gun(m):
print('gun running')
return m*m
'''
f1(gun)
temp = f1(gun)
temp(5)
'''
@f1
def gun2(m):
print('gun running')
return m*m
'''
1. @f1 -> f1( gun2 ) -> f2
2. f2 ,等待调用
3. gun2 (5) -> 当参数 5传入 --> f2(5)
4. f2(5), 开始运行 -> print('f2 running') -> func(y): func = gun2 y = 5 ->{{func(y) 等于 gun2(5)}}
5. gun2(5) 开始运行 -> print('gun running') -> 25
6. 25 +1 -> 26
'''
##测试时间
'''
import time
def run_time(func):
def new_fun(*args,**kwargs):
t0 = time.time()
print('star time: %s'%(time.strftime('%x',time.localtime())) )
back = func(*args,**kwargs)
print('end time: %s'%(time.strftime('%x',time.localtime())) )
print('run time: %s'%(time.time() - t0))
return back
return new_fun
'''
import time #不要纠结
def run_time(func):
def new_fun():
t0 = time.time()
print('star time: %s'%(time.strftime('%x',time.localtime())) )
func()
print('end time: %s'%(time.strftime('%x',time.localtime())) )
print('run time: %s'%(time.time() - t0))
return new_fun
@run_time
def test():
for i in range(1,10):
for j in range(1,i+1):
print('%dx%d=%2s'%(j,i,i*j),end = ' ')
print ()
########## 留个映像,用的不是很多
4.类装饰器
@property
装饰过的函数返回的不再是一个函数,而是一个property对象
装饰过后的方法不再是可调用的对象,可以看做数据属性直接访问。
@staticmethod #(静态方法)
把没有参数的函数装饰过后变成可被实例调用的函数,
函数定义时是没有参数的,可以不接收参数
@classmethod (类方法)
把装饰过的方法变成一个classmethod类对象,既能能被类调用又能被实例调用。
注意参数是cls代表这个类本身。而是用实例的方法只能被实例调用。
一般来说,要使用某个类的方法,需要先实例化一个对象再调用方法。
而使用@staticmethod或@classmethod,就可以不需要实例化,直接类名.方法名()来调用。
这有利于组织代码,把某些应该属于某个类的函数给放到那个类里去,同时有利于命名空间的整洁
##类装饰器
class Test_Class():
def __init__(self,func):
self.func = func
def __call__(self):
print('类')
return self.func
@Test_Class
def test():
print('这是一个测试')
test() # self.func : test 函数体
test()()
# 1. @Test_Class : Test_Class( test ) -> 相当于:t = Test_Class( test )# 2. test() -> 相当于: t() 调用实例的call方法 -> 返回 self.func函数体# 3. test()() 调用test()
###python自带3个,类的内置装饰器
class Rectangle:
'''这是一个长方形类,它可以计算面积'''
aaa = 1
def __init__(self,length,width): #构造方法
if isinstance(length,(int,float)) and isinstance(width,(int,float)):
self.length = length
self.width = width
else:
print('请输入int or float')
@property # 可以把方法,当成属性一样调用 , r.area
def area(self):
return self.length * self.width
@staticmethod #静态方法, 不用self了,实例可以直接调用
def func():
print('可以调用吗?')
@classmethod #将实例,还原成了类cls self实例
def show(cls):
print(cls)
print('show fun')
r = Rectangle(2,3)
文章来源: 松勤网
-
讨债公司/蓝月传奇辅助/蓝月辅助(0) 回复 (0)
-
讨债公司 搬家公司 蓝月传奇辅助(0) 回复 (0)