当前位置 博文首页 > 关注我：??Python面向对象保姆式教学??，新手速成精英之路！
我决定了，出一期Python教学专栏博客，为每个想学Python的新手提供系统性、实用性、教学型的博客学习系列文章，主要知识板块包括以下几个方面：
这些都是Python新手入门都绕不过的知识板块，没有它们你直接去学爬虫等方向你会一脸懵逼的，相反地，如果你掌握了它们之后，你去选择Python的任何方向进行进阶都是没有问题的。
【Python新手入门专栏】
【正则表达式】的内容我在之前已经出过了，感兴趣可以去看看，今天的内容是【面向对象编程】。
不积跬步无以至千里，不积小流无以成江海，一个一个板块的知识积累，早晚你也会成为你羡慕的那种人，接下来就是正式的内容了。
面向对象是一个抽象的编程思维，很多编程语言都有的一种思想，Python是纯的面向对象的语言，简单来说可以理解为注重如何解决问题，而不是去研究底层怎么实现。
面向对象和面向过程是两种不同的思想，面向对象编程的语言有Python等语言，面向过程编程的语言有C等语言，在写代码的编程思维是不同的。
举个例子来理解这两种思想，拿洗衣服为例。
用手洗衣服一般是这么干的：找盆-放水-加洗衣粉-浸泡衣服-搓洗-拧干-冲洗-拧干-晾晒。
这是一种面向过程的思想，一旦中间哪个环节不知道怎么办，洗衣服就洗不好，比如说你不知道怎么搓洗导致衣服洗不干净，比如说搓洗完之后没有拧干直接晾晒导致一地水等等，某1个环节出错了，都达不到想要的洗衣服效果。
用洗衣机洗衣服一般是这么干的：打开洗衣机-把衣服放进去-加洗衣粉-按开始按钮-晾晒。
这是一种面向对象的思想，你不用知道把衣服放进去之后洗衣机是怎么洗的，你只要知道把衣服放进去后倒洗衣粉然后按按钮就可以了。
同样的，在编程语言当中，体现是不一样的，C语言写代码的时候你得关注着你的内存等底层东西，但Python写代码的时候我们几乎很少去关注底层的东西，注重点在于用什么方法去解决问题就可以了。
在正式涉及代码之前，有一段概念性的东西是需要理解的，理解了这些基础概念之后，我们才能更好地进入面向对象编程。
这两个概念放在一起谈可能更容易理解一些，可以简单理解为类是产生对象的模板。
上面我们说过洗衣机的例子，如果说洗衣机是对象，那么制造这种洗衣机的图纸就是类；如果说鸡蛋是对象，那么母鸡就是类；如果说狗是对象，那么狗类就是类。
在Python中，万物皆对象，变量是对象，函数是对象，字符串、列表、元组等等都是对象。
（1）对象的组成： 对象=属性+方法
对象是由属性和方法组成的，属性可以理解为对象有什么，方法可以理解为对象能做什么。
（2）对象的属性有哪些特征
比如说洗衣机是一个对象，那么洗衣机是有颜色的，颜色就是1个属性，但颜色是个抽象东西，因为它可以是红色、白色、黑色等等颜色。
比如说计算机是1个对象，那么计算机有硬盘，硬盘就是计算机的一个属性，所以说对象的属性可以是另一个对象。
比如说鼠标是一个对象，鼠标的滚轮是1个对象，鼠标里面的单片机是1个对象等等，你会发现，鼠标这个大对象是由多个小对象组成。
（3）对象的方法
有1个规则先了解一下，对象的方法可以被自己调用，也可以被别的对象调用，后面我会详细讲解。
在对象这里我们暂时不讲代码，因为还要先讲类的知识，才能更好地理解代码里的类和对象，下面会讲到的。
上面有提到过，类是产生对象的模板，那么类就是对象的抽象化，对象是类的具象化。
既然 对象=属性+方法，同样的，类=属性+方法。
（1）创建类
创建类的方法：
class 类名：
属性1
属性2
方法1
方法2
#1个类中可以有多个属性和方法，也可以只有属性或者只有方法
举例，创建1个学生类，并使用它创建对象
#创建Student类
class Student:
name = "小明" #学生类的name属性
age = 18 #学生类的age属性
def learn(self): #学生类的learn方法
print("学生的学习方法被调用了")
#创建Student类的对象
s1 = Student() #Student()就是创建的1个类对象，只是便于简写，我把它传给了s1
s1.learn() #对象的方法
print(s1.age) #执行对象的属性
#上面这两行代码其实可以直接写成Student().learn() ，也同样是利用类创建了对象并调用对象的方法
执行结果：
学生的学习方法被调用了
18
其实创建Student类的对象时，后面的3行代码还可以写成这样，效果是一样：
Student().learn() #创类的对象并使用对象的方法
print(Student().age) #创建类的对象并执行对象的属性
回过头来，我们再从代码和概念结合的角度来理解一下什么是属性和什么是方法。
类属性就是类里面有什么，比如说类里面有name和age，所以name和age是Student这个类的属性。
类方法是类能做什么，比如说类里面有learn(self)这个函数，它能执行“学生的学习方法被调用了”，也就是这个类能执行什么能干什么，所以learn(self)这个函数就是类的方法。
我们前面介绍过对象的属性和类的属性，那么我们来看一下两者的区别和特征。
1. 类属性定义在类的内部，任何方法之外
1. 创建类的时候直接创建
2. 类名.新的属性名=属性值
2. 使用类属性：
1. 对象.类属性
2. 类.类属性
3. 类属性的特点：
1. 类属性是属于类对象的
2. 对象共用类属性。如果类属性变化，所有的对象也会改变
4. 类属性有且只有一份，牵一发而动全局
对象属性定义在方法内部
1. 创建
1. 对象.实例属性名=属性值
2. 方法内部创建：self.属性名 = 属性值
2. 使用对象属性
对象.实例属性名
3. 对象属性各自拥有互相独立
4. 对象属性和类属性发生命名冲突
1. 以对象属性名优先
2. 对象属性名会遮蔽同名的类属性
def 函数名（self,参数1，参数2，....）
1.self默认传递，不需要传值
2.self指代的是当前的实例（对象）
3.一定会有self传递，但名字不一定必须叫self，可以叫aa
4.self后面可以跟多个参数，用“，”隔开
1.对象.方法名（自动传递对象），例如 s2.fun1()
2.类名.方法名（类名（）） #“类名（）”相当于创建对象
注：方法的调用与函数类似，谁调用就返回给谁
def __init__():
1.这个方法不需要被调用，只要创建对象就会自动执行
2.这个方法只能返回None值，无法返回其他类型的值
3.如果要给init传递多个参数，只能通过 类名（多个参数） 的方式去传递
4.如果类里面没有定义init，默认去调用父类
5.如果类里面重复定义了多个init方法，会被最后一个init方法覆盖
举例：创建对象，查看默认执行的init并传递多个值；调用1个类的方法，确认该方法被调用并执行传递的值。
#创建类
class Student:
name = "小莫"
age = "18"
def __init__(self,aa,bb):
print("init被调用了")
print(aa)
print(bb)
def fun1(self):
print("函数1")
print(self)
def fun2(self):
print("函数2")
Student.fun1(Student(100,200)) #创建对象并传递多个值给init
执行结果为：
init被调用了
100
200
函数1
<__main__.Student object at 0x000001DAD8168400> #self值的存储地址
三大特性：封装、继承、多态。
1.对象都有明确的边界，把属性和方法保护在边界之内。（安全性）
2.封装的力度适中。
3.封装的原则
（1）将不需要对外提供的内容进行隐藏。
（2）隐藏属性，提供公共的方法对其访问
私有属性：__name="xxx"
继承是父类与子类的关系，比如狗类和二哈，狗类就是父类，二哈是子类。
（1）定义形式（类的完整形式）
class 子类的类名（父类的类名）：
属性
方法
（2）父类：基类，超类
object————顶层类
如果对象没有书写继承关系，默认继承object
（3）继承的特点
举例：用子类创建的对象调用父类的属性和方法
# 定义父类
class A:
name1 = "父类的属性1"
def aa(self):
print("父类的方法1")
# 定义子类
class B(A):
name2 = "子类的属性1"
def bb(self):
print("子类的方法1")
n = B()
print(n.name2) #调用子类的属性
n.bb() #调用子类的方法
print(n.name1) #调用父类的属性
n.aa() #调用父类的方法
执行结果为：
子类的属性1
子类的方法1
父类的属性1
父类的方法1
可扩展性。父类扩展了，子类也得到扩展。
如果子类没有构造方法，对象会去调用父类的。
如果子类有自己的构造方法，则不会去调用父类的。
子类的构造方法可以调用父类的构造方法，调用可以有以下两种方式：
父类的类名.__init__(self) #手动传递self
super().__init__() #不需要加self
一个子类可以继承多个父类。
# 定义父类A
class A:
name_a = "父类A的属性1"
def aa(self):
print("父类A的方法1")
# 定义父类B
class B:
name_b = "父类B的属性1"
def bb(self):
print("父类B的方法1")
#定义子类C
class C(A,B): #继承两个父类
pass #跳过
n = C()
print(n.name_a)
print(n.name_b)
n.aa()
n.bb()
执行结果为：
父类A的属性1
父类B的属性1
父类A的方法1
父类B的方法1
注：多继承有好有坏，优点是增强了可拓展性，缺点则是继承关系复杂之后容易混乱逻辑，难看懂，同时也会占用大量资源，比如著名的钻石继承问题，主要涉及mro和C3算法，不懂的可以百度一下。
（4）方法覆盖
#定义父类
class Animal:
def eat(self):
print("动物会吃东西")
#定义子类狗
class dog(Animal):
def eat(self):
print("狗会吃东西")
d = dog()
d.eat()
执行结果为：
狗会吃东西
子类覆盖了覆盖的方法之后，本质上并没有替换父类的方法，父类的方法依然存在并可以给其他子类调用。
方法覆盖的前提：子类的方法名必须和父类的完全相同
（5）方法重载
出现多个方法名一样的方法（函数），Python中通过默认值进行方法重载。
粉丝专属福利
多态：一类事物有多种形态，是一种使用对象的方式，子类重写父类的方法，调用不同的子类对象的相同父类的方法，可以产生不同的效果。
举例：以王者荣耀选英雄为例，英雄类（Hero）为父类，该父类中有一个方法叫stroke(技能)；程咬金和后裔分别为两个子类，两个子类中也有stroke这个方法；调用者为另一个父类，有一个选择英雄的方法，该方法需要调用stroke这个类方法，最后调用不同的子类（程咬金或后裔）对象，得到不同的技能描述。
#定义父类Hero
class Hero :
def stroke(self): #技能函数
print("英雄技能")
#定义子类程咬金
class ChengYaoJin(Hero):
def stroke(self): #技能函数
print("一技能跳跃，二技能旋转，大招回血")
#定义子类后裔
class HouYi(Hero):
def stroke(self): #技能函数
print("一技能多发，二技能射圈，大招大鸟眩晕")
#定义调用者
class Person:
def chose_hero(self,hero): #玩家选择英雄
hero.stroke()
c = ChengYaoJin() #程咬金
x = HouYi() #后裔
p = Person() #玩家
p.chose_hero(c) #玩家选择程咬金，"c"换成"x"就会产生不同的结果
执行结果为：
一技能跳跃，二技能旋转，大招回血
