学习Python全套代码【超详细】Python入门、核心语法、数据结构、Python进阶

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Python全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Python知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024c （备注Python）

正文

	- 3.2.3 遍历元组
	- 3.2.4 综合案例：销售数据统计-销冠
+ 第三节 列表 list
+ - 3.3.1 定义列表
	- 3.3.2 增删改查
	- 3.3.3 列表函数
	- * insert
		* pop
		* remove
		* clear
		* extend
		* reverse
		* sort
		* copy
	- 3.3.4 列表表达式
	- 3.3.5 综合案例-销售数据统计-排行榜
+ 第四节 字典 dict
+ - 3.4.1 字典的定义
	- 3.4.2 增删改查
	- 3.4.3 遍历字典
	- 3.4.4 字典函数
+ 第五节 集合 set
+ - 3.5.1 集合的定义
	- 3.5.2 遍历集合
	- 3.5.3 增删改查
	- 3.5.4 集合函数

• 第四部分 Python进阶
• • 第一节 函数
    • • 4.1.1 函数定义及调用
        • 4.1.2 函数的参数
        • 4.1.3 函数的返回值
        • 4.1.4 匿名函数
    • 第二节 面向对象
    • • 4.2.1 面向对象基本概念
        • 4.2.2 类和实例
        • 4.2.3 对象的属性与方法
        • 4.2.3 类属性与方法
        • 4.2.4 一切皆对象
        • 4.2.5 综合案例-电商购物车商品统计分析
        • 4.2.6 自定义属性-property
    • 第三节 模块和包管理
    • • 4.3.1 模块的导入
        • 4.3.2 自定义模块
        • 4.3.3 常用内置模块
• 结束语

本篇文章的目标

通过本篇文章的学习，带你养成编程思维，掌握Python所有的基础语法。

而且，看完就完完全全可以说自己会Python了！

第一部分 Python入门

第一节 Python语言介绍

Python是世界上最流行的编程语言，已经连续多年占据各种语言的排行榜第一位。（当然不是所有榜单）

在各个领域都有着广泛应用，包括数据分析、服务器开发、运维开发、人工智能开发，甚至少儿编程也开始学习Python。

这也不经让无数程序猿朋友感叹：人生苦短，我用Python！

而关于Python的发展历史，这里我不会详细讲解，就放一张创始人的照片吧！

Python语言创始人

Java语言创始人

C++语言创始人

JavaScript语言创始人

Go语言创始人

看完各个编程语言的创始人，选什么语言不用我多说了吧（手动狗头）

第二节 Python安装及配置

1.2.1 Python版本介绍

Python目前有两个版本共存，Python 2 和 Python 3，其中Python官方宣布：Python 2于2020年1月1 日起不再维护，所以如果你现在开始学Python，肯定是要学习Python3了。

但由于Python2的生命周期较长，而且是刚刚停止维护，所以在许多公司中还在使用，有些面试官喜欢 在面试的时候问你：Python2 和 Python3有何区别？不要担心，他们的区别其实没那大，只要掌握了 Python3，很快你就能掌握它们的一些细微差别。

现在你只需要知道，有这么两个版本，且它们之间有一些差别。在之后的过程中，我们会具体的讲。

1.2.2 安装Python环境

1. 访问Python官网，https://www.python.org , Python官网会通过浏览器识别你的操作系统，所以 只要按下图操作即可下载相应的版本。

2. 双击运行下载下来的安装文件，按照提示一步步的进行安装（除了地址可以更改，其他默认即可）。

3. 测试是否正确安装。

   1. 打开控制台，Windows在搜索栏里输入"cmd"并回车。（Mac打开系统自带的"终端"应用程序）
   2. 在控制台内输入"python"，并回车，如果出现以下界面，则说明安装成功。

1.2.3 Hello World

Python的代码以简洁高效著称，比如下面这四行代码，就可以实现包含10000个数据的正态分布直方图。

# 以下这段新手直接运行一般都会报错，咱先不运行，这里仅用作讲解
import matplotlib.pyplot as plt
import numpy as np

plt.hist(np.random.randn(10000), bins=40)
plt.show()

效果如下：

你看，短短4行代码，就能画出这么一个图，是不是很nice！

那接下来，我们来写个Hello world吧，Python的第一行代码绝对比你想象的简单，在上一步打开的控制台内，输入以下的代码：

print("Hello world")

然后敲回车键，如果你的显示器上显示了“Hello world”，恭喜你，你的第一个Python程序已经运行成功了，是不是很简单！试着把Hello world替换成你想说的话，再次运行看看。

这里的print是一个内置函数，关于函数的概念我们可以先不管，我们只要知道使用print函数可以在屏幕上输出指定的内容。print函数也可以支持这样的写法：

print("Hello", "world")

print("Hello", "my", "friends")

逗号隔开了多个单词，我们没有输入空格，但在输出的时候Python会自动用空格把每个单词隔开，实际上，我们可以输入100个，1000个无数个单词。大家注意逗号在这里的用法，后面我们会经常用到这种写法。

第三节 交互式编程

在上面的步骤中，我们输入了一行代码，按回车键后，将代码提交给了Python内置的解释器，解释器运行了代码后，将运行结果打印在了控制台上， 这种一次输入对应一次输出的形式，我们称之为交互式编程。

试试将Hello world案例中右边的引号去掉，看看会输出什么。

你会看到一句话，像这样：

SyntaxError: EOL while scanning string literal

解释器尝试运行你的代码，但由于那个缺失的引号，导致执行的过程中出错，解释器向你打印了这个错误， 这时候屏幕显示的不是输出，而是error(异常或者说报错）。一个有经验的程序员，看到这个error 信息后就能判断出是什么地方出现了问题。

而如果后续你还跟着看我的博文的话，你也是能成为老司机的哦！

qis交互式编程并不是Python独有的，但Python的交互式界面是最强大的，它还有很丰富的插件，提供了一系列非常强大的功能，这些有机会的话我也会在后面详细介绍。

第四节 Python开发工具

其实python的开发工具有很多，但单从使用功能以及安装体验上来讲，最适合大家的我认为是Pycharm。

Pycharm其实安装起来也非常简单，点击官网下载地址https://www.jetbrains.com/pycharm/download/点击下载就可以啦（蓝色的download是收费版，一般我们用社区版即可）。

安装除了地址外，其他按默认即可。

安装完之后打开，点击create new project（你们左边应该是空白的）。

这样，我们就能在pycharm上运行程序啦。

第二部分 核心语法

第一节 变量

2.1.1 变量的定义

变量就是可变的量，对于一些有可能会经常变化的数据，我们需要使用一个符号，这样才能计算中使用它，就像我们在小学时学过的一元方程中的"x"一样。比如说，我们在控制台内输入：

x = "world"

这样我们就新定义了一个变量，它的值是"world"， 我们稍稍修改一下Hello world的例子，这次我们使用变量x。

print("Hello", x)

运行后输出的结果和我们之前的例子是一样的，在这里，x就相当于"world"。对于变量，我们可以理解为一个带有抓手的容器，我们可以往里任何我们想放的东西，而这个抓手，就是变量名，提着这个抓 手，我们可以更方便的使用容器里的东西。

我们再写几个例子，巩固一下：

name = "Smith"
print("Mr", name)
print("Mrs", name)

在这个例子里，有一对史密斯夫妇，对他们的称呼应该分别叫Mr Smith 和 Mrs Smith，注意我们在代码中只写了一次Smith，就可以实现2次使用。还有一个好处是，假如换了一对夫妇，他们的名字不一 样，我们只要修改name的值就行了，其他的代码完全不用修改，是不是很方便呢？

大家思考一下，假设上面的例子中，我们要打印100遍他们的名字，如果不用定义变量，那当我们修改时要怎么做？理解到变量的作用了吧？

2.1.2 变量名规则

在Python中，变量名遵循以下的规则：

1. 变量名由字母、数字和下划线组成，也就是a-z, A-Z, 0-9和_
2. 变量名不能以数字开头
3. 变量名是区分大小写的，比如a 和 A就是两个不同的变量。

这个规则大家不用背，我们来举几个例子看一看，很快就明白了。

这些都是合法的变量名：

a = "hello"

MyJob = "analyst"

player1 = "姚明"

_private_name = "ss"

player1_score = 41

_ = "something"

下面这些都是不合法的变量名：

1abc   # 不能以数字开头

123

abc-   # 注意这是横杠符号，不是下划线

另外，在此基础上，我们也约定了一些变量名的命名规范。比如：

1. 普通变量一般用小写字母
2. 最好不要用单词加数字的方式来命名变量，尤其是没有意义的随机数字。
3. 有两种风格的变量名：单词之间用下划线隔开；每个单词的首字母使用大写字母。

注意，上面的规范只是程序员们的一种约定俗成规则，并不是Python语言的硬性要求。但是遵循了这些规范，写出来的变量名可读性更高，更有利于团队合作。

2.1.3 关键字

以下的这些单词都是Python的关键字，每个编程语言都有各自的关键字，它们组成了编程语言基本的语法规则。大家先不用管它们的作用，只要在命名的时候避免使用这些名字就行了。

False      await      else       import     pass

None       break      except     in         raise

True       class      finally    is         return

and        continue   for        lambda     try

as         def        from       nonlocal   while

assert     del        global     not        with

async      elif       if         or         yield

事实上，如果你一不小心定义了一个与关键字相同的变量，代码会在运行的时候报错。比如下面这个：

True = 0

上面这行代码运行会输出下面的信息，提示不能给关键字赋值。

SyntaxError: can’t assign to keyword

2.1.4 变量赋值

变量是可以重复使用，并且是可以修改的，由于Python的变量不需要先声明，所以变量的声明和赋值是在同一行代码完成的，比如我们上面声明的name变量

name = "Smith"

在这一行里，我们先定义了一个名为"name"的变量，然后给它赋值为"Smith"，这样，我们就有了一个 变量"name"，它的值是"Smith"。变量必须要先声明，才能使用。如果使用了一个从未定义过的变量 xxx，Python解释器会抛给你一个这样的错误：

NameError: name ‘xxx’ is not defined

在变量定义完成后，我们可以随意读取、修改它的值，比如：

# 定义name变量，赋值为"Smith"
name = "Smith"
print("Mr", name)

# 修改变量的值为"Jones"
name = "Jones"
print("Mr", name)

这上面这个例子中，我们使用了同一个变量"name"，但它的值发生了变化，导致程序中两次输出的结果也发生了相应的变化。

现在我们掌握了如何给变量赋值，我们再来学习稍微高级一点的技巧，让大家领略Python的高效。有时候，我们需要定义好几个变量，以进行计算。比如现在我想要定义三个变量，并把它们的值都设为1，可以这样写：

a = b = c = 1

这样就定义三个变量，且它们的初始值都是1，那如果我想定义的三个变量值都不一样呢？

a, b, c = 1, 2, 3

大家可以试一下，在控制台里输入这样一行代码，然后分别打印一下a,b,c这三个变量的值、

通过测试可以发现，这样写其实就相当于是：

a = 1
b = 2
c = 3

这也是其他大部分编程语言的写法，大家比较一下，哪种写法更高效呢？

我们再思考一下，既然可以同时给多个变量赋予不同的值，那可不可以直接交换几个变量的值呢？

# 定义两个变量，其中a=1, b=2
a,  b= 1, 2

# 进行交换，现在a=2, b=1
a, b = b, a

这样的操作非常优雅、高效，大家可以试试更多的变量的交换。

2.1.5 变量的销毁

在Python中，我们一般无需手动的去销毁变量，Python的垃圾回收机制会帮我们处理掉那些不再使用的变量，如果我们想刻意销毁删除某个变量，可以使用del关键字，像这样

del name

销毁后，这个变量就像没有定义过一样，再使用它的话就会产生异常。（不过说实话我自己倒是基本没用这个功能。

第二节 数据类型

如果有学习过其他编程语言的同学，可能在学习变量的时候就会想问，在Python中定义一个变量的时 候，怎么没有先声明它的类型呢？

这正是Python的简洁高效之处。变量在Python中是不区分类型的，但它的值有类型，不同的值有不同的类型，我们来了解一下下面这三种基本的数据类型：

数值，包括整数和浮点数
字符串
布尔值

2.2.1 数值

Python中数值有两种类型，整形(int)和浮点型(float)，通俗一点的讲，一个是不带小数点的，一个带小数点的。

# 这是一个整形
a = 100

# 这是一个浮点型变量
b = 3.14

整形和浮点形数值可以相互运算，比如

# c是一个浮点型变量
c = a + b

这个很容易理解，一个整数加上一个小数，得到的肯定还是一个小数。我们再看另一个例子，可以先猜猜是什么类型。

a = 0.14
b = 3.14 
c = b - a
# c=3.0

这里面变量c还是一个浮点型，它的值是3.0，可以得出一个结论，只要有浮点数参与的运算，它的结果肯定也是浮点数。

2.2.2 字符串

我们在Hello world例子中使用的就是字符串类型

a = "Hello world"

当如果字符串含有特殊字符，比如双引号，我们可以加一个\来进行转义。

print("Buddha: \"What we think, we become.\"")

# 输出的结果是：Buddha: "What we think, we become."

截止目前，我们在定义字符串时使用的都是双引号，其实Python也支持单引号，它们并没有什么区别。

a = "Hello"
b = 'world'

print(a, b)
# 输出的结果仍然是Hello world

这种灵活的写法给了我们便利，比如上面那个字符串中包含双引号的例子中，我们可以使用单引号定义字符串，这样就不用对字符中的字符串进行转义了，这样看起来是不是清爽了很多。

print('Buddha: "What we think, we become."')

有时候我们要定义的字符串比较长，超出了一行的长度，在编写的时候使用一个反斜杠""来连接多行：

sentence = "This's a very long long long \
long long sentence............"

print(sentence)

上面的代码在输出的时候还是会显示为一整行。如果说还有更长的字符串，类似一整段话，我们可以使用三引号

zen = """Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense."""

print(zen)

当然，上面的双引号也可以用单引号代替。

2.2.3 布尔值(boolean, bool)

布尔值只有两个值: True 和 False，顾名思义，True代表真，False代表假，我们用布尔值一般是用来做条件判断。在Python3中，True和False是关键字，所以我们不能定义为变量名。

2.2.4 空值 None

空值None是Python中的一个特殊值，它代表空值，表示“什么都没有”，None同时也是关键字。None的用处有很多，比如说你想定义一个变量，但一时还没想好给它赋什么值，甚至连它用什么类型也没决 定好，这时可以先用None。

temp = None
print(temp)

None被输出的时候显示为一个字符串"None"

2.2.5 类型转换

2.2.5.1 布尔值转换

要想把其他值转换为布尔值，需要使用一个内置函数bool()，我们在控制台按顺序输入以下的代码：

Python

# 以下值都为True
bool(1)
bool(-1)
bool(255)
bool(0.0000001)
bool(-99.99)

# 下面的值为False
bool(0)
bool(0.0)

通过上面的代码，不难总结出：对于数值类型，所有的非零值转换为True, 只有零值才转换为False. 字符串也可以转换为布尔值

# 这是一个空字符串，转换结果为False
bool("")

# 转换结果为True
bool("abc")

# 这是一个只包含一个空格的字符串，转换结果为为True
bool(" ")

对于任何非空的字符串，转换为布尔值都是True。注意第一行代码和第三行代码。

空值转换为布尔值永远都是False（敲黑板）

# 结果为False
bool(None)

2.2.5.2 字符串转换

首先介绍一下我们可以使用str() 将其他类型转换为字符串，

True, False, None 这三个值转换为字符串就是它们的单词本身，实际上在实际编程中，我们很少需要把它们转换成字符串来使用。

str(True)
str(False)
str(None)
# 结果是'True' # 结果是'False' # 结果是'None'

对于数值类型，我们也可以用str()将它们转换为字符串，

print("My age is", str(18))

在上面的例子中，我们使用str()将18转换为"18"，然后再输出。实际上，在这个例子中，如果不进行强制转换的话，也不会出错，那是因为，print函数会自动将数值先转换成字符串再输出。

2.2.5.3 数值转换

数值转换是我们在数据分析过程中经常用到的，因为我们从任何文件中读到的数字一开始都是字符串， 需要将它们转换为数值才能进行运算。

如果想要把一个整数字符串转换为int类型，使用int()；

num = "1"
int(num) + 1

如果将int()去掉，这段代码则会报错，因为num是个字符串，不能将字符串和数值进行相加。

数值的前后带有空格也可以成功转换：

int(" 100 ")
# 结果为100

带有符号的数字也可以成功转换

int("-1")  # 结果为-1 
int("+1")  # 结果为1

如果想要把一个带小数点的字符串转换为float类型，使用float() pi = “3.1415926”

float(pi)

int类型和float类型之间也可以相互转换

int(3.14)  #结果为3
int(9.9)  # 结果为9
float(100)  # 结果为100.0

注意第二行中，9.9并没有转换为10，虽然这样更符合我们的常识，四舍五入嘛，但float在被转换为int的过程中，它的小数部分精度将被丢弃，只取整数部分。所以在将float转换为int的过程中，永远要小 心。

那如果想要四舍五入的来转换呢，毕竟这样更符合我们的需求。Python给我们提供了一个内置函数： round

round(9.9)  #结果为10 
round(9.5)  #结果为10
round(9.49) #结果为9

甚至，round函数让我们可以指定要保留小数点后几位：
保留小数点后两位，由于第三位是1，所以结果是3.14 round(3.1415926, 2)
保留小数点后三位，由于第四位是5，所以结果是3.142 round(3.1415926, 3)

布尔值也可以转换为int或者float

int(True)  # 结果是1
int(False)  # 结果是0

float(True) # 结果是1.0
float(False)# 结果是0.0

观察一下，恰好是数值类型转换为布尔类型的相反过程。

第三节 运算符

2.3.1 算术运算符

Python中进行数值运算需要的符号如下，我们来一一学习一下。

运算符	描述	    实例
+	    加	    1 + 1; a + b
-	    减	    10 - 5; a - b -c
*	    乘	    4 * 2 相当 4 × 2
/	    除	    4 / 2 相当于 4 ÷ 2
//	    取整除	10 // 4 结果是 2
%    	取模		10 % 4 相当于 10 - (10 // 4) × 4
**	    指数		2 ** 3 相当于 2 * 2 * 2，也就是2的3次方
()	    小括号	提高运算优先级，比如: (2 + 8) * 3

我们来看几个例子：

print(1 + 1) 
print(10 - 5) 
print(4 * 2) 
print(4 / 2)  # 结果是2.0

上面的例子都是简单的加减乘除，我们用肉眼就能观察出结果，需要注意的是除法运算, 当我们使用单斜杠除法运算符时，即使除数和被除数都是整数，它的返回结果也是一个浮点数。

print(5 / 2)  # 结果是2.5 
print(5 // 2)  # 结果是2

当我们需要对两个整数进行除法运算，且对结果的小数精度要求不高的时候，一般使用双斜杠来进行运算，这样能保证结果也是整数，不用再进行类型转换。

print(10 / 3)  # 结果是3.3333333333333335

、

上面这行代码的结果很有意思，我们都清楚，10 ÷ 3的结果是3.333…无限循环小数，但无限循环小数毕竟是个数学概念，计算机无法表达，所以只能显示到一定的位数。细心的你可能会发现最后一位为什么是5呢？四舍五入的话也应该是3呀。这是因为小数以二进制形式表示时的有穷性导致的，也就是计算机底层机制的原因。这里面的细节大家可以先不管，但要记住进行浮点数运算时是有精度问题的。

print(10 % 4)  # 结果是2
print((2 + 8) * 3)  # 结果是30

取模运算符大家先暂时可以理解为取余数，记住以下几个规则：

1. 当两个数能整除时，取模运算的结果为0，比如 8 % 4 的结果是0
2. 当0<a<b时，a % b = a，比如 3 % 8 的结果是3
3. 当两个数中有负数时，结果可能会跟我们预料的不同，记住这个公式就行了 ：a % b 就相当于a - (a // b) * b

2.3.2 使用算术运算符操作字符串

对，没有看错，字符串在Python中也可以“运算”，有两种操作，我们先看看加法。

print("Hello " + "world")

加号可以将两个字符串拼接成一个字符串，也可以将多个字符串拼接在一起：

print("apple " + "apple " + "apple ")

那如果有太多的"apple"怎么办呢？总不能一直加下去吧，这时候我们可以使用"*"运算符，表示将该字符串重复几次并拼接成一个字符串。

print("apple " * 5)

使用加号拼接字符串时需要注意，不能将字符串与数值一起相加，比如说我们要给用户发现一条查询积分的消息：

print("您账户积分为：" + 500)

这样写将会报错，所以我们要在拼接之前，先将500转换为字符串，运用我们上面学过的知识，修改成这样：

print("您账户积分为：" + str(500))

2.3.3 赋值运算符

赋值操作其实我们已经用过了，在前面定义变量的时候我们都会使用等于号。

num = 1
name = "Smith"

结合上面的运算符，我们可以做更多的赋值操作：

运算符	描述				实例
+=		加法赋值运算符	c += a  等效于 c = c + a
-=		减法赋值运算符	c -= a  等效于 c = c - a
*= 		乘法赋值运算符	c *= a  等效于 c = c * a
/=		除法赋值运算符	c /= a  等效于 c = c / a
//=		取整除赋值运算符	c //= a 等效于 c = c // a
%=		取模赋值运算符	c %= a  等效于 c = c % a
**=		幂赋值运算符		c = a   等效于 c = c a

我们在日常编程中最常用的是加法赋值和减法赋值，比如设置一个计数器，每次+1

count = 0
count += 1
count += 1

执行了两次加法赋值操作后，count的值变成了2。

2.3.4 比较运算符

比较运算符是用来运算布尔值的， 将两个值放在一起比较，最后得到True或者False。

运算符	描述		实例
==		等于		100 == 100
!=		不等于	100 != 99
>		大于		2 > 1
<		小于		1 < 2
>=		大于等于	3 >= 2
<=		小于等于	2 <= 3

我们可以在控制台cmd中的python里输入一些比较运算，看看它们的返回值是什么

100 == 100  # True
100 == "abc"  # False
1 != 2  # True
2 != 2  # False
3 > 3  # False
3 >= 3  # True
2 < 3  # True
2 <= 3  # True

这都是符合我们的常识的操作，大家在控制台里试着敲一遍就明白了。下面再试试一些比较特殊的例子：

100 == "100"   # False
100 == 50 * 2  # True
str(100) == "100"  # True
1.0 != 1  # False
int(1.9) == 1  # True

需要注意的一点是，数值100 和字符串"100"是不相等的，这一点尤其要小心，这种隐藏的bug很难被发现。

2.3.4 逻辑运算符

真实的程序中，常常需要判断的条件是复杂的，所以我们需要逻辑运算符将多个比较运算连接起来。

运算符	逻辑表达式	描述	 
and		x and y		任意一个是False，结果就是False	True and False 结果为False
or		x or y		任意一个是True，结果就是True;	True or False 结果为True
not		not x		将条件取反	not False 结果为True

我们来看几个例子：

# 定义两个变量 
a, b = 1, 2 

a > 0 and a < b  # True

a % 2 == 0 or b % 2 == 0  # True

not a > b  # True

and, or, not它们也是Python中的关键字，这是经常需要使用的三个关键字。掌握好逻辑运算符是学好任何一门编程语言的基础。

逻辑运算符可以与赋值操作组合，让你的代码更老练：

a = 0 or 100   # a=100
b = 1 or 2  # b=1

第四节 流程控制

经过前面三个小节的学习，我们已经对Python编程语言有了一个初步的了解。如果说Python是一条蟒蛇，变量、数据类型、运算符就是它的肌肉和骨架，而流程控制相当于它的神经系统，掌握了流程控 制知识，就可以让Python灵活的游动起来。

Python的流程控制比较简洁，主要分为两块：条件判断和循环控制。

2.4.1 条件判断

2.4.1.1 if…else…语句

在这里要介绍两个重要的关键字，if 和 else，看它们的字面意思就能猜到它们表示“如果”… “否则”… 我们来看看在代码中如何使用

num = 3

# 通过取模运算判断num是否能被2整除
if num % 2 == 0:
   print(str(num) + "是一个偶数")
else:
   print(str(num) + "是一个奇数")

这一波段代码是一个完整的逻辑，今后我们写的程序会更复杂，但也只不过是这段代码的重复和组合而 已。

2.4.1.2 elif

上面的例子中是一个非常简单的逻辑，一个整数，它要么是偶数要么是奇数，如果说再复杂一点的条件，我们该如何写呢？比如说来判断一个学生的考试成绩，60分以下的为不及格，60~90分为合格，90 分以上为优秀，这里面有三个条件。

score = 59

if score < 60:
   print("您的考试成绩不及格")
elif score < 90:
   print("您的考试成绩合格")
else:
   print("您的考试成绩优秀")

在这个例子中，使用了一个新的关键字"elif", 它只能用在if判断之后，else之前。

2.4.1.3 if 条件嵌套

还是以学生考试成绩的例子来说，现在我们想对60-100分的进行更细的划分，60-70分为合格，70-90 分为良好，90分以上为优秀。

score = 100

if score >= 60:
	if score < 70:
       print("您的考试成绩为合格")
   elif score < 90:
       print("您的考试成绩为良好")
   else:
       print("您的考试成绩为优秀")
else:
   print("您的考试成绩不及格")

嵌套循环可以嵌套无数层，但通常我们都建议尽量减少嵌套的层数，以增加代码的可读性。

2.4.1.3 与逻辑运算符组合

age = 22
if age > 18 and age < 60:
   print("你已经不是个孩子啦，该去工作啦")

上面的例子表示，年龄大于18岁并且小于60岁，也可以这样写：

age = 22

if 18 < age < 60:
   print("你已经不是个孩子啦，该去工作啦")

这样的代码更简洁，可读性更高，这是Python特有的简洁写法。

2.4.1.4 自动类型转换

if 和 elif 的后面总是跟着一个表达式，这个表达式的结果必须是True或者False，如果表达式运算出来的结果不是一个布尔值，则会自动将结果转换为布尔值，无论它是什么类型的值。转换的结果遵循我们之 前学过的布尔转换规律。

count = 0

if count:
	print("条件成立")
else:
	print("条件不成立")

试着将count的值改为1，条件则成立了。

result = None
if result:
   pass
else:
   print("什么收获都没有")

记住：0值、None 和空字符串转换为布尔值后都是False

pass是Python的关键字，它表示什么也不做。

2.4.2 循环

看到循环我们首先会想到一些物体，比如旋转的风扇、车轮，一个圆的形状。一个圆形的跑道，如果沿着它跑，除非我们自己停下来，永远不会有终点，但是可以计算我们跑了多少圈。假设我们在跑步之前，给自己设定一个目标，跑完10圈就不跑了，然后去一圈一圈的跑完了10圈，停止。这个过程就很像代码里的循环语句了。

2.4.2.1 while循环

lap = 0

while lap < 10:
   lap += 1

   print("我跑完了第" + str(lap + 1) + "圈")

运行上面的代码，会得到以下的输出：

我跑完了第1圈
我跑完了第2圈
我跑完了第3圈
我跑完了第4圈
我跑完了第5圈
我跑完了第6圈
我跑完了第7圈
我跑完了第8圈
我跑完了第9圈
我跑完了第10圈

2.4.2.2 for循环

for循环可以用来遍历序列，序列指的是一个可迭代的有序的集合，比如字符串就是一个序列，下面我 们用for循环来打印出一个字符串中的所有字符。

seq = "hello"

for s in seq:
   print(s)

这段代码的输出如下：

h
e
l
l
o

也可以用for循环来打印一连串的数字，这里需要用到一个新的内置函数：range。

for i in range(5):
   print(i)

range函数的作用就是提供一个从0到4的迭代器，而for可以遍历这个迭代器。注意是从0开始的，整个循环一共打印了5个数。

输出结果是：

0
1
2
3
4

我们可以修改一下之前写的跑圈的while循环，改用for循环加range函数来实现：

for lap in range(10):
   print("我跑完了第" + str(lap + 1) + "圈")

对比一下，哪种写法更简洁，更优雅 ？很明显是用for循环这种。这里面有一个细节需要注意，由于lap的值是从0开始到9结束，所以我们需要在输出的时候给它+1。

2.4.2.3 嵌套循环

既然掌握了两种循环写法，那可以把它们组合起来运用，我们来写一个例子，在控制台中打印出指定边长的长方形或者正方形图案。

# 指定长方形的宽和高
width, height = 10, 5

# 因为是从上往下开始打印，所以先遍历高度

for i in range(height):
	for j in range(width):
		print("*", end="")
	print()

在这里，print函数有了第二个参数，end表示在打印完指定的内容后，在结尾再打印一个指定的字符串，默认每个print语句在结尾会加一个换行符"\n", 传递一个空字符串给它，表示打印完星号以后不再添加任何输出内容。

第二个print函数没有任何参数，那它会输出一个换行符。

所以整个程序的逻辑就是每输出10个星号后，输出一个换行符，最终输出的图案如下：

**********
**********
**********
**********
**********

既然可以打印出一个长方形，那我们也可以打印一个直角三角形：

*
**
***
****
*****

代码如下

for i in range(5):
   	for j in range(i + 1):
       	print("*", end="")
   	print()

再来一个稍微复杂一点的案例，打印出这样一个九九乘法表：

1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

代码如下：

for i in range(1, 10):
   	for j in range(1, i + 1):
       	print("%s*%s=%s" % (j, i, i * j), end=" ")
   	print()

2.4.2.4 break 和continue

有时候在循环内部，我们需要临时略过某一次循环或者干脆跳出整个循环，这时候就需要用到break和continue。

在下面这个例子中，我们使用for循环和continue来打印出10以内的所有奇数相加的式子，并求出它们的和。

total = 0

for i in range(10):
   	if i % 2 == 0:
       	continue
   	print(i, end=" + ")
   	total += i

print(" = %s" % total)

关键字break用来打断整个循环并跳出。看这个例子，给一个字符串，这个字符串是一个小数，要求打印出小数的整数部分。

s = "238.9237834829"

for i in s:
   	if i == '.':
       	print()
       	break

   	print(i, end='')

小数的整数部分都在小数点的左边，而我们遍历字符串是从左往右，所以当遇到小数点后，就停止遍历，这样就正好实现了打印这个小数的整数部分。

2.4.3 演示：智能密码锁程序

最近几年很流行的智能密码锁程序，除了可以用指纹开锁、人脸识别开锁外，都会有密码开锁的功能， 以防万一。密码开锁功能是这样的，首先设定好密码，以后每次开锁的时候只要输入的数字中含有设定的密码，就视为解锁成功。这样的设定是为了防止别人的窥探，具有更高的安全性。

首先，由于涉及到了输入，先来学习一下Python内置的输入函数: input

password = input("请设置您的密码")

在执行到这行代码时，控制台就变成光标闪烁的状态，用户可以用键盘进行字符的输入，输入完成后， 再输入一个回车表示输入结束，输入的字符串赋给等号左边的变量。

# 设置初始密码
password = "123"

while True:
	pwd = input("请输入您想要设置的密码：")
   	# 如果没有输入任何密码，则使用初始密码作为密码
   	if not pwd:
       	break
   	confirm_password = input("请再次输入您的密码：")
   	if pwd == confirm_password:
       	password = pwd
       	break
   	else:
       	print("您两次输入的密码不一致，请重新输入。")

print("您的初始密码已设置为：" + password)
print("进入开锁程序。。。")

# 开锁
while True:
   	input_pwd = input("请输入您的密码：")
   	# 判断输入的密码中是否包含密码
   	if password in input_pwd:
       	print("开锁成功！")
       	break
   	else:
       	print("您输入的密码有误，请重新输入")

注意 password in input_pwd 这行代码，关键字in表示如果在指定的序列中找到值返回 True，否则返回 False。

第三部分 数据结构

第一节 字符串

在任何一门编程语言中，字符串都是最基础、最重要的数据结构。前面我们已经学习过字符串的基本使用方法，现在继续深入的学习更多的知识。

3.1.1 字符串的格式化输出

3.1.1.1 格式化运算符

在之前while循环的一个例子中， 有这样一行代码：

print("我跑完了第" + str(lap + 1) + "圈")

这里我们使用了两个加号做了字符串拼接，并且将整形转换成了字符串，现在介绍一种更好的办法，使用格式化输出来打印这句话。

print("我跑完了第%d圈" % 1)

这里的百分号就是格式化符号，跟模运算符一样，但在不同的地方用法不一样。%d是一种占位，表示 要显示在这里是一个整数，常用的占位符有以下几种：

占位符	描述
%d		整数占位符
%f		浮点数占位符
%.f		指定精度的浮点数占位符
%s		字符串占位符
%%		输出百分号%

如果给%d 传入一个浮点数，那它会自动将它转换成整数

print("%d" % 3.14)  # 输出3
print("%d" % 3.99)  # 输出3

转换成整数的规则和类型转换的规则一 样，不会四舍五入。

%f的用法有两种，一种就是直接使用，比如

print("%f" % 3.14)

它会输出“3.140000”，后面的0是自动补齐的，如果我们只想要输出小数点后两位，可以这样写： print(“%.2f” % 3.14)

print("%.2f" % 3.1415926)

上面的两行代码输出都是"3.14"，“%.2f” 这种写法指定了小数点后面的位数，即使浮点数后面的小数部分超出了2位，也只会输出两位。如果不足两位，或者是个整数，会自动补零到两位。

print("%.2f" % 3)  # 3.00
print("%.2f" % 3.1) # 3.10
print("%s" % 100) print("%s" % 3.14)  # 输出100 # 输出3.14
print("%s" % "python")  # 输出python

%s 是胜任最广泛的占位符，它可以对应任何类型的变量。
在同一个字符串可以同时使用多个占位符：

report = "%d年%s公司营收增长了百分之%.2f" % (2019, "腾讯", 20.28) 
print(report)

当我们需要在字符串输出一个百分比，就需要用到%%，比如说：

report = "%d年%s公司营收增长了%.2f%%" % (2019, "腾讯", 20.28)
print(report)

3.1.1.2 format 函数

除了%运算符外，Python还为我们提供了字符串的format函数提供丰富的格式化。比如说，在输出一个较长的数字时，根据国际惯例，每三位用逗号分隔：

print('{:,}'.format(1234567890))  # 1,234,567,890

format函数也可以像%那样来格式化多个参数：

report = "{0}年{1}公司营收增长了{2}%".format(2019, "腾讯", 20.28)
print(report)

{0}表示第一个参数，{1}{2}表示第二、第三个参数，以此类推。这样做的好处是，如果有参数在字符串出现多次，可以不用重复的传入。

‘{0}的GDP为{1:,}…虽然它的GDP只有{1:,}美元，但它的人均GDP高达18万美元’.format(“摩纳哥”, 7100000000)

假设这个GDP数据在报告中多处被引用，万一需要修订的话，我们只需要修改一处就行了。

3.1.2 字符串的下标和切片

字符串其实也是一种序列，可以理解为一串整齐的按顺序排着队的字符，组成了字符串，那每个字符在队伍中都有自己的位置，这个位置就是下标，又叫作索引。

C	H	I	N	A
1	2	3	4	5

如上表，"CHINA"这个字符串，从左往右每一个字符对应了一个下标（索引），需要特别注意的是，在计算机编程中，所有的下标都是从0开始的，当我们要访问一个字符串的第1个字符时，使用的下标应该是0。

"CHINA"[0]

使用中括号加数字的方式，表示要访问的是具体哪个位置上的字符。

"CHINA"[1]  # 第2个字符"H"
"CHINA"[4]   # 第5个字符"A"

第5个字符"A"是这个字符串的最后一个，我们也可以这样来访问：

"CHINA"[-1]  # 最后一个字符"A" 
"CHINA"[-2]  # 倒数第二个字符"N"

使用负数下标可以从右往左访问，这种写法是Python特有的，非常的快捷，对于任意长度的字符串，我们都可以使用-1来获取它的最后一个字符，注意使用负数下标是是从-1开始的，因为-0也是0，产生重复了。

切片操作也是Python的一大特色，极大简化了序列访问和操作，

"CHINA"[0:3]

上面的切片将会得到"CHI"，切片操作是以冒号隔开两个下标，冒号左边的代表开始下标，右边的代表结束下标，特别需要注意的是，结尾下标表示截取到该下标前一个位置的下标。那[0:3]，一共截取了3-0=3个字符，从0开始数，0、1、2，恰好是三个。

所以如果我们用[0:0]这种写法，将会得到一个空的字符串，

"CHINA"[0:0] "CHINA"[0:-1]  # 空字符串 # CHIN

那如果想得到切片出整个字符串，可以这样写

"CHINA"[0:6]  # CHINA

但一般我们都会这样写，冒号右边的省略，表示一直截取到最后一个字符。

"CHINA"[0:] # CHINA

事实上，前面的0也可以不写，冒号左边为空表示从第一个字符开始截取。

# 从0到末尾   
"CHINA"[:]  # CHINA
# 从0到第3个
"CHINA"[:3] # CHI  
# 从第3个到末尾
"CHINA"[2:] # INA

如果想要隔一个字符取一个，可以这样写 # 每隔两个字符截取一个

"CHINA"[::2]  # CIA

第二个冒号表示截取步长，这里的2表示每两个字符取一个，如果不传，默认就是每一个都取。步长也可以为负数，如果传递了一个负数，则表示是从右往左进行截取。

# 从右往左每隔两个两个字符截取一个
"CHINA"[::-2]    # AIC

所以，如果想倒序输出一个字符串，可以这样写

"CHINA"[::-1]  # ANIHC

3.1.3 字符串函数

字符串本身有很多函数，前面其实已经学习过一个format函数，我们再来介绍几个其他的常用函数： 3.1.3.1 去除空白字符函数

先来了解一下什么是空白字符，空白符包括空格、换行（\n）、制表符（\t）。

print("A\tB\tC\nD\tE\tF")

在控制台里会整齐的输出成这样：

A B C
D E F

在C后面有一个\n换行符，所以D才会显示在了第二行。而ABC、DEF之间的空白则是\t制表符造成的。 按键盘上的空格键会产生一个空格，按回车键则会产生一个换行符，按Tab键则会产生一个制表符，用户在输入数据的时候有时候经常会误输入这几个字符，所以在在处理用户输入的数据时，要先去除头尾 的空白字符。

password = "123"
input_password = " 123"
print(password == input_password)

print输出为False，由于在1前面有一个空格，导致了密码校验失败，所以必须对用户的输入先进行处理 password = “123”

input_password = " 123"
print(password == input_password.strip())

我们在input_password后面加了一个函数strip()，现在输出变成了True。strip函数的作用就是去除字符串首尾的所有空白字符。

" abc ".strip()
"\t abc \n".strip()

得到的将是字符串"abc"，但是strip函数并不会去除掉字符串之间的空白字符

" a   b   c ".strip()

得到的结果是"a b c"，只去掉了首尾空白字符，保留了中间的。另外还有lstrip和rstrip函数，分别去除字符串左边和右边的空白字符。

3.1.3.2 大小写操作

这个比较简单，我们直接看代码。

# 将所有字符变成大写 
"china".upper()  
# CHINA

# 将字符串的首字母变成大写 
"china".capitalize() 
# China

# 将所有字符变成小写
"CHINA".lower()
# china

# 将每个单词的首字母变成大写 
"i have a dream".title()
# I Have A Dream

3.1.3.3 字符串判断

判断字符串是否以指定的字符串开头或者结尾

函数			说明
startswith	是否以指定的字符串开头
endswith	是否以指定的字符串结尾
isdigit		是否是一串数字
islower		是否全是小写字母
isupper		是否全是大写字母

3.1.3.4 查找与替换

在前面智能密码锁的案例中，我们用过in来判断一个字符串是否被包含在另一个字符中 password = ‘123’

input_pwd = '456123789' 

print(password in input_pwd)  # True

这样可以判断出是input_pwd中是否有password，但如果想要知道password在input_pwd中的确切位置，就需要使用find函数

input_pwd.find(password)  # 结果是3

结果是3。在input_pwd中寻找password，找到了，且它的出现的位置是3，也就是第4个字符。如果没有找到则会返回-1

input_pwd.find("notexists")   # 结果是-1

除了find函数，index函数也有相同的功能，唯一的区别是 ，index函数如果没有找到相应的字符串就会报错

input_pwd.index(password)  # 结果是3
# 这行代码将会在运行时报错 input_pwd.index("notexists")

count函数能够查找出指定的字符串一共出现了几次，如果没有出现，则返回0。

"abba".count('a')  # 2
 'abba'.count('c')   # 0

replace函数提供了替换字符串中某些部分的功能

"abba".replace('a', 'b')  # 结果是'bbbb'

'apple banana'.replace('apple', 'orange')  # 结果是'orange banana'

3.1.3.5 字符串长度

字符串本身没有测量长度的函数，需要借助一个Python内置函数len。

len("China")  # 5
len("")  # 0
len("a")  # 1

len函数非常重要，它不光可以测量字符串的长度，也可以测量其他所有有长度的对象。 r = range(10)

len(r)  # 10

3.1.4 综合案例：异常号码数据分析

结合以上的字符操作知识，可以开发一个电话号码识别程序，用户输入一串数字，程序识别它是不是一 个有效的电话号码，如果是有效电话号码，我们再识别它是一个固定电话号码、手机号码、还是400号 码。用户输入"exit"后，程序退出。

这是一个稍微复杂的需求，在动手写代码之前，我们先分析一下需求。先列举一下常见的几种电话号码 形式，手机号码是11位的，以1开头，不同运营商的前三位不一样，由于三位太多了，我们就以前两位来判断，包括13,15,17,18,19

再看固定号码，区号+电话号码的方式，区号可能是三位（010），也可能是四位（0888），电话号码是8位，那加起来一共是11位或12位。

最是400电话，这个特征很明显，以400开头，共10位。

实现代码如下：

cellphone_number_start = "13,15,17,18,19"
telephone_number_start = "010,021,022,025,0888,0555"

while True:
	num = input("请输入一个电话号码: \n")
	if num == 'exit':
		break
	if not num:
       	print("电话号码不能为空")
   	num = num.strip()
   	if not num.isdigit():
       	print("您输入的是一个无效电话号码")
       	continue

   	if num.startswith('1') and len(num) == 11 and num[0:2] in cellphone_number_start:
       	print("这是一个手机号码")
       	continue
   	elif num.startswith('400') and len(num) == 10:
       	print("这是一个广告电话")
       	continue
   	elif num.startswith("0"):   # 当代码太长时，可以用反斜杠分割成多行。
       	if (len(num) == 12 and num[0:4] in telephone_number_start) or \
(len(num) == 11 and num[0:3] in telephone_number_start):
           	print("这是一个固定电话")
           	continue
           
   	print("无法识别该号码")

第二节 元组 tuple

3.2.1 定义元组

现在我们知道了字符串是一种序列，它可以迭代循环，也可以按索引访问，也可以切片访问。但它的成员只能是单个的字符，现在来介绍一种更多元化的序列：元组，英文叫tuple，可这样来定义一个元组：

t = ('My', 'age', 'is', 18)

在这个元组中包含了3个字符串，一个整形数字，元组中的每一项称作元素，4个元素按照从左到右的顺序排列。可以用下标索引访问：

t[0]  # 'my'
t[-1]  # 18

也可以通过切片来访问，注意切片返回的是一个包含切片片段的新元组。

t[0:2]  # ('My', 'age')

事实上元组定义的时候也可以不用括号

t = 'My', 'age', 'is', 18

但当，元组中只有一个元素的时候，必须要加一个逗号：

t = ('solo',）

# 或者不带括号
t = 'solo',

可以将一个序列强制转换为元组

tuple('abc')  # ('a', 'b', 'c')

tuple(range(5)) # (0, 1, 2, 3, 4)

后面的逗号表明这是一个元组，否则就会被认为是一个字符串。

3.2.2 元组操作

现在我们介绍字符串的另一个函数join，有了它，可以把元组这样的序列拼接成一个整体的字符串。

# 注意最后一个元素
t = ('My', 'age', 'is', "18")
print(" ".join(t))  # 输出结果：'My age is 18'

注意最后一个元素，这次我们将它设置成了字符串，因为join函数要求参数序列中的每一个元素都必须是字符串。

和字符串一样，元组也有count, index函数，使用的方法也是一样：

t = ('a', 'b', 'b', 'a')

t.count('a')   # 2
t.index('b')   # 1
t.index('c')   # Error

# 查看长度 
len(t)  # 4

元组也支持 in 操作，想要判断元组中是否包含某个元素：

'a' in t  # True

'x' in t  # False

最后，需要记住的是元组和字符串都是只读的，也就是不可修改的。我们不能单独改变元组中的某个元素，或者是字符串中的某个字符。

3.2.3 遍历元组

元组属于序列，所以可以像字符串那样去遍历它：

lst = ('a', 'b', 'c', 'd', 'e')

for i in lst:
	print(i)

使用for循环可以方便快捷的遍历元组，上面的例子将打印出元组中的每一个元素。也可以使用while来遍历元组，虽然并不经常这样使用。

lst = list(range(10))
i = 0

while i < 10:
	print(lst[i])
 	i += 1

3.2.4 综合案例：销售数据统计-销冠

在真实的项目中，数据结构通常是比较复杂，经常碰到嵌套的元组，甚至是多层嵌套，我们来看一个例 子：

# 当元组元素较多、较长时，可以这样书写 
sales = (("Peter", (78, 70, 65)), ("John", (88, 80, 85)), ("Tony", (90, 99, 95)), ("Henry", (80, 70, 55)), ("Mike", (95, 90, 95)))

这是包含某公司所有销售人员第一季度销售业绩的元组，单位是万元，其中的每一个元素对应一个销售人员的信息，人员信息也是一个元组，包括姓名和业绩，业绩又是一个元组，按照顺序分别是1、2、3 月份的销售额。需求：找出总销售额最高的那个员工，并将TA的名字和总销售额输出。

champion = ''
max_amount = 0

for sale in sales:
   name = sale[0]
   quarter_amount = sale[1]
   total_amount = 0
   for month_amount in quarter_amount:
       total_amount += month_amount
       
   if total_amount > max_amount:
       max_amount = total_amount
       champion = name

print("第一季度的销冠是%s, TA的总销售额是%d万元" % (champion, max_amount))

上面的代码也可进一步优化一下，使得代码行数更少，结构更简单。

champion = ''
max_amount = 0

for name, quarter_amount in sales:
   total_amount = sum(quarter_amount)

   if total_amount > max_amount:
       champion, max_amount = name, total_amount

print("第一季度的销冠是%s, TA的总销售额是%d万元" % (champion, max_amount))

这里用到了一个sum函数，它是Python内置函数，可以计算出一个序列里所有数值的总和。

第三节 列表 list

3.3.1 定义列表

列表可以理解为可变的元组，它的使用方式跟元组差不多，区别就是列表可以动态的增加、修改、删除元素。

看一下列表的定义：

# 定义一个空列表
lst = []
lst = list()

# 定义带有初始值的列表
lst = [1, 2, 3]
lst = ["a", 1, 2, 3, "b", "c"]
lst = list(range(5))
lst = list("abc")
lst = list((1, 2, 3))

以上方式都可以定义一个列表。注意变量名使用了lst，有意的避开了list，虽然list不是关键字，但我们在命名变量的时候不要使用这些内置名称，否则可能会引起无法预知的错误。

3.3.2 增删改查

列表的访问和字符串、元组一样，索引或者下标都可以。

lst = ['a', 'b', 'c', 'd', 'e']
lst[0]  # 'a'
lst[1:3]  # ['b', 'c']

列表是可以修改的, 还是以上面的lst为例：

lst.append('x')

往lst里添加了一个元素，现在列表变成了

['a', 'b', 'c', 'd', 'e', 'x']

注意append函数总是在列表后面添加元素，列表的长度也增加了1.因此原来list[-1]的值从原来的’e’变成 了’x’，

len(lst)   # 6
lst[-1]  # 'x'

修改列表中的元素

lst[-1] = 'f'

# 修改后列表变为：
# ['a', 'b', 'c', 'd', 'e', 'f']

删除列表中的元素

del lst[0]
# 删除后列表变为：
# ['b', 'c', 'd', 'e', 'f']

注意，由于我们删除的是第一个元素，现在剩下的所有元素的索引都发生了变化，第一个lst[0]变成了’b’，后面的也都往前挪了一位。但是lst[-1]没有变，还是’f’。涉及到删除操作的时候要小心，防止使 用错误的索引。

3.3.3 列表函数

列表也是一种序列，它也具有index和count函数和支持len函数，这些函数的用法和元组一样，它的循环遍历也和元组一样，不再赘述。下面来介绍一下列表特有的一些函数。

insert

insert函数和刚刚介绍的append函数一样，用来向列表中添加一个新的元素，区别就是append是在最后添加，insert则可以向任意位置添加。

lst = ['a', 'c', 'e']

# 在第二个元素'c'前面插入一个字符串'b'
lst.insert(1, 'b')

# lst现在的值是['a', 'b', 'c', 'e']

# 在最后一个元素'e'前面插入一个字符串'd'
lst.insert(-1, 'd')

# lst现在的值是['a', 'b', 'c', 'd', 'e']

pop

每次调用pop函数会从列表中“弹”出一个元素，接着上面的lst操作

temp = lst.pop()

print(lst)  # ['a', 'b', 'c', 'd']
print(temp)  # 'e'

我们发现列表最后一个元素’e’不见了，并被在控制台打印出了。如果想“弹”出其他位置的元素，可以传 一个位置参数给pop函数，像这样：

temp = lst.pop(2)

print(lst)  # ['a', 'b', 'd']
print(temp)  # 'c'

remove

前面我们已经学习了使用del关键字去删除列表元素，del操作可删除指定下标索引的元素，如果我们要删除指定内容的元素，就需要用到remove函数。

lst = [1, 2, 1, 'a', 'b', 'c']

lst.remove('a')
print(lst)  # lst的值为[1, 2, 1, 'b', 'c']

lst.remove(1)  # 注意这里的1是元素值，不是索引
print(lst)  # lst的值为[2, 1, 'b', 'c']

remove函数会从左至右找到与指定的值相匹配的第一个元素，并将它删除。在使用的时候需要区分del, pop, remove的区别。

clear

clear函数会清空列表内的所有元素。

lst = [1,2,3,4]

lst.clear()
print(lst)  # 结果为[]

extend

extend函数有点像append函数，但append函数每次只能添加一个元素，而extend可以添加一组。 lst = []

lst.extend(range(5))
print(lst)  # [0, 1, 2, 3, 4]

lst.extend([5, 6, 7])  
print(lst)  # [0, 1, 2, 3, 4, 5, 6, 7]

reverse

将整个列表反转，以上一步的lst为例

lst.reverse()
print(lst)  # [7, 6, 5, 4, 3, 2, 1, 0]

sort

按照一定的规则将列表中的元素重新排序，对于数值，默认按从小到大的顺序排列。 lst = [3, 5, 2, 1, 4]

lst.sort()

print(lst)  # [1, 2, 3, 4, 5]

如果想要让列表从大到小排列，可以加上reverse参数。 lst = [3, 5, 2, 1, 4]

lst = [3, 5, 2, 1, 4]
lst.sort(reverse=True)

print(lst)  # [5, 4, 3, 2, 1]

对于字符串，则会按照它们的ASCII值的顺序排列。ASCII是基于拉丁字母的一套电脑编码系统，所有的编程语言都支持ASCII编码。ASCII值一共有128个字符，包含数字0~9，字母a-z, A-Z，还有一些常用的符号。每一个字符对应一个数字，比如字母’A’对应的就是65， 字母’B’对应66，等等。在Python中，可以使用内置函数将字符与它的ASSCII值互转。

ord('A')  # 65

chr(66)  # 'B'

sort函数会比对每个字符串的第一个字符，如果第一个字符相同，则比对第二个字符，以此类推。

fruits = ['apple', 'banana', 'orange', 'blueberry']

fruits.sort()
print(fruits)  # ['apple', 'banana', 'blueberry', 'orange']

注意观察"banana"和"blueberry"的顺序。

如果列表的元素不是简单的字符或者数字，那怎么进行排序呢，比如有下面一个列表，它存储了公司第一季度每个月的收入。

revenue = [('1月', 5610000), ('2月', 4850000), ('3月', 6220000)]

注意列表中的每一个元素是一个元组，元组的第一项是月份，第二项是销售额，现在想要按照它的销售额来从高到低排序。如果直接调用sort函数，它会按照元组中第一项的字符串顺序进行排序。

revenue.sort(reverse=True)  # 排序后为 [('3月', 6220000), ('2月', 4850000), ('1月', 5610000)]

这显然不对，2月的收入比1月低，应该排到最后。这时应该传递key参数

revenue.sort(reverse=True, key=lambda x:x[1])  # 排序后为 [('3月', 6220000), ('1月', 5610000), ('2月', 4850000)]

key参数接收的是一个函数，我们在这里给它传递了一个匿名函数，关于函数的使用后面再学习，这里我们需要了解是通过key参数，我们指定了sort排序的依据，就是每个元组里面的第二项。

copy

lst1 = [1, 2, 3]
lst2 = lst1
lst1.append(4)

上面的代码执行完成以后，lst 和 lst2的值都变成了 [1, 2, 3, 4] ，但我们在代码里面只修改了lst1, lst2的值也跟着改变了，这不符合我的预期，可能会导致bug。所以，如果我们想要创建一个跟lst1一模一样的新列表，且不再受它以后操作的影响，就可以使用copy函数：

lst1 = [1, 2, 3]
lst2 = lst1.copy()

lst1.append(4)

print(lst1)  # [1, 2, 3, 4]
print(lst2)  # [1, 2, 3]

3.3.4 列表表达式

列表表达式是一种快捷的创建列表的表达式，可以将多行代码省略为一行。比如，列出20以内的所有偶数

[i * 2 for i in range(10)]  # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

当然，上面的代码我们也可以这样实现

[i for i in range(0, 20, 2)]

range函数可以接收三个参数：第一个是起始数值（包含），可以省略，默认从0开始；第二个是结束数值（不包含）；第三个是步长，可以省略，默认为1。是不是有点像切片操作？

上面的代码就相当于：

even_nums = []

for i in range(0, 20, 2):
	even_nums.append(i)

对比来看，列表表达式确实更简洁更优雅，再看一个例子，打印出大写的26个字母。

# 65是大写字母‘A’的ASCII值
print([chr(i) for i in range(65, 65 + 26)])

3.3.5 综合案例-销售数据统计-排行榜

再进一步，还记得前面写过的找出销售冠军的例子吗？

sales = (("Peter", (78, 70, 65)), ("John", (88, 80, 85)), ("Tony", (90, 99, 95)), ("Henry", (80, 70, 55)), ("Mike", (95, 90, 95)))


![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/30dbefa7f311a757b18ab8f5ab6e9073.jpeg)

**感谢每一个认真阅读我文章的人，看着粉丝一路的上涨和关注，礼尚往来总是要有的：**



①　2000多本Python电子书（主流和经典的书籍应该都有了）

②　Python标准库资料（最全中文版）

③　项目源码（四五十个有趣且经典的练手项目及源码）

④　Python基础入门、爬虫、web开发、大数据分析方面的视频（适合小白学习）

⑤ Python学习路线图（告别不入流的学习）




**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注python）**
![img](https://img-blog.csdnimg.cn/img_convert/636ce268ba8ae52aa8954dd56c7651c7.png)

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
CII值的顺序排列。ASCII是基于拉丁字母的一套电脑编码系统，所有的编程语言都支持ASCII编码。ASCII值一共有128个字符，包含数字0~9，字母a-z, A-Z，还有一些常用的符号。每一个字符对应一个数字，比如字母’A’对应的就是65， 字母’B’对应66，等等。在Python中，可以使用内置函数将字符与它的ASSCII值互转。

ord(‘A’) # 65

chr(66) # ‘B’

sort函数会比对每个字符串的第一个字符，如果第一个字符相同，则比对第二个字符，以此类推。

fruits = [‘apple’, ‘banana’, ‘orange’, ‘blueberry’]

fruits.sort()
print(fruits) # [‘apple’, ‘banana’, ‘blueberry’, ‘orange’]

注意观察"banana"和"blueberry"的顺序。


如果列表的元素不是简单的字符或者数字，那怎么进行排序呢，比如有下面一个列表，它存储了公司第一季度每个月的收入。

revenue = [(‘1月’, 5610000), (‘2月’, 4850000), (‘3月’, 6220000)]

注意列表中的每一个元素是一个元组，元组的第一项是月份，第二项是销售额，现在想要按照它的销售额来从高到低排序。如果直接调用sort函数，它会按照元组中第一项的字符串顺序进行排序。

revenue.sort(reverse=True) # 排序后为 [(‘3月’, 6220000), (‘2月’, 4850000), (‘1月’, 5610000)]

这显然不对，2月的收入比1月低，应该排到最后。这时应该传递key参数

revenue.sort(reverse=True, key=lambda x:x[1]) # 排序后为 [(‘3月’, 6220000), (‘1月’, 5610000), (‘2月’, 4850000)]

key参数接收的是一个函数，我们在这里给它传递了一个匿名函数，关于函数的使用后面再学习，这里我们需要了解是通过key参数，我们指定了sort排序的依据，就是每个元组里面的第二项。


###### copy

lst1 = [1, 2, 3]
lst2 = lst1
lst1.append(4)

上面的代码执行完成以后，lst 和 lst2的值都变成了 [1, 2, 3, 4] ，但我们在代码里面只修改了lst1, lst2的值也跟着改变了，这不符合我的预期，可能会导致bug。所以，如果我们想要创建一个跟lst1一模一样的新列表，且不再受它以后操作的影响，就可以使用copy函数：

lst1 = [1, 2, 3]
lst2 = lst1.copy()

lst1.append(4)

print(lst1) # [1, 2, 3, 4]
print(lst2) # [1, 2, 3]

##### 3.3.4 列表表达式


列表表达式是一种快捷的创建列表的表达式，可以将多行代码省略为一行。比如，列出20以内的所有偶数

[i * 2 for i in range(10)] # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

当然，上面的代码我们也可以这样实现

[i for i in range(0, 20, 2)]

range函数可以接收三个参数：第一个是起始数值（包含），可以省略，默认从0开始；第二个是结束数值（不包含）；第三个是步长，可以省略，默认为1。是不是有点像切片操作？


上面的代码就相当于：

even_nums = []

for i in range(0, 20, 2):
even_nums.append(i)

对比来看，列表表达式确实更简洁更优雅，再看一个例子，打印出大写的26个字母。

65是大写字母‘A’的ASCII值

print([chr(i) for i in range(65, 65 + 26)])

##### 3.3.5 综合案例-销售数据统计-排行榜


再进一步，还记得前面写过的找出销售冠军的例子吗？

sales = ((“Peter”, (78, 70, 65)), (“John”, (88, 80, 85)), (“Tony”, (90, 99, 95)), (“Henry”, (80, 70, 55)), (“Mike”, (95, 90, 95)))

感谢每一个认真阅读我文章的人，看着粉丝一路的上涨和关注，礼尚往来总是要有的：

①　2000多本Python电子书（主流和经典的书籍应该都有了）

②　Python标准库资料（最全中文版）

③　项目源码（四五十个有趣且经典的练手项目及源码）

④　Python基础入门、爬虫、web开发、大数据分析方面的视频（适合小白学习）

⑤ Python学习路线图（告别不入流的学习）

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注python）
[外链图片转存中…(img-fp5eBUJ3-1713080233282)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！