前言

本系列课程仅供 Python 初学者参考，目的是让各位的 Python 期末考试能够如履薄冰。
因本人水平有限，加之编写时间紧张匆忙，难免有疏漏之处，敬请指正。

总目录

• 第一课
• 第二课

本节目录

上次更新时间：2023-11-30 10:43

(点击可直接跳转)

• 1.1 Python 语言基础
     1.1.1 注释规则
     1.1.2 代码缩进
     1.1.3 编码规范
     1.1.4 基本输入和输出
• 1.2 变量
     1.2.1 保留字
     1.2.2 标识符
     1.2.3 定义变量
• 1.3 数据类型
     1.3.1 整型
     1.3.2 浮点型
     1.3.3 文本型
     1.3.4 布尔型
     1.3.5 列表
     1.3.6 元组
     1.3.7 字典
     1.3.8 数据类型转换

第一课

1.1 Python 语言基础

学习 Python 需要了解它的语法特点，如注释规则、代码缩进、编码规范等。下面将展开详细介绍。

1.1.1 注释规则

Python 中的注释类似于语文中的文言文注释。所谓注释，就是在代码中添加标注性的文字，进而帮助更好地阅读代码。

单行注释

在 Python 中，使用 # 作为单行注释的符号。从符号 # 开始到换行为止，其后面的所有内容都被解释器忽略。

用法：

# 注释内容

多行注释

Python 中并没有单独的多行注释标记，而是将包含在一对三引号 (""" """ 或 ''' ''')，并且不属于任何语句的内容视为多行注释。

用法：

"""
注释内容 1
注释内容 2
"""

文件编码声明注释

在 Python 3 中，默认采用 UTF-8 编码。这种编码支持世界上绝大多数语言的字符。

用法：

# -*- coding: 编码 -*-

或者

# coding=编码

例如，指定 GBK 编码:

# -*- coding: gbk -*-

例程

1.大杂烩

# 指定 UTF-8 编码
# -*- coding: utf-8 -*-

# 添加版权信息
"""
 @ 版权所有：沧笙踏歌
 @ 文件名：demo.py
 @ 创建日期：2023年11月23日
 @ 创建人：沧笙踏歌
"""

# 输出多行内容
print("""
众水，众方，众民与众律法的女王
成为人类，就意味着隐藏秘密，经历痛苦，与孤独相伴......
即便如此你也愿意吗？
"即便承受了许多痛苦与孤独，她也不曾质疑世界的美好"
""")

# 注释代码
"""
req = self.session.get(url, headers = get_header(referer_url, Config.User.sessdata, chunk_list), stream = True, proxies = get_proxy(), auth = get_auth())
        
    with open(path, "rb+") as f:
        f.seek(chunk_list[0])

        for chunk in req.iter_content(chunk_size = 1024):
            if chunk:
                f.write(chunk)
                f.flush()

                self.completed_size += len(chunk)

                self.thread_info[thread_id]["chunk_list"][0] += len(chunk)

                if self.completed_size >= self.total_size:
                    self.flag = True
"""

1.1.2 代码缩进

在 Python 中，对于类定义、函数定义、流程控制语句，以及异常处理语句等，行尾的冒号和下一行的缩进表示一个代码块的开始，而缩进结束，则表示一个代码块的结束。

缩进可以使用空格或 Tab 键实现。若使用空格，通常情况下采用 4 个空格作为一个缩进量；而使用 Tab 键，则采用一个 Tab 键作为一个缩进量。

示例：

score = int(input("请输入分数："))

if score < 60:
    grade = "D"
elif score < 70:
    grade = "C"
elif score < 85:
    grade = "B"
elif score <= 100:
    grade = "A"

print("评级：" + grade)

1.1.3 编码规范

在 Python 中采用 PEP8 作为编码规范，其中 PEP 是 Python Enhancement Proposal 的缩写，翻译过来是 Python 增强建议书，而 PEP8 表示版本，它是 Python 代码的样式指南。

以下给出 PEP8 编码规范中的一些应该严格遵守的条目：

• 每个 import 语句只导入一个模块，尽量避免一次导入多个模块
• 不要在行尾添加分号 ;
• 建议每行不超过 80 个字符
• 使用必要的空行可以增加代码的可读性
• 通常情况下，运算符两侧、函数参数之间、逗号 , 两侧建议使用空格进行分隔
• 适当使用异常处理结构提高程序容错性

1.1.4 基本输入和输出

使用 input() 函数输入

在 Python 中，使用 input() 函数接收用户通过键盘输入的内容。

用法：

variable = input("提示文字")

其中，variable 为保存输入结果的变量，双引号内的文字是用于提示用户要输入的内容的。

示例：

tip = input("请输入文字：")

如果想要接收数值，需要把接收的字符串进行类型转换。

示例：

age = int(input("请输入数字："))

例程

1.复读机

a = input("输入：")
print("你刚才输入的是：", a)

使用 print() 函数输出

在 Python 中，使用 print() 函数可将结果输出到控制台中。

用法：

print(输出内容)

其中，输出内容可以是数字和字符串，此类内容将直接输出；也可以是包含运算符的表达式，此类内容将计算结果输出。

示例：

a = 10                       # 变量 a，值为 10
b = 20                       # 变量 b，值为 20

print(10)                    # 输出数字 10
print(a + b)                 # 输出 a + b 的结果 30
print(a if a > b else b)     # 输出条件表达式的结果 20
print("La vaguelette")       # 输出字符串 "La vaguelette"

例程

1.输出 Hello, world

print("Hello, world")

2.输出《唐多令·芦叶满汀洲》

print("唐多令·芦叶满汀洲")
print("宋·刘过")
print("芦叶满汀洲，寒沙带浅流。二十年重过南楼。柳下系船犹未稳，能几日，又中秋。")
print("黄鹤断矶头，故人今在否？旧江山浑是新愁。欲买桂花同载酒，终不似，少年游。")

1.2 变量

在学习变量之前，先来了解什么是保留字和标识符。

1.2.1 保留字

保留字是 Python 中已经被赋予特定意义的单词，在开发时，不可以将保留字作为函数、类、模块和其他对象的名称来使用。
Python 中的保留字如下表所示：

Python 中的保留字也可通过运行以下两行代码查看：

import keyboard
keyborad.kwlist()

1.2.2 标识符

标识符可以简单地理解为一个名字，它主要用来标识变量、函数、类、模块和其它对象名称。

标识符命名原则：

• 以字母、下划线 _ 和数字组成，但不能以数字开头
• 不能使用 Python 中的保留字
• 区分大小写，例如 name 和 Name 是两个不同的标识符
• 不含特殊字符（? / ! 等符号）

示例：

name           # √
value123456    # √
12345          # ×，不能以数字开头
123age         # ×，同上
name56_        # √
_address       # √

1.2.3 定义变量

在 Python 中，不需要先声明变量名和类型，直接赋值即可创建变量。
为变量赋值可以通过等号实现：

用法：

变量名 = value

示例：

# 创建一个整型变量，并赋值 1024
number = 1024

# 创建一个字符串变量
weapon = "静水流涌之辉"

另外，Python 是一种动态类型的语言，也就是说变量的类型可以随时变化。

示例：

# 字符串类型的变量
name = "芙卡洛斯"

# 查看变量类型
print(type(name))

# 修改为整数型
name = 1024

# 查看变量类型
print(type(name))

输出：

<class 'str'>
<class 'int'>

1.3 数据类型

在 Python 中，数据类型主要有以下几种：

1.3.1 整型

整型包括十进制整数、八进制整数、十六进制整数和二进制整数。

十进制整数

十进制整数大家都很熟悉，此处略过。

八进制整数

由 0-7 组成，进位规则“逢八进一”，且以 0o / 0O 开头的数。

例如：0o2000 （十进制的 1024）

十六进制整数

由 0-9、A-F 组成，进位规则“逢十六进一”，且以 0x / 0X 开头的数。

例如：0x29A （十进制的 666）

二进制整数

只有 0 和 1 两个基数，进位规则“逢二进一”。

例如：10000000 （十进制的 128）

例程

1.大杂烩 2.0

# 十进制整数
123
0
-666
-123456789
655365152465492162534245252422152

# 八进制整数，十进制的 83
0o123

# 十六进制整数，十进制的 45086
0xB01E

# 二进制整数，十进制的 10
1010

1.3.2 浮点型

浮点数由整数部分和小数部分组成，主要用于包括小数的数。此外，浮点数也可以使用科学计数法表示。

例如：

1.0
3.1415926535897
1.000000000005
-2.053
-5.66666666666666

# 科学计数法表示
1.5e2
-3.14e5
8.2e-9

1.3.3 字符串型

字符串就是连续的字符串序列，可以是计算机所能表示的一切字符的集合。
在 Python 中，字符串属于不可变序列，通常使用单引号 ''，双引号 ""，或者三引号 ''' '''，""" """ 括起来。
其中，单引号和双引号中的字符必须在一行上，而三引号中的字符可以分布在连续的多行上。

示例：

'我要学树穴'
"树穴猪要烤岩"
"""风与牧歌之城"""

# 跨行书写
"""
我
可
以
跨
行
书
写
[酷]
"""

'但我不可以跨行 [哭哭]'

Python 中的字符串还支持转义字符。所谓转义字符，是指使用反斜杠 \ 对一些特殊字符进行转义。
常用的转义字符如下表所示：

拓展

Python 支持引号的嵌套，规则如下：

• 字符串开始和结尾使用的引号形式必须是一致的，例如 ' 和 '，" 和 "，不可以是 ' 和 "
• 单引号 '' 只能和 双引号 "" 交叉嵌套

示例：

# 单引号中嵌套双引号
'"东去长安万里余，故人何惜一行书。"'

# 双引号中嵌套单引号
"'愿此行，终抵群星'"

# 只能交叉嵌套，以下两种用法均是错误的
''应急食品''
""规则，就是用来打破的！""

# 可以进行多级嵌套，但仍需注意交叉嵌套
"'"'"""TECH OTAKUS SAVE THE WORLD"""'"'"

1.3.4 布尔型

布尔值是表示真和假的值，即 True 和 False。

在 Python 中，所有对象都可以进行真值测试，只有以下列出的情况得到的值为假，其余都为真。

• False
• None
• 数值里的 0，包括 0、0.0、复数 0
• 空序列，包括空字符串、空列表、空元组、空字典

拓展

在 Python 中，布尔值可以转换为数值，其中 True 表示 1，False 表示 0。

示例：

print(True + True)         # 1 + 1
print(True + False)        # 1 + 0
print(1 + False + True)    # 1 + 0 + 1

输出：

2
1
2

1.3.5 列表

序列

首先介绍一下序列的概念。
序列是一块用于存储多个值的内存空间，并且按照一定的顺序排列，每个值（元素）都分配一个数字，称为下标（索引）。通过下标可以取出相应的值。
在 Python 中，序列结构主要有列表、元组、集合、字符串和字典。其中集合和字典不支持下标、切片、相加和相乘操作。

下标

序列中的每个元素都有一个编号，这个编号叫下标，也被称为索引 (index)。
在 Python 中，下标从 0 开始编号，即下标为 0 表示第一个元素，下标为 1 表示第二个元素，以此类推。

例如：

[元素 1, 元素 2, 元素 3, 元素 4, 元素 ..., 元素 n]
   0       1       2      3       ...     n-1        # 下标

Python 比较神奇，它的下标还可以是负数。此时表示从右向左计数，即下标为 -1 表示最后一个元素，下标为 -2 表示倒数第二个元素。

例如：

[元素 1, 元素 2, 元素 3, 元素 ..., 元素 n-1, 元素 n]
   -n    -(n-1)  -(n-2)    ...      -2       -1      # 下标

通过下标可以访问列表中任意元素。

示例：

# 现有仙舟罗浮部分地点组成的一个列表
a = ["神策府", "地衡司", "丹鼎司", "工造司", "太卜司"]

print(a[0])   # 输出第一个元素
print(a[1])   # 输出第二个元素
print(a[-1])   # 输出最后一个元素

输出：

神策府
地衡司
太卜司

切片

切片操作是访问序列中元素的另一种方法，它可以访问一定范围内的元素。通过切片操作可以生成一个新的序列。

用法：

sequence[start: end: step]

参数说明如下：

• sequence：表示序列的名称
• start：表示切片开始的位置（包含该位置，闭区间），如果省略，默认值为 0
• end：表示切片结束的位置（不包含该位置，开区间），如果省略，默认值为序列的长度
• step：表示切片的步长，如果省略，默认值为 1

示例：

verse = ["真名，渡厄真君", "此刻，寂灭之时", "稻光，亦是永恒", "可叹，落叶飘零", "坚冰，断绝深仇", "欢唱，以我之名", "破绽，稍纵即逝", "且尝，苦尽甘来", "知识，与你分享"]

# 输出第 2-6 个元素
print(verse[1:6])

# 输出第 2 个、第 4 个、第 6 个元素
print(verse[1:6:2])

输出：

['此刻，寂灭之时', '稻光，亦是永恒', '可叹，落叶飘零', '坚冰，断绝深仇', '欢唱，以我之名']
['此刻，寂灭之时', '可叹，落叶飘零', '欢唱，以我之名']

序列相加

在 Python 中，支持两种相同类型的序列相加操作，即将两个序列进行连接，不会去除重复的元素，使用加 + 运算符实现。

示例：

verse1 = ["不动鸣神，恒常乐土", "千手百眼，天下人间", "无念无想，泡影断灭", "虚空鼓动，劫火高杨"]
verse2 = ["仿若无因飘落的轻雨", "向深水中的晨星", "罪人舞步旋"]

print(verse1 + verse2)

输出：

['不动鸣神，恒常乐土', '千手百眼，天下人间', '无念无想，泡影断灭', '虚空鼓动，劫火高杨', '仿若无因飘落的轻雨', '向深水中的晨星', '罪人舞步旋']

乘法

在 Python 中，使用数字 n 乘以一个序列会生成新的序列。新序列的内容为原来序列被重复 n 次的结果。

示例：

verse = ["我将，扭转万象", "这一击，贯穿星辰"]

print(verse * 3)

输出：

['我将，扭转万象', '这一击，贯穿星辰', '我将，扭转万象', '这一击，贯穿星辰', '我将，扭转万象', '这一击，贯穿星辰']

检查某个元素是否是序列的成员

在 Python 中，可以使用 in 关键字检查某个元素是否是序列的成员，即检查某个元素是否包含在该序列中。

用法：

element in sequence

其中， element 表示要检查的元素，sequence 表示指定的序列。

例如，要检查名称为 verse 的序列中，是否包含元素 "欢唱，以我之名"，可以使用以下代码：

verse = ["真名，渡厄真君", "此刻，寂灭之时", "稻光，亦是永恒", "可叹，落叶飘零", "坚冰，断绝深仇", "欢唱，以我之名", "破绽，稍纵即逝", "且尝，苦尽甘来", "知识，与你分享"]

print("欢唱，以我之名" in verse)

输出：

True

True 表示在序列中存在指定的元素。

此外，也可以使用 not in 关键字检查某个元素是否不包含在指定的序列中。

示例：

verse = ["真名，渡厄真君", "此刻，寂灭之时", "稻光，亦是永恒", "可叹，落叶飘零", "坚冰，断绝深仇", "欢唱，以我之名", "破绽，稍纵即逝", "且尝，苦尽甘来", "知识，与你分享"]

print("欢唱，以我之名" not in verse)

输出：

False

计算序列的长度、最大值和最小值

在 Python 中，提供了内置函数计算序列的长度、最大值和最小值。接下来将分别介绍。

len() 函数用于计算序列的长度。

示例：

verse = ["真名，渡厄真君", "此刻，寂灭之时", "稻光，亦是永恒", "可叹，落叶飘零", "坚冰，断绝深仇", "欢唱，以我之名", "破绽，稍纵即逝", "且尝，苦尽甘来", "知识，与你分享"]

print("序列 verse 的长度为", len(verse))

输出：

序列 verse 的长度为 9

max() 函数用于计算序列中的最大元素。

示例：

verse = [6, 30, 98, 198, 328, 648]

print("序列 verse 中最大值为", max(verse))

输出：

序列 verse 中最大值为 648

min() 函数用于计算序列中的最小元素。

示例：

verse = [6, 30, 98, 198, 328, 648]

print("序列 verse 中最小值为", min(verse))

输出：

序列 verse 中最小值为 6

除上述的 3 个函数外，Python 还提供了如下表所示的内置函数。

列表

Python 中的列表是由一系列按特定顺序排列的元素组成的。它是 Python 中内置的可变序列。
在形式上，列表的所有元素都放在一对中括号 [] 中，两个相邻的元素使用逗号 , 分隔。在内容上，可以将任何类型的内容放入列表中，并且在一个列表中，元素的类型可以不同。

列表的创建和删除

在 Python 中提供了多种创建列表的方法，下面将分别进行介绍。

1.使用赋值运算符直接创建列表
用法：

listname = [元素1, 元素2, 元素3, ......， 元素n]

其中，listname 表示列表的名称；元素1、元素2、元素3、元素n 表示列表中的元素，个数没有限制。

示例：

num = [1, 2, 3, 4, 5, 6]
slogan = ["遥遥领先", "我们继续领先", "领先同行超过 50%"]
i = [198, 328, 648, "以月色为剑", ["沫芒宫", "欧庇克莱歌剧院", "枫丹科学院"]]
python = ["人生苦短", '我用 Python', True, 0x2c3]

2.创建空列表
示例：

empty = []

3.创建数值列表
在 Python 中，可以使用 list() 函数直接将 range() 函数循环出来的结果转换为列表。

list() 函数的基本语法如下：

list(data)

其中，data 表示可以转换为列表的数据，其类型可以是 range 对象、字符串、元组或者其他可迭代类型的数据。

示例：

# 创建一个 1 - 20（左闭右开，不包括 20）的奇数列表
a = list(range(1, 20, 2))

print(a)

输出：

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

4.删除列表
对于已经创建的列表，当不再使用时，可以使用 del 语句将其删除。

用法：

del listname

其中，listname 为要删除的列表名称。

访问列表元素

在 Python 中，输出列表的内容可以直接使用 print() 函数。

示例：

a = ["神策府", "地衡司", "丹鼎司", "工造司", "太卜司"]

print(a)

输出：

['神策府', '地衡司', '丹鼎司', '工造司', '太卜司']

从上述执行结果可以看出，在输出列表时，是包括左右两侧的中括号的。如果不想输出全部元素，也可以通过列表的下标获取指定的元素。

例如，要获取列表 a 中下标为 3 的元素，可以使用下列代码：

print(a[3])

输出：

工造司

从上述执行结果可以看出，在输出单个列表元素时，不包括中括号，如果是字符串，还不包括左右的引号。

例程
1.每日一贴

# 导入日期时间类
import datetime

days = ["星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"]
sentences = [
    "山重水复疑无路，柳暗花明又一村",
    "攀登时节动群英，奋发日夜向前行",
    "古之立大事者，不惟有超世之才，亦必有坚忍不拔之志",
    "路漫漫其修远兮，吾将上下而求索",
    "非学无以广才，非志无以成学",
    "不经一番寒彻骨，怎得梅花扑鼻香",
    "人生自是有情痴，此恨不关风与月"
]

# 获取当前星期
day = datetime.datetime.now().weekday()

# 输出每日一贴
print("今天是" + days[day] + "，继续努力哦！\n")
print(sentences[day])

输出：

今天是星期五，继续努力哦！

非学无以广才，非志无以成学

在上述代码中，datetime.datetime.now() 用于获取当前日期，而 weekday() 方法则是从时间对象中获取星期，其值为 0-6，0 代表星期一，1 代表星期二，以此类推，6 代表星期日。

遍历列表

遍历列表中的所有元素是常用的一种操作，在遍历的过程中可以完成查询，处理等功能。在 Python 中，遍历列表的方法有很多种，下面介绍常用的两种方法。

1.使用 for 循环实现
使用 for 循环遍历列表，只能输出元素的值。

用法：

for item in listname:
    # 代码块

其中，item 用于保存获取到的元素值，要输出元素的内容时，直接输出该变量即可；listname 为列表名称。

示例：

verse = ["真名，渡厄真君", "此刻，寂灭之时", "稻光，亦是永恒", "可叹，落叶飘零", "坚冰，断绝深仇", "欢唱，以我之名", "破绽，稍纵即逝", "且尝，苦尽甘来", "知识，与你分享"]

# 输出各个元素的内容
for item in verse:
    print(item)

输出：

真名，渡厄真君
此刻，寂灭之时
稻光，亦是永恒
可叹，落叶飘零
坚冰，断绝深仇
欢唱，以我之名
破绽，稍纵即逝
且尝，苦尽甘来
知识，与你分享

2.使用 for 循环和 enumerate() 函数实现
使用 for 循环和 enumerate() 函数可以实现同时输出下标和元素内容。

用法：

for index, value in enumerate(listname):
    # 代码块

参数说明如下：

• index：用于保存元素的下标
• value: 用于保存获取到的元素值
• listname：列表名称

示例：

verse = ["真名，渡厄真君", "此刻，寂灭之时", "稻光，亦是永恒", "可叹，落叶飘零", "坚冰，断绝深仇", "欢唱，以我之名", "破绽，稍纵即逝", "且尝，苦尽甘来", "知识，与你分享"]

# 输出各个元素的下标和内容
for index, value in enumerate(verse):
    print(index, value)

输出：

0 真名，渡厄真君
1 此刻，寂灭之时
2 稻光，亦是永恒
3 可叹，落叶飘零
4 坚冰，断绝深仇
5 欢唱，以我之名
6 破绽，稍纵即逝
7 且尝，苦尽甘来
8 知识，与你分享

添加、修改和删除列表元素

1.添加元素
列表对象的 append() 方法用于在列表的末尾添加一个元素。

用法：

listname.append(obj)

其中，listname 为要添加元素的列表名称；obj 为要添加到列表末尾的对象。

示例：

a = [1, 2, 3, 4, 5]

# 添加一个元素 6
a.append(6)

# 输出
print(a)

输出：

[1, 2, 3, 4, 5, 6]

若想要将一个列表中的全部元素添加到另一个列表中，可以使用列表对象的 extend() 方法实现。

用法：

listname.extend(seq)

其中，listname 为原列表；seq 为要添加的列表。执行后，seq 的内容将追加到 listname 的末尾。

示例：

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

# 合并列表
a.extend(b)

# 输出
print(a)

输出：

[1, 2, 3, 'a', 'b', 'c']

2.修改元素
修改列表中的元素只需要通过下标获取该元素，然后重新为其赋值即可。

示例：

a = [1, 2, 3]

# 将下标为 0 的元素修改为 1000
a[0] = 1000

# 输出
print(a)

输出：

[1000, 2, 3]

3.删除元素
（1）根据下标删除

删除列表中的指定元素和删除列表类似，也可以使用 del 语句实现。不同的是在指定列表名称时，换成列表元素。

示例：

a = [1, 2, 3, 4, 5, 888]

# 删除元素 888，其下标为 5
del a[5]

# 输出
print(a)

输出：

[1, 2, 3, 4, 5]

（2）根据元素值删除

使用列表对象的 remove() 方法可以根据元素值删除元素。

示例：

a = [1, 2, 3, 666]

# 删除元素 666
a.remove(666)

# 输出
print(a)

输出：

[1, 2, 3]

当指定的元素不存在时，将会抛出 ValueError 异常。所以在使用 remove() 方法删除元素前，最好先判断该元素是否存在。

示例：

a = [1, 2, 3, 666]
value = 888

# 判断要删除的元素是否存在
if value in a:
    # 删除指定元素
    a.remove(value)

# 输出
print(a)

输出：

[1, 2, 3, 666]

对列表进行统计计算

1.获取指定元素出现的次数
使用列表对象的 count() 方法可以获取指定元素在列表中出现的次数。

用法：

listname.count(obj)

其中，listname 表示列表的名称；obj 表示要获取出现次数的对象。

示例：

# 某人跃迁了十次，获得：
verse = [
    "平平无奇的垃圾",
    "乏善可陈的垃圾",
    "普普通通的垃圾",
    "中规中矩的垃圾",
    "朴实无华的垃圾",
    "不值一提的垃圾",
    "平平无奇的垃圾",
    "稀松平常的垃圾",
    "平平无奇的垃圾",
    "百里挑一的垃圾"
]

# 请问一共获得了多少个 "平平无奇的垃圾" ？
print(verse.count("平平无奇的垃圾"))

输出：

3

2.获取指定元素首次出现的下标
使用列表对象的 index() 方法可以获取指定元素在列表中首次出现的位置（下标）。

用法：

listname.index(obj)

参数说明如下：

• listname：表示列表名称
• obj：表示要查找的对象
• 返回值：首次出现的下标位置

示例：

# 某人跃迁了十次，获得：
verse = [
    "平平无奇的垃圾",
    "乏善可陈的垃圾",
    "普普通通的垃圾",
    "中规中矩的垃圾",
    "朴实无华的垃圾",
    "不值一提的垃圾",
    "平平无奇的垃圾",
    "稀松平常的垃圾",
    "平平无奇的垃圾",
    "百里挑一的垃圾"
]

# 请问首次获得 "平平无奇的垃圾" 是在第几次？
index = verse.index("平平无奇的垃圾")
print("下标位置：" + str(index))
print("实际次数：第", index + 1, "次")

输出：

下标位置：0
实际次数：第 1 次

3.统计数值列表的元素和
在 Python 中，提供了 sum() 函数用于统计数值列表中各元素的和。

用法：

sum(iterable[, start])

参数说明如下：

• iterable：表示要统计的列表
• start：从指定下标的元素开始统计，默认为 0

示例：

# 某人最近的账单
bill = [6, 30, 98, 198, 328, 648]

# 计算账单总金额
total = sum(bill)

# 输出
print("账单金额为", total)

输出：

账单金额为 1308

对列表进行排序

1.使用列表对象的 sort() 方法实现
列表对象提供了 sort() 方法用于对原列表中的元素进行排序。排序后，原列表的元素顺序将发生改变。

用法：

listname.sort(key = None, reverse = False)

参数说明如下：

• listname：表示要排序的列表
• key：用于指定一个函数，根据该函数的返回值对列表进行排序。默认值为 None，表示使用列表元素自身的值进行排序
• reverse：排序方式，True 表示降序排列，False 表示升序排列，默认为 False

示例：

# 某人最近的账单
bill = [648, 98, 328, 328, 60, 648, 6]
print("原列表", bill)

# 进行升序排列
bill.sort(reverse = False)
print("升序", bill)

# 进行降序排列
bill.sort(reverse = True)
print("降序", bill)

输出：

原列表 [648, 98, 328, 328, 60, 648, 6]
升序 [6, 60, 98, 328, 328, 648, 648]
降序 [648, 648, 328, 328, 98, 60, 6]

如果想要对字符串列表进行排序，则需要指定其 key 参数。

示例：

characters = ["Furina", "Neuvillette", "navia", "Wriothesley","charlotte", "Lyney", "lynette", "freminet", "Chevreuse"]

# 区分字母大小写
characters.sort()
print("区分字母大小写", characters)

# 不区分字母大小写
characters.sort(key = str.lower)
print("不区分字母大小写", characters)

输出：

区分字母大小写 ['Chevreuse', 'Furina', 'Lyney', 'Neuvillette', 'Wriothesley', 'charlotte', 'freminet', 'lynette', 'navia']
不区分字母大小写 ['charlotte', 'Chevreuse', 'freminet', 'Furina', 'lynette', 'Lyney', 'navia', 'Neuvillette', 'Wriothesley']

2.使用内置的 sorted() 函数实现
在 Python 中，提供了一个内置的 sorted() 函数，用于对列表进行排序。与列表对象的 sort() 方法不同的是，排序后原列表的元素排列顺序不变。

用法：

sorted(lsitname, key = None, reverse = False)

参数说明如下：

• listname：表示要排序的列表
• key：用于指定一个函数，根据该函数的返回值对列表进行排序。默认值为 None，表示使用列表元素自身的值进行排序
• reverse：排序方式，True 表示降序排列，False 表示升序排列，默认为 False

示例：

# 某人最近的账单
bill = [648, 98, 328, 328, 60, 648, 6]
print("原列表", bill)

# 进行升序排列
bill_as = sorted(bill)
print("升序", bill_as)

# 进行降序排列
bill_des = sorted(bill, reverse = True)
print("降序", bill_des)

输出：

原列表 [648, 98, 328, 328, 60, 648, 6]
升序 [6, 60, 98, 328, 328, 648, 648]
降序 [648, 648, 328, 328, 98, 60, 6]

列表推导式

使用列表推导式可以快速生成一个列表，或根据某个列表生成满足指定需求的列表。列表推导式通常有以下几种常用的语法格式：

（1）根据序列生成新的列表
用法：

list = [Expression for var in sequence]

参数说明如下：

• list：表示生成的列表名称
• Expression：表达式
• var：循环变量
• sequence：用于生成新列表的原序列

示例：

# 商品价格列表
price = [1999, 2499, 3299, 4299, 6999]

# 输出打五折价格
sale = [int(i * 0.5) for i in price]

print("原价", price)
print("打五折后", sale)

输出：

原价 [1999, 2499, 3299, 4299, 6999]
打五折后 [999, 1249, 1649, 2149, 3499]

（2）根据序列生成新的符合指定条件的列表
用法：

list = [Expression for var in sequence if condition]

参数说明如下：

• list：表示生成的列表名称
• Expression：表达式
• var：循环变量
• sequence：用于生成新列表的原序列
• condition：条件表达式

示例：

# 生成 1-20 以内的合数
prime_number = [i for i in range(1, 21) if (i % 2 == 0 and i != 2) or (i % 3 == 0 and i != 3) or (i % 5 == 0 and i != 5)]

print(prime_number)

输出：

[4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20]

二维列表

顾名思义，二维列表就是包含列表的列表。也就是一个列表中的元素又都是一个列表。

示例：

# 下列列表就是二维列表
[
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

创建二维列表后，可以通过以下格式访问列表中的元素：

listname[下标1][下标2]

参数说明如下：

• listname：表示列表名称
• 下标1：表示列表的第几行
• 下标2：表示列表的第几列

例如，可将下表表示为二维列表：

代码如下：

a = [
    [101, 102, 103, 104, 105],
    [201, 202, 203, 204, 205],
    [301, 302, 303, 304, 305]
]

访问二维列表的元素：

print(a[0][1])
print(a[1][2])
print(a[2][4])

输出：

102
203
305

1.3.6 元组

元组是 Python 中另一个重要的序列结构。与列表类似，也是由一系列按特定顺序排列的元素组成。但是，它为不可变序列。因此，元组也称不可变列表。
在形式上，元组的所有元素都放在一对小括号 () 中，两个相邻元素使用逗号 , 分隔。在内容上，可以将任何类型的内容放入元组中，并且在一个元组中，元素的类型可以不同。

元组的创建和删除

1.使用赋值运算符直接创建元组
用法：

tuplename = (元素1, 元素2, 元素3, ......)

其中，listname 表示元组的名称；元素1、元素2、元素3、元素n 表示元组中的元素，个数没有限制。

示例：

num = (1, 2, 3, 4, 5, 6)
slogan = ("遥遥领先", "我们继续领先", "领先同行超过 50%")
i = (198, 328, 648, "以月色为剑", ["沫芒宫", "欧庇克莱歌剧院", "枫丹科学院"])
python = ("人生苦短", '我用 Python', True, 0x2c3)

在 Python 中，虽然元组是使用一对小括号将所有元素括起来，但实际上，小括号并不是必须的，只要将一组值用逗号分隔开，Python 就可以认为它是元组。

示例：

verse = "Non, le grand amour ne suffit pas.", "Seul un adieu fleurira.", "C'est notre histoire de vie, douce et amère."

输出该元组后，将显示以下内容：

('Non, le grand amour ne suffit pas.', 'Seul un adieu fleurira.', "C'est notre histoire de vie, douce et amère.")

如果要创建的元组只包括一个元素，则需要在定义元组时，在元组后面加一个逗号 ,。

示例：

verse = ("Moi, je suis et serai toujours là,",)

输出 verse，将显示以下内容：

('Moi, je suis et serai toujours là,',)

而下述代码，则表示定义一个字符串：

verse = ("Moi, je suis et serai toujours là,")

输出 verse，将显示以下内容：

'Moi, je suis et serai toujours là,'

2.创建空元组
示例：

empty = ()

3.创建数值元组
在 Python 中，可以使用 tuple() 函数直接将 range() 函数循环出来的结果转换为元组。

tuple() 函数的基本语法如下：

tuple(data)

其中，data 表示可以转换为元组的数据，其类型可以是 range 对象、字符串、列表或者其他可迭代类型的数据。

示例：

# 创建一个 1 - 20（左闭右开，不包括 20）的奇数元组
a = tuple(range(1, 20, 2))

print(a)

输出：

(1, 3, 5, 7, 9, 11, 13, 15, 17, 19)

4.删除元组
对于已经创建的元组，当不再使用时，可以使用 del 语句将其删除。

用法：

del tuplename

其中，tuplename 为要删除的元组名称。

访问元组元素

类比列表的元素访问，其原理是完全一样的，这里不再过多赘述。

修改元组

由于元组是不可变序列，无法对它的单个元素值修改，但我们可以通过给元组重新赋值来修改元组。

示例：

language = ("C", "C++", "Java", "Python")
language = ("C", "C++", "C#", "Java")

print(language)

输出：

('C', 'C++', 'C#', 'Java')

元组推导式

使用元组推导式可以快速生成一个元组，它的表现形式和列表推导式类似，只是将列表推导式中的中括号 [] 修改为小括号 ()。

示例：

verse = (i for i in range(10))

print("生成的元组为", verse)

输出：

生成的元组为 <generator object <genexpr> at 0x000001F9C377F2A0>

从上述执行结果可以看出，使用元组推导式生成的结果并不是一个元组或者列表，而是一个生成器对象。要使用生成器对象，可以将其转换为元组或者列表。

示例：

verse = (i for i in range(10))

print("转换后", tuple(verse))

输出：

转换后 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

要使用生成器对象，还可以直接通过 for 循环遍历，或者直接使用 __next__() 方法进行遍历。

示例：

number = (i for i in range(3))
print(number.__init__())
print(number.__init__())
print(number.__init__())
print("转换后", tuple(number))

输出：

0
1
2
转换后 ()

再如，使用 for 循环遍历生成器对象，输出每个元素的值：

number = (i for i in range(3))

for i in number:
    print(i)

print(tuple(number))

输出：

0
1
2
()

从上述两个示例可以看出，无论通过哪种方法遍历，遍历后的原生成器对象都已经不存在。

1.3.7 字典

字典是无序、可变的，保存的内容是以“键—值对”的形式存储的。类似于词典，它可以把单词和释义关联起来。通过单词就可以快速找到它的释义。其中，单词相当于键（key），而对应的释义相当于值 （value）。键是唯一的，而值可以有多个。

字典的主要特征如下：

• 通过键而不是下标存取数据
• 字典是任意对象的无序集合
• 字典是可变的，并且可以任意嵌套
• 字典的键必须唯一，不允许出现两个相同的键，如果出现两次，后者将会覆盖前者
• 字典的键必须不可变，所以可以使用数字、字符串或元组，但不能使用列表

字典的创建和删除

定义字典时，每个元素都包含两个部分—“键”和“值”，并且在“键”和“值”之间使用冒号分隔，相邻两个元素使用逗号分隔，所有元素放在一个大括号“{}”中。

用法：

dictionary = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3', ......, 'keyn': 'valuen'}

参数说明如下：

• dictionary：表示字典的名称
• key：表示键，必须是唯一的
• value：表示值，可以是任何数据类型

示例：

# 我们将尘世七执政中部分神明放进一个名叫 characters 的字典
characters = {"风神": "温迪", "岩神": "钟离", "雷神": "雷电将军", "草神": "纳西妲", "水神": "芙宁娜"}

同列表或元组一样，也可以创建空字典。在 Python 中，可以使用下列两种方法创建空字典：

dictionary = {}

或者：

dictionary = dict()

Python 的 dict() 方法除了可以创建一个空字典，还可以通过已有数据快速创建字典。

1.通过映射函数创建字典
用法：

dictionary = dict(zip(list1, list2))

参数说明如下：

• dictionary：表示字典的名称
• zip() 函数：用于将多个列表或元组对应位置的元素组合为元组，并返回包含这些内容的 zip 对象。如果想得到元组，可以使用 tuple() 函数将 zip 对象转换为元组；如果想得到列表，可以使用 list() 函数将其转换为列表。
• list1：表示一个列表，用于指定字典的键
• list2：表示一个列表，用于指定字典的值

如果 list1 和 list2 的长度不同，则与最短的列表长度相同。

示例：

key = ["风神", "岩神", "雷神", "草神", "水神"]
value = ["温迪", "钟离", "雷电将军", "纳西妲", "芙宁娜"]

characters = dict(zip(key, value))
print(characters)

输出：

{'风神': '温迪', '岩神': '钟离', '雷神': '雷电将军', '草神': '纳西妲', '水神': '芙宁娜'}

2.通过给定的“键—值对”创建字典
用法：

dictionary = dict(key1 = value1, key2 = value2, ......, keyn = valuen)

参数说明如下：

• dictionary：表示字典的名称
• key：表示键，必须是唯一的
• value：表示值，可以是任何数据类型

示例：

characters = dict("风神" = "温迪", "岩神" = "钟离", "雷神" = "雷电将军", "草神" = "纳西妲", "水神" = "芙宁娜")

print(characters)

在 Python 中，还可以使用 dict 对象的 fromkeys() 方法创建值为空的字典。
示例：

dictionary = dict.fromkeys(list1)

参数说明如下：

• dictionary：表示字典的名称
• list1：作为字典的键的列表

示例：

key = ["风神", "岩神", "雷神", "草神", "水神"]

characters = dict.fromkeys(key)
print(characters)

输出：

{'风神': None, '岩神': None, '雷神': None, '草神': None, '水神': None}

同列表和元组一样，对于不再需要的字典，也可以使用 del 语句将其删除。
示例：

del dictionary

另外，如果只是想删除字典的全部元素，可以使用字典对象的 clear() 方法。执行 clear() 方法后，原字典将变为空字典。
示例：

dictionary.clear()

除上述介绍的方法外，还可以使用字典对象的 pop() 方法删除并返回指定“键”的元素，以及使用字典对象的 popitem() 方法删除并返回字典中的一个元素。

访问字典

在 Python 中，如果想将字典的内容输出也比较简单，可以直接使用 print() 函数。
示例：

# 打印之前的 characters 字典
print(characters)

输出：

{'风神': '温迪', '岩神': '钟离', '雷神': '雷电将军', '草神': '纳西妲', '水神': '芙宁娜'}

然而，在使用字典时，很少会直接输出它的内容。一般需要根据指定的键得到相应的值。在 Python 中，访问字典的元素可以通过下标的方式实现，与列表和元组不同，这里的下标不是索引，而是键。
例如，想要获取“水神”的名字，可以使用下列代码：

print(characters["水神"])

输出：

芙宁娜

在上述方法获取指定键的值时，如果指定的键不存在，将抛出如下异常：

Traceback (most recent call last):
  File "d:\Projects\Python\lesson\example.py", line 2, in <module>
    print(characters["水神"])
          ~~~~~~~~~~^^^^^^
KeyError: '水神'

在实际开发中，很可能我们不知道当前存在什么键，所以要避免上述异常的产生。具体的解决方法是使用条件表达式对不存在的情况进行处理，即给一个默认值。
例如，可以将上述代码修改为：

print(characters["水神"] if "水神" in characters else "无")

当“水神”不存在时，将显示以下内容：

无

另外，Python 中推荐的方法是使用字典对象的 get() 方法获取指定键的值。
用法：

dictionary.get(key[,default])

其中，dictionary 为字典对象；key 为指定的键；default 为可选项，用于当指定的键不存在时，返回一个默认值，如果省略，则返回 None。
例如，通过 get() 方法获取“水神”的名字，可以使用下列代码：

print(characters.get("水神"))

输出：

芙宁娜

遍历字典

字典是以“键—值对”的形式存储数据的，所以就可能需要对这些“键—值对”进行获取。Python 提供了遍历字典的方法，通过遍历可以获取字典中的全部“键—值对”。
使用字典对象的 items() 方法可以获取字典的“键—值对”列表。
用法：

dictionary.items()

其中，dictionary 为字典对象；返回值为可遍历的“键—值对”元组列表。想要获取具体的“键—值对”，可以通过 for 循环遍历该元组列表。
示例：

characters = {"风神": "温迪", "岩神": "钟离", "雷神": "雷电将军", "草神": "纳西妲", "水神": "芙宁娜"}

for item in characters.items():
    print(item)

输出：

('风神', '温迪')
('岩神', '钟离')
('雷神', '雷电将军')
('草神', '纳西妲')
('水神', '芙宁娜')

上述示例得到的是元组中的各个元素，如果想要获取具体的每个键和值，可以使用下列代码：

characters = {"风神": "温迪", "岩神": "钟离", "雷神": "雷电将军", "草神": "纳西妲", "水神": "芙宁娜"}

for key, value in characters.items():
    print(key, "是", value)

输出：

风神 是 温迪
岩神 是 钟离
雷神 是 雷电将军
草神 是 纳西妲
水神 是 芙宁娜

添加、修改和删除字典元素

由于字典是可变序列，因此可以随时在其中添加“键—值对”，这和列表类似。向字典中添加元素的语法格式如下：

dictionary[key] = value

参数说明如下：

• dictionary：表示字典的名称
• key：表示元素的键，必须是唯一的
• value：表示元素的值，可以是任何数据类型

示例：

# 还是之前的场景，现有一个由部分尘世七执政组成的字典
characters = {"风神": "温迪", "岩神": "钟离", "雷神": "雷电将军", "草神": "纳西妲"}

# 添加“水神”芙宁娜
characters["水神"] = "芙宁娜"

# 输出
print(characters)

输出：

{'风神': '温迪', '岩神': '钟离', '雷神': '雷电将军', '草神': '纳西妲', '水神': '芙宁娜'}

由于在字典中，“键”必须是唯一的，因此如果新添加元素的“键”与已经存在的“键”重复，那么将使用新的“值”替换原来的“值”，相当于修改字典的元素。
示例：

characters = {"风神": "温迪", "岩神": "钟离", "雷神": "雷电将军", "草神": "纳西妲", "水神": "芙宁娜"}

# 将岩神的名字修改为摩拉克斯
characters["岩神"] = "摩拉克斯"

# 输出
print(characters)

输出：

{'风神': '温迪', '岩神': '摩拉克斯', '雷神': '雷电将军', '草神': '纳西妲', '水神': '芙宁娜'}

当字典中某个元素不需要时，可以使用 del 语句将其删除。例如，要删除字典 characters 的键为“风神”的元素，可以使用下列代码：

characters = {"风神": "温迪", "岩神": "钟离", "雷神": "雷电将军", "草神": "纳西妲", "水神": "芙宁娜"}

del characters["风神"]

print(characters)

输出：

{'岩神': '钟离', '雷神': '雷电将军', '草神': '纳西妲', '水神': '芙宁娜'}

字典推导式

使用字典推导式可以快速生成一个字典，它的表现形式和列表推导式类似。

示例：

key = ["风神", "岩神", "雷神", "草神", "水神"]
value = ["温迪", "钟离", "雷电将军", "纳西妲", "芙宁娜"]

characters = {key: value for key, value in zip(key, value)}
print(characters)

输出：

{'风神': '温迪', '岩神': '钟离', '雷神': '雷电将军', '草神': '纳西妲', '水神': '芙宁娜'}

二维字典

与二维列表类似，二维字典就是包含字典的字典。也就是一个字典中的元素又都是一个字典。

示例：

# 定义一个 characters_info 字典
characters_info = {
    "风神": {
        "姓名": "温迪",
        "生日": "6月16日",
        "所属": "蒙德城",
        "神之心": "风",
        "命之座": "歌仙座"
    },
    "岩神": {
        "姓名": "钟离",
        "生日": "12月31日",
        "所属": "璃月港",
        "神之心": "岩",
        "命之座": "岩王帝君座"
    },
    "雷神": {
        "姓名": "雷电将军",
        "生日": "6月26日",
        "所属": "稻妻城",
        "神之心": "雷",
        "命之座": "天下人座"
    },
    "草神": {
        "姓名": "纳西妲",
        "生日": "10月27日",
        "所属": "须弥城",
        "神之心": "草",
        "命之座": "智慧主座"
    },
    "水神": {
        "姓名": "芙宁娜",
        "生日": "10月13日",
        "所属": "枫丹廷",
        "神之眼": "水",
        "命之座": "司颂座"
    }
}

# 输出水神的信息
print("姓名：" + characters_info["水神"]["姓名"])
print("生日：" + characters_info["水神"]["生日"])
print("所属：" + characters_info["水神"]["所属"])
print("神之眼：" + characters_info["水神"]["神之眼"])
print("命之座：" + characters_info["水神"]["命之座"])

输出：

姓名：芙宁娜
生日：10月13日
所属：枫丹廷
神之眼：水
命之座：司颂座

1.3.8 数据类型转换

Python 是动态类型的语言，使用变量时无需声明变量类型。虽然如此，但有时仍然需要用到类型转换。

例如，要想通过 print() 输出提示文字“你的身高：”和浮点型变量 height 的值，就需要将浮点型变量 height 转换为字符串。否则，将显示 TypeError 错误。

height = 175.3

print("你的身高：" + str(height))

在 Python 中，提供了如下表所示的函数进行各数据类型间的转换：

例程
1.抹零结账

money = 28.5 + 2.6 + 11.4 + 15.8 + 18.2     # 累加总计金额
money_str = str(money)                      # 转换为字符串
print("商品总金额为：" + money_str)
money_real = int(money)                     # 进行抹零处理
money_real_str = str(money_real)            # 转换为字符串
print("实收金额为：" + money_real_str)

输出：

商品总金额为：76.5
实收金额为：76