有人整个 Python 学习生涯都没有搞明白的技术之一：面向对象。
先放美图调整下心情。
欢迎关注，点赞，评论
Python 面向对象的编程
Python 准确地说也是一门面向对象编程的语言，简称 OOP，咱已经知道在 Python 中所有的数据类型都是对象，除了 Python 设置好的以外，Python 允许程序开发者自己定义数据类型，这种由程序员自定的数据类型就是 类。
面向对象初学有门槛，学习请谨慎。
1 类的定义与使用
类的定义语法格式如下：
class MyClass():
代码块
...
代码块
类名的第一个字母建议大写，例如语法格式中的 MyClass。
1.1 定义类、属性与方法
类的内部包含属性与方法，接下来咱定义一个 “人” 类。
# 定义人类
class Person():
# 类的属性
name = "橡皮擦"
# 类的方法
def talk(self):
print("say hello")
在上述代码中，Person 是类名称，在这个类中定义了一个属性与一个方法。类的内部定义方法与函数非常相似，但是注意在类内部定义的函数可不能在称为函数了（是不是开始绕了），要叫做方法，因为只有类的对象才可以调用该方法。 方法定义时注意有一个参数为 self，牢记为固定写法，在所有类内部的方法参数中，都要写上 self 这个关键字。
1.2 属性与方法的调用
在调用属性与方法之前，必须先定义一个类的对象，具体方式如下，这个操作也叫做 实例化，类的实例化操作之后就出现了对象。
对象 = 类名()
例如刚才已经定义好了一个人类，使用下述代码可以获取一个人类的对象。
# 定义对象
xiang = Person()
对象定义完毕就可以使用属性与方法了。
class Person():
# 类的属性
name = "橡皮擦"
# 类的方法
def talk(self):
print("say hello")
xiang = Person()
# 输出对象
print(xiang)
# 输出对象的属性
print(xiang.name)
# 输出对象的方法
xiang.talk()
代码运行之后，输出如下内容。
<__main__.Person object at 0x000002465F364B70>
橡皮擦
say hello
代码中的变量 xiang 就是 Person 类的一个对象，通过 xiang 对象可以读取 Person 类内的 name 属性与 talk 方法。
如果类还有其它的属性与方法，使用相同的方式即可实现。
推荐 ：020 持续更新，精品小圈子每日都有新内容，干货浓度极高。
结实人脉、讨论技术 你想要的这里都有！
抢先入群，跑赢同龄人！（入群无需任何费用）
点击此处，与Python开发大牛一起交流学习。
群号：745895701
申请即送：
Python软件安装包，Python实战教程
资料免费领取，包括 Python基础学习、进阶学习、爬虫、人工智能、自动化运维、自动化测试等
1.3 类的构造函数
难度上在调高一点，建立类的同时希望初始一些数据进去，也就是初始化类，该内容是在类的内部编写一个方法，这个方法是一个特殊的方法，在编程的过程中定义类的对象将自动执行这个方法。
初始化方法名称是固定的 init，该方法在 init 左右各有两个下划线。类的初始化方法称为 构造函数（刚说了类里面叫做方法，自己就叫函数了，是不是迷糊了，这个还真没办法，大家都这么叫）。
接下来编写一个代码，当定义一个类的对象时候，默认给 Person 类的属性 name 赋值。
class Person():
# 类的属性
name = "橡皮擦"
# 构造函数
def __init__(self, in_name):
self.name = in_name
# 类的方法
def talk(self):
print("say hello")
xiang = Person('teacher')
# 输出对象
print(xiang)
# 输出对象的属性
print(xiang.name)
# 输出对象的方法
xiang.talk()
上述代码做了一些简单的变动，首先加入了 init 构造函数，注意构造函数的参数有两个，一个是 self，这个在类内部定义函数的时候是必须的，并且需要放在参数的最左边，Python 在定义一个类的对象的时候会自动传入这个参数 self。self 代表的类本身的对象。
构造函数中还有一个参数 in_name，如果设计了构造函数，并且有除了 self 以外的其它参数，那在定义 Person 对象的时候，必须传递该参数，传递进来的该参数通过 self.name 可以修改对象的属性。
说起来很绕，简单里面就是每次当我们用类定义一个对象的时候，例如下述代码：
obj1 = Person()
obj2 = Person()
上面定义了两个对象，都是依据类 Person 定义的，self 这个参数在类的内部就表示具体是哪个对象。
如果还不理解，没有问题，记住下面的话。
类声明之后，相当于你自己定义了一个数据类型，你可以使用该种数据类型的变量，只是由于面向对象的概念，把这个变量叫做对象了，对象可以调用类的属性和方法，一个类对应多个对象，那如何判断具体是哪个对象在调用类内部的属性或者方法呢，需要用到的就是 self 这个参数。
1.4 属性初始值
在本部分之前，在类内部设定一个初始值，直接用 name = "橡皮擦" 来完成了，学习完构造函数之后，你应该了解到通常在 Python 初始化数据时，一般放在 init 方法内。
class Person():
# 构造函数
def __init__(self, in_name, in_age):
# 属性的初始化
self.name = in_name
self.age = in_age
# 类的方法
def talk(self):
# 类中的属性，在初始化之后可以通过 self.name 调用
print(self.name)
print("say hello")
def show_age(self):
# 通过 self.age 调用初始化的年龄
print(self.age)
xiang = Person('teacher', 19)
# 输出对象
print(xiang)
# 输出对象的属性
print(xiang.name)
# 输出对象的方法
xiang.talk()
2 封装
接下来要学习的是面向对象的三个基本特征之一，封装。
封装简单理解就行，先不要钻进去，理解概念，理解概念。
刚才我们使用的属性与方法都可以通过对象在类的外部访问，这些叫做公有属性与公有方法，但有些时候类内部的属性和方法不希望被外部对象进行修改，需要引入私有属性与私有方法相关概念，这种概念的引入导致了封装概念的出现。
封装就是封住类内部的东西，不叫你随便用（其实是有办法可以调用到的）。
2.1 私有属性
在类内部定义私有属性非常简单，是写作上的技巧，只需要在属性前面加上两个下划线即可，即 __name。
例如在人类中定义一个秘密变量为私有属性。
class Person():
# 构造函数
def __init__(self, in_name, in_age):
# 属性的初始化
self.name = in_name
self.age = in_age
self.__secret = "我有代码洁癖" # 私有属性
# 类的方法
def talk(self):
# 类中的方法，可以访问到私有属性
print(self.__secret)
print("say hello")
def show_age(self):
print(self.age)
xiang = Person('teacher', 19)
# 尝试输出对象的私有属性
print(xiang.__secret) # 报错
# 尝试通过类的方法输出私有属性
xiang.talk()
类的内部初始化好私有属性之后，通过对象.属性名发现无法调用到私有属性，但是在类的内部是可以使用私有属性的，这种操作就叫做封装属性。
2.2 私有方法
有私有属性，必然有私有方法，这两个形式一样的，在方法前面加上两个下划线，就是私有方法了。
class Person():
# 构造函数
def __init__(self, in_name, in_age):
# 属性的初始化
self.name = in_name
self.age = in_age
self.__secret = "我有代码洁癖" # 私有属性
# 类的方法
def talk(self):
# 类中的方法，可以访问到私有属性
print(self.__secret)
print("say hello")
# 类的私有方法
def __show_age(self):
print(self.age)
xiang = Person('teacher', 19)
# 尝试输出对象的私有属性
# print(xiang.__secret) # 报错
# 尝试通过类的方法输出私有属性
xiang.__show_age() # 报错
注意报错的内容，能记住就记住，熟练地找到代码错误的前提就是你碰到的代码错误足够多。
3 继承
学习继承概念以前，有几个新词需要学习一下，首先类是可以继承的，其中被继承的类称为父类或者基类，继承的类称为子类或者衍生类。使用类继承最大的好处就是，父类实现的公有属性或者方法在子类中不用重新设计了。
该内容也是说起来迷糊，先看一下语法格式。
# 定义个父类
class BaseClassName():
父类的代码块
class ChildClassName(BaseClassName):
子类的代码块
继承类的时候，括号内放置父类的名称。
3.1 继承的简单应用
声明一个动物类，然后让狗类继承动物类。动物类有一个公有属性叫做 name，一个公有方法叫做 sleep。
# 定义 Animal 类
class Animal():
def __init__(self):
self.name = "动物名称"
def sleep(self):
print("动物都会睡觉")
# Dog 类继承自 Animal 类
class Dog(Animal):
pass
dog = Dog()
print(dog.name)
dog.sleep()
上述代码中的 Dog 类没有任何属性与方法，只是继承了 Animal 类，就拥有了 Animal 类的公有属性与公有方法。
该继承方式，子类无法直接读取父类的私有属性或者方法，也就是下述代码是错误的。
# 定义 Animal 类
class Animal():
def __init__(self):
self.name = "动物名称"
self.__secret = "秘密"
def sleep(self):
print("动物都会睡觉")
# Dog 类继承自 Animal 类
class Dog(Animal):
pass
dog = Dog()
print(dog.__secret)
dog.sleep()
3.2 子类与父类有相同名称的属性或方法
在程序编写的时候，子类也可以有自己的初始化方法，即 init 方法，在这种情况下会出现子类中的属性名、方法名与父类相同的情况，此时请以子类中的属性值或方法为主。
# 定义 Animal 类
class Animal():
def __init__(self):
self.name = "动物名称"
self.__secret = "秘密"
def sleep(self):
print("动物都会睡觉")
# Dog 类继承自 Animal 类
class Dog(Animal):
def __init__(self):
self.name = "狗"
def sleep(self):
print("狗会睡觉")
# 父类的对象
animal = Animal()
animal.sleep()
# 子类的对象
dog = Dog()
dog.sleep()
该内容如果扩展开来就是面向对象的三大特征的最后一个 -- 多态。
3.3 子类用父类的方法
使用 super 函数可以在子类中调用父类的方法，具体代码如下：
# 定义 Animal 类
class Animal():
def __init__(self, a_name):
self.name = a_name
self.__secret = "秘密"
def sleep(self):
print("动物都会睡觉")
def show(self):
print("现在传递进来的名称为" + self.name)
# Dog 类继承自 Animal 类
class Dog(Animal):
def __init__(self, a_name):
# 调用父类对象的普通方法
# super().sleep()
super().__init__("动物名称" + a_name)
# 父类的对象
animal = Animal("普通动物")
animal.show()
# 子类的对象
dog = Dog("大狗狗")
dog.show()
在 Dog 类的构造函数中通过 super().init("动物名称" + a_name) 修改了传递给父类的参数，此方案相当于通过 super 函数生成一个父类的对象，然后在调用父类的 init 方法，实现对父类的初始化操作。
4 多态
多态简单理解是说父类与子类有相同方法，通过父类、子类创建出的对象调用相同的方法名出现不同的结果。更多时候多态是程序会根据对象自动去调用指定的方法，该内容具体代码实现如下： 首先定义一个函数，这个函数有一个参数即可。
def gogo(obj):
obj.say()
该函数的参数可以为任意数据类型的对象，然后在定义两个类，这两个类中需都存在 say 方法。
class Dog():
def say(self):
print("汪汪汪")
class Cat():
def say(self):
print("喵喵喵")
# 该函数会通过传进的对象进行判断是调用哪个方法。
def gogo(obj):
obj.say()
# 通过 Dog 定义一个对象
dog = Dog()
# 通过 Cat 定义一个对象
cat = Cat()
# 在 gogo 函数中传递 dog 对象
gogo(dog)
# 在 gogo 函数中传递 cat 对象
gogo(cat)
以上代码当传入函数体内部的对象更换时，输出的数据不同，这种编码的形式或者叫编码的设计思路就是多态的一种展示。
简单理解就是 同一方法因对象不同导致实现内容不同。
5 多重继承
上文讲解的都是单一继承关系，在实际编码中很多时候会用到多重继承，就是一个类继承多个父类，语法结构如下：
class 子类名称(父类1,父类2,父类3...):
类的代码块
该内容不再进行扩展开讲解，在多重继承的时候，记住一句话就行，写在前面的父类比写在后面的父类优先级要高，也就说如果父类中都出现了同一个方法，那子类优先选择前面的父类，即上面语法格式中的 父类1。
6 对象的数据类型判断
使用 type 函数可以判断某对象的数据类型，例如下述代码：
class Dog():
def say(self):
print("汪汪汪")
class Cat():
def say(self):
print("喵喵喵")
# 通过 Dog 定义一个对象
dog = Dog()
# 通过 Cat 定义一个对象
cat = Cat()
print(type(dog))
print(type(cat))
输出内容为：
type 可以获取到对象的来源类。
7 isinstance 函数
isinstance 函数可以判断对象是否属于某一个类，语法格式如下：
isinstance(对象,类) # 如果对象是由类实例化而来，返回 True，否则返回 Flase
该函数可以判断出一个对象是否实例化自父类。
# 父类
class Animal():
pass
# 子类
class Dog(Animal):
def say(self):
print("汪汪汪")
# 子类
class Cat(Animal):
def say(self):
print("喵喵喵")
# 通过 Dog 定义一个对象
dog = Dog()
# 通过 Cat 定义一个对象
cat = Cat()
print(isinstance(dog,Dog)) # True
print(isinstance(dog,Animal)) # True
print(isinstance(cat,Animal)) # True
8 特殊属性、方法
在之前的课程中，使用 dir 函数作用于某一对象，会得到如下内容。
该内容存在大量的 XXXX 的内容，这些就是一个对象中特殊的属性与方法。
接下来列举几个。
doc 获取文档字符串
如果一个类中声明了文档字符串，就是在类的开始用 """ 三引号定义了一些内容，例如下述代码：
class Animal():
""""
我是文档字符串，相当于一个类的说明部分，其实我有标准的格式
橡皮擦在第一遍滚雪球的时候，就是不愿意写
"""
pass
animal = Animal()
print(animal.__doc__)
name 属性 这里留下一个思考题，就是自行查阅 name 属性是干啥的，如果理解了，以后看到下面的代码不会问为什么。
if __name__ == '__main__':
执行某些代码
特殊方法部分在第一遍滚雪球的时候，不用费力去学习了，段位还没到，学了和没学一样，如果觉得非学不可，恰好是一个求索知识的机会，这时的学习会事半功倍的。
想学习可以自行找资料，关键词为 str()、repr()、iter()。
9 总结
面向对象，对于编程初学者来说，这个东西学了跟没学一样，你要坚信不只是你无法在第一遍学习的时候就完全掌握，橡皮擦老师一样的，跟橡皮擦老师一起学习的老前辈同学也是一样的，橡皮擦带过的学生也是一样的，大家都一样，99%的人都一样，坚持就对了，先知道在 Python 中也有类，也有对象就够了，时间是学习最大的利器，打卡，打卡，每天学那么一点点，3 个月后见。
最后一碗毒鸡汤
前女友和我分手有两个原因，一是我当时没什么钱，二是她猜到了我将来也不会有什么钱。 O(∩_∩)O 哈哈~
如果你有想要交流的想法、技术，欢迎在评论区留言。