面向对象的动静态方法和三大特性之继承

对象独有的功能

针对对象独有的方法，我们无法真正的实现

如果在全局则不是独有的
如果在类中则是公共的
python解释器针对上诉问题添加了一个非常牛的特性:定义在类中的函数默认是绑定给对象的(相当于是对象独有的办法)

class Person:
    h_type = '人类'

    def __init__(self,name):  # 让对象拥有独有的属性
        self.name = name

    # 定义在类中的函数，我们称之为方法
    def eat(self):  # 是对象公有的方法，也算对象独有的方法，对象来调用就被当作第一个参数传入
        print(f'{self.name}正在干饭')

    def others(self,a,b):
        print(f'对象{self.name}调用了此函数')

p1 = Person('jason')
p1.eat()  # jason正在干饭
p2 = Person('oscar')
p2.eat()  # oscar正在干饭
# 如何理解绑定二字
'绑定就是当对象调用类的方法时，含有self参数的函数会自动与对象绑定'
p1.others(1,2)  # 对象jason调用了此函数
Person.others(p2,1,2)  # 对象oscar调用了此函数

动静态方法

动静态方法是专门针对在类体代码中编写的函数，分为如下三种：

绑定给对象的方法：直接在类体代码中编写即可，对象调用会自动将对象当作第一个参数传入

class Student:
    school = '清华大学'
    def __init__(self,name):
        self.name = name
    def run(self):  # self用于接受对象
        print(f'{self.name}快跑！')  # jason快跑！


s1 = Student('jason')
s1.run()

绑定给类的方法(classmethod)：无论是类还是类实例化产生的对象来调用，默认传入的参数都为类

class Student:
    school = '清华大学'
    def __init__(self,name):
        self.name = name


    @classmethod  # 绑定给类的方法
    def run(cls):  # cls用来接受类
        print(f'类{cls}来调用的函数')

p1 = Student('jason')
p1.run()  # 类<class '__main__.Student'>来调用的函数
Student.run()  # 类<class '__main__.Student'>来调用的函数

静态方法(staticmethod):类和对象都可以调用，但无论谁来调用都必须按照普通的传参方式

class Student:
    school = '清华大学'
    def __init__(self,name):
        self.name = name
    @staticmethod  # 静态方法
    def sleep(a,b): # 无论谁来调用都必须正常传参
        print('静态方法')

三大特性之继承

面向对象的三大特性分别是：封装、继承、多态

继承的定义

继承的含义
在现实生活中继承其实就是用来描述人与人之间资源的关系
eg：儿子继承父亲的财产(拥有了父亲所有的资源)
在编程世界里继承其实就是用来描述类与类之间的数据的关系
eg：类A继承类B(拥有了类B里面所有的数据和功能)
继承的目的
现实生活中继承就是想占有别人的财产，而编程世界里继承就是为了节省代码编写
eg：可以继承一个类，也可以继承多个类
继承的操作

class 类名(父类名)：
    pass
1.定义类的时候在类名后加括号
2.括号内填写你需要继承的类名
3.括号没可以填写多个父类，逗号隔开即可

我们将被继承的类称之为：父类或基类或超类
我们将继承类的类称之为：子类或 派生类
而我们平时最常用的就是父类和子类

class F1:
   pass
class F2:
   pass
class F3:
   pass
class MyClass(F1,F2,F3):
    pass
# MyClass类继承了F1,F2,F3父类

继承的本质

抽象：将多个类共同的数据和功能抽取出来形成一个基类
继承：从上往下白嫖各个基类里面的资源

对象：数据与功能的结合体
类：多个对象相同的数据和功能的结合体
父类：多个类相同的数据和功能的结合体
一定要掌握继承的本质，这样以后我们才会在代码中自己定义中子类父类

名字的查找顺序

1.不继承的情况下名字的查找顺序：先从对象自身查找，没有的话，再去产生该对象的类中查找

class Student:
    school = '清华大学'
    def choice_course(self):
        print('正在选课')

s1 = Student()
print(s1.school)  # 清华大学     对象查找school，自身名称空间没有，所以查找的是类的school
s1.school = '北京大学'  # 在自身的名称空间产生了新的school
'对象点名字并写了赋值符号和数据值，那么操作的肯定是自己的名称空间'
print(s1.school)  # 北京大学
print(Student.school)  # 清华大学

查找顺序: 对象 >>> 类
2. 单继承的情况下名字的查找顺序：先从对象自身查找，然后是产生该对象的类，然后是一个个父类

class F1:
   name = 'from F1'
class F2:
   name = 'from F2'
class F3:
   name = 'from F3'
class MyClass(F1,F2,F3):
    name = 'from MyClass'

obj = MyClass()
print(obj.name)
对象  >>>  类  >>> 父类...


class A1:
    def func1(self):
        print('from A1 func1')
    def func2(self):
        print('from A1 func2')
        self.func1()
    def func3(self):
        print('from A1 func3')
class MyClass(A1):
    def func1(self):
        print('from MyClass func1')
obj = MyClass()
obj.func2()
'''只要涉及到对象查找名字，就要回到最开始的位置依次查找'''
"""
输出结果:
    from A1 func2
    from MyClass func1
"""

MyClass类分别继承F1,F2,F3父类，那么查找顺序就按照位置参数的顺序查找

3.多继承的情况下名字的查找顺序

非菱形继承(最后不会归总到一个我们自定义类上):深度优先(每个分支都走到底，再切换)

如图所示，MyClass类继承了父类A、B、C，父类A、B、C分别继承了父类D、E、F,那么就为非菱形继承

菱形继承(最后归总到一个我们自定义的类上)：广度优先(前面几个分支都不会走最后一个类，最后一个分支才会走)

如图所示，MyClass类继承了父类A、B、C，父类A、B、C分别继承了父类D、E、F,然后父类D、E、F分别继承类G那么就为菱形继承

也可以使用类点mro()方法查看该类产生的对象名字的查找顺序

经典类与新式类

经典类：不继承object或其子类的类(什么都不继承)
新式类: 继承了object或其子类的类

在python3中所有的类默认都会继承object，也就意味着python3里面只有新式类
在python2中有经典类和新式类，由于经典类没有核心的功能，所以到了python3直接砍掉了

以后我们在定义类的时候，如果没有想要继承的父类，一般推荐以下写法

class MyClass(object):
    pass
'目的是兼容python2'

派生方法

子类中定义类与父类一模一样的方法并且扩展了该功能

class MyList(list):
    def append(self,obj):
        if obj =='jason':
            raise Exception('jason不能被添加到列表中')
        super().append(obj)

a = MyList()
a.append(11)
a.append(22)
print(a)
a.append('jason')

'派生可以让我们不仅拥有list类的所有功能，同时，我们还可以对某些功能进行过滤扩展。'

posted @ 2022-07-27 16:21 荀飞阅读(38) 评论(0) 编辑收藏举报

刷新页面返回顶部