day27（继承）

昨日能容回顾

1.面向对象编程思想前戏
 人狗大战
引出一个概念>>>:数据与功能'绑定'
2.编程思想
1.面向过程编程
过程的核心就是流程化 好比在设计流水线 
2.面向对象编程
对象核心就是'整合' 将数据与功能整合到一起，比较适用于流程不固定的业务，eg:游戏人物(王者里面的英雄后羿)
上述两种编程思想没有优劣 只是应用场景不同 ，甚至有些情况下可能是两者的混合使用。
3.类与对象的概念
对象:数据与功能的结合体
类:多个对象相同的数据与功能的结合体
比喻
	多个人对象					人类
	多个狗对象					犬类
在代码中必须要先定义类才能产生对象
4.代码定义类
语法结构
	class 类名:
		公共的数据
		公共的功能
1.class是定义类的关键字
2.类名相当于函数名也可以加括号调用 但是推荐首字母大写用于区分
3.类体代码无需调用就会自动执行并产生一个类的名称空间
查看名称空间的方法>>>:__dict__
"""类获取数据和功能有一个简便的方式>>>:句点符"""
5.代码产生对象
"""如何产生对象:类名加括号"""
类产生的多个对象都可以访问到类中公共的数据和功能
我们将类产生对象的过程叫做对象的'实例化
6.对象的独有数据
__init__如何执行
1.类加括号先产生一个空对象
2.将类括号内的参数和空对象交给__init__执行
	空对象作为第一个参数
3.该方法会给对象添加独有的数据并自动返回对象本身
"""
#形参self说明
	由于第一个参数主要用来接收对象 所以起了一个固定的名字
7.绑定方法
# 在类中定义的函数默认都是绑定给对象使用的
	对象调用会自动将对象当做第一个参数传入
  所以类中定义的函数第一个形参会自动帮你写self

面向对象编程思想前戏

数据与功能的的绑定   《人狗情未了》

编程思想

1.面向过程编程
比较适用于流程固定化的业务
过程核心就是流程化.....
2.面向对象编程
比较适用于流程不固定的业务
对象就是整合  将数据、功能、整合到一起、、
上述两种方法没有优劣之分只是应用场景不一样、、、

类与对象的概念

"""对：象数据功能结合体
类：多个对象相同的数据与功能的结合体
先定义类在定义对象 或者是说在产生对象
比喻"""
'\'	多个人对象					人类

代码定义类

首先了解语法结构
语法结构
	class 类名
		公共数据
		公共功能
1.class是定义类的关键字
2.类名相当于函数名 也可以加括号调用 但是推荐首字母大写  便于区分
3.类替代码是无需调用就会自动执行文件并产生一个类的名称空间
class Student:
	school='老男孩'
	def tescher(self):
	   print('正在嘿嘿嘿')
如何查看名称空间中的名字
print(Student.__dict__)
''以字典形式展示''
如何查看名称空间的名字
print(student.__dict__.get('school'))
print(Student.__dict__['tescher'])

代码产生对象

直接就是类名加括号  (object)
obj1=Student()
类产生的对象都可以访问到类中公共的数据和功能
'类产生对象的过程就是对象实例化'

对象独有的数据

# 推导步骤1  一步步自己手动添加
  obj1.__dict__['name'] = 'jason'
  obj2.__dict__['name'] = 'kevin'
# 推导步骤2  封装成函数减少代码冗余
	def set_info(obj, name):
    obj.__dict__['name'] = name
# 推导步骤3  将函数整合到类体代码中
	class Student:
    def set_info(obj, name):
      obj.name = name
# 推导步骤4  python提供自动出发的方法
	class Student:
    def __init__(obj, name):
      obj.name = name
"""
__init__如何执行
1.类加括号先产生一个空对象
2.将类括号内的参数和空对象交给__init__执行
	空对象作为第一个参数
3.该方法会给对象添加独有的数据并自动返回对象本身
"""
# 形参self说明
	由于第一个参数主要用来接收对象 所以起了一个固定的名字
  	class Student:
      def __init__(self, name):
        obj.name = name

绑定方法

class Student:
	def __dict__(self,name):
	    object1.name=name
	def func(self):
		pass
	def index(self):
		pass
在类中定义的函数默认都是绑定给对象使用的   1.对象调用会自动将对像当作第一个参数传入2.所以类中定义的参数第一个参数会帮你写入self

今日内容详细

动态方法与静态方法

# 动态方法

# 绑定给对象
# class Student:
#     school = '青海湖'
#
#     def run(self):
#         print('正在跑步')
#
#
# obj1 = Student()
# Student.run(123)# 类调用绑定给对象的方法：有几个参数传几个参数
# obj1.run()# 对象调用绑定给对象的方法：会自动将第一个对象当作第一个函数传入
#


# class Student:
#     school='光华大学'
#     # 绑定给对象的方法
#     def run(self):
#         print('阿巴')
#     #     绑定给类的方法
#     @classmethod
#     def eat(cls):
#         print('阿巴阿巴')
# object1=Student()# 类调用绑定给类的方法：会自动将类当作第一个参数传入
# print(Student)
# Student.eat()#对象调用绑定给绑定给类的方法也不需要传参数会将产生对象的类当作第一个参数传入
#静态方法、

class Student:
    school='蓝男孩'
    def run(self):
        print(self)

    @classmethod
    def eat(cls):
        print('阿巴阿巴')
    @staticmethod
    def spek(a):
        print(a)
object1=Student()
#类调用静态方法：要自己传值
Student.spek(1)
# 对象调用静态方法：也要自己穿
object1.spek(123)

面向对象的三大特性之一:继承

面向对象三大特征：继承，封装，多态、
继承含义：
三大对象追重要的一个用的多用的广实际应用性强
继承含义：我们最先想到的就是继承家产
所以这里面有两个关系就很明了
父亲 儿子  
儿子继承了爸爸的江山
用代码来说就是代码A继承了代码B
也就是A继承了B的功能（所有功能数据）
而面向对象中继承则是用来描述类与类之间数据的从属关系  
生活中继承的目的是少奋斗，不用为了生活而太麻烦。
代码里的继承是为了获取功能，减少代码量为了简洁明了
继承的目的
	现实生活中通过继承可以快速的积累财富少奋斗N多年 并且可以多继承
  	eg:可以认多个爹 磅多个富婆
  面向对象中通过继承可以减少代码冗余 提升开发效率 同样也支持多继承
  	eg:类A可以继承多个类同时拥有多个类里面的代码使用权
# 基本继承使用方法
# class Student:  #因为是被继承的类所以可以说是父类 专业名词 基类
#     def get_mony(self):
#         print('月入百万')
#
#
# class S1(Student):#这是继承别人得类  所以称之为子类  专业名词派生类
#     pass
#     # def get_mony(self):
#     #    print('月入十万')
# S1.get_mony(1)
# 继承多个父类    在python中一个类可以同时继承多个父类

class A:
    nameA = 'formA'


class B:
    nameB = 'formB'


class C:
    nameC = 'fromC'


class Myclass(A, B, C):
    pass


print(Myclass.nameA)
print(Myclass.nameB)
print(Myclass.nameC)

继承本质

抽象：由下往上抽取相同特征
继承：由上往下直接白嫖
面向对象编程中  父类的主要功能其实就是来减少代码的冗余     所谓父爱如山在这里就体现了帮你扛下了所有   
对象是数据功能的结合体
类：多个对象相同相同数据功能的结合体
父类：多个类相同的数据和功能结合体

class Fruit:
    def __init__(self,name,weight):
        self.name=name
        self.weight=weight
# # 定义Orange类，继承了Fruit类
class Orange(Fruit):
    def taste(self):
        print(f"我是{self.name}不同水果的口感不同")


# # 定义Banana类，继承了Fruit类
class Banana(Fruit):
    def teste(self):
        print(f"我是{self.name}！重{self.weight}克")
# 创建Orange对象
obj1=Orange('橙子',16)
obj1.taste()
# 创建Banana对象
obj2=Banana('大香蕉',66)
obj2.teste()

名字的查找顺序

不继承的情况下 名字的查找顺序是 先从对象自己的名称空间去查找 没有去类里面找  对象------>到类
只继承一个的情况下  就是单继承
如果对象 ，类都没有就去父类
对象---->类--->父类
经典案例  非常具有迷惑性
  	class A:
      def f1(self):
          print('from A.f1')
      def f2(self):
          print('from A.f2')
          self.f1()  '''以后看到self点东西 一定要问自己self是谁'''
    class MyClass(A):
       def f1(self):
            print('from MyClass.f1')
    obj = MyClass()
    obj.f2()
    # 执行的方法分别是A里面的f2和MyClass里面的f1
死咬概念  然后  对象---->类--->父类
没有就去下一个
 
 
父类的查找顺序就是从左往右
多个父类如果还有分类两种情况
非菱形继承  菱形继承
菱形继承  广度优先  非菱形继承深度优先
''''名字的查找顺序永远都是 先从当前对象自身开始查找'''

派生类

前面所学的几个都是不劳而获
派生类  就是站在不劳而获的这些功能上做一些自己的事 
如果自己写的子类需要使用父类的方法 并且还需要基于该方法做扩展
这样的子类我们称之为派生类(本质还是子类)      
   重点就在 使用super关键字来实现
"""
最近有点想吃水果、、、、

class Fruit:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight


# # 定义Orange类，继承了Fruit类
class Orange(Fruit):
     # 用了Fruit类里面的__init__方法之后
    def __init__(self, name, weight, colour, sweet, sour):
       # 子类调用父类的方法 精简语法
        super().__init__(name, weight)
        #自己还要添加一个额外的东西
        self.colour = colour
        self.sweet = sweet
        self.sour = sour
        print(f"我是{self.name}{self.weight}克是{self.colour}{self.sweet}{self.sour}")


# # 定义Banana类，继承了Fruit类
class Banana(Fruit):
    def __init__(self, name, weight, colour, sweet, sour):
        子类调用父类的方法 精简语法
        super().__init__(name, weight)
        #自己还要添加一个额外的东西
        self.colour = colour
        self.sweet = sweet
        self.sour = sour
        print(f"我是{self.name}！重{self.weight}克")


org = Orange('橙子', 50, '橙色', '不是很甜', '有点酸')
print(org.__dict__)
banna=Banana('香蕉',123,'黄色','甜','不酸')
print(banna.__dict__)

、print之后的结果
我是橙子50克是橙色不是很甜有点酸
{'name': '橙子', 'weight': 50, 'colour': '橙色', 'sweet': '不是很甜', 'sour': '有点酸'}
我是香蕉！重123克
{'name': '香蕉', 'weight': 123, 'colour': '黄色', 'sweet': '甜', 'sour': '不酸'}

派生功能前瞻

class MyClass(list):
    def append(self,args):#先找对象本身  在找产生对象的类
        if args == 123:
            print('数字123不能追加')
            return
#关键字 （super） super(MyClass, self).append(args)
obj1 = MyClass()
obj1.append(333)
obj1.append(222)
obj1.append(123)
print(obj1)