大学生精通Python从由浅入深（Python基础篇）_由浅入深学python

看到这位头发浓密大叔了吗！1989年，为了打发圣诞节假期，龟叔(吉多·范·罗苏姆)开始写Python语言的编译器 。
1991年，第一个Python编译器诞生

Python这个名字，来自龟叔所挚爱的电视剧Monty Python’s Flying Circus (蒙蒂·蟒蛇的飞行马戏团）

---

我们为什么要学习这一项语言，Python有以下几个优点

• 技术趋势：Python自带明星属性多年稳居编程语言前三

• 简单：Python开发代码少，阅读一个良好的Python程序就感觉像是在读英语一样，Python的这种代码本质是它最大的优点之一。它使你能够专注于解决问题而不是去搞明白语言本身。

• 易学：就如同你即将看到的一样，Python极其容易上手。前面已经提到了，Python有极其简单的语法，在开发同等业务下，相比C语言、java语言，Python语言开发的代码精简的多。

• 免费、开源：Python开源的。简单地说，你可以自由地阅读它的源代码、对它做改动、这是为什么Python如此优秀的原因之一，它是由一群希望看到一个更加优秀的Python的人创造并经常改进着的。

• 可移植性：由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上），所有Python程序无需修改就可以在下述任何平台上面运行。

• 丰富的库：Python标准库确实很庞大。它可以帮助你处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。记住，只要安装了Python，所有这些功能都是可用的。这被称作Python的“功能齐全”理念。

• 解释性：Python编程语言不需要编译，直接运行

• 规范的代码：Python采用强制缩进的方式，使代码具有良好的阅读性。

缺点：

• 执行效率较慢（相比于C和C++而言）若有速度要求，可使用C/C++来改写关键部分！当然了，这个缺点也被计算机越来越强大的性能所弥补。
• Python第三方库超多比如requests、PySpark、PyFlink、Django、Flask等等，不过，这也从侧面说明：Python语言优秀，吸引的人才多，开发的项目库也多。

每个人对Python语言都有不同的看番，接下来我们开始我们python的学习吧！

---

目前，Python有两个大版本，分别是 Python2 和 Python3，我们本次教程主要为Python3大版本
Python官网：python.org

第一章 Python安装

1.1 Python环境的安装

在学习一项语言之前，我们必须下载相关的安装包并配置相关环境，然而在生产环境中，我们⼀般不会选择最新版本的Python，因为可能会存在未知Bug，所以⼀般强烈建议大家在选择软件版本时，向前推1 ~ 2个版本。本节内容我们将来配置Python环境。

安装Python注意事项：

• 不要将Python安装在中文目录下
• 安装时记得勾选【将Python解释器安装路径添加到Path环境变量】选项
• 安装完成后，在cmd窗口输入python命令查看是否安装成功，若没出现python版本号，则需要去Path环境变量中去查看是否有Python内容

• Python官网：python.org

 

①下载好Python解释器后我们可以开始安装

点击 Next



出现这个页面就完事啦！

②验证是否安装完成
调出cmd窗口命令，并输入python，若出现版本号，则成功！

 

1.2 用python输出“Hello，World”

作为程序员学习一项语言的例行公事，怎么能不对世界说你好呢！

 

1.3 Python解释器以及开发工具

• 前面我们下载的python其实包含了python解释器，我们在运用python时需要通过python解释器，因此要在窗口命令行输入 python，但在Python的开发领域，其开发工具非常非常多，EditPlus、Notepad++、Sublime Text3、Visual Studio Code、PyCharm（目前功能最强大的IDE）接下来我们要下载python开发工具，当下全球Pyhon开发者我使用最频繁的工具软件PyCharm继承开发工具（IDE）
• Pycharm下载网站
  下载配置完后市这样子的，各式各样开发工具千奇百态，选择自己喜欢的工具就行了哦，这里就不多赘述了！

1.2.1 Pycharm常用快捷键
1、代码补全：回车、换行
2、代码保存：CTRL+S
3、快速复制一行：CTRL+D
4、代码格式化：CTRL+ALT+L

---

 

第二章 Python基础

2.1 Python基础-注释

注释指的是：在程序，对代码进行解释说明的文字
首先强调一件事：Python代码 => Python解析器 => 机器语言，但是注释经过了Python的解释器并不会解析与执行。
注释对代码有解释说明，这样可以让别然可以看得懂代码的作用，增强了程序的可读性。

在Python中，注释分为两类

• 单行注释：对一小行代码做局部注释说明
  语法: # 内容

• 多行注释： 1、定义类、模块，要做多行注释，能让读者知道含义；2、定义函数:在函数名的第1行代码处做多行注释。
  语法："""内容"""

演示效果

Tip：快速注释快捷键：ctrl+/（先将需要注释的内容括起来）

---

 

2.2 Python基础-关键字和标识符

标识符
标识符，相当于调用内存地址的一个映像外号。

标识符要遵守五个命名规范：

1. 精简、见名知意
2. 由数字、字母、下划线组成，且开头不为数字
3. 区分大小写
4. 不能和关键字同名

常见的命名方法

（1）小驼峰命名法
（2）大驼峰命名法
（3）下划线来_来链接所有词语

注意：这里的常见命名方法属于编程【道德】，就是在标识符命名规范的基础上，增加了额外要求。

为了给Python标识符新增一些额外的要求，常见的有

1. 变量名/函数名/方法名：所有字母都小写，且单词之间用下环线_连接
2. 模块名：所有字母均小写；
3. 类名：遵循大驼峰命名法
4. 常量：都大写
   关键字是指的是在Python语言中，已经使用的一些词语，具有特殊意义。在创建名字时，不能创建与关键字同名！
   我们可以使用keywork库中的.kwlist进行查看Python中的关键字

# 1.导入库
import keyword

# 2. 列出关键字
print(keyword.kwlist)
1
2
3
4
5

 

2.5 Python基础-数据类型

常量与变量

常量： 在程序运行过程中不会变化的量
变量： 在程序运行过程中发生变化的量
无论是变量还是常量，在创建时都会在内存开辟一块控件，用于保存它的值

1、变量不需要声明类型
Python的变量和常量不需要事先声明类型，这是个根据Python的动态语言特性而来的

2、赋值比较
这个知识点最重要的就是区分赋值和比较，在Python==是比较，=为赋值，比如下列的表达式

age = 18
name = "ziwu"
1
2

3、先创建再使用
每个变量在使用前都必须赋值，变量赋值后在会被创建。若是直接引用未定义的变量，会包以下错误

age # 直接执行
NameError: name 'age' is not defined
1
2

4、赋值背后的原理
在Python中，一切都是对象，变量就是对象的引用
当我们写代码age = 18时，Python解释器干了两件事

• 在内存中创建了一个18的对象
• 在内存中创建了名为age的变量，并把它指向18

我们可以通过id查看这些原理

# 内存中创建了'ziwu'的字符串对象
# 将'ziwu'的地址赋予给a
# a的地址赋予给b
a = 'ziwu'
b = a
print(id('ziwu'))
print(id(a))
print(id(b))
# 结果为 'ziwu'、a、b的三个地址值都相同
1
2
3
4
5
6
7
8
9

字符串类型

1、如何定义字符串
可以使用 单引号、双引号、三引号来创建字符串

a = 'ziwu'
a1 = "ziwu"
a2 = """ziwu"""
a3 = '''ziwu'''
print(a==a1==a2==a3)
# 输出结果为true
1
2
3
4
5
6

2、字符串常用的方法
对象有很多实用的方法，这里举例产假概念的几个，后面第五章会详细讲解字符串的一些方法！

• 分割字符串:指定分隔符分割字符串

a = 'ziwu,sumi,xixiha'
b = a.split(',')
print(b)
print(type(b))
# ['ziwu', 'sumi', 'xixiha']
# <class 'list'>
1
2
3
4
5
6

整数和浮点数

整数
通常被称整型，表示数字时我们有时会用十六进制和八进制表时，他们的类型也为整型
浮点数
浮点数也就是小数，例如1.1，3.14，1.2
对于一些过大的小数我们会用科学计数法去表示
例如：3.14e2为314.00，e2相当于x100，或则小数点向右移两位

a = 1.2e10
print(a)
# 12000000000.0
1
2
3

布尔值

在Python中布尔值有俩：True、False（首字母大写）
Python内置的bool()函数可以来测试一个表达式的布尔结果

print(bool(1>2))
1

变量的定义非常的简单，Python定义变量和常量不用实现声明类型，但必须赋值后才能调用，我们在学习其他编程语言的时候已经接触过一些数据类型，当然在python也不例外，为了应对不同的业务需求，也

会把数据分为不同的类型，如下图所示：

面试题：请手写出Python中的7种数据类型？

答：数值类型、布尔类型、字符串类型、列表类型、元组类型、集合类型、字典类型

问题：如何判断一个变量到底是什么类型？

答：① 使用type(变量名称)方法，返回变量的数据类型 ② isinstance(变量名称,数据类型)，只能返回True或False（真的还是假的）

• 上述我们问题二中提到了如何获取该数据的数据类型语句：type(变量名称)

例题：

# 方式1：使用print直接输出类型信息
name = 'Tom'
age = 18
print(type(age))
name = '大白菜'
price = 3.5
print(type(price))

# 方式2：使用变量存储type（）语句的结果
string_type = type("ziwu")
print(string_type)

# 方式3：使用type（）语句，查看变量存储的数据类型信息
name = 666
name_type = type(name)
print(name_type)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

 

2.6 Python基础-print输出函数

print函数我们其实已经不陌生了，前前后后也用了不少次，多少有点经验，明白点它的用法了。

print函数用于将内容格式化显示在标准输出上，主要指的是屏幕显示器。

print可以接受多个字符串，字符串类型的变量或者可print的对象。每个字符串用逗号“,”隔开，连成一串输出。print会依次打印每个字符串，同时，每遇到一个逗号","就输出一个空格。

print是一个函数，用于输出信息内容

另外的，如果想要让print()输出更美观些，也可以使用转义字符来处理。
转义字符，指的是无法直接表达本身含义，就需要转化含义来显示。
转义字符有：

若要给一个字符转义，通常要加入转义符 \

**tip:快速上下移动代码：**ctrl+shift+↑/↓

---

 

2.7 Python基础-格式化输出

目前为止，我们所有的输出都是直接通过print(变量名称)形式直接打印的。但是实际工作中，我们可能需要对变量的输出进行格式化操作（按照一定格式进行输出）。
基本语法:

...
print(变量名称)
print('字符串%格式' % (变量名称))
print('字符串%格式 %格式 %格式' % (变量名称1, 变量名称2, 	变量名称3))
1
2
3
4

荔枝（以下例子是不是简洁多了呢）：

name = "ziwu"
age= 18
print("IT大牛是%s" %(name))
print("我的名字是%s,我的年龄仅仅%d" %(name,age))
1
2
3
4

其中的，%s
% 表示：我要占位
s 表示：将变量变成字符串放入占位的地方
d 表示：将变量变成整数放入占位的地方

所以，综合起来的意思就是：我先占个位置，等一会有个变量过来，我把它变成字符串放到占位的位置
当多个表变量占位，变量要用括号括起来，并按照占位符顺序填入

当然不仅仅只有%s可以使用，下列表格列出了 python 中常见%格式。

更多格式化符号不再过多文章节是，下图参考

---

 

2.7.1 Python基础-格式化输出拓展-格式化精度控制

在%d、%f中我们可以使用辅助符号"m.n"来控制数据的宽度和精度

m，控制宽度，要求是数字（很少使用）,设置的宽度小于数字自身，不生效
.n，控制小数点精度，要求是数字，会进行小数的四舍五入，而整形不考虑小数位置，因此%d不考虑控制精度

示例：
%5d：表示将整数的宽度控制在5位，如数字11，被设置为5d，就会变成：[空格][空格][空格]11，用三个空格补足宽度。
%5.2f：表示将宽度控制为5，将小数点精度设置为2
小数点和小数部分也算入宽度计算。如，对11.345设置了%7.2f 后，结果是：[空格][空格]11.35。2个空格补足宽度，小数部分限制2位精度后，四舍五入为 .35
%.2f：表示不限制宽度，只设置小数点精度为2，如11.345设置%.2f后，结果是11.35

多值一起案例：

name = "ziwu"
year = 3
money = 100000.56
print("我的名字是%s,工作%d年了，工资%.2f元了" % (name, year, money))
1
2
3
4

---

 

2.8 Python基础-format方法简化输出

除了上述格式化输出方式外，也可以使用format()函数处理
format格式：

print('字符串{}'.format(变量名称1))
print('{}字符串{}'.format(变量名称1, 变量名称2))
1
2

原来的 format 格式输出比较繁琐，在Python3.6以后版本，为了简化format输出操作，引入了一个简写形式：
语法：f"内容{变量}"

name = "ziwu"
age= 18
print("IT大牛是{},年龄为{}".format(name,age))
print(f"IT大牛是{name}，年龄为{age}")
1
2
3
4

特点：

• 不理会类型直接插入
• 不做精度控
• 适合对精度没有要求的时候快速使用

当然，你也可以对format做精度控制：

a = 132.456
print(f"这个数字是{a:.2f}")
1
2

还有一种方法，用字符串切片的方式，我们会在第五章讲解：

a = 132.456
result = str(a)
result = result[:result.index(".")+3]
print(result)
1
2
3
4

---

 

2.9 Python基础-字符串拓展-格式化输出中的转义符号

在字符串中，如果出现了\t和\n，其代表的含义就是两个转义字符

\t ：制表符，一个tab键（4个空格）的距离
\n ：换行符
1
2

案例：

print('*\t*\t*')
print('hello\nworld')
1
2

特别说明：默认情况下，每个print()方法执行完毕后，都会输出一个\n换行符。如果不想让print()方法换行，可以添加一个end参数

print('*', end='')
1

---

 

2.10 Python基础-数据输入

到目前为止，我们所有的程序都只能把数据输出给用户。但是实际工作中，我们经常输入获取用户的输入信息，如银行系统中的密码输入、淘宝中的用户登录验证，以下介绍Python中怎么进行数据输入。

语法：input()

也可以在input（）的括号中输入内容，寓意为在前面print一串内容

input()默认接收的都是字符串，如果想接受数据，请自行进行类型转换！

小结：
① input()可以用于接收由外部设备输入的信息，但是如果用户没有输入任何内容，则input()函数会中止当前代码的继续执行，处于等待状态，直到用户输入结束。
② 所有由input()方法获取的数据都是字符串类型，如果要使用，则要进行类型转换，下列是类型转换表。

---

 

2.11 数据类型转换

在Python中，若要把某数据转换为指定数据类型的结果，语法：指定数据类型(变量名)
数据转换的类型有:

③eval(str) 用来将已转换后的数据结果，重新转换为原始数据类型。

a = "True"
b = "3.14"
print(type(eval(a)))
print(type(eval(b)))
1
2
3
4

---

 

2.12 Python基础-运算符

所谓的算数运算符就是我们日常生活中的加减乘除等待。
①算数运算符

②赋值运算符

③复合赋值运算符

---

 
 

第三章 判断

3.1 Python判断语句-布尔值和比较运算符

布尔值字面量：

• True 表示真
• False 表示假

定义变量存储布尔值类型数据：
变量名称 = 布尔值字面量在定义时需要注意True、False开头字母为大写

比较运算符

逻辑运算符（与或非）

not：就是取反，只有一个表达式not 表达式，如果表达式为True，则not以后就返回False。反之，则返回True。
and ：逻辑与，只有当两边的表达式全部为真，则最终结果返回为真，否则返回为假。
or ：逻辑或，只要有一方为真，则整个表达式的返回结果就为真。除非两边的表达式都为假，则整个结果返回为假。

扩展：短路运算(逻辑运算符)
在Python代码中，逻辑运算符的运算，要遵循短路运算原则。
① 表达式1 and 表达式2，如果表达式1条件为真，则最终的运算结果由右边的表达式2来决定。如果表达式1条件为假，则最终结果为假。其右边的表达式2不需要在进行运算。
② 表达式1 or 表达式2，如果表达式1为真，则最终的运算结果由表达式1来决定，为真。如果表达式1为假，则最终结果由表达式2来决定。如果表达式2为真，则最终结果为真，如果表达式2为假，则最终结果为假。

在逻辑运算中，不一定逻辑运算符的两边都是纯表达式，也可以是数值类型的数据或字符串类型的数据。
Python把0、空字符串和None看成 False，其他数值和非空字符串都看成 True，所以： 空字符串就是只有一对引号的字符串，''或""

[了解]运算符优先级：

---

 

3.2 Python判断语句-if语句的基本格式

这是java中的条件判断语句:

if (条件判断) {
    则执行某段代码...
}
1
2
3

但是Python中，不需要使用这么多复杂的符号，直接可以编写条件判断及执行某段代码

Python：

if 判断条件:
	(Tab缩进)条件成立时，要进行的语句
# 例题
age = 18
if age >= 18
	print("我是老八，我已过18！")
1
2
3
4
5
6

if单分支语句选择原理图：学编程除了会写代码还不行，还要回画图（流程图）

（1）条件的结果总是布尔型的；
（2）注意：if语句后记得使用Tab进行强制缩进。

---

 

3.3 Python判断语句-if else语句的基本格式

相比3.2，此条件语句可以列举出条件不成立时执行的语句

if 要判断的条件:
	条件成立时，要进行的语句
else：
	条件不成立时执行的语句
# 例题
age = 18
if age >= 18
	print("我是老八，我已过18！")
else：
	print("我未成年")
1
2
3
4
5
6
7
8
9
10

else关键字不能单独使用，使用时要注意好格式

if…else…双分支语句结构原理图：

---

 

3.4 Python判断语句-if elif else语句的基本格式

相比3.3，此条件语句可以列举出多条件成立时执行的语句

if 要判断的条件:
	条件成立时，要进行的语句
elif 要判断的条件
	条件成立时的语句
else：
	条件不成立时执行的语句
# 例题
age = int(input("动物园门票购买，请输入你的身高"))
if age < 120:
	print("免费")
elif age >= 120:
	print("缴费60元")
else:
	print("神秘代码，系统出错")
1
2
3
4
5
6
7
8
9
10
11
12
13
14

if多分支语句多重条件判断原理图：

---

 

3.5 Python判断语句-判断语句的嵌套

if 外层条件判断:
    # 如果条件为True，则执行以下语句段
    if 内层条件判断:
        # 如果内层条件为True，则执行以下语句段
else:
    # 如果条件为False，则执行以下语句段
1
2
3
4
5
6

嵌套结构看起来异常复杂，但是我们在编写时要遵循一个原则：先编写外层判断，所有语句编写完成后，在编写内层条件判断结构。
第二个if，属于第一个if里面，只有第一个if执行成功，第二个if才开始执行
接下来写一段猜数字代码

# 构建一个随机的变量
import random
num = random.randint(1,10)

guess_num = int(input("输入你想要猜测的数据："))

# 判断语句
if guess_num == num:
    print("真厉害，一次猜中")
else:
    if guess_num > num:
        print("你猜测的数字大了")
    else:
        print("你猜测的数字小了")

    guess_num = int(input("请再次输入你想要猜测的数据："))

    if guess_num == num:
        print("第二次就猜中了，好厉害呀！")
        exit(0)
    else:
        if guess_num > num:
            print("你猜测的数字大了")
        else:
            print("你猜测的数字小了")

        guess_num = int(input("请最后输入你想要猜测的数据："))

        if guess_num == num:
            print("第三次就猜中了，好厉害呀！")
        else:
            print("没有机会了，告辞")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

综合案例：剪刀石头布
参与游戏的角色有两个（玩家 与 电脑），玩家手工出拳，电脑随机出拳，根据石头剪刀布判断输赢。

玩家：player（玩家手工输入石头0、剪刀1、布2）

电脑：computer（随机出拳）

输赢结果很重要，有三种情况：

① 玩家赢

☆ player：石头 赢 computer：剪刀

☆ player：剪刀 赢 computer：布

☆ player：布 赢 computer：石头

② 平局

只要player 与 computer出拳相等，就代表平局

③ 电脑赢

如果不满足以上两个条件，则电脑获胜！

未知知识点：如何让计算机随机出拳 => 随机(random)

# 1.导入库
import random

# 2.显示操作界面
# 6.多次重复操作
while True:
    print("================================")
    print("猜拳小游戏操作有:")
    print("\t（1）石头")
    print("\t（2）剪刀")
    print("\t（3）布")
    print("================================")
    # 3.玩家出拳
    player = int(input("请输入出拳方式:"))
    # 4.电脑出拳（动态）
    computer = random.randint(1,3)
    # 5.判断
    if (player == 1 and computer == 2) or (player == 2 and computer == 3) or (player == 3 and computer == 1):
        print("恭喜您, 胜利了!!!")
    elif player == computer:
        print("==========平局.")
    else:
        print("你输了, 不要走, 洗洗手再来一把!!")

# 扩展
# 需求1: 改进程序, 在输出时把电脑和玩家的出拳方式显示出来
# 需求2: 可以让用户退出玩游戏
# 【思考】需求3: 用户就不输入1/2/3、输入非数字(程序出错? 如何改进解决?)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

---

 

3.6 Python判断语句-三目运算符

1、什么是三目运算符

在Python中三目运算符也叫三元运算符，其主要作用：就是用于简化if…else…语句。

if 条件判断:
    # 语句段1
else:
    # 语句段2
1
2
3
4

转换为三目运算符

语句段1 if 条件判断 else 语句段2
1

---

 

第四章 循环

在Python中，循环一共分为两大类：while循环与for循环

思考问题：while循环和for循环如何选择呢？

① 对于循环次数已知的情况，建议使用while循环

② 对于循环次数未知的情况，建议使用for循环
但是有了 range 关键字的加入，for循环更加精简！在后期使用时，优先推荐for循环

4.1 Python循环语句-while循环的基础

基本语法：

# ① 定义一个计数器（初始化一个计数器）
i = 0或1
# ② 编写while循环结构
while 循环条件(判断 计数器 是否达到了目标位置):
	循环体1
	循环体2
	...
	# ③ 在循环内部更新计数器
	i = i + 1 或 i += 1
1
2
3
4
5
6
7
8
9

# 例题
i = 0
while i < 100
	print("喵喵喵")
	i += 1

# 1~100的和
i = 1
sum = 0
while i <= 100:
    sum += i
    i += 1
print(sum)

# 猜数字
#定义随机数
import random
num = random.randint(1,100)

input_num = int(input("请输入数字"))
count = 0
while input_num != num:
    if input_num<num:
        print("小了")
        input_num = int(input("请输入数字："))
        count += 1
    else:
        print("大了")
        input_num = int(input("请输入数字:"))
        count += 1

print(f"猜对了,你一共猜了{count}次")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

while循环流程图：

---

 

4.2 Python循环语句-while循环的嵌套运用

我们运用案例来了解while的嵌套运用

# 我们小明每天表白100天，且要送10朵玫瑰
# 外层： 表白100天
# 内层： 送玫瑰花
i = 1
# 外层
while i <= 100:
    print(f"今天时第{i}天，准备表白")

    #内层
    j = 0
    while j < 10:
        print(f"送给小妹第{j}朵玫瑰花")
        j += 1

    print("小妹我喜欢你！")
    i += 1

# 九九乘法表
i = 1
while i <= 9:
    j = 1
    while j <= i:
        print(f"{j}*{i}={i * j}\t", end='')
        j += 1

    i += 1
    print()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

常见错误：

i = 1
result = 0
while i <= 100:
    if i % 2 == 0:
        result += i
        i += 1 ##这里语句是在 if内的，不在while外循环内
print(f'1~100之间所有偶数的和：{result}')
1
2
3
4
5
6
7

问题的原因：在于i += 1缩进了2次，导致其和if形成了一个整体。while循环中计数器无法更新，最终导致以上代码出现了死循环。

---

 

4.3 Python循环语句-for循环的基础语法

for循环时一种“轮询”机制，是对一批内容进行“逐个处理”！for循环也被称为遍历循环
另外当循环次数未知的情况，建议使用for循环。

for 临时变量 in 序列:
    循环满足条件时执行的代码
1
2

Python中的for寻魂与其他高级语言中的for循环用法不一致，Python中的for循环时无法定义循环条件的，只能从处理数据集中，依次取出内容进行处理

# 数字符中一共有多少个i
name = 'itziwu is brand of itcast'
flag = 0
for x in name:
    if x == 'i':
        flag += 1

print(f"式子中一共有{flag}个i")
1
2
3
4
5
6
7
8

拓展1:
for与else搭配使用：

for 零时变量 in 序列:
	循环满足条件时执行的代码
else：
	当for循环[正常]执行结束后，再执行此代码
	
# 例子
for temp in "itziwu"
	print(temp)
else:
	print("代码遍历完毕")
1
2
3
4
5
6
7
8
9
10

拓展2:
for死循环（没意义这样写）:

lists = [1,2,2,3,4]
# 使 for 循环条件的序列范围无限
for temp in lists:
	lists.append(temp)
1
2
3
4

---

 

4.4 Python循环语句-for循环-range语句、randint语句

Python2 range() 函数返回的是列表，而在Python3中 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。（由于我们还未学习面向对象，为了方便大家理解，你可以简单的将其理解为一个序列结构）

主要作用：获取一个简单的数字序列

语法1：range(num)获取一个从0开始，到num的一个数字序列，不包括num本身，例如range（5）取得的数字序列为【0，1，2，3，4】
语法2：range(num1，num2)获取一个从num1开始，到num2的一个数字序列，不包括num本身,例如range（1,5）取得的数字序列为【1，2，3，4】
语法2：range(num1，num2,step)获取一个从num1开始，到num2的一个数字序列，不包括num本身,数字之间的差值为step,例如range（1,6,2）取得的数字序列为【1，3，5】

#1~100（不包含100）的偶数有多少个
count = 0
for x in range(1,100):
    if x % 2 == 0:
        count += 1

print(f"偶数有{count}个")
1
2
3
4
5
6
7

range有一个口诀：只顾头不顾尾，包含头部信息，但是不包含尾部信息，如range(10)，则返回0~9之间的序列，又比如range(0, 5)代表返回0 ~ 4之间的序列。

---

在Python中，要使用要随机数，首先先要导入随机数 random 包

import random
1

random 包中产生随机数的函数:

与 range 不同， 括号内的两个数分别都能取到它本身

例题猜数字：
 

4.5 Python循环语句-for循环嵌套运用

for循环之间的嵌套与while嵌套一致

# 表白100天，每天送10朵花

for i in range(1,101):
    print(f"今天是u第{i}天！")
    for x in range(1,11):
        print(f"送第{x}只玫瑰花，妹妹我爱你")
print("表白成功")

# 九九乘法表
for i in range(1,10):
    for j in range(1,i+1):
        print(f"{j} * {i} = {j * i}\t",end='')
    print()
1
2
3
4
5
6
7
8
9
10
11
12
13

 

4.6 Python循环语句-循环中断continue、break

在python循环中，经常会遇到两个常见的关键词：break 与 continue , 这两个语句都是都能改变流程控制。

# 某公司，账户余额有1W元，给20名员工发工资。
# 员工编号从1到20，从编号1开始，依次领取工资，每人可领取1000元
# 领工资时，财务判断员工的绩效分（1-10）（随机生成），如果低于5，不发工资，换下一位
# 如果工资发完了，结束发工资。
import random
money = 10000
#外循环员工
for x in range(1,21):
    if money <= 0:
        break
    else:
        point = random.randint(1, 10)
        if point < 5:
            print(f"员工{x}的绩效为{point},低于5，不发工资")
        else:
            print(f"员工{x}的绩效为{point},发工资1000元")
            money -= 1000
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

---

 

4.6 Python循环语句-死循环

在编程中一个无法自我停止的循环被称为”死循环“
在Python中，我们也可以使用while True来模拟死循环

while True
	print("我停不下来啦！")
1
2

---

 

第五章

在现实生活中，我们知道容器是用来存放东西的，比如实验室里的烧杯等。

类似的，在Python中的容器是用来存放数据的。

与此同时，为了操作方便，Python给我们提供了对容器中数据处理的方法，例如增加、删除、修改、查询等。

变量名.函数(x)
1

在Python中，常见容器有：

5.1 字符串

字符串表示文本内容，例如中文文字、学生姓名、一段英文等。

通俗地说，字符串就是使用双引号引起来的内容。

创建字符串语法：

变量名 = "内容"
1

说明：

• 字符串可以使用双引号或单引号表示，较常见的是双引号表示

字符串可以使用双引号或单引号表示，较常见的是双引号表示。

5.1.1 字符串索引下标

如果有字符串: name = 'abcdef' ，在内存中的实际存储如下: 【要定义了变量，就会在电脑内存中开辟一块空间(内存地址值)，用于表示变量。】

例如，我们要获取name中的b和c，要怎么获取(变量名[索引])，**若查看字符串的长度，可以使用如下函数：

# 定义
name = "abcdef"
# 取第一个和最后一个字符
print(name[0])
print(name[5])
print(name[len(name)-1])
1
2
3
4
5
6

不可变类型的内存变化：不可变类型的变量内容变化了，地址值也变化了；而可变类型无论内容变化，都用的是同一个地址值。而我们的字符串是不可变类型（id(变量名)查看地址值）

strs = "Hello"
print(id(strs))
# 2405697181680

strs2 = strs + "World"
print(id(strs))
# 2405697543664
1
2
3
4
5
6
7

字符串的While循环
我们字符串的while遍历是基于len()函数的基础上去遍历的，代码:
（1）定义一个字符串变量，内容为：ABCDEF；

（2）使用while循环来遍历元素；

（3）执行程序，观察效果。

# 1.定义变量
strs = "ABCDEF"
# 2.遍历   0-最大索引值
i = 0
# while i <= (len(strs)-1):
while i < len(strs):
    print(strs[i])
    i += 1

# 3.扩展: 反转??
# result = ""
# name = "itheima"
# # a  逆向
# i = len(name)-1
# while i >= 0:
#     # result = result + name[i]
#     result += name[i]
#     i -= 1
# print(f"反转字符串结果为:{result}")

# b
# name = "itheima"
# print(name[::-1])  # 记住
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

字符串的for循环
（1）定义一个字符串变量，内容为：ABCDEF；

（2）使用for循环来遍历元素；

（3）执行程序，观察效果。

# 对齐
# 1.当明确知道循环的次数时 ,可以考虑使用while循环
# 2.当不清楚要循环几次时, 优先考虑使用for  -->优先考虑使用for循环，更简单

# 1.定义字符串
strs = "ABCDEF"
# 2.for遍历
# for temp in strs:
#     print(temp)

# 3.扩展: range()? -0，xx
# 变量名[索引值]
for index in range(0,len(strs)):
    print(strs[index])
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

 

5.1.2 字符串切片

字符串切片，就是将字符串一部分内容截取，同样与range()相同，左闭右开。
语法:

变量名[起始下标:结束下标(:步长)]
# 括号内容为附加，没括号内容默认步长为1
1
2

注意：选取的区间属于左闭右开型，即从“起始”位开始，到“结束”位的前一位结束(注意：不包含结束位本身)；注意：截取内容时，包含起始位，但不包含结束位。
逆向排序：[::-1]

strs = "heyPython"

# 1、遍历
temp = ""
for i in range(len(strs)):
    temp += strs[len(strs) - i - 1]
print(temp)

# 2、方法
temp1 = list(strs)
temp1.reverse()
print("".join(temp1))

# 3、切片
print(strs[::-1])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

 

5.1.3 字符串常用的函数

Python容器为字符串提供了很多方法变量名.函数名（参数），接下来我们分别一一分析。

---

 

5.1.4 查找元素：find(),index(),count()

所谓字符串查找的方法即是查找子串（元素）在字符串中的位置或者出现次数

srs = "hello world and itcast and itziwu and Python"
#查找字符
print(srs.find("orld"))	#输出为7
print(srs.index("orld"))	#输出为7
print(srs.count("i"))	#输出为2
1
2
3
4
5

---

5.1.5 修改元素：replace(),split()

src = srs.replace("itziwu", "itheima")
print(srs.replace("itziwu", "itheima"))
print(src)

srr = "java#11116#6742#ziwu"
print(srr.split("#"))
# 输出结果为['java', '11116', '6742', 'ziwu']
1
2
3
4
5
6
7

---

5.1.6 居中center()

# 定义
name = "abcdef"

print(name.center(20))
print(name.center(20, '#'))
1
2
3
4
5

---

5.1.7 字母操作-大小写操作

name = "abcdef"
new_name = name.upper()
print(new_name)
# ABCDEF

new_name = name.lower()
print(new_name)
# abcdef

new_name = name.capitalize()
print(new_name)
# Abcdef

new_name = name.swapcase()
print(new_name)
# ABCDEF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

---

5.1.8 特殊语句

# 定义
name = 'abc&)#de#$ffs@#dffbd'
new_name = name.title()
print(new_name)
# 输出为：Abc&)#De#$Ffs@#Dffbd
1
2
3
4
5

s = '  alexW%Usir  %2%  '
s9_1 = s.strip()   
#删除字符串前后的空格
​
print(s9_1)   
#alexW%Usir  %2%
​
ss = '% alexW%Usir  %2%  %%%%'
s9_2 = ss.strip('%')   
#删除字符串前后的%
​
print(s9_2)  
# alexW%Usir  %2%　
1
2
3
4
5
6
7
8
9
10
11
12
13

应用例子：
在没输入数据前，或输入完数据后，屏蔽空格，大大加高用户体验！

username = input('请输入名字：').strip()
if username == '小明':
    print('你好呀 主人')
1
2
3

5.1.9 is系列

5.1.10 连接

5.2 Python数据容器-列表的语法定义

一种可以容纳多份数据的数据类型，每容纳的一个容器称之为一个元素，可以是任意数据类型。
语法：

# 定义变量
变量名称 = [元素1, 元素2，元素3……]	# 多个元素之间使用,分割

# 定义空列表
变量名称 = []
变量名称 = list()

# 例子
name_list = ['itziwu','itcase', 'python']
my_list = ['itziwu',666,True]
new_list = [['itziwu',666,True],['itziwu','itcase', 'python']]
1
2
3
4
5
6
7
8
9
10
11

上述例子我们可以看到，数据容器内可以同时存放多个不同类型的数据，数据容器之间也可以相互嵌套！接下来我们就学习如何利用列表的下标取出数值！

列表中每个元素的下标索引从前到后，从0开始，依次递增；也可以反向取元素从-1开始，依次递减，对应元素从后向前；嵌套列表也同理，先取第一个列表，在从中取其中的元素（[0][1]）如下文例子

name_list = ['itziwu','itcase', 'python']
print(name_list[0])
# 输出结果为itziwu
print(name_list[-1])
# 输出结果为python

new_list = [['itziwu',666,True],['itziwu','itcase', 'python']]
print(new_list[0][1])
# 输出结果为666
print(new_list[1][2])
# 输出结果为python
1
2
3
4
5
6
7
8
9
10
11

此外我们可以用len（）查看列表有多少函数！

lists = ["深圳大学","深圳理工大学","南方科技大学"]
print(len(lists))
1
2

---

遍历列表

• 使用while循环遍历
• 使用for循环遍历

lists = ["西瓜", "香蕉", "火龙果"]
# for循环
for temp in lists:
    print(temp)

# while循环
i = 0
while i < len(lists):
    print(lists[i])
    i += 1

1
2
3
4
5
6
7
8
9
10
11

 

5.2 Python数据容器-列表的常用操作

---

列表-增操作

new_list = ['itziwu',666,True]
new_list.append("新插入位置1")
print(new_list)
# 输出值为 ['itziwu', 666, True , '新插入位置1']

new_list = ['itziwu',666,True]
old_list = ['ziwu',888,False]
new_list.extend(old_list)
print(new_list)
# 输出值为 ['itziwu', 666, True, 'ziwu', 888, False]

new_list = ['itziwu',666,True]
new_list.insert(1,"新插入位置1")
print(new_list)
# 输出值为 ['itziwu', '新插入位置1', 666, True]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

列表-删操作

new_list = ['itziwu',666,True,888]
del new_list[0]
new_list.pop(1)
new_list.remove(888)
print(new_list)
# 输出值为 666
1
2
3
4
5
6

---

列表-改操作

new_list = ['itziwu',666,True]
new_list[1]= 888
print(new_list[1])
# 输出为 888
1
2
3
4

---

列表-查操作

new_list = ['itziwu',666,True]
# 访问下标
index = new_list.index("itziwu")
print(index)
# 输出为" 0 "

lists = ["192.168.1.15","172.168.46.128","177.32.25.44"]
# 访问长度
print(f"现在黑名单一共：{len(lists)}")
ip = input("输入你的ip")

# 是否存在
if ip in lists:
    print("黑名单")
else:
    print("访问成功")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

---

列表-其他操作

---

例题：动态验证码：

import random

strs = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
code = ""
for temp in range(0, 6):
    index = random.randint(0, len(strs) - 1)
    text = strs[index]	# 随机抽取元素
    code += text
print(f"当前验证码为：{code}")
1
2
3
4
5
6
7
8
9

 

5.3 Python数据容器-元组

元组也与列表一样，可以存储不同类型的数据，但是与列表不同的时，元组的数据不可以修改、不可以删除、不可以添加，只可以查询。
语法:元组变量名 = (元素1,元素2,元素3,...)

元组的语法和用法都和列表类似，但元组只可以查询，所以元组能使用：变量名【索引】、index()、len()、in()

city = ("北京","天津","南京")

print(city)
#   ('北京', '天津', '南京')

print(city[0])
#   北京

print(city.index("北京"))
#   0-为北京的索引

print(len(city))
#   3-有三个元素

if "南京" in city:
    print("在")
else:
    print("否")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

元组的遍历与列表一致，这里就不多赘述了
 

5.4 Python数据容器-字典

5.4.1 字典的基本使用

如何访问已经定义字典的值？变量名[键]，若访问不存在的键，则会报错。

ziwu_message = {"name":"ziwu","age":"18","hobby":"永劫无间"}
print(ziwu_message["name"])
1
2

注意：

• 字典元素的key是唯一的，否则所对应value的值只会保留最后赋值的那一个，位置在第一个key的书写位置，且key值为不可变类型数据：字符串、数字、元组
• value值可以重复
• 一般的定义键的类型是字符串
• 字典的元素所在的位置没有先后顺序之分

---

字典-增操作：

例子：

ziwu_message = {"name":"ziwu","age":"18","hobby":"永劫无间"}
ziwu_message["number"] = "119"
print(ziwu_message)
# {'name': 'ziwu', 'age': '18', 'hobby': '永劫无间', 'number': '119'}
1
2
3
4

---

字典-删操作：

message = {"name": "ziwu", "age": "18", "hobby:": "打电动"}
del message["hobby:"]
print(message)
# {'name': 'ziwu', 'age': '18'}
message.clear()
print(message)
# {}
    
1
2
3
4
5
6
7
8

---

字典-改操作：

message = {"name": "ziwu", "age": "18", "hobby:": "打电动"}
message["hobby:"] = "打kun球"
print(message)
# {'name': 'ziwu', 'age': '18', 'hobby:': '打kun球'}
1
2
3
4

---

字典-查操作：

message = {"name": "ziwu", "age": "18", "hobby:": "打电动"}

print(len(message))
# 3
print(message.keys())
# dict_keys(['name', 'age', 'hobby:'])
print(message.values())
# dict_values(['ziwu', '18', '打电动'])
print(message.items())
# dict_items([('name', 'ziwu'), ('age', '18'), ('hobby:', '打电动')])
1
2
3
4
5
6
7
8
9
10

---

字典的遍历

键（key）的遍历：直接对字典变量进行for遍历，默认遍历的是键，但代码不好阅读，我们统一以字典名.key()的方式书写！

message = {"name": "ziwu", "age": "18", "hobby:": "打电动"}

for temp in message:
	print(temp)
1
2
3
4

---

容器知识补充

容器：在 python 中，容器是用来存储多个对象的数据类型，比如列表、元组、字典等。

公共运算符

# 1. 字符串
str1 = "Hello"
str2 = str1 + "WORLD"
print(str2)	# HelloWORLD
print(str1 * 3) # HelloHelloHello

# 列表
lists1 = [1, 2]
lists2 = [3, 4]
result = lists1 + lists2
print(result)	# [1, 2, 3, 4]
print(1 in result)	# True
print(100 in result)	# False
1
2
3
4
5
6
7
8
9
10
11
12
13

---

公共方法

我们以以下例子充分了解公共方法：
（1）定义一个列表变量，内容为：10、300、20、200、30、100、999；

（2）获取列表变量的总长度；

（3）获取列表的最大值和最小值；

# 1、定义一个列表变量
datas = [10,300,20,200,30,100,0,999]
# 2.总长度
print(len(datas))
# 3.最大最小值
# 先排序
# datas.sort()
# print(f"最大值:{datas[6]}")  # 硬编码
# print(f"最大值:{datas[len(datas)-1]}")
# print(f"====最小值:{datas[0]}")
# 简便方法
print(f"最大值:{max(datas)}")
print(f"====最小值:{min(datas)}")
1
2
3
4
5
6
7
8
9
10
11
12
13

 

第六章

6.1 函数的基础定义

函数是组织封装好的，可以重复使用的，因此可以使用函数解决重复代码的问题。
在Python中，有几个重要的概念：
（1）函数名
（2）参数
（3）返回值
语法：

def 函数名(参数):
    函数体
    [return 返回值]
函数名()
1
2
3
4

例子：

# 参数可以为空
def say_hi():
    print("hi!我是ziwu.")

say_hi()

# 带参数例子
# 参数之间用逗号分隔
def add(x,y):
    result = x + y
    print(f"x+y的结果是{result}")

add(4,10)

#带返回值例子
def add(a,b):
    result = a + b
    return result
# return后，再接任何语句都不执行
r = add(4,7)
print(r)
# 11
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

定义函数小技巧
a. 要对函数命名，需要遵循标识符的五条命名规范 : –道德：所有字母均小写，且单词之间使用下划线连接
b. 对函数命名，一般指的是一个动作、行为： -->动词、动词_名词 如：play() play_baskball()
c.先封装，后调用
d.会改变的量尽量不要放到函数内

6.2 函数的基础定义-函数的参数

我们上文提及了函数的基本定义，在定义函数时，设定了参数，则可称这函数为：有参函数。反之，没有参数的函数被称为无参函数。

def 函数名(参数1，参数2……) 	# 形参
	函数体
	……

函数名(参数1，参数2……) 	#实参
1
2
3
4
5

(1) 形参是指形式参数，在定义函数时参数；
(2)实参是实际参数，表示在调用函数时传递的参数值，具有实际意义

变量在函数体内的作用域：
主要分为两类：局部变量和全局变量

• 局部变量： 定义在函数体内部，只可以在函数内部生效，当函数调用完成后，销毁局部变量
• 全局变量： 所谓全局变量，是指在函数体内外都能生效的变量

num = 200 

def test_a():
	num = 500

test_a()
print(num) # 输出为200,如果硬想要修改，则在test_a函数内语法为
"""
def test_a():
	global num #设置内部定义的变量为全局变量
	num = 500
"""
1
2
3
4
5
6
7
8
9
10
11
12

global 变量名：当在函数内想将变量视为全局变量
就近原则

---

6.1.1 [掌握]缺省参数

缺省参数指的是：在定义函数的时候，就为参数提供默认值，与此同时，在调用函数的时候，可以不传递默认参数的值，如果给缺省参数传递了数值，以传递的值为准
缺省参数语法：

def 函数名(参数1，参数2……，参数n=值) 	
	函数体
	……

函数名(参数1，参数2……[值n])
1
2
3
4
5

例题：

#（1）定义一个显示姓名、年龄、性别的函数，且默认性别为男；
def show_infos(name,age,sex="男"):
	print("=========================")
    print("个人信息显示如下:")
    print(f"姓名:{name}")
    print(f"年龄:{age}")
    print(f"性别:{sex}")
    print("=========================")

show_infos("ziwu", 18, "女")
show_infos("ziwu", 18)
1
2
3
4
5
6
7
8
9
10
11

---

[掌握]不定长参数

通常情况下，不定长参数在不确定调用函数时，要传递多少个参数的场景当然也可以不传递参数
语法：

def 函数名(参数1,..,*args,**kwargs):
	代码
	...
	
函数名(值1, 值2, 值3, ... 参数1=值, 参数2=值,...)
1
2
3
4
5

注意：

• *args:前面一个*号的，传入值时不用指明参数名，直接传入参数即可，传入的参数以列表的方式存储
• **kwargs:前面两个**的，传入值需要指明参数名，传入的参数以字典的方式存储。

#第一个是元组形式，第二个是字典形式
def sun(*a, **b):
    print(a)
    print(b)
 
sun(1, 22, x=11, y=22)
1
2
3
4
5
6
7

结果：

(1, 22)
{'x': 11, 'y': 22}
1
2

 

6.2 函数的基础定义-函数返回值

return 作用：①、返回函数；②、结束函数；
如果函数没有使用return语句返回数据，实际上是返回了None这个字面量

def check_age(age):
    """
    check_a函数对比年龄
    :param age:年龄
    :return:返回真假
    """
    if age > 18:
        return "SUCCESS"
    else：
    	pass
    	print("未成年！")
        

print(check_age(16))
#未成年！ None
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

 

6.3 函数的基础定义-函数的嵌套调用

函数之间也可以嵌套运用！嵌套调用的意思是：在一个函数内调用了另一个函数。

#例子
def func_b():
    print("内容b")

def func_a():
    print("内容a")
    func_b()

def func_c():
    print("内容c")
    func_a()

func_c()
1
2
3
4
5
6
7
8
9
10
11
12
13

#ATM机例子
# 全局变量
money = 500000
name = input("请输入你的姓名：")
# 主菜单
def main():
    print("--------主菜单--------")
    print(f"{name}，您好，欢迎来到ziwuATM自助存储机器")
    print("查询余额\t【请输入1】")
    print("存款\t\t【请输入2】")
    print("取款\t\t【请输入3】")
    print("退出\t\t【请输入4】")
    return input("请输入你的选择：")
# 查询
def query(show_header):
    if show_header:
        print("--------查询余额--------")
    print(f"你的余额还剩下：{money}元")

# 存款
def saving(num):
    global money
    money += num
    query(False)

# 取款
def get_money(num):
    global money
    money -= num
    query(False)
# 设置无限循环，保证程序不会退出
while True:
    keyboard_input = main()
    if keyboard_input == "1":
        query(True)
        continue
    elif keyboard_input == "2":
        saving(int(input("您想要存多少钱，请输入：")))
        continue
    elif keyboard_input == "3":
        get_money(int(input("您想要存多少钱，请输入：")))
        continue
    else:
        break

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

 

6.4 函数-说明文档的使用

函数说明文档就是通过注释内容对这个函数进行解释说名，下图是python中print函数中的说明文档

在PyCharm中在函数体内第一行通过三次双引号回车即可以对函数使用文档进行编辑：

def test(a,b,c):
    """
    
    :param a: 
    :param b: 
    :param c: 
    :return: 
    """
    pass
1
2
3
4
5
6
7
8
9

①说明文档第一空行内填写函数的作用；
②param：填写参数说明

---

拆包和交换变量值

拆包：

1:组包 1 2 3 —> (1,2,3)
2:拆包 (66,67,68,69) —> 66 67 68 69

在生活中，我们会把我们需要的物品一个个装进背包中携带到工作地，当我们需要用到物品时，会将背包中的物品都取出；这就好比我们组包、拆包的过程。

• 程序中的拆包

把组合形成的[元组形式]的数据拆分出单个元素内容，这个过程就是程序中的拆包

例如，在一个函数中使用return返回值的时候，我们可以使用字典、元组来存储各个键和值

def get_sum_deff(a, b):
    # 求和
    c1 = a + b
    # 求差
    c2 = a - b
    # 组包
    return c1, c2  # 可以省略括号不写


# 拆包
sums, deff = get_sum_deff(66, 79)
print(f"他们的和为：{sums}")
print(f"他们的差为：{deff}")
1
2
3
4
5
6
7
8
9
10
11
12
13

student = {"name": "ziwu", "gender": "女", "age": 18}

#   拆包
for key, value in student.items():
    print(f"{key}:----->{value}")
1
2
3
4
5

交换变量值

在其它语言我们相交换两个变量的值需要引用到第三个变量，但是在Python中我们可以直接进行交换!

• 例如，现在有变量a = 20和b = 45，请尝试用拆包的方式来交换两个变量的值

a = 20
b = 45

# 引入第三变量方法
# temp = a
# a = b
# b = temp

# 拆包
(a, b) = (b, a)
print(f"a = {a};b = {b}")
#	a = 45;b = 20
1
2
3
4
5
6
7
8
9
10
11
12

---

引用
在Python中，值是考引用来传递的，我们在给函数传递参数时，本质上就iu是把引用当成参数进行传递

1:电脑内存中的内存地址值(引用)是唯一的;
2:如果两个变量的内存地址值是一样的,表示同一个内容.

代码（用id()查看地址值，is 判断地址值是否相同）：

def sum(a,b):
    print(f"传入的a的地址为：{id(a)}")
    print(f"传入的b的地址为：{id(b)}")


a = 20
b = 45
print(f"未传入的a的地址为：{id(a)}")
print(f"未传入的b的地址为：{id(b)}")
print(a is b)
sum(a,b)
1
2
3
4
5
6
7
8
9
10
11

结果：

未传入的a的地址为：140712958656160
未传入的b的地址为：140712958656960
False
传入的a的地址为：140712958656160
传入的b的地址为：140712958656960
1
2
3
4
5

6.5 Python函数、异常处理

异常就是Python程序发送不正常时间，有的时候异常可称为错误。
当检测到一个错误时，Python解释器无法继续执行，反而出现了一些错误提示，这就是异常，也就是我们常常说的BUG
Python中常见的异常:

6.5.1 异常常见处理方式

异常处理语法:

try:
	可能会发生异常的代码
except:
	如果出现异常，执行的代码
1
2
3
4

其中typ、except都是处理异常的关键字

我们来制造一个IndexError异常

print("Hello")
try:
    strs = "hello"
    print(strs[100])
except:
    print("发生了异常")
print("666")
1
2
3
4
5
6
7

结果为：

Hello
发生了异常
666
1
2
3

当我们不进行异常处理时，程序将会报错不再继续往下运行。而异常处理代码，能够让程序不崩溃！

第七章

7.1 python文件的基础定义

我们不管其他教程操作文件的过程多复杂，在俺这就分三步（1. 打开文件；2. 读写文件 3. 关闭文件）
（1）打开文件
在操作一个文件之前，首先需要打开文件

常见的mode访问模式有：

说明
（1）访问模式r表示read，即读
（2）访问模式w表示write，即写
（3）当读取内容有中文的文件时，需要设定文件编码格式为utf-8

（2）读写数据
读数据：

当为访问模式r的时候，可以读取数据

写数据：

当访问模式为w的时候，可以读取数据;
当访问模式为a时，用于追加数据！

（3）关闭文件
每次打开文件后，都需要关闭文件，用于释放系统内存

（4）实战练习

1. 在当前目录创建test.txt文件且分别写入数据：Hello World且追加内容至ziwu Love
2. 将此文件拷贝至新文件test[备份].txt上

# 写入Hello World
file = open("test.txt","w")
file.write("Hello World")
file.close()

# 追加ziwu Love
file = open("test.txt","a")
file.write("ziwu Love")
file.close()

# 上两行先运行，输出内容
file = open("test.txt","r")
print(file.read())
file.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 拷贝源文件
file = open("test.txt","r")
copy_file = file.read()
file.close()

#写入新文件
file = open("test[备份].txt","w")
new_file= file.write(copy_file)
file.close()

# 上两行先运行，输出内容
with open("test[备份].txt","r") as file:
    print(file.read())
1
2
3
4
5
6
7
8
9
10
11
12
13

7.1.1 python文件-快捷读取数据

上一个拷贝例子最后我们用到了with…as语法，这个语法不需要我们手动close文件，现在我们来细讲⑧！
语法：

with open(name,mode,encoding) as 变量名:
	变量名.read()
	# 变量名.write()
1
2
3

7.1.2 python文件-os模块

Pyton中的文件操控大部分功能都存储在os模块中，如查看路径、创建目录、显示文件列表等
os模块时Python标准库，直接导入使用即可

# 导入os包
import os
1
2

在Python中，os模块的常用函数分为两类：

(a) 通过os.path调用的函数
(b) 通过os.直接调用的函数

---

• op.path常用函数（需要用os.path调用）：

import os

path_name = "./file/test.txt"   #相对路径

# 是否存在
print(os.path.exists(path_name))
# 是否为文件
print(os.path.isfile(path_name))
# 是否为目录
print(os.path.isdir(path_name))
# 绝对路径
print(os.path.abspath(path_name))
# 单独文件名
print(os.path.basename(path_name))
# 切片
print(path_name[path_name.rfind("/")+1:])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出结果：

F:\Python\pythonProject_test\day08\02-test.py 
True
True
False
F:\Python\pythonProject_test\day08\file\test.txt
test.txt
test.txt
1
2
3
4
5
6
7

---

• os.常用函数

例题：
（1）获取当前工作目录
（2）获取file目录下的所有文件或目录列表信息
（3）在当前目录下创建day10/file目录

import os

print(os.getcwd())

print(os.listdir("file"))

os.makedirs("./day10/file")
1
2
3
4
5
6
7