4万字【Python高级编程】保姆式教学，进阶感觉到吃力？学完这些就轻松了_与实例方法的区别是接收的第一个参数不是self,而是cls-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_61083409/article/details/126801606

前几天和一个小伙子聊天时，发现了一个问题，他从零开始学Python，学完列表、字典和函数等基础之后，就开始往爬虫方向进阶学习，结果又花了一个多月的时间，啥也没学成，反而寸步难行。

在这里插入图片描述

其实这个问题的主要原因还是在于Python入门知识没学好，我所说的Python入门知识指的不仅仅是列表等基础知识，还包括面向对象和进程线程等高级编程内容。

这可能是初学者不太清楚该怎么打基础，然后不巧的是所选择的学习资源就没有好好讲高级编程这一块的内容，导致了后面学起来吃力。欲速则不达，所以要往Python爬虫等方向学习的小伙伴们，我个人觉得应当先把入门知识学好。

今天给大家写了一篇关于Python高级编程这一块的教学文章，在你学完了列表等基础之后，学学这一块的内容，将会让你的进阶之路更加轻松顺畅！

先来看一下Python高级编程包括哪些东西：

在这里插入图片描述

一、面向对象编程

（一）面向对象的思想

面向对象是一个抽象的编程思维，很多编程语言都有的一种思想，Python是纯的面向对象的语言，简单来说可以理解为注重如何解决问题，而不是去研究底层怎么实现。

面向对象和面向过程是两种不同的思想，面向对象编程的语言有Python等语言，面向过程编程的语言有C等语言，在写代码的编程思维是不同的。

在这里插入图片描述

举个例子来理解这两种思想，拿洗衣服为例。

用手洗衣服一般是这么干的：找盆-放水-加洗衣粉-浸泡衣服-搓洗-拧干-冲洗-拧干-晾晒。

这是一种面向过程的思想，一旦中间哪个环节不知道怎么办，洗衣服就洗不好，比如说你不知道怎么搓洗导致衣服洗不干净，比如说搓洗完之后没有拧干直接晾晒导致一地水等等，某1个环节出错了，都达不到想要的洗衣服效果。

用洗衣机洗衣服一般是这么干的：打开洗衣机-把衣服放进去-加洗衣粉-按开始按钮-晾晒。

这是一种面向对象的思想，你不用知道把衣服放进去之后洗衣机是怎么洗的，你只要知道把衣服放进去后倒洗衣粉然后按按钮就可以了。

在这里插入图片描述

同样的，在编程语言当中，体现是不一样的，C语言写代码的时候你得关注着你的内存等底层东西，但Python写代码的时候我们几乎很少去关注底层的东西，注重点在于用什么方法去解决问题就可以了。

在正式涉及代码之前，有一段概念性的东西是需要理解的，理解了这些基础概念之后，我们才能更好地进入面向对象编程。

在这里插入图片描述

（二）面向对象的两个重要概念：类和对象

1.对象和类的概念

这两个概念放在一起谈可能更容易理解一些，可以简单理解为类是产生对象的模板。

上面我们说过洗衣机的例子，如果说洗衣机是对象，那么制造这种洗衣机的图纸就是类；如果说鸡蛋是对象，那么母鸡就是类；如果说狗是对象，那么狗类就是类。

在Python中，万物皆对象，变量是对象，函数是对象，字符串、列表、元组等等都是对象。

在这里插入图片描述

2.对象详解

（1）对象的组成：对象=属性+方法

对象是由属性和方法组成的，属性可以理解为对象有什么，方法可以理解为对象能做什么。

（2）对象的属性有哪些特征

对象的属性可以是抽象的属性

比如说洗衣机是一个对象，那么洗衣机是有颜色的，颜色就是1个属性，但颜色是个抽象东西，因为它可以是红色、白色、黑色等等颜色。

对象的属性可以是另一个对象

比如说计算机是1个对象，那么计算机有硬盘，硬盘就是计算机的一个属性，所以说对象的属性可以是另一个对象。

大对象由小对象所组成

比如说鼠标是一个对象，鼠标的滚轮是1个对象，鼠标里面的单片机是1个对象等等，你会发现，鼠标这个大对象是由多个小对象组成。

请添加图片描述

（3）对象的方法

有1个规则先了解一下，对象的方法可以被自己调用，也可以被别的对象调用，后面我会详细讲解。

在对象这里我们暂时不讲代码，因为还要先讲类的知识，才能更好地理解代码里的类和对象，下面会讲到的。

3.类的详解

上面有提到过，类是产生对象的模板，那么类就是对象的抽象化，对象是类的具象化。

既然对象=属性+方法，同样的，类=属性+方法。

（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() ，也同样是利用类创建了对象并调用对象的方法

执行结果：

其实创建Student类的对象时，后面的3行代码还可以写成这样，效果是一样：

Student().learn()	#创类的对象并使用对象的方法
print(Student().age)	#创建类的对象并执行对象的属性

回过头来，我们再从代码和概念结合的角度来理解一下什么是属性和什么是方法。

类属性就是类里面有什么，比如说类里面有name和age，所以name和age是Student这个类的属性。

类方法是类能做什么，比如说类里面有learn(self)这个函数，它能执行“学生的学习方法被调用了”，也就是这个类能执行什么能干什么，所以learn(self)这个函数就是类的方法。

在这里插入图片描述

（1）属性详解

我们前面介绍过对象的属性和类的属性，那么我们来看一下两者的区别和特征。

类属性
1. 类属性定义在类的内部，任何方法之外
  1. 创建类的时候直接创建
  2. 类名.新的属性名=属性值
2. 使用类属性：
  1. 对象.类属性
  2. 类.类属性
3. 类属性的特点：
  1. 类属性是属于类对象的
  2. 对象共用类属性。如果类属性变化，所有的对象也会改变
4. 类属性有且只有一份，牵一发而动全局
对象属性

对象属性定义在方法内部
1. 创建
  1. 对象.实例属性名=属性值
  2. 方法内部创建：self.属性名 = 属性值
2. 使用对象属性
  对象.实例属性名
3. 对象属性各自拥有互相独立
4. 对象属性和类属性发生命名冲突
  1. 以对象属性名优先
  2. 对象属性名会遮蔽同名的类属性

（2）类的方法详解

类方法的声明

def 函数名（self,参数1，参数2，…）
self

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.封装

1.对象都有明确的边界，把属性和方法保护在边界之内。（安全性）

2.封装的力度适中。

3.封装的原则

（1）将不需要对外提供的内容进行隐藏。
（2）隐藏属性，提供公共的方法对其访问
		私有属性：__name="xxx"

2.继承

继承是父类与子类的关系，比如狗类和二哈，狗类就是父类，二哈是子类。

（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()

执行结果为：