[7.27]类与面向对象之功能的具体化

学习内容概要

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

内容详细

对象独有的功能

class Person:
    h_type = '人类'  # 公共对象 类和对象都可以调用

    def __init__(self,name):  # 通过传实参的方式 让对象拥有独有的数据
        
        self.name = name  # 左边的name是k 后面的name 传入的数据值
    def ert(self):  # 定义在类中的函数 称之为方法
        print('%s在玩游戏'% self.name)  # 是多个对象公共的方法 也算是对象独有的方法 因为每个对象传入的实参数据不同  来调用的时候 会自动把对象当成第一个参数传入 
    def inner(self,a,b):  # 对象调用此方法时 只要传入两个实参就可以了 ② 类调用时候 需要传入三个实参 并且最好一个参数传入的是对象
        print('来自inner')
 

p1 = Person('make')
print(p2.name)  # jaosn
p1.ert()  # make在玩游戏
Person.ert(p1)  # make在玩游戏

#  利用传入不同的数据 绑定功能 让公共的方法成为对象独有的调用的方法

p2 = Person('jaosn')
print(p2.name)  # jaosn
p2.ert()  # jaosn在玩游戏
Person.ert(p2)  # jaosn在玩游戏

# 调用inner方法
p3 = Person('tony')  
p1.others(1, 2)  # 来自inner  对象调用此方法时 只要传入两个实参就可以了
Person.others(p1,1,2)  # 来自inner  类调用时候 需要传入三个实参 并且最好一个参数传入的是对象



总结 ：
针对对象独有的方法 我们无法真正实现
    1.如果在全局则不是独有的
    2.如果在类中则是公共的
定义在类中的函数默认是绑定给对象的(相当于是对象独有的方法)

动静态方法

• 专门针对在类体代码中变写的函数（方法）

  • 1.绑定给对象的方法

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

    class Person:
        h_type = '人类'
    
        def eat(self):  # self用于接收对象
            print('在不在',self)
            
    p1 = Person()  
    p1.eat()  # 对象调用会自动将对象当做第一个参数传入
    Person.eat(p1)  # 类调用则有几个形参就传几个实参
    
    

  • 2.绑定给类的方法

    class Person:
        h_type = '人类'
    
        @classmethod  # 绑定给类的方法
        def eat(cls):  # cls用于接收类 也是class的缩写
            print('吃不吃',cls)
    
            
    Person.eat()  # 吃不吃 <class '__main__.Person'>
    # 类可以直接调用 不用传参 类调用会自动将类当做第一个参数传入
    p1 = Person()
    p1.eat()  # 吃不吃 <class '__main__.Person'>
    # 对象也可以直接调用方法  对象调用会自动将产生该对象的类当做第一个参数传入
            
    

  • 3.静态方法(普普通通的函数)

  class Person:
      h_type = '人类'
  
      @staticmethod # 静态方法
      def run(a,b):  # 无论谁调用此方法都需要按照普普通通的函数传参方式
          print('跑不跑')
  Person.run(1,2)  # 跑不跑 （类调用 按照方法里的形参的个数 传入相同的个数的实参）
  p1 = Person()
  p1.run(1,2)  # 跑不跑 （对象调用 按照方法里的形参的个数 传入相同的个数的实参）
  

面向对象三大特征之继承

• 面向对象三大特征分别是

  • 继承 、封装 、多态（主要是继承特征常用）

• 1.继承的含义
  在现实生活中继承其实就是用来描述人与人之间资源的关系
  eg:儿子继承父亲的财产(拥有了父亲所有的资源)
  在编程世界里继承其实就是用来描述类与类之间数据的关系
  eg:类A继承类B(拥有了类B里面所有的数据和功能)

• 2.继承的目的

  ​ 现实生活中继承就是拿到别人的财产

  ​ eg：父亲 母亲

  ​ 编程世界里继承就是为了节省代码编写

  ​ eg：可以继承一个类 也可以继承多个类

• 3.继承的操作

  class 类名(类名):
          pass
      
  	1.定义类的时候在类名后加括号
  	2.括号内填写你需要继承的类名
   	3.括号内可以填写多个父类 逗号隔开即可
  	"""
  	我们将被继承的类称之为: 父类或基类或超类
  	我们将继承类的类称之为: 子类或派生类
  	ps:平时最常用的就是父类和子类
  	"""
  	class MyClass(F1,F2,F3):
      pass
  
  ps:从左到右（F1~F3）按照顺序 查找每个父类中的属性即可
  

  ​

继承的本质

抽象	继承
将多个类共同的数据或功能抽取出来形成一个基类	从上（父类）往下（上一层的子类）获取各个基类里面的资源

• 对象：数据和功能的结合体
• 类：多个对象相同的数据和功能的结合体
• 父类：多个类相同的数据和功能的结合体
• ps：类和父类最主要的功能就是为了节省代码

名字的查找顺序

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

  • 注意：先从对象自身查找 没有的话 再去产生该对象的类中查找 （顺序：对象>>>类）

  • 关键字：mro()

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

         
      class Student:
              school = '清华大学'
              def choice_course(self):
                  print('正在选课')
          stu1 = Student()
          print(stu1.school)  # 清华大学 # 对象查找school 自身名称空间没有 所以查找的是类的  清华大学
          stu1.school = '北京大学'  # 在对象自身的名称空间中产生了新的 school 赋的值
          ps：对象点名字并写了赋值符号和数据值 那么操作的肯定是自己的名称空间
          print(stu1.school)  # 北京大学  # 对象查找school 自身名称空间中有 所以值为 北京大学2
          print(Student.school)  # 清华大学   # 在类名称空间中 school 的值还是 清华大学
         
  

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

  • 先从对象自身查找 然后是产生该对象的类 然后是一个个父类（顺序：对象 >>> 类 >>> 父类...）
  • ps:涉及对象查找名字（功能） 每找一次就要回到自己最开始的地方 依次查找 以免遗漏

  class A:
      name = 'from A'
  
  
  class B(A):  # 继承A
      name = 'from B'
  
  
  class C(B):  # 继承B
      name = 'from C'
  
  
  class MyClass(C):  # 继承C
      name = 'from MyClass'
  
  
  
  obj = MyClass()
  obj.name = '我来自obj自己的名称空间'  # ①
  print(obj.name)
  
  """
  过程：
  	打印：  对象 obj.name 时
  	顺序: 1.先在对象自身的名称空间中去找
  		 2.类的名称空间中去找
  		 3.因为类MyClass 继承了 类C 所
  以类MyClass没有 去类C空间中找 依次去B>A
  
  """
  
  顺序：对象 >>> 类 >>> 父类...
  
  
  
  **** 演练：
  
  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.多继承的情况下名字的查找顺序

  • 非菱形继承(最后不会归总到一个我们自定义类上)

  • 深度优先(每个分支都走到底 再切换)

• 菱形继承(最后归总到一个我们自定义类上)

• 广度优先(前面几个分支都不会走最后一个类 最后一个分支才会走)

经典类与新式类

• 经典类

  ​ 不继承object或其子类的类(什么都不继承)

  ​ 在python2中有经典类和新式类
  ​ 由于经典类没有核心的功能 所以到了python3直接砍掉了

• 新式类

  ​ 继承了object或其子类的类

  ​ 在python3中所有的类默认都会继承object
  ​ 也就意味着python3里面只有新式类

• 提醒事项

  ​ 以后我们在定义类的时候 如果没有想要继承的父类 一般推荐以下写法
  ​ class MyClass(object):
  ​ pass
  目的是为了兼容python2

派生方法

• 本质

  在子类中定义 类 与 父类一模一样的方法 并且扩展了该功能 使其功能变的更加强大 这就是派生

• 关键字：super()

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


#
class Teacher(Person):
    def __init__(self, name, age, gender, level, hobby, Height):
        # Person.__init__(self,name,age,gender)  # 先调用父类的方法
        super().__init__(name, age, gender)  # super专门用于子类调用父类的方法
        self.level = level  # 可以补充想添加的数据
        self.hobby = hobby
        self.Height = Height



t1 = Teacher('小伍', 18, 'man', '王者','台球',210)
print(t1.level)  # 王者
print(t1.hobby)  # 台球
print(t1.Height)  # 210