python学习笔记

今日内容概要

• 对象独有的功能
• 动静态方法
• 面向对象三大特性之继承
• 继承的本质
• 名字的查找顺序
• 经典类与新式类
• 派生方法

今日内容详细

对象独有的功能

class Person:
    h_type = '人类'
    def __init__(self, name):  # 让对象拥有独有的数据
        self.name = name
    # 定义在类中的函数，我们称之为方法
    def eat(self):
        print('%s正在干饭' % self.name)
    def others(self, a, b)
        print('from others')

'''
针对对象独有的方法  我们无法真正实现
1.如果在全局则不是独有的
2.如果在类中则是公共的
python解释器针对上述问题添加了一个非常牛的特性
定义在类中的函数默认是绑定给对象的(相当于是对象独有的方法)
'''

p1 = Person('jason')
p1.eat()  # eat(p1)  jason正在干饭
p2 = Person('kevin')
p2.eat()  # eat(p2)  kevin正在干饭
# 如何理解绑定二字
p3 = Person('oscar')
Person.eat(p3)  # oscar正在干饭

p1 = Person('jason')
p1.others(1, 2) # from others
Person.others(p1,1,2) # from others

动静态方法

类体代码中编写的函数	对象调用	类调用
绑定给对象的方法	对象调用会自动将对象当做第一个参数传入	类调用则有几个形参就传几个实参
绑定给类的方法	对象调用会自动将产生该对象的类当做第一个参数传入	类调用会自动将类当做第一个参数传入
静态方法(普普通通的函数)	按照普普通通的函数传参方式	按照普普通通的函数传参方式

直接在类体代码中编写即可

class Student:
    school = '清华大学'

    # 绑定给对象的方法
    def run(self):  # self用于接收对象
        print('from run', self)

    @classmethod  # 绑定给类的方法
    def eat(cls):  # cls用于接收类
        print('from eat', cls)

    @staticmethod  # 静态方法
    def sleep(a, b):  # 无论谁来调用都必须按照普普通通的函数传参方式
        print('from sleep')


stu1 = Student()
# 调用绑定给对象的方法
Student.run(stu1) # from run <__main__.Student object at 0x0000023FFEE9F310>
stu1.run() # from run <__main__.Student object at 0x0000023FFEE9F310>
# 调用绑定给类的方法
Student.eat()  # 类调用会自动将类当做第一个参数传入    eat(Student)
stu1.eat()  # 对象调用会自动将产生该对象的类当做第一个参数传入  eat(Student)
# 调用静态方法
Student.sleep(1,2) # from sleep
stu1.sleep(1, 2) # from sleep

面向对象三大特性之继承

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

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

• 继承的操作

class 类名(需要继承的类名):
    pass
1.定义类的时候在类名后加括号
2.括号内填写你需要继承的类名
3.括号内可以填写多个父类
逗号隔开即可
"""
我们将被继承的类称之为: 父类或基类或超类
我们将继承类的类称之为: 子类或派生类
ps:平时最常用的就是父类和子类
"""

class MyClass(F1, F2, F3):
    pass
ps: 目前掌握从左到右查找每个父类中的属性即可

继承的本质

抽象:将多个类共同的数据或功能抽取出来形成一个父类

继承:从上往下白嫖各个父类里面的资源

对象:数据和功能的结合体

类:多个对象相同的数据和功能的结合体

父类:多个类相同的数据和功能的结合体

ps:类和父类最主要的功能其实就是节省代码

名字的查找顺序

• 不继承的情况

对象中没有要查找的名称，会去类中查找。

class A:
    cls_A = 'from A'
a = A()
print(a.__dict__)  # 空的
print(a.cls_A)  # from A

对象中有要查找的名称，则输出在对象中的名称。

class A:
    cls_A = 'from A'
a = A()
a.__dict__['cls_A'] = 'from a'  # 在自身的名称空间中产生了新的值
print(a.__dict__)  # {'cls_A': 'from a'}
print(a.cls_A)  # from a
"""对象点名字并写了赋值符号和数据值 那么操作的肯定是自己的名称空间"""

总结：先从对象自己的名称空间中查找，没有则去类里面的名称空间查找

• 单继承的情况

# 父类A
class A:
    def f1(self):
        print('from A.f1')
    def f2(self):
        print('from A.f2')
        self.f1()
# 子类MyClass
class MyClass(A):
    def f1(self):
        print('from MyClass.f1')

obj = MyClass()
obj.f2()  
"""
执行结果：
from A.f2
from MyClass.f1
"""
'''只要涉及到对象查找名字 几乎要回到最开始的位置依次查找'''

总结：先从对象自己的名称空间中查找，没有则取去类中查找，如果还没有并且类有父类则去父类中查找，以此往复下去。

• 多继承的情况

非菱形继承的情况下(最后不会归总到一个我们自定义类上)：

父类中名字的查找顺序就是按照继承时从左往右依次查找，如果多个父类还有分类，那么遵循"深度优先"(每个分支都走到底 再切换)。

菱形继承的情况下(最后归总到一个我们自定义类上)：

父类中名字的查找顺序就是按照继承时从左往右依次查找，如果多个父类还有分类，那么遵循"广度优先"(前面几个分支都不会走最后一个类 最后一个分支才会走)。

总结：父类中名字的查找顺序就是按照继承时从左往右依次查找，如果查找的父类还有个父类，优先查找；如果所有的父类有着共同的父类，那么这个父类会最后查找。

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

注意:主要涉及到对象查找名字 那么几乎都是

对象自身>>>类>>>父类

经典类与新式类

经典类
	不继承object或其子类的类(什么都不继承)
新式类
	继承了object或其子类的类
"""
在python3中所有的类默认都会继承object
	也就意味着python3里面只有新式类
在python2中有经典类和新式类
	由于经典类没有核心的功能 所以到了python3直接砍掉了
	
以后我们在定义类的时候  如果没有想要继承的父类 一般推荐以下写法
    class MyClass(object):
        pass
目的是为了兼容python2
"""
以后写代码针对object无需关心 知道它的存在即可

派生方法

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

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

class Teacher(People):
    def __init__(self,name,sex,age,title): # 派生
        self.name=name
        self.sex=sex
        self.age=age
        self.title=title
    def teach(self):
        print('%s is teaching' %self.name)

obj=Teacher('lili','female',28,'高级讲师') #只会找自己类中的__init__，并不会自动调用父类的
obj.name,obj.sex,obj.age,obj.title
('lili', 'female', 28, '高级讲师')


方法一：“指名道姓”地调用某一个类的函数
class Teacher(People):
    def __init__(self,name,sex,age,title):
        People.__init__(self,name,age,sex) #调用的是函数,因而需要传入self
        self.title=title
    def teach(self):
        print('%s is teaching' %self.name)


方法二：super() 调用super()会得到一个特殊的对象，该对象专门用来引用父类的属性
class Teacher(People):
    def __init__(self,name,sex,age,title):
        super().__init__(name,age,sex) #调用的是绑定方法，自动传入self
        self.title=title
    def teach(self):
        print('%s is teaching' %self.name)

这两种方式的区别是：方式一是跟继承没有关系的，而方式二的super()是依赖于继承的