对象的独有功能、动静态方法、面向对象三大特性之继承、派生、数据和方法的查找顺序、经典类和新式类

对象的独有功能

针对对象独有的方法，我们无法实现（当我们将函数定义在全局时，不满足对象独有的；当我们定义在类中的时，是类中公共的方法）。python解释器针对这个问题添加了一个特性：定义在类中的函数默认是绑定给对象的(相当于是对象独有的方法)

class Student:
    school = '清华大学'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def course(self,a,b):
        print('选课啦')
    def info1(self):  #
        print(f'{self.name}今年{self.age}')

stu1 = Student('nana',18)
print(stu1.course(1,2))  # 选课啦
print(stu1.info1())  # nana今年18

stu2 = Student('xiao',19)
print(stu2.course(1,1))  # 选课啦
print(stu2.info1())  # xiao今年19

print(Student.course(stu1,2,3))  # 选课啦
print(Student.info1(stu1))  # nana今年18

ps:1.类里面的__init__函数，让对象拥有了独有的数据
   2.定义在类中的函数，我们称为方法，它是多个对象公共的方法，也是多个对象独有的方法，对象来调用就会将对象当做第一个参数传入
   3.类自己调用里面的方法(括号里面有self)时，有几个形参就传几个实参

动静态方法

专门针对在类体代码中的函数有三种：绑定给对象的方法、绑定给类的方法、静态方法

绑定给对象的方法

直接在类体代码中编写即可，对象调用会自动将对象当做第一个参数传入，类调用则有几个形参就传几个实参

class Student:
    school = '清华大学'
    def course(self):
        print('选课啦',self)

stu1 = Student()
stu1.course()  # 选课啦 <__main__.Student object at 0x0000022A799D72B0>
ps: self用于接收对象

绑定给类的方法

类调用会自动将类当做第一个参数传入，对象调用会自动将产生该对象的类当做第一个参数传入

class Student:
    school = '清华大学'
    @classmethod
    def course(cls):
        print('选课啦')
stu1 = Student()
stu1.course()  # 选课啦  >>>course(Student)
Student.course()  # 选课啦   >>>course(Student)

ps:@classmethod 是绑定给类的方法，cls用于接收类

静态方法

无论是类来调用，还是对象调用，都必须按照函数传参的方式传参，一个也不能少

class Student:
    school = '清华大学'
    @staticmethod
    def course(a,b):
        print('选课啦')
        
stu1 = Student()
stu1.course(1,2)    # 选课啦
Student.course(1,2)  # 选课啦

ps:@staticmethod是静态方法

面向对象三大特性之继承

面向对象三大特性有继承、派生、多态

继承概念

1.继承的含义：用来描述类与类之间的数据关系
	eg:类A继承类B，就是类A拥有了类B所有的数据和功能
2.继承的目的：为了节省代码的编写，在python中一个类可以继承多个类

继承 操作

class 类名(类名):
    pass
1.定义类的时候类名后加括号
2.括号内填写你需要继承的类名
3.括号内可以填写多个父类，用逗号隔开
4.知识补充：
	4.1 将被继承的类称之为：父类、基类、超类
	4.2 将继承类的类称之为：子类、派生类
5.实例
class A:
    name = 'a'
class B:
    name = 'b'
class Myclass(A,B):
    pass

print(Myclass.name)  # a
print(Myclass.mro())  # [<class '__main__.Myclass'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>] 
ps:查找的顺序可以用 类名.mro()
   查询继承的父类可以用 类名.__bases__

继承的 本质

1.理解抽象和继承
抽象：将多个共同的数据或功能抽取出来形成一个基类(父类)
继承：可以获取多个基类(父类)的所有方法和数据
2.理解对象、类、父类
对象：是数据和功能的结合体
类：是多个对象相同的数据和功能的结合体
父类：多个类相同的数据和功能的结合体
类和父类最主要的功能就是节省代码

继承的运用

class Student():
    school = '清华'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def choice_course(self):
        print('选课')

1.需求：需要构建一个老师的类，里面有老师的姓名，年龄，以及教授的课程功能
class Teacher():
    school = '清华'
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def teach_course(self):
        print('上课')
2.发现老师和学生对象度需要姓名和年龄，为了节省代码，可以直接将其变为父类，老师和学生类直接继承即可

class Father:
    school = '清华'
    def __init__(self, name, age):
        self.name = name
        self.age = age

class Student(Father):
    def choice_course(self):
        print('选课')

class Teacher(Father):
    def teach_course(self):
        print('上课')

stu1 = Student('nana',18)
print(stu1.__dict__)  # {'name': 'nana', 'age': 18}

teach1= Teacher('xiao',18)
print(teach1.__dict__)  # {'name': 'xiao', 'age': 18}

名字 查找顺序

1.不继承的情况下名字的查找顺序

先从对象自身开始查找，没有的话，再去产生该对象的类中去查找（对象>>>类）

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

stu1 = Student()
print(stu1.__dict__)  # {}
print(stu1.school)  # 清华 >>>自己名称空间没有，所以在类中查找名字
stu1.school = '北大'
print(stu1.school)  # 北大 >>>自己的名称空间里增添了school名字，所以用自己名称空尽力的名字
print(Student.school)  # 清华 >>>对象点名字并写了赋值符号和数据值 那么操作的肯定是自己的名称空间

2.单继承的情况下名字的查找顺序

先从对象自身查找，没有的话，去产生该对象的类中去查找，再去父类中查找（对象>>>类>>>父类）

class A1:
    def func1(self):
        print('from A1 func1')
    def func2(self):
        print('from A1 func2')
        self.func1()  # obj.func1()
class MyClass(A1):
    def func1(self):
        print('from MyClass func1')
obj = MyClass()
obj.func2()
>>>from A1 func2
>>>from MyClass func1

ps:涉及到对象查找名字，几乎要回到最开始的位置依次查找

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

非菱形继承

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

class D:
    name = 'from D'
class E:
    name = 'from E'
class F:
    name = 'from F'
class A(D):
    name = 'from A'
class B(E):
    name = 'from B'
class C(F):
    name = 'from C'
class MyClass(A,B,C):
    name = 'from MyClass'
obj = MyClass()
print(obj.name)
print(MyClass.mro())  >>>查看该类产生的对象名字的查找顺序

菱形继承

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

class G:
    name = 'from G'
class D(G):
    name = 'from D'
class E(G):
    name = 'from E'
class F(G):
    name = 'from F'
class A(D):
    name = 'from A'
class B(E):
    name = 'from B'
class C(F):
    name = 'from C'
class MyClass(A,B,C):
    name = 'from MyClass'
obj = MyClass()
print(obj.name)
print(MyClass.mro())

经典类和新式类

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

1.python2与python3的区别
	在python3中所有的类默认都会继承object，也就是python3里面全是新式类
    在python2中既有经典类，又有新式类，因为经典类没有核心的功能，所以在python3就没有了
2.以后我们在定义的时候，如果没有想要继承的父类，推荐：
	    class MyClass(object):
        	pass
    目的是：兼容python2
3.效果一样
class MyClass:  
	pass
class MyClass(object):
    pass

面向对象三大特性之派生

派生就是子类继承了父类，并且扩展的自己的功能

class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender


>>>需求:教师类想在Person类的基础上扩展职位、授课功能
class Teacher(Person):
    def __init__(self,name,age,gender,job):
        Person.__init__(self, name, age, gender)
        self.job = job
    def teach_course(self):
        print("授课")
teach1 = Teacher('nana',18,'女','讲师')
print(teach1.__dict__)  # {'name': 'nana', 'age': 18, 'gender': '女', 'job': '讲师'}

>>>:python解释器做出优化
class Teacher(Person):
    def __init__(self,name,age,gender,job):
        super().__init__( name, age, gender)
        self.job = job
    def teach_course(self):
        print("授课")
teach1 = Teacher('nana',18,'女','讲师')
print(teach1.__dict__)  # {'name': 'nana', 'age': 18, 'gender': '女', 'job': '讲师'}

ps:super专门用于子类调用父类的方法

标签：__,静态方法,name,self,面向对象,print,age,class,三大
来源： https://www.cnblogs.com/luonacx/p/16525778.html