4万字Python高级编程保姆式教学，进阶感觉到吃力？学完这些就轻松了
Posted 退休的龙叔
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了4万字Python高级编程保姆式教学，进阶感觉到吃力？学完这些就轻松了相关的知识，希望对你有一定的参考价值。
前几天和一个小伙子聊天时，发现了一个问题，他从零开始学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()
执行结果为：
狗会吃东西
-
子类覆盖了覆盖的方法之后，本质上并没有替换父类的方法，父类的方法依然存在并可以给其他子类调用。
-
方法覆盖的前提：子类的方法名必须和父类的完全相同
（5）方法重载
出现多个方法名一样的方法（函数），Python中通过默认值进行方法重载。
3.多态和多态性
多态：一类事物有多种形态，是一种使用对象的方式，子类重写父类的方法，调用不同的子类对象的相同父类的方法，可以产生不同的效果。
举例：以王者荣耀选英雄为例，英雄类（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"就会产生不同的结果
执行结果为：
一技能跳跃，二技能旋转，大招回血
多态性：向不同的对象发送不同的信息，不同的对象接收到信息后，会做出不同的反应。
#定义鸟类
class Bird:
def fly(self):
print("鸟会飞")
#定义飞机类
class Plane:
def fly(self):
print("飞机会飞")
#定义火箭类
class Rocket:
def fly(self):
print("火箭会飞")
#函数调用父类的fly方法
def fun1(obj):
obj.fly()
fun1(Bird()) #调用鸟类的fly方法
fun1(Plane()) #调用飞机类的fly方法
fun1(Rocket()) #调用火箭类的fly方法
执行结果为：
鸟会飞
飞机会飞
火箭会飞
二、模块与包
👳（一）模块
1.定义
模块指的是Python的程序文件（源文件），模块的文件名就是模块名加上.py，里面包含了Python对象定义和Python语句，模块包含了定义函数、类和执行代码等等，一般情况下不要去修改模块，以免模块失效。
2.模块导入
Python中允许导入的形式来进行模块调用，Python中的模块也是对象，模块中定义的所有全局变量，导入后都成为模块的属性。
语法1： import 模块名
如果要导入多个模块，可以只用1个import来导入多个模块，多个模块之间用逗号隔开即可，但是在Python的PEP8风格里面，不建议这么做，所以要导入几个模块，就写几个import来进行挨个导入。
例子：导入math模块并调用sqrt()开平方的功能对9进行开平方
import math
num = math.sqrt(9)
print(num)
输出结果：
3.0
提示一下，在Python中进行运算操作默认返回的是float类型，所以是3.0。
语法2： from 模块名 import 功能1，功能2
注意这里的功能后面不加括号。
例子：导入math模块并调用sqrt()开平方的功能对9进行开平方
from math import sqrt
num = sqrt(9)
print(num)
输出结果：
3.0
语法3：from 模块名 import
一般情况下，这个语法可以导入模块的所有功能，当你要用某个模块的多个功能的时候，就不用挨个写了，这里我就不举例了，都是一样的。
注意点：
这个方式并非在所有情况下都能导入模块中的所有功能，
如果模块中有__all__=["功能1"，"功能2"]这样的声明,
那么导入的模块只能用功能1和功能2，
如果模块中还有功能3等等功能，但是没有在__all__=[列表]中声明，则无法调用。
例子：(这个例子需要看完下面的自定义模块才看得懂)
新建了1个叫module1的模块，模块代码有2个功能：
def fun1() : #实现a+b并输出结果
print("fun1")
def fun2() : #实现a+b并输出结果
print("fun2")
__all__ = ["fun1"] #声明只能调用fun1()
在另一个Python文件中用语法3的方式导入模块中的所有方法：
from module1 import *
fun1()
fun2()
执行结果只打印出来fun1,然后就报错提示fun2()没有被定义，无法识别，这就是因为
在module1中用__all__声明了可调用的方法只有fun1()。
3.定义别名
有的模块或者模块内的功能名字比较长，多次使用的时候不方便，可以进行自定义模块或者功能的名字。
1.模块自定义别名： import 模块名 as 别名
例子：自定义time模块为别名t并使用。
import time as t
t.sleep(3) #延迟三秒
print("hello world")
程序执行3秒后输出：
hello world
2.功能自定义别名： from 模块名 import 功能名 as 别名
例子：导入time模块并自定义sleep()功能为s这个名字
from time import sleep as s
s(5) #延时5秒
print("hello world")
程序执行5秒后输出：
hello world
4.自定义模块
每个人都能生成自定义模块来进行调用，自定义模块就是Python文件，我们写代码时创建的Python文件就相当于1个模块。
注意点：被调用的模块尽量放在当前Python文件相同目录下，否则导入时要声明所在文件夹才能导入。
例子：自定义1个模块，在另一个Python文件中进行调用。
新建1个名为module1的Python文件，代码如下：
def fun1(a,b) : #实现a+b并输出结果
print(a+b)
相同目录下新建另一个Python文件，调用module1.py这个模块：
import module1
module1.fun1(20,30)
运行当前Python文件结果：
50
5.模块的测试
每个模块导入的时候都默认被执行一遍，但同时在模块内部又存在着很多的内部测试代码，为了避免导入模块时执行了模块内部的测试代码，于是就牵扯到一个方法：
很多模块在内部都有测试方法：
if __name__ == "__main__":
代码1
这个方法能够实现一个功能，在模块中执行的话，就会执行代码1的代码，在其他文件导入该模块的时候，则不会执行代码1的代码，所以一般模块内部的测试都放在了代码1当中。
为什么？神奇的点就在于__name__，它在当前文件中执行的结果是__main__，在其他文件导入时执行的结果是模块名，所以利用这一点，用上if语句就能判断模块执行到底是在当前文件执行还是被导入执行。
举例：
新建1个Python叫module1，作为模块,代码如下：
print(__name__) #打印__name__
执行结果：
__main__
再新建1个Python文件，导入刚才建好的module1.py模块：
import module1
执行结果：
module1
在当前文件的执行和被导入时执行，结果是不一样的，所以它成为了模块的内部测试方法。
注意点：在自定义的模块中，不建议写while循坏，不然导入的过程中一直在执行模块里面的while循坏，可能会跳不出来，也就是一直在导入模块，其他代码执行不到。
👳（二）包
1.定义
包就是将有联系的模块放在同一个文件夹下，并且该文件夹里有“__init__.py”这个文件，这个文件夹就叫做包。
包的特征：
1.包也是对象
2.必须有__init__.py文件
3.__init__.py文件是包的构造方法，控制着包的导入行为，一般是个空包
4.包里面不仅可以有模块，还可以有子包
2.包的创建
在Pycharm软件中新建1个项目文件，创建完成后，打开Pycharm创建1个项目文件夹→点击文件夹→右键弹出选项→New→Python Package→完成创建，创建的新文件夹就是包，里面自动创建了init文件。
3.包的导入
常规导入方法主要有2种。
方法1：import 包名.模块名.目标
方法2：import 包名.子包.模块名.目标
这里所说的目标可以是变量、函数等等对象，具体的在下面会讲到。
4.包的使用
使用形式1：常规使用1
import 包名.模块名
包名.模块名.功能
举例：创建1个包，在另一个.py文件中使用，要求.py文件不包含在创建的包内。
步骤1，打开Pycharm新建一个项目，创建1个包，命名为demo，包里面新建1个.py文件，命名为my_module，代码如下：
a = 100
def fun1():
print("这是1个包")
步骤2，打开另1个.py文件，导入已创建的包
import demo.my_module
print(demo.my_module.a)
demo.my_module.fun1()
执行结果：
100
这是1个包
使用形式2：常规使用2
from 包名 import 模块名
模块名.功能
模块名.变量
举例：我沿用上面已经创建好的demo包，直接在步骤2中修改代码，用这个新方式去导入包并使用。
from demo import my_module
print(my_module.a)
my_module.fun1()
执行结果是一样的：
100
这是1个包
使用形式3：另起别名并使用
import 包名.模块名 as 别名
别名.功能
别名.变量
上面使用形式1中可能有人会发现，导入模块后的使用不太方便，又要包名又要模块名的，能不能简单点？当然可以，直接给包里的模块另起1个缩短的别名，后面直接用别名就可以了。
沿用上面的使用形式1的例子，这里我就不改动步骤1了，我直接在步骤2中进行另起别名。
import demo.my_module as n1 #另起别名为n1
print(n1.a)
n1.fun1()
执行结果：
100
这是1个包
结果是一样的，但如果代码比较长的话，使用别名会方便很多。
当然了，这里也可以用使用形式2的方式导入包并另起别名，使用时用别名就可以了，这个方式我就不举例了，你们自己可以去试试。
使用方式4：导入某个功能
from 包名.模块名 import 功能1
功能1
这里我也沿用已创建好的包，直接在另一个.py文件中进行使用。
from demo.my_module import fun1
fun1()
执行结果：
这是1个包
使用方式5：导入所有功能
在模块导入的时候我们介绍了import * 这个方式去导入模块里面的所有功能，在这里也可以这么入导入包里面的模块的所有功能。
举例，名叫“demo”包里面有1个模块叫“hhhh”，模块的代码如下：
def fun1():
print("这是功能1")
def fun2():
print("这是功能2")
然后我们在另一个.py文件中调用一下;
from demo.hhhh import *
fun1()
fun2()
执行结果:
这是功能1
这是功能2
6.关于all的使用
关于__all__的使用在模块的时候有介绍过，那是控制可以被导入的功能列表，但在包里面，__all__是控制可以被导入
以上是关于4万字Python高级编程保姆式教学，进阶感觉到吃力？学完这些就轻松了的主要内容，如果未能解决你的问题，请参考以下文章
❤️万字Python基础保姆式教学❤️，小白快速入门Python！