python入门基础大全（全网最细）

标签：输出 最细 python 全网 list1 列表 字符串 str print

1. 编码

如果在程序中用到了中文，直接输出结果很可能会出错，比如：

print("你好")

解决的办法是，在程序的开头写入如下代码：

# -*- coding:utf-8 -*-

或者

# coding=utf-8

用于向 Python 解释器声明源代码文件所用的编码类型为“utf-8”，如果代码里有中文，打印的时候可以使中文正常显示。

2. 注释

Python 中的注释包括单行注释和多行注释。

2.1 单行注释

Python 中单行注释以 # 开头：

# 第一个注释
print("Hello World") # 第二个注释

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

Hello World

2.2 多行注释

（1）Python 中多行注释可以用多个 # 开头，或者用 ''' 和 """ 双引注释内容：

# 第一个注释
# 第二个注释

'''
第三个注释
第四个注释
'''

"""
第五个注释
第六个注释
"""

print("Hello World")

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

Hello World

（2）通过快捷键进行多行注释

在 Windows 系统中，可以通过鼠标选择需要注释的代码，然后使用“Ctrl+/”可以快速注释或取消注释多行代码：

# def outer(origin):
#     def inner():
#         print("before")
#         res = origin()  # 调用下面的 func 函数
#         print("after")
#         return res
#
#     return inner
print("Hello")

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

Hello

3. 标识符

3.1 标识符的概念

标识符是程序中某一元素（变量、关键字、函数、类、模块、对象）的名字。说通俗点，标识符就是以后给我们写的每个代码所起的名字，就好比我们每个人生下来都要起名字。除了关键字的名字是固定的，其它元素都可以根据标识符的命名规则进行命名。

3.2 标识符的命名规则

标识符由字母（ A~Z , a~z ）、数字（0-9）、以及下划线（_）组成。

（1）标识符的第一个字符必须是字母（ A~Z , a~z ）或下划线（_）；

比如：

Hello
apple
_max
_Min

（2）标识符的其它部分由字母（ A~Z , a~z ）、数字（0-9）或者下划线（_）组成；

比如：

Apple10
Apple_10
V_3_V
CON2_5
_Test_3

（3）标识符对大小写敏感；

比如：

A 和 a
Apple 和 apple
Sum_ 和 sum_
_name 和 _NAME
Test2 和 test2

3.3 变量

变量是标识符的一种，是一个用于保存值的占位符。可以通过变量名获得对值的引用，可以是任意的数据类型。变量命名时尽量体现出值的数据类型。如命名 count、length 和 size 表明数据类型是数字，命名 name、title 和 message 表明数据类型是字符串，单个字符命名的变量诸如 i、j、k 通常在循环中使用。

Python 中使用变量，不需要声明，直接为变量赋值即可使用，比如：

a = 10
print(a)

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

10

上述代码中，a 即为变量。但要注意，不能使用没有进行过赋值的变量，使用之后就会报错，比如：

print(a)

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

Traceback (most recent call last):
  File "", line 1, in <module>
    print(a)
NameError: name 'a' is not defined

4. 关键字

4.1 关键字的概念

有一分部标识符是 Python 自带的、具有特殊含义的名字，我们称之为“关键字”，或者“保留字”；关键字已经被 Python 使用，所以不允许开发者自己定义和关键字名字相同的标识符。

4.2 查看关键字

Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：【Win+R】调出【运行】弹窗>>>输入“cmd”>>>点击【确定】>>>在打开的界面中输入“python”>>>回车，进入 Python 交互模式，在交互模式下输入以下代码：

>>> import keyword
>>> keyword.kwlist

执行以上代码，输出结果为当前版本的所有关键字：

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

5. 输出

Python 输出主要包括标准化输出、格式化输出、不换行输出、换行输出和更换间隔字符输出。

5.1 标准化输出

Python 编程中 print 的用法是输入 print（），括弧中可以是数字、变量、字符串、列表、元组合字典。需要注意的是：① print 一定要全部小写；② print 后边的括弧要在英文状态输入。

（1）括号内可以是字符串，需要用单引号或双引号括起来，比如：

print("Hello World")
print('Hello World')

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

Hello World
Hello World

（2）括号内可以是数字或者数字的运算，比如：

print(7)
print(7+5)

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

7
12

（3）括弧内可以是变量或者变量的运算，比如：

a = 4
b = 7*8/2
print(a)
print(b)
print(a+b)

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

4
28.0
32.0

（3）括号内可以是字符串和数字的组合，需要把数字用引号括起来作为字符串使用，比如：

print("My lucky number is", " 6 ")

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

My lucky number is 6 

（4）括号内可以是字符串和变量的组合，比如：

a = 3
print("输出的数字为：", a)

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

输出的数字为： 3

5.2 格式化输出（%）

格式化是对字符串进行一定的格式显示或输出的方式，可以通过“%”，“format 函数”和“print(f"string")”实现。

% 符号可以实现字符串的格式化。在字符串内部 %() 表示特定格式字符串的占位，字符串右侧通过 % 连接要格式化的参数，它们和内部占位符 % 一一对应，中间不需要逗号连接。常用的格式符号如下：

i格式符号	转换
%d	*有符号十进制整数
%s	*通过str()字符串转换来格式化
%i	有符号十进制整数
%c	字符
%u	无符号十进制整数
%o	八进制整数
%x	十六进制整数（小写字母）
%X	十六进制整数（大写字母）
%e	索引符号（小写'e'）
%E	索引符号（大写"E"）
%f	浮点实数
%g	%f和%e的简写
%G	%F和%E的简写

① %d 的使用，比如：

number = 6
print("My lucky number is %d" % number)

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

My lucky number is 6

② %s 的使用，比如：

print("My name is %s" % "Li Ming")

name = "Jenny"
print("Her name is %s" % name)

print("My name is %s"" and my lucky colour is %s" % ("Li Ming", "blue"))

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

My name is Li Ming
Her name is Jenny
My name is Li Ming and my lucky colour is blue

5.3 格式化输出（format 函数）

format 函数是字符串内嵌的一个方法，用于格式化字符串。以大括号 {} 来标明被替换的字符串，语法格式为："{}".format()

（1）通过大括号 {} 的默认顺序依次匹配元组中的参数

str = "{} is a beautiful {}！".format("Beijing","city")
print(str)

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

Beijing is a beautiful city！

（2）通过索引的方式匹配参数

str1 = "{0} is a beautiful {1}!".format("Beijing", "city")
print(str1)
str2 = "{1} is a beautiful {2}!".format("Tianjin","Beijing", "city")
print(str2)

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

Beijing is a beautiful city!
Beijing is a beautiful city!

（3）通过参数名匹配参数

str1 = "{name1} is a beautiful {name2}!".format(name1="Beijing", name2="City")
print(str1)

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

Beijing is a beautiful city!

（4）混合使用

① 可以通过索引，参数名混合进行匹配，但命名参数必须写到最后，否则会报错：

str1 = "{0} is a beautiful {name}!".format("Beijing", name="city")
print(str1)

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

Beijing is a beautiful city!

② 可以通过默认顺序和参数名混合进行匹配，但命名参数必须写到最后，否则会报错：

str1 = "{} is a beautiful {name}!".format("Beijing", name="city") 
print(str1)

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

Beijing is a beautiful city!

③ 不可以索引和默认顺序混合使用，否则会报错。

（5）通过对象的属性匹配参数

class Names:
    Name1 = "Beijing"
    Name2 = "city"


str1 = "{names.Name1} is a beautiful {names.Name2}!".format(names=Names)
print(str1)

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

Beijing is a beautiful city!

（6）引用参数部分

str1 = "The first letter of '{word}' is '{word[0]}'.".format(word="hello")
print(str1)

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

The first letter of 'hello' is 'h'.

（7）数字的处理

① 保留小数位数

str1 = "π is {:.2f}.".format(3.1415926)  #保留两位小数
print(str1)

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

π is 3.14.

② 给数字加千位符

str1 = "{:,}".format(100000000)
print(str1)

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

100,000,000

③ 进制的转换

s1 = "{:b}".format(8)     # 将数字8转换为二进制
print(s1)
s2 = "{:o}".format(8)     # 将数字8转换为八进制
print(s2)      
s3 = "{:x}".format(12)    # 将数字12转换为十六进制
print(s3) 

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

1000
10
C

（8）格式的处理

通过 ：数字 指定转换后的字符串长度，不足的部分用空格补充：

s = "{:2}b".format('a')
print(s) 
# 如果指定的长度小于参数的长度，按照原参数匹配
s1 = "{:2}World".format('Hello')
print(s1) 

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

a b
HelloWorld

（9）字符的填充

可通过 :符号^数字 进行字符串的填充，其中数字为填充后的字符串总长度：

s = "{:*^10}".format('Hello')
print(s)

s = "{:-^20}".format('123456')
print(s)

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

**Hello***
-------123456-------

（10）匹配列表、字典中的参数

在 format 函数格式化时，可使用 * 或者 ** 对列表、字典和元组进行拆分。

① 匹配列表中的参数

list = ["Beijing", "city"]
str1 = "{} is a beautiful {}!".format(*list)
str2 = "{1} is a beautiful {0}!".format(*list)
print(str1)
print(str2)

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

Beijing is a beautiful city!
city is a beautiful Beijing!

② 匹配字典中的参数

dict = {"name1": "Beijing", "name2": "city"}
str1 = "{name1} is a beautiful {name2}!".format(**dict)
print(str1)

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

Beijing is a beautiful city!

5.4 格式化输出（print(f"string={}")）

在 Python 中，print(f"string={}") 是一种用于格式化字符串的语法结构。其中，“string”表示字符串；“f”前缀表示这是一个格式化字符串；“{}”是占位符，用于指示将要插入该位置的变量。注意：“f”后面一定要紧跟字符串，不能隔有空格，否则会报错。

a = 1
b = 2
c = 3
print(f"b={b}, c={c}, a={a}")
# 上面的代码等效于：
print("b={}, c={}, a={}".format(2, 1, 3))

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

b=2, c=3, a=1
b=2, c=1, a=3

5.5 不换行输出

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""，比如：

print("a")
print("b", end="")
print("c")

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

a
bc

5.6 换行输出

（1）print 默认输出是换行的，此外，在变量末尾加上 end="\n" 可以在多个 print 函数的输出结果中实现换行，比如：

print("a")
print("b", end="")
print("c", end="\n")
print("d")

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

a
bc
d

（2）转义字符 \n 可以在 print 一次性输出的字符串中间换行，比如：

print("123456789---------")
print("123456789\n---------")

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

123456789---------
123456789
---------

（3）可以借助 for 循环和 while 循环实现换行输出，比如：

# for 循环实现换行输出
a = "hello"
for i in a:
    print(i)
# while 循环实现换行输出
j = 0
while j <= 4:
    print(a[j])
    j += 1

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

h
e
l
l
o
h
e
l
l
o

5.7 实现水平制表符输出

（1）在变量末尾加上 end="\t" 可以在多个 print 函数的输出结果中实现水平制表符，比如：

print("a", end="\t")
print(end="")
print("b")

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

a	b

（2）转义字符 \t 可以在 print 一次性输出的字符串中间实现水平制表符，比如：

print("123456789\t---------")

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

123456789	---------

5.8 更换间隔字符输出

默认情况下，print() 函数一次性输出的两个字符串使用空格分隔，在变量末尾加上参数 sep ="" 可以修改间隔字符，比如：

print("www", "baidu", "com")
print("www", "baidu", "com", sep=".")
print("www", "baidu", "com", sep="/")

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

wwwbaiducom
www.baidu.com
www/baidu/com

6. 数字类型

Python 中存在四种不同的数字（Number）类型，整数（int）、浮点数（float）、布尔类型（bool）和复数（complex）。

6.1 整数（int）

整数（int）是完整的数字，正数或负数，没有小数，长度不限。默认用十进制表示，同时也支持二进制，八进制，十六进制表示方式。比如：

3
-3

6.2 浮点数（float）

Python 的浮点数（float）也就是数学中的小数。比如：

3.14
2.5
-0.3

6.3 布尔（bool）

Python 中提供了 bool 类型来表示真（对）或假（错），并分别用 关键字 Ture（真或对）或 False（假或错）来表示，在 Python中，是明确区分大小写的，即首字母一定要大写，不然解释器会报错。比如：

print(True)
print(False)

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

True
False

bool 类型只有 Ture 和 False 两个实例，且 bool 值可以当作整数来代替，即 True 代表整数1，False 代表整数 0，并可以参与运算，但在项目开发中不能这样用：

print(5 > 4)
print(5 < 4)
print(True+1)
print(False+1)

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

True
False
2
1

6.4 复数（complex）

复数由实数部分和虚数部分组成，可以用 a+bj 或者 complex(a, b)表示，复数的实部 a 和虚部 b 都是浮点型。

（1）方式一：a+bj

1+4j
-8j

（2）方式二：complex(a, b)

complex(1, 4)
complex(0, -8)

7. 数据类型转换

数据类型转换是将自身数据类型转化成新的数据类型，并拥有新数据类型相关操作的过程。

7.1 用 type() 函数查看数据类型

有时你可能想知道某个程序中的变量类型，也许这个类型从代码中并不明显，或者你从一个代码无法访问的源头得到了这个信息。每当你想查看一个变量的类型时，你可以使用 type() 函数，语法格式为 type(object)，其中 object 为需要查看数据类型的目标数据，不需要用引号引起来。

（1）识别字符串（str），比如：

name1 = "Li Ming"
print(type(name1))

name2 = "123456"
print(type(name2))

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

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

用 type() 函数检查 "Li Ming" 显示它的类型是 str；用 type() 函数检查 "123456"，这个变量再次持有 str 的类型，尽管我们看到了数字，但它是一个被双引号引起来的数字字符串，而不是实际的数字类型。

（2）识别整数（int），浮点数（float） ，布尔类型（bool）和复数（complex），比如：

name1 = 123456
print(type(name1))

name2 = 1.23456
print(type(name2))

print(type(5 > 4))
print(type(4 > 5))

print(type(1+4j))
print(type(complex(4, 5)))

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

<class 'int'>
<class 'float'>
<class 'bool'>
<class 'bool'>
<class 'complex'>
<class 'complex'>

7.2 隐式类型转换

在隐式类型转换中，Python 会自动将一种数据类型转换为另一种数据类型，不需要我们去干预，比如：

print(type(1+0.1))

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

<class 'float'>

我们对两种不同类型的数据进行运算，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。

7.3 显式类型转换

在显式类型转换中，用户将对象的数据类型转换为所需的数据类型。

（1）int() 函数

int() 函数用于将一个字符串或数字转换为整型。语法格式为 int(x, base=10)，x 为字符串或数字，base 为进制数，默认十进制。

① 不输入参数时，输出结果为 0：

print(int())
print(int(3))           
print(int(3.6)) 

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

0
3
3

② 若 x 为纯数字，则不能有 base 参数，否则报错，比如：

print(int(3, 10))

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

Traceback (most recent call last):
  File "", line 1, in <module>
    print(int(3, 10))
TypeError: int() can't convert non-string with explicit base

如果是带参数 base 的话，x 要以字符串的形式进行输入，比如：

print(int("3", 10))

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

3 

（2）float() 函数

float() 函数用于将整数和字符串转换成浮点数。语法格式为 float(x)，其中 x 为整数或字符串。比如：

print(float(3))             # 整数
print(float(3.0))           # 小数
print(float(-3.0))          # 小数
print(float("3"))           # 字符串
print(float("3.0"))         # 字符串

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

3.0
3.0
-3.0
3.0
3.0

（3）str() 函数

str() 函数用于将参数转换成字符串类型，即适于人阅读的形式。比如：

print(str(1))
print(str("1"))

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

1
1

8. 输入

Python 中 input 函数用于提示并获取终端用户输入内容，一般获取的输入内容为字符串类型。 input 函数的语法格式为 input(tips)，其中 tips 为提示信息，一般用引号引起来提示输出。运行代码之后可自定义输入目标数据，返回结果为字符串 str 类型。比如：

a = input("请输入账号：")
print("您输入的账号为：%s" % a)
print("您输入的账号类型为：", type(a))

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

请输入账号：abcdefg
您输入的账号为：abcdefg
您输入的账号类型为： <class 'str'>

9. 运算符

Python 运算符主要包括算术运算符、比较运算符、赋值运算符、位运算符、逻辑运算符、成员运算符和身份运算符。

9.1 算术运算符

算术运算符包括：加（+）、减（-）、乘（*）、除（/）、取模（%）、幂（**）和取整除（//）。以下假设变量 a=10，变量 b=21：

运算符	含义	描述	实例
+	加	两个对象相加	a + b 输出结果 31
-	减	得到负数或是一个数减去另一个数	a - b 输出结果 -11
*	乘	两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 210
/	除	x 除以 y	b / a 输出结果 2.1
%	取模	返回除法的余数	b % a 输出结果 1
**	幂	返回 x 的 y 次幂	a ** b 为10的21次方
//	取整除	往小的方向取整数	b // a 输出结果 2

9.2 比较运算符

比较运算符包括：等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）和小于等于（<=）。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量 True 和 False 等价。以下假设变量 a 为10，变量 b 为20：

运算符	含义	描述	实例
==	等于	比较对象是否相等	a == b 返回 False
!=	不等于	比较两个对象是否不相等	a != b 返回 True
>	大于	返回 x 是否大于 y	a > b 返回 False
<	小于	返回 x 是否小于 y	a < b 返回 True
>=	大于等于	返回 x 是否大于等于 y	a >= b 返回 False
<=	小于等于	返回 x 是否小于等于 y	a <= b 返回 False

9.3 赋值运算符

赋值运算符包括：简单的赋值运算符（=）、加法赋值运算符（+=）、减法赋值运算符（-=）、乘法赋值运算符（*=）、除法赋值运算符（/=）、取模赋值运算符（%=）、幂赋值运算符（**=）和取整除赋值运算符（//=）。

运算符	含义	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c * a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

比如：

a = 2
b = 11

c = a + b
print(c)

c += a
print(c)

c -= a
print(c)

c *= a
print(c)

c /= a
print(c)

c %= a
print(c)

c **= a
print(c)

c //= a
print(c)

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

13
15
13
26
13.0
1.0
1.0
0.0

9.4 位运算符

按位运算符是把数字看作二进制来进行计算。

（1）位运算符的规则

程序中的数在计算机内存中都是以二进制的形式存在的，位运算就是直接对整数在内存中对应的二进制位进行操作。比如，a 为 60，b 为 13，它们的二进制格式如下：

a = 0011 1100
b = 0000 1101

运算符	含义	描述	实例
&	按位与运算符	参与运算的两个值,如果两个相应位都为 1，则该位的结果为 1，否则为 0	(a & b) 输出结果 12 ，二进制解释：0000 1100
|	按位或运算符	只要对应的二个二进位有一个为 1 时，结果位就为 1	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符	当两对应的二进位相异时，结果为 1	(a ^ b) 输出结果 49 ，二进制解释：0011 0001
~	按位取反运算符	对数据的每个二进制位取反，即把 1 变为 0，把 0 变为 1。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<	左移动运算符	运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃，低位补0	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符	把“>>”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

（2）二进制与十进制之间的转换方法

① 十进制转二进制

Ⅰ 十进制正整数转换为二进制

采用"除2取余，逆序排列"法。具体做法是：用2去除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为0时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。比如：

十进制正整数 78 转换为二进制数 1001110

Ⅱ 十进制负整数转换为二进制整数

先是将对应的正整数转换成二进制后，对二进制取反，然后对结果再加 1。比如：

十进制负整数 -83 转换为二进制整数

Ⅲ 十进制小数转换为二进制

对小数点以后的数乘以 2，有一个结果吧，取结果的整数部分（不是 1 就是 0 喽），然后再用小数部分再乘以 2，再取结果的整数部分……以此类推，直到小数部分为 0 或者位数已经够了就 OK 了。然后把取的整数部分按先后次序排列就 OK 了，就构成了二进制小数部分的序列。比如：

十进制小数 0.125 转换为二进制

② 二进制转十进制

Ⅰ 二进制正整数转换为十进制

首先将二进制数补齐位数，首位如果是 0 就代表是正整数，如果首位是 1 则代表是负整数。

先看首位是 0 的正整数，补齐位数以后，将二进制中的位数分别将下边对应的值相乘，然后相加得到的就为十进制，比如 1010 转换为十进制：

二进制正整数 1010 转换为十进制

Ⅱ 二进制负整数转换为十进制

若二进制补足位数后首位为 1 时，就需要先取反再换算：比如，11101011，首位为 1，那么就先取反：-00010100，然后算一下 10100 对应的十进制为20，所以对应的十进制为-20：

二进制负整数 11101011 转换为十进制

Ⅲ 二进制小数转换为十进制

例如 0.1101 转换为十进制的方法：将二进制中的四位数分别于下边对应的值相乘后相加得到的值即为换算后的十进制。

二进制小数 0.1101 转换为十进制

（3）补码与源码

现在计算机普遍使用补码表示负数，但是如果任意给出一个二进制数字，无法分辨它是源码还是补码。如果确认是补码，求源码的方式是：补码取反再加 1。补码的第一位符号位决定了源码的正负，第一位为 0 源码为正，第一位为 1 源码为负。

比如，在求解 ~60 时，60 按位取反后得到 1100 0011，其第一位为1，源码为负值，取反后为 0011 1100，再加 1 得 0011 1101，其值为 61，再加上负号即为 -61。

（4）位运算符在 Python 中的应用

在进行十进制位运算时，无需转换为二进制，只要使用位运算符，Python 就会按照二进制来进行计算。比如：

a = 60
b = 13
print(a & b)
print(a | b)
print(a ^ b)
print(~a)
print(a << 2)
print(a >> 2)

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

12
61
49
-61
240
15

9.5 逻辑运算符

Python 语言支持逻辑运算符：

运算符	含义	逻辑表达式	描述
and	布尔“与”	x and y	同真为真，一假则假
or	布尔“或”	x or y	同假才假，一真即真
not	布尔“非”	x not y	非真即假，非假即真

在 Python 中，整数0代表假，整数 1 代表真。除此之外，Python 也把任意的空数据结构视为假，把任何非空数据结构视为真。真和假的概念是 Python 中每个对象的固有属性，一般来说：① 数字如果非零，则为真；② 其他对象如果非空，则为真。Python 还有一个特殊对象：None，它总被认为是假。

比如：

a = 10
b = 20

if a and b:
    print("1 - 变量 a 和 b 都为 true")
else:
    print("1 - 变量 a 和 b 有一个不为 true")

if a or b:
    print("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
    print("2 - 变量 a 和 b 都不为 true")

# 修改变量 a 的值
a = 0
if a and b:
    print("3 - 变量 a 和 b 都为 true")
else:
    print("3 - 变量 a 和 b 有一个不为 true")

if a or b:
    print("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
    print("4 - 变量 a 和 b 都不为 true")

if not (a and b):
    print("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
    print("5 - 变量 a 和 b 都为 true")

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

1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 false

9.6 成员运算符

Python 支持成员运算符：

运算符	描述
in	如果在指定的序列中找到值返回 True，否则返回 False
not in	如果在指定的序列中没有找到值返回 True，否则返回 False

比如：

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

if a in list:
    print("a在列表中")
else:
    print("a不在列表中")

if b not in list:
    print("b不在列表中")
else:
    print("b在列表中")

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

a不在列表中
b在列表中

9.7 身份运算符

（1）身份运算符是 Python 用来判断的两个对象的存储单元是否相同的一种运算符号，身份运算符只有 is 和 is not 两个运算符，返回的结果都是 True 或者 False：

运算符	描述	实例
is	判断两个标识符是不是引用自一个对象	x is y， 如果引用的是同一个对象则返回 True，否则返回 False
is not	是判断两个标识符是不是引用自不同对象	x is not y，如果引用的不是同一个对象则返回结果 True，否则返回 False

比如：

a = 1
b = 2
c = a
print(a is b)
print(a is c)
print(a is not b)
print(a is not c)

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

False
True
True
False

再比如：

a = [0, 1, 2]
b = [1-1, 2-1, 3-1]
c = a
print(a)
print(b)
print(a is b)
print(a is c)

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

[0, 1, 2]
[0, 1, 2]
False
True

通过这个结果我们发现，a 和 b 引用的对象是不一致的，所以 a is b 输出的结果是 False，因为变量 b 是需要计算的，虽然计算之后得到的列表跟 a 一模一样，但是计算之前的过程每个元素是要存储的，变量 a 当中的元素都是数字，计算机是直接存储结果的，而变量 b 当中的每个元素都是表达式，表达式的储存跟单个元素的储存是不一致的，列表、元组都是如此。

（2）is 与 == 的区别

is 用于判断两个变量引用对象是否为同一个，== 用于判断引用变量的值是否相等。比如：

a = [0, 1, 2]
b = [1-1, 2-1, 3-1]
c = a
print(a is b)
print(a is c)
print(b is c)
print(a is b is c)
print(a == b == c)

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

False
True
False
False
True

9.8 运算符优先级

以下表格列出了从最高到最低优先级的所有运算符， 相同单元格内的运算符具有相同优先级：

优先级	运算符	描述	结合性
19	()	小括号	无
18	x[i]	索引运算符	左
17	x.attribute	属性访问	左
16	**	乘方（指数）	右
15	~	按位取反	右
14	+, -	正号，负号	右
13	*, /, %, //	乘，除，取模，取整除	左
12	+, -	加号，减号	左
11	>>, <<	右移动运算符，左移动运算符	左
10	&	按位与运算符	右
9	^	按位异或运算符	左
8	|	按位或运算符	左
7	==, !=, <=, <, >, >=	等于，不等于，小于等于，小于，大于等于，大于	左
6	is, is not	身份运算符	左
5	in, not in	成员运算符	左
4	not	逻辑运算符非	右
3	and	逻辑运算符与	左
2	or	逻辑运算符或	左
1	exp1, exp2	逗号运算符	左

所谓结合性，就是当一个表达式中出现多个优先级相同的运算符时，先执行哪个运算符：先执行左边的叫左结合性，先执行右边的叫右结合性。例如对于表达式对于 100 / 25 * 16，/ 和 * 的优先级相同，应该先执行哪一个呢？这个时候就不能只依赖运算符优先级决定了，还要参考运算符的结合性。/ 和 * 都具有左结合性，因此先执行左边的除法，再执行右边的乘法，最终结果是 64。

Python 中大部分运算符都具有左结合性，也就是从左到右执行；只有 ** 乘方运算符、单目运算符（例如 not 逻辑非运算符）、赋值运算符和三目运算符例外，它们具有右结合性，也就是从右向左执行。

10. 行与缩进

Python 最具特色的就是使用缩进来表示代码块。缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数，一般用 Tab 健进行操作。比如：

if True:
    print("Answer")
    print("True")
else:
    print("Answer")
    print("False")  

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

Answer
True

以下代码最后一行语句和同一代码块语句缩进数的空格数不一致，会导致运行错误：

if True:
    print("Answer")
    print("True")
else:
    print("Answer")
  print("False")    # 缩进不一致，会导致运行错误

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

  File ".py", line 6
    print ("False")
                   ^
IndentationError: unindent does not match any outer indentation level

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 语句中，可以把 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. 模块的导入和下载

（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)

（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("很遗憾，你输了。")

（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 包名”，即可进行模块的安装。

在 PyCharm 代码编辑区下载模块（包）

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:end: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:end: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                                                 # 通过加法赋值运算符实现 办公室编号的递增，至此完成一次遍历，直至 3 次遍历全部完成

---

VeryVast

5 次咨询

5.0

武汉大学 土地资源管理硕士在读

1981 次赞同

去咨询

编辑于 2024-05-19 17:42・IP 属地湖北

内容所属专栏

Python基础

订阅专栏

Python

Python 入门

Python基础

​赞同 162​​323 条评论

​分享

​喜欢​收藏

1. 编码

如果在程序中用到了中文，直接输出结果很可能会出错，比如：

print("你好")

解决的办法是，在程序的开头写入如下代码：

# -*- coding:utf-8 -*-

或者

# coding=utf-8

用于向 Python 解释器声明源代码文件所用的编码类型为“utf-8”，如果代码里有中文，打印的时候可以使中文正常显示。

2. 注释

Python 中的注释包括单行注释和多行注释。

2.1 单行注释

Python 中单行注释以 # 开头：

# 第一个注释
print("Hello World") # 第二个注释

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

Hello World

2.2 多行注释

（1）Python 中多行注释可以用多个 # 开头，或者用 ''' 和 """ 双引注释内容：

# 第一个注释
# 第二个注释

'''
第三个注释
第四个注释
'''

"""
第五个注释
第六个注释
"""

print("Hello World")

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

Hello World

（2）通过快捷键进行多行注释

在 Windows 系统中，可以通过鼠标选择需要注释的代码，然后使用“Ctrl+/”可以快速注释或取消注释多行代码：

# def outer(origin):
#     def inner():
#         print("before")
#         res = origin()  # 调用下面的 func 函数
#         print("after")
#         return res
#
#     return inner
print("Hello")

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

Hello

3. 标识符

3.1 标识符的概念

标识符是程序中某一元素（变量、关键字、函数、类、模块、对象）的名字。说通俗点，标识符就是以后给我们写的每个代码所起的名字，就好比我们每个人生下来都要起名字。除了关键字的名字是固定的，其它元素都可以根据标识符的命名规则进行命名。

3.2 标识符的命名规则

标识符由字母（ A~Z , a~z ）、数字（0-9）、以及下划线（_）组成。

（1）标识符的第一个字符必须是字母（ A~Z , a~z ）或下划线（_）；

比如：

Hello
apple
_max
_Min

（2）标识符的其它部分由字母（ A~Z , a~z ）、数字（0-9）或者下划线（_）组成；

比如：

Apple10
Apple_10
V_3_V
CON2_5
_Test_3

（3）标识符对大小写敏感；

比如：

A 和 a
Apple 和 apple
Sum_ 和 sum_
_name 和 _NAME
Test2 和 test2

3.3 变量

变量是标识符的一种，是一个用于保存值的占位符。可以通过变量名获得对值的引用，可以是任意的数据类型。变量命名时尽量体现出值的数据类型。如命名 count、length 和 size 表明数据类型是数字，命名 name、title 和 message 表明数据类型是字符串，单个字符命名的变量诸如 i、j、k 通常在循环中使用。

Python 中使用变量，不需要声明，直接为变量赋值即可使用，比如：

a = 10
print(a)

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

10

上述代码中，a 即为变量。但要注意，不能使用没有进行过赋值的变量，使用之后就会报错，比如：

print(a)

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

Traceback (most recent call last):
  File "", line 1, in <module>
    print(a)
NameError: name 'a' is not defined

4. 关键字

4.1 关键字的概念

有一分部标识符是 Python 自带的、具有特殊含义的名字，我们称之为“关键字”，或者“保留字”；关键字已经被 Python 使用，所以不允许开发者自己定义和关键字名字相同的标识符。

4.2 查看关键字

Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：【Win+R】调出【运行】弹窗>>>输入“cmd”>>>点击【确定】>>>在打开的界面中输入“python”>>>回车，进入 Python 交互模式，在交互模式下输入以下代码：

>>> import keyword
>>> keyword.kwlist

执行以上代码，输出结果为当前版本的所有关键字：

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

5. 输出

Python 输出主要包括标准化输出、格式化输出、不换行输出、换行输出和更换间隔字符输出。

5.1 标准化输出

Python 编程中 print 的用法是输入 print（），括弧中可以是数字、变量、字符串、列表、元组合字典。需要注意的是：① print 一定要全部小写；② print 后边的括弧要在英文状态输入。

（1）括号内可以是字符串，需要用单引号或双引号括起来，比如：

print("Hello World")
print('Hello World')

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

Hello World
Hello World

（2）括号内可以是数字或者数字的运算，比如：

print(7)
print(7+5)

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

7
12

（3）括弧内可以是变量或者变量的运算，比如：

a = 4
b = 7*8/2
print(a)
print(b)
print(a+b)

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

4
28.0
32.0

（3）括号内可以是字符串和数字的组合，需要把数字用引号括起来作为字符串使用，比如：

print("My lucky number is", " 6 ")

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

My lucky number is 6 

（4）括号内可以是字符串和变量的组合，比如：

a = 3
print("输出的数字为：", a)

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

输出的数字为： 3

5.2 格式化输出（%）

格式化是对字符串进行一定的格式显示或输出的方式，可以通过“%”，“format 函数”和“print(f"string")”实现。

% 符号可以实现字符串的格式化。在字符串内部 %() 表示特定格式字符串的占位，字符串右侧通过 % 连接要格式化的参数，它们和内部占位符 % 一一对应，中间不需要逗号连接。常用的格式符号如下：

i格式符号	转换
%d	*有符号十进制整数
%s	*通过str()字符串转换来格式化
%i	有符号十进制整数
%c	字符
%u	无符号十进制整数
%o	八进制整数
%x	十六进制整数（小写字母）
%X	十六进制整数（大写字母）
%e	索引符号（小写'e'）
%E	索引符号（大写"E"）
%f	浮点实数
%g	%f和%e的简写
%G	%F和%E的简写

① %d 的使用，比如：

number = 6
print("My lucky number is %d" % number)

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

My lucky number is 6

② %s 的使用，比如：

print("My name is %s" % "Li Ming")

name = "Jenny"
print("Her name is %s" % name)

print("My name is %s"" and my lucky colour is %s" % ("Li Ming", "blue"))

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

My name is Li Ming
Her name is Jenny
My name is Li Ming and my lucky colour is blue

5.3 格式化输出（format 函数）

format 函数是字符串内嵌的一个方法，用于格式化字符串。以大括号 {} 来标明被替换的字符串，语法格式为："{}".format()

（1）通过大括号 {} 的默认顺序依次匹配元组中的参数

str = "{} is a beautiful {}！".format("Beijing","city")
print(str)

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

Beijing is a beautiful city！

（2）通过索引的方式匹配参数

str1 = "{0} is a beautiful {1}!".format("Beijing", "city")
print(str1)
str2 = "{1} is a beautiful {2}!".format("Tianjin","Beijing", "city")
print(str2)

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

Beijing is a beautiful city!
Beijing is a beautiful city!

（3）通过参数名匹配参数

str1 = "{name1} is a beautiful {name2}!".format(name1="Beijing", name2="City")
print(str1)

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

Beijing is a beautiful city!

（4）混合使用

① 可以通过索引，参数名混合进行匹配，但命名参数必须写到最后，否则会报错：

str1 = "{0} is a beautiful {name}!".format("Beijing", name="city")
print(str1)

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

Beijing is a beautiful city!

② 可以通过默认顺序和参数名混合进行匹配，但命名参数必须写到最后，否则会报错：

str1 = "{} is a beautiful {name}!".format("Beijing", name="city") 
print(str1)

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

Beijing is a beautiful city!

③ 不可以索引和默认顺序混合使用，否则会报错。

（5）通过对象的属性匹配参数

class Names:
    Name1 = "Beijing"
    Name2 = "city"


str1 = "{names.Name1} is a beautiful {names.Name2}!".format(names=Names)
print(str1)

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

Beijing is a beautiful city!

（6）引用参数部分

str1 = "The first letter of '{word}' is '{word[0]}'.".format(word="hello")
print(str1)

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

The first letter of 'hello' is 'h'.

（7）数字的处理

① 保留小数位数

str1 = "π is {:.2f}.".format(3.1415926)  #保留两位小数
print(str1)

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

π is 3.14.

② 给数字加千位符

str1 = "{:,}".format(100000000)
print(str1)

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

100,000,000

③ 进制的转换

s1 = "{:b}".format(8)     # 将数字8转换为二进制
print(s1)
s2 = "{:o}".format(8)     # 将数字8转换为八进制
print(s2)      
s3 = "{:x}".format(12)    # 将数字12转换为十六进制
print(s3) 

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

1000
10
C

（8）格式的处理

通过 ：数字 指定转换后的字符串长度，不足的部分用空格补充：

s = "{:2}b".format('a')
print(s) 
# 如果指定的长度小于参数的长度，按照原参数匹配
s1 = "{:2}World".format('Hello')
print(s1) 

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

a b
HelloWorld

（9）字符的填充

可通过 :符号^数字 进行字符串的填充，其中数字为填充后的字符串总长度：

s = "{:*^10}".format('Hello')
print(s)

s = "{:-^20}".format('123456')
print(s)

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

**Hello***
-------123456-------

（10）匹配列表、字典中的参数

在 format 函数格式化时，可使用 * 或者 ** 对列表、字典和元组进行拆分。

① 匹配列表中的参数

list = ["Beijing", "city"]
str1 = "{} is a beautiful {}!".format(*list)
str2 = "{1} is a beautiful {0}!".format(*list)
print(str1)
print(str2)

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

Beijing is a beautiful city!
city is a beautiful Beijing!

② 匹配字典中的参数

dict = {"name1": "Beijing", "name2": "city"}
str1 = "{name1} is a beautiful {name2}!".format(**dict)
print(str1)

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

Beijing is a beautiful city!

5.4 格式化输出（print(f"string={}")）

在 Python 中，print(f"string={}") 是一种用于格式化字符串的语法结构。其中，“string”表示字符串；“f”前缀表示这是一个格式化字符串；“{}”是占位符，用于指示将要插入该位置的变量。注意：“f”后面一定要紧跟字符串，不能隔有空格，否则会报错。

a = 1
b = 2
c = 3
print(f"b={b}, c={c}, a={a}")
# 上面的代码等效于：
print("b={}, c={}, a={}".format(2, 1, 3))

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

b=2, c=3, a=1
b=2, c=1, a=3

5.5 不换行输出

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""，比如：

print("a")
print("b", end="")
print("c")

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

a
bc

5.6 换行输出

（1）print 默认输出是换行的，此外，在变量末尾加上 end="\n" 可以在多个 print 函数的输出结果中实现换行，比如：

print("a")
print("b", end="")
print("c", end="\n")
print("d")

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

a
bc
d

（2）转义字符 \n 可以在 print 一次性输出的字符串中间换行，比如：

print("123456789---------")
print("123456789\n---------")

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

123456789---------
123456789
---------

（3）可以借助 for 循环和 while 循环实现换行输出，比如：

# for 循环实现换行输出
a = "hello"
for i in a:
    print(i)
# while 循环实现换行输出
j = 0
while j <= 4:
    print(a[j])
    j += 1

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

h
e
l
l
o
h
e
l
l
o

5.7 实现水平制表符输出

（1）在变量末尾加上 end="\t" 可以在多个 print 函数的输出结果中实现水平制表符，比如：

print("a", end="\t")
print(end="")
print("b")

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

a	b

（2）转义字符 \t 可以在 print 一次性输出的字符串中间实现水平制表符，比如：

print("123456789\t---------")

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

123456789	---------

5.8 更换间隔字符输出

默认情况下，print() 函数一次性输出的两个字符串使用空格分隔，在变量末尾加上参数 sep ="" 可以修改间隔字符，比如：

print("www", "baidu", "com")
print("www", "baidu", "com", sep=".")
print("www", "baidu", "com", sep="/")

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

wwwbaiducom
www.baidu.com
www/baidu/com

6. 数字类型

Python 中存在四种不同的数字（Number）类型，整数（int）、浮点数（float）、布尔类型（bool）和复数（complex）。

6.1 整数（int）

整数（int）是完整的数字，正数或负数，没有小数，长度不限。默认用十进制表示，同时也支持二进制，八进制，十六进制表示方式。比如：

3
-3

6.2 浮点数（float）

Python 的浮点数（float）也就是数学中的小数。比如：

3.14
2.5
-0.3

6.3 布尔（bool）

Python 中提供了 bool 类型来表示真（对）或假（错），并分别用 关键字 Ture（真或对）或 False（假或错）来表示，在 Python中，是明确区分大小写的，即首字母一定要大写，不然解释器会报错。比如：

print(True)
print(False)

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

True
False

bool 类型只有 Ture 和 False 两个实例，且 bool 值可以当作整数来代替，即 True 代表整数1，False 代表整数 0，并可以参与运算，但在项目开发中不能这样用：

print(5 > 4)
print(5 < 4)
print(True+1)
print(False+1)

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

True
False
2
1

6.4 复数（complex）

复数由实数部分和虚数部分组成，可以用 a+bj 或者 complex(a, b)表示，复数的实部 a 和虚部 b 都是浮点型。

（1）方式一：a+bj

1+4j
-8j

（2）方式二：complex(a, b)

complex(1, 4)
complex(0, -8)

7. 数据类型转换

数据类型转换是将自身数据类型转化成新的数据类型，并拥有新数据类型相关操作的过程。

7.1 用 type() 函数查看数据类型

有时你可能想知道某个程序中的变量类型，也许这个类型从代码中并不明显，或者你从一个代码无法访问的源头得到了这个信息。每当你想查看一个变量的类型时，你可以使用 type() 函数，语法格式为 type(object)，其中 object 为需要查看数据类型的目标数据，不需要用引号引起来。

（1）识别字符串（str），比如：

name1 = "Li Ming"
print(type(name1))

name2 = "123456"
print(type(name2))

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

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

用 type() 函数检查 "Li Ming" 显示它的类型是 str；用 type() 函数检查 "123456"，这个变量再次持有 str 的类型，尽管我们看到了数字，但它是一个被双引号引起来的数字字符串，而不是实际的数字类型。

（2）识别整数（int），浮点数（float） ，布尔类型（bool）和复数（complex），比如：

name1 = 123456
print(type(name1))

name2 = 1.23456
print(type(name2))

print(type(5 > 4))
print(type(4 > 5))

print(type(1+4j))
print(type(complex(4, 5)))

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

<class 'int'>
<class 'float'>
<class 'bool'>
<class 'bool'>
<class 'complex'>
<class 'complex'>

7.2 隐式类型转换

在隐式类型转换中，Python 会自动将一种数据类型转换为另一种数据类型，不需要我们去干预，比如：

print(type(1+0.1))

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

<class 'float'>

我们对两种不同类型的数据进行运算，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。

7.3 显式类型转换

在显式类型转换中，用户将对象的数据类型转换为所需的数据类型。

（1）int() 函数

int() 函数用于将一个字符串或数字转换为整型。语法格式为 int(x, base=10)，x 为字符串或数字，base 为进制数，默认十进制。

① 不输入参数时，输出结果为 0：

print(int())
print(int(3))           
print(int(3.6)) 

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

0
3
3

② 若 x 为纯数字，则不能有 base 参数，否则报错，比如：

print(int(3, 10))

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

Traceback (most recent call last):
  File "", line 1, in <module>
    print(int(3, 10))
TypeError: int() can't convert non-string with explicit base

如果是带参数 base 的话，x 要以字符串的形式进行输入，比如：

print(int("3", 10))

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

3 

（2）float() 函数

float() 函数用于将整数和字符串转换成浮点数。语法格式为 float(x)，其中 x 为整数或字符串。比如：

print(float(3))             # 整数
print(float(3.0))           # 小数
print(float(-3.0))          # 小数
print(float("3"))           # 字符串
print(float("3.0"))         # 字符串

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

3.0
3.0
-3.0
3.0
3.0

（3）str() 函数

str() 函数用于将参数转换成字符串类型，即适于人阅读的形式。比如：

print(str(1))
print(str("1"))

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

1
1

8. 输入

Python 中 input 函数用于提示并获取终端用户输入内容，一般获取的输入内容为字符串类型。 input 函数的语法格式为 input(tips)，其中 tips 为提示信息，一般用引号引起来提示输出。运行代码之后可自定义输入目标数据，返回结果为字符串 str 类型。比如：

a = input("请输入账号：")
print("您输入的账号为：%s" % a)
print("您输入的账号类型为：", type(a))

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

请输入账号：abcdefg
您输入的账号为：abcdefg
您输入的账号类型为： <class 'str'>

9. 运算符

Python 运算符主要包括算术运算符、比较运算符、赋值运算符、位运算符、逻辑运算符、成员运算符和身份运算符。

9.1 算术运算符

算术运算符包括：加（+）、减（-）、乘（*）、除（/）、取模（%）、幂（**）和取整除（//）。以下假设变量 a=10，变量 b=21：

运算符	含义	描述	实例
+	加	两个对象相加	a + b 输出结果 31
-	减	得到负数或是一个数减去另一个数	a - b 输出结果 -11
*	乘	两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 210
/	除	x 除以 y	b / a 输出结果 2.1
%	取模	返回除法的余数	b % a 输出结果 1
**	幂	返回 x 的 y 次幂	a ** b 为10的21次方
//	取整除	往小的方向取整数	b // a 输出结果 2

9.2 比较运算符

比较运算符包括：等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）和小于等于（<=）。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量 True 和 False 等价。以下假设变量 a 为10，变量 b 为20：

运算符	含义	描述	实例
==	等于	比较对象是否相等	a == b 返回 False
!=	不等于	比较两个对象是否不相等	a != b 返回 True
>	大于	返回 x 是否大于 y	a > b 返回 False
<	小于	返回 x 是否小于 y	a < b 返回 True
>=	大于等于	返回 x 是否大于等于 y	a >= b 返回 False
<=	小于等于	返回 x 是否小于等于 y	a <= b 返回 False

9.3 赋值运算符

赋值运算符包括：简单的赋值运算符（=）、加法赋值运算符（+=）、减法赋值运算符（-=）、乘法赋值运算符（*=）、除法赋值运算符（/=）、取模赋值运算符（%=）、幂赋值运算符（**=）和取整除赋值运算符（//=）。

运算符	含义	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c * a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

比如：

a = 2
b = 11

c = a + b
print(c)

c += a
print(c)

c -= a
print(c)

c *= a
print(c)

c /= a
print(c)

c %= a
print(c)

c **= a
print(c)

c //= a
print(c)

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

13
15
13
26
13.0
1.0
1.0
0.0

9.4 位运算符

按位运算符是把数字看作二进制来进行计算。

（1）位运算符的规则

程序中的数在计算机内存中都是以二进制的形式存在的，位运算就是直接对整数在内存中对应的二进制位进行操作。比如，a 为 60，b 为 13，它们的二进制格式如下：

a = 0011 1100
b = 0000 1101

运算符	含义	描述	实例
&	按位与运算符	参与运算的两个值,如果两个相应位都为 1，则该位的结果为 1，否则为 0	(a & b) 输出结果 12 ，二进制解释：0000 1100
|	按位或运算符	只要对应的二个二进位有一个为 1 时，结果位就为 1	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符	当两对应的二进位相异时，结果为 1	(a ^ b) 输出结果 49 ，二进制解释：0011 0001
~	按位取反运算符	对数据的每个二进制位取反，即把 1 变为 0，把 0 变为 1。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<	左移动运算符	运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃，低位补0	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符	把“>>”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

（2）二进制与十进制之间的转换方法

① 十进制转二进制

Ⅰ 十进制正整数转换为二进制

采用"除2取余，逆序排列"法。具体做法是：用2去除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为0时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。比如：

十进制正整数 78 转换为二进制数 1001110

Ⅱ 十进制负整数转换为二进制整数

先是将对应的正整数转换成二进制后，对二进制取反，然后对结果再加 1。比如：

十进制负整数 -83 转换为二进制整数

Ⅲ 十进制小数转换为二进制

对小数点以后的数乘以 2，有一个结果吧，取结果的整数部分（不是 1 就是 0 喽），然后再用小数部分再乘以 2，再取结果的整数部分……以此类推，直到小数部分为 0 或者位数已经够了就 OK 了。然后把取的整数部分按先后次序排列就 OK 了，就构成了二进制小数部分的序列。比如：

十进制小数 0.125 转换为二进制

② 二进制转十进制

Ⅰ 二进制正整数转换为十进制

首先将二进制数补齐位数，首位如果是 0 就代表是正整数，如果首位是 1 则代表是负整数。

先看首位是 0 的正整数，补齐位数以后，将二进制中的位数分别将下边对应的值相乘，然后相加得到的就为十进制，比如 1010 转换为十进制：

二进制正整数 1010 转换为十进制

Ⅱ 二进制负整数转换为十进制

若二进制补足位数后首位为 1 时，就需要先取反再换算：比如，11101011，首位为 1，那么就先取反：-00010100，然后算一下 10100 对应的十进制为20，所以对应的十进制为-20：

二进制负整数 11101011 转换为十进制

Ⅲ 二进制小数转换为十进制

例如 0.1101 转换为十进制的方法：将二进制中的四位数分别于下边对应的值相乘后相加得到的值即为换算后的十进制。

二进制小数 0.1101 转换为十进制

（3）补码与源码

现在计算机普遍使用补码表示负数，但是如果任意给出一个二进制数字，无法分辨它是源码还是补码。如果确认是补码，求源码的方式是：补码取反再加 1。补码的第一位符号位决定了源码的正负，第一位为 0 源码为正，第一位为 1 源码为负。

比如，在求解 ~60 时，60 按位取反后得到 1100 0011，其第一位为1，源码为负值，取反后为 0011 1100，再加 1 得 0011 1101，其值为 61，再加上负号即为 -61。

（4）位运算符在 Python 中的应用

在进行十进制位运算时，无需转换为二进制，只要使用位运算符，Python 就会按照二进制来进行计算。比如：

a = 60
b = 13
print(a & b)
print(a | b)
print(a ^ b)
print(~a)
print(a << 2)
print(a >> 2)

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

12
61
49
-61
240
15

9.5 逻辑运算符

Python 语言支持逻辑运算符：

运算符	含义	逻辑表达式	描述
and	布尔“与”	x and y	同真为真，一假则假
or	布尔“或”	x or y	同假才假，一真即真
not	布尔“非”	x not y	非真即假，非假即真

在 Python 中，整数0代表假，整数 1 代表真。除此之外，Python 也把任意的空数据结构视为假，把任何非空数据结构视为真。真和假的概念是 Python 中每个对象的固有属性，一般来说：① 数字如果非零，则为真；② 其他对象如果非空，则为真。Python 还有一个特殊对象：None，它总被认为是假。

比如：

a = 10
b = 20

if a and b:
    print("1 - 变量 a 和 b 都为 true")
else:
    print("1 - 变量 a 和 b 有一个不为 true")

if a or b:
    print("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
    print("2 - 变量 a 和 b 都不为 true")

# 修改变量 a 的值
a = 0
if a and b:
    print("3 - 变量 a 和 b 都为 true")
else:
    print("3 - 变量 a 和 b 有一个不为 true")

if a or b:
    print("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
    print("4 - 变量 a 和 b 都不为 true")

if not (a and b):
    print("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
    print("5 - 变量 a 和 b 都为 true")

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

1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 false

9.6 成员运算符

Python 支持成员运算符：

运算符	描述
in	如果在指定的序列中找到值返回 True，否则返回 False
not in	如果在指定的序列中没有找到值返回 True，否则返回 False

比如：

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

if a in list:
    print("a在列表中")
else:
    print("a不在列表中")

if b not in list:
    print("b不在列表中")
else:
    print("b在列表中")

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

a不在列表中
b在列表中

9.7 身份运算符

（1）身份运算符是 Python 用来判断的两个对象的存储单元是否相同的一种运算符号，身份运算符只有 is 和 is not 两个运算符，返回的结果都是 True 或者 False：

运算符	描述	实例
is	判断两个标识符是不是引用自一个对象	x is y， 如果引用的是同一个对象则返回 True，否则返回 False
is not	是判断两个标识符是不是引用自不同对象	x is not y，如果引用的不是同一个对象则返回结果 True，否则返回 False

比如：

a = 1
b = 2
c = a
print(a is b)
print(a is c)
print(a is not b)
print(a is not c)

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

False
True
True
False

再比如：

a = [0, 1, 2]
b = [1-1, 2-1, 3-1]
c = a
print(a)
print(b)
print(a is b)
print(a is c)

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

[0, 1, 2]
[0, 1, 2]
False
True

通过这个结果我们发现，a 和 b 引用的对象是不一致的，所以 a is b 输出的结果是 False，因为变量 b 是需要计算的，虽然计算之后得到的列表跟 a 一模一样，但是计算之前的过程每个元素是要存储的，变量 a 当中的元素都是数字，计算机是直接存储结果的，而变量 b 当中的每个元素都是表达式，表达式的储存跟单个元素的储存是不一致的，列表、元组都是如此。

（2）is 与 == 的区别

is 用于判断两个变量引用对象是否为同一个，== 用于判断引用变量的值是否相等。比如：

a = [0, 1, 2]
b = [1-1, 2-1, 3-1]
c = a
print(a is b)
print(a is c)
print(b is c)
print(a is b is c)
print(a == b == c)

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

False
True
False
False
True

9.8 运算符优先级

以下表格列出了从最高到最低优先级的所有运算符， 相同单元格内的运算符具有相同优先级：

优先级	运算符	描述	结合性
19	()	小括号	无
18	x[i]	索引运算符	左
17	x.attribute	属性访问	左
16	**	乘方（指数）	右
15	~	按位取反	右
14	+, -	正号，负号	右
13	*, /, %, //	乘，除，取模，取整除	左
12	+, -	加号，减号	左
11	>>, <<	右移动运算符，左移动运算符	左
10	&	按位与运算符	右
9	^	按位异或运算符	左
8	|	按位或运算符	左
7	==, !=, <=, <, >, >=	等于，不等于，小于等于，小于，大于等于，大于	左
6	is, is not	身份运算符	左
5	in, not in	成员运算符	左
4	not	逻辑运算符非	右
3	and	逻辑运算符与	左
2	or	逻辑运算符或	左
1	exp1, exp2	逗号运算符	左

所谓结合性，就是当一个表达式中出现多个优先级相同的运算符时，先执行哪个运算符：先执行左边的叫左结合性，先执行右边的叫右结合性。例如对于表达式对于 100 / 25 * 16，/ 和 * 的优先级相同，应该先执行哪一个呢？这个时候就不能只依赖运算符优先级决定了，还要参考运算符的结合性。/ 和 * 都具有左结合性，因此先执行左边的除法，再执行右边的乘法，最终结果是 64。

Python 中大部分运算符都具有左结合性，也就是从左到右执行；只有 ** 乘方运算符、单目运算符（例如 not 逻辑非运算符）、赋值运算符和三目运算符例外，它们具有右结合性，也就是从右向左执行。

10. 行与缩进

Python 最具特色的就是使用缩进来表示代码块。缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数，一般用 Tab 健进行操作。比如：

if True:
    print("Answer")
    print("True")
else:
    print("Answer")
    print("False")  

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

Answer
True

以下代码最后一行语句和同一代码块语句缩进数的空格数不一致，会导致运行错误：

if True:
    print("Answer")
    print("True")
else:
    print("Answer")
  print("False")    # 缩进不一致，会导致运行错误

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

  File ".py", line 6
    print ("False")
                   ^
IndentationError: unindent does not match any outer indentation level

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 语句中，可以把 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. 模块的导入和下载

（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)

（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("很遗憾，你输了。")

（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 包名”，即可进行模块的安装。

在 PyCharm 代码编辑区下载模块（包）

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:end: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:end: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                                                 # 通过加法赋值运算符实现 办公室编号的递增，至此完成一次遍历，直至 3 次遍历全部完成

标签：输出,最细,python,全网,list1,列表,字符串,str,print
From： https://blog.csdn.net/langjiaohjiopji/article/details/143676786