python--继承+多继承+类方法+实例方法
继承
子类调用父类的方法：
self.方法名称()【在子类里面】
类实例.方法名称()【在子类外面】
super()：用来调用父类的方法
python
class Test01:
def __init__(self):
pass
# 定义一个公共方法 test01
def test01(self):
print('Test01 >>> test01')
# 定义一个私有方法 __test02
def __test02(self):
self.test01()
print('Test01 >>> test02')
# 定义一个继承自 Test01 的类 Test02
class Test02(Test01):
# 定义一个公共方法 test03
def test03(self):
print('Test02 >>> test03')
# 调用父类 Test01 的公共方法 test01
self.test01()
if __name__ == '__main__':
# 实例化 Test02 类的对象 a
a=Test02()
# 调用 a 的 test03 方法
a.test03()单继承
python
class A:
def foo(self):
print("father foo")
class B(A):
pass
#实例化B对象b
b = B()
#调用b.foo()方法，输出"father foo
b.foo() # father foo多继承
普通多继承
python
# 案例一、普通多继承
class A:
def foo(self):
print(A)
class B:
def foo(self):
print(B)
class C(A):
pass
class D(B):
pass
# 继承顺序似乎和C、D的顺序有关，要是改成 class E(D, C), 继承顺序又会不一样
class E(C, D):
pass
e = E()
e.foo()
# A
# mro() 或 __mro__ 可以查看继承顺序
print(E.mro())
# [<class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class '__main__.D'>, <class '__main__.B'>, <class 'object'>]
# 即继承顺序是：E->C->A->D->B菱形多继承
python
# 案例二、菱形结构继承
class A:
pass
class B(A):
pass
class C(A):
pass
class D(C,B):
pass
print(D.mro())
# [<class '__main__.D'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
# 即继承顺序是：D->C->B->A
# 说明python的继承不完全是深度优先算法实现，而是采用 C3算法+DFS算法（深度优先）super关键字
super()：用来调用父类的方法
python
class A:
def __init__(self):
print("A")
class B(A):
def __init__(self):
print("B")
super().__init__()
b = B()
# [输出]：
# B
# A方法
实例方法
定义在类中，第一个参数【实例对象】，习惯用self来表示他
self：类实例
调用：实例.方法名()
类方法
定义在类中，通过 @classmethod修饰之后，他就是类方法，第一个参数是类本身，习惯上使用cls来占位，注意与self 的区别
cls：类本身
调用：类名称.类方法() Test01.test02()
类实例.类方法() Test01().test02()
静态方法
定义在类中，通过 @staticmethod修饰后，他就是静态方法，参数可以随便，没有self，cls (类和类实例)
调用：
类名称.类方法() Test01.test03()
类实例.类方法() Test01().test03()
类方法 和 静态方法区别
相同点：
都是挂在类下面，可以通过类直接调用
他们都可以被实例调用
不同点：
类方法可以使用
类的属性，和静态方法静态方法：不可以使用
类的属性和方法使用场景：
当你的类不能重复初始化的时候，就可以使用类方法或者实例方法
装饰器
定义装饰器
python
# 它通过将函数func包装在一个新的函数中来修改其行为
def decorator(func):
# 定义一个新的函数，该函数将被返回
def wrapper(*args, **kargs):
# 打印被装饰的函数的名称
print(func.__name__)
# 返回被装饰的函数的调用结果
return func(*args, **kargs)
# 返回修改后的函数
return wrapper使用装饰器
使用方法1f = decorator(函数名) # 装饰器不传入参数时
f = (decorator(参数))(函数名) # 装饰器传入参数时
f() # 执行被装饰过的函数
使用方法2@decorator # 已定义的装饰器
def f(): # 自定义函数
pass
f() # 执行被装饰过的函数
python
# 使用
@decorator
def function_to_be_decorated():
print("Hello, this is the function to be decorated!")
# 调用被装饰的函数
function_to_be_decorated()自身不传入参数的装饰器
python
def login(func):
def wrapper(*args, **kargs):
# 打印函数名
print('函数名:%s' % func.__name__)
# 调用被装饰的函数
return func(*args, **kargs)
return wrapper
@login
def f():
# 打印函数本身
print('inside decorator!')
# 调用被装饰的函数
f()
# 输出:
# 函数名:f
# 函数本身:inside decorator!自身传入参数的装饰器
python
def login(text):
# 定义一个装饰器，接受一个字符串作为参数
def decorator(func):
# 定义一个装饰器函数，接受一个函数作为参数
def wrapper(*args,**kargs):
# 打印登录信息和函数名称
print('%s----%s'%(text, func.__name__))
# 调用原始函数并返回结果
return func(*args,**kargs)
# 返回装饰器函数
return wrapper
# 返回装饰器
return decorator
@login('this is a parameter of decorator') # 等价于 ==> (login(text))(f) ==> 返回 wrapper
def f():
print('2019-06-13')
f() # 等价于 ==> (login(text))(f)() ==> 调用 wrapper() 并返回 f()
# 输出:
# this is a parameter of decorator----f
# 2019-06-13