本篇可乐和大家一起来吃透 Python 的面向对象，类和实例。
面向对象(OOP)
解释：面向对象它是一种编程的思想，将现实事物抽象化为编程对象。
举例说明：喝可乐
① 选择自己根据配方买对应的材料然后制作可乐，最后喝可乐。
② 自己去小卖部直接买可乐喝。
第一种属于面向过程(对应到编程当中，也就是每一个步骤都需要一步一步实现)
第二种就是面向对象，我们并不需要知道每一步是如何实现的，只需要知道最后能够喝可乐即可。
一、类
解释：类是面向对象的重要组成部分，类是对相同特征和行为事物的统称，是一个抽象的概念。
✔ 语法
class 类名:
实际代码
✔ 举例：以人为例子
# 人有眼睛，鼻子，嘴巴这些特征。可以玩电脑，走路这些行为。
# 代码如下：
class Person:
def __init__(self):
self.eyes = "眼睛"
self.nose = "鼻子"
self.mouth = "嘴巴"
def play_computer(self):
print("我会玩电脑")
def walk(self):
print("我会走路")
# self:下面会细讲,并用代码演示
二、对象
解释：对象是类创建出来真实存在的事物，对象又可以称为实例。
✔ 语法
对象名 = 类名()
✔ 举例：以上述人为例子
人是一个抽象的概念，并不能代表实实在在的事物，但是可乐和在座的各位同学都是实际存在的事物，我们都属于人。
class Person:
def __init__(self):
self.eyes = "眼睛"
self.nose = "鼻子"
self.mouth = "嘴巴"
def play_computer(self):
print("我会玩电脑")
def walk(self):
print("我会走路")
# 创建 kele 对象
kele = Person()
2.1 调用对象方法
✔ 语法
对象.方法名(参数)
✔ 举例
class Person:
def __init__(self):
self.eyes = "眼睛"
self.nose = "鼻子"
self.mouth = "嘴巴"
def play_computer(self):
print("我会玩电脑")
def walk(self):
print("我会走路")
# 创建 kele 对象
kele = Person()
kele.play_computer()
# 输出 我会玩电脑
✔ 解释实例方法中的 self 是什么
先上代码
class Person:
def __init__(self):
self.eyes = "眼睛"
self.nose = "鼻子"
self.mouth = "嘴巴"
def play_computer(self):
print("我会玩电脑")
def eye(self):
print(self.eyes)
self.eyes = "卡兹然大眼睛"
print(self.eyes)
kele = Person()
kele.eye()
# 输出结果是 眼睛 卡兹然大眼睛
class Person:
def __init__(self):
self.eyes = "眼睛"
self.nose = "鼻子"
self.mouth = "嘴巴"
def play_computer(self):
print("我会玩电脑")
def eye(self):
pass
kele = Person()
print(kele.eyes)
kele.eyes = "卡兹然大眼睛"
print(kele.eyes)
# 输出 眼睛 卡兹然大眼睛
到这里可能有一部分同学已经明白 self 实际上是个什么东东了，为了更加通俗易懂，可乐再举一个例子：
class Person:
def __init__(self):
self.eyes = "眼睛"
self.nose = "鼻子"
self.mouth = "嘴巴"
def play_computer(self):
print(f"self是{self}")
kele = Person()
kele.play_computer()
print(f"kele是{kele}")
结果：
根据上述两个示例，我们可以知道 self 实际上就是类创建出来的实例对象。
❗ 对象在调用方法的时候不需要手动传 self 值，因为 python 解释器会自动将实例引用传递给 self 。
2.2 获取对象属性
解释：属性就是特征。例如：人的手，人的鼻子，人的身高，人的体重。
✔ 语法
① 对象名.属性名 (这种在类外部使用)
② self.属性名 (这种在类内部使用)
✔ 举例1：还是以人为例子
class Person:
def __init__(self):
self.eyes = "眼睛"
self.nose = "鼻子"
self.mouth = "嘴巴"
def play_computer(self):
print(f"self是{self}")
kele = Person()
print(kele.nose)
# 输出 鼻子
✔ 举例2
class Person:
def __init__(self):
self.eyes = "眼睛"
self.nose = "鼻子"
self.mouth = "嘴巴"
def get_nose(self):
print(self.nose)
kele = Person()
kele.get_nose()
# 输出 鼻子
2.3 修改/设置对象属性
✔ 语法
① 对象名.属性名 = 值 (这种在类外部使用)
② self.属性名 = 值 (这种在类内部使用)
✔ 举例1：依旧以人为例子
class Person:
def __init__(self):
self.eyes = "眼睛"
self.nose = "鼻子"
self.mouth = "嘴巴"
def play_computer(self):
print(f"self是{self}")
kele = Person()
kele.nose = "卡兹然大鼻子"
print(kele.nose)
# 输出 卡兹然大鼻子
✔ 举例2
class Person:
def __init__(self):
self.eyes = "眼睛"
self.nose = "鼻子"
self.mouth = "嘴巴"
def modify_nose(self):
self.nose = "卡兹然大鼻子"
kele = Person()
kele.modify_nose()
print(kele.nose)
# 输出 卡兹然大鼻子
2.4 魔法方法
解释：所谓的魔法方法也就是 python 内部已经提供的方法，他们的表现形式是 xxx 。
2.4.1 魔法方法 init
解释 init 方法它是用于对象生成之后进行初始化的函数，不需要程序员手动调用，python 解释器会在对象创建之后自动调用。
例如：人与生俱来就有嘴巴，鼻子，眼睛。那么我们在构造类的时候，就可以将这些属性放进 init 方法中。
✔ 举例
class Person:
def __init__(self):
self.eyes = "眼睛"
self.nose = "鼻子"
self.mouth = "嘴巴"
print(self.eyes)
kele = Person()
# 输出 眼睛
❗ 他并不需要程序员手动调用。
2.4.2 魔法方法 new
解释：我们之前一直在说对象是由类创建出来的，那么类又是怎么创建出来的呢？就是通过 new 方法，这个方法的功能就是创建对象。
✔ 如何通过 new 方法实现单例
解释：所谓的单例就是一个类创建出来的对象都是相同的。
在默认情况下类创建出来的各个对象都是不一样的，如果我们想一个类创建出来的对象都是一样的，那该怎么做呢？答案就是通过 new 方法。
✔ 类创建不同的对象代码
class Person:
def __init__(self):
self.eyes = "眼睛"
self.nose = "鼻子"
self.mouth = "嘴巴"
kele1 = Person()
kele2 = Person()
print(kele1)
print(kele2)
结果如图：
✔ 单例代码
class Person:
instance = None
def __new__(cls, *args, **kwargs):
if not cls.instance:
cls.instance = super(Person, cls).__new__(cls, *args, **kwargs)
return cls.instance
def __init__(self):
self.eyes = "眼睛"
self.nose = "鼻子"
self.mouth = "嘴巴"
kele1 = Person()
kele2 = Person()
print(kele1)
print(kele2)
先贴出结果：
解释一下代码：
具体代码在下面讲解完继承，类属性，类方法之后就知道什么含义了，可乐先讲一下代码的大致意思：用变量 instance 存储对象的内存地址，开始时只为 None ，当第一个对象创建之后，将该内存地址赋值给 instance 变量，后续的对象创建时判断变量 instance 是否有值了。如果有，那么将之前的对象地址给新对象。这样就保证了，后续的对象都和第一个对象的内存地址一样，即该类创建出来的对象都是同一个。
2.5 类属性
解释：类对象所拥有的属性，该类创建出来的所有对象共享同一个类属性，类属性在内存中只会有一个副本。
✔ 使用场景
如果在一个类中所有的对象都有一个共同的属性，并且这个属性的值是一样的，那么我们就可以将属性设置为类属性，如果这个属性的值每个对象都有其自己的含义，那么我们可以将其定义为实例属性。
✔ 语法
在类里面 属性名 = 值
✔ 举例
class Person:
nose = "鼻子"
def __init__(self, name):
self.name = name
kele1 = Person("可乐1号")
kele2 = Person("可乐2号")
2.5.1 获取类属性
✔ 语法
① cls.属性名 (在类里面)
② 类.属性名 (在类外面)
③ 实例.属性名 (在类外面)
✔ 举例
class Person:
nose = "鼻子"
kele = Person()
print(kele.nose)
print(Person.nose)
# 输出 鼻子 鼻子
2.5.2 修改类属性的值
✔ 语法
① cls.属性名 = 值 (在类里面)
② 类.属性名 = 值 (在类外面)
❗ 不可用实例.属性名 = 值来修改，这个含义代表添加实例属性。
✔ 举例
class Person:
nose = "鼻子"
Person.nose = "卡自然大鼻子"
print(Person.nose)
# 输出 卡自然大鼻子
2.6 类方法
解释：类方法是类对象所拥有的方法，用 @classmethod 来对方法进行修饰。
✔ 使用场景
类方法一般搭配类属性来使用，常常用于对类属性的修改。
✔ 语法
@classmethod
def 类方法名(cls):
✔ 举例
class Person:
nose = "鼻子"
@classmethod
def add(cls):
pass
2.6.1 调用类方法
✔ 语法
① 类.类方法名 (在类外面)
② 实例.类方法名 (在类外面)
③ cls.类方法名 (在类里面)
✔ 举例1
class Person:
nose = "鼻子"
@classmethod
def add(cls, nose):
cls.nose = nose
@classmethod
def update(cls):
cls.add("卡自然大鼻子")
Person.update()
print(Person.nose)
# 输出 卡自然大鼻子
✔ 举例2
class Person:
nose = "鼻子"
@classmethod
def update(cls):
cls.nose = "卡自然大鼻子"
Person.update()
print(Person.nose)
# 输出 卡自然大鼻子
✔ 举例3
class Person:
nose = "鼻子"
@classmethod
def update(cls):
cls.nose = "卡自然大鼻子"
kele = Person()
kele.update()
print(kele.nose)
# 输出 卡自然大鼻子
2.7 静态方法
解释：静态方法可以理解为就是普通的函数，只不过他的作用域限制于类里面，但是和类和实例本身并没有多大的关系，他通过 @staticmethod 来修饰。
✔ 使用场景
如果想定义一个函数，但是该函数和类本身或者实例对象没有多大关系，但是限制于该类中就可以使用静态方法来定义。
✔ 举例
class Person:
@staticmethod
def play_game():
print("可乐打游戏")
kele = Person()
kele.play_game()
# 输出 可乐打游戏
三、面向对象三大特性
特性：封装，继承，多态。
3.1 封装
解释：将代码写到类里面即是封装，并且封装还可以给属性或者方法设置权限。在上述代码中已经使用了封装的特性。
3.2 继承
解释：指的是类当中的从属关系，子类自动拥有父类所有的属性和方法。
❗ 所有的类都默认继承Object类。
3.2.1 单继承
单继承：只继承一个父类。
✔ 举例
class Father:
def __init__(self):
self.name = "可乐家族"
def get_name(self):
print(self.name)
class Son(Father):
pass
son = Son()
son.get_name()
# 输出 可乐家族
3.2.2 多继承
多继承：子类同时继承多个父类。
✔ 举例1
class Father:
def __init__(self):
self.name = "可乐家族"
def get_name(self):
print(self.name)
class Mother:
def __init__(self):
self.name = "妈妈家族"
def get_name(self):
print(self.name)
def add_nose(self):
self.nose = "鼻子"
class Son(Mother, Father):
pass
son = Son()
son.get_name()
# 输出 妈妈家族
✔ 举例2
class Father:
def __init__(self):
self.name = "可乐家族"
def get_name(self):
print(self.name)
class Mother:
def __init__(self):
self.name = "妈妈家族"
def get_name(self):
print(self.name)
def add_nose(self):
self.nose = "鼻子"
class Son(Father, Mother):
pass
son = Son()
son.get_name()
# 输出 可乐家族
❗ 如果继承的父类当中拥有相同的属性或者方法，那么优先继承第一个父类的属性和方法。
3.2.3 mro确认继承顺序
继承顺序：如果一个类继承多个父类，并且继承关系比较复杂，那么我们可以使用内置方法 mro 来确定继承顺序。
✔ 举例
class Father:
def __init__(self):
self.name = "可乐家族"
def get_name(self):
print(self.name)
class Mother:
def __init__(self):
self.name = "妈妈家族"
def get_name(self):
print(self.name)
def add_nose(self):
self.nose = "鼻子"
class Son(Mother, Father):
pass
print(Son.__mro__)
结果如图：
3.2.4 重写父类的方法
继承中，支持子类对父类的方法进行重写。
✔ 举例
class Father:
def __init__(self):
self.name = "可乐家族"
def get_name(self):
print(self.name)
class Mother:
def __init__(self):
self.name = "妈妈家族"
def get_name(self):
print(self.name)
def add_nose(self):
self.nose = "鼻子"
class Son(Mother, Father):
def get_name(self):
print("子类重新方法")
son = Son()
son.get_name()
# 输出 子类重新方法
3.2.5 继承之super
super：子类重写父类方法，但是还需要调用父类的其他方法或同名方法时，使用 super 可以不用关心继承的是哪个父类，在语法上只需要填写子类类名即可。
✔ 举例1
class Father:
def __init__(self):
self.name = "可乐家族"
def get_name(self):
print(self.name)
class Mother:
def __init__(self):
self.name = "妈妈家族"
def get_name(self):
print(self.name)
def add_nose(self):
self.nose = "鼻子"
class Son(Mother, Father):
def get_name(self):
print("子类重新方法")
Mother.get_name(self)
Father.__init__(self)
Father.get_name(self)
son = Son()
son.get_name()
# 输出 子类重新方法 妈妈家族 可乐家族
✔ 举例2
class Father:
def __init__(self):
self.name = "可乐家族"
def get_name(self):
print(self.name)
class Mother:
def __init__(self):
self.name = "妈妈家族"
def get_name(self):
print(self.name)
super(Mother, self).__init__()
super(Mother, self).get_name()
def add_nose(self):
self.nose = "鼻子"
class Son(Mother, Father):
def get_name(self):
print("子类重新方法")
super(Son, self).get_name()
son = Son()
son.get_name()
# 输出 子类重新方法 妈妈家族 可乐家族
❗ super 会自动查找父类，且顺序遵循__mro__顺序,适合单继承使用；
❗ super 只能继承最近的上一级父类,顺序按照__mro__顺序。
3.3 多态
解释：不同的对象，有不同的结果，子类重写父类的方法，并且调用不同的子类的相同父类方法，有不同的结果。
我们先上代码来看：
class Person:
def get_sex(self):
print("人")
class Man(Person):
def get_sex(self):
print("男人")
class Women(Person):
def get_sex(self):
print("女人")
man = Man()
women = Women()
man.get_sex()
women.get_sex()
# 输出 男人 女人
代码解释：
一个 Person 类中有一个父类公共方法 get_sex ，子类 man 和 women 通过重写父类方法，产生不同的效果，这就是多态。那么多态有什么好处呢？多态可以使得代码变得更加灵活，更通用，适应的业务场景多。
到此，我们在本篇中学习了 python 面向对象。各位同学在学习过程中遇到疑问可以私聊可乐，可乐看到了都会一一回复的。那么下一篇可乐将和大家看一下闭包，装饰器和深拷贝，浅拷贝。谢谢大家的支持~~~
