python基础（三）

python基础（三）

11. 条件判断语句

11.1 if 语句

条件判断是通过一条或多条判断语句的执行结果（True 或者 False）来决定执行的代码块。在 Python 语法中，使用 if、elif 和 else 三个关键字来进行条件判断，Python 中 if 语句的一般形式如下：

if 条件表达式_1:
代码块_1
elif 条件表达式_2:
代码块_2
else:
代码块_3
（1）如果 “条件表达式_1” 为 True，将执行 “代码块_1” 块语句

（2）如果 “条件表达式_1” 为 False，将判断 “条件表达式_2”

（3）如果"条件表达式_2" 为 True 将执行 “代码块_2” 块语句

（4）如果 “条件表达式_2” 为 False，将执行"代码块_3"块语句

注意：

① Python 中用 elif 代替了 else if，所以条件判断语句的关键字为：if – elif – else；

④ elif 后面加条件和冒号，而 else 后只能直接加冒号，不能加条件；可以有多个 elif ，但只能有一个 else。

③ 每个条件后面要使用冒号:，表示接下来是满足条件后要执行的语句块；

④ 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块；

作业：(90, 100]-A, (80, 90]-B, (70, 80]-C, (60, 70]-D, [0, 60]-E，判断 score = 77 的等级。

score = 77
if 90 < score <= 100:
    print("本次考试等级为 A")
elif 80 < score <= 90:
    print("本次考试等级为 B")
elif 70 < score <= 80:
    print("本次考试等级为 C")
elif 60 < score <= 70:
    print("本次考试等级为 D")
else:                          # 这一行也可以写成：elif 0 <= score <= 60:
    print("本次考试等级为 E")

执行以上代码，输出结果为：

本次考试等级为 C

11.2 if 嵌套

在嵌套 if 语句中，可以把 if - elif - else 结构放在另外一个 if - elif - else 结构中，但是要注意同一个代码块的语句必须包含相同的缩进空格数：

if 条件表达式_1:
代码块_1
if 条件表达式_2:
代码块_2
elif 条件表达式_3:
代码块_3
else:
代码块_4
elif 条件表达式_4:
代码块_5
else:
代码块_6

作业 ：车辆驾驶员的血液酒精含量小于 20mg/100ml 不构成酒驾；酒精含量大于或等于 20mg/100ml 为酒驾；酒精含量大于或等于 80mg/100ml 为醉驾，请编写 Python 程序判断是否为酒后驾车。

content = int(input("请输入驾驶员每100ml血液酒精的含量："))
if 0 <= content < 20:
    print("驾驶员不构成酒驾")
elif 20 <= content < 100:
    if 20 <= content < 80:
        print("驾驶员构成酒驾但不构成醉驾")
    elif 80 <= content < 100:
        print("驾驶员构成醉驾")

11.3 assert语句

assert 语句，又称断言语句，可以看做是功能缩小版的 if 语句，它用于判断某个表达式的值，如果值为真，则程序可以继续往下执行；反之，Python 解释器会报 AssertionError 错误。assert 语句通常用于检查用户的输入是否符合规定，还经常用作程序初期测试和调试过程中的辅助工具，可以有效预防 bug 的发生，提高程序的健壮性，语法格式为：

assert 条件表达式
代码块

注意：①“条件表达式”后不用加冒号 : ②“代码块”前不用缩进。

a = int(input("请输入考试分数："))
assert 0 <= a <= 100                           # 断言数学考试分数是否位于正常范围内         
print("你的考试成绩为：", a)                   # 只有当考试成绩位于 [0,100]范围内，程序才会继续执行

执行以上代码，输出结果为：

# 输入96
请输入考试分数：96
你的考试成绩为： 96
# 输入101
请输入考试分数：101
AssertionError

Python 支持设置 AssertionError 的提示语句，语法格式为：assert + 空格 + 要判断语句, “报错语句”

① 当 assert 后条件表达式为假时：

a = 10
b = 1
assert a < b, "判断为假，因为 a < b"

执行以上代码，输出结果为：

Traceback (most recent call last):
  File "C:\****", line 3, in <module>
    assert a < b, "判断为假，因为 a < b"
           ^^^^^
AssertionError: 判断为假，因为 a < b

② 当 assert 后条件表达式为真时：

a = 10
b = 1
assert a > b, "a < b"

执行以上代码，没有报错。

12. 模块的导入和下载

12.1 模块的导入

在 Python 中用 import 或者 from…import 来导入相应的模块：

将整个模块 (somemodule) 导入，格式为： import somemodule
从某个模块中导入某个函数，格式为： from somemodule import somefunction
从某个模块中导入多个函数，格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *
比如：

import random  # 引入随机数
x = random.randint(0, 2)  # 随机生成 0、1、2 中的一个数字，赋值给变量 x
print(x)

12.2 函数的调用

从某个模块导入某个函数后，调用该函数的语法格式为：模块名称.函数名称(变量)

比如，Python 中的 randint 用来生成指定范围内的随机整数，在使用 randint 之前，需要调用 random 库。该函数的语法格式为 random.randint(x, y)，参数 x 和 y 代表生成随机数的区间范围，生成的随机数包括 x 和 y。

作业：综合使用 import 函数和 if 语句实现剪刀石头布游戏效果，剪刀（0），石头（1）、布（2）。

import random
x = random.randint(0, 2)
y = int(input("请输入剪刀、石头、布相对应的数字，其中剪刀（0），石头（1）、布（2）："))

if y not in [0, 2]:
    print("你输入了 0、1、2 之外的数字，请重新输入！")
    exit()

if y == 0:
    print("你出的是剪刀；")
elif y == 1:
    print("你出的是石头；")
elif y == 2:
    print("你出的是布；")

if x == 0:
    print("电脑出的是剪刀；")
elif x == 1:
    print("电脑出的是石头；")
elif x == 2:
    print("电脑出的是布；")

if x == y:
    print("你和电脑打平了。")
else:
    if x == 0 and y == 1:
        print("恭喜，你赢了！")
    elif x == 0 and y == 2:
        print("很遗憾，你输了。")
    elif x == 1 and y == 0:
        print("很遗憾，你输了。")
    elif x == 1 and y == 2:
        print("恭喜，你赢了！")
    elif x == 2 and y == 0:
        print("恭喜，你赢了！")
    elif x == 2 and y == 1:
        print("很遗憾，你输了。")

12.3 模块（包）的下载

在 Python 中，模块（包）是一组函数、类、变量或语句的集合，可以被其他程序引用。Python 拥有丰富的模块库，但是在使用时有时需要下载其他的模块。

①使用 pip 下载模块（包）

pip 是 Python 的包管理工具，可以用于安装、升级和卸载 Python 包。使用 pip 下载模块非常简单：右键开始菜单栏、选择“运行”、输入“cmd”并点击“确定”、在命令提示行中输入以下命令并回车：

pip install name

或者

pip install name==版本号

其中，name 表示模块（包）的名称；比如下载 pandas 模块：

pip install pandas

或者

pip install pandas==1.0.3

②使用 PyCharm 下载模块（包）

打开 PyCharm，进入项目界面；
点击菜单栏上的 File -> Settings；
在弹出的窗中，选择 Project -> Project Interpreter；
接下来点击上面界面左上角的“+”；
然后在搜索框中搜索需要安装的第三方库，然后点击界面左下角的“Install Package”进行安装即可。

③在 PyCharm 代码编辑区下载模块（包）
点击底部标红的需要下载的模块名称，在弹出的对话框中继续点击“Install package 包名”，即可进行模块的安装。

13. 字符串的创建

只要是被引号【单、双、三引号】包裹起来的内容就叫字符串。这个内容可以是中文、英文、数字、图例等，只要在引号里就叫字符串。字符串英文为 string，简写为 str。

13.1 引号的使用

（1）单引号 ’ 和双引号 "

二者使用完全相同，用来指定一个单行字符串。

print('hello')
print("hello")

执行以上代码，输出结果为：

hello
hello

（2）三引号 ‘’’ 或 “”"

可以指定一个多行字符串：

print('''Hello
World
!''')

print("""Hello
World
!""")

执行以上代码，输出结果为：

Hello
World
!
Hello
World
!

（3）对引号进行转义

假设你想要在一个字符串中包含一个单引号（‘），肯定不能用 ‘What’ s your name ?’ 来指示它，因为 Python 会弄不明白这个字符串从何处开始，何处结束，所以，需要指明单引号而不是字符串的结尾。对于类似情况，有两种处理方案：

① 在引号前面添加反斜杠 \ 就可以对引号进行转义，让 Python 把它作为普通文本对待

print('What\'s your name ?')
print("Do you know \"Python\" ?")

执行以上代码，输出结果为：

What's your name ?
Do you know "Python" ?

② 使用不同的引号包围字符串

print("What\'s your name ?")
print('Do you know \"Python\" ?')

执行以上代码，输出结果为：

What's your name ?
Do you know "Python" ?

13.2 转义字符

由反斜杠加上一个字符或数字组成，它把反斜杠后面的字符或数字转换成特定的意义。简单来说就是字符要转成其他含义的的功能，所以我们叫它 “转义字符”。转义字符的意义就是避免出现二义性，避免系统识别错误。

符号	名称	描述
\（在行尾时）	续行符	在使用时要注意，可以在 \ 前有空格等，但是 \ 后面不要有空格，后面一定要紧跟着回车换行，否则就会报错
\	反斜杠符号	转义反斜杠
’	单引号	转义字符串中的单引号
"	双引号	转义字符串中的双引号
\n	换行	一般用于末尾
\t	横向制表符	可以认为是一个间隔符
\r	回车	表示将光标的位置回退到本行的开头位置
\b	退格	将光标前移，覆盖删除前一个

a = 1 + 2 + 3 + 4 + 5 + 6 \
    + 7 + 8 + 9 + 10 + 11 \
    + 12 + 13 + 14 + 15 + 16                       # 反斜杠实现续行
print(a)                                     
print("\\a")                                       # 反斜杠转义反斜杠
print("Do you know \"Python\" ?")                  # 反斜杠转义双引号
print('Do you know \'Python\' ?')                  # 反斜杠转义单引号
print("What's your name ?\nHow old are you ?")     # 反斜杠实现换行
print("aa\taa")                                    # 反斜杠实现横向制表符
print("aaaa\rb")                                   # 反斜杠实现删除反斜杠之前所有元素
print("aaa\bb")                                    # 反斜杠实现退格

执行以上代码，输出结果为：

136
\a
Do you know "Python" ?
Do you know 'Python' ?
What's your name ?
How old are you ?
aa	aa
b
aab

使用 r 或者 R 可以让反斜杠不发生转义：

print(r"\\a")
print(r"Do you know \"Python\" ?")
print(r'Do you know \'Python\' ?')
print(r"What's your name ?\nHow old are you ?")
print(r"aa\taa")
print(r"aaaa\rb")
print(r"aaa\bb")

执行以上代码，输出结果为：

\\a
Do you know \"Python\" ?
Do you know \'Python\' ?
What's your name ?\nHow old are you ?
aa\taa
aaaa\rb
aaa\bb

14 字符串的操作

14.1 字符串的索引

Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。

14.2 字符串的检索

（1）检索字符串中是否包含目标字符串

find 函数用于查找字符串中是否包含目标字符串，指定 start 和 end 的范围（顾头不顾尾），检查目标字符串是否包含在指定范围内，如果指定范围内包含目标字符串，返回的是目标字符串中的起始位置对应的索引值；如果不包含目标函数，返回-1，语法格式为：str.find(sub, start, end)

● str：原字符串；
● sub：要查找的目标字符串；
● start：开始检索的位置所对应的索引值；如果不指定，则默认从头开始检索；
● end：结束检索的位置所对应的索引值；如果不指定，则默认一直检索到结尾。

同 find 函数类似，index 函数也可以用于检索是否包含指定的字符串，不同之处在于，当指定的字符串不存在时，index 函数会抛出异常，语法格式为：str.index(sub, start, end)

str = "abcdefghijklmn"
print(str.find("abc"))
print(str.find("lmn"))
print(str.find("n", 5, 13))
print(str.index("abc"))
print(str.index("n", 5, 13))

执行以上代码，输出结果为：

Traceback (most recent call last):
  File ".py", line 6, in <module>
    print(str.index("n", 5, 13))
          ^^^^^^^^^^^^^^^^^^^^^
ValueError: substring not found
0
11
-1
0

（2）检索字符串包含目标字符串的次数

count 函数用于查找目标字符串在另一字符串中出现的次数，指定 start 和 end 的范围（顾头不顾尾），如果检索的字符串不存在，则返回 0，否则返回出现的次数，语法格式为：str.count(sub, start, end)

● str：原字符串；
● sub：要查找的目标字符串；
● start：开始检索的位置所对应的索引值；如果不指定，则默认从头开始检索；
● end：结束检索的位置所对应的索引值；如果不指定，则默认一直检索到结尾。

str = "abcabcabcabc"
print(str.count("abc", 0, 3))
print(str.count("a"))

执行以上代码，输出结果为：

1
4

14.3 字符串的替换

replace 函数可以将指定字符串替代为目标字符串，语法格式为：str.replace(old_str, new_str, num)

① 其中 str 为定义的字符串；② old_str 为需要被替换的字符串；③ new_str 为替换的新字符串；④ num 为可选参数, 若不添加可选参数 num，默认将所有的多个被替换的字符串 old_str 全部替换为新字符串new_str，若添加可选参数 num，则将字符串 str 中的前不超过 num 个的字符串 old_str 替换为字符串 new_str。

str1 = "Welcome to Beijing ! Beijing is a beautiful city ."
print(str1.replace("Beijing", "Wuhan"))
str2 = "Welcome to Beijing ! Beijing is a beautiful city . I love Beijing . Do you love Beijing ?"
print(str2.replace("Beijing", "Wuhan", 2))

执行以上代码，输出结果为：

Welcome to Wuhan ! Wuhan is a beautiful city .
Welcome to Wuhan ! Wuhan is a beautiful city . I love Beijing . Do you love Beijing ?

14.4 字符串的删除

（1）strip 函数

strip 函数用于删除字符串头、尾指定的字符（默认为空格）或字符序列，但只能删除开头或是结尾的字符，不能删除中间部分的字符，语法格式为：str.strip([chars])

其中，str 表示原字符串，[chars] 用来指定要删除的字符，可以同时指定多个，如果未指定参数，即 str.strip()，则默认会删除空格以及制表符、回车符、换行符等特殊字符；带有参数的时候，删除多个字符时只要原字符串的头、尾有对应其中的某个字符即删除，不考虑顺序，直到遇到第一个不包含在其中的字符为止。

str1 = "    123123123\n\t\r"
print(str1.strip())
str2 = "******123******"
print(str2.strip("*"))
str3 = "123321213231***123321132231"
print(str3.strip("123"))
print(str3.strip("132"))
print(str3.strip("213"))
str4 = "123321213231**123**123321132231"
print(str4.strip("213"))
str5 = "123321213231**123**123321132231"
print(str3.strip("123456789"))

执行以上代码，输出结果为：

123
***
***
***
**123**
**123**

（2）lstrip 函数

lstrip 函数用于删除字符串左侧指定的字符（默认为空格）或字符序列，语法格式为：str.lstrip([chars])

其中，str 表示原字符串，[chars] 用来指定要删除的字符，可以同时指定多个，如果未指定参数，即 str.lstrip()，则默认会从左到右开始删除空格以及制表符、回车符、换行符等特殊字符，直至不含这些特殊字符为止；带有参数的时候，从左到右删除多个字符时只要原字符串的左侧有对应其中的某个字符即删除，不考虑顺序，直到遇到第一个不包含在其中的字符为止。

str1 = "   \n\t\r123123123\n123\r123\t123"
print(str1.lstrip())
str2 = "123123123***123***123123123"
print(str2.lstrip("123"))
str3 = "123123123***123***123123123"
print(str3.lstrip("123456"))

执行以上代码，输出结果为：

123123123
123	123
***123***123123123
***123***123123123

（3）rstrip 函数

rstrip 函数用于删除字符串右侧指定的字符（默认为空格）或字符序列，语法格式为：str.rstrip([chars])

其中，str 表示原字符串，[chars] 用来指定要删除的字符，可以同时指定多个，如果未指定参数，即 str.rstrip()，则默认会从右到左开始删除空格以及制表符、回车符、换行符等特殊字符，直至不含这些特殊字符为止；带有参数的时候，从右到左删除多个字符时只要原字符串的右侧有对应其中的某个字符即删除，不考虑顺序，直到遇到第一个不包含在其中的字符为止。

str1 = "123\n123\t123\r123123123\n\r\t  "
print(str1.rstrip())
str2 = "123123123***123***123123123"
print(str2.rstrip("123"))
str3 = "123123123***123***123123123"
print(str3.rstrip("123456"))

执行以上代码，输出结果为：

123
123123123
123123123***123***
1203123123***123***

14.5 字符串的长度

len 函数用来返回一个对象实例（字符、列表、元组等）的长度或项目个数，语法格式为：len(str)，其中 str 用于指定要进行长度统计的字符串：

str1 = "Beijing!"
str2 = "北京欢迎你!"
print(len(str1))
print(len(str2))
print(len("Beijing!"))
print(len("北京欢迎你!"))

执行以上代码，输出结果为：

8
6
8
6

在 Python 中，不同的字符所占的字节数不同，数字、英文字母、小数点、下划线以及空格，各占一个字节，而一个汉字可能占 2~4 个字节，具体占多少个，取决于采用的编码方式。例如，汉字在 GBK/GB2312 编码中占用 2 个字节，而在 UTF-8 编码中一般占用 3 个字节。我们可以使用 encode 函数，将字符串进行编码后再获取它的字节数，语法格式为：len(str.encode(“编码格式”))，其中 str 用于指定要进行长度统计的字符串，编码格式包括 GBK 等，不填默认为 UTF-8。

str1 = "人生苦短，我用Python"
print(len(str1.encode()))
print(len(str1.encode("gbk")))

执行以上代码，输出结果为：

27
20

14.6 字符串的对齐

Python提供了 3 种可用来进行字符串对齐的方法，分别是 ljust 函数、rjust 函数 和 center 函数。

（1）ljust 函数

ljust 函数返回一个原字符串左对齐，并使用指定字符填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串，语法格式为：str.ljust(width[, fillchar])

● str：要进行填充的字符串；
● width：包括 str 本身长度在内，字符串要占的总长度；
● fillchar：作为可选参数，用来指定填充字符串时所用的字符，默认情况使用空格。

str1 = "https://github.com/"
str2 = "https://www.bilibili.com/"
print(str1.ljust(30))
print(str2.ljust(30))
print(str1.ljust(10))
print(str2.ljust(10))
print(str1.ljust(30, "*"))
print(str2.ljust(30, "*"))

执行以上代码，输出结果为：

https://github.com/           # 该输出结果中除了明显可见的网址字符串外，其后还有空格字符存在，每行一共 30 个字符长度
https://www.bilibili.com/     # 该输出结果中除了明显可见的网址字符串外，其后还有空格字符存在，每行一共 30 个字符长度
https://github.com/
https://www.bilibili.com/
https://github.com/***********
https://www.bilibili.com/*****

（2）rjust 函数

rjust 函数返回一个原字符串右对齐，并使用指定字符填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串，语法格式为：str.rjust(width[, fillchar])

● str：要进行填充的字符串；
● width：包括 str 本身长度在内，字符串要占的总长度；
● fillchar：作为可选参数，用来指定填充字符串时所用的字符，默认情况使用空格。

str1 = "https://github.com/"
str2 = "https://www.bilibili.com/"
print(str1.rjust(30))
print(str2.rjust(30))
print(str1.rjust(10))
print(str2.rjust(10))
print(str1.rjust(30, "*"))
print(str2.rjust(30, "*"))

执行以上代码，输出结果为：

           https://github.com/
     https://www.bilibili.com/
https://github.com/
https://www.bilibili.com/
***********https://github.com/
*****https://www.bilibili.com/

（3）center 函数

center 函数返回一个原字符居中对齐，并使用指定字符填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串，语法格式为：str.center(width[, fillchar])

● str：要进行填充的字符串；
● width：包括 str 本身长度在内，字符串要占的总长度；
● fillchar：作为可选参数，用来指定填充字符串时所用的字符，默认情况使用空格。

str1 = "https://github.com/"
str2 = "https://www.bilibili.com/"
print(str1.center(30))
print(str2.center(30))
print(str1.center(10))
print(str2.center(10))
print(str1.center(30, "*"))
print(str2.center(30, "*"))

执行以上代码，输出结果为：

     https://github.com/      
  https://www.bilibili.com/   
https://github.com/
https://www.bilibili.com/
*****https://github.com/******
**https://www.bilibili.com/***

14.7 字符串的截取和拼接

（1）字符串的截取

字符串的截取的语法格式为：str[start🔚step]，其中 start 表示开始检索的位置所对应的索引值，如果不指定，则默认从头开始检索；end 表示结束检索的位置所对应的索引值，如果不指定，则默认一直检索到结尾；step 表示步长，默认为 1；顾头不顾尾。

① 进行字符串的截取，[] 中只有一个数字时，输出该数字索引值对应位置的元素；
② 进行字符串的截取，省略起始位置时，默认从第一位开始输出；省略结束位置时，默认输出到最后一位。

a = "shijiazhuang"
print(a[0])
print(a[5])
print(a[0:5])
print(a[0:8])
print(a[-5:-2])         # 起始位置是倒数第五位的 h，结束位置是倒数第二位的 n，顾头不顾尾
print(a[0:10:2])
print(a[:5])
print(a[5:])

执行以上代码，输出结果为：

s
a
shiji
shijiazh
hua       
siizu
shiji
azhuang

（2）字符串的拼接
① 空格自动拼接

print("h" "a" "p" "p" "y")

执行以上代码，输出结果为：

happy

② 加号“+”拼接

print("h" + "a" + "p" + "p" + "y")

执行以上代码，输出结果为：

happy

③ 多行字符串拼接

print("h"
      "a"
      "p"
      "p"
      "y")

执行以上代码，输出结果为：

happy

④ 乘号“*”重复拼接

print("happy"*5)

执行以上代码，输出结果为：

happyhappyhappyhappyhappy

14.8 字符串的分割和合并

（1）字符串的分割

split 函数可以将一个字符串按照指定的分隔符切分成多个子串，这些子串会被保存到列表中（不包含分隔符），作为方法的返回值反馈回来，语法格式为：str.split(sep=" ",num)[n]

sep：表示分隔符，不能为空，可以是字符串中的任何元素；

num：表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串，并且每一个子字符串可以赋给新的变量。默认为 -1, 即分隔所有；

[n]：表示选取索引值 n 所对应的分片，如果默认则为选取所有的切片。

str = "www.nihao.com.cn"
print(str.split("."))
print(str.split("c"))
print(str.split(".", 2))
print(str.split(".", 2)[2])
a, b, c, d = str.split(".")
print(a)
print(b)
print(c)
print(d)

执行以上代码，输出结果为：

['www', 'nihao', 'com', 'cn']
['www.nihao.', 'om.', 'n']
['www', 'nihao', 'com.cn']
com.cn
www
nihao
com
cn

（2）字符串的合并

join 函数用于连接任意数量的字符串（包括要连接的元素字符串、元组、列表、字典），用新的目标分隔符连接，返回新的字符串，语法格式为：“sep”.join(sequence)

sep：表示分隔符，可以为空；

sequence：要连接的元素序列，join 后只能接受一个参数，所以 sequence 需要在之前定义好。

sequence = "H", "a", "p", "p", "y"
print("".join(sequence))
print(" ".join(sequence))
print("-".join(sequence))

执行以上代码，输出结果为：

Happy
H a p p y
H-a-p-p-y

14.9 字符串的编码和解码

在电脑中输入字符时，电脑要把它转换为二进制数才能存储在电脑中。在 Python 中，有两种常用的字符串类型，分别为 str 和 bytes 类型，其中 str 用来表示 Unicode 字符，bytes 用来表示二进制数据。str 类型和 bytes 类型之间就需要使用 encode 函数和 decode 函数进行转换。

（1）编码

encode 函数用于将 str 类型转换成 bytes 类型，这个过程也成为编码，语法格式为：str.encode(encoding=“字符编码类型”,errors=“错误处理方式”)

参数	含义
str	表示要进行转换的字符串
encoding=“字符编码类型”	指定进行编码时采用的字符编码，该选项默认采用 utf-8 编码。例如，如果想使用简体中文，可以设置 gb2312。当方法中只使用这一个参数时，可以省略前边的“encoding=”，直接写编码格式，例str.encode(“UTF-8”)
errors=“错误处理方式”	指定错误处理方式，其可选择值可以是：strict：遇到非法字符就抛出异常；ignore：忽略非法字符；replace：用“？”替换非法字符；xmlcharrefreplace：使用 xml 的字符引用；该参数的默认值为 strict。

（2）解码

decode 函数用于将 bytes 类型的二进制数据转换为 str 类型，这个过程也成为解码，语法格式为：bytes.decode(encoding=“字符编码类型”, errors=“错误处理方式”)

参数	含义
bytes	表示要进行转换的二进制数据
encoding=“字符编码类型”	指定解码时采用的字符编码，默认采用 utf-8 格式。当方法中只使用这一个参数时，可以省略“encoding=”，直接写编码方式即可。注意，对 bytes 类型数据解码，要选择和当初编码时一样的格式。
errors=“错误处理方式”	指定错误处理方式，其可选择值可以是：strict：遇到非法字符就抛出异常；ignore：忽略非法字符；replace：用“？”替换非法字符；xmlcharrefreplace：使用 xml 的字符引用；该参数的默认值为 strict。

str = "我要成为Python大佬"
str_en = str.encode("UTF-8")
print("UTF-8编码：", str_en)
str_de = str_en.decode("UTF-8")
print("UTF-8解码：", str_de)

执行以上代码，输出结果为：

UTF-8编码： b'\xe6\x88\x91\xe8\xa6\x81\xe6\x88\x90\xe4\xb8\xbaPython\xe5\xa4\xa7\xe4\xbd\xac'
UTF-8解码： 我要成为Python大佬

14.10 字符串的大小写字母转换

（1）首字母大写

capitalize 函数可以将字符串的第一个字母变成大写，其他字母变小写，语法格式为：str.capitalize()，其中 str 为定义的字符串：

str = "abCDef"
print(str.capitalize())

执行以上代码，输出结果为：

Abcdef

（2）字母全部大写

upper 函数可以将字符串中的字母全部大写，语法格式为：str.upper()，其中 str 为定义的字符串：

str = "abCDef"
print(str.upper())

执行以上代码，输出结果为：

ABCDEF

（3）字母全部小写

lower 函数可以将字符串中的字母全部小写，语法格式为：str.lower()，其中 str 为定义的字符串：

str = "abCDef"
print(str.lower())

执行以上代码，输出结果为：

abcdef

（4）字母大小写互换

swapcase 函数可以对字符串的大小写字母进行转换，即将大写字母转换为小写字母，小写字母会转换为大写字母，语法格式为：str.swapcase()，其中 str 为定义的字符串：

str = "abCDef"
print(str.swapcase())

执行以上代码，输出结果为：

ABcdEF

（5）标题化

title 函数用于返回“标题化”的字符串，就是说所有单词的首个字母转化为大写，其余字母均为小写，语法格式为：

str.title()
比如：

print(str.title("tHe wOrLDwidE Web"))
print(str.title("北京luohu"))
str1 = "tHe wOrLDwidE Web"
print(str1.title())

执行以上代码，输出结果为：

The Worldwide Web
北京Luohu
The Worldwide Web

14.11 字符串的检查

（1）startswith 函数

startswith 函数用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 start 和 end 指定值，则在指定范围内检查，语法格式为：str.startswith(substr[, start[, end]])

● str：被检测的字符串；
● substr：指定的字符串；
● start：作为可选参数，检测的起始位置对应的字符串索引值，默认为 0，顾头不顾尾；
● end：作为可选参数，检测的结束位置对应的字符串索引值，默认为 len(str)，顾头不顾尾。

str1 = "abcdefg"
print(str1.startswith("abc"))
print(str1.startswith("efg"))
print(str1.startswith("abc", 0, 6))
print(str1.startswith("abc", 1, 5))

执行以上代码，输出结果为：

True
False
True
False

（2）endswith 函数

endswith 函数用于检查字符串是否是以指定子字符串结尾，如果是则返回 True，否则返回 False。如果参数 start 和 end 指定值，则在指定范围内检查，语法格式为：str.endswith(substr[, start[, end]])

● str：被检测的字符串；
● substr：指定的字符串；
● start：作为可选参数，检测的起始位置对应的字符串索引值，默认为 0，顾头不顾尾；
● end：作为可选参数，检测的结束位置对应的字符串索引值，默认为 len(str)，顾头不顾尾。

str1 = "abcdefg"
print(str1.endswith("abc"))
print(str1.endswith("efg"))
print(str1.endswith("efg", 0, 6))
print(str1.endswith("efg", 0, 7))
print(str1.endswith("efg", 1, 5))

执行以上代码，输出结果为：

False
True
False
True
False

（3）isalpha 函数

isalpha 函数用于检查字符串是否只由字母或文字组成，如果字符串至少有一个字符并且所有字符都是字母或文字则返回 True，否则返回 False，语法格式为：str.isalpha()

str1 = "abcdefg"
str2 = "我很帅"
str3 = "hello你好"
str4 = "hello 你好"
str5 = "hello_你好"
str6 = "hello你好!"
print(str1.isalpha())
print(str2.isalpha())
print(str3.isalpha())
print(str4.isalpha())
print(str5.isalpha())
print(str6.isalpha())

执行以上代码，输出结果为：

True
True
True
False
False
False

（4）isdigit 函数、isdecimal 函数和 isnumeric 函数

isdigit 函数、isdecimal 函数和 isnumeric 函数均可用于检查字符串是否只由数字组成，如果字符串只包含数字则返回 True，否则返回 False，它们的区别如下：

	True	False	Error
isdigit 函数	Unicode 数字，byte 数字（单字节），全角数字（双字节）	汉字数字，罗马数字，小数	无
isdecimal 函数	Unicode 数字，全角数字（双字节）	罗马数字，汉字数字，小数	byte 数字（单字节）
isnumeric 函数	Unicode 数字，全角数字（双字节），汉字数字	小数，罗马数字	byte 数字（单字节）

① Unicode 数字

str1 = "1"  
print(str1.isdigit())
print(str1.isdecimal())
print(str1.isnumeric())

执行以上代码，输出结果为：

True
True
True

② 全角数字（双字节）

str1 = "１" 
print(str1.isdigit())
print(str1.isdecimal())
print(str1.isnumeric())

执行以上代码，输出结果为：

True
True
True

③ byte 数字（单字节）

str1 = b"1"  # byte 数字（单字节）
print(str1.isdigit())
print(str1.isdecimal())
print(str1.isnumeric())

执行以上代码，输出结果为：

True
AttributeError: 'bytes' object has no attribute 'isdecimal'
AttributeError: 'bytes' object has no attribute 'isdecimal'

④ 罗马数字

str1 = "Ⅰ"  # byte 数字（单字节）
print(str1.isdigit())
print(str1.isdecimal())
print(str1.isnumeric())

执行以上代码，输出结果为：

False
False
True

⑤ 汉字数字

str1 = "一"  
print(str1.isdigit())
print(str1.isdecimal())
print(str1.isnumeric())

执行以上代码，输出结果为：

False
False
True

⑥ 小数

str1 = "0.1"
print(str1.isdigit())
print(str1.isdecimal())
print(str1.isnumeric())

执行以上代码，输出结果为：

False
False
False

（7）istitle 函数

istitle 函数用于检查字符串中所有的单词拼写首字母是否为大写，且其他字母为小写，如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False，语法格式为：str.istitle()

str1 = "Welcome To Beijing !"
str2 = "Welcome to beijing !"
print(str1.istitle())
print(str2.istitle())

执行以上代码，输出结果为：

True
False

（8）isupper 函数

isupper 函数用于检查字符串中所有的字母是否都为大写，如果字符串中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字符都是大写，则返回 True，否则返回 False，语法格式为：str.isupper()

str1 = "WELCOME TO  BEIJIGN !"
str2 = "Welcome To Beijing !"
print(str1.isupper())
print(str2.isupper())

执行以上代码，输出结果为：

True
False

（9）islower 函数

islower 函数用于检查字符串是否由小写字母组成，如果字符串中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字符都是小写，则返回 True，否则返回 False，语法格式为：str.islower()

str1 = "welcome to beijing !"
str2 = "Welcome To Beijing !"
print(str1.islower())
print(str2.islower())

执行以上代码，输出结果为：

True
False

（10）isspace 函数

isspace 函数用于检查字符串是否只由空白字符组成，如果字符串中只包含空格，则返回 True，否则返回 False，语法格式为：str.isspace()

str1 = "         "
str2 = "a b c d e"
print(str1.isspace())
print(str2.isspace())

执行以上代码，输出结果为：

True
False

（11）isalnum 函数

isalnum 函数用于检查字符串是否由字母和数字组成，如果 str 至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False，语法格式为：str.isalnum()

str1 = "abc"
str2 = "123"
str3 = "abc123"
str4 = "abc 123"
str5 = "abc-123"
print(str1.isalnum())
print(str2.isalnum())
print(str3.isalnum())
print(str4.isalnum())
print(str5.isalnum())

执行以上代码，输出结果为：

True
True
True
False
False

15 列表

15.1 列表的概念

列表（list）是一个有序且可更改的序列，允许重复。列表可以存储整数、小数、字符串、列表、元组等任何类型的数据，同一个列表中元素的类型也可以不同，格式为：[element1 , element2 , element3 , … , elementn]，其中，listname 表示变量名，element1 ~ elementn 表示列表元素。

15.2 列表的创建

在 Python 中，创建列表的方法可分为两种。

（1）使用 [] 创建列表

使用 [] 创建列表后，一般使用 = 将它赋值给某个变量，语法格式为：listname = [element1 , element2 , element3 , … , elementn]，其中，listname 表示变量名，element1 ~ elementn 表示列表元素。

list1 = [1, 2, 3, 4]
list2 = ["1", "2", "3", "4"]
list3 = ["a", "b", 1, 2]
list4 = ["www.baidu.com", 6, [1, 2, 3], 6.0]
print(type(list1))
print(type(list2))
print(type(list3))
print(type(list4))

执行以上代码，输出结果为：

<class 'list'>
<class 'list'>
<class 'list'>
<class 'list'>

（2）用 list 函数创建列表

除了使用 [] 创建列表外，Python 还提供了内置的 list 函数，可以将其它数据类型转换为列表类型。

① 将字符串转换成列表

list1 = list("Beijjing")
print(type(list1))
print(list1)

执行以上代码，输出结果为：

<class 'list'>
['B', 'e', 'i', 'j', 'j', 'i', 'n', 'g']

② 将元组转换成列表

tuple1 = ("a", "b", "c", "d")
list1 = list(tuple1)
print(type(list1))
print(list1)

执行以上代码，输出结果为：

<class 'list'>
['a', 'b', 'c', 'd']

③ 将字典转换成列表

dict1 = {"a": 1, "b": 2, "c": 3}
list1 = list(dict1)
print(type(list1))
print(list1)

执行以上代码，输出结果为：

<class 'list'>
['a', 'b', 'c']

④ 将区间转换成列表

list1 = list(range(1, 5))
print(type(list1)) 
print(list1)

执行以上代码，输出结果为：

<class 'list'>
[1, 2, 3, 4]

⑤ 创建空列表

list1 = list()
print(type(list1))
print(list1)

执行以上代码，输出结果为：

<class 'list'>
[]

15.3 列表的索引、访问和切片

（1）列表的索引

与字符串的索引一样，列表正向索引从 0 开始，第二个索引是 1，依此类推：

也可以反向索引，最后一个元素的索引为 -1，往前一位为 -2，以此类推：

（2） 列表的访问

列表是 Python 序列的一种，我们可以使用索引访问列表中的某个元素（得到的是一个元素的值），也可以使用切片返回列表中的一组元素（得到的是一个新的子列表）。

使用索引访问列表元素的语法格式为：listname[i]，其中，listname 表示列表名字，i 表示索引值。列表的索引可以是正数，也可以是负数。

（3）列表的切片

使用切片返回列表元素的语法格式为：listname[start🔚step]，其中，listname 表示列表名字，start 表示开始检索的位置所对应的索引值，如果不指定，则默认从头开始检索；end 表示结束检索的位置所对应的索引值，如果不指定，则默认一直检索到结尾；step 表示步长，默认为 1；顾头不顾尾。

list1 = ["a", "b", "c", 1, "d"]
print(list1[0])
print(list1[-5])
print(list1[0:4])
print(list1[0:5])
print(list1[0:5:2])

执行以上代码，输出结果为：

a
a
['a', 'b', 'c', 1]
['a', 'b', 'c', 1, 'd']
['a', 'c', 'd']

15.4 列表的基础操作

（1）列表的组合

使用 + 将多个列表合并：

a = ["h", "a", "p", "p", "y"]
b = ["n", "e", "w"]
c = ["y", "e", "a", "r"]
d = a + b + c
print(d)

执行以上代码，输出结果为：

['h', 'a', 'p', 'p', 'y', 'n', 'e', 'w', 'y', 'e', 'a', 'r']

（2）列表的重复

使用 * 将列表重复打印：

b = ["n", "e", "w"]
print(b*3)

执行以上代码，输出结果为：

['n', 'e', 'w', 'n', 'e', 'w', 'n', 'e', 'w']

（3）列表的长度

Python 中可以使用 len 函数查看列表长度，语法格式为：len(listname)

b = ["n", "e", "w"]
print(len(b))

执行以上代码，输出结果为：

3

（4）返回列表中元素最小值和最大值

Python 中可以分别使用 max 函数和 min 函数查看列表中元素的最大值和最小值，语法格式为：max(listname)，min(listname)

list1 = [4, 5, 3, 1, 2]
print(max(list1))
print(min(list1))

执行以上代码，输出结果为：

5
1

（5）返回列表中元素的总和

Python 中可以使用 sum 函数返回列表各元素的总和，语法格式为：sum(listname)

list1 = [1, 2, 3, 4]
a = sum(list1)
print(a)

执行以上代码，输出结果为：

10

15.5 列表的遍历

（1）通过 for 循环遍历（最常用）

for item in listname:
    print(item)

item 表示遍历到的每一个元素，listname 表示需要遍历的列表。

（2）通过 range 函数遍历

for i in range(len(listname)):      # range 函数顾头不顾尾
    print(listname[i])

i 表示遍历到的每一个元素的索引，listname 表示需要遍历的列表。

（3）通过 enumerate 函数遍历

enumerate 是 Python 的内置函数，对于一个可迭代的对象（如列表、字符串），enumerate 函数可以将一个可遍历的数据对象组合为一个索引序列，同时列出数据和数据下标，语法格式为：enumerate(iteration, start)，其中，iteration 为需要遍历的参数，比如字典、列表、元组等，start参数为开始的参数，默认为 0。当既需要遍历索引同时需要遍历元素的时候，可以考虑使用 enumerate 函数。

list1 = [1, 2, 3, 4, 5]
for i_value in enumerate(list1):
    print(i_value)
for i, value in enumerate(list1):
    print(i, value)

其中，i 为遍历列表得到的索引，value 为遍历列表得到的每一个列表的元素，执行以上代码，输出结果为：

(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
0 1
1 2
2 3
3 4
4 5

15.6 列表中元素的添加【增】

（1）append 函数

append 函数用于在列表的末尾追加元素，语法格式为：listname.append(obj)，print(listname)，其中，listname 表示要添加元素的列表；obj 表示添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

append 函数是在要添加元素的列表 listname 末尾添加元素，添加元素后列表 listname 就已经发生了改变，如果要返回新的列表，是输出 listname，而不是输出 listname.append(obj)；此外，当给 append 函数传递列表或者元组时，此方法会将它们视为一个整体，作为一个元素添加到列表中，从而形成包含列表和元组的新列表。

list1 = ["aa", "bb", "cc", "dd"]
list1.append("ee")
print(list1)
list2 = ["ff", "gg", "hh"]
list1.append(list2)
print(list1)
tuple1 = ("ii", "jj", "kk", "ll")
list1.append(tuple1)
print(list1)

执行以上代码，输出结果为：

['aa', 'bb', 'cc', 'dd', 'ee']
['aa', 'bb', 'cc', 'dd', 'ee', ['ff', 'gg', 'hh']]
['aa', 'bb', 'cc', 'dd', 'ee', ['ff', 'gg', 'hh'], ('ii', 'jj', 'kk', 'll')]

（2）extend 函数

append 函数也用于在列表的末尾追加元素，extend 函数和 append 函数的不同之处在于：extend 函数不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中，语法格式为：listname.extend(obj)，print(listname)，其中，listname 表示要添加元素的列表；obj 表示添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

此外，当添加的单个元素包含多个字符时，extend 函数会把这个元素所包含的字符逐个添加到列表中。

list1 = ["aa", "bb", "cc", "dd"]
list1.extend("ee")
print(list1)
list1.extend("10")
print(list1)
list1.extend("1e!")
print(list1)
list2 = ["ff", "gg", "hh"]
list1.extend(list2)
print(list1)
tuple1 = ("ii", "jj", "kk", "ll")
list1.extend(tuple1)
print(list1)

执行以上代码，输出结果为：

['aa', 'bb', 'cc', 'dd', 'e', 'e']
['aa', 'bb', 'cc', 'dd', 'e', 'e', '1', '0']
['aa', 'bb', 'cc', 'dd', 'e', 'e', '1', '0', '1', 'e', '!']
['aa', 'bb', 'cc', 'dd', 'e', 'e', '1', '0', '1', 'e', '!', 'ff', 'gg', 'hh']
['aa', 'bb', 'cc', 'dd', 'e', 'e', '1', '0', '1', 'e', '!', 'ff', 'gg', 'hh', 'ii', 'jj', 'kk', 'll']

（3）insert 函数

insert 函数用于在列表中间某个位置插入元素，语法格式为：listname.insert(index, obj)，print(listname)，其中，index 表示指定位置的索引值，obj 表示添加的数据，insert 函数会将 obj 插入到 listname 列表第 index 个元素的位置。

当插入列表或者元祖时，insert 函数也会将它们视为一个整体，作为一个元素插入到列表中，这一点和 append 函数相同。

list1 = ["aa", "bb", "cc", "dd"]
list1.insert(0, "11")
print(list1)
list1.insert(3, "22")
print(list1)
list1.insert(5, ["ee", "ff", "gg"])
print(list1)

执行以上代码，输出结果为：

['11', 'aa', 'bb', 'cc', 'dd']
['11', 'aa', 'bb', '22', 'cc', 'dd']
['11', 'aa', 'bb', '22', 'cc', ['ee', 'ff', 'gg'], 'dd']

15.7 列表中元素的删除【删】

（1）del 关键字

del 是 Python 中的关键字，专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素。

① 删除整个列表

对于已经创建的列表，如果不再使用，可以使用 del 关键字将其删除，语法格式为：del listname，其中，listname 表示列表名称。

list1 = ["a", "b", "c"]
print(type(list1))
del list1
print(type(list1))

执行以上代码，输出结果为：

<class 'list'>
NameError: name 'list1' is not defined. Did you mean: 'list'?

② 删除单个元素

del 可以删除列表中的单个元素，语法格式为：del listname[index]，print(listname)，其中，listname 表示列表名称，index 表示元素的索引值。

del 删除列表 listname 中的元素后，列表 listname 就已经发生了改变，如果要返回新的列表，是输出 listname，而不是输出 del listname[index]；

list1 = ["a", "b", "c"]
del list1[0]
print(list1)

执行以上代码，输出结果为：

['b', 'c']

③ 删除一段连续的元素

del 删除中间一段连续元素的语法格式为：del.listname[start:end]，其中，start 表示起始索引，end 表示结束索引，顾头不顾尾。

list1 = ["a", "b", "c", "d", "e", "f"]
list2 = ["a", "b", "c", "d", "e", "f"]
del list1[0:4]
del list2[2:5]
print(list1)
print(list2)

执行以上代码，输出结果为：

["e", "f"]
["a", "b", "f"]

（2）pop 函数

pop 函数用来删除列表中指定索引处的元素，语法格式为：listname.pop(index)，其中，listname 表示列表名称，index 表示索引值，如果不写 index 参数，默认会删除列表中的最后一个元素。

list1 = ["a", "b", "c", "d", "e", "f"]
list1.pop()
print(list1)
list1.pop(2)
print(list1)

执行以上代码，输出结果为：

["a", "b", "c", "d", "e"]
["a", "b", "d", "e"]

（3）remove 函数

remove 函数会根据元素本身的值来进行删除操作，语法格式为：listname.remove(obj)，print(listname)，其中，listname 表示列表名称，obj 表示要删除的目标元素。

需要注意的是，remove 函数只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。

list1 = [2, 36, 2, 7, "aa", "bb"]
list1.remove("aa")
print(list1)
list1.remove(2)
print(list1)
list1.remove(2)
print(list1)
list1.remove(2)
print(list1)

执行以上代码，输出结果为：

[2, 36, 2, 7, 'bb']
[36, 2, 7, 'bb']
[36, 7, 'bb']
ValueError: list.remove(x): x not in list

（4）clear 函数

clear 函数用来删除列表的所有元素，即清空列表，语法格式为：listname.clear()

list1 = [2, 36, 2, 7, "aa", "bb"]
list1.clear()
print(list1)

执行以上代码，输出结果为：

[]

15.8 列表中元素的修改【改】

Python 提供了两种修改列表元素的方法，可以每次修改单个元素，也可以每次修改一组元素（多个）。

（1）修改单个元素

修改单个元素，即直接对元素赋值，语法格式为：listname[index] = valuation，print(listname)，其中，listname 表示要被修改的列表，index 表示指定位置的索引值，valuation 表示要赋的值。

list1 = [2, 36, 2, 7, "aa", "bb"]
list1[2] = 66
print(list1)
list1[5] = "ee"
print(list1)

执行以上代码，输出结果为：

[2, 36, 66, 7, 'aa', 'bb']
[2, 36, 66, 7, 'aa', 'ee']

（2）修改一组元素

Python 支持通过切片语法给一组元素赋值，语法格式为：listname[start:end] = [obj_list]，print(listname)，listname 表示要被修改的列表，start 表示开始修改的位置所对应的索引值，end 表示结束修改的位置所对应的索引值（顾头不顾尾），obj_list 表示要替换成的那部分列表。

list1 = ["a", 1, "b", 2, "c", 3] 
list1[1:4] = [4, "d", 5] 
print(list1)

执行以上代码，输出结果为：

['a', 4, 'd', 5, 'c', 3]

① 在进行这种操作时，如果不指定步长，Python 就不要求新赋值的元素个数与原来的元素个数相同；这意味，该操作既可以为列表添加元素，也可以为列表删除元素：

list1 = ["a", 1, "b", 2, "c", 3]
list1[1:4] = [4, "d", 5, "e", 6, "f"]
print(list1)
list1[0:6] = [7]
print(list1)

执行以上代码，输出结果为：

['a', 4, 'd', 5, 'e', 6, 'f', 'c', 3]
[7, 'f', 'c', 3]

② 如果对空切片赋值，就相当于插入一组新的元素：

list1 = ["a", 1, "b", 2, "c", 3] 
list1[4:4] = [4, "d"] 
print(list1)

执行以上代码，输出结果为：

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

15.9 列表中元素的查找【查】

（1）count 函数

count 函数用于统计某个元素在列表中出现的次数，语法格式为：listname.count(obj)，其中，listname 表示列表名，obj 表示要统计的元素。如果 count 函数返回 0，就表示列表中不存在该元素，所以 count 函数也可以用来判断列表中的某个元素是否存在。

list1 = ["a", "b", "a", "b", 1, 2, 1, 1]
print(list1.count("c"))
print(list1.count("a"))
print(list1.count(1))

执行以上代码，输出结果为：

0
2
3

（2）index 函数

index 函数用于查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致 ValueError 错误，语法格式为：listname.index(obj, start, end)，其中，listname 表示列表名称，obj 表示要查找的元素，start 表示起始位置对应的索引值，end 表示结束位置对应的索引值（顾头不顾尾）。

start 和 end 可以都不写，此时会检索整个列表；如果只写 start 不写 end，那么表示检索从 start 到末尾的元素；如果 start 和 end 都写，那么表示检索 start 和 end 之间的元素。

list1 = ["a", "b", "a", "b", 1, 2, 1, 1, "a"]
print(list1.index("a"))
print(list1.index(1))
print(list1.index(1, 3, 8))
print(list1.index("b", 0, 4))
print(list1.index("c"))

执行以上代码，输出结果为：

0
4
4
1
ValueError: 'c' is not in list

（3）in，not in 成员运算符

成员运算符 in 和 not in 用于断列表中的某个元素是否存在，语法格式为：obj in listname 和 obj not in listname，obj 表示要查找的元素，listname 表示列表名称，如果表述正确，返回 True，否则返回 False。

list1 = ["a", "b", "a", "b", 1, 2, 1, 1, "a"]
print("a" in list1)
print("a" not in list1)

执行以上代码，输出结果为：

True
False

15.10 列表中元素的排列【排】

（1）sorted 函数

sorted 函数作为 Python 内置函数之一，用于对序列（列表、元组、字典、集合、还包括字符串）进行排序，语法格式为：listname = sorted(iterable, key=None, reverse=False) ，print(listname)

其中，iterable 表示指定的序列（可迭代的对象），key 参数可以自定义排序规则，reverse 参数指定以升序（False，默认）还是降序（True）进行排序，sorted 函数会返回一个排好序的列表。注意，key 参数和 reverse 参数是可选参数，即可以使用，也可以忽略。使用 sorted 函数对序列进行排序，并不会在原序列的基础进行修改，而是会重新生成一个排好序的列表。

list1 = [4, 5, 3, 1, 2]                           # 列表
list2 = sorted(list1)
print(list1)
print(list2)
list3 = ["c", "a", "e", "d", "b"]
print(sorted(list3))
print(sorted(list3, reverse=True))
tuple1 = (4, 5, 3, 1, 2)
print(sorted(tuple1))                             # 元组
dict1 = {1: "a", 5: "b", 3: "e", 2: "d", 4: "c"}  # 字典
print(sorted(dict1)) 
a1 = {4, 5, 3, 1, 2}                              # 集合
print(sorted(a1)) 
str1 = "45312"                                    # 字符串
print(sorted(str1)) 

执行以上代码，输出结果为：

[4, 5, 3, 1, 2]
[1, 2, 3, 4, 5]
['a', 'b', 'c', 'd', 'e']
['e', 'd', 'c', 'b', 'a']
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
['1', '2', '3', '4', '5']

（2）sort 函数

sort 函数用于对原列表进行排序，语法格式为：listname.sort(key=None, reverse=False)，print(listname)，listname 表示指定的序列，key 参数可以自定义排序规则，reverse 参数指定以升序（False，默认）还是降序（True）进行排序。使用 sort 函数对列表进行排序，不返回值，直接在列表上操作，会改变原列表的值。

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

执行以上代码，输出结果为：

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

（3）reverse 函数

reverse 函数用于对列表中的元素反向排序，语法格式为：listname.reverse()，listname 表示指定的序列，使用 reverse 函数对列表进行排序，不返回值，直接在列表上操作，会改变原列表的值。

list1 = [4, 5, 3, 1, 2]
list1.reverse()
print(list1)
list2 = ["c", "a", "e", "d", "b"]
list2.reverse()
print(list2)

执行以上代码，输出结果为：

[2, 1, 3, 5, 4]
['b', 'd', 'e', 'a', 'c']

15.11 列表的嵌套

list1 = [[1, 2, 3], ["a", "b"], ["a", 1]]
print(list1[0])

执行以上代码，输出结果为：

[1, 2, 3]

作业：一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配。

# 遍历、追加
offices = [[], [], []]                                     # 定义一个嵌套有 3 个空列表的 offices 列表
teachers = ["A", "B", "C", "D", "E", "F", "G", "H"]        # 定义一个由 8 位老师组成的 teachers 列表
for teacher in teachers:                                   # 遍历 teachers 列表中每一个 teacher 元素
    import random                                          # 引入 random 随机库
    index = random.randint(0, 2)                           # 定义一个索引值，为随机生成的 0、1、2
    offices[index].append(teacher)                         # 将遍历的每一个teacher元素追加到随机生成的office嵌套列表中，至此完成一次遍历，直至8此次遍历全部完成
# 打印
i = 1                                                      # 定义办公室的编号，后面的占位符会用到，因为从 1 开始，所以先将其定义为 1
for office in offices:                                     # 遍历 offices 列表中每一个 office 嵌套列表
    print("第 %d 个办公室的人数： %d" % (i, len(office)))  # 打印输出每个 office 嵌套列表的长度，也就是每个办公室安排老师的数量
    for teacher in office:                                 # 遍历 office 嵌套列表中每一个 teacher 元素
        print("%s" % teacher, end="\t")                    # 打印输出每个 office 列表中包含的全部 teacher 元素，加入 end="\t" 实现水平制表符
    print(end="\n")                                        # 打印 end="\n" 实现换行打印
    print("-" * 20)                                        # 打印 "-" * 20 实现分隔效果
    i += 1                                                 # 通过加法赋值运算符实现 办公室编号