Python

一、前言

这是哪托针对老师的课件整理的复习笔记，基础入门，希望能对广大基础小白受用。内容如有错误的地方，劳请留言指正。

笔记所有代码使用Microsoft VS Code的 Python、Jupyter 插件编译。

二、语言基础

2.1标识符

1.2.1标识符

标识符可以包括英文、数字以及下划线，并且：

开头必须是字母或下划线；

不能以数字开头开头；

区分大小写的；

不能出现分隔符、标点符号或者运算符；

不能使用关键字：def if for while class等

最好不要使用内置模块名、类型名、函数名、已经导入的模块 及其成员名

合法的标识符：A、ABC、aBc、a1b2、ab_123、__（连续两个下画线）、_123 等
非法的标识符：6a2b、abc-123、hello world（中间用了空格）、for（关键字）等

1.2.2关键字

关键字None

None是一个特殊的Python对象，不是False，不是0，也不是空字符串、空列表等。
None有自己的数据类型NoneType，None和任何其他数据类型进行是否相等比较永远返回False。
可以将None赋值给任何变量，但是不能创建其他NoneType对象。

2.1.3变量

变量： 与 C与Java语言相比

相同点：

用于储存计算结果或能表示值
可以通过变量名访问，变量值通常是可变的。
变量具有名字，不同变量是通过名字相互区分的。
不同点：

变量的数据类型：不需要声明
变量的数据类型：可以变化（Python是动态类型语言）。
变量使用之前：必须赋值。
常量：Python没有常量，即没有语法规则限制改变一个常量的值。

怎么办呢？
使用人为约定。通常用全大写字母表示常量，编程时不要修改它的值。

常量示例

TAX_RATE = 0.17
PI = 3.14
CUMTXHC = “你喜欢我吗”
1
2
3
4
‘
运行运行

2.2数据类型

1.整型int

整数：没有小数部分的数值，分为正整数、0和负整数。

100、0、 -100

100 #十进制
ob101 #二进制
0o11 #八进制
0x2F #十六进制
1
2
3
4

2.浮点数float

浮点数：包含小数点的数。

15.0、0.37、-11.2、2.3e2、3.14e-2

15.0
2.3e2 #科学计数法
3.14e-2
1
2
3
‘
运行运行

3.复数complex

复数由两部分组成：实部和虚部。复数的形式为：实部+虚部j。

2+3j、0.5-0.9j都是复数。

2+3j
z=0.5-0.9j
z.real #复数的实部
z.imag #复数的虚部
1
2
3
4
‘
运行运行
两个注意点：

Python支持任意大的数字，仅受内存大小的限制（所以在使用时，不用考虑int、float的范围）
为了提高可读性，在数值中可以使用下画线

4.布尔bool

布尔类型是用来表示逻辑“是”、“非”的一种类型，它只有两个值，True和False （首字母T和F是大写的）

Python将布尔值True实现为1（int类型），False实现为0，所以可以参与整型运算，但不建议这么做

5.字符串str

Python语言中的字符串是一种序列。字符串用单引号、双引号、三引号作为定界符。

“Python”、’ Hello,World ‘、“123”、’’’abcd8 ^ ‘’’等。

6.列表 list

列表也是一种序列类型。列表用方括号“［”和“］”将列表中的元素括起来。元素之间以逗号进行分隔。

［1,2,3,True］、［“one”,“two”,“three”,“four”］和［3,4.5, “abc”］

7.元组 tuple

元组也是一种序列。元组用“(”和“)”作为边界将元素括起来。元素之间以逗号分隔。

(1,2,3,True)、(“one”,“two”,“three”,“four”)和(3,4.5, “abc”)。

8.字典 dict

字典是唯一内建的映射类型，可用来实现通过数据查找关联数据的功能。字典是键值对的无序集合。字典中的每一个元素都包含两部分：键和值。字典用大括号“{”和“}”来表示，每个元素的键和值用冒号分隔，元素之间用逗号分隔。

{‘1801’:‘张三’, ‘1802’:‘徐虎’, ‘1803’:‘张林’}

9.集合 set

集合是由各种不可变类型的元素组成，但元素之间无序，并且元素都不重复。

{‘car’, ‘ship’, ‘train’, ‘bus’}。

2.3赋值语句、运算符

2.3.1赋值语句的格式

<变量>=<表达式>

#常规：同java
#特殊：多变量赋值
x,y=1,2
a = b = 3
#两变量的交换
x,y=1,2
x,y=y,x
1
2
3
4
5
6
7
‘
运行运行

2.3.2运算符

1.算数运算符

在Python中，算术运算符有：+（加）、-（减）、*（乘）、/（真除法）、//（求整商）、%（取模）、**（幂）。

需要说明的几点：

（1） + 运算符不支持不同类型的对象之间的连接

3+”ab” #错误：不同类型
str(3)+”ab” #正确：通过类型转换函数str()将数字3转换成字符串’3’
1
2
（2） * 运算符可以用于列表、元组或字符串与整数的相乘，用于将这些序列重复整数所指定的次数。它不适用于字典和集合与整数的相乘。

[1,3,5] * 2 # 列表list
#[1, 3, 5, 1, 3, 5]
(‘a’,’b’,’c’) * 2 # 元组tuple
#(‘a’, ‘b’, ‘c’, ‘a’, ‘b’, ‘c’)
‘Hello’ * 2 # 字符串str
#’HelloHello’
{1801:’Lily’} * 2 # 字典dict：不可以。因为字典的键key不能重复。
1
2
3
4
5
6
7
（3）** 运算符：幂运算，与内置函数pow()相同

（4）/ 真除法 与 //整数除法

5/3 # 真除 1.6666666666666667
5//3 # 取商的整数部分 1
7.4//3 # 操作数为实数时，则取实数形式的整数（即*.0） 2.0
1
2
3
‘
运行运行

2.关系运算符

六个：<（小于）、<=（小于等于）、>（大于）、>=（大于等于）、==（等于）、!=（不等于）。

结果：布尔值True或False

所有的字符串都是Unicode字符串；

单个字符：可以通过ord()函数获取该字符的Unicode码，
通过chr()函数把编码转换为对应的字符。
ord(‘a’) #97
chr(97) #得到对应的字符 a
ord(‘我’) #25105
chr(25105) #我
1
2
3
4
‘
运行运行
注意：字符串和数字属于不可比较大小的

列表比较大小：也是从左到右逐个元素的依次比较，类似 字符串之间的比较

列表中：字符串与数值也是不能比较的

[1,2,3]>[‘a’,’b’] # 出错
[‘ab’,’c’,6]>[‘ab’,3,’a’] # 出错
1
2
（5）关系运算符可以连用，等价于某几个用and连接起来的表达式。注意：C语言和Java语言均不可这么用。

3<5>2 #与 下式 含义相同 True
3<5 and 5>3 #True
3<5==5 #与 下式 含义相同 True
3<5 and 5==5 #True
1
2
3
4
‘
运行运行
（6）因为精度问题可能导致实数运算有一定的误差

要尽可能地避免在实数之间进行相等性判断
0.4-0.3 # 有误差了
#0.10000000000000003
0.1==0.4-0.3 # 误差 导致 不相等
#Flase
#解决方法：使用实数之间的差值的绝对值是否小于某一个很小的数来作为实数之间是否相等的判断。
abs(0.1-(0.4-0.3))<0.00000000001 # True，表示 0.1 和 0.4-0.3是相等的
#True
1
2
3
4
5
6
7
‘
运行运行

3.测试运算符

四个：in、not in、is、is not。
结果：返回布尔值True或False

2 in [2,3,4] # 列表 True
a = 3
a in [2,3,4] #True

b=”abcedfg” # 测试 字符串str
“ab” in b #True

a = (1,2,3)
b = (1,2,3)
a is b # False: 虽然a、b内容一样，但不是同一个对象。
a is not b # True
1
2
3
4
5
6
7
8
9
10
11
‘
运行运行
（7）同一性测试运算符is和is not测试是否为同一个对象或内存地址是否相同，返回布尔值True和False。

x=[1,3,5]
y=[1,3,5]
x is y #测试x、y是否为同一个对象：x，y相等，但不是同一个对象 Flase
x is not y #True
x==y #测试x、y是否相等 True
1
2
3
4
5
‘
运行运行
注意：

是否相等==：只是测试值是否相同，
是否为同一个对象is：指的是是否指向同一个对象（如果指向同一个对象，则内存地址应该相同，当然也相等）
内置函数id()返回对象的标识（内存地址）

id(x) # 每个人运行得到的内存地址可能会不一样 3055563066432
z=x # 赋值语句z=x，则z和x不仅值相等而且指向同一个对象，z、x的内存地址相同。
z is x #True
1
2
3

4.逻辑运算符

在Python中，逻辑运算符有：and（与）、or（或）、not（非）。通过逻辑运算符可以将任意表达式连接在一起。

哪些是False：False、None、数值类型中的0、空字符串’’、空元组()、空列表[]、空字典{}、空集合{}等

not False #True
not True #Flase
not 3 # 非零值为True Flase
not 0 # 零值为false True
1
2
3
4
‘
运行运行
（10）逻辑操作符and和or也称作短路操作符，具有惰性求值的特点：

短路运算：表达式从左向右解析，一旦结果可以确定就停止。
注意：逻辑运算符and、or不一定会返回布尔值True和False。
and(与运算)：结果不一定为True或False

当计算表达式exp1 and exp2时，
①先计算exp1的值，当exp1的值为True或非空值（非0、非None、值非空的其他数据类型），才计算并输出exp2的值；
②当exp1的值为False或空值（0、None、值为空的其他数据类型），直接输出exp1的值，不再计算exp2。

True and 3 # 第一个为True，则输出第二个的值（结果与第二个值有关）：下同 3
4 and False #Flase
3<4 and 4>5 # 3<4的值为True，则计算并输出4>5的值False
False and 4 # 第一个为False，则不再计算第二个的值，直接输出第一个的值：下同
0 and ‘c’ # 直接输出0
() and ‘c’ # 直接输出()
1
2
3
4
5
6
‘
运行运行
or或运算：结果不一定为True或False

当计算表达式exp1 or exp2时：
①先计算exp1的值，当exp1的值为True或非空值（非0、非None、值非空的其他数据类型），直接输出exp1的值，不再计算exp2；
②当exp1的值为False或空值（0、None、值为空的其他数据类型），才计算并输出exp2的值。

True or 3 #第一个为True，则不再计算第二个的值，直接输出第一个的值：下同
3<4 or 4>5 #3<4的值为True，则直接输出True
False or 4 #第一个为False，则继续计算第二个的值，输出第二个的值：下同
0 or ‘c’
1
2
3
4
‘
运行运行
（11）赋值运算符（=）、复合赋值运算符（+=、-=、*=、/=、//=、%=、**=）、位运算符（&、|、^等）等。
此处基本同C语言。

(12)特别注意： Python没有自加++与自减–

（13）优先级小括号（）最高

2.4从控制台输入和输出

1. input()函数

用于输入数据，无论用户输入什么内容，该函数都返回字符串类型。

其格式如下：

input(prompt=None) # prompt=None，表示提示语默认为空

x = input(“请输入x值：”) # 请输入x值：100
type(x) # 查看x的类型，为<class ‘str’> #str
1
2
‘
运行运行

2.类型转换函数

1）int()函数
格式1：int([x])
功能：截取数字的整数部分或将字符串转换成一个整数；如果不给定参数则返回0。

int() #1、没有参数时：0
int(23.74) #2、浮点数：直接截取整数部分（不进行四舍五入）
int(-3.52)
int(‘4’) #3、整数字符串
int(‘45.6’) #4、浮点数字符串：错误 。
1
2
3
4
5
注意：int()函数不接受带小数的数字字符串

格式2 ：int(x, base=10)
功能：把base进制的字符串x转换为十进制，base为基数(进制)，默认为十进制
base的有效值范围为0和2-36

int(‘1001001’,2) #1、二进制的数1001001转换为十进制数 73
int(‘2ef’,16) #2、十六进制的数2ef转换为十进制数 751
int(‘27’,8) #3、八进制的数27转换为十进制数 23
int(‘101.001’,2) #4、不允许二进制的小数（不接受带小数的数字）
int(‘0b110’, base=0) #5、二进制的数110转换为十进制数 6

1
2
3
4
5
6
2)float()函数
格式：float(x=0, /)
功能：将一个数字或字符串转换成浮点数

float() # 默认参数x为0
float(‘inf’) #无穷大，inf不区分大小写
int(“3+5”) # 错误
float(“3.5*2”) # 错误
#int()、float()不能转换表达式字符串，所以引入eval()函数
1
2
3
4
5

3. eval()函数
   格式 ：eval(source, globals=None, locals=None, /)
   功能：将 source 字符串 当做一个python 表达式 进行解析和计算，返回计算结果。
   参数说明：
   source是一个字符串，这个字符串能表示成Python表达式，或者是能够通过编译的代码；
   globals是可选的参数，默认为None，如果设置属性不为None的话，就必须是dictionary对象；
   locals也是可选的参数，默认为None，如果设置属性不为None的话，可以是任何map对象。

字符串中是表达式：返回表达式的值；
字符串中是列表、元组或字典：得到真正的列表、元组或字典；
字符串中是能够通过编译的代码：执行代码。
x=3
eval(‘x+1’) # 表达式：x+1
eval(‘3+5’) #8
eval(‘[1,2,3]’) # 返回列表[1,2,3]
eval(‘{1:23,2:32}’) # 返回字典{1:23,2:32}
eval(‘print(32)’) # 执行print(32)语句 9
eval(“import(‘os’).getcwd()”) # 执行语句：获取当前目录
#####组合使用： int()、float()、eval()函数和input（）
x=eval(input(“请输入x值：”)) #输入列表格式：[1,2,3]
x #获得列表
x=eval(input(“请输入x值：”)) #输入字典格式：{‘a’:1,’b’:2}
x #获得字典
1
2
3
4
5
6
7
8
9
10
11
12

3.数据的输出

print()函数
格式如下:

print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

各参数的解释如下:

value：需要输出的对象，一次可以输出一个或者多个对象(其中…表示任意多个对象)，对象之间要用逗号(,)分隔
sep：对象之间的间隔符，默认用一个空格分隔；
end：以何字符结尾，默认值是换行符；
file：表示输出位置，可将输出到文件，file指定的对象要有“写”的方法，默认值是sys.stdout(标准输出，即控制台屏幕)；
flush：将缓存里面的内容是否强制刷新输出，默认值是False（一般不需要）。

print(‘1.hello’,’world’,’!’) #一次输出三个对象，中间默认用空格隔开
print(‘2.hello’,’world’,’!’,sep=’‘) #一次输出三个对象，中间用隔开
print(‘3.hello’,’world’,’!’,sep=’’) #一次输出三个对象，中间无分隔，因为sep参数值被设置为空字符串了
print(‘4.hello’,’world’,’!’,end=’!’) #一次输出三个对象，以!结尾（不换行）
print(‘5.hello’,’world’,’!’,sep=’,’, end=’!’) #一次输出三个对象，以，分隔，以！结尾
1
2
3
4
5
‘
运行运行
可以看出：print函数默认输出是换行的。如果要实现不换行，需要在变量末尾设置 end参数

2.5内置函数

函数 功能
abs(x) 返回数字x的绝对值，如果给出复数，返回值就是该复数的模
bin(x) 把整数x转换为二进制
divmod(x,y) 函数返回整商和余数的元组
eval(s[,globals[,locals]]) 计算字符串中表达式的值并返回
help(obj) 返回对象obj的帮助信息
id(obj) 返回对象obj的标识（内存地址）
input(prompt=None, /) 接受键盘输入，显示提示信息，返回字符串
len(obj) 返回对象obj（列表、元组、字典、字符串、集合、range对象）的元素个数
map(func, *iterables) 包含若干函数值的map对象，其中func表示函数，iterables表示迭代对象，将函数作用于迭代对象
max(x[,y,z…])、min(x[,y,z…]) 返回给定参数的最大值、最小值，参数可以为可迭代对象
pow(x,y[,z]) pow()函数返回以x为底，y为指数的幂。如果给出z值，该函数就计算x的y次幂值被z取模的值
print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False) 输出对象，默认输出到屏幕，相邻数据之间使用空格分隔，结尾以换行符结束
range([start,]end[,step]) 返回range对象，该对象包含按参数（[start,end)范围内，step为步长）生成的整数
round(x[,n]) 返回浮点数x的四舍五入值，若不给出n值，则返回整数；给出n值，则代表舍入到小数点后的位数
sorted(iterable, /, *, key=None, reverse=False) 返回排序后的列表，其中iterable表示要排序的序列或迭代对象，key表示排序规则，reverse表示升序或降序，默认升序
sum(iterable, start=0, /) 返回序列iterable中所有元素之和，如果指定起始值start，则返回start+sum(iterable);如果iterable为空，则返回start
chr(i) 返回Unicode编码为i所对应的字符，0 <= i <= 0x10ffff
complex(real[,imag]) 把字符串或数字转换为复数，如果第1个参数是字符串，不能使用第2个参数
float(x=0, /) 把一个数字或字符串转换成浮点数
hex(x) 把整数转换成十六进制串
int(x[,base]) 把数字和字符串转换成一个整数，或把base进制的字符串x转换为十进制，base为可选的基数，默认为十进制
list([x])、tuple([x])、dict([x])、set([x]) 将对象x转换成列表、元组、字典、集合，或生成空列表、空元组、空字典、空集合
oct(x) 把给出的整数x转换成八进制串
ord(x) 返回一个字符的Unicode编码

三、流程控制

3.1分支结构

单分支if语句

双分支if/else语句

多分支if/elif/else语句

选择结构的‘嵌套’

选择结构的三元运算

【注意】：Python没有switch语句

语法类似于java此处省略

3.2循环结构

定义：

给定的判断条件为真（包括非零、非空）时，重复执行某些操作；
判断条件为假（包括零、空）时，结束循环。
循环分类：

while语句
for语句
循环中断:

break
continue
带else的循环语句（Python特有）

与java类似相关内容请参考java

3.2.1for循环语句

for语句通过遍历一个序列（字符串、列表、元组）或迭代器等可迭代对象中的每个元素来建立循环。
for语句的语法形式如下所示：

for 变量 in 序列或迭代器等可迭代对象:
循环体
1
2
补充
range（）函数：返回可迭代对象。

语法格式如下：
range(start, stop[, step])

功能：
产生一个从start开始（包括start,默认为0），到stop结束（不包括stop），两个整数对象之间间隔step（默认为1）的可迭代对象。

可以用for循环直接遍历range函数产生的可迭代对象

for i in range(0,10): # 默认step：1
print(i,end=’ ‘)
for i in range(3,15):
print(i,end=’ ‘)
1
2
3
4
‘
运行运行
range对象可以被转换成列表或元组，例如：

y=list(x) # range对象转换为list列表对象
z=tuple(x) # range对象转换为tuple元组对象
1
2

3.2.2 break语句和continue语句

详细解释：

break语句：可以用在while和for循环中。在循环进行过程中，如果某个条件被满足（一般通过if语句判断是否满足执行break语句的条件），则可以通过break语句立即终止本层循环。如果break语句在具有两层循环嵌套的内层循环中，则只终止内层循环，进入到外层循环的下一条语句继续执行。
continue语句：可以用在while和for循环中。在循环体执行过程中，如果遇到continue语句，程序会跳过本次循环的循环体剩余语句，回到循环开始的地方重新判断是否进入下一次循环。
精简：

break语句终止整个当前循环；
continue语句的执行不会终止整个当前循环，只是提前结束本次循环，跳过循环体中本次循环的剩余语句，提前进入到下一次循环。
再精简：

同C语言。

3.2.3 带else的循环语句（与C语言不同，不建议用）

Python中的while和for语句后面还可以带有else语句块。

语句语法如下：

while 条件表达式:
循环体
else：
else语句块
1
2
3
4
三种执行流程：

1）正常循环：当条件表达式为真（True、非空、非零）时，反复执行循环体。

2）执行一次else：当条件表达式为假（False、零、空）而导致循环终止（或无法进入循环），else语句块执行一次，然后结束该循环结构。

3）不执行else：如果该循环是因为执行了循环体中的break语句而导致循环终止，else语句块不会执行，直接结束该循环结构。

例：从键盘输入一个正整数n，用while循环找出小于等于该整数n且能被23整除的最大正整数。如果找到了，输出该整数；如果没有找到，则输出“未找到”

n=int(input(‘请输入一个正整数：’))
i=n
while i>0:
if i % 23 == 0:
print(“小于等于”,n,”且能被23整除的最大正整数是：”,i)
break
i = i-1
else:
print(“未找到。”)
1
2
3
4
5
6
7
8
9
‘
运行运行
带else的for语句语法如下：

for 变量 in 序列或迭代器等可迭代对象:
循环体
else:
else语句块
1
2
3
4

3.2.4循环嵌套

四、常用数据结构

4.1 序列

4.1.1列表 list

列表是Python中最基本的数据结构，是最常用的数据类型。

列表的特点：

1.列表将由若干数据作为元素的序列放置在一对方括号中，元素之间以逗号分隔。

2.列表中的元素允许重复。

3.列表是可以修改的：增删改查。(以上类似数组)

4.列表元素可以由任意类型的数据构成。同一列表中各元素的类型可以各不相同。（不同于数组）

列表的操作汇总：

创建列表： [,]、list()

访问元素: list1[n]

更改元素值

切片: [::]形式

列表计算： 列表+列表，列表 * 整数

列表

方法
1
-查：.index()、.count()、
-增：.extend()、.insert()、.append()、
-删：.pop()、.remove()、.clear()
-序：.sort()、.reverse()）

序列函数（不仅仅用于列表）：len()、max()、min()、sorted()、reversed()

命令：del 列表

1.列表的创建

创建 一维列表

list1 = [3.14, 1.61, 0, -9, 6,3.14] # 1.[,…,]方式: 普通列表
list2 = [‘train’, ‘bus’, ‘car’, ‘ship’]
list3 = [‘a’,200,’b’,150, ‘c’,100.5]
list4 = [] # 2.[]方式：创建空列表
list5=list() # 3.list()函数

创建 二维列表

list_sample=[[‘IBM’,’Apple’,’Lenovo’],[‘America’,’America’,’China’]]
1
2
3
4
5
6
7
8
‘
运行运行

2.列表的元素访问

索引：列表中的每个元素被关联一个序号，即元素的位置。
索引值是从0开始，第二个则是 1，以此类推，从左向右逐渐变大；
列表也可以从后往前，索引值从-1开始，从右向左逐渐变小。
适用于所有序列类型的对象：列表、元组、字符串

3.修改元素

通过重新赋值来更改某个元素的值
注意合法索引范围，超过范围则会出错。

4.列表切片

在列表中，可以使用切片操作来选取指定位置上的元素组成新的列表。

简单的切片方式为（步长默认为1）：原列表名[start : end]

[start：end)：左封闭(能取到)，右开放(取不到)
左索引start为0时可缺省，右索引end为列表长度时可缺省。
vehicle = [‘train’, ‘bus’, ‘car’, ‘ship’]
vehicle[0:3]
vehicle[0:1] # 取第0号元素
vehicle[:3] # start缺省：为 0
vehicle[3:] # end缺省：为列表长度4（长度从1开始计算）
vehicle[:] # start、end都缺省：全列表
vehicle[3:3] # start等于end时：空列表
1
2
3
4
5
6
7
‘
运行运行
也可以使用负数作索引

vehicle = [‘train’,’bus’,’car’,’ship’]
vehicle[-3:-1] # 索引为-3和-2位置上的元素:依然是从左往右取 [‘bus’, ‘car’]
vehicle[-2:] # 索引从-2至列表末尾位置上的元素 [‘car’, ‘ship’]
1
2
3
‘
运行运行
切片步长：非零整数（即可正可负，但不能为0）（跳着切片）

原列表名[start : end : step]

步长为1时：参数可以省略。
步长不为1时：该参数不可省略。
n=list(range(10)) # range()函数为0-9的可迭代对象，用list()函数转换为从0到9的列表n
n[0:10:2] # 步长为2，索引值从0开始，每次增长2，但索引值必须小于10。 [0, 2, 4, 6, 8]
n[::3] # [0,3,6,9]
n[7:2:-1] # 步长为负数时，start不能小于end值。 [7, 6, 5, 4, 3]
n[11::-2] # 11超过范围，实际索引从最后一个元素开始。不出错。 [9, 7, 5, 3, 1]
n[::-2] # 这里步长为负数，表示在整个列表内，从后往前取值。 [9, 7, 5, 3, 1]
n[::-1] # 作用：逆序 [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
1
2
3
4
5
6
7
‘
运行运行
利用切片还可以更改元素值。有点类似多变量赋值的感觉。

n[2:4]=[110,1] # 分别更改索引号为2和3的位置上元素值。
n[-5::2]=[-1,-2,-3] # 分别更改索引号为-5、-3、-1三个位置上的元素值。
n[2:5]=[10,11] # 少给1个数呢？少的那个数，被删掉了
1
2
3

5. del命令

注意是命令，不是函数或方法。

从列表中删除元素，也可以删除整个列表

vehicle = [‘train’, ‘bus’, ‘car’, ‘ship’]
del vehicle[3]
vehicle # 删除了’ship’
del vehicle # 删除列表vehicle
vehicle # 列表vehicle不存在了：再次使用出错
1
2
3
4
5
补充：方法、函数、命令的概念上的区别

命令：内置命令，没有括号
函数：是指内置函数（或用import导入的某模块的函数），直接可以使用，比如pow(2,3)
方法：是指某个对象的方法，格式为对象名.方法名()，比如list.sort()，是指列表list对象的sort()方法
6.列表运算
1)列表相加

通过列表相加的方法生成新列表
支持 复合赋值 +=
vehicle1 = [‘train’, ‘bus’, ‘car’, ‘ship’]
vehicle2 = [‘subway’, ‘bicycle’]
vehicle2 + vehicle1 # 结果为新列表，原列表不变
vehicle+=[‘bike’] # 复合赋值语句
vehicle1-vehicle2 # 不支持 减 运算：出错
1
2
3
4
5
2)列表乘法

列表 * 整数n：生成一个新列表。
新列表：原来列表的元素重复n次。
vehicle1 = [‘train’, ‘bus’]
vehicle1 * 3 #[‘train’, ‘bus’, ‘train’, ‘bus’, ‘train’, ‘bus’]
vehicle = vehicle1 * 2 # 相乘语句
vehicle *= 2 # 复合赋值语句，相当于重新定义了vehicle列表
1
2
3
4
‘
运行运行

7.列表方法：类型本身的方法

1. index(value[,start=0[,stop]])
   返回第一个value值元素索引位置。
   start没指定：则从索引为0的位置开始查找，否则从索引为strat的位置开始查找。
   stop没指定：可以查找到列表最后元素，否则在位于[start, stop)内的索引区间查找。
   如果找不到匹配项，就会引发异常。
   vehicle = [‘train’, ‘bus’, ‘car’, ‘subway’, ‘ship’, ‘bicycle’, ‘car’]
   vehicle.index(‘car’) # 整个列表范围内’car’第1次出现的索引位置是2
   vehicle.index(‘car’, 3) # 在从索引为3开始，’car’第1次出现的索引位置是
   1
   2
   3
   ‘
   运行运行

2. count()
   统计某个元素在列表中出现的次数。

3. append()
   追加单个元素到列表的尾部，只接受一个元素
   元素可以是任何数据类型，被追加的元素在列表中保持着原结构类型。

4. extend()
   在列表的末尾一次性追加另一个列表中的多个值（只能有一个参数）
   应用：用新列表扩展原有的列表
   insert()
   将一个元素插入到指定位置。
   两个参数：第一个参数是索引点，即插入的位置，第二个参数是插入的元素。
   vehicle = [‘train’, ‘bus’, ‘car’, ‘ship’]
   vehicle.insert(3,’plane’) # 插入后，在3位置
   vehicle.insert(-2,’bike’) # 注意插入后的位置，在-2位置的前面
   1
   2
   3
   ‘
   运行运行

5. remove()
   用于移除列表中与某值匹配的第一个元素
   如果找不到匹配项，就会引发异常

6. pop()
   移除列表中的一个元素（默认为最后一个元素），并且返回该元素的值（出栈）
   可以指定索引位置
   当不在索引范围内或者是空列表中，均会触发异常

7. clear()
   删除列表中所有元素，但保留列表对象。
   请注意与del命令的区别：del命令删除整个列表时，列表对象不再保留

8. reverse()方法
   用于将列表中的元素位置反向存放。
   列表中可以有不同类型的元素，reverse()方法只是将位置反转

9. sort()
   元素排序：默认按升序排列。

两个参数：

reverse参数：默认为False（升序），若等于True表示降序排序（如果包含的是字符串，按字符串排序规则）。
key参数：指定排序方式。
numbers=[12,34,3.14,99,-10]
numbers.sort() # 按数值大小升序
numbers.sort(reverse=True) # 降序
numbers.sort(key=str) # 按转换为字符串后的大小升序排列，ASCII码
nv=[12,’bus’,99,’train’] # 排序的元素必须是可比较大小（字符串和数值不能比较）
nv.sort()
1
2
3
4
5
6
8.列表函数：不单单用于列表的函数，也可用于其他数据结构

9.列表遍历

通过for语句或者while语句循环遍历所有元素
vehicle=[‘train’, ‘bus’, ‘car’, ‘subway’, ‘ship’, ‘bicycle’]
for i in vehicle: #1.直接遍历每一个元素
print(i,end=’ ‘)
i=0
while i<len(vehicle): #3.while循环：通过索引遍历每一个元素
print(vehicle[i],end=’ ‘)
i+=1
1
2
3
4
5
6
7
‘
运行运行

4.1.2元组

元组和列表十分相似，元组是用一对圆括号（）括起、用逗号分隔的多个元素的组合。

属于序列：有顺序，可以重复；
元组是不可更改的，是不可变对象：元组创建之后就不能修改、添加、删除成员。
元组的上述特点使得其在处理数据时效率较高，而且可以防止出现误修改操作。

1.元组的创建

tuple1 = (‘a’,200,’b’,150, ‘c’,100) # 1.创建多个元素的元组
tuple3 = (3,) #创建单一元素的元组，后面的逗号不能省略(省略后，就变成字符串类型了
tuple4=() # 2.创建空元组
tuple5 = tuple() # 3.使用tuple函数，创建空元组
1
2
3
4
‘
运行运行

2.元组的访问

和列表一样，可以通过索引(访问单个)、切片(访问多个)来访问元组的成员

vehicle=(‘train’, ‘bus’, ‘car’, ‘ship’, ‘subway’, ‘bicycle’)
vehicle[-3] # 索引方式
vehicle[0:3:2] # 切片方式
vehicle[1]=’bike’ #元组：不能更改元素值。不能赋值。 报错
1
2
3
4
3.元组的运算
1)元组相加
通过元组相加的方法生成新元组

vehicle1 = (‘train’, ‘bus’, ‘car’, ‘ship’)
vehicle2 = (‘subway’, ‘bicycle’)
vehicle1 = vehicle1 + vehicle2 # 正确：重新定义了vehicle1
1
2
3
‘
运行运行
2)元组相乘
用数字n乘以一个元组，会生成一个新元组。
在新元组中原来的元组元素将依次被重复n次。
vehicle1 = (‘train’, ‘bus’, ‘car’, ‘ship’)
vehicle1*2
1
2
‘
运行运行
3).元组的遍历
通过for语句或者while语句(同列表方法)

4.1.3 列表与元组的转换

1.列表–>元组

tuple()函数：接受一个列表，并返回一个包含同样元素的元组。
从结果上看，tuple()函数冻结了列表
vehicle = [‘train’, ‘bus’, ‘car’, ‘ship’, ‘subway’, ‘bicycle’] #list
tuple(vehicle) #元组
t = tuple(vehicle)
1
2
3
‘
运行运行

2.元组–>列表

list()函数：接受一个元组，并返回一个包含同样元素的列表。
从结果上看， list()函数融化了元组
vehicle=(‘train’,’bus’,’car’,’ship’,’subway’,’bicycle’)
list1 = list(vehicle)
1
2
‘
运行运行

4.2 字典

字典是Python中唯一内建的映射类型
用一对花括号“{”和“}”作为边界，元素之间以逗号分隔：{123:“zhangsan”,456:“lisi”}

每个元素是一对键（key）和值（value），键和值之间用英文冒号分隔。
映射：可通过数据key查找关联数据value。
无序：字典的元素没有顺序，因此不能像序列那样通过位置索引来查找成员数据。但是每一个值都有一个对应的键。
不重复：字典的键是不重复的。
用法：通过键key来访问相应的值value（值value是可以重复的）。

4.2.1 创建字典

abbreviation ={‘WAN’:’Wide Area Network’, ‘CU’:’Control Unit’, ‘LAN’:’Local Area Network’, ‘GUI’:’Graphical User Interface’} #1.{‘’:’’,’’:’’}创建
a=dict(WAN=’Wide Area Network’,CU=’Control Unit’,LAN=’Local Area Network’) #2.dict()创建,需注意：键外面不能加引号
keys=[‘WAN’,’CU’,’LAN’] #列表list
values=(‘Wide Area Network’,’Control Unit’,’Local Area Network’) #元组
b=dict(zip(keys,values)) #3.由序列构建zip对象，由zip对象创建字典
c=dict.fromkeys([‘WAN’,’CU’,’LAN’]) #4.以给定序列(元组或者列表)为键，创建值为空的字典
d={} #5-1.创建空字典
e=dict() #5-2.无参的dict函数
1
2
3
4
5
6
7
8
‘
运行运行
键key必须是不可修改类型的数据，如数值、字符串和元组等(列表是可变的，不能作为字典的键)
键对应的值value可以是任何类型的数据。
字典是无序集合，字典的显示次序由字典在内部的存储结构决定。

4.2.2 字典操作

1.字典中“键-值”对的数量

len()：返回字典中项（键-值对）的数量

abbreviation ={‘WAN’:’Wide Area Network’, ‘CU’:’Control Unit’, ‘LAN’:’Local Area Network’, ‘GUI’:’Graphical User Interface’}
len(abbreviation)
1
2
‘
运行运行

2.查找与特定键相关联的值：键—>值

abbreviation ={‘WAN’:’Wide Area Network’, ‘CU’:’Control Unit’, 1:’Local Area Network’, ‘GUI’:’Graphical User Interface’}
abbreviation[1]
1
2
‘
运行运行

3.修改字典中的数据

在字典中，某个键相关联的值可以通过赋值语句来修改.
如果指定的键不存在，则相当于向字典中添加新的键值对

abbreviation ={‘WAN’:’Wide Area Network’, ‘CU’:’Control Unit’, ‘LAN’:’Local Area Network’, ‘GUI’:’Graphical User Interface’}
abbreviation[‘CU’]=’control unit’ #有则修改
abbreviation[‘FTP’]=’File Transfer Protocol’ #无则添加
1
2
3
‘
运行运行

4.删除字典条目

del 命令：用来删除字典条目或者整个字典

del abbreviation[‘CU’] #键存在
del abbreviation #删除整个
1
2
检查字典中是否含有某键的项
in命令：查找某键值是否在字典中。如果存在返回“True”，否则返回“False”

4.2.3 字典方法

1.keys()、values()

keys()方法将字典中的键以可迭代的dict_keys对象返回。values()方法将字典中的值以可迭代的dict_values对象形式返回

abbreviation ={‘WAN’:’Wide Area Network’, ‘CU’:’Control Unit’, ‘LAN’:’Local Area Network’, ‘GUI’:’Graphical User Interface’}
abbreviation.keys()
#dict_keys([‘WAN’, ‘CU’, ‘LAN’, ‘GUI’])
list(abbreviation.values()) #转换成 列表
tuple(abbreviation.values()) #转换成 元组
1
2
3
4
5
‘
运行运行

2.items()

将字典中的所有键和值以可迭代的dict_items对象返回，每对键值对组成元组作为一个元素

abbreviation ={‘WAN’:’Wide Area Network’, ‘CU’:’Control Unit’, ‘LAN’:’Local Area Network’, ‘GUI’:’Graphical User Interface’}
abbreviation.items()
#dict_items([(‘WAN’, ‘Wide Area Network’), (‘CU’, ‘Control Unit’), (‘LAN’, ‘Local Area Network’), (‘GUI’, ‘Graphical User Interface’)])
list(abbreviation.items()) #转换成 列表
tuple(abbreviation.items()) #转换成 元组
1
2
3
4
5
‘
运行运行

3.setdefault()

使用dict.setdefault(key, default=None)时，

如果字典中包含参数key对应的键，则返回该键对应的值；
否则以参数key的值为键，以参数default的值为该键对应的值，在字典中插入键-值对元素，并返回该元素的值部
abbreviation ={‘WAN’:’Wide Area Network’, ‘CU’:’Control Unit’, ‘LAN’:’Local Area Network’, ‘GUI’:’Graphical User Interface’}
abbreviation.setdefault(‘CU’) #1.存在这个键：返回对应的值value
abbreviation.setdefault(‘CU’,”控制单元”) #2.存在这个键，默认值和原有的值不一样：返回对应的原值value
abbreviation[‘CU’]=’control unit’ #有则修改
abbreviation.setdefault(‘FTP’,’File Transfer Protocol’) #3.不存在这个键：插入新的键值对
abbreviation[‘FTP’]=’File Transfer Protocol’ #和之前比较：无则添加
abbreviation.setdefault(‘cu’) #4.不存在这个键，也未指定新值 ‘cu’: None
1
2
3
4
5
6
7
‘
运行运行

4.update()

将另一个字典中的所有键值对一次性地添加到当前字典中
如果两个字典中存在有相同的键，则以另一个字典中的值更新当前字典

5.clear()

clear()方法将字典中的所有条目删除，变成空字典

6.pop()

pop()方法能够弹出并删除字典中的键值对

abbreviation.pop(‘CU’) #返回键为’CU’的值，并在字典中删除该键值对
1

7.popitem()

popitem()方法能够弹出字典的一个元素，如果字典为空则触发异常

8.get()

返回指定键所对应的值，如果键不存在则返回默认值。默认值为None，也可以自己指定。

4.2.4遍历字典

1.遍历字典的key

for i in abbreviation: #默认遍历字典的键
print(i)
print(i,abbreviation[i])
for i in abbreviation.keys(): #和上面相同
print(i,abbreviation[i])
1
2
3
4
5

2.遍历字典的值Value

for i in abbreviation.values():
print(i)
1
2

3.遍历字典的键值对

for i in abbreviation.items(): #keys() values() items()
print(i)
1
2

4.2.5列表、元组、字典的转换

1.列表与字典之间的转化：字典–>列表

Python中的list()函数可以将字典转换列表，但列表不能转换为字典

list(abbreviation) #默认将键转化为列表
list(abbreviation.keys()) #键
list(abbreviation.values()) #值
list(abbreviation.items()) #键值对
1
2
3
4

2.元组与字典之间的转化：字典–>元组

Python中的tuple()函数可以将字典转换元组，但元组不能转换为字典

tuple(abbreviation) #默认将键转化为元组
tuple(abbreviation.keys()) #键
tuple(abbreviation.values()) #值
tuple(abbreviation.items()) #键值对
1
2
3
4

4.3 集合 Set

集合是一组用{ }括起来的无序,不重复元素，元素之间用逗号分隔。
元素可以是各种类型的不可变对象。

集合，想象成 只有key 没有value值的字典dict

4.3.1 集合的创建

集合类型的值有两种创建方式：

用一对花括号将多个元素括起来，元素之间用逗号分隔：{1,3,‘a’}
函数set()：将字符串、列表、元组等类型的数据转换为集合类型。
vehicle={‘train’,’bus’,’car’,’ship’} # 1、直接赋值
vehicle=set([‘train’,’bus’,’car’,’ship’]) # 2、Set()函数，list（） tuple（） dict()
#注意：空集合只能用set()来创建，而不能用空的花括号{}表示，因为Python已将空{}用于表示空字典
a=set() # 无参的set函数，空集合
1
2
3
4
‘
运行运行
集合中没有相同的元素，因此创建集合时会自动删除掉重复的元素（利用这一点，可以快速去重）。

4.3.2 集合的运算

1.len() 、max()、min()、sum()

返回集合中元素的个数

nums = {4,3,8,9,0,-5,7}
max(nums)
sum(nums)
sorted(nums) # 生成排序后的列表：集合本身无序
reversed(nums) # 不能反序：集合本身无序
1
2
3
4
5

2.in

判断某元素是否存在于集合之中，判断结果用布尔值True或False表示

3.并集、交集

并集：创建一个新的集合，该集合包含两个集合中的所有元素。
交集：创建一个新的集合，该集合为两个集合中的公共部分

vehicle1={‘train’,’bus’,’car’,’ship’}
vehicle2={‘subway’,’bicycle’,’bus’}
vehicle1|vehicle2 #并集
vehicle1&vehicle2 #交集
1
2
3
4
‘
运行运行

4.差集

A-B表示集合A与B的差集，返回由出现在集合A中但不出现在集合B中的元素所构成的集合。

vehicle1-vehicle2
1

5.对称差

返回由两个集合中那些不重叠的元素所构成的集合

vehicle1^vehicle2
1

6.子集和超集

子集：如果集合A的每个元素都是集合B中的元素，则集合A是集合B的子集。
超集：超集是仅当集合A是集合B的一个子集，集合B才是集合A的一个超集。
A<=B，检测A是否是B的子集；
A<B，检测A是否是B的真子集；
A>=B，检测A是否是B的超集；
A>B，检测A是否是B的真超集；
以上结果只返回True或False
A |= B将B的元素并入A中。

4.3.3 集合的方法

同样以面向对象方式实现集合类型的运算

1.union()、intersection()

union()方法相当于并集运算。
intersection()方法相当于交集运算
vehicle1={‘train’,’bus’,’car’,’ship’}
vehicle2={‘subway’,’bicycle’,’bus’}
vehicle1.union(vehicle2) #并集，新的集合
vehicle1 # vehicle1未发生改变
vehicle2 # vehicle2未发生改变
vehicle1.intersection(vehicle2) #交集，产生新集合
1
2
3
4
5
6
‘
运行运行

2.update()

update()方法相当于集合元素合并运算，注意与union()方法的区别

vehicle1.update(vehicle2)
vehicle1 # vehicle1发生了改变
1
2

3.difference()

相当于差集运算

vehicle1.difference(vehicle2) #新集合
vehicle1 #原集合没有变化
1
2

4.symmetric_difference()

相当于对称差运算

vehicle1.symmetric_difference(vehicle2) #结果相同
vehicle2.symmetric_difference(vehicle1)
1
2

5.issubset()和issuperset()

issubset()方法：判断是否子集。<=
issuperset()方法：判断是否超集>=
vehicle2.issubset(vehicle1)
vehicle1.issuperset(vehicle2)
1
2

6.add()

是向集合中添加元素

vehicle1.add(‘ship’) #重复元素，只保留一个
1

7.remove()

是从集合中删除元素，如果集合中没有该元素，则出错

8.discard()

作用是从集合中删除元素，如果集合中没有该元素，也不提示出错

9.pop()

pop()方法的作用是从集合中删除任一元素，并返回该元素；
如果集合为空，则抛出KeyError异常。

10.clear()

从集合中删除所有元素，变成一个空集合

4.4 可迭代对象Iterable 与 迭代器Iterator

简单解释：

可迭代对象 是 存放元素的容器，可以被遍历其中的元素。（类比：链表）

迭代器 由可迭代对象（容器）提供的(因为只有该容器知道怎么遍历它的每一个元素)，用于遍历容器元素的一个工具。（类比：链表的遍历指针p）

4.4.1 可迭代(Iterable)对象

列表、元组、字符串、字典可以用 for…in…进行遍历。

表面：只要可以用 for…in…进行遍历的对象就是可迭代对象，那么列表、元组、字符串、字典都是可迭代对象。

本质：如果一个对象实现了__iter__()方法，那么这个对象就是可迭代(Iterable)对象

help(list) #方法1：查看list对象的方法，是否有__iter__方法（类似于java中查看某一个类可实现的方法）
1
‘
运行运行
方法2：可以通过调用内置函数isinstance()来判断一个对象是否属于可迭代(Iterable)对象

from collections.abc import Iterable
isinstance([‘abc’,1,8.5],Iterable) #1.列表list是可迭代对象吗？
isinstance(123,Iterable) #7.数值int float 是可迭代对象吗？不是
1
2
3
‘
运行运行
迭代器（Iterator）：实现了__iter__方法和__next__方法，并且可以通过__next__方法不断返回下一个值的对象

迭代器(Iterator)还可以通过内置函数next()访问下一个元素。

可以通过调用Python内置函数isinstance()来判断一个对象是否属于迭代器(Iterator)

from collections.abc import Iterator
isinstance([],Iterator) #列表list 是迭代器吗？
isinstance([],Iterator) #列表list 是迭代器吗？
isinstance({1:’one’,2:’two’},Iterator) #字典dict 是迭代器吗？
isinstance({‘one’,’two’},Iterator) #集合set 是迭代器吗？
isinstance(‘abcdefg’,Iterator) #字符串str 是迭代器吗？
isinstance(range(10),Iterator) #range函数生成的数列 是迭代器吗？
isinstance(123,Iterator) #数值 是迭代器吗？
#以上对象均不能成为迭代器（注意迭代器和可迭代对象不同）
1
2
3
4
5
6
7
8
9
‘
运行运行
可迭代对象（容器）—> 迭代器(迭代工具)

虽然列表、元组、字符串、字典、集合都是可迭代(Iterable)对象而不是迭代器(Iterator)，但可以通过iter()函数获得一个迭代器(Iterator)
from collections.abc import Iterator
vehicle=[‘train’,’bus’,’car’,’ship’] #列表 list
v=iter(vehicle) #取list的迭代器
v.next() #1、自带方法__next__()：返回下一个值
next(v) #2、也可以用内置函数next()函数
v.next() #没有下一个元素了，触发StopIteration异常
next(v) #内置函数：next()访问下一个值(同样异常)
1
2
3
4
5
6
7
‘
运行运行

4.4.2 相关内置函数

enumerate（）枚举
zip() 组合
map() 映射（逐个计算）
filter（）过滤（挑选）
共同点：这四个函数都会返回一个 特定对象，它们都既是迭代器、也是可迭代对象。

1.enumerate() 枚举
格式：enumerate(iterable, start=0)
功能：返回下标和值的enumerate对象。
参数：第1个参数表示可迭代(Iterable)对象，第2个参数表示下标的开始值，默认从0开始。
通俗：将容器的每个元素取出来，搭配一个下标

enumerate对象：既是Iterable对象（容器），也是Iterator对象（容器的遍历工具）

vehicle=[‘train’,’bus’,’car’,’ship’] #列表list（用其他容器也可以）
vv1=enumerate(vehicle) #取得list的枚举器
for i in vv1: #迭代器 可以使用for in语句
print(i,” “)
#(0, ‘train’)
#(1, ‘bus’)
#(2, ‘car’)
#(3, ‘ship’)
next(vv1) #也可以使用next()函数
vv1.next() #也可以使用 next()方法
list(vv1) # 将剩余的enumerate对象vv1元素转换为列表
tuple(vv2) #enumerate对象vv2转换为元组
vv2=enumerate(vehicle,1) #下标从1开始
vv2.next() #返回下一个值
for i in enumerate(vehicle): #遍历enumerate对象中的元素
print(i,end=’ ‘) #(0, ‘train’) (1, ‘bus’) (2, ‘car’) (3, ‘ship’)
for i,x in enumerate(vehicle):
print(i,x,end=’ ‘) #遍历enumerate对象元素的下标和值 0 train 1 bus 2 car 3 ship
vv1=enumerate(vehicle)
dict(vv1) #enumerate对象vv1转换为字典:枚举号转为key，枚举值转为value
#{0: ‘train’, 1: ‘bus’, 2: ‘car’, 3: ‘ship’}
vv1=enumerate(vehicle)
set(vv1) #enumerate对象vv1转换为集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
2.zip()
格式：zip(iter1 [,iter2 […]])
功能：将多个迭代器(Iterator)对象（或者可迭代(Iterable)对象）中的元素压缩到一起，返回一个zip对象。
通俗：将多个容器的逐个对应元素拼合在一起

同样，zip对象既是一个可迭代(Iterable)对象，也是一个迭代器(Iterator)对象。

vv1=zip(‘abcd’) #1、只有一个参数：字符串（容器），每个元素是元组
list(vv1) #[(‘b’,), (‘c’,), (‘d’,)]
vv3 = zip(‘abcd’,vehicle) #2、有两个参数：有两个容器作为参数
list(vv3) #[(‘c’, ‘car’), (‘d’, ‘ship’)]
(‘b’, ‘bus’) in zip(‘abcd’,vehicle) #zip对象是可迭代对象（容器），可以使用in运算
vv2=zip(‘abcd’,enumerate(vehicle)) #第二个参数是 枚举（也是容器）
next(vv2) #(‘a’, (0, ‘train’))
vv3=zip(range(2),vehicle) #不同长短时：匹配短的
list(vv3)
vv4=zip(‘abcd’,range(4),vehicle) #3、更多参数：更多容器
next(vv4) #(‘a’, 0, ‘train’)
1
2
3
4
5
6
7
8
9
10
11
3.map()
格式：map(func, *iterables)
功能：把一个函数func依次映射到可迭代(Iterable)对象的每个元素上，返回一个map对象。
通俗：将每个元素 传入 func函数，把结果放入map里

map对象：既是一个可迭代(Iterable)对象，也是一个迭代器(Iterator)对象

aa=[‘1’,’5.6’,’7.8’,’9’]
bb1=map(float,aa) #将每个元素变为float类型
next(bb1) #1.0
list(map(str,range(5))) #将0-4改为字符串
#[‘0’, ‘1’, ‘2’, ‘3’, ‘4’]
def fun(x): # 2、定义一个 函数
return x**2
list(map(fun,[1,2,3,4])) #list中的每个元素，都执行一次fun函数，结果放入map
#[1, 4, 9, 16]
1
2
3
4
5
6
7
8
9
‘
运行运行
4.filter()
格式：filter(函数名 or None, 可迭代对象)
功能：把一个带有一个参数的函数function作用到一个可迭代(Iterable)对象上，返回一个filter对象。
filter对象中的元素由可迭代(Iterable)对象中使得函数function返回值为True的那些元素组成。
如果指定函数为None，则返回可迭代(Iterable)对象中等价于True的元素。
通俗：将容器中的元素用函数过滤（挑选）一下

filter对象：既是一个可迭代(Iterable)对象，也是一个迭代器(Iterator)对象。

只保留满足条件的元素

aa=[5,6,-9,-56,-309,206] #用法1：函数
def func(x): #定义函数func，x为奇数返回True，否则返回False
return x%2!=0

bb=filter(func,aa) #将aa中的每个元素，作为参数，带入func(x)。将返回值为True的元素保留下来。
type(bb) #bb是一个filter对象
next(bb) #5
cc=filter(lambda x:x%2!=0,aa) #用法2：lambda函数（匿名函数，不用单独定义函数了）
dd=[6,True,1,0,False]
ee=filter(None,dd) #用法4：指定函数为None（函数就不起作用了。就看元素本身，是否为True）
1
2
3
4
5
6
7
8
9
10
‘
运行运行

4.5 推导式

利用列表推导式、字典推导式、集合推导式可以从一个数据对象构建另一个新的数据对象。
利用生成器推导式可以构建生成器对象。
语法糖

4.5.1 列表推导式

列表推导式（list comprehension）是Python开发时用得最多的技术之一，表示对可迭代(Iterable)对象的元素进行遍历、过滤或再次计算，生成满足条件的新列表。
它的结构是在一个方括号里包含一个函数或表达式（再次计算），接着是一个for语句（遍历），然后是0个或多个for（遍历）或者if语句（过滤），在逻辑上等价于循环语句，但是形式上更简洁。
语法形式：
[函数 / 表达式
for 值1 in 可迭代对象1 if 条件1
for 值2 in 可迭代对象2 if 条件2
……
for 值n in 可迭代对象n if 条件n ]

1.列表推导式和循环语句for
如果要将一个列表中的元素均扩大2倍组成新列表：

n=[10,-33,21,5,-7,-9,3,28,-16,37] #列表推导式：
number=[i*2 for i in n]
number
1
2
3
‘
运行运行
两点：

利用列表推导式更加简洁。
由于Python内部对列表推导式做了大量优化，还能保证较快的运行速度
for循环可以嵌套。列表推导式中也可以有多个for语句。
如果要将一个一层嵌套数字列表中的元素展开后扩大2倍组成新列表：

n=[[10,-33,21],[5,-7,-9,3,28,-16,37]] #一层嵌套列表
number=[] #常规写法：
for i in n: #每一行
for j in i: #行中的每一列
number.append(j2)
number
n=[[10,-33,21],[5,-7,-9,3,28,-16,37]] #列表推导式：
number=[j2 for i in n for j in i]
number
1
2
3
4
5
6
7
8
9
‘
运行运行
2.列表推导式和条件语句if
在列表推导式中，条件语句if对可迭代(Iterable)对象中的元素进行筛选，起到过滤的作用。

#接着上面的例子，如果是将一个数字列表中的是正数的元素扩大2倍组成新列表：
n=[10,-33,21,5,-7,-9,3,28,-16,37]
number=[i*2 for i in n if i>0]
number
1
2
3
4
‘
运行运行
另外，在列表推导式中还可以使用if else语句。

#将一个数字列表中的正偶数扩大2倍、正奇数扩大3倍组成新列表
n=[10,-33,21,5,-7,-9,3,28,-16,37]
number=[i2 if i%2==0 else i3 for i in n if i>0]
number
1
2
3
4
‘
运行运行
3.列表推导式和函数function
在列表推导式中可以使用函数function。

#利用列表推导式快速生成包含15个30~80（包含30、80）之间的随机整数列表rlist。
import random
rlist=[random.randint(30,80) for i in range(15)] #使用randint()函数
rlist

对rlist中的元素，如果被3整除则该数除以3，如果被7整除则该数扩大2倍，其他的数扩大5倍，这些数组成新列表number

def ff(x):
if x%3==0:
x/=3
elif x%7==0:
x*=2
else:
x*=5
return x
number=[ff(i) for i in rlist] #使用自定义的ff()函数
number
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
‘
运行运行
4.同时遍历多个列表或可迭代对象
#有两个成绩列表score1和score2，将score1中分数90及以上和score2中分数85及以下的元素两两分别组成元组，将这些元组组成列表nn中的元素
score1=[86,78,98,90,47,80,90]
score2=[87,78,89,92,90,47,85]
nn=[(i,j) for i in score1 if i>=90 for j in score2 if j<=85]
nn
1
2
3
4
5
‘
运行运行

4.5.2 字典推导式

字典推导式和列表推导式的使用方法类似

将方括号变成花括号
需要两个表达式，一个生成键，一个生成值，两个表达式之间使用冒号分隔
最后生成的是字典
语法形式：
{函数 / 表达式
for 值1 in 可迭代对象1 if 条件1
for 值2 in 可迭代对象2 if 条件2
……
for 值n in 可迭代对象n if 条件n }

列表name存储若干人的名字（唯一），列表score在对应的位置上存储这些人的成绩，利用字典推导式，以名字为键、成绩为值组成新字典dd。

name= [‘Bob’,’Tom’,’Alice’,’Jerry’,’Wendy’,’Smith’]
score=[86,78,98,90,47,80]
dd={i:j for i,j in zip(name,score)}

以名字为键、成绩为值组成新字典exdd，新字典中的键值对只包含成绩80及以上的

exdd={i:j for i,j in zip(name,score) if j>=80} #增加一个if

以名字为键、名字的长度为值组成新字典nd

nd={i:len(i) for i in name}
1
2
3
4
5
6
7
8
‘
运行运行

4.5.3 集合推导式

集合也有自己的推导式，跟列表推导式类似

只不过将方括号变成花括号
最后生成的是集合
语法形式：
{函数 / 表达式
for 值1 in 可迭代对象1 if 条件1
for 值2 in 可迭代对象2 if 条件2
……
for 值n in 可迭代对象n if 条件n }
alist=[i2 for i in (1,2,3,3,2,1,4)]
bset={i2 for i in (1,2,3,3,2,1,4)}
1
2
‘
运行运行
不难发现，构建alist和bset的时候，除了方括号和花括号不同以外其他语法均相同，alist生成一个列表，里面的元素是元组(1,2,3,3,2,1,4)中每个元素的2倍，而且元素位置一一对应；blist生成一个集合，里面的元素是元组(1,2,3,3,2,1,4)中每个元素的2倍去掉重复元素后的结果，并且并非与元组的元素位置一一对应。

需要说明的是：元组没有推导式

4.5.4 生成器推导式

生成器推导式用法与列表推导式类似，把列表推导式的方括号改成圆括号。它与列表推导式最大的区别是：生成器推导式的结果是一个生成器对象，是一种迭代器(Iterator)；而列表推导式的结果是一个列表。
生成器对象可以通过for循环或者next()方法、next()函数进行遍历，也可以转换为列表或元组，但是不支持使用下标访问元素，已经访问过的元素也不支持再次访问。当所有元素访问结束之后，如果想再次访问就必须重新创建该生成器对象。

gen=(int(i/3) for i in range(1,10) if i%3==0)
gen #<generator object at 0x00000110CC45C970>
list(gen) #生成器对象转换为列表
gen.next() #不能再次访问
next(gen) #访问下一个元素
gen=(int(i/3) for i in range(1,10) if i%3==0)
for i in gen: #for循环遍历
print(i,end=’ ‘)
1
2
3
4
5
6
7
8

五、字符串

5.1 字符串的编码

ASCII码

标准ASCII码为7位编码，包括英文字母、数字、标点符号等128个字符。用1个字节存储，最高位为0.
扩展ASCII码：1个字节存储，最高位为1。

Unicode编码

.把所有语言统一到一套编码里
.采用2个字节或4个字节（生僻字符）的编码
.缺点：全部是英文的话，比ASCII码多用一倍存储空间

UTF-8编码

可变长编码，英文字符用1个字节（兼容ASCII码），中文字符用3个字节，其他语言也有用2或4个字节

GB2312、GBK等中文编码

一般用2个字节

Python3支持两种类型字符串：str类型（支持Unicode编码）和bytes类型，而且str类型和bytes类型可以相互转换。

str.encode()可以转换为bytes类型
bytes.decode()转换为str类型
除此之外，其他方法都一样
s=’我’ #str类型
#编码（str–>bytes）
s1=s.encode(‘gbk’) #编码成bytes类型，gbk编码格式
s1 #b’\xce\xd2’，16进制，2个字节（1位16进制数，用4位2进制数表示）
s2=s.encode(‘utf-8’) #编码成bytes类型，utf-8编码格式
s2 #b’\xe6\x88\x91’，16进制，3个字节
#解码（bytes–>str）
s3=s1.decode(‘gbk’) #s1目前是gbk编码的bytes字符串，使用gbk进行解码
s4=s2.decode(‘utf-8’) #s2目前是utf-8编码的bytes字符串，使用utf-8进行解码
s5=s.encode(‘ascii’) #s(‘我’)是str类型字符串，中文字符串不能以ascii编码
‘ABC’.encode(‘ascii’) #英文字符串可以以ascii编码
1
2
3
4
5
6
7
8
9
10
11
也可以使用bytes(string, encoding) 和str(bytes_or_buffer[, encoding])完成两种类型的相互转换

s=’阳光’
b=bytes(s,encoding=’gbk’) #str–>bytes，用gbk编码转换
u=bytes(s,encoding=’utf-8’) #用utf-8编码转换,3个字节
bs=str(b,encoding=’gbk’) #bytes–>str，用gbk编码转换
us=str(u,encoding=’utf-8’)#str类型
ub = str(u,encoding=’gbk’) #u是用utf-8转换来的,’阳光’,3个字节
ub #结果有误
1
2
3
4
5
6
7
‘
运行运行
Python3.x完全支持中文字符，解析器默认采用UTF-8解析源程序，
无论是数字字符、英文字母、汉字都按 一个 字符来对待和处理

5.2 字符串的构建

在Python中字符串的构建，主要通过两种方法来实现，一是使用str函数，二是用单引号、双引号或三引号

1.单引号或双引号构造字符串 ：要求引号成对出现
合法：如：‘Python World!’、‘ABC’、“what is your name？”
不合法：’string”
2.字符串本身有 单引号或双引号时：
字符串包含了 单引号，且不用转义字符：整个字符串就要用 双引号 来构造。
字符串包含了 双引号，且不用转义字符：整个字符串要用 单引号 来构造。

print(“Let’s go!”) #字符串本身有单引号
‘“Hello world!”,he said.’ #字符串本身有双引号
print(‘“Hello world!”,he said.’) #print函数输出时，是没有外层的引号的
1
2
3
‘
运行运行
3.对引号转义
‘Let's go!’
print(‘Let's go!’)
“"Hello world!"he said”
print(“"Hello world!"he said”)
1
2
3
4
‘
运行运行
4.对其他字符转义
转义字符以“\”开头，后接某些特定的字符或数字

转义字符 含义 转义字符 含义 转义字符 含义
\（行尾） 续行符 \n 换行符 \f 换页符
\ 一个反斜杠 \r 回车 \ooo 3位8进制数ooo对应的字符，如\123
’ 单引号’ \t 横向（水平）制表符 \xhh 2位16进制数hh对应的字符，如\x6a
“ 双引号” \v 纵向（垂直）制表符 \uhhhh 4位16进制数hhhh表示的Unicode字符
print(“你好\n再见！”) #\n表示换行，相当于敲了一个回车键
print(‘\123\x6a’) #8进制数123对应的字符是“S”，16进制数6a对应的字符“j sj
1
2
‘
运行运行
5.原始字符串
假设在C:\test文件夹中有一个文件夹net，如何输出完整路径呢？可能你想到的是

print(“c:\test\net”) #错误
1
‘
运行运行
第1种方法：使用“\”表示反斜杠，则t和n不再形成\t和\n

print(“c:\test\net”)
1
‘
运行运行
第2种方法：在原始字符串前加 r 前缀
在字符串前面加上字母 r 或 R 表示原始字符串，所有的字符都是原始的本义而不会进行任何转义。

print(r”c:\test\net”)
1
‘
运行运行
6.三重引号字符串
三重引号将保留所有字符串的格式信息。

如字符串跨越多行，行与行之间的回车符、引号、制表符或者其他任何信息，都将保存下来。
在三重引号中可以自由的使用单引号和双引号。
‘’’”What’s your name?”
“My name is Jone”‘’’
#’”What's your name?”\n “My name is Jone”‘
print(‘’’”What’s your name?”

   "My name is Jone"''')

“What’s your name?”

   "My name is Jone"

1
2
3
4
5
6
7
8
9

5.3 字符串格式化

5.3.1 用 % 符号格式化字符串
格式以%开头
格式化运算符用%表示用对象代替格式串中的格式，最终得到1个字符串
基本同C语言

1.字符串格式的书写
[ ]中的内容可以省略；
简单的格式是：% 加格式字符，如%f、%d、%c等；
当最小宽度及精度都出现时，它们之间不能有空格，格式字符和其他选项之间也不能有空格，如%8.2f。
2.常用格式字符的含义（基本同C语言）

3.最小宽度和精度
最小宽度：转换后的值所保留的最小字符个数。
精度（对于数字来说）：结果中应该包含的小数位数。

#浮点数
a=3.1416
‘a=%6.2f’%a #总宽度为6，保留2位小数，四舍五入 ‘a= 3.14’
‘%f’%3.1416 #单独的%f，默认保留6位小数 ‘3.141600’
‘%.2f’%3.1416 #保留2位小数，第2位四舍五入，3.14
‘%.2f’%3.1476 #四舍五入为3.15
‘%7.2f’%3.1416 #宽度7位，保留2位小数，空位填空格 ‘ 3.14’
‘%07.2f’%3.1416 #宽度7位，保留2位小数，空位填0 ‘0003.14’
‘%7.2f’%1234567.8901 #实际宽度，允许超出最小宽度 ‘1234567.89’
‘%+07.2f’%3.1416 #宽度7位，保留2位小数，正数加正号，空位填0 ‘+003.14’
‘%-7.2f’%-3.1416 #宽度7位，保留2位小数，空位填空格，左对齐输出 ‘-3.14 ‘
“%-2d”%156 #左对齐
“%-2d”%5 #左对齐，右补空格
‘%d’%’5’ #字符串’5’用格式化整数%d输出，引发异常（类型必须一致）
‘%s’%5 #与str()等价
#多对象：%后用元组
‘%.2f,%4d,%s’%(3.456727,89,’Lily’) #常量–>元组
‘3.46, 89,Lily’
name=’Lily’
age=18
‘我叫%s，今年%d岁’%(name,age) #变量–>元组 ‘我叫Lily，今年18岁’

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
4.进位制和科学计数法
a=123456
y=’%o’%a #转换为八进制串
z=’%x’%a #转换为十六进制串
za=’%0x’%a #16进制数前添加0x
se=’%e’%a #转换为科学计数法串，基底e
se #小数点前有一位非零数字，小数点后是6位小数
‘%e’%12345.678 #科学计数法，基底e ‘1.234568e+04’
‘%E’%12345.678 #科学计数法，基底E ‘1.234568E+04’
‘%g’%12345.678 #采用浮点数形式，根据值的大小采用%e或%f
‘%G’%12345.678 #采用浮点数形式
‘%.4G’%12345.678 #采用科学计数法形式，基底E
1
2
3
4
5
6
7
8
9
10
11
‘
运行运行
5.3.2 format()方法格式化字符串
format()方法是通过{}和:来代替传统%方式

首先看{}和参数的对应关系

‘我叫{},今年{}岁’.format(‘张清’,18) #以下输出均为’我叫张清,今年18岁’
‘我叫{0},今年{1}岁’.format(‘张清’,18)
‘我叫{1},今年{0}岁’.format(18,’张清’)

my=[‘张清’,18]
‘我叫{},今年{}岁’.format(my) #列表前加，自动解包
‘我叫{0[0]},今年{0[1]}岁’.format(my) #列表不加*，则需要用列表的索引元素
#{后的0表示第一个参数(若有第2个参数，则为1)，[]中的数字表示列表元素的索引
‘我叫{name},今年{age}岁’.format(name=’张清’,age=18) #直接写变量名
‘我叫{name},今年{age}岁’.format(age=18,name=’张清’) #有了名字之后，就可以任意顺序

my={‘name’:’张清’,’age’:18}
‘我叫{name},今年{age}岁’.format(my) #字典前加，自动解包

‘{0:.2f}’.format(2/3) #十进制的0.67
‘{0:b}’.format(8) #二进制
‘{0:o}’.format(8) #八进制
‘{0:x}’.format(18) #十六进制
‘{:,}’.format(1234567890) #千分位格式化，1,234,567,890
‘{0:>10}’.format(18) #右对齐 ‘**18’
‘{0:<10}’.format(18) #左对齐 ‘18**‘
‘{0:^9}’.format(18) #居中对齐 ‘18‘
‘{0:0=10}’.format(-18) #0放在-和18中间 ‘-000000018’
‘{0:_},{0:#x}’.format(9999) #_作为分隔符（起到千分位的作用） ‘9_999,0x270f’

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
‘
运行运行
5.3.3 带f前缀的格式化字符串
name=’张清’
age=18
f’我叫{name},今年{age}岁’
1
2
3
‘
运行运行

5.4 字符串截取

字符串 属于 序列 类型，同样，可以使用索引或者切片。

单个字符

索引str[index]取出单个字符
切片字符

str[start : end : step]取出一片字符。同序列的切片。
s=”student”
s[1:3] #取出位置为1到位置为2的字符，不包括位置3的字符 ‘tu’
s[:3] #取出从头至位置为2的字符 ‘stu’
s[-2:] #取出从倒数第2个位置开始的所有字符,从左往右取（步长默认是1） ‘nt’
s[:] #正序全部字符
s[::-1] #逆序全部字符
s[::2] #步长为2
1
2
3
4
5
6
7
‘
运行运行
字符串属于不可变序列类型，不支持字符串修改

5.5 字符串常用内置函数

s=’Merry days will come,believe.’
len(s) #字符串长度
max(s) #最大字符
min(s) #最小字符：本处为空格
ord(‘M’) #获取该字符的Unicode码 77
chr(77) #把编码转换为对应的字符 ‘M’
ord(‘好’) #汉字的编码
chr(22909)

1
2
3
4
5
6
7
8
9
‘
运行运行

5.6字符串常用方法

由于字符串属于不可变序列，下述方法中涉及到返回字符串的都是新字符串，原有字符串对象不变。

1.center()、ljust()、rjust()
格式：

center(width, fillchar=’ ‘) 居中对齐
ljust(width, fillchar=’ ‘) 左对齐
rjust(width, fillchar=’ ‘) 右对齐
说明：

width：指定宽度；
fillchar：填充的字符，默认为空格。
功能：

返回一个宽度为width的新字符串，原字符串居中（左对齐或右对齐）出现在新字符串中，如果width大于字符串长度，则使用fillchar进行填充。
‘你好’.center(10) #居中对齐，以空格填充 ‘ 你好 ‘
‘你好’.center(11,”“) #居中对齐，以填充 ‘*你好‘
‘你好’.ljust(10,”!”) #右对齐，以！填充 ‘你好!!!!!!!!’
‘你好’.rjust(10,”-“) #左对齐，以-填充 ‘——–你好’
1
2
3
4
‘
运行运行
2.lower()、upper()
lower()方法将大写字母转换为小写字母，其他字符不变，并返回新字符串（全部为小写字母）。
upper()方法将小写字母转换为大写字母，其他字符不变，并返回新字符串（全部为大写字母）。
用处：解决有关不区分大小写问题

3.capitalize()、title()、swapcase()
capitalize()：将整个字符串 首字母转换为大写形式，其他字母转换为小写形式。
title()： 将每个单词的首字母转换为大写形式，其他部分的字母转换为小写形式。
swapcase()：将大小写互换。
提醒：均返回新字符串，原字符串对象不做任何修改。

4.islower()、isupper()、isdigit()
功能：测试字符串是否为全小写、大写、数字。如果是，则返回True；否则返回False。

其他的方法，请通过“help(str)”自行查看帮助信息。

5.find()、rfind()
格式：

S.find(sub[, start[, end]])
S.rfind(sub[, start[, end]])
说明：

sub：字符串（子串）；
start：开始位置；
end：结束位置。查找范围start开始，end结束，不包括end。
功能：

在字符串S中，在[start,end)范围内查找并返回子串sub首次出现的位置索引
如果没有找到则返回-1。
默认范围是整个字符串。
其中find()方法从左往右查找，rfind()方法从右往左查找。
6.index()、rindex()
格式：

S.index(sub[, start[, end]])
S.rindex(sub[, start[, end]])
功能：

在字符串S中，查找并返回在[start,end)范围内，子串sub首次出现的位置索引
如果不存在则抛出异常。(和find()、rfind()的不同点)
默认范围是整个字符串。
其中index()方法从左往右查找，rindex()方法从右往左查找。
7.count()
格式：

S.count(sub[, start[, end]])
功能：

在字符串S中，查找并返回[start,end)范围内子串sub出现的次数
如果不存在，则返回0。
默认范围是整个字符串。
8.split()
功能：

以指定字符为分隔符，从左往右将字符串分割开来，并将分割后的结果组成列表返回。
如果字符串中的某种字符出现0次或多次，可以利用split()方法，根据该字符把字符串分离成多个子串组成的列表。
对于split()，如果不指定分隔符，实际上表示以任何空白字符（包括连续出现的）作为分隔符。

空白字符包括空格、换行符、制表符等。

除了split()，还有rsplit()，表示从右往左将字符串分割开来，这两种方法还能指定最大分隔次数

9.join()
join()方法可用来连接序列中的元素，并在两个元素之间插入指定字符，返回一个字符串

join()方法是split()方法的逆方法

s=’Heart is living in tomorrow’
slie=s.split() #用空格分割
ss=’ ‘.join(slie) #用空格接上
1
2
3
‘
运行运行
10.replace()
格式：

replace(old,new,count=-1)
功能：

查找字符串中old子串并用new子串来替换。
参数count默认值为-1，表示替换所有匹配项，否则(count为其他值时）最多替换count次。
返回替换后的新字符串（原字符串不变）。
s1=’中国北京，北京地铁，地铁沿线，北京沿线城市’
s4=s1.replace(‘北京’,’Beijing’,2) #指定最大替换次数
1
2
‘
运行运行
11.maketrans()、translate()
maketrans()：生成字符映射表
translate()：根据字符映射表替换字符。
这两种方法联合起来使用可以一次替换多个字符。
t=’’.maketrans(‘iort’,’mn24’) #两个序列中的元素按照次序一一对应，用于替换
#{105: 109, 111: 110, 114: 50, 116: 52}
s=’Heart is living in tomorrow’
s.translate(t)
#’Hea24 ms lmvmng mn 4nmn22nw’
#’Heart is living in tomorrow’
1
2
3
4
5
6
‘
运行运行
12.strip()
strip()：去除字符串两侧的空白字符(空格、回车、制表符等）或指定字符，并返回新字符串。

s1=’HHwHeart is liwving iHn tomorrowHww’
s1.strip(‘Hw’) #从两端逐一去除“H”或“w”字符，直到不是这两个字符为止（中间的字符Hw不能去除）
1
2
‘
运行运行

5.7 字符串string模块

字符串string模块定义了Formatter类、Template类、capwords函数和常量，熟悉string模块可以简化某些字符串的操作。

import string
s=input(‘请输入英文单词，用空格分隔：’)
ss=string.capwords(s) #用到了string.capwords()函数
print(‘单词首字母大写：’,ss)
1
2
3
4
‘
运行运行
说明：这种方法直接用到string模块中的常量ascii_lowercase和random模块中choice()方法。choice()方法的功能是在一个非空的序列中随机选择一个元素。

import random
x=’012345abcde’
random.choice(x)
1
2
3
‘
运行运行

5.8正则表达式

5.8.1正则表达式的元字符
正则表达式（模式串）中的字符，根据作用不同，分为两类：

普通字符：大多数字母和字符一般都会和自身匹配。
元字符：有些字符比较特殊，它们和自身并不匹配，而是表明应和一些特殊的东西匹配，或者会影响重复次数。
因为在模式串中常常有特殊字符，为了书写方便，在字符串前加r前缀，不对其进行转义。

第一种情况：
模式串中全部是 普通字符

import re #导入re模块
w=’abc’ #模式串中 全部是普通字符
re.findall(w,’aabaab’) #无匹配
re.findall(w,’aabcaabc’) #两处匹配（查找到两个）
1
2
3
4
‘
运行运行
第二种情况：
模式串中含有 元字符

常用的元字符：

1.“.”：表示任意单个字符 (除换行符以外)
import re
s=’hi,i am a student.my name is Hilton.’
re.findall(r’i’,s) #在s中，匹配所有的i
1
2
3
‘
运行运行
s=’’’hi,
i student.
Hilton.’’’ #三引号字符串中可以有换行符
re.findall(r’.’,s) #本结果中：没有匹配两个换行符
1
2
3
4
s=’hi,i am a student.my name is Hilton.’
re.findall(r’i.’,s) #匹配i后面跟除换行符以外的任意字符的形式
#必须是两个字符：第一个是i，第2个是换行符以外的任意字符，可以是空白符
1
2
3
2.“[]”：指定字符集
用来指定一个字符集合，例如：[abc]、[a-z]、[0-9]；
从字符集合中必须选一个，也只能选一个字符（即单个字符）
有些元字符在方括号中不起作用（作为普通字符）,例如：[akm$]和[m.]中元字符都不起作用；
方括号内的“”表示补集，匹配不在区间范围内的字符，例如：[3]表示除3以外的字符。
import re
s=’mat mit mee mwt meqwt’
re.findall(r’m[iw]t’,s) #匹配m后跟i或者w再跟t形式：mit mwt
#查找3个字符：第1字符必须是m，第3字符必须是t，中间字符只能是iw中的一个
1
2
3
4
‘
运行运行
3.“^”：匹配行首，匹配每 行 中以^后面的字符开头的字符串（必须放在模式串的开头）
英文称为caret (英语发音：/ˈkærət/)
记忆法：^数学上读作hat，帽子（戴头上），可以形象的想象成 首部

匹配模式：

默认只匹配多行字符串的首行；
多行匹配需要单独设置re.M参数。
4.“” ： 匹 配 ‘ 行 尾 ‘ ， 匹 配 每 行 中 以 ”：匹配行尾，匹配每行中以”：匹配‘行尾‘，匹配每行中以之前的字符结束的字符串
英语读作dollar，音标：[‘dɒlə®]
记忆法：$，可以形象的想象成 弯曲的尾巴，“行尾”

匹配模式：

默认只匹配多行字符串的末行；
多行匹配需要单独设置re.M参数。
5.“\”：反斜杠后面可以加不同的字符以表示不同的特殊意义（四对）
\b匹配单词头或单词尾（\b放前面，会匹配单词头；\b放后面，会匹配单词尾）；相当于^或$(但这两个只能用于整个字符串，不能切分单词)

\B与\b相反，匹配非单词头或单词尾（不查找单词头或单词尾，只查其他部分）；

\d匹配任何数字字符；相当于[0-9]；

\D与\d相反，匹配任何非数字字符，相当于[^0-9]；

\s匹配任何空白字符，相当于[\t\n\r\f\v]；

\S与\s相反，匹配任何非空白字符，相当于[^\t\n\r\f\v]；\t是制表符，\f是换页符，\v是垂直制表符

\w匹配任何字母、数字或下画线字符，相当于[a-zA-Z0-9_]；

\W与\w相反，匹配任何非字母、数字和下画线字符，相当于[^a-zA-Z0-9_]；

也可以用于取消所有的元字符：\、[。

这些特殊字符都可以包含在[]中。如：[\s,.]将匹配任何空白字符、”,“或”.”。

第一对：\b和\B

字符串中切分单词的分隔符，包括空格、换行、制表符、各种标点符号。

\b：单词头/单词尾：注意不是整个字符串，而是分隔后的每个单词

\B：和\b相反（不查开头/结尾的，只查其他部分的）

第二对：\d与\D

\d:数字字符，等同于[0-9]

\D：和\d相反，等同于[^0-9]（非数字字符）

第三对：\s与\S

\s：匹配（查找）任何空白字符，相当于[\t\n\r\f\v]：横向制表符、换行、回车、换页符、纵向制表符

\S：和\s相反，不匹配（查找）任何空白字符，相当于[^\t\n\r\f\v]

\S与“.”区别

“.”， 表示任意单个字符（换行符除外）
“\S”，表示任意单个字符（空白符除外）。注意是大写的S。
第四对：\w与\W

\w：匹配任何字母、数字或下画线字符，相当于[a-zA-Z0-9_]

\W：和\w相反，不匹配任何字母、数字或下画线字符，相当于[^a-zA-Z0-9_]

第五点：用\取消元字符

s=’hi,i am a student.my name is Hilton.’
re.findall(r’t.’,s) #此时的.就是元字符：匹配(查找)t+任意字符
re.findall(r’t.‘,s) #此时的.就是普通的字符：匹配(查找)t.
1
2
3
第六点：\d、\D、\s、\S、\w、\W也可以用在[]内

以上5类元字符都是表示单个字符。
.:任意单个字符（换行符除外）
[]:集合中的任意单个字符
^:行首
$:行尾
:\b\d\s\w

量词
正则表达式能指定正则表达式的一部分的重复次数，用到的元字符有“*”、“+”、“?”、“{}”。