​本篇可乐和大家一起来吃透 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 面向对象。各位同学在学习过程中遇到疑问可以私聊可乐，可乐看到了都会一一回复的。那么下一篇可乐将和大家看一下闭包，装饰器和深拷贝，浅拷贝。谢谢大家的支持~~~

< END>