XX学Python·面向对象

• 面向对象的思维方式

  • 面向对象，是一个编程思想，并不是一项技术，重在理解

  • 面向过程：一步一步的完成功能：自上而下，逐步细化

  • 面向对象：找到或者构造一个可以完成功能的主体：找到实体，功能完备

• 类和对象

  • 类就是一系列拥有相同或相似功能的对象的集合，或者说类就是一系列事物的统称

  • 对象就是类的具体的表现形式

1、手机是对象还是类？  类
2、苹果手机，是对象还是类？  类
3、iPhonex 手机是对象还是类？  类
4、我手里的苹果手机，是对象还是类？  对象

类的定义

• 经典类
  • class 类名：
• 新式类
  • class 类名（父类名）：

# 经典类
# 不由任何类派生,或者说不继承任何类
class student:
    pass  # 为了保证代码结构完整,在类下边必须书写表达式,如没有内容，要使用pass占位
 
# 新式类
# 括号内就是父类,也就是存在一定的继承关系
# 有些地方称其为object的派生类
class teacher(object):
    # pass
    ...  # 为了保障代码结构完整,也可以使用...来进行占位

类的实例化

• 类的实例化又叫做创建对象
• 类中实例化后的对象可以调用类中的方法
• 一个类理论上可以实例化无数个对象
• 格式：对象名 = 类名()

# 定义一个类
class Student(object):
    # 定义方法.定义方式和函数定义类似
    def study(self):
        print('我在听直播课,贼有意思,就是学习非常不努力我也能听懂')
    def eat(self):
        print('我在吃脑白金,补补脑子继续学习')
 
 
# 类的实例化(创建对象)
s1 = Student()
# 我们可以直接打印对象,得到的是其所对应的类和所在的内存地址
print(s1)  # <__main__.Student object at 0x7f9be20848e0>
# 也可以打印对象的类型,就是我们创建对象所使用的类
print(type(s1))  # <class '__main__.Student'>
 
# 实例对象可以调用实例方法
s1.study()
s1.eat()
 
# 理论上类可以创建无数个实例对象
s2 = Student()
print(s2)
 
# 类名的定义要使用大驼峰命名法
# 类名严格区分大小写,类名遵循标识符的命名规则
# class ChineseStudent():
#     pass
#
# s3 = student()  NameError: name 'student' is not defined

self

• self就是将调用方法的实例对象传入方法内部，在方法内部可调用实例的属性和方法

# 在类的内部定义方法的时候,自动传入一个self
# 在调用实例方法时,不需要对self 进行传值
# self到底是什么?有什么用?
class Student(object):
    def study(self):
        # 由于s1和self指向同一块内存空间,所以其必为同一个对象
        # 也就是说在对象调用方法时会将对象本身传入方法内部进行使用
        print(self)  # <__main__.Student object at 0x7fa2654848e0>
        print('我要学习了,谁也不要打扰我,我知道你们为了超过我不择手段,但是没有用')
 
    def eat(self):
        # 可以在方法内部调用实例所拥有的属性或者方法
        print('我要吃饭了吃完就学习')
        self.study()
 
 
# 实例化对象
s1 = Student()
print(s1)  # <__main__.Student object at 0x7fa2654848e0>
s1.study()
s1.eat()
# 方法是定义在类的内部,所有对象共有一个类,所以调用方法的时候,需传入调用方法所使用的对象
 
# s2 调用study方法时所指向的空间和s1无关所以两个对象指向不同的内存空间
s2 = Student()
s2.study()

实例属性的添加和获取

• 在类的外部添加和获取实例属性

  • 添加：对象名.属性名 = 值

  • 获取：对象名.属性名

  • 创建对象后，我们对其中一个对象添加实例属性，其他对象不发生变化

# 定义类
class Person(object):
    def eat(self):
        print('早饭吃了油条和包子,血糖110')
 
 
# 实例化属性
p1 = Person()
# 给p1添加实例属性
p1.name = 'xiaoming'
# 调用实例属性
print(p1.name)  # xiaoming
 
# 如果我们再创建一个对象,其实例属性name是否存在?  不存在
p2 = Person()
p2.age = 18
# AttributeError: 'Person' object has no attribute 'name'
# print(p2.name)
# print(p1.age)
# 结论:对象被创建后,添加实例属性,对其他的对象不产生影响
 
# 如果我们对同一个实例属性添加两次值会怎样?
p1.name = 'Rose'
print(p1.name)
# 如果当前对象的该属性名存在,则重新赋值,如果不存在,则新建一个属性
# 类似于dict
 
# 可以通过__dict__去查询对象的属性,该属性以字典形式保存
# 对象属性保存在一个字典结构空间内,多次赋值会覆盖原来的值,给新的属性赋值,会增加属性数量
class Student(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def __str__(self):
        return f'姓名为{self.name},年龄{self.age}'
 
 
s1 = Student('xx', '18')
print(s1)  # 姓名为xx,年龄18
print(s1.__dict__)  # {'name': 'xx', 'age': '18'}
s1.__dict__ = {'name': 'lsl', 'age': '18'}
print(s1.name)  # 
 
 
# 对象属性删除del
del p1.name
# AttributeError: 'Person' object has no attribute 'name'
print(p1.name)

• 在类的内部添加和获取实例属性

  • 添加：self.属性名 = 值

  • 获取：self.属性名

  • 一般实例属性写在实例方法中，调用该方法才能获取实例属性，对象创建后，其中一个实例调用该方法，获取实例属性，其余对象不发生变化

class Person(object):
    def add_attr(self):
        self.name = 'xiaoming'
        self.age = 18
        self.gender = '女'
 
 
# 实例化对象
p1 = Person()
# 创建完成后,p1的实例属性添加了么?
# AttributeError: 'Person' object has no attribute 'name'\
# print(p1.name, p1.age, p1.gender)
# 为什么没有属性呢?  我们定义的添加实例属性的方法没有被调用
# 所以需要先调用添加实例属性的方法,才能使用实例属性
p1.add_attr()
print(p1.name, p1.age, p1.gender)  # xiaoming 18 女
 
p2 = Person()
# AttributeError: 'Person' object has no attribute 'name'
# 执行方法在第1个对象中添加了实例属性,对第2个不产生影响,如想添加实例属性需再次调用方法
# print(p2.name)
 
# 在类的外部可以修改类内部添加的实例属性么?  可以
p1.name = 'Rose'
print(p1.name)  # Rose
 
# 同一个对象在类的内部和外部添加实例属性 本质上是一样的
# 在类的外部使用对象名,其实使用的是对象的引用地址,在其引用地址位置添加了对应的实例属性
# 在类的内部使用self,其实也代表该应用地址,也是在其应用地址位置添加了对饮的实例属性
 
# 为什么在类的内部要使用self 而不使用对象名?   简便,灵活.复用性高
# 1.每次使用对象不一致,如使用对象名,需每次传入不同对象名或每个对象定义一个方法,不利于代码复用.
# 2.某时在没有将对象赋值给变量的时候,就需要添加其属性,这个时候,没有办法获取对象的名称.

魔术方法

• 一般是系统在特定时机自动调用的函数或方法，绝大多数情况不需要程序员手动调用

# __func__()格式定义的函数或方法，我们自己定义禁用这种方式。
# 以下是系统内置变量，不是函数也不是方法
print(__name__)
print(__file__)

__init__（）方法

• __init__()方法在对象创建完成后，初始化对象时，自动调用

• 在init方法中添加的属性，由于每个对象都会执行该方法，所以都包含该属性，被称之为共有属性

• 在init方法之外添加的属性，由于不是每个对象都拥有，所以被称之为独有属性

• 带参数的__init__()方法

  • init方法在对象被创建时，可将“类名()”这里括号添加的参数传递到init方法内部

  • 在接收到参数时，可以动态给对象添加实例属性

  • 如果init方法添加了参数，那么在创建对象时，必须给其赋值，否则报错

# 每次我们创建对象时,如果使用init方法,是不是只能添加同一个值的属性呢?
# 如果我们能够将参数传递到init方法中,是不是就可以在创建对象时,动态添加属性值了呢?
# 我们怎样给init进行传参呢?
# 在实例化对象时,类名(参数1, 参数2....)这些参数会传递给init方法,进行使用
 
# class Person(object):
#     def __init__(self, name, age):
#         print(name, age)
 
 
# TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'
# p1 = Person()
# 既然我们给init方法中添加了参数,就必须传值,否则就会报错
# 传参的数量,就是init方法中除了self之外的位置参数的数量
# p1 = Person('Jack', 18)  # Jack 18
# 结论: 在Person类创建对象时,在()内添加参数,可被init接收
 
# 怎样实现动态的实例属性添加呢?
class Person(object):
    def __init__(self, name, age):
        # self.属性名 = 参数  将函数外部传递进来的参数赋值给对象,创建实例属性
        self.name = name
        self.age = age
 
 
# 实例化对象时要正确传参
p1 = Person('Rose', 17)
print(p1.name, p1.age)
# 创建第二个对象,查看属性是否动态传递成功
p2 = Person('Jack', 18)
print(p2.name, p2.age)
 
# 在创建对象时可指定其不同对象属性的值不同,但是所有的对象包含的属性类别相同
# 要给每一个对象单独赋值,或给init方法中的属性一些默认值,否则会报错

__str__()方法

• 在类的内部实现__str__()方法，会在我们将对象转换为str类型时自动调用，返回其return内的数据
• str方法内只能返回str类型的数据
• str方法自动调用的场景
  • 强制类型转换： str（对象）
  • 隐式类型转换： %s作为占位符接收对象，或者 print打印等，都会自动调用

# __str__()方法是在数据被转换为str类型时自动调用的方法
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
 
    def __str__(self):
        # 在__str__方法中只能返回字符串类型数据,否则就会报错
        # TypeError: __str__ returned non-string (type int)
        # return 123
        # return None
        return f'我的名字是{self.name}, 我的年龄是{self.age}'
 
 
p1 = Person('Rose', 18)
# 如果我们打印p1会在控制台输出什么?
# 默认会输出对象类型,和内存地址
# print(p1)  # <__main__.Person object at 0x7fb70db848e0>
# 我们如果让其在打印时输出我们想要输出的内容?  重写str方法
 
# 重写str方法后
# 结论:打印p1时,会自动调用__str__()方法
print(p1)  # 我的名字是Rose, 我的年龄是18
 
# 是因为print方法我们才将p1变为我们改写的str方法中的内容么?  不是
# 其实我们再执行print时,会做一次隐式的数据类型转换 也就是使用str(对象)
str1 = str(p1)
print(str1)

__del__()方法

• 对象被释放前，自动执行__del__()方法
• 切断引用或释放对象的几个场景
  • 出了函数作用域后，局部变量被释放
  • 程序执行完成后，所有变量被释放
  • 执行del操作后，可以提前释放变量

# 之前我们学过del操作
# del 变量名  或者  del (变量名)
 
# del操作  可以切断数据和引用位置的联系
# 切断引用后,a 没有引用任何数据,1也没有任何变量引用,所以双双被释放掉
# a = 1
# del a
# print(a)
 
# __del__()方法,在c语言中成为析构函数
# 在对象被释前自动执行该方法,执行后,对象立即被释放
 
# 定义类
# class Person(object):
#     def __init__(self,name, age):
#         self.name = name
#         self.age = age
 
 
# p1 = Person('Rose', 18)
 
# del p1
# NameError: name 'p1' is not defined
# 在这种情况下,我们能否知道p1已经被释放了?  没有提示
# 如果已经被释放了还继续使用,是不是会报错? 会报错
# 我么你怎样去进行提示?  使用__del__()
# print(p1)
 
 
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def __del__(self):
        print('我被释放了,真爽',self.name)
 
 
p1 = Person('Rose', 18)
 
# del p1 # 使用del造成p1被提前释放,在程序结束前将对象释放了
# p1被释放后,我们就接收到了提示,证明p1不存在了,之后就不要使用了
# print(p1)
# 如果没有del操作,则在程序结束后,会将所有的变量进行统一释放
# print('程序结束')
 
# 结论:在对象被释放时,会自动调用__del__方法,使用del操作可提前释放对象,否则在程序结束后,也会将变量统一释放
 
# 如果一个对象,或者说同一块内存空间,被多个变量引用,使用del可以释放么?
# p2 = p1  # p1和p2指向同一内存空间,或者说两个变量引用同一个数据
# del p1
# # 如果只删除p1的引用,对象还被p2引用着,该对象不会被释放,必须切断所有引用,才能正常释放
# del p2
# # 如果将p2的引用也切断了,则对象正常释放
# print('程序结束')
 
 
# 结论:对象被引用时无法释放,除非程序终止,如1个对象被多个变量引用,必将所有引用切断才能正常释放,否则无法释放对象
# 举例:多个主人牵一条狗,如果有一个主人没有撒手,狗也跑不了
p4 = None
def func():
    p3 = Person('xiaoming', 15)
    global p4
    p4 = p3
    print(p3)
 
func()
# 在函数执行完后,出了作用域,会将函数内所有的临时变量释放掉,除非其被外部变量引用
 
print('程序结束')

手机案例

'''
需求:
1.创建phone类  Phone
2.在类中添加方法,  充电   听歌  打电话  玩游戏
3.每个手机都有初始的电量,并且在创建对象时可以手动输入电量
4.充电可以输入充电时长, 充电1小时获得20个单位的电量
5.听歌(15)  打电话(10)  玩游戏(30)都会消耗电量
6.电量0到100,充电到100会结束。使用手机,如果电量不足以支撑完成操作则警告,并自动关机
'''
 
# 分析:
'''
1.在上述需求中有哪些类?  一个 Phone
2.在上述类中有哪些属性(名词)?  一个 电量
3.在上述类中有哪些方法(动词)?  四个  充电  听歌 打电话 玩游戏
4.有哪些数值判断:在使用手机和充电过程中,让电量范围保持在0-100间
'''
 
 
# 定义类
class Phone(object):
    def __init__(self, power):
        if power >= 100:
            self.power = 100
        elif power <= 0:
            self.power = 0
        else:
            self.power = power
 
    def add_power(self, time):
        print(f'充电开始,共充电{time}小时')
        self.power += 20 * time
        if self.power >= 100:
            self.power = 100
            print('充满电了')
        else:
            print(f'充电结束,当前电量为{self.power}')
 
    def music(self):
        print('音乐真好听呀,再来一首大河向东流')
        self.power -= 15
        if self.power > 0:
            print(f'听歌结束,剩余电量为{self.power}')
        else:
            self.power = 0
            print(f'手机没电了赶紧充电吧,别听歌了')
 
    def call(self):
        print('给女朋友打个电话,希望还没睡觉')
        self.power -= 10
        if self.power > 0:
            print(f'电话打完了,成功分手,剩余电量为{self.power}')
        else:
            self.power = 0
            print(f'手机没电了赶紧充电吧,别打电话了')
 
    def play_game(self):
        print('我最爱玩游戏了,每次都赢没办法,就是这么厉害')
        self.power -= 30
        if self.power > 0:
            print(f'游戏打完了,太爽了,我打游戏,舍友打我,剩余电量{self.power}')
        else:
            self.power = 0
            print('手机没电了,赶紧充电吧,别玩游戏了')
 
 
p1 = Phone(20)
p1.music()
p1.call()
p1.play_game()
p1.add_power(4)
p1.add_power(4)
print(p1.power)

封装

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

• 将属性和方法写到类的内部,使实例获得较为全面的功能,且可将属性和方法设置私有权限,保证暴露接口的安全性

• 封装的优点:

  • 可以找到一个对象能够完成所有的功能或者业务,迭代和维护较为方便

  • 可以设置私有属性或方法,提高代码安全性,只暴露想要暴露的接口

  • 可以降低模块或类的使用难度,暴露少量接口即可完成全部功能

• 私有属性,私有方法

  • 当前属性或方法只能在类的内部进行调用,在类的外部无法使用,则称该属性,者方法为私有属性,或私有方法

# 格式:在属性或方法前加上两个下划线  __属性名  或者 __方法名
class Person(object):
    def __drive(self):
        print('我开着小汽车,嘟嘟嘟')
 
    def go_shopping(self):
        self.__drive()
        print('我去购物了')
 
 
p1 = Person()
p1.go_shopping()
 
 
# 如果 我只想使用购物方法, 开车只不过是一个中间方法,不会单独使用
# 暴露多个方法反而让用户不知调用什么方法,故将无用的方法进行私有化,降低类或模块使用难度
# AttributeError: 'Person' object has no attribute '__drive'
# 在类的外部无法调用drive方法,所以私有化成功
# p1.__drive()
# 私有属性或私有方法,也是告诫其他人不要轻易调用
 
# 私有属性
class Women(object):
    def __init__(self, name, age):
        self.name = name
        self.__age = age
 
    def __str__(self):
        # 私有属性和私有方法在类的内部是随意调用的
        return f'我的名字是{self.name}, 我的年龄是{self.__age}'
 
 
w1 = Women('Rose', 45)
print(w1.name)
# AttributeError: 'Women' object has no attribute '__age'
# print(w1.__age)
# 在类的外部添加的属性,不是私有属性,可以在类的外部进行调用
w1.__gender = '女'
print(w1.__gender)
 
# 拓展  使用__dict__查询私有属性
print(w1.__dict__)
# 在类的外部怎么调用私有属性?_类名__私有属性名。在类外部可通过该方法获取私有属性并修改
# 但不要使用,因为如果别人定义了私有属性,大概率是不想让修改
print(w1._Women__age)

• 私有属性的修改和获取方法

# 一般情况下,不会强行调用私有属性和方法,我们会设置get方法和set方法进行调用和修改
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.__age = age
 
    def get_age(self):
        return self.__age
 
    def set_age(self, age):
        self.__age = age
 
 
p1 = Person('Rose', 18)
# 使用get方法,可以直接调用私有属性
print(p1.get_age())
# 在使用set方法时,可以对私有属性进行赋值
p1.set_age(45)
print(p1.get_age())
#结论:使用get,set方法可以对私有属性进行赋值和获取,在类的外部也可以使用他
 
# 为什么花很大力气将其进行私有化,然后又花了更大的力气把数据进行了提取和修改?
class Person1(object):
    def __init__(self, name, age):
        self.name = name
        self.__age = age
 
    # 如果一个数据只能存储数据,无法使用其中的数据,那这个数据存储方案将没有任何意义
    def get_age(self):
        # 需求:获取年龄的时候,为了觉得自己年轻,返回的年龄少5岁,如小于18岁,则说18岁
        age = self.__age - 5
        if age < 18:
            return 18
        else:
            return age
 
    def set_age(self, age):
        # 需求:保存的数据必须是0到100,如果大于100存入100,如果小于0则存入0
        if age > 100:
            self.__age = 100
        elif age < 0:
            self.__age = 0
        else:
            self.__age = age
 
p1 = Person1('Rose', 35)
# 在使用get方法提取数据的时候,可以对提取规则进行指定
print(p1.get_age())
# 使用set方法存入数据的时候,可以对规则进行指定
p1.set_age(115)
print(p1.get_age())
 
# 结论:某些数据,在存入或提取时,需按照指定规则进行加工，这时使用get和set方法极为方便
# 例: 提取手机号或身份证号进行脱敏
# 如：存入数据逻辑存在偏差,如存储性别,0,1和男女,可用set进行规则调整,保证存入数据一致性

继承

# 继承:子类对象可以使用父类中的属性或方法的过程,叫做继承
# 格式: class 子类名(父类名):
# object是所有类的公共父类,基类,顶级类
# 如果使用经典类,或者新式类中括号内什么也不写,其实默认就继承了object
class Person(object):
    pass
 
class Man(Person):
    pass
 
class Boy(Man):
    pass

• 单继承就是某个类只继承自一个父类，同时，继承关系中可以有多级继承

  • 继承过程中，子类可以使用父类的所有非私有属性或方法
  • 如果父类或更高级的父类，实现了init方法，并且进行了参数设定，实例化子类对象时必须传值

• MRO(Method Resolution Order)方法解析顺序，可通过类名.__mro__或类名.mro()获得“类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找到。

# 定义一个Person类
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.__age = age
 
# 定义一个Father类,继承Person
class Father(Person):
    def __sing(self):
        print('我会唱学猫叫,跟我一起来')
 
    def dance(self):
        print('我会跳四小天鹅,就是天鹅还缺仨')
 
# 定义一个Son类,继承Father
class Son(Father):
    def play(self):
        # AttributeError: 'Son' object has no attribute '_Son__sing'
        # 继承父类时,只能继承父类中的非私有属性和方法
        self.__sing()
        self.dance()
 
# 实例化一个Son对象
# TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'
# son继承了father,father继承person,person中书写了init方法的参数,所以此处必须传参
# s1 = Son()
s1 = Son('xiaoming', 12)
# s1继承了父类的属性和方法,Son类中没有书写任何内容,但可调用父类及其父类的父类中的方法
# s1.sing()
# 但是父类中的私有属性或者方法,无法调用
# AttributeError: 'Son' object has no attribute '__age'
# print(s1.__age)
# AttributeError: 'Son' object has no attribute '__sing'
# s1.__sing()
# s1.play()
 
# 查看类的继承链条
# (<class '__main__.Son'>, <class '__main__.Father'>, <class '__main__.Person'>, <class 'object'>)
print(Son.__mro__)

• 多继承：一个子类，继承多个父类的过程就是多继承

  • 在多继承中，子类可以调用多个父类中的非私有方法或者属性

  • 多继承中，如出现同名属性或方法，优先调用继承位置靠前的父类中的方法或属性

• 子类中重写父类方法

  • 子类中重写父类方法，则调用方法时，直接调用子类中的方法，不会调用父类的

  • 重写时只要方法名称相等即可，不需要进行参数的校对

  • 为什么可以重写父类方法，因为在调用方法或者属性时，会按照继承层级依次查找

# 定义一个Person类
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
 
# 定义一个Father类,继承Person
class Father(Person):
    def sing(self):
        print('我会唱学猫叫,跟我一起来')
 
    def dance(self):
        print('我会跳四小天鹅,就是天鹅还缺仨')
 
 
# 定义一个Son类,继承Father
class Son(Father):
    # 需求:在Son执行sing方法时,让他唱一分钱
    def sing(self):
        print('我喜欢唱一分钱, 你自己学猫叫吧')
 
    # 我们进行方法 重写的时候,不需要关注参数,只需方法名相同即可
    def __init__(self):
        pass
 
 
# s1 = Son('xiaoming', 12)
# s1.sing()
 
# 为什么子类中重写了父类方法就不能进行调用了?
# 之前我么讲了__mro__  打印继承顺序,同时其也是方法或属性的调用顺序,例如想使用Son对象调用sing方法,但是不知道sing在哪个类中
# 所以,系统先去当前Son类中查找,查看是否存在sing方法
# 如果存在,则调用,如果不存在,则去父类中 Father中查找,如果Father类中存在sing则调用,如果不存在,则去更高级父类(person)中查找
# 直到查询到object类中,如果依然不存在,则报错
# 所以如果子类中书写了对应的方法,则父类中的同名方法无法被调用
 
# 可不可以让Son类不需要使用name和age就可以创建对象呢? 在Son中重写init方法
s1 = Son()
s1.sing()

• 在子类中调用父类方法

  • super（）.方法名（）

  • 类名.方法名（self）

  • spuer(要从哪一个类的上一级类开始查找，self）.方法名（）

  • 子类调用父类方法时，一般都是想对父类方法进行扩展

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def driver(self):
        print('开车太好玩了 ,10迈,太快了')
 
 
class Father(Person):
    # 如果想在原有父类方法基础上扩展,例如现在需要重写一个init方法
    # 可以接收 name, age ,gender三个属性
    def __init__(self, name, age, gender):
        # 在父类方法中已经添加了name,和age我们可以直接使用
        super().__init__(name, age)
        # 在父类方法的基础上在添加一个子类方法独有的功能
        self.gender = gender
 
    def driver(self):
        print('我要去天安门完,开挖掘机不让我进')
 
    def __str__(self):
        return f'我的姓名是{self.name},我的年龄是{self.age},我的性别是{self.gender}'
 
class Son(Father):
    def driver(self):
        # 调用Person中的dirver
        # TypeError: driver() missing 1 required positional argument: 'self'
        # Person.driver()
        Person.driver(self)
        # 从Father类的上一级类开始查找方法,并进行调用
        super(Father,self).driver()
 
        # 调用Father中的dirver
        super().driver()
        # 格式:super(从哪个类的上一级开始查找,self).方法名()
        # 如果类名是当前类,可以省略括号内的内容
        super(Son, self).driver()
 
# 所有的参数都传递到了Father类中,并且添加为当前对象的属性
print(Father('Jack', 28, '男'))
s1 =Son('xiaoming', 12, '男')
s1.driver()
 
# 子类中调用父类方法的三种方式:
# super().方法名()   # 只能调用当前类的上一级类中的方法或函数
# 类名.方法名(self)  # 所使用的类名,必须在当前类的继承关系中.这种方法可以调用不在类中的类方法，但是不能使用self作为对象出现
# super(要从哪一个类的上级类开始查询,self).方法名()  # 类名必须在继承关系内,如果类名是当前所在的类,则可以将括号内内容省略,就是第一中方式

多态

• 在继承链条中，子类重写父类方法，即多个子类和父类中都拥有同名方法，将其对象传入函数或方法内部，执行相同方法后，所展示的效果完全不同，这种现象叫做多态

class Person(object):
    def driver(self):
        print('开车太好玩了')
 
 
class Father(Person):
    def driver(self):
        print('爸爸要去天安门完,开挖掘机不让进')
 
 
class Mother(Person):
    def driver(self):
        print('妈妈会开小汽车,嘟嘟嘟')
 
 
class Son(Father):
    def driver(self):
        print('儿子会骑自行车,真好玩')
 
 
def go_shopping(who):
    who.driver()
 
 
# 在我调用go_shopping时,可以将什么对象传进来?
p1 = Person()
f1 = Father()
s1 = Son()
m1 = Mother()
go_shopping(p1)  # 开车太好玩了
go_shopping(f1)  # 爸爸要去天安门完,开挖掘机不让进
go_shopping(s1)  # 儿子会骑自行车,真好玩
go_shopping(m1)  # 妈妈会开小汽车,嘟嘟嘟
 
 
# 如果创建一个Monkey对象,能否传入go_shopping并正确执行?
class Monkey(object):
    def driver(self):
        print('猴子在骑自行车')
 
 
# 一个无继承关系的类,存在指定方法,可进行对象的传递,并在方法或函数内使用,但逻辑会有偏差
# 这种语法没问题,但逻辑上有严重偏差的方式叫做"鸭子类型"(扩展,不要求掌握)
monkey1 = Monkey()
go_shopping(monkey1)

面向对象的其他特性

• 类属性:所有对象所共有的属性，在对其修改所有对象的类属性发生了改变
  • 实例属性:每个对象独有的，添加修改实例属性对其他对象不产生影响

# 类属性,有些地方也叫类变量.就是在类中创建的属于所有对象的属性
class Chinese(object):
    # 类属性是所有对象所共有的
    color = 'yellow'
    def __init__(self, name):
        self.name = name
 
 
c1 = Chinese('xiaohong')
c2 = Chinese('xiaohuang')
c3 = Chinese('xiaolv')
 
# 上述三个对象拥有的实例属性是什么?  name
# 他们每个人的实例属性相同么?之间有联系么?  不相同,每个对象间的实例属性互不相关
# 但三个对象的类属性完全相同
print(c1.color)
print(c2.color)
print(c3.color)
# 类属性的获取方式
# 格式1:对象名.类属性名 在实例属性中,不能有与类属性同名的属性,否则不能通过这种方式提取
# 格式2:类名.类属性名  (推荐)
 
# 修改类属性.格式:类名.类属性名 = 值
Chinese.color = 'orange'
# 注意:修改类属性不能使用  对象名.属性名 = 值  这种方式会添加一个实例属性
print(c1.color)
print(c2.color)
print(c3.color)
 
# 类属性使用场景:
# 可以进行计数
# 可以控制或者包含多个对象
class Apple(object):
    apple_list = []
    def __init__(self):
        Apple.apple_list.append(self)
 
    count = 10
    def eat(self):
        Apple.count -= 1
 
a1 = Apple()
a2 = Apple()
a3 = Apple()
a4 = Apple()
 
a1.eat()
a2.eat()
a3.eat()
a4.eat()
print(Apple.count)
print(Apple.apple_list)

• 类方法
  • 在方法内部不需要使用实例属性和实例方法,但要使用类属性或类方法就定义类方法
  • 定义方式：需要在方法上方写@classmethod
  • 在类方法中会自动传入cls，这个参数代表的是当前类本身

class Apple(object):
    num = 10
    def __init__(self):
        self.eat_num = 0
 
    def eat(self):
        self.eat_num += 1  # 每次吃苹果,当前的食用数量加1
        Apple.num -= 1  # 每次吃苹果,让苹果总数 -1
    # 当方法中不适用实例属性和实例方法,只使用到类属性和类方法的时候我们就选择类方法
    # 因为类方法,不需要创建实例去进行调用,可以直接使用类名调用
    @classmethod
    def eat_apple_num(cls):
        # 在类方法中传入的cls即为当前类的类名,cls.num相当于Apple.num
        print(f'一共被吃了{10-cls.num}个,还剩{cls.num}个')
 
# 类方法的调用。格式: 类名.类方法名
Apple.eat_apple_num()
 
# 创建对象
a1 = Apple()
a2 = Apple()
a3 = Apple()
a4 = Apple()
# 吃苹果
a1.eat()
a2.eat()
a3.eat()
a4.eat()
a4.eat()
 
# 调用类方法
Apple.eat_apple_num()
 
# 查看每人吃了几个苹果
print(a1.eat_num)
print(a2.eat_num)
print(a3.eat_num)
print(a4.eat_num)
 
# 类方法可以使用对象调用么?
# a1.eat_apple_num()  不推荐这样使用

• 静态方法
  • 既不依赖于实例，也不依赖于类，这种方法我们就可以定义为静态方法
  • 静态方法中,不会传入self,也不会传入cls.所以在使用静态方法时,静态方法中不要使用类或对象的属性或方法

class Person(object):
    @staticmethod
    def func():
        print('我是一个静态方法')
 
 
Person.func()
# 静态方法就是一个普通函数,放到类内部就是为了封装,方便我们去继承和导入模块
 
# def func():
#     print('我是一个静态方法')
# 一般能定义为函数的内容,都可改写为静态方法,为更好的封装,我们会将其写到类中

• 小案例

class Game(object):
    top_score = 100
 
    def __init__(self, name):
        self.name = name
 
    @staticmethod
    def print_game_info():
        print('游戏信息展示')
 
    @classmethod
    def show_top_score(cls):
        print(f'最高分为：{cls.top_score}')
 
    def start_game(self):
        print(f'{self.name}开始游戏')
 
 
Game.print_game_info()  # 游戏信息展示
Game.show_top_score()  # 最高分为：100
# 实例方法必须使用实例进行调用,使用类调用报错
# Game.start_game() 
# TypeError: start_game() missing 1 required positional argument: 'self'
 
g1 = Game('xx')
g1.start_game()  # xx开始游戏
g1.print_game_info()  # 游戏信息展示。实例可调用静态方法
g1.show_top_score()  # 最高分为：100。实例可调用类方法