面向对象进阶
1.类属性和对象属性
class Person:
# country是数据属性，对象可以任意调用，也叫类变量
country = "上海"
def __init__(self, name, age):
# name,age 是实例变量
self.name = name
self.age = age
# 函数属性，绑定方法
def show(self):
message = f"{self.country}-{self.name}-{self.age}"
print(message)
print(Person.country) # 上海
p1 = Person("serein",20)
2.对象属性的查找顺序
class Student:
school = '清华大学'
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
def read(self):
print(f'正在读书')
# 实例化类得到类对象
stu = Student(name='serein', age=18, gender='male')
# 对象的属性查找顺序
# 【1】首先从自己本身开始找 从 stu.__dict__ 开始找
# 【2】找不到再去实例化他的类中找 从 Student.__dict__ 开始找
# 【3】别的方法没有初始化过这个属性，并且这个类没有继承其他的类
# 【4】找不到就报错了
# 总结 ： obj(对象) ---> class(类) ---> gender_class(父类) ---> 找不到直接报错
3.类的特殊方法
class Cat():
...
from new_class import Cat
class Animal():
...
class BlackCat(Cat):
...
class People:
'''这是一个People类的注释'''
def __init__(self, name, age):
self.name = name
self.age = age
def run(self):
'''
这是一个注释
:return:
'''
print(f"{self.name} can run!")
def login_auth(func):
def inner():
# 查看函数的名字
print(func.__name__) # index
return func()
return inner
@login_auth
def index():
pass
index()
person = People(name='serein', age=22)
# 类的名字
def check_class_name(class_name):
print(class_name.__name__)
check_class_name(class_name=People)
check_class_name(class_name=Animal)
# 查看类的文档字符串，查看类中的多行注释内容 ('''''' / """""")
def check_class_name(class_name):
print(class_name.__doc__)
check_class_name(class_name=People) # 这是一个People类的注释
check_class_name(class_name=Animal) # None
# 类的字典属性
def check_class_name(class_name):
print(class_name.__dict__)
check_class_name(class_name=People) # 这是一个People类的注释
check_class_name(class_name=Animal) # None
# 查看类定义所在的模块
def check_class_name(class_name):
print(class_name.__module__)
check_class_name(class_name=People) # __main__
check_class_name(class_name=Animal) # __main__
check_class_name(class_name=Cat) # new_class
# 查看当前实例所对应的类
def check_class_name(obj_name):
print(obj_name.__class__)
check_class_name(obj_name=People(name='serein',age=18)) # __main__
check_class_name(obj_name=Animal()) # __main__
check_class_name(obj_name=Cat()) # new_class
4.绑定方法、类方法、静态方法
- 绑定方法，默认有一个self参数，由对象进行调用（此时self就等于调用方法的这个对象）【对象&类均可调用】
- 类方法，默认有一个cls参数，用类或对象都可以调用（此时cls就等于调用方法的这个类）【对象&类均可调用】
- 静态方法，无默认参数，用类和对象都可以调用。【对象&类均可调用】
class Foo(object):
def __init__(self, name, age):
self.name = name
self.age = age
def f1(self):
print("绑定方法", self.name)
@classmethod
def f2(cls, name):
print("类方法", cls, name)
@staticmethod
def f3(name):
print("静态方法", name)
# 绑定方法（对象）
obj = Foo("serein", 20)
obj.f1() # Foo.f1(obj)
# 类方法
Foo.f2('serein') # cls就是当前调用这个方法的类。（类）cls = Foo
obj.f2('serein') # cls就是当前调用这个方法的对象的类。
# 静态方法
Foo.f3('serein') # 类执行执行方法（类）
obj.f3('serein') # 对象执行执行方法
5.总结
# 总结 ： 绑定方法 与 非绑定方法
# 【一】概念上来说
# 绑定方法 ： 就是绑定给某个目标(类或对象)的方法才叫绑定方法
# 非绑定方法：不绑定给某个目标(类或对象)的方法叫非绑定方法
# 【二】调用方式上来看
# 绑定给对象的方法：对象可以任意调用，类可能会受到某些限制
# 绑定给类的方法：类可以任意调用，对象可能会受到某些影响
# 非绑定方法：不受类和对象的限制，可以任意调用
# 【三】定义方式上来看
class Person():
# 【1】绑定给对象的方法：正常我们定义的所有方法都是绑定给对象的方法
# 在定义方法的时候，会自动补全 self
def read(self):
print(self)
# 【2】绑定给类的方法：用装饰器装饰我们想要绑定给类的方法
# 在定义方法的时候，会自动补全 cls
@classmethod
def write(cls):
print(cls)
# 【3】非绑定方法：既不绑定给对象也不绑定给类
# 在定义方法的时候，不会自动补全参数
@staticmethod
def run():
...
# 【四】三种函数的调用
# 【1】绑定给对象的方法
# (1)对象调用
p = Person()
p.read()
# (2)类调用,self的值就是实例化得到的对象
Person.read(Person())
# 【2】绑定给类的方法
# (1)类调用
Person.write()
# (2)对象调用
p = Person()
p.write()
# 【3】静态方法(非绑定方法)
# (1)对象调用
p = Person()
p.run()
# (2)类调用
Person.run()