Python教程_综合任务:需要使用for循环、if else语句、列表操作、索引取值操作。数据准备

01_你好Python

初识Python

Python的起源
1989年，为了打发圣诞节假期，Gudio van Rossum吉多· 范罗苏姆（龟叔）决心开发一个新的解释程序（Python雏形）
1991年，第一个Python解释器诞生
Python这个名字，来自龟叔所挚爱的电视剧Monty Python’s Flying Circus

为什么选择Python

什么是编程语言

1. 什么是编程语言？
   人类和计算机交流的一种专有领域语言
2. 编程语言的工作原理？
   想法转换为编程语言代码
   通过翻译官（解释器）翻译成二进制提交计算机执行

Python安装

安装python分三个步骤：

1.下载python
2.安装python
3.检查是否安装成功

1、下载Python

（1）python下载地址https://www.python.org/downloads/

（2）选择下载的版本

（3）点开Download后，找到下载文件

Gzipped source tarball 是Linux系统下载的版本
XZ compressed source tarball 是CentOS系统下载的版本
注意Linux和CentOS自带python，一般不用再下载python。
macOS 64-bit/32-bit installer：Mac电脑32位系统版本。
macOS 64-bit installer：Mac电脑64位系统
Windows x86-64：windows 64位操作系统版本。
Windows x86：windows 32操作系统版本。
embeddable zip file：解压安装。下载的是一个压缩文件，解压后即表示安装完成。
executable installer：程序安装。下载的是一个exe可执行程序，双击进行安装。
web-based installer：在线安装。下载的是一个exe可执行程序，双击后，该程序自动下载安装文件(所以需要有网络)进行安装

2、安装Python

（1）双击python-3.7.5-amd64.exe
（2）勾选 Add Python 3.7 to PATH，再点击Customize installation

Install now 默认安装且默认安装路径（一般默认安装在C盘）
Customize installation 自定义安装
Add Python 3.7 to PATH 自动加到环境变量中
（3）不知道的默认就可以了，点击next。

（4）更改安装地址（建议不安装C盘，如果C盘内存小安装的东西多了会很卡，当然内存大就无所谓了）

（5）等待安装过程

（6）安装成功

3、检查是否安装成功Python

当Python 安装结束后，如果是Windows系统，可以在应用列表中看到Python图标，如下：

如果是在Mac 系统中，可以打开命令行，然后运行如下命令：
python3 --version
如果命令行能够正常显示Python3 的版本，则说明安装成功。

第一个Python程序

print("Hello, World!")
1

Python解释器

1. 计算机只认识什么？ 0和1
2. Python解释器的作用是 将Python代码翻译成计算机认识的0和1并提交计算机执行 在解释器环境内可以一行行的执行我们输入的代码 也可以使用解释器程序，去执行”.py”代码文件
3. “.py”文件是什么？ python语言的代码文件，里面记录了python的代码
4. Python解释器程序在 <Python安装目录>/python.exe

Python开发工具

Python程序的开发有许多种方式，一般我们常见的有：
Python解释器环境内，执行单行代码
使用Python解释器程序，执行Python代码文件
使用第三方IDE（集成开发工具），如PyCharm软件，开发Python程序

02_Python基础语法

字面量

1. 掌握字面量的含义 代码中，被写在代码中的固定的值，称之为字面量
2. 常见的字面量类型 我们目前了解：整数、浮点数、字符串这三类即可
3. 如何基于print语句完成各类字面量的输出 print(字面量)，如： print(10)，输出整数10 print(13.14)，输出浮点数13.14 print(“黑马程序员”)，输出字符串：黑马程序员

注释

1. 注释的作用是？ 注释是代码中的解释型语句，用来对代码内容进行注解 注释不是代码，不会被程序执行
2. 单行注释如何定义？ 通过 # 号定义，在#号右侧的所有内容均作为注释 建议在#号和注释内容之间，间隔一个空格 单行注释一般用于对一行或一小部分代码进行解释
3. 多行注释如何定义？ 通过一对三个引号来定义(“”“注释内容”“”)，引号内部均是注释，可以换行 多行注释一般对：Python文件、类或方法进行解释

变量

1.变量是什么，有什么作用？ 变量就是在程序运行时，记录数据用的
2. 变量的定义格式是？ 变量名 = 变量值
3. 变量的特征是？ 变量的值可以改变
4.print语句如何输出多份内容？ print(内容1, 内容2, …, 内容N)
5.Python中如何做减法？ 使用符号 - 即可完成减法运算 拓展：加（+）、减（-）、乘（*）、除（/）

数据类型

1. 使用什么语句可以查看数据的类型？ type()

2. 如下代码，name_type变量可以存储变量name的类型信息，是因为？
   因为type()语句会给出结果（返回值）

3. 变量有没有类型？ 没有，字符串变量表示变量存储了字符串而不是表示变量就是字符串

数据类型转换

1.字符串、整数、浮点数类型转换的语句是？

2.任何类型都可以转换成字符串，对不对？ 正确
3. 字符串可以随意转换成数字，对不对？ 错误，字符串内必须只有数字才可以
4.浮点数转整数会丢失什么？ 丢失精度，也就是小数部分

标识符

1. 什么是标识符？ 用户编写代码时，对变量、类、方法等编写的名字，叫做标识符。
2. 标识符的命名规则？ 内容限定 （中文、英文、数字、下划线） 大小写敏感 不可使用关键字
   
3. 变量的命名规范？ 见名知意 下划线命名法 英文字母全小写

运算符

常见的算术（数学）运算符有： 加（+）、减（-）、乘（）、除（/）、整除（//）、取余（%）、求平方（**）
赋值运算符有：
标准赋值：=
复合赋值：+=、-=、=、/=、//=、%=、**=

字符串扩展

字符串的三种定义方式

字符串的三种定义方式：

单引号方式
双引号方式
三引号方式

引号的嵌套可以使用：

\ 来进行转义单引号内可以写双引号或双引号内可以写单引号

"""
演示字符串的三种定义方式：
- 单引号定义法
- 双引号定义法
- 三引号定义法
"""

# 单引号定义法，使用单引号进行包围
name = '黑马程序员'
print(type(name))
# 双引号定义法
name = "黑马程序员"
print(type(name))
# 三引号定义法，写法和多行注释是一样的
name = """
我是
黑马
程序员
"""
print(type(name))
# 在字符串内 包含双引号
name = '"黑马程序员"'
print(name)
# 在字符串内 包含单引号
name = "'黑马程序员'"
print(name)
# 使用转义字符 \ 解除引号的效用
name = "\"黑马程序员\""
print(name)
name = '\'黑马程序员\''
print(name)
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

字符串拼接字

1.如何完成字符串拼接？
使用“+”号连接字符串变量或字符串字面量即可
2. 有哪些注意事项？
无法和非字符串类型进行拼接

符串格式化

1.字符串格式化的语法?
“%占位符” % 变量
2. 常用占位符有哪3个？
字符串:%s 整数:%d 浮:%f

"""
演示对表达式进行字符串格式化
"""
print("1 * 1 的结果是：%d" % (1 * 1))
print(f"1 * 2的结果是：{1 * 2}")
print("字符串在Python中的类型名是：%s" % type("字符串"))
1
2
3
4
5
6

格式化的精度控制

1. 精度控制的语法是：
   m.n的形式控制，如%5d、%5.2f、%.2f
   m和.n均可省略
2. 如果m比数字本身宽度还小，会发生什么事？
   m不生效
3. .n会对小数部分做精度限制，同时：？
   会对小数部分做四舍五入

字符串格式化方式2

1.可以通过
f”{变量} {变量}”的方式进行快速格式化
2. 这种方式：
不理会类型
不做精度控制
适合对精度没有要求的时候快速使用

"""
演示第二种字符串格式化的方式：f"{占位}"
"""
name = "传智播客"
set_up_year = 2006
stock_price = 19.99
# f: format
print(f"我是{name}，我成立于：{set_up_year}年，我今天的股价是：{stock_price}")
1
2
3
4
5
6
7
8

对表达式进行格式化

1. 表达式是什么？
   表达式就是一个具有明确结果的代码语句，如 1 + 1、type(“字符串”)、3 * 5等
   在变量定义的时候，如 age = 11 + 11，等号右侧的就是表达式，也就是有具体的结果，将结果赋值给了等号左侧的变量
2. 如何格式化表达式？
   f"{表达式}"
   “%s%d%f” % (表达式、表达式、表达式）

数据输入

1. input()语句的功能是，获取键盘输入的数据
2. 可以使用：input(提示信息)，用以在使用者输入内容之前显示提示信息。
3. 要注意，无论键盘输入什么类型的数据，获取到的数据永远都是字符串类型

"""
演示Python的input语句
获取键盘的输入信息
"""
name = input("请告诉我你是谁？")
print("我知道了，你是:%s" % name)

# 输入数字类型
num = input("请告诉我你的银行卡密码：")
# 数据类型转换
num = int(num)
print("你的银行卡密码的类型是：", type(num))

name = """黑马程序员"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14

03_Python判断语句

布尔类型和比较运算符

1.在Python中，可以表示真假的数据类型是：
布尔类型，字面量True表示真，字面量False表示假
2.除了可以定义布尔类型外，还可以通过计算得到布尔类型？
通过<比较运算符>计算得到布尔类型的结果
== 判断是否相等，!= 判断是否不相等
3.判断是否大于，<判断是否小于
=判断是否大于等于，<=判断是否小于等于

"""
演示布尔类型的定义
以及比较运算符的应用
"""
# 定义变量存储布尔类型的数据
bool_1 = True
bool_2 = False
print(f"bool_1变量的内容是：{bool_1}, 类型是：{type(bool_1)}")
print(f"bool_2变量的内容是：{bool_2}, 类型是：{type(bool_2)}")
# 比较运算符的使用
# == , !=, >, <, >=, <=
# 演示进行内容的相等比较
num1 = 10
num2 = 10
print(f"10 == 10的结果是：{num1 == num2}")

num1 = 10
num2 = 15
print(f"10 != 15的结果是：{num1 != num2}")

name1 = "itcast"
name2 = "itheima"
print(f"itcast == itheima 结果是：{name1 == name2}")

# 演示大于小于，大于等于小于等于的比较运算
num1 = 10
num2 = 5
print(f"10 > 5结果是：{num1 > num2}")
print(f"10 < 5的结果是：{num1 < num2}")

num1 = 10
num2 = 11
print(f"10 >= 11的结果是：{num1 >= num2}")
print(f"10 <= 11的结果是：{num1 <= num2}")
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

if语句的基本格式

1. if语句的基本格式

2. if语句的注意事项：
   判断条件的结果一定要是布尔类型
   不要忘记判断条件后的： 引号
   归属于if语句的代码块，需在前方填充4个空格缩进

"""
演示Python判断语句：if语句的基本格式应用
"""
age = 10

if age >= 18:
    print("我已经成年了")
    print("即将步入大学生活")

print("时间过的真快呀")
1
2
3
4
5
6
7
8
9
10

if else 语句

1.if else 语句，其中
if和其代码块，条件满足时执行
else搭配if的判断条件，当不满足的时候执行
2.if else语句的注意事项：
else不需要判断条件，当if的条件不满足时，else执行
else的代码块，同样要4个空格作为缩进

"""
演示Python中
if else的组合判断语句
"""
age = int(input("请输入你的年龄："))

if age >= 18:
    print("您已成年，需要买票10元。")
else:
    print("您未成年，可以免费游玩。")
1
2
3
4
5
6
7
8
9
10

if elif else语句

1.if elif else语句的作用是？
可以完成多个条件的判断
2.使用if elif else的注意点有：
elif可以写多个
判断是互斥且有序的，上一个满足后面的就不会判断了
可以在条件判断中，直接写input语句，节省代码量

"""
演示if elif else 多条件判断语句的使用
"""

# 通过if判断，可以使用多条件判断的语法
# 第一个条件就是if
if int(input("请输入你的身高（cm）：")) < 120:
    print("身高小于120cm，可以免费。")
elif int(input("请输入你的VIP等级（1-5）：")) > 3:
    print("vip级别大于3，可以免费。")
elif int(input("请告诉我今天几号：")) == 1:
    print("今天是1号免费日，可以免费")
else:
    print("不好意思，条件都不满足，需要买票10元。")
1
2
3
4
5
6
7
8
9
10
11
12
13
14

判断语句的嵌套

1.嵌套判断语句可以用于多条件、多层次的逻辑判断
2.嵌套判断语句可以根据需求，自由组合if elif else来构建多层次判断
3.嵌套判断语句，一定要注意空格缩进，Python通过空格缩进来决定层次关系

"""
演示判断语句的嵌套使用
"""

# if int(input("你的身高是多少：")) > 120:
#     print("身高超出限制，不可以免费")
#     print("但是，如果vip级别大于3，可以免费")
#
#     if int(input("你的vip级别是多少：")) > 3:
#         print("恭喜你，vip级别达标，可以免费")
#     else:
#         print("Sorry 你需要买票10元")
# else:
#     print("欢迎小朋友，免费游玩。")


age = 11
year = 1
level = 1
if age >= 18:
    print("你是成年人")
    if age < 30:
        print("你的年龄达标了")
        if year > 2:
            print("恭喜你，年龄和入职时间都达标，可以领取礼物")
        elif level > 3:
            print("恭喜你，年龄和级别达标，可以领取礼物")
        else:
            print("不好意思，尽管年龄达标，但是入职时间和级别都不达标。")

    else:
        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
33
34
35

04_Python循环语句

while循环的基础语法

1.while循环的语法格式

2.while循环的注意事项：
条件需提供布尔类型结果，True继续，False停止
空格缩进不能
忘请规划好循环终止条件，否则将无限循环

"""
演示while循环的基础应用
"""
i = 0
while i < 100:
    print("小美，我喜欢你")
    i += 1
1
2
3
4
5
6
7

while循环的嵌套应用

1. 嵌套循环的语法格式：见右图
   
2. 嵌套循环需要注意的地方:注意条件的控制，避免无限循环多层嵌套，主要空格缩进来确定层次关系
3. 嵌套循环的使用难点：循环条件的控制，层次越多越复杂，需要细心+耐心

"""
演示while循环的嵌套使用
"""

# 外层：表白100天的控制
# 内层：每天的表白都送10只玫瑰花的控制

i = 1
while i <= 100:
    print(f"今天是第{i}天，准备表白.....")

    # 内层循环的控制变量
    j = 1
    while j <= 10:
        print(f"送给小美第{j}只玫瑰花")
        j += 1

    print("小美，我喜欢你")
    i += 1

print(f"坚持到第{i - 1}天，表白成功")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

for循环的基础语法

1. for循环的语法格式是：

2. for循环的注意点
   无法定义循环条件，只能被动取出数据处理
   要注意，循环内的语句，需要有空格缩进
3. range语句的功能是：
   获得一个数字序列（可迭代类型的一种）

"""
演示for循环的基础语法
"""

name = "itheima"

for x in name:
    # 将name的内容，挨个取出赋予x临时变量
    # 就可以在循环体内对x进行处理
    print(x)

1
2
3
4
5
6
7
8
9
10
11

4. range语句的语法格式：
   语法1：
   语法2：
   语法3：
5. range语句的注意事项：
   语法1从0开始，到num结束（不含num本身）
   语法2从num1开始，到num2结束（不含num2本身）
   语法3从num1开始，到num2结束（不含num2本身），步长以step值为准

"""
演示Python中的range()语句的基本使用
"""

# range语法1 range(num)
# for x in range(10):
#     print(x)

# range 语法2 range(num1, num2)
# for x in range(5, 10):
#     # 从5开始，到10结束（不包含10本身）的一个数字序列，数字之间间隔是1
#     print(x)

# range 语法3 range(num1, num2, step)
# for x in range(5, 10, 2):
#     # 从5开始，到10结束（不包含10本身）的一个数字序列，数字之间的间隔是2
#     print(x)

for x in range(10):
    print("送玫瑰花")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

7. for循环中的临时变量，其作用域限定为：
   循环内

"""
演示Python for循环临时变量的作用域
"""
i = 0
for i in range(5):
    print(i)

print(i)
1
2
3
4
5
6
7
8

8. 这种限定：
   是编程规范的限定，而非强制限定
   不遵守也能正常运行，但是不建议这样做
   如需访问临时变量，可以预先在循环外定义它

for循环的嵌套应用

1. for循环的嵌套语法：
   见右图

2. 注意事项：
   需要注意缩进，嵌套for循环同样通过缩进确定层次关系
   for循环和while循环可以相互嵌套使用

"""
演示嵌套应用for循环
"""

# 坚持表白100天，每天都送10朵花
# range
i = 0
for i in range(1, 101):
    print(f"今天是向小美表白的第{i}天，加油坚持。")

    # 写内层的循环了
    for j in range(1, 11):
        print(f"给小美送的第{j}朵玫瑰花")

    print("小美我喜欢你")

print(f"第{i}天，表白成功")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

循环中断 : break和continue

1. continue的作用是：
   中断所在循环的当次执行，直接进入下一次
2. break的作用是：
   直接结束所在的循环
3. 注意事项：
   continue和break，在for和while循环中作用一致
   在嵌套循环中，只能作用在所在的循环上，无法对上层循环起作用

05-Python函数

函数介绍

1. 函数是：
   组织好的、可重复使用的、用来实现特定功能的代码段
2. 使用函数的好处是：
   将功能封装在函数内，可供随时随地重复利用
   提高代码的复用性，减少重复代码，提高开发效率

函数的定义

1. 函数的定义语法

2. 函数使用步骤:
   先定义函数
   后调用函数
3. 注意事项：
   参数不需要，可以省略
   返回值不需要，可以省略

"""
演示函数的定义语法
"""

# 定义一个函数，输出相关信息
def say_hi():
    print("Hi 我是黑马程序员，学Python来黑马")

# 调用函数，让定义的函数开始工作
say_hi()
1
2
3
4
5
6
7
8
9
10

函数的参数

1. 函数的传入参数的作用是？
   在函数运行的时候，接受外部传入的数据
2. 使用方式

3. 注意事项
   函数定义中的参数，称之为形式参数
   函数调用中的参数，称之为实际参数
   函数的参数数量不限，使用逗号分隔开
   传入参数的时候，要和形式参数一一对应，逗号隔开

"""
演示函数使用参数
"""

# 定义2数相加的函数，通过参数接收被计算的2个数字
def add(x, y, z):
    result = x + y + z
    print(f"{x} + {y} + {z}的计算结果是：{result}")

# 调用函数，传入被计算的2个数字
add(5, 6, 7)
1
2
3
4
5
6
7
8
9
10
11

函数的返回值

函数返回值的定义:

1. 什么是函数返回值？
   函数在执行完成后，返回给调用者的结果
2. 返回值的应用语法：
   使用关键字：return 来返回结果
3. 注意：
   函数体在遇到return后就结束了，所以写在return后的代码不会执行。

None类型:

1. 什么是None
   None是类型’NoneType’的字面量，用于表示：空的、无意义的
2. 函数如何返回None
   不使用return语句即返回None
   主动return None
3. 使用场景
   函数返回值
   if判断
   变量定义

"""
演示：定义函数返回值的语法格式
"""


# 定义一个函数，完成2数相加功能
def add(a, b):
    result = a + b
    # 通过返回值，将相加的结果返回给调用者
    return result
    # 返回结果后，还想输出一句话
    print("我完事了")


# 函数的返回值，可以通过变量去接收
r = add(5, 6)
print(r)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

函数说明文档

1. 函数说明文档的作用是？
   对函数进行说明解释，帮助更好理解函数的功能
2. 定义语法
3. 

:param 用于解释参数
:return 用于解释返回值

"""
演示对函数进行文档说明
"""

# 定义函数，进行文档说明
def add(x, y):
    """
    add函数可以接收2个参数，进行2数相加的功能
    :param x: 形参x表示相加的其中一个数字
    :param y: 形参y表示相加的另一个数字
    :return: 返回值是2数相加的结果
    """
    result = x + y
    print(f"2数相加的结果是：{result}")
    return result

add(5, 6)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

函数的嵌套调用

1. 什么是嵌套调用
   在一个函数中，调用另外一个函数
2. 执行流程
   函数A中执行到调用函数B的语句，会将函数B全部执行完成后，继续执行函数A的剩余内容

"""
演示嵌套调用函数
"""

# 定义函数func_b
def func_b():
    print("---2---")
# 定义函数func_a，并在内部调用func_b
def func_a():
    print("---1---")

    # 嵌套调用func_b
    func_b()

    print("---3---")
# 调用函数func_a
func_a()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

变量的作用域

1. 什么是局部变量
   作用范围在函数内部，在函数外部无法使用
2. 什么是全局变量
   在函数内部和外部均可使用
3. 如何将函数内定义的变量声明为全局变量
   使用global关键字，global 变量

"""
演示在函数使用的时候，定义的变量作用域
"""

# 演示局部变量
# def test_a():
#     num = 100
#     print(num)
#
#
# test_a()
# 出了函数体，局部变量就无法使用了
# print(num)

# 演示全局变量
# num = 200
#
# def test_a():
#     print(f"test_a: {num}")
#
# def test_b():
#     print(f"test_b: {num}")
#
# test_a()
# test_b()
# print(num)

# 在函数内修改全局变量
# num = 200
#
# def test_a():
#     print(f"test_a: {num}")
#
# def test_b():
#     num = 500       # 局部变量
#     print(f"test_b: {num}")
#
# test_a()
# test_b()
# print(num)

# global关键字，在函数内声明变量为全局变量
num = 200

def test_a():
    print(f"test_a: {num}")

def test_b():
    global num      # 设置内部定义的变量为全局变量
    num = 500
    print(f"test_b: {num}")

test_a()
test_b()
print(num)
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
46
47
48
49
50
51
52
53
54
55

06-Python数据容器

数据容器入门

1.什么是数据容器？
一种可以存储多个元素的Python数据类型

2. Python有哪些数据容器？
   list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)
   它们各有特点，但都满足可容纳多个元素的特性。

数据容器：list(列表)

列表的定义:

1. 列表的定义语法
   [元素1, 元素2, 元素3, …]
2. 什么是元素？
   数据容器内的每一份数据，都称之为元素
3. 元素的类型有限制吗？
   元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表

列表的下标索引:

1. 列表的下标索引是什么？
   列表的每一个元素，都有编号称之为下标索引
   从前向后的方向，编号从0开始递增
   从后向前的方向，编号从-1开始递减

2. 如何通过下标索引取出对应位置的元素呢？
   列表[下标]，即可取出
3. 下标索引的注意事项：
   要注意下标索引的取值范围，超出范围无法取出元素，并且会报错

"""
演示数据容器之：list列表
语法：[元素，元素，....]
"""
# 定义一个列表 list
my_list = ["itheima", "itcast", "python"]
print(my_list)
print(type(my_list))

my_list = ["itheima", 666, True]
print(my_list)
print(type(my_list))

# 定义一个嵌套的列表
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))

# 通过下标索引取出对应位置的数据
my_list = ["Tom", "Lily", "Rose"]
# 列表[下标索引], 从前向后从0开始，每次+1，  从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范；通过下标索引取数据，一定不要超出范围
# print(my_list[3])

# 通过下标索引取出数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])


# 取出嵌套列表的元素
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list[1][1])
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

列表的常用操作:

1. 列表的常见方法有:

"""
演示数据容器之：list列表的常用操作
"""
mylist = ["itcast", "itheima", "python"]
# 1.1 查找某元素在列表内的下标索引
index = mylist.index("itheima")
print(f"itheima在列表中的下标索引值是：{index}")
# 1.2如果被查找的元素不存在，会报错
# index = mylist.index("hello")
# print(f"hello在列表中的下标索引值是：{index}")

# 2. 修改特定下标索引的值
mylist[0] = "传智教育"
print(f"列表被修改元素值后，结果是：{mylist}")
# 3. 在指定下标位置插入新元素
mylist.insert(1, "best")
print(f"列表插入元素后，结果是：{mylist}")
# 4. 在列表的尾部追加```单个```新元素
mylist.append("黑马程序员")
print(f"列表在追加了元素后，结果是：{mylist}")
# 5. 在列表的尾部追加```一批```新元素
mylist2 = [1, 2, 3]
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是：{mylist}")
# 6. 删除指定下标索引的元素（2种方式）
mylist = ["itcast", "itheima", "python"]

# 6.1 方式1：del 列表[下标]
del mylist[2]
print(f"列表删除元素后结果是：{mylist}")
# 6.2 方式2：列表.pop(下标)
mylist = ["itcast", "itheima", "python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容：{mylist}, 取出的元素是：{element}")
# 7. 删除某元素在列表中的第一个匹配项
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
mylist.remove("itheima")
print(f"通过remove方法移除元素后，列表的结果是：{mylist}")

# 8. 清空列表
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")
# 9. 统计列表内某元素的数量
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
count = mylist.count("itheima")
print(f"列表中itheima的数量是：{count}")

# 10. 统计列表中全部的元素数量
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
count = len(mylist)
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

2. 列表有哪些特点？

list（列表）的遍历

1. 什么是遍历？
   将容器内的元素依次取出，并处理，称之为遍历操作
2. 如何遍历列表的元素？
   可以使用while或for循环
3. for循环的语法：

4. for循环和while对比
   for循环更简单，while更灵活
   for用于从容器内依次取出元素并处理，while用以任何需要循环的场景

"""
演示使用while和for循环遍历列表
"""


def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return: None
    """
    mylist = ["传智教育", "黑马程序员", "Python"]
    # 循环控制变量：通过下标索引来控制，默认是0
    # 每一次循环，将下标索引变量+1
    # 循环条件：下标索引变量 < 列表的元素数量

    # 定义一个变量，用来标记列表的下标
    index = 0       # 初始下标为0
    while index < len(mylist):
        # 通过index变量取出对应下标的元素
        element = mylist[index]
        print(f"列表的元素：{element}")

        # 至关重要：将循环变量（index）每一次循环都+1
        index += 1


def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return:
    """
    mylist = [1, 2, 3, 4, 5]
    # for 临时变量 in 数据容器:
    for element in mylist:
        print(f"列表的元素有：{element}")


if __name__ == '__main__':
    # list_while_func()
    list_for_func()
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

数据容器：tuple(元组)

1. 元组的定义方式：
   (元素, 元素, 元素, …)
2. 元组的操作方法：
3. 元组的注意事项：
   不可修改内容（可以修改内部list的内部元素）
4. 元组的特点：
   和list基本相同（有序、任意数量元素、允许重复元素），唯一不同在于不可修改。
   支持for循环

"""
演示tuple元组的定义和操作
"""

# 定义元组
t1 = (1, "Hello", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)}, 内容是：{t1}")
print(f"t2的类型是：{type(t2)}, 内容是：{t2}")
print(f"t3的类型是：{type(t3)}, 内容是：{t3}")

# 定义单个元素的元素
t4 = ("hello", )
print(f"t4的类型是：{type(t4)}, t4的内容是：{t4}")
# 元组的嵌套
t5 = ( (1, 2, 3), (4, 5, 6) )
print(f"t5的类型是：{type(t5)}, 内容是：{t5}")

# 下标索引去取出内容
num = t5[1][2]
print(f"从嵌套元组中取出的数据是：{num}")

# 元组的操作：index查找方法
t6 = ("传智教育", "黑马程序员", "Python")
index = t6.index("黑马程序员")
print(f"在元组t6中查找黑马程序员，的下标是：{index}")
# 元组的操作：count统计方法
t7 = ("传智教育", "黑马程序员", "黑马程序员", "黑马程序员", "Python")
num = t7.count("黑马程序员")
print(f"在元组t7中统计黑马程序员的数量有：{num}个")
# 元组的操作：len函数统计元组元素数量
t8 = ("传智教育", "黑马程序员", "黑马程序员", "黑马程序员", "Python")
num = len(t8)
print(f"t8元组中的元素有：{num}个")
# 元组的遍历：while
index = 0
while index < len(t8):
    print(f"元组的元素有：{t8[index]}")
    # 至关重要
    index += 1

# 元组的遍历：for
for element in t8:
    print(f"2元组的元素有：{element}")

# 修改元组内容
# t8[0] = "itcast"

# 定义一个元组
t9 = (1, 2, ["itheima", "itcast"])
print(f"t9的内容是：{t9}")
t9[2][0] = "黑马程序员"
t9[2][1] = "传智教育"
print(f"t9的内容是：{t9}")
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
46
47
48
49
50
51
52
53
54
55

数据容器：str(字符串)

1. 字符串为什么被称之为数据容器呢？
   字符串可以看做是字符的容器，支持下标索引等特性
2. 字符串有哪些常用操作方法？

3. 字符串有哪些特点：

"""
演示以数据容器的角色，学习字符串的相关操作
"""
my_str = "itheima and itcast"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{my_str}取下标为2的元素，。值是：{value},取下标为-16的元素。值是：{value2}")

# my_str[2] = "H"

# index方法
value = my_str.index("and")
print(f"在字符串{my_str}中查找and，其起始下标是：{value}")

# replace方法
new_my_str = my_str.replace("it", "程序")
print(f"将字符串{my_str}，进行替换后得到：{new_my_str}")

# split方法
my_str = "hello python itheima itcast"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到：{my_str_list}, 类型是：{type(my_str_list)}")

# strip方法
my_str = "  itheima and itcast  "
new_my_str = my_str.strip() # 不传入参数，去除首尾空格
print(f"字符串{my_str}被strip后，结果：{new_my_str}")

my_str = "12itheima and itcast21"
new_my_str = my_str.strip("12")
print(f"字符串{my_str}被strip('12')后，结果：{new_my_str}")

# 统计字符串中某字符串的出现次数, count
my_str = "itheima and itcast"
count = my_str.count("it")
print(f"字符串{my_str}中it出现的次数是：{count}")
# 统计字符串的长度, len()
num = len(my_str)
print(f"字符串{my_str}的长度是：{num}")
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

数据容器的切片

1. 什么是序列？
   内容连续、有序，支持下标索引的一类数据容器
2. 哪些数据容器可以视为序列？
   列表、元组、字符串
3. 序列如何做切片
   序列[起始:结束:步长]
   起始可以省略，省略从头开始
   结束可以省略，省略到尾结束
   步长可以省略，省略步长为1（可以为负数，表示倒序执行）

"""
演示对序列进行切片操作
"""

# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]      # 步长默认是1，所以可以省略不写
print(f"结果1：{result1}")

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:]     # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2：{result2}")

# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")


# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]          # 等同于将序列反转了
print(f"结果4：{result4}")


# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}")


# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")
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

数据容器：set(集合)

1.集合有哪些特点:
集合内不允许重复元素（去重） 集合内元素是无序的（不支持下标索引）
2. 集合的定义方式： {元素, 元素, …, 元素}
3. 集合的常用操作

4. 如何遍历集合元素
可以使用for循环进行变量
不可以使用while循环，因为不支持下标索引
5. 集合的特点

"""
演示数据容器集合的使用
"""

# 定义集合
my_set = {"传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima"}
my_set_empty = set()        # 定义空集合
print(f"my_set的内容是：{my_set}, 类型是：{type(my_set)}")
print(f"my_set_empty的内容是：{my_set_empty}, 类型是：{type(my_set_empty)}")

# 添加新元素
my_set.add("Python")
my_set.add("传智教育")      #
print(f"my_set添加元素后结果是：{my_set}")
# 移除元素
my_set.remove("黑马程序员")
print(f"my_set移除黑马程序员后，结果是：{my_set}")
# 随机取出一个元素
my_set = {"传智教育", "黑马程序员", "itheima"}
element = my_set.pop()
print(f"集合被取出元素是：{element}, 取出元素后：{my_set}")

# 清空集合, clear
my_set.clear()
print(f"集合被清空啦，结果是：{my_set}")

# 取2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是：{set3}")
print(f"取差集后，原有set1的内容：{set1}")
print(f"取差集后，原有set2的内容：{set2}")


# 消除2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后，集合1结果：{set1}")
print(f"消除差集后，集合2结果：{set2}")

# 2个集合合并为1个
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"2集合合并结果：{set3}")
print(f"合并后集合1：{set1}")
print(f"合并后集合2：{set2}")

# 统计集合元素数量len()
set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(f"集合内的元素数量有：{num}个")

# 集合的遍历
# 集合不支持下标索引，不能用while循环
# 可以用for循环
set1 = {1, 2, 3, 4, 5}
for element in set1:
    print(f"集合的元素有：{element}")
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

数据容器：dict(字典、映射)

1. 为什么使用字典
   字典可以提供基于Key检索Value的场景实现
   就像查字典一样
2. 字典的定义语法

3. 字典的注意事项
   键值对的Key和Value可以是任意类型（Key不可为字典）
   字典内Key不允许重复，重复添加等同于覆盖原有数据
   字典不可用下标索引，而是通过Key检索Value

"""
演示数据容器字典的定义
"""

# 定义字典
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是：{my_dict1}, 类型：{type(my_dict1)}")
print(f"字典2的内容是：{my_dict2}, 类型：{type(my_dict2)}")
print(f"字典3的内容是：{my_dict3}, 类型：{type(my_dict3)}")

# 定义重复Key的字典
my_dict1 = {"王力鸿": 99, "王力鸿": 88, "林俊节": 77}
print(f"重复key的字典的内容是：{my_dict1}")

# 从字典中基于Key获取Value
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
score = my_dict1["王力鸿"]
print(f"王力鸿的考试分数是：{score}")
score = my_dict1["周杰轮"]
print(f"周杰轮的考试分数是：{score}")
# 定义嵌套字典
stu_score_dict = {
    "王力鸿": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    }, "周杰轮": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    }, "林俊节": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }
}
print(f"学生的考试信息是：{stu_score_dict}")

# 从嵌套字典中获取数据
# 看一下周杰轮的语文信息
score = stu_score_dict["周杰轮"]["语文"]
print(f"周杰轮的语文分数是：{score}")
score = stu_score_dict["林俊节"]["英语"]
print(f"林俊节的英语分数是：{score}")
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
46
47

4. 字典的常用操作

"""
演示字典的常用操作
"""
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
# 新增元素
my_dict["张信哲"] = 66
print(f"字典经过新增元素后，结果：{my_dict}")
# 更新元素
my_dict["周杰轮"] = 33
print(f"字典经过更新后，结果：{my_dict}")
# 删除元素
score = my_dict.pop("周杰轮")
print(f"字典中被移除了一个元素，结果：{my_dict}, 周杰轮的考试分数是：{score}")

# 清空元素, clear
my_dict.clear()
print(f"字典被清空了，内容是：{my_dict}")

# 获取全部的key
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")
# 遍历字典
# 方式1：通过获取到全部的key来完成遍历
for key in keys:
    print(f"字典的key是:{key}")
    print(f"字典的value是：{my_dict[key]}")

# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
    print(f"2字典的key是:{key}")
    print(f"2字典的value是：{my_dict[key]}")

# 统计字典内的元素数量, len()函数
num = len(my_dict)
print(f"字典中的元素数量有：{num}个")
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

5.操作注意
新增和更新元素的语法一致，如果Key不存在即新增，如果Key存在即更新（Key不可重复）
6.字典的特点

数据容器的通用操作

容器通用功能总览

"""
演示数据容器的通用功能
"""
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

# len元素个数
print(f"列表 元素个数有：{len(my_list)}")
print(f"元组 元素个数有：{len(my_tuple)}")
print(f"字符串元素个数有：{len(my_str)}")
print(f"集合 元素个数有：{len(my_set)}")
print(f"字典 元素个数有：{len(my_dict)}")

# max最大元素
print(f"列表 最大的元素是：{max(my_list)}")
print(f"元组 最大的元素是：{max(my_tuple)}")
print(f"字符串最大的元素是：{max(my_str)}")
print(f"集合 最大的元素是：{max(my_set)}")
print(f"字典 最大的元素是：{max(my_dict)}")
# min最小元素
print(f"列表 最小的元素是：{min(my_list)}")
print(f"元组 最小的元素是：{min(my_tuple)}")
print(f"字符串最小的元素是：{min(my_str)}")
print(f"集合 最小的元素是：{min(my_set)}")
print(f"字典 最小的元素是：{min(my_dict)}")
# 类型转换: 容器转列表
print(f"列表转列表的结果是：{list(my_list)}")
print(f"元组转列表的结果是：{list(my_tuple)}")
print(f"字符串转列表结果是：{list(my_str)}")
print(f"集合转列表的结果是：{list(my_set)}")
print(f"字典转列表的结果是：{list(my_dict)}")
# 类型转换: 容器转元组
print(f"列表转元组的结果是：{tuple(my_list)}")
print(f"元组转元组的结果是：{tuple(my_tuple)}")
print(f"字符串转元组结果是：{tuple(my_str)}")
print(f"集合转元组的结果是：{tuple(my_set)}")
print(f"字典转元组的结果是：{tuple(my_dict)}")
# 类型转换: 容器转字符串
print(f"列表转字符串的结果是：{str(my_list)}")
print(f"元组转字符串的结果是：{str(my_tuple)}")
print(f"字符串转字符串结果是：{str(my_str)}")
print(f"集合转字符串的结果是：{str(my_set)}")
print(f"字典转字符串的结果是：{str(my_dict)}")
# 类型转换: 容器转集合
print(f"列表转集合的结果是：{set(my_list)}")
print(f"元组转集合的结果是：{set(my_tuple)}")
print(f"字符串转集合结果是：{set(my_str)}")
print(f"集合转集合的结果是：{set(my_set)}")
print(f"字典转集合的结果是：{set(my_dict)}")
# 进行容器的排序
my_list = [3, 1, 2, 5, 4]
my_tuple = (3, 1, 2, 5, 4)
my_str = "bdcefga"
my_set = {3, 1, 2, 5, 4}
my_dict = {"key3": 1, "key1": 2, "key2": 3, "key5": 4, "key4": 5}

print(f"列表对象的排序结果：{sorted(my_list)}")
print(f"元组对象的排序结果：{sorted(my_tuple)}")
print(f"字符串对象的排序结果：{sorted(my_str)}")
print(f"集合对象的排序结果：{sorted(my_set)}")
print(f"字典对象的排序结果：{sorted(my_dict)}")

print(f"列表对象的反向排序结果：{sorted(my_list, reverse=True)}")
print(f"元组对象的反向排序结果：{sorted(my_tuple, reverse=True)}")
print(f"字符串对象反向的排序结果：{sorted(my_str, reverse=True)}")
print(f"集合对象的反向排序结果：{sorted(my_set, reverse=True)}")
print(f"字典对象的反向排序结果：{sorted(my_dict, reverse=True)}")
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

07-Python函数进阶

函数多返回值

如果一个函数要有多个返回值，该如何书写代码？

按照返回值的顺序，写对应顺序的多个变量接收即可
变量之间用逗号隔开
支持不同类型的数据return

"""
演示函数的多返回值示例
"""

# 演示使用多个变量，接收多个返回值
def test_return():
    return 1, "hello", True

x, y, z = test_return()
print(x)
print(y)
print(z)
1
2
3
4
5
6
7
8
9
10
11
12

函数多种传参方式

1. 掌握位置参数
   ·根据参数位置来传递参数
2. 掌握关键字参数
   ·通过“键=值”形式传递参数，可以不限参数顺序
   ·可以和位置参数混用，位置参数需在前
3. 掌握缺省参数
   ·不传递参数值时会使用默认的参数值
   ·默认值的参数必须定义在最后
4. 掌握不定长参数
   · 位置不定长传递以*号标记一个形式参数，以元组的形式接受参数，形式参数一般命名为args
   · 关键字不定长传递以**号标记一个形式参数，以字典的形式接受参数，形式参数一般命名为kwargs

"""
演示多种传参的形式
"""
def user_info(name, age, gender):
    print(f"姓名是:{name}, 年龄是:{age}, 性别是:{gender}")
# 位置参数 - 默认使用形式
user_info('小明', 20, '男')

# 关键字参数
user_info(name='小王', age=11, gender='女')
user_info(age=10, gender='女', name='潇潇')    # 可以不按照参数的定义顺序传参
user_info('甜甜', gender='女', age=9)

# 缺省参数（默认值）
def user_info(name, age, gender):
    print(f"姓名是:{name}, 年龄是:{age}, 性别是:{gender}")

user_info('小天', 13, '男')


# 不定长 - 位置不定长, *号
# 不定长定义的形式参数会作为元组存在，接收不定长数量的参数传入
def user_info(*args):
    print(f"args参数的类型是：{type(args)}，内容是:{args}")

user_info(1, 2, 3, '小明', '男孩')

# 不定长 - 关键字不定长, **号
def user_info(**kwargs):
    print(f"args参数的类型是：{type(kwargs)}，内容是:{kwargs}")
user_info(name='小王', age=11, gender='男孩')
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

匿名函数

函数作为参数传递

1. 函数本身是可以作为参数，传入另一个函数中进行使用的。

"""
演示函数作为参数传递
"""

# 定义一个函数，接收另一个函数作为传入参数
def test_func(compute):
    result = compute(1, 2)  # 确定compute是函数
    print(f"compute参数的类型是:{type(compute)}")
    print(f"计算结果：{result}")

# 定义一个函数，准备作为参数传入另一个函数
def compute(x, y):
    return x + y
# 调用，并传入函数
test_func(compute)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2. 将函数传入的作用在于：传入计算逻辑，而非传入数据。
   lambda匿名函数
3. 匿名函数使用lambda关键字进行定义
4. 定义语法：

3. 注意事项：
   匿名函数用于临时构建一个函数，只用一次的场景
   匿名函数的定义中，函数体只能写一行代码，如果函数体要写多行代码，不可用lambda匿名函数，应使用def定义带名函数

"""
演示lambda匿名函数
"""

# 定义一个函数，接受其它函数输入
def test_func(compute):
    result = compute(1, 2)
    print(f"结果是:{result}")
# 通过lambda匿名函数的形式，将匿名函数作为参数传入
def add(x, y):
    return x + y
test_func(add)
test_func(lambda x, y: x + y)
1
2
3
4
5
6
7
8
9
10
11
12
13

08-Python文件操作

文件的编码

1. 什么是编码？
   编码就是一种规则集合，记录了内容和二进制间进行相互转换的逻辑。
   编码有许多中，我们最常用的是UTF-8编码
2. 为什么需要使用编码？
   计算机只认识0和1，所以需要将内容翻译成0和1才能保存在计算机中。
   同时也需要编码， 将计算机保存的0和1，反向翻译回可以识别的内容。

文件的读取

1. 操作文件需要通过open函数打开文件得到文件对象
2. 文件对象有如下读取方法：
   read()
   readline()
   readlines()
   for line in 文件对象
3. 文件读取完成后，要使用文件对象.close()方法关闭文件对象，否则文件会被一直占用

"""
演示对文件的读取
"""

# 打开文件
import time

f = open("D:/测试.txt", "r", encoding="UTF-8")
print(type(f))
# 读取文件 - read()
# print(f"读取10个字节的结果：{f.read(10)}")
# print(f"read方法读取全部内容的结果是：{f.read()}")
print("-----------------------------------------------")
# 读取文件 - readLines()
# lines = f.readlines()   # 读取文件的全部行，封装到列表中
# print(f"lines对象的类型：{type(lines)}")
# print(f"lines对象的内容是：{lines}")

# 读取文件 - readline()
# line1 = f.readline()
# line2 = f.readline()
# line3 = f.readline()
# print(f"第一行数据是：{line1}")
# print(f"第二行数据是：{line2}")
# print(f"第三行数据是：{line3}")

# for循环读取文件行
# for line in f:
#     print(f"每一行数据是:{line}")
# # 文件的关闭
# f.close()
# time.sleep(500000)
# with open 语法操作文件
with open("D:/测试.txt", "r", encoding="UTF-8") as f:
    for line in f:
        print(f"每一行数据是：{line}")

time.sleep(500000)
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

文件的写入

1. 写入文件使用open函数的”w”模式进行写入
2. 写入的方法有：
   wirte()，写入内容
   flush()，刷新内容到硬盘中
3. 注意事项：
   w模式，文件不存在，会创建新文件
   w模式，文件存在，会清空原有内容
   close()方法，带有flush()方法的功能

"""
演示文件的写入
"""

# 打开文件，不存在的文件, r, w, a
import time

# f = open("D:/test.txt", "w", encoding="UTF-8")
# # write写入
# f.write("Hello World!!!")       # 内容写入到内存中
# # flush刷新
# # f.flush()                       # 将内存中积攒的内容，写入到硬盘的文件中
# # close关闭
# f.close()                       # close方法，内置了flush的功能的
# 打开一个存在的文件
f = open("D:/test.txt", "w", encoding="UTF-8")
# write写入、flush刷新
f.write("黑马程序员")
# close关闭
f.close()


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

文件的追加

1. 追加写入文件使用open函数的”a”模式进行写入
2. 追加写入的方法有（和w模式一致）：
   wirte()，写入内容
   flush()，刷新内容到硬盘中
3. 注意事项：
   a模式，文件不存在，会创建新文件
   a模式，文件存在，会在原有内容后面继续写入
   可以使用”\n”来写出换行符

"""
演示文件的追加写入
"""

# 打开文件，不存在的文件
# f = open("D:/test.txt", "a", encoding="UTF-8")
# # write写入
# f.write("黑马程序员")
# # flush刷新
# f.flush()
# # close关闭
# f.close()
# 打开一个存在的文件
f = open("D:/test.txt", "a", encoding="UTF-8")
# write写入、flush刷新
f.write("\n月薪过万")
# close关闭
f.close()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

09-Python异常模块与包

了解异常

1. 什么是异常：
   异常就是程序运行的过程中出现了错误
2. bug是什么意思：
   bug就是指异常的意思，因为历史因为小虫子导致计算机失灵的案例，所以延续至今，bug就代表软件出现错误。

"""
主动写一段错误代码，演示异常的出现
"""

# 通过open，读取一个不存在的文件
f = open("D:/abc.txt", "r", encoding="UTF-8")

1
2
3
4
5
6
7

异常的捕获方法

1. 为什么要捕获异常？
   在可能发生异常的地方，进行捕获。当异常出现的时候，提供解决方式，而不是任由其导致程序无法运行。
2. 捕获异常的语法？

3. 如何捕获所有异常？
   异常的种类多种多样，如果想要不管什么类型的异常都能捕获到，那么使用:
   except:
   except Exception:
   两种方式捕获全部的异常

"""
演示捕获异常
"""

# 基本捕获语法
# try:
#     f = open("D:/abc.txt", "r", encoding="UTF-8")
# except:
#     print("出现异常了，因为文件不存在，我将open的模式，改为w模式去打开")
#     f = open("D:/abc.txt", "w", encoding="UTF-8")

# 捕获指定的异常
# try:
#     print(name)
#     # 1 / 0
# except NameError as e:
#     print("出现了变量未定义的异常")
#     print(e)
# 捕获多个异常
# try:
#     # 1 / 0
#     print(name)
# except (NameError, ZeroDivisionError) as e:
#     print("出现了变量未定义 或者 除以0的异常错误")
# 未正确设置捕获异常类型，将无法捕获异常

# 捕获所有异常
try:
    f = open("D:/123.txt", "r", encoding="UTF-8")
except Exception as e:
    print("出现异常了")
    f = open("D:/123.txt", "w", encoding="UTF-8")
else:
    print("好高兴，没有异常。")
finally:
    print("我是finally，有没有异常我都要执行")
    f.close()

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

异常的传递

异常是具有传递性的
当函数func01中发生异常, 并且没有捕获处理这个异常的时候, 异常会传递到函数func02, 当func02也没有捕获处理这个异常的时候main函数会捕获这个异常, 这就是异常的传递性.
提示: 当所有函数都没有捕获异常的时候, 程序就会报错

"""
演示异常的传递性
"""

# 定义一个出现异常的方法
def func1():
    print("func1 开始执行")
    num = 1 / 0     # 肯定有异常，除以0的异常
    print("func1 结束执行")
# 定义一个无异常的方法，调用上面的方法

def func2():
    print("func2 开始执行")
    func1()
    print("func2 结束执行")
# 定义一个方法，调用上面的方法

def main():
    try:
        func2()
    except Exception as e:
        print(f"出现异常了，异常的信息是：{e}")

main()

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

Python模块

1. 什么是模块？
   模块就是一个Python代码文件，内含类、函数、变量等，我们可以导入进行使用。
2. 如何导入模块

3. 注意事项：
   from可以省略，直接import即可
   as别名可以省略
   通过”.”来确定层级关系
   模块的导入一般写在代码文件的开头位置
4. 如何自定义模块并导入？
   在Python代码文件中正常写代码即可，通过import、from关键字和导入Python内置模块一样导入即可使用。
5. name__变量的功能是？
   name__变量 =="**main**"表示，只有当程序是直接执行的才会进入if内部，如果是被导入的，则if无法进入
6. 注意事项
   不同模块，同名的功能，如果都被导入，那么后导入的会覆盖先导入的
   __all__变量可以控制import *的时候哪些功能可以被导入

"""
演示Python的模块导入
"""

from time import sleep

 

# 使用import导入time模块使用sleep功能（函数）
# import time     # 导入Python内置的time模块（time.py这个代码文件）
# print("你好")
# time.sleep(5)   # 通过. 就可以使用模块内部的全部功能（类、函数、变量）
# print("我好")

# 使用from导入time的sleep功能（函数）
# from time import sleep
# print("你好")
# sleep(5)
# print("我好")

# 使用 * 导入time模块的全部功能
# from time import *      # *表示全部的意思
# print("你好")
# sleep(5)
# print("我好")

# 使用as给特定功能加上别名
# import time as t
# print("你好")
# t.sleep(5)
# print("我好")

from time import sleep as sl
print("你好")
sl(5)
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
33
34
35
36
37

"""
演示自定义模块
"""

# 导入自定义模块使用
# import my_module1
# from my_module1 import test
# test(1, 2)

# 导入不同模块的同名功能
# from my_module1 import test
# from my_module2 import test
# test(1, 2)
# __main__变量
# from my_module1 import test

# __all__变量
from my_module1 import *
test_a(1, 2)
# test_b(2, 1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Python包

1. 什么是Python的包？
   包就是一个文件夹，里面可以存放许多Python的模块（代码文件），通过包，在逻辑上将一批模块归为一类，方便使用。
2. init.py文件的作用？
   创建包会默认自动创建的文件，通过这个文件来表示一个文件夹是Python的包，而非普通的文件夹。
3. __all__变量的作用？
   同模块中学习到的是一个作用，控制 import * 能够导入的内容

"""
演示Python的包
"""

# 创建一个包
# 导入自定义的包中的模块，并使用
# import my_package.my_module1
# import my_package.my_module2
#
# my_package.my_module1.info_print1()
# my_package.my_module2.info_print2()

# from my_package import my_module1
# from my_package import my_module2
# my_module1.info_print1()
# my_module2.info_print2()

# from my_package.my_module1 import  
# from my_package.my_module2 import info_print2
# info_print1()
# info_print2()

# 通过__all__变量，控制import * 
from my_package import *
my_module1.info_print1()
my_module2.info_print2()

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

安装第三方Python包

1. 什么是第三方包？有什么作用？
   第三方包就是非Python官方内置的包，可以安装它们扩展功能，提高开发效率。
2. 如何安装？
   在命令提示符内：
   pip install 包名称
   pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称
   在PyCharm中安装

10-综合案例-数据可视化-折线图

json数据格式

1. json：是一种轻量级的数据交互格式, 采用完全独立于编程语言的文本格式来存储和表示数据（就是字符串）
   Python语言使用JSON有很大优势，因为：JSON无非就是一个单独的字典或一个内部元素都是字典的列表
   所以JSON可以直接和Python的字典或列表进行无缝转换。
2. json格式数据转化
   通过 json.dumps(data) 方法把python数据转化为了 json数据
   data = json.dumps(data)
   如果有中文可以带上：ensure_ascii=False参数来确保中文正常转换
   通过 json.loads(data) 方法把josn数据转化为了 python列表或字典
   data = json.loads(data)

"""
演示JSON数据和Python字典的相互转换
"""
import json
# 准备列表，列表内每一个元素都是字典，将其转换为JSON
data = [{"name": "张大山", "age": 11}, {"name": "王大锤", "age": 13}, {"name": "赵小虎", "age": 16}]
json_str = json.dumps(data, ensure_ascii=False)
print(type(json_str))
print(json_str)
# 准备字典，将字典转换为JSON
d = {"name":"周杰轮", "addr":"台北"}
json_str = json.dumps(d, ensure_ascii=False)
print(type(json_str))
print(json_str)
# 将JSON字符串转换为Python数据类型[{k: v, k: v}, {k: v, k: v}]
s = '[{"name": "张大山", "age": 11}, {"name": "王大锤", "age": 13}, {"name": "赵小虎", "age": 16}]'
l = json.loads(s)
print(type(l))
print(l)
# 将JSON字符串转换为Python数据类型{k: v, k: v}
s = '{"name": "周杰轮", "addr": "台北"}'
d = json.loads(s)
print(type(d))
print(d)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

pyecharts模块介绍

1. 开发可视化图表使用的技术栈是：
   Echarts框架的Python版本：PyEcharts包
2. 如何安装PyEcharts包：
   pip install pyecharts
3. 如何查看官方示例
   打开官方画廊：
   https://gallery.pyecharts.org/#/README

pyecharts快速入门

1. pyecharts模块中有很多的配置选项, 常用到三个类别的选项:
   全局配置选项
   系列配置选项
2. 全局配置项能做什么？
   配置图表的标题
   配置图例
   配置鼠标移动效果
   配置工具栏
   等整体配置项

"""
演示pyecharts的基础入门
"""
# 导包
from pyecharts.charts import Line
from pyecharts.options import TitleOpts, LegendOpts, ToolboxOpts, VisualMapOpts
# 创建一个折线图对象
line = Line()
# 给折线图对象添加x轴的数据
line.add_xaxis(["中国", "美国", "英国"])
# 给折线图对象添加y轴的数据
line.add_yaxis("GDP", [30, 20, 10])

# 设置全局配置项set_global_opts来设置,
line.set_global_opts(
    title_opts=TitleOpts(title="GDP展示", pos_left="center", pos_bottom="1%"),
    legend_opts=LegendOpts(is_show=True),
    toolbox_opts=ToolboxOpts(is_show=True),
    visualmap_opts=VisualMapOpts(is_show=True),
)

# 通过render方法，将代码生成为图像
line.render()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

数据处理

创建折线图

"""
演示可视化需求1：折线图开发
"""
import json
from pyecharts.charts import Line
from pyecharts.options import TitleOpts, LabelOpts

# 处理数据
f_us = open("D:/美国.txt", "r", encoding="UTF-8")
us_data = f_us.read()   # 美国的全部内容

f_jp = open("D:/日本.txt", "r", encoding="UTF-8")
jp_data = f_jp.read()   # 日本的全部内容

f_in = open("D:/印度.txt", "r", encoding="UTF-8")
in_data = f_in.read()   # 印度的全部内容

# 去掉不合JSON规范的开头
us_data = us_data.replace("jsonp_1629344292311_69436(", "")
jp_data = jp_data.replace("jsonp_1629350871167_29498(", "")
in_data = in_data.replace("jsonp_1629350745930_63180(", "")

# 去掉不合JSON规范的结尾
us_data = us_data[:-2]
jp_data = jp_data[:-2]
in_data = in_data[:-2]

# JSON转Python字典
us_dict = json.loads(us_data)
jp_dict = json.loads(jp_data)
in_dict = json.loads(in_data)

# 获取trend key
us_trend_data = us_dict['data'][0]['trend']
jp_trend_data = jp_dict['data'][0]['trend']
in_trend_data = in_dict['data'][0]['trend']

# 获取日期数据，用于x轴，取2020年（到314下标结束）
us_x_data = us_trend_data['updateDate'][:314]
jp_x_data = jp_trend_data['updateDate'][:314]
in_x_data = in_trend_data['updateDate'][:314]

# 获取确认数据，用于y轴，取2020年（到314下标结束）
us_y_data = us_trend_data['list'][0]['data'][:314]
jp_y_data = jp_trend_data['list'][0]['data'][:314]
in_y_data = in_trend_data['list'][0]['data'][:314]

# 生成图表
line = Line()       # 构建折线图对象
# 添加x轴数据
line.add_xaxis(us_x_data)   # x轴是公用的，所以使用一个国家的数据即可
# 添加y轴数据
line.add_yaxis("美国确诊人数", us_y_data, label_opts=LabelOpts(is_show=False))     # 添加美国的y轴数据
line.add_yaxis("日本确诊人数", jp_y_data, label_opts=LabelOpts(is_show=False))     # 添加日本的y轴数据
line.add_yaxis("印度确诊人数", in_y_data, label_opts=LabelOpts(is_show=False))     # 添加印度的y轴数据

# 设置全局选项
line.set_global_opts(
    # 标题设置
    title_opts=TitleOpts(title="2020年美日印三国确诊人数对比折线图", pos_left="center", pos_bottom="1%")
)

# 调用render方法，生成图表
line.render()
# 关闭文件对象
f_us.close()
f_jp.close()
f_in.close()
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

11-综合案例-数据可视化-地图

基础地图使用

"""
演示地图可视化的基本使用
"""
from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts

# 准备地图对象
map = Map()
# 准备数据
data = [
    ("北京", 99),
    ("上海", 199),
    ("湖南", 299),
    ("台湾", 399),
    ("广东", 499)
]
# 添加数据
map.add("测试地图", data, "china")

# 设置全局选项
map.set_global_opts(
    visualmap_opts=VisualMapOpts(
        is_show=True,
        is_piecewise=True,
        pieces=[
            {"min": 1, "max": 9, "label": "1-9", "color": "#CCFFFF"},
            {"min": 10, "max": 99, "label": "10-99", "color": "#FF6666"},
            {"min": 100, "max": 500, "label": "100-500", "color": "#990033"}
        ]
    )
)

# 绘图
map.render()
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

疫情地图-国内疫情地图

"""
演示全国疫情可视化地图开发
"""
import json
from pyecharts.charts import Map
from pyecharts.options import *

# 读取数据文件
f = open("D:/疫情.txt", "r", encoding="UTF-8")
data = f.read()     # 全部数据
# 关闭文件
f.close()
# 取到各省数据
# 将字符串json转换为python的字典
data_dict = json.loads(data)        # 基础数据字典
# 从字典中取出省份的数据
province_data_list = data_dict["areaTree"][0]["children"]
# 组装每个省份和确诊人数为元组，并各个省的数据都封装入列表内
data_list = []      # 绘图需要用的数据列表
for province_data in province_data_list:
    province_name = province_data["name"]                   # 省份名称
    province_confirm = province_data["total"]["confirm"]    # 确诊人数
    data_list.append((province_name, province_confirm))


# 创建地图对象
map = Map()
# 添加数据
map.add("各省份确诊人数", data_list, "china")
# 设置全局配置，定制分段的视觉映射
map.set_global_opts(
    title_opts=TitleOpts(title="全国疫情地图"),
    visualmap_opts=VisualMapOpts(
        is_show=True,           # 是否显示
        is_piecewise=True,      # 是否分段
        pieces=[
            {"min": 1, "max": 99, "lable": "1~99人", "color": "#CCFFFF"},
            {"min": 100, "max": 999, "lable": "100~9999人", "color": "#FFFF99"},
            {"min": 1000, "max": 4999, "lable": "1000~4999人", "color": "#FF9966"},
            {"min": 5000, "max": 9999, "lable": "5000~99999人", "color": "#FF6666"},
            {"min": 10000, "max": 99999, "lable": "10000~99999人", "color": "#CC3333"},
            {"min": 100000, "lable": "100000+", "color": "#990033"},
        ]
    )
)
# 绘图
map.render("全国疫情地图.html")
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
46
47

疫情地图-省级疫情地图

"""
演示河南省疫情地图开发
"""
import json
from pyecharts.charts import Map
from pyecharts.options import *

# 读取文件
f = open("D:/疫情.txt", "r", encoding="UTF-8")
data = f.read()
# 关闭文件
f.close()
# 获取河南省数据
# json数据转换为python字典
data_dict = json.loads(data)
# 取到河南省数据
cities_data = data_dict["areaTree"][0]["children"][3]["children"]

# 准备数据为元组并放入list
data_list = []
for city_data in cities_data:
    city_name = city_data["name"] + "市"
    city_confirm = city_data["total"]["confirm"]
    data_list.append((city_name, city_confirm))

# 手动添加济源市的数据
data_list.append(("济源市", 5))

# 构建地图
map = Map()
map.add("河南省疫情分布", data_list, "河南")
# 设置全局选项
map.set_global_opts(
    title_opts=TitleOpts(title="河南省疫情地图"),
    visualmap_opts=VisualMapOpts(
        is_show=True,           # 是否显示
        is_piecewise=True,      # 是否分段
        pieces=[
            {"min": 1, "max": 99, "lable": "1~99人", "color": "#CCFFFF"},
            {"min": 100, "max": 999, "lable": "100~9999人", "color": "#FFFF99"},
            {"min": 1000, "max": 4999, "lable": "1000~4999人", "color": "#FF9966"},
            {"min": 5000, "max": 9999, "lable": "5000~99999人", "color": "#FF6666"},
            {"min": 10000, "max": 99999, "lable": "10000~99999人", "color": "#CC3333"},
            {"min": 100000, "lable": "100000+", "color": "#990033"},
        ]
    )
)

# 绘图
map.render("河南省疫情地图.html")
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
46
47
48
49
50

12-综合案例-数据可视化-动态展示柱状图

基础柱状图

1. 通过Bar()构建一个柱状图对象
2. 和折线图一样，通过add_xaxis()和add_yaxis()添加x和y轴数据
3. 通过柱状图对象的：reversal_axis()，反转x和y轴
4. 通过label_opts=LabelOpts(position=“right”)设置数值标签在右侧显示

"""
演示基础柱状图的开发
"""
from pyecharts.charts import Bar
from pyecharts.options import LabelOpts
# 使用Bar构建基础柱状图
bar = Bar()
# 添加x轴的数据
bar.add_xaxis(["中国", "美国", "英国"])
# 添加y轴数据
bar.add_yaxis("GDP", [30, 20, 10], label_opts=LabelOpts(position="right"))
# 反转x和y轴
bar.reversal_axis()
# 绘图
bar.render("基础柱状图.html")

# 反转x轴和y轴

# 设置数值标签在右侧
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

基础时间线柱状图

1. 什么是时间线？

from pyecharts.charts import Timeline
timeline = Timeline()

2. 自动播放

3. 如何设置主题
timeline = Timeline({“theme”: ThemeType.LIGHT})

"""
演示带有时间线的柱状图开发
"""
from pyecharts.charts import Bar, Timeline
from pyecharts.options import LabelOpts
from pyecharts.globals import ThemeType

bar1 = Bar()
bar1.add_xaxis(["中国", "美国", "英国"])
bar1.add_yaxis("GDP", [30, 30, 20], label_opts=LabelOpts(position="right"))
bar1.reversal_axis()

bar2 = Bar()
bar2.add_xaxis(["中国", "美国", "英国"])
bar2.add_yaxis("GDP", [50, 50, 50], label_opts=LabelOpts(position="right"))
bar2.reversal_axis()

bar3 = Bar()
bar3.add_xaxis(["中国", "美国", "英国"])
bar3.add_yaxis("GDP", [70, 60, 60], label_opts=LabelOpts(position="right"))
bar3.reversal_axis()

# 构建时间线对象
timeline = Timeline({"theme": ThemeType.LIGHT})
# 在时间线内添加柱状图对象
timeline.add(bar1, "点1")
timeline.add(bar2, "点2")
timeline.add(bar3, "点3")

# 自动播放设置
timeline.add_schema(
    play_interval=1000,
    is_timeline_show=True,
    is_auto_play=True,
    is_loop_play=True
)

# 绘图是用时间线对象绘图，而不是bar对象了
timeline.render("基础时间线柱状图.html")
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

"""
扩展列表的sort方法
在学习了将函数作为参数传递后，我们可以学习列表的sort方法来对列表进行自定义排序
"""

# 准备列表
my_list = [["a", 33], ["b", 55], ["c", 11]]

# 排序，基于带名函数
# def choose_sort_key(element):
#     return element[1]
#
# my_list.sort(key=choose_sort_key, reverse=True)
# 排序，基于lambda匿名函数
my_list.sort(key=lambda element: element[1], reverse=True)

print(my_list)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

GDP动态柱状图绘制

"""
演示第三个图表：GDP动态柱状图开发
"""
from pyecharts.charts import Bar, Timeline
from pyecharts.options import *
from pyecharts.globals import ThemeType

# 读取数据
f = open("D:/1960-2019全球GDP数据.csv", "r", encoding="GB2312")
data_lines = f.readlines()
# 关闭文件
f.close()
# 删除第一条数据
data_lines.pop(0)
# 将数据转换为字典存储，格式为：
# { 年份: [ [国家, gdp], [国家,gdp], ......  ], 年份: [ [国家, gdp], [国家,gdp], ......  ], ...... }
# { 1960: [ [美国, 123], [中国,321], ......  ], 1961: [ [美国, 123], [中国,321], ......  ], ...... }
# 先定义一个字典对象
data_dict = {}
for line in data_lines:
    year = int(line.split(",")[0])      # 年份
    country = line.split(",")[1]        # 国家
    gdp = float(line.split(",")[2])     # gdp数据
    # 如何判断字典里面有没有指定的key呢？
    try:
        data_dict[year].append([country, gdp])
    except KeyError:
        data_dict[year] = []
        data_dict[year].append([country, gdp])

# print(data_dict[1960])
# 创建时间线对象
timeline = Timeline({"theme": ThemeType.LIGHT})
# 排序年份
sorted_year_list = sorted(data_dict.keys())
for year in sorted_year_list:
    data_dict[year].sort(key=lambda element: element[1], reverse=True)
    # 取出本年份前8名的国家
    year_data = data_dict[year][0:8]
    x_data = []
    y_data = []
    for country_gdp in year_data:
        x_data.append(country_gdp[0])   # x轴添加国家
        y_data.append(country_gdp[1] / 100000000)   # y轴添加gdp数据

    # 构建柱状图
    bar = Bar()
    x_data.reverse()
    y_data.reverse()
    bar.add_xaxis(x_data)
    bar.add_yaxis("GDP(亿)", y_data, label_opts=LabelOpts(position="right"))
    # 反转x轴和y轴
    bar.reversal_axis()
    # 设置每一年的图表的标题
    bar.set_global_opts(
        title_opts=TitleOpts(title=f"{year}年全球前8GDP数据")
    )
    timeline.add(bar, str(year))


# for循环每一年的数据，基于每一年的数据，创建每一年的bar对象
# 在for中，将每一年的bar对象添加到时间线中

# 设置时间线自动播放
timeline.add_schema(
    play_interval=1000,
    is_timeline_show=True,
    is_auto_play=True,
    is_loop_play=False
)
# 绘图
timeline.render("1960-2019全球GDP前8国家.html")
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

13-面向对象

初识对象

1. 生活中或是程序中，我们都可以使用设计表格、生产表格、填写表格的形式组织数据
2. 进行对比，在程序中：
   设计表格，称之为：设计类（class）
   打印表格，称之为：创建对象
   填写表格，称之为：对象属性赋值

class User:
    name =None
    gender =None
    age =None

user = User()
user.name = "小米"
user.gender = "女"
user.age = 18

print(user)
print(user.name)
print(user.gender)
print(user.age)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

成员方法

1. 类是由哪两部分组成呢？
   类的属性，称之为：成员变量
   类的行为，称之为：成员方法
   注意：函数是写在类外的，定义在类内部，我们都称之为方法哦
2. 类和成员方法的定义语法

3. self的作用
   表示类对象本身的意思
   只有通过self，成员方法才能访问类的成员变量
   self出现在形参列表中，但是不占用参数位置，无需理会

class User:
    name =None
    gender =None
    age =None
    def gosay(self,age =1):
        print(age,self)

user = User()
user.name = "小米"
user.gender = "女"
user.age = 18

print(user)
print(user.name)
print(user.gender)
print(user.age)
user.gosay()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

类和对象

1. 现实世界的事物由什么组成？
   属性
   行为
   类也可以包含属性和行为，所以使用类描述现实世界事物是非常合适的
2. 类和对象的关系是什么？
   类是程序中的“设计图纸”
   对象是基于图纸生产的具体实体
3. 什么是面向对象编程？
   面向对象编程就是，使用对象进行编程。
   即，设计类，基于类创建对象，并使用对象来完成具体的工作

构造方法

1.构造方法的名称是：
_ _ init _ _，注意init前后的2个下划线符号
2. 构造方法的作用： 构建类对象的时候会自动运行 构建类对象的传参会传递给构造方法，借此特性可以给成员变量赋值
3. 注意事项： 构造方法不要忘记self关键字 在方法内使用成员变量需要使用self

class User:
    name =None
    gender =None
    age =None
    def gosay(self):
        print(self.name)

    def __init__(self,name):
        self.name = name
        
user = User("小明")
1
2
3
4
5
6
7
8
9
10
11

其它内置方法

封装

1. 封装的概念是指？
   将现实世界事物在类中描述为属性和方法，即为封装。
2. 什么是私有成员？为什么需要私有成员？
   现实事物有部分属性和行为是不公开对使用者开 放的。同样在类中描述属性和方法的时候也需要达到这个要求，就需要定义私有成员了
3. 如何定义私有成员？
   成员变量和成员方法的命名均以__作为开头即可
4. 私有成员的访问限制？
   类对象无法访问私有成员
   类中的其它成员可以访问私有成员

继承

1. 什么是继承？
   继承就是一个类，继承另外一个类的成员变量和成员方法
   语法：

子类构建的类对象，可以
有自己的成员变量和成员方法 使用父类的成员变量和成员方法
2. 单继承和多继承 单继承：一个类继承另一个类 多继承：一个类继承多个类，按照顺序从左向右依次继承 多继承中，如果父类有同名方法或属性，先继承的优先级高于后继承
3. pass关键字的作用是什么 pass是占位语句，用来保证函数（方法）或类定义的完整性，表示无内容，空的意思
4.复写表示：
对父类的成员属性或成员方法进行重新定义
5.复写的语法：
在子类中重新实现同名成员方法或成员属性即可
6.在子类中，如何调用父类成员

注意：只可以在子类内部调用父类的同名成员，子类的实体类对象调用默认是调用子类复写的

类型注解

1. 什么是类型注解，有什么作用？
   在代码中涉及数据交互之时，对数据类型进行显式的说明，可以帮助：
   PyCharm等开发工具对代码做类型推断协助做代码提示
   开发者自身做类型的备注
2. 类型注解支持：
   变量的类型注解
   函数（方法）的形参和返回值的类型注解
3. 变量的类型注解语法
   语法1： 变量: 类型
   语法2： 在注释中，# type: 类型
4. 注意事项
   类型注解只是提示性的，并非决定性的。数据类型和注解类型无法对应也不会导致错误
5. 函数（方法）可以为哪里添加注解？
   形参的类型注解
   返回值的类型注解
6. 函数（方法）的类型注解语法？

注意，返回值类型注解的符号使用： ->
7.什么是Union类型？
使用Union可以定义联合类型注解
8.Union的使用方式
导包：from typing import Union
使用：Union[类型, …, 类型]

var1 = "1" # type: str

var2: str = "234"

def fun(data : list) -> list:
	return data
    
def fun(data : list) -> list:
	pass
1
2
3
4
5
6
7
8
9

多态

1. 什么是多态？
   多态指的是，同一个行为，使用不同的对象获得不同的状态。
   如，定义函数（方法），通过类型注解声明需要父类对象，实际传入子类对象进行工作，从而获得不同的工作状态
2. 什么是抽象类（接口）
   包含抽象方法的类，称之为抽象类。抽象方法是指：没有具体实现的方法（pass）称之为抽象方法
3. 抽象类的作用
   多用于做顶层设计（设计标准），以便子类做具体实现。
   也是对子类的一种软性约束，要求子类必须复写（实现）父类的一些方法
   并配合多态使用，获得不同的工作状态。

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Dog")

class Cat(Animal):
    def speak(self):
        print("Cat")


def make_noise(animal: Animal):
    animal.speak();

dog = Dog();
cat = Cat();
make_noise(dog);
make_noise(cat);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

14-SQL

数据库介绍

1. 数据库是什么？有什么作用呢？
   数据库就是指数据存储的库，作用就是组织数据并存储数据。
2. 数据库如何组织数据呢？
   按照：库 -> 表 -> 数据 三个层级进行组织
3. 数据库软件是什么？我们学习哪种数据库软件呢？
   数据库软件就是提供库->表->数据，这种数据组织形式的工具软件，也称之为数据库管理系统
   常见的数据库软件有：Oracle、MySQL、SQL Server、PostgreSQL、SQLite，课程以MySQL软件为基础进行学习
4. 数据库和SQL的关系是？
   数据库（软件）提供数据组织存储的能力
   SQL语句则是操作数据、数据库的工具语言

MySQL教程

MySQL教程

Python & MySQL

1. Python中使用什么第三方库来操作MySQL？如何安装？
   使用第三方库为：pymysql
   安装：pip install pymysql
2. 如何获取链接对象？
   from pymysql import Connection 导包
   Connection(主机,端口,账户,密码)即可得到链接对象
   链接对象.close() 关闭和MySQL数据库的连接
3. 如何执行SQL查询
   通过连接对象调用cursor()方法，得到游标对象
   游标对象.execute()执行SQL语句
   游标对象.fetchall()得到全部的查询结果封装入元组内
4. 什么是commit提交？
   pymysql库在执行对数据库有修改操作的行为时，是需要通过链接对象的commit成员方法来进行确认的。
   只有确认的修改，才能生效。
5. 如何自动提交呢？

Python-PyMysql详解

1.简介

PyMySQL 是在 Python3.x 版本中用于连接 MySQL 服务器的一个库 PyMySQL 遵循 Python 数据库 API
v2.0 规范，并包含了 pure-Python MySQL 客户端库。 如果还未安装，我们可以使用以下命令安装最新版的 PyMySQL：

pip install PyMySQL
1

pymysql github地址

2.数据库连接

以下实例链接 Mysql 的 textdb 数据库：

import pymysql

# 打开数据库连接
db = pymysql.connect(host='localhost',
                     user='root',
                     password='xxxxx',
                     database='textdb')

# 使用 cursor() 方法创建一个游标对象 cursor
cursor = db.cursor()

# 使用 execute()  方法执行 SQL 查询，获取数据库版本
cursor.execute("SELECT VERSION()")

# 使用 fetchone() 方法获取单条数据.
data = cursor.fetchone()

print(data)

# 关闭不使用的游标对象
cursor.close()
# 关闭数据库连接
db.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

---

3.创建数据表

如果数据库连接存在我们可以使用execute()方法来为数据库创建表，如下所示创建表EMPLOYEE：

import pymysql

# 打开数据库连接
db = pymysql.connect(host='localhost',
                     user='root',
                     password='xxxxxx',
                     database='text')

# 使用 cursor() 方法创建一个游标对象 cursor
cursor = db.cursor()

# 使用预处理语句创建表
sql = """CREATE TABLE EMPLOYEE (
         FIRST_NAME  CHAR(20) NOT NULL,
         LAST_NAME  CHAR(20),
         AGE INT,  
         SEX CHAR(1),
         INCOME FLOAT )"""

#执行sql语句
cursor.execute(sql)

# 关闭不使用的游标对象
cursor.close()
# 关闭数据库连接
db.close()
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

4.插入操作

普通的插入

以下实例使用执行 SQL INSERT 语句向表 EMPLOYEE 插入记录：

import pymysql

# 打开数据库连接
db = pymysql.connect(host='localhost',
                     user='root',
                     password='xxxxxx',
                     database='text')

# 使用 cursor() 方法创建一个游标对象 cursor
cursor = db.cursor()

# SQL 插入语句
sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
         LAST_NAME, AGE, SEX, INCOME)
         VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
   # 执行sql语句
   cursor.execute(sql)
   # 提交到数据库执行
   db.commit()
except:
   # 如果发生错误则回滚
   db.rollback()

# 关闭不使用的游标对象
cursor.close()
# 关闭数据库连接
db.close()
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

使用变量传值的方式插入数据

以上例子也可以写成如下形式：（注意这里的数字类型使用%s，字符串类型使用'%s'）

import pymysql

# 打开数据库连接
db = pymysql.connect(host='localhost',
                     user='root',
                     password='245074472',
                     database='text')

# 使用 cursor() 方法创建一个游标对象 cursor
cursor = db.cursor()

first_name='dahe'
last_name='dahezhiquan'
age=22
sex='M'
income=18000

# SQL 插入语句
sql = "INSERT INTO EMPLOYEE(FIRST_NAME, \
       LAST_NAME, AGE, SEX, INCOME) \
       VALUES ('%s', '%s',  %s,  '%s',  %s)" % \
       (first_name, last_name, age, sex, income)
try:
   # 执行sql语句
   cursor.execute(sql)
   # 执行sql语句
   db.commit()
except:
   # 发生错误时回滚
   db.rollback()

# 关闭不使用的游标对象
cursor.close()
# 关闭数据库连接
db.close()
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

---

5.查询操作

Python查询Mysql使用 fetchone() 方法获取单条数据, 使用fetchall() 方法获取多条数据。

• fetchone(): 该方法获取下一个查询结果集。结果集是一个对象
• fetchall(): 接收全部的返回结果行.
• rowcount: 这是一个只读属性，并返回执行execute()方法后影响的行数。

查询EMPLOYEE表中salary（工资）字段大于1000的所有数据：

import pymysql

# 打开数据库连接
db = pymysql.connect(host='localhost',
                     user='root',
                     password='xxxxxx',
                     database='text')

# 使用 cursor() 方法创建一个游标对象 cursor
cursor = db.cursor()

# SQL 查询语句
sql = "SELECT * FROM EMPLOYEE \
       WHERE INCOME > %s" % (1000)
try:
    # 执行SQL语句
    cursor.execute(sql)
    # 获取所有记录列表,以元组来存储
    results = cursor.fetchall()
    print(results)
    # 遍历元组存值
    for row in results:
        fname = row[0]
        lname = row[1]
        age = row[2]
        sex = row[3]
        income = row[4]
        # 打印结果
        print("fname=%s,lname=%s,age=%s,sex=%s,income=%s" % \
              (fname, lname, age, sex, income))
except:
    print("错误：没有查找到数据")

# 关闭不使用的游标对象
cursor.close()
# 关闭数据库连接
db.close()
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

---

6.更新操作

更新操作用于更新数据表的数据，以下实例将表中 SEX 为 ‘M’ 的 AGE 字段递增 1：

import pymysql

# 打开数据库连接
db = pymysql.connect(host='localhost',
                     user='root',
                     password='xxxxxx',
                     database='text')

# 使用 cursor() 方法创建一个游标对象 cursor
cursor = db.cursor()

# SQL 更新语句
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = '%c'" % ('M')
try:
   # 执行SQL语句
   cursor.execute(sql)
   # 提交到数据库执行
   db.commit()
except:
   # 发生错误时回滚
   db.rollback()

# 关闭不使用的游标对象
cursor.close()
# 关闭数据库连接
db.close()
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

---

7.删除操作

删除操作用于删除数据表中的数据，以下实例演示了删除数据表 EMPLOYEE 中 AGE 大于 22 的所有数据：

import pymysql

# 打开数据库连接

db = pymysql.connect(host='localhost',
                     user='root',
                     password='xxxxxx',
                     database='text')

# 使用 cursor() 方法创建一个游标对象 cursor
cursor = db.cursor()

# SQL 删除语句
sql = "DELETE FROM EMPLOYEE WHERE AGE > %s" % (22)
try:
   # 执行SQL语句
   cursor.execute(sql)
   # 提交修改
   db.commit()
except:
   # 发生错误时回滚
   db.rollback()

# 关闭不使用的游标对象
cursor.close()
# 关闭数据库连接
db.close()
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

---

8.执行事务

事务机制可以确保数据一致性。
事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。

• 原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。
• 一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
• 隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
• 持久性（durability）。持续性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

Python DB API 2.0 的事务提供了两个方法 commit 和 rollback

# SQL删除记录语句
sql = "DELETE FROM EMPLOYEE WHERE AGE > %s" % (20)
try:
   # 执行SQL语句
   cursor.execute(sql)
   # 向数据库提交
   db.commit()
except:
   # 发生错误时回滚
   db.rollback()
1
2
3
4
5
6
7
8
9
10

对于支持事务的数据库， 在Python数据库编程中，当游标建立之时，就自动开始了一个隐形的数据库事务。
commit()方法游标的所有更新操作，rollback()方法回滚当前游标的所有操作。每一个方法都开始了一个新的事务。

15-PySpark

前言介绍

1. 什么是Spark、什么是PySpark
   Spark是Apache基金会旗下的顶级开源项目，用于对海量数据进行大规模分布式计算。
   PySpark是Spark的Python实现，是Spark为Python开发者提供的编程入口，用于以Python代码完成Spark任务的开发
   PySpark不仅可以作为Python第三方库使用，也可以将程序提交的Spark集群环境中，调度大规模集群进行执行。
2. 为什么要学习PySpark？
   大数据开发是Python众多就业方向中的明星赛道，薪资高岗位多，Spark（PySpark）又是大数据开发中的核心技术
3. 如何衔接大数据开发方向？
   课程以Python第三方库的视角学习使用PySpark，不涉及专业大数据知识，所以完全可以学会
   想要深入大数据开发领域：

基础准备

1. 如何安装PySpark库
   pip install pyspark
2. 为什么要构建SparkContext对象作为执行入口
   PySpark的功能都是从SparkContext对象作为开始
3. PySpark的编程模型是？
   数据输入：通过SparkContext完成数据读取
   数据计算：读取到的数据转换为RDD对象，调用RDD的成员方法完成计算
   数据输出：调用RDD的数据输出相关成员方法，将结果输出到list、元组、字典、文本文件、数据库等

数据输入

1. RDD对象是什么？为什么要使用它？
   RDD对象称之为分布式弹性数据集，是PySpark中数据计算的载体，它可以：
   提供数据存储
   提供数据计算的各类方法
   数据计算的方法，返回值依旧是RDD（RDD迭代计算）
   后续对数据进行各类计算，都是基于RDD对象进行
2. 如何输入数据到Spark（即得到RDD对象）
   通过SparkContext的parallelize成员方法，将Python数据容器转换为RDD对象
   通过SparkContext的textFile成员方法，读取文本文件得到RDD对象

数据计算

map方法

1. map算子（成员方法）
   接受一个处理函数，可用lambda表达式快速编写
   对RDD内的元素逐个处理，并返回一个新的RDD
2. 链式调用
   对于返回值是新RDD的算子，可以通过链式调用的方式多次调用算子。

flatMap方法

1. flatMap算子
   计算逻辑和map一样
   可以比map多出，解除一层嵌套的功能

reduceByKey方法

1. reduceByKey算子
   接受一个处理函数，对数据进行两两计算

filter方法

1. filter算子
   接受一个处理函数，可用lambda快速编写
   函数对RDD数据逐个处理，得到True的保留至返回值的RDD中

distinct方法

1. distinct算子
   完成对RDD内数据的去重操作

sortBy方法

1. sortBy算子
   接收一个处理函数，可用lambda快速编写
   函数表示用来决定排序的依据
   可以控制升序或降序
   全局排序需要设置分区数为1

数据输出

1. Spark的编程流程就是：
   将数据加载为RDD（数据输入）
   对RDD进行计算（数据计算）
   将RDD转换为Python对象（数据输出）
2. 数据输出的方法
   collect：将RDD内容转换为list
   reduce：对RDD内容进行自定义聚合
   take：取出RDD的前N个元素组成list
   count：统计RDD元素个数
   数据输出可用的方法是很多的，本小节简单的介绍了4个。
3. RDD输出到文件的方法
   rdd.saveAsTextFile(路径)
   输出的结果是一个文件夹
   有几个分区就输出多少个结果文件
4. 如何修改RDD分区
   SparkConf对象设置conf.set(“spark.default.parallelism”, “1”)
   创建RDD的时候，sc.parallelize方法传入numSlices参数为1

分布式集群运行

16-【拓展】Python高阶技巧

闭包

1. 什么是闭包
   定义双层嵌套函数， 内层函数可以访问外层函数的变量
   将内存函数作为外层函数的返回，此内层函数就是闭包函数
2. 闭包的好处和缺点
   优点：不定义全局变量，也可以让函数持续访问和修改一个外部变量
   优点：闭包函数引用的外部变量，是外层函数的内部变量。作用域封闭难以被误操作修改
   缺点：额外的内存占用
3. nonlocal关键字的作用
   在闭包函数（内部函数中）想要修改外部函数的变量值
   需要用nonlocal声明这个外部变量

装饰器

1. 什么是装饰器
   装饰器就是使用创建一个闭包函数，在闭包函数内调用目标函数。
   可以达到不改动目标函数的同时，增加额外的功能。
2. 装饰器的写法

设计模式

1. 什么是设计模式
   设计模式就是一种编程套路。
   使用特定的套路得到特定的效果
2. 什么是单例设计模式
   单例模式就是对一个类，只获取其唯一的类实例对象，持续复用它。
   节省内存
   节省创建对象的开销
3. 什么是工厂模式
   将对象的创建由使用原生类本身创建
   转换到由特定的工厂方法来创建
4. 好处

多线程

1. 什么是进程
   程序在操作系统内运行，即成为一个运行进程
2. 什么是线程
   进程内部可以有多个线程，程序的运行本质上就是由进程内部的线程在实际工作的。
3. 什么是并行执行
   多个进程同时在运行，即不同的程序同时运行，称之为：多任务并行执行
   一个进程内的多个线程同时在运行，称之为：多线程并行执行
4. threading模块的使用
   thread_obj = threading.Thread(target=func) 创建线程对象
   thread_obj.start() 启动线程执行
5. 如何传参

网络编程

1. 什么是Socket
   socket (简称 套接字) 是进程之间通信一个工具。
2. 什么是服务端、客户端？

正则表达式

1. 什么是正则表达式
   是一种字符串验证的规则，通过特殊的字符串组合来确立规则
   用规则去匹配字符串是否满足
   如([1]+(.[\w-]+)*@[\w-]+(.[\w-]+)+$)可以表示为一个标准邮箱的格式
2. re模块的三个主要方法
   re.match，从头开始匹配，匹配第一个命中项
   re.search，全局匹配，匹配第一个命中项
   re.findall，全局匹配，匹配全部命中项
3. 字符串的r标记表示，字符串内转移字符无效，作 为普通字符使用
4. 正则表达式的元字符规则

递归

1. 什么是递归
   在满足条件的情况下，函数自己调用自己的一种特殊编程技巧
2. 递归需要注意什么？
   注意退出的条件，否则容易变成无限递归
   注意返回值的传递，确保从最内层，层层传递到最外层
3. os模块的3个方法
   os.listdir，列出指定目录下的内容
   os.path.isdir，判断给定路径是否是文件夹，是返回True，否返回False
   os.path.exists，判断给定路径是否存在，存在返回True，否则返回False