python六大数据类型详解_整理python六大数据类型的内置函数

python 六大数据类型详解

数据类型简介

Python3 中有六个标准的数据类型：Number（数值）、String（字符串）、List（列表）、Tuple（元组）、Sets（集合）、Dictionary（字典）。

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数值）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

下面我们一一介绍这些数据类型的使用。

Number（数值）

Python3 支持 int、float、bool、complex（复数）。

数字类型是顾名思义是用来存储数值的，需要记住的是，有点和 Java 的字符串味道差不多，如果改变了数字数据类型的值，将重新分配内存空间。

Python 支持三种不同的数值类型：

• 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
• 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点类型不精确存储，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
• 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

示例：

#!/usr/bin/python3 
counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "test"     # 字符串 
print (counter)
print (miles)
print (name)
1
2
3
4
5
6
7

数字类型转换

• int(x) 将x转换为一个整数。
• float(x) 将x转换到一个浮点数。
• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。额外说明

和别的语言一样，数字类型支持各种常见的运算，不过 Python 的运算比别的大多数常见语言都更加丰富，此外，还有大量丰富的方法，提供更高效的开发。

数值运算示例：

print (5 + 4)  # 加法   输出 9
print (4.3 - 2) # 减法   输出 2.3
print (3 * 7)  # 乘法  输出 21
print (2 / 4)  # 除法，得到一个浮点数    输出 0.5
print (2 // 4) # 除法，得到一个整数 输出 0
print (17 % 3) # 取余   输出 2
print (2 ** 5) # 乘方  输出 32
1
2
3
4
5
6
7

String（字符串）

创建字符串可以使用单引号、双引号、三单引号和三双引号，其中三引号可以多行定义字符串，Python 不支持单字符类型，单字符也在Python也是作为一个字符串使用。

我们定义一个 s='python’语句，它在计算机中的执行顺序是先在内存中创建一个字符串 Python ，在程序栈寄存器中创建一个变量 s，最后把 Python 的地址赋给s 。

再来看看字符串的一些常见操作：

s = '学习Python'

# 切片
# 字符串索引index取值范围：-len()到len()-1   越界会报错
s[0], s[-1], s[3:], s[::-1]	# '优', 'n', 'Python', 'nohtyP的雅优'

# 替换，还可以使用正则表达式替换
s.replace('Python', 'Java')	 # '学习Java'

# 查找，find()、index()、rfind()、rindex()
s.find('P')			# 3, 返回第一次出现的子串的下标
s.find('h', 2)			# 6, 设定下标2开始查找
s.find('23333')			# -1, 查找不到返回-1
s.index('y')			# 4, 返回第一次出现的子串的下标
s.index('P')		# 不同与find(), 查找不到会抛出异常

# 转大小写, upper()、lower()、swapcase()、capitalize()、istitle()、isupper()、islower()
s.upper()			# '学习PYTHON'
s.swapcase()	    # '学习pYTHON', 大小写互换
s.istitle()			# True
s.islower()			# False

# 去空格,strip()、lstrip()、rstrip()

# 格式化
s1 = '%s %s' % ('Windrivder', 21)	# 'Windrivder 21'
s2 = '{}, {}'.format(21, 'Windridver')	# 推荐使用format格式化字符串
s3 = '{0}, {1}, {0}'.format('Windrivder', 21)
s4 = '{name}: {age}'.format(age=21, name='Windrivder')

# 连接与分割，使用 + 连接字符串，每次操作会重新计算、开辟、释放内存，效率很低，所以推荐使用join
l = ['2017', '03', '29', '22:00']
s5 = '-'.join(l)			# '2017-03-29-22:00'
s6 = s5.split('-')			# ['2017', '03', '29', '22:00']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

以上是一些常见的操作。

另外还有一点需要注意的是字符串编码，所有的 Python 字符串都是 Unicode 字符串，当需要将文件保存到外设或进行网络传输时，就要进行编码转换，将字符转换为字节，以提高效率。

# encode 将字符转换为字节
str = '学习Python'
print (str.encode())			# 默认编码是 UTF-8  输出：b'\xe5\xad\xa6\xe4\xb9\xa0Python'
print (str.encode('gbk'))      # 输出  b'\xd1\xa7\xcf\xb0Python'
# decode 将字节转换为字符
print (str.encode().decode('utf8'))   # 输出 '学习Python'
print (str.encode('gbk').decode('gbk'))             # 输出 '学习Python'
1
2
3
4
5
6
7

Python字符串的45个方法详解

python中字符串对象提供了很多方法来操作字符串，功能相当丰富。必须进行全面的了解与学习，后面的代码处理才能更得心应手，编程水平走向新台阶的坚实基础。目前一共有45个方法，给大家分类整理，可以收藏查询使用。

• 获取字所有的符串方法

#获取字所有的符串方法
print(dir(str))
[...,'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith','expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier','islower', 'isnumeric','isprintable', 'isspace', 'istitle','isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
1
2
3

一、大小写转换

01、capitalize()

**描述：**将字符串的第一个字母变成大写，其余字母变为小写。

语法： str.capitalize()

示例：

"i Love python".capitalize()
'I love python'

"i Love pYthoN".capitalize()
'I love python'
1
2
3
4
5

02、title()

描述：返回一个满足标题格式的字符串。即所有英文单词首字母大写，其余英文字母小写。

语法： str.title()

示例：

"i am very love python".title()
'I Am Very Love Python'
1
2

03、swapcase()

**描述：**将字符串str中的大小写字母同时进行互换。即将字符串str中的大写字母转换为小写字母，将小写字母转换为大写字母。

语法： str.swapcase()

示例：

"I Am Love PYTHON".swapcase()
'i aM lOVE python'

"我爱pythoN Python pYTHON".swapcase()
'我爱PYTHOn pYTHON Python'
1
2
3
4
5

04、lower()

**描述：**将字符串中的所有大写字母转换为小写字母。

语法： str.lower()

示例：

"我爱pythoN Python!".lower()
'我爱python python!'
1
2

05、upper()

**描述：**将字符串中的所有小写字母转换为大写字母。

语法： str.upper()

示例：

"i am very love python".upper()
'I AM VERY LOVE PYTHON'
1
2

06、casefold()

**描述：**将字符串中的所有大写字母转换为小写字母。也可以将非英文 语言中的大写转换为小写。

注意 ：lower()函数和casefold()函数的区别：lower() 方法只对ASCII编码，即‘A-Z’有效，对于其它语言中把大写转换为小写的情况无效，只能用 casefold() 函数。

语法： str.casefold()

示例：

 "Groß - α".casefold()#德语
 'gross - α'
 
"I am verY love python".casefold()
'i am very love python'
1
2
3
4
5

二、字符串填充

07、center()

**描述：**返回一个长度为width,两边用fillchar(单字符)填充的字符串，即字符串str居中，两边用fillchar填充。若字符串的长度大于width,则直接返回字符串str。

语法： str.center(width , “fillchar”)

• width —— 指定字符串长度。
• fillchar —— 要填充的单字符，默认为空格。

示例：

'shuai'.center(10)
'  shuai   '

'shuai'.center(10,'*')
'**shuai***'

#名字补齐
L = ['Jack','jenny','joe']
[name.center(10,'#') for name in L]
['###Jack###', '##jenny###', '###joe####']

for name in L:    
	print(name.center(10,'#'))

###Jack###
##jenny###
###joe####
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

08、ljust()

**描述：**返回一个原字符串左对齐,并使用fillchar填充(默认为空格)至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

语法： str.ljust(width, fillchar) -> str 返回一个新的字符串

• width —— 指定字符串的输出长度。
• fillchar—— 将要填充的单字符，默认为空格。

示例：

'shuai'.ljust(10)
'shuai     '

'shuai'.ljust(10,'*')
'shuai*****'

L = ['Jack','jenny','joe']
[name.ljust(10,'#') for name in L]
['Jack######', 'jenny#####', 'joe#######']

for name in L:    
	print(name.ljust(10,'#'))
Jack######
jenny#####
joe######
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

09、rjust()

**描述：**返回一个原字符串右对齐,并使用fillchar填充(默认为空格)至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

语法： str.ljust(width, fillchar)

• width —— 指定字符串的输出长度。
• fillchar—— 将要填充的单字符，默认为空格。

示例：

'shuai'.rjust(10)
'     shuai'

'shuai'.rjust(10,'*')
'*****shuai'

L = ['Jack','jenny','joe']
[name.rjust(10,'#') for name in L]
['######Jack', '#####jenny', '#######joe']

for name in L:    
	print(name.rjust(10,'*'))
******Jack
*****jenny
*******joe

for name in L:    
	print(name.rjust(10,'好'))
好好好好好好Jack
好好好好好jenny
好好好好好好好joe
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

10、zfill()

**描述：**返回指定长度的字符串，使原字符串右对齐，前面用0填充到指定字符串长度。

语法： str.zfill(width)

width —— 指定字符串的长度,但不能为空。若指定长度小于字符串长度，则直接输出原字符串。

示例：

'12'.zfill(10)
'0000000012'

 #对用户ID进行填充
 L=['56783','34','987766721','326']
 [id.zfill(10) for id in L]
 ['0000056783', '0000000034', '0987766721', '0000000326']
 
for id in L:    
	print(id.zfill(10))
0000056783
0000000034
0987766721
0000000326
#等价于用0填充的右对齐
[id.rjust(10,'0') for id in L]
['0000056783', '0000000034', '0987766721', '0000000326']

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

三、字符串编码

11、encode()

**描述：**以指定的编码格式编码字符串，默认编码为 ‘utf-8’。encode英文原意 编码。

语法： str.encode(encoding=‘utf-8’, errors=‘strict’)

• encoding 参数可选，即要使用的编码，默认编码为 ‘utf-8’。字符串编码常用类型有：utf-8，gb2312，cp936，gbk等。
• errors 参数可选，设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeEncodeError。其它可能值有 ‘ignore’, ‘replace’, 'xmlcharrefreplace’以及通过 codecs.register_error() 注册其它的值。

示例：

"我爱祖国".encode(encoding="utf8",errors="strict")
b'\xe6\x88\x91\xe7\x88\xb1\xe7\xa5\x96\xe5\x9b\xbd'

"I love my country".encode(encoding="utf8",errors="strict")
b'I love my country'
1
2
3
4
5

12、decode()

**描述：**以 encoding 指定的编码格式解码字符串，默认编码为字符串编码。decode英文意思是 解码，

语法： str.decode(encoding=‘utf-8’, errors=‘strict’)

• encoding ——要使用的编码，如：utf-8,gb2312,cp936,gbk等。
• errors ——设置不同解码错误的处理方案。默认为 ‘strict’,意为编码错误引起一个 UnicodeDecodeError。其它可能得值有 ‘ignore’, 'replace’以及通过 codecs.register_error() 注册的1其它值。

示例：

str1 = "我爱学习".encode(encoding="utf-8")
str1
b'\xe6\x88\x91\xe7\x88\xb1\xe5\xad\xa6\xe4\xb9\xa0'

str1.decode(encoding="utf-8")
'我爱学习'
1
2
3
4
5
6

​

四、字符串查找

13、find()

**描述：**查找字符串中指定的子字符串sub第一次出现的位置，可以规定字符串的索引查找范围。若无则返回 -1。

语法： str.find(sub,start,end) -> int 返回整数

参数：

• sub —要索引的子字符串。
• start —索引的起始位置。默认值为0。
• end —索引的结束位置。默认值为字符串长度len(str)。[start,end) 不包括end。

示例：

#查找子字符串"o"
"I love python".find('o')
3

#索引起始位置为4 索引范围为：ve python
"I love python".find('o',4)
11

#索引起始位置为4,结束位置为12 索引范围为：ve pytho
"I love python".find('o',4,12)
11

"I love python".find('o',4,11)
#不包括11位的'o',返回-1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

14、rfind()

**描述：**查找字符串中指定的子字符串sub最后一次出现的位置，可以规定字符串的索引查找范围。若无则返回 -1。

语法： str.rfind(sub,start,end) -> int 返回整数

参数：

• sum —要索引的子字符串。
• start —索引的起始位置。默认值为0。
• end —索引的结束位置。默认值为字符串长度len(str)。[start,end) 不包括end。

注：rfind()函数用法与find()函数相似，rfind()函数返回指定子字符串最后一次出现的位置，find()函数返回指定子字符串第一次出现的位置。

#查找子字符串"o"
"I love python".find('o')
3

#索引起始位置为4 索引范围为：ve python
"I love python".find('o',4)
11

#索引起始位置为4,结束位置为12 索引范围为：ve pytho
"I love python".find('o',4,12)

1
2
3
4
5
6
7
8
9
10
11

15、index()

**描述：**查找字符串中第一次出现的子字符串的位置，可以规定字符串的索引查找范围[star,end)。若无则会报错。

语法： str.index(sub, start, end) -> int 返回整数

参数：

• sub —— 查找的子字符串。
• start —— 索引的起始位置，默认为0。
• end —— 索引的结束位置，默认为字符串的长度。

示例：

"I love python".index("o") #默认索引整个字符串
"I love python".index("o",4)  #索引 ve python11
"I love python".index("o",4,12) #索引 ve pytho11
"I love python".index("love")    #索引多个字符2"I love python".index("k")   #索引字符串不存在，报错ValueError: substring not fou
1
2
3
4

16、rindex()

描述： rindex() 方法返回子字符串最后一次出现在字符串中的索引位置，该方法与 rfind() 方法一样，可以规定字符串的索引查找范围[star,end)，只不过如果子字符串不在字符串中会报一个异常。

语法： str.rindex(sub, start, end) -> int 返回整数。

参数：

• sub —— 查找的子字符串。
• start —— 索引的起始位置，默认为0。
• end —— 索引的结束位置，默认为字符串的长度。

示例：

"I love python".rindex('o')
11

"I love python".index('o')
3

"I love python".rindex('k')
ValueError: substring not found

"I love python".rfind('k')
-1
1
2
3
4
5
6
7
8
9
10
11

五、字符串格式化

17、format()

描述： Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。基本语法是通过 {} 和 : 来代替以前的 % 。使用format()来格式化字符串时，使用在字符串中使用{}作为占位符，占位符的内容将引用format()中的参数进行替换。可以是位置参数、命名参数或者兼而有之。

format 函数可以接受不限个参数，位置可以不按顺序。

语法： format(value, format_spec)

参数：

示例：

# 位置参数
'{}:您{}购买的{}到了！请下楼取快递。'.format('快递小哥','淘宝','快递')
'快递小哥:您淘宝购买的快递到了！请下楼取快递。'

#给批量客户发短息
n_list=['马云','马化腾','麻子','小红','李彦宏','二狗子']
for name in n_list:    
	print('{0}：您淘宝购买的快递到了！请下楼取快递！'.format(name))

马云：您淘宝购买的快递到了！请下楼取快递！
马化腾：您淘宝购买的快递到了！请下楼取快递！
麻子：您淘宝购买的快递到了！请下楼取快递！
小红：您淘宝购买的快递到了！请下楼取快递！
李彦宏：您淘宝购买的快递到了！请下楼取快递！
二狗子：您淘宝购买的快递到了！请下楼取快递！

#名字进行填充
for n in n_list:    
	print('{0}：您淘宝购买的快递到了！请下楼取快递！'.format(n.center(3,'*')))
*马云：您淘宝购买的快递到了！请下楼取快递！
马化腾：您淘宝购买的快递到了！请下楼取快递！
*麻子：您淘宝购买的快递到了！请下楼取快递！
*小红：您淘宝购买的快递到了！请下楼取快递！
李彦宏：您淘宝购买的快递到了！请下楼取快递！
二狗子：您淘宝购买的快递到了！请下楼取快递！

'{0}, {1} and {2}'.format('gao','fu','shuai')
'gao, fu and shuai'

x=3
y=5
'{0}+{1}={2}'.format(x,y,x+y)

# 命名参数
'{name1}, {name2} and {name3}'.format(name1='gao', name2='fu', name3='shuai')
'gao, fu and shuai'

# 混合位置参数、命名参数
'{name1}, {0} and {name3}'.format("shuai", name1='fu', name3='gao')
'fu, shuai and gao'

#for循环进行批量处理
["vec_{0}".format(i) for i in range(0,5)]
['vec_0', 'vec_1', 'vec_2', 'vec_3', 'vec_4']

['f_{}'.format(r) for r in list('abcde')]
['f_a', 'f_b', 'f_c', 'f_d']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

18、format_map()

**描述：**返回字符串的格式化版本。在Python3中使用format和format_map方法都可以进行字符串格式化，但format是一种所有情况都能使用的格式化方法，format_map仅使用于字符串格式中可变数据参数来源于字典等映射关系数据时才可以使用。

语法： str.format_map(mapping) -> str 返回字符串

参数： mapping 是一个字典对象

示例：

People = {"name": "john", "age": 33}
"My name is {name},iam{age} old".format_map(People)

#对比案例
定义一个字典
student = {'name':'张三','class':'20200504','score':748}

使用format输出相关信息：
'{st[class]}班{st[name]}总分：{st[score]}'.format(st=student)
'20200504班张三总分：748'

format_map方法后如下
'{class}班{name}总分：{score}'.format_map(student)
'20200504班张三总分：7'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

六、解决判断问题

19、endswith()

**描述：**判断字符串是否以指定字符或子字符串结尾。

语法： str.endswith(“suffix”, start, end) 或str[start,end].endswith(“suffix”) 用于判断字符串中某段字符串是否以指定字符或子字符串结尾。—> bool 返回值为布尔类型（True,False）

参数：

• suffix — 后缀，可以是单个字符，也可以是字符串，还可以是元组（"suffix"中的引号要省略，常用于判断文件类型）。
• start —索引字符串的起始位置。
• end — 索引字符串的结束位置。

注意：空字符的情况。返回值通常为True

示例：

 "I love python".endswith('n')
 
True

"I love python".endswith("python")
True
"I love python".endswith("n",0,6)# 索引 i love 是否以“n”结尾。
False
"I love python".endswith("") #空字符
True
"I love python".endswith(("n","z"))#遍历元组的元素，存在即返回True，否者返回False
True
"I love python".endswith(("k","m"))
False


#元组案例
file = "python.txt"
if file.endswith("txt"):
	print("该文件是文本文件")
elif file.endswith(("AVI","WMV","RM")):    
	print("该文件为视频文件")
else:    
	print("文件格式未知)

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

20、startswith()

**描述：**判断字符串是否以指定字符或子字符串开头。

语法： str.endswith(“suffix”, start, end) 或

str[start,end].endswith(“suffix”) 用于判断字符串中某段字符串是否以指定字符或子字符串结尾。

—> bool 返回值为布尔类型（True,False）

参数：

• suffix — 后缀，可以是单个字符，也可以是字符串，还可以是元组（"suffix"中的引号要省略）。
• start —索引字符串的起始位置。
• end — 索引字符串的结束位置。

注意：空字符的情况。返回值通常也为True

示例：

"hello,i love python".startswith("h")
True
"hello,i love python".startswith("l",2,10)# 索引 llo,i lo 是否以“l”开头。
True
"hello,i love python".startswith("") #空字符
True
"hello,i love python"[0:6].startswith("h") # 只索引  hello,
True
"hello,i love python"[0:6].startswith("e")
False
"hello,i love python"[0:6].startswith("")
True
"hello,i love python".startswith(("h","z"))#遍历元组的元素，存在即返回True，否者返回False
True
"hello,i love python".startswith(("k","m"))
False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

21、isalnum()

**描述：**检测字符串是否由字母和数字组成。str中至少有一个字符且所有字符都是字母或数字则返回 True,否则返回 False

语法： str.isalnum() -> bool 返回值为布尔类型（True,False）

参数：

示例：

"seven-11".isalnum()
False
"seven11".isalnum()
True
"seven".isalnum()
rue
"11".isalnum()
True
1
2
3
4
5
6
7
8

22、isalpha()

**描述：**检测字符串是否只由字母组成。字符串中至少有一个字符且所有字符都是字母则返回 True,否则返回 False。

语法： str.isalpha() -> bool 返回值为布尔类型（True,False）

参数：无

示例：

"I love python".isalpha()#存在空格返回False
False
"Ilovepython".isalpha()
True
"Ilovepython123".isalpha()
False

1
2
3
4
5
6
7

23、isdecimal()

**描述：**检查字符串是否只包含十进制字符。字符串中若只包含十进制字符返回True，否则返回False。该方法只存在于unicode对象中。注意:定义一个十进制字符串，只需要在字符串前添加前缀 ‘u’ 即可。

语法： str.isdecimal() -> bool 返回值为布尔类型（True,False）

参数：无

示例：

"123456".isdecimal()
True
"123456python".isdecimal()
False
1
2
3
4

24、isdigit()

**描述：**检测字符串是否只由数字组成.字符串中至少有一个字符且所有字符都是数字则返回 True,否则返回 False。

语法： str.isdigit() -> bool 返回值为布尔类型（True,False）

参数：无

注：能判断“①”，不能判断中文数字。但 isnumeric() 函数可以。

示例：

"python".isdigit() #全为字母
False
"123".isdigit()  #全为数字
True
"python666".isdigit()   #字母和数字的组合
False
"一二三四五六七".isdigit() #中文数字输出False
False
"①".isdigit()
True
1
2
3
4
5
6
7
8
9
10

25、isidentifier()

**描述：**判断str是否是有效的标识符。str为符合命名规则的变量，保留标识符则返回True,否者返回False。

语法： str.isidentifier() -> bool 返回值为布尔类型（True,False）

**参数：**无

示例：

"123".isidentifier()  #变量名为123
False
"def".isidentifier()  #变量名为保留字
True
"_123".isidentifier()  #变量名有下划线开头
True
"student".isidentifier()#变量名由字母开端
True
1
2
3
4
5
6
7
8

26、islower()

**描述：**检测字符串中的字母是否全由小写字母组成。（字符串中可包含非字母字符）字符串中包含至少一个区分大小写的字符，且所有这些区分大小写的字符都是小写，则返回 True，否则返回 False。

语法： str.islower() -> bool 返回值为布尔类型（True,False）

**参数：**无

示例：

#字符串中的字母全为小写
"i love python".islower()
True

 #字符串中的字母全为小写，也存在非字母的字符
 "我爱python！".islower()
 True
 
 #字符串中有大写字符
 "I love python".islower()
 False

1
2
3
4
5
6
7
8
9
10
11
12

27、isupper()

**描述：**检测字符串中的字母是否全由大写字母组成。（字符串中可包含非字母字符）。字符串中包含至少一个区分大小写的字符，且所有这些区分大小写的字符都是大写，则返回 True，否则返回 False。

语法： str.isupper() -> bool 返回值为布尔类型（True,False）

**参数：**无

示例：

"I LOVE PYTHON".isupper() #全为大写字母
True
"i LOVE PYTHON".isupper()  #存在小写字母
False
"我爱PYTHON".isupper()  #存在非字母的字符
True
1
2
3
4
5
6

28、isnumeric()

**描述：**测字符串是否只由数字组成。这种方法是只适用于unicode对象。字符串中只包含数字字符，则返回 True，否则返回 False。

语法： str.isnumeric() -> bool 返回值为布尔类型（True,False）

**参数：**无

示例：

"123456".isnumeric()  #全为数字
True

"python666".isnumeric()  #字母数字组合
False
"一二三四五六".isnumeric()  #中文数字
True
"①".isnumeric()
True

1
2
3
4
5
6
7
8
9
10

29、isprintable()

**描述：**判断字符串中是否有打印后不可见的内容。如：\n \t 等字符。若字符串中不存在\n \t 等不可见的内容，则返回True,否者返回False。

语法： str.isprintable() -> bool 返回值为布尔类型（True,False）

**参数：**无

示例：

#不存在用print()打印后不可见的内容

"i love  python".isprintable()
True
#存在用print()打印后不可见的内容
\n"i love python \n".isprintable()
False
"i love \t python".isprintable()
False
1
2
3
4
5
6
7

30、isspace()

描述： 检测字符串是否只由空格组成。若字符串中只包含空格，则返回 True，否则返回 False。

语法： str.isspace() -> bool 返回值为布尔类型（True,False）

**参数：**无

示例：

str1 = "   "#空格
str2 = "i love python"
print(str1.isspace())
True
print(str2.isspace())
False
print(str2[1].isspace()) #字符串str2 的第二个字符为空格
True
1
2
3
4
5
6
7
8

31、istitle()

**描述：**检测判断字符串中所有单词的首字母是否为大写，且其它字母是否为小写，字符串中可以存在其它非字母的字符。若字符串中所有单词的首字母为大写，且其它字母为小写，则返回 True，否则返回 False.

语法： str.istitle() -> bool 返回值为布尔类型（True,False）

**参数：**无

示例：

"I Love Python".istitle() #各单词的首字母均为大写，其余字母为小写
True
"I love python".istitle()
False
"I LOVE PYTHON".istitle()
False
"我爱Python".istitle()  #存在其它非字母字符，
True
1
2
3
4
5
6
7
8

七、字符串修剪

32、strip()

**描述：**该函数的作用是去除字符串开头和结尾处指定的字符，不会去除字符串中间对应的字符

语法： str.strip(chars)

参数： chars – 要去除的字符 默认为空格或换行符。

示例：

#默认参数，去除了空格，\n \t \r字符，且未除去字符串中间相应的字符
a = ' \n111 aaa  '
print(a.strip())
111 aaa


#去除两端的指定字符
b='.-.word:我很帅.-.'
print(b.strip('.-.'))
word:我很帅

c='参考：来自公众号AI入门学习'
print(c.strip('参考：'))
来自公众号AI入门学习
1
2
3
4
5
6
7
8
9
10
11
12
13
14

33、lstrip()

描述： lstrip() 方法用于截掉字符串左边的空格或指定字符。

语法： str.lstrip(chars)

参数： chars–要去除的字符 默认为空格或换行符。

示例：

#去除左边指定字符
a = '--我爱Python--'
a.lstrip('--')
'我爱Python--'

#重复的值只需要写一个
a.lstrip('-')
'我爱Python--'
1
2
3
4
5
6
7
8

34、 rstrip()

描述： 删除 str 字符串末尾的指定字符（默认为空格）

语法： str.rstrip(chars)

参数： chars --要去除的字符 默认为空格或换行符。

示例：

#去除右边指定字符
a = '6234412134445533-456'
a.rstrip('-456')
'6234412134445533'

#对一个列表所有的字符串进行去除
ls = ['34667777777-456','62344121344433-456','28993333455-456']
[i.rstrip('-456') for i in ls]
['34667777777', '62344121344433', '28993333']
1
2
3
4
5
6
7
8
9

八、字符串加密解密

35、maketrans()

**描述：**制作翻译表，删除表，常与translate()函数连用。即：返回用于str.translate方法翻译的转换表。

语法： str.maketrans(intab, outtab，delchars)

参数：

• intab – 字符串中要替代的字符组成的字符串。
• outtab – 相应的映射字符的字符串。
• delchars – 可选参数，表示要删除的字符组成的字符串。

示例：

str.maketrans() 生成一个字符一对一映射的table，然后使用 translate(table) 对字符串S中的每个字符进行映射。
例如，现在想要对"I love fairy"做一个简单的加密，将里面部分字符都替换为数字，这样别人就不知道转换后的这句话是什么意思。
in_str  = 'afcxyo'
out_str = '123456'

# maketrans()生成映射表
map_table=str.maketrans(in_str,out_str)

# 使用translate()进行映射
my_love='I love fairy'
my_love.translate(map_table)
'I l6ve 21ir5'

注意maketrans(x, y, z]) 中的x和y都是字符串，且长度必须相等。
如果maketrans(x, y, z]) 给定了第三个参数z，这这个参数字符串中的每个字符都会被映射为None。

#'yo'都会被隐藏了
map_table=str.maketrans(in_str,out_str,'yo')
my_love='I love fairy'
my_love.translate(map_table)
'I lve 21
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

36、translate()

**描述：**过滤(删除)，翻译字符串。即根据maketrans()函数给出的字符映射转换表来转换字符串中的字符。

注：translate()函数是先过滤(删除)，再根据maketrans()函数返回的转换表来翻译。

语法： str.translate(table)

参数：

**示例：**见上述案例

九、分割字符串

37、partition()

**描述：**根据指定的分隔符(sep)将字符串进行分割。从字符串左边开始索引分隔符sep,索引到则停止索引。

语法： str.partition(sep)

参数： sep —— 指定的分隔符。

返回值：(head, sep, tail) 返回一个三元元组，head:分隔符sep前的字符串，sep:分隔符本身，tail:分隔符sep后的字符串。如果字符串包含指定的分隔符sep，则返回一个三元元组，第一个为分隔符sep左边的子字符串，第二个为分隔符sep本身，第三个为分隔符sep右边的子字符串。如果字符串不包含指定的分隔符sep,仍然返回一个三元元组，第一个元素为字符串本身，第二第三个元素为空字符串

示例：

string = 'https://www.google.com.hk/'

string.partition("://") #字符串str中存在sep"://"
('https', '://', 'www.google.com.hk/')

string.partition(",")  #字符串str中不存在sep",",返回了两个空字符串。('https://www.google.com.hk/', '', '')

string.partition(".")  #字符串str中存在两个"." 但索引到www后的"."  停止索引。
('https://www', '.', 'google.com.hk/')

type(string.partition("://")) #返回的是tuple类型
tuple

1
2
3
4
5
6
7
8
9
10
11
12
13

38、rpartition()

**描述：**根据指定的分隔符(sep)将字符串进行分割。从字符串右边(末尾)开始索引分隔符sep,索引到则停止索引。

语法： str.rpartition(sep)

参数： sep —— 指定的分隔符。

返回值： (head, sep, tail) 返回一个三元元组，head:分隔符sep前的字符串，sep:分隔符本身，tail:分隔符sep后的字符串。如果字符串包含指定的分隔符sep，则返回一个三元元组，第一个为分隔符sep左边的子字符串，第二个为分隔符sep本身，第三个为分隔符sep右边的子字符串。如果字符串不包含指定的分隔符sep,仍然返回一个三元元组，第一个元素为字符串本身，第二第三个元素为空字符串。

注：rpartition()函数与partition()函数用法相似，rpartition()函数从右边(末尾)开始索引，partition()函数从左边开始索引。

示例：

string = 'https://www.google.com.hk/'

string.rpartition(".")  #字符串str中不存在sep",",返回了两个空字符串。 ('https://www.google.com', '.', 'hk/')

string.partition(".")  #字符串str中不存在sep",",返回了两个空字符串。
('https://www', '.', 'google.com.hk/')
1
2
3
4
5
6

39、split()

**描述：**拆分字符串。通过指定分隔符sep对字符串进行分割，并返回分割后的字符串列表。

语法： str.split(sep=None, maxsplit=-1) [n]

• sep —— 分隔符，默认为空格,但不能为空即(")。
• maxsplit —— 最大分割参数，默认参数为-1。
• [n] —— 返回列表中下标为n的元素。列表索引的用法。

示例：

#默认空格分割
str1 = "I love python"
str1.split()
['I', 'love', 'python']
#取第三位
str1.split()[2]
'python'

#以"."为分隔符,maxsplit默认为-1
str2 = '列夫·尼古拉耶维奇·托尔斯泰'
str2.split('·')
['列夫', '尼古拉耶维奇', '托尔斯泰']
#以"."为分隔符,只分割一次。
str2.split('·',1) 
['列夫', '尼古拉耶维奇·托尔斯泰]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

40、rsplit()

**描述：**拆分字符串。通过指定分隔符sep对字符串进行分割，并返回分割后的字符串列表,类似于split()函数，只不过 rsplit()函数是从字符串右边(末尾)开始分割。

语法： str.rsplit(sep=None, maxsplit=-1) -> list of strings 返回 字符串列表 或str.rsplit(sep=None, maxsplit=-1)[n]

参数：

• sep —— 分隔符，默认为空格,但不能为空即(")。
• maxsplit —— 最大分割参数，默认参数为-1。
• [n] —— 返回列表中下标为n的元素。列表索引的用法。

示例：

 # 只搜索到一个sep时，两者结果相同
 'abcxyzopq'.partition('xy')
 ('abc', 'xy', 'zopq')
 
'abcxyzopq'.rpartition('xy')
('abc', 'xy', 'zopq')

# 搜索到多个sep时，分别从左第一个、右第一个sep分割
'abcxyzopxyq'.partition('xy')
('abc', 'xy', 'zopxyq')

'abcxyzopxyq'.rpartition('xy') 
('abcxyzop', 'xy', 'q')
1
2
3
4
5
6
7
8
9
10
11
12
13

41、splitlines()

**描述：**按照(’\n’, ‘\r’, \r\n’等)分隔，返回一个包含各行作为元素的列表，默认不包含换行符。\n 换行符 \r 回车符 \r\n 回车+换行

语法： S.splitlines([keepends=False])

参数： keepends – 在输出结果里是否去掉行界符(’\r’, ‘\r\n’, \n’等)，默认为 False，不包含行界符，如果为 True，则保留行界符。

示例：

# 字符串以换行符为分隔符拆分，去掉换行符
'HOW\nSOFT\nWORKS'.splitlines()
['HOW', 'SOFT', 'WORKS']

# 如果keepends为True，保留换行符
'HOW\nSOFT\nWORKS'.splitlines(True)
['HOW\n', 'SOFT\n', 'WORKS']

"123\n456\r789\r\nabc".splitlines()
['123', '456', '789', 'abc']
1
2
3
4
5
6
7
8
9
10

42、join()

**描述：**将iterable变量的每一个元素后增加一个str字符串。

语法： sep.join(iterable)

• sep——分隔符。可以为空。
• iterable—— 要连接的变量 ，可以是 字符串，元组，字典，列表等。

示例：

python中经常看到join，特别是在自然语言处理的时候，分词什么的，但是很多初学者不理解其中的意思，这里进行详细的介绍，希望对大家能有帮助。将可迭代对象(iterable)中的字符串使用string连接起来。注意，iterable中必须全部是字符串类型，否则报错。如果你还是python的初学者，还不知道iterable是什么，却想来看看join的具体语法，那么你可以暂时将它理解为：字符串string、列表list、元组tuple、字典dict、集合set。当然还有生成器generator等也可以用该方法。
1）字符串
L='python'
'_'.join(L)
'p_y_t_h_o_n'
'_uu_'.join(L)
'p_uu_y_uu_t_uu_h_uu_o_uu_n'

2）元组
L1=('1','2','3')
'_'.join(L1)
'1_2_3'

3）集合。注意，集合无序。
L2={'p','y','t','h','o','n'}
'_'.join(L2)
't_n_o_h_y_p'

4）列表
L2=['py','th','o','n']
'_'.join(L2)
'py_th_o_n'

5）字典
L3={'name':"malongshuai",'gender':'male','from':'China','age':18}
'_'.join(L3)
'name_gender_from_age'

6）iterable参与迭代的部分必须是字符串类型，不能包含数字或其他类型。
L1=(1,2,3)
'_'.join(L1)
TypeError: sequence item 0: expected str instance, int found

以下两种也不能join。
L1=('ab',2)
L2=('AB',{'a','cd'})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

九、字符串替换

43、replace()函数

**描述：**把str.中的 old 替换成 new,如果 count 指定，则替换不超过 count次.。

语法： str.replace(old, new, count)

参数：

• old —— 将被替换的子字符串。
• new —— 新子字符串，用于替换old子字符串。
• count —— 替换的次数，默认全部替换。

案例：

s = "我的小伙伴张三"
s.replace("张三","马云")
'我的小伙伴马云'

s = "I love python"
#默认字符串中的全部"o" 全部替换为"w"
s.replace("o","w")
'I lwve pythwn'

#只替换一个"o"
s.replace("o","w",1)
'I lwve python'

#子字符串可以是多个字符。
s.replace("python","java")
'I love java'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

44、expandtabs()

**描述：**将字符串S中的 \t 替换为一定数量的空格。默认N=8。

语法： str.expandtabs(tabsize=8)

tabsize 的默认值为8。tabsize值为0到7等效于tabsize=8。tabsize每增加1，原字符串中“\t”的空间会多加一个空格。

示例：

'01\t012\t0123\t01234'.expandtabs(4)
'01  012 0123    01234'

'01\t012\t0123\t01234'.expandtabs(8)
'01      012     0123    01234'
1
2
3
4
5

十、统计字符次数

45、count()

**描述：**统计字符串里某个字符出现的次数。可以选择字符串索引的起始位置和结束位置。

语法： str.count(“char”, start,end) 或 str.count(“char”)

• str —— 为要统计的字符(可以是单字符，也可以是多字符)。
• star —— 为索引字符串的起始位置，默认参数为0。
• end —— 为索引字符串的结束位置，默认参数为字符串长度即len(str)。

示例：

'abc--qo-ab'.count('ab')
2
#从第二位开始查找
'abc--qo-ab'.count('ab',1)
1
#不包括边界
'abc--qo-ab'.count('ab',1,9)
0
1
2
3
4
5
6
7
8

---

List（列表）

Python 中的数据结构是通过某种方式组织在一起的数据元素的集合，这些数据元素可以是数字、字符、甚至可以是其他数据结构 在 Python 中，最基本的数据结构是序列（列表和元组），序列中的每个元素都有一个序号（元素的具体位置），这个序号叫索引，索引下标从0开始，以此类推…

列表是写在方括号 [] 之间、用逗号分隔开的元素列表，列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套），列表中的元素是可以改变。

• 列表俗称是 Python 中的苦力，列表可变（可以改变列表的内容）
• 列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
• 列表的数据项不需要具有相同的类型 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。

示例：

list1 = ['baidu', 'google', 12, 34];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

Weekday = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(Weekday[0])   # 输出 Monday

#list 搜索
print(Weekday.index("Wednesday"))

#list 增加元素
Weekday.append("new")
print(Weekday)

# list 删除
Weekday.remove("Thursday")
print(Weekday)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

列表的遍历

list = ["a","b","c"]
for i in list:
    print(i)
    

for index in range(0,3):
    print(list[index])
    list[index] = list[index]+'_new' # 每一个元素末尾加上 _new
    list.append('d')  # 在列表末尾添加'd'
print(list)


1
2
3
4
5
6
7
8
9
10
11
12

1. 列表函数

1.1 list 函数

如果对字符串赋值后想要改变字符串中的某个值，因为字符串不能像列表一样可更改，如果想改变这时候可以利用 list 函数，如下：

>>> ll=list('hello')
>>> ll
['h', 'e', 'l', 'l', 'o']
>>> ll[2]
'l'
>>> ll[2]='5'
>>> ll
['h', 'e', '5', 'l', 'o']
1
2
3
4
5
6
7
8

注意：list 函数适用于所有类型的序列，而不只是字符串

1.2 len 函数

len 函数返回列表中的元素个数

>>> list1 = ['baidu', 'google', 12, 23];
>>> len(list1)
4
1
2
3

1.3 max 函数

max 函数返回列表元素最大值

>>> list_num=[2,3,5,6,8,12]
>>> max(list_num)
12
1
2
3

1.4 min 函数

返回列表元素最小值

>>> list_num=[2,3,5,6,8,12]
>>> min(list_num)
2
1
2
3

2 列表方法

列表提供了几个详细的方法，这些方法用于检查或者修改列表中的内容

2.1 append

append 方法用于在列表的末尾追加新的内容

list_append = [1,2,3,4]
list_append.append(5)
list_append
>>> [1, 2, 3, 4, 5]
1
2
3
4

2.2 count

count 方法用于统计某个元素在列表中出现的次数

num=[1, 2, 3, 4, 5, 5, 5, 5, 6]
# 统计num列表中5出现的次数
num.count(5)
4

# 统计字母a出现的次数
name=['a','a','abf','ark','nhk']
name.count('a')
>>> 2
1
2
3
4
5
6
7
8
9

2.3 extend

extend 方法表示追加内容，它可以在列表的末尾一次性追加另一个序列中的多个值，也就是用新列表扩展原有列表

a =[1,2,3]
b = [4,5,6]
# 将列表b追加在列表a后面
a.extend(b)
a
>>> [1, 2, 3, 4, 5, 6]
1
2
3
4
5
6

此操作和列表的相加操作，但是追加操作改变原有列表，而相加不改变原有列表，例如：

a = [1,2,3]
b = [4,5,6]
a + b
>>> [1, 2, 3, 4, 5, 6]
# 连接操作不改变原有列表
a
>>> [1, 2, 3]
1
2
3
4
5
6
7

2.4 index

index 方法用于从列表中找出某个元素第一次匹配的位置的索引位置

content = ['where','who','lisi','cntent','who']
content.index('who')
>>> 1
1
2
3

注意： 以上方法中有两个位置有‘who’,但是只找出了第一次匹配的索引位置元素

2.5 insert

insert 方法用于像列表中插入对象

num = [1,2,5,6,7]
num.insert(2,3)
num
>>> [1, 2, 3, 5, 6, 7]

num.insert(3,4)
num
>>> [1, 2, 3, 4, 5, 6, 7]
1
2
3
4
5
6
7
8

2.6 pop

pop 方法会移除列表中的一个元素（默认是最后一个），并且返回该元素的值

x = [1,2,3]
x.pop()
>>> 3

x[1, 2]
x.pop()
>>> 2

x
>>> [1]
1
2
3
4
5
6
7
8
9
10

**注意：**pop 方法是唯一一个既能修改列表又能返回元素值的方法（除了None）,pop 和 append 方法是 Python 中数据结构的出栈和入栈，如果追加（append）刚刚出栈（pop）的值，得到的还是原来的列表

x = [1,2,3]
x.append(x.pop())
x
>>> [1, 2, 3]
1
2
3
4

2.7 remove

remove 方法用于移除列表中第一个匹配的元素

content = ['where', 'who', 'lisi', 'cntent', 'who', 'who']
# 移除了第一个匹配的元素
content.remove('who')
content
>>> ['where', 'lisi', 'cntent', 'who', 'who']
1
2
3
4
5

2.8 reverse

reverse 方法是将列表中的元素进行反转操作

x=[1, 2, 3]
# 元素反向存储
x.reverse()
x
>>> [3, 2, 1]
1
2
3
4
5

2.9 sort

sort 方法用于在原位置排序，‘原位置排序’意味着改变原来的列表而让列表中的元素有顺序排列

x = [2,3,5,6,1,4,7]
x.sort()
x
>>> [1, 2, 3, 4, 5, 6, 7]
1
2
3
4

2.10 clear

clear 方法用于清空列表

list1=['baidu', 'google', 12, 23]
list1
>>> ['baidu', 'google', 12, 23]
#　清空列表内容
list1.clear()
list1
>>> []
1
2
3
4
5
6
7

2.11 copy

copy 方法是复制列表

list1 = ['baidu', 'google', 12, 23]
list1.copy()
>>> ['baidu', 'google', 12, 23]

list2 = list1.copy()
list2
>>> ['baidu', 'google', 12, 23]
1
2
3
4
5
6
7

3. 列表基本操作

列表可以使用所有适用于序列的标准操作，比如第7天所学的索引、分片、连接和相乘，更有趣的是，列表是可以修改的，也就是定义的列表内容可以根据需求更改，本节介绍一些改变列表的方法：如元素赋值、元素删除、分片赋值以及列表方法（但是请注意，并不是所有的列表方法都能真正改变列表）

3.1 改变列表：元素赋值

在列表中要给指定的元素赋值时，我们需要指定特定的索引标记来为列表中某个特定的，位置明确的元素赋值，比如 x[3]=5

x=[1,2,3,4,5]
x
>>> [1, 2, 3, 4, 5]
# 改变列表第四个元素的内容
x[3]=5
x
>>> [1, 2, 3, 5, 5]
1
2
3
4
5
6
7

注意： 不能为一个位置不存在的元素赋值，如果列表长度为2，则不能为索引为10 的元素进行赋值，如果需要赋值则需要创建一个长度为11的列表。

3.2 删除列表元素

若要删除列表中的元素，直接利用del删除即可

# 定义长度为4的姓名列表
names=['zhangsan','lisi','wangwu','zhaoliu']
names
>>> ['zhangsan', 'lisi', 'wangwu', 'zhaoliu']

# 删除第三个元素
del names[2]

# 最后列表长度由4变为3
names
>>> ['zhangsan', 'lisi', 'zhaoliu']
1
2
3
4
5
6
7
8
9
10
11

del 语句还能用于删除其他元素，也可以用于变量的删除操作。

3.3 切片赋值

切片

切片： 变量的名字[start: end: step]

​ start的默认值是按照step方向上的第一个元素

​ end的默认值是按照step的方向上的最后一个元素

​ step的默认值是1

>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
>>> L[0:3]   # 取L前三个元素
['Michael', 'Sarah', 'Tracy']
# L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。
# 如果第一个索引是0，还可以省略：
>>> L[:3]
['Michael', 'Sarah', 'Tracy']
>>> L[1:3]
['Sarah', 'Tracy']
# 支持倒数切片，L[-1]取倒数第一个元素
>>> L[-2:]
['Bob', 'Jack']
>>> L[-2:-1]
['Bob']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在 Python 中对序列或者列表的切片操作是一个很强大的特性，切片赋值会显得更加强大，例如：

# 定义一个list
name = list('Pyther')

# 改变 list 中的最后两个值
name[4:]='on'
name
>>> ['P', 'y', 't', 'h', 'o', 'n']
1
2
3
4
5
6
7

从上可知，程序可以一次为多个元素赋值，在切片赋值时，可以使用与原序列不等长的序列将切片替换，例如：

name_re = list('perl')
name_re
>>> ['p', 'e', 'r', 'l']
# 切片替换
name_re[1:] = list('ython')
name_re
>>> ['p', 'y', 't', 'h', 'o', 'n']
1
2
3
4
5
6
7

切片赋值还可以在不需要更改原有列表任何内容的情况下进行新元素插入

num = [1,4,5]
# 在第一个元素后插入新的元素
num[1:1]=[2,3]
num
>>> [1, 2, 3, 4, 5]
1
2
3
4
5

同理也可以通过切片操作来删除列表中的元素，同样也支持负数切片操作

num=[1, 2, 3, 4, 5]
# 给第一个和第三个元素之间切片赋值一个空序列，即删除元素
num[1:3] = []
num
>>> [1, 4, 5]

# 负数切片操作
num[-1:-1] = [5,5,5]
num
>>> [1, 2, 3, 4, 5, 5, 5, 5, 6]
1
2
3
4
5
6
7
8
9
10

---

Tuple（元组）

元组（tuple）与列表类似（戴了枷锁的列表），不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开，组中的元素类型也可以不相同。

• Python 的元组与列表类似，不同之处在于元组的元素不能修改。
• 元组使用小括号()，列表使用方括号[]。

示例：

letters = ('a','b','c','d','e','f','g')
print(letters[0])  # 输出 'a'
print(letters[0:3])  # 输出一组 ('a', 'b', 'c')
1
2
3

1. 元组基本操作

1.1 创建元组

元组创建很简单，只需要在括号中添加元素(不需要括号也可以)，并使用逗号隔开即可。

>>> tup1 = ('baidu', 'google', 12, 34); 
>>> tup2 = (1, 2, 3, 4, 5 );
>>> tup3 = "a", "b", "c", "d";

# 创建空元组
>>> tup4 = ()

# 查看tup4和tup3的类型
>>> type(tup4)
<class 'tuple'>
>>> type(tup3)
<class 'tuple'>
1
2
3
4
5
6
7
8
9
10
11
12

注意： 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用，如下：

>>> TupNum = (34)   
>>> type(TupNum)   # 不加逗号是整型
<class 'int'>
>>> TupNum = (34,)
>>> type(TupNum)  # 加上逗号变元组
<class 'tuple'>
1
2
3
4
5
6

元组与字符串类似，下标索引从 0 开始，可以对元组进行截取，组合等操作。

1.2 访问元组

元组的访问和序列访问元素一样，都是通过下标索引进行访问操作

>>> tup1 = ('baidu', 'google',1,2)
>>> tup2 = (1, 2, 3, 4, 5, 6, 7)
>>> tup1[0:2]
('baidu', 'google')
>>> tup2[1:4]
(2, 3, 4)
1
2
3
4
5
6

1.3 修改元组

元组中的值一旦定义就不能修改，但是我们可以通过元组与元组之间的连接关系来对元组进行修改，例如：

>>> tup1 = ('baidu', 'google',1,2)
>>> tup2 = (1, 2, 3, 4, 5, 6, 7)
>>> tup1 + tup2
('baidu', 'google', 1, 2, 1, 2, 3, 4, 5, 6, 7)
1
2
3
4

注意： 以下修改元组属于非法操作，因为元组不支持通过索引列来修改，只能对元组进行复制和连接操作

tup1[0] = 100 （不能进行此操作）

1.4 删除元组

由于元组的不可修改性，所以元组中的元素值是不允许删除的，但我们可以使用 del 语句来删除整个元组，如下实例:

#!/usr/bin/python3 
tup1 = ('baidu', 'google',1,2) 

print (tup)
del tup;
print ("删除后的元组 tup : ")
print (tup)

# 报错信息如下，证明整个元组已经被删除
删除后的元组 tup1 : 
Traceback (most recent call last):  
  File "tupple.py", line 29, in <module>    
	print(tup1)
NameError: name 'tup1' is not defined
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2 元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。总而言之对整个元组进行一些运算后就会生成一个新的元组。

2.1 元组求长度

元组求长度使用运算函数 len ，如下

# 求元组tup1的长度
>>> tup1 = ('baidu', 'google',1,2)
>>> len(tup1)
4
1
2
3
4

2.2 连接元组

两个甚至对个元组的连接使用 + 连接符，例如：

>>> tup1 = (1,2,3)
>>> tup2 = (4,5,6)
>>> tup3 = (7,8,9)
>>> tup1 + tup2 + tup3
(1, 2, 3, 4, 5, 6, 7, 8, 9)
1
2
3
4
5

2.3 复制元组

tup1 = ('abc')
# 元组复制需要加上分隔符后面复制的内容就按照分隔符分隔开
(tup1,) * 3
('abc', 'abc', 'abc')
1
2
3
4

2.4 判断元素

判断元组中元素是否存在使用关键字 in 进行判断，判断结果返回布尔值

>>> tup1
'abc'
>>> 'a' in tup1
True
1
2
3
4

2.5 元组中指定位置元素访问

和序列一样，元组中的元素同样可以使用索引号访问指定位置的元素，例如：

>>> content = ('hello','world','!')
>>> content
('hello', 'world', '!')
>>> content[1:]
('world', '!')
>>> content[:2]
('hello', 'world')
>>> content[-1]
'!'
>>> content[-2]
'world'
1
2
3
4
5
6
7
8
9
10
11

3 元组内置函数

和列表一样，元组同样也拥有一些内置函数，这些函数用于判元组中的元素大小以及将元组做相应的转换

#计算元组元素个数。
len(tuple)
#返回元组中元素最大值。
max(tuple)
#返回元组中元素最小值。	
min(tuple)	
#将列表转换为元组。	
tuple(list)
1
2
3
4
5
6
7
8

---

Set（集合）

Python也包含有 集合 类型。集合是由不重复元素组成的无序的集。它的基本用法包括成员检测和消除重复元素。集合对象也支持像 并集，交集，差集，对称差分等数学运算。
集合：特殊的字典，相当于字典中的key

集合（set）是一个无序不重复元素的序列，使用大括号 {} 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 {} ，因为 {} 是用来创建一个空字典。

集合不能被切片也不能被索引，除了做集合运算之外，集合元素可以被添加还有删除：

示例：

集合结构如下：

set1 = {'hello', 'hello', 'word', 'word'}
set1
#　输出结果实现自动去重
{'hello', 'word'}
1
2
3
4

a_set = {1,2,3,4}
# 添加
a_set.add(5)
print(a_set)  # 输出{1, 2, 3, 4, 5}
# 删除
a_set.discard(5)
print(a_set)  # 输出{1, 2, 3, 4}
1
2
3
4
5
6
7

# 可以用来去除重复
>>> list = [1,2,3,4,1,2,4,3,5,6]
>>> print(set(list))
[1,2,3,4,5,6]

# 如果使用流程控制解决重复问题
list = [1,2,3,4,1,2,4,3,5,6]
new_list = []
for i in list:
    if i not in new_list:
        new_list.append(i)
1
2
3
4
5
6
7
8
9
10
11

1、集合创建

可以使用大括号 { } 或者 set() 函数创建集合，

创建格式：

parame = {value01,value02,...}或者set(value)
1

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

# 创建空集合
>>> empty_set = set()
>>> type(empty_set)  
<class 'set'>
# 创建空字典
>>> empty_dict = {}
>>> type(empty_dict)  
<class 'dict'>
1
2
3
4
5
6
7
8

2、集合的基本操作

2.1 添加元素

语法格式：

s.add(x)
1

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

s = set(('hello','world'))
print(s)
# 向集合 s 中添加元素
s.add('!')
print('添加元素后的集合是：%s' % s)
# 输出结果是：
添加元素后的集合是：{'world', '!', 'hello'}
1
2
3
4
5
6
7

除了 add() 方法可以添加元素外，还有一个方法，也可以添加元素，并且参数可以是列表，元组，字典等，语法格式如下：

s.update( x )
1

参数 x 可以是一个，也可以是多个，多个参数之间用逗号相隔

#　1）添加列表
s.update([1,3],[2,4])
print('添加元素后的集合是：%s' % s)

# 2）添加元组
s.update(('h', 'j'))
print('添加元素后的集合是：%s' % s)
1
2
3
4
5
6
7

2.2 移除元素

语法格式：

s.remove( x )
1

将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

# 将元素 2 从集合中移除
s.remove(2)
print('移除元素 2 后的集合是：%s' % s)

# 如果移除集合中不存在的元素会报异常
# 移除集合中不存在的集合
s.remove('hi')
print('移除元素后的集合是：%s' % s)
#　异常信息
Traceback (most recent call last):  
    File "test.py", line 20, in <module>  
    s.remove('hi')  KeyError: 'hi'
1
2
3
4
5
6
7
8
9
10
11
12

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

s.discard( x )
1

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  
# 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}
1
2
3
4
5

我们也可以设置随机删除集合中的一个元素，语法格式如下：

s.pop()
1

# 随机删除集合中的一个元素
s = {1, 3, 4, 'world', '!', 'hello', 'h', 'j'}
print(s)
s.pop()
print('移除元素后的集合是：%s' % s)
# 输出结果：{1, 3, 4, 'world', '!', 'hello', 'h', 'j'}
# 移除元素后的集合是：{3, 4, 'world', '!', 'hello', 'h', 'j'}
1
2
3
4
5
6
7

注意：在交互模式，pop 是删除集合的第一个元素（排序后的集合的第一个元素）。

2.3 计算集合元素个数

语法格式：

len(s)
1

计算集合 s 元素个数。

print('集合 s 的长度是：%s' % len(s))
# 输出结果
集合 s 的长度是：7
1
2
3

2.4 清空集合

语法格式：

s.clear()
1

清空集合 s

s.clear()
print('集合清空后的结果是：%s' % s)
# 输出结果：
集合清空后的结果是：set()
1
2
3
4

2.5 判断元素是否存在

语法格式：

x in s
1

判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

# 判断元素是否存在
s = {'hello',  'word'}
# 判断元素 hello 是否在集合 s 中
print(hello' in s)
# 输出结果：True
1
2
3
4
5

2.6 集合运算

集合之间的运算符分别是‘-’、‘|’、‘&’、‘^’ ; 下面以两个集合之间的运算为例进行讲解：

• ‘-’：代表前者中包含后者中不包含的元素
• ‘|’：代表两者中全部元素聚在一起去重后的结果
• ‘&’：两者中都包含的元素
• ‘^’：不同时包含于两个集合中的元素

>>> a = set('afqwbracadaagfgbrafg')
>>> b = set('rfgfgfalacazamddg')
>>> a                                  
{'r', 'q', 'd', 'b', 'w', 'g', 'f', 'c', 'a'}
>>> b
{'r', 'd', 'g', 'f', 'l', 'z', 'c', 'm', 'a'}

# 集合a中包含而集合b中不包含的元素
>>> a - b                              
{'b', 'w', 'q'} 

# 集合a或b中包含的所有元素
>>> a | b                             
{'d', 'g', 'l', 'c', 'r', 'q', 'b', 'w', 'f', 'z', 'm', 'a'}

# 集合a和b中都包含了的元素
>>> a & b                              
{'r', 'd', 'g', 'f', 'c', 'a'}

# 不同时包含于a和b的元素
>>> a ^ b                              
{'l', 'q', 'b', 'w', 'z', 'm'}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3、集合推导式

和列表一样，集合也支持推导式

# 判断元素是否存在
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
1
2
3
4

4、集合内置方法

4.1 difference()

difference() 方法用于返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中，返回一个新的集合。

difference() 方法语法：

set.difference(set)
1

实例： 两个集合的差集返回一个集合，元素包含在集合 x ，但不在集合 y ：

# 求两个集合的差集，元素在 x 中不在 y 中
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
z = x.difference(y)
print('两个集合的差集是：%s' % z)
# 输出结果为：{'cherry', 'banana'}
1
2
3
4
5
6

4.2 difference_update()

• difference_update() 方法用于移除两个集合中都存在的元素。
• difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合，而 difference_update() 方法是直接在原来的集合中移除元素，没有返回值。

x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
x.difference_update(y)
print(x)
# 结果为：{'banana', 'cherry'}

x1 = {1,2,3,4}
y1 = {1,2,3}
x1.difference_update(y1)
print(x1)
# 结果为：{4}
1
2
3
4
5
6
7
8
9
10
11

4.3 intersection()

intersection() 方法用于返回两个或更多集合中都包含的元素，即交集，返回一个新的集合。

intersection() 方法语法：

set.intersection(set1, set2 ... etc)
# 参数：set1 -- 必需，要查找相同元素的集合
# set2 -- 可选，其他要查找相同元素的集合，可以多个，多个使用逗号 , 隔开
1
2
3

实例：

# 返回两个或者多个集合的交集
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.intersection(y)
print(z) # {"apple"}

#　返回三个集合的交集
x = {"a", "b", "c"}
y = {"c", "d", "e"}
z = {"f", "g", "c"}
result = x.intersection(y, z)
print('三个集合的交集是：%s' % result)
# 三个集合的交集是：{'c'}
1
2
3
4
5
6
7
8
9
10
11
12
13

4.4 intersection_update()

• intersection_update() 方法用于获取两个或更多集合中都重叠的元素，即计算交集。
• intersection_update() 方法不同于 intersection() 方法，因为 intersection() 方法是返回一个新的集合，而 intersection_update() 方法是在原始的集合上移除不重叠的元素。

intersection_update() 方法语法：

set.intersection_update(set1, set2 ... etc)
# 参数 set1 -- 必需，要查找相同元素的集合
# set2 -- 可选，其他要查找相同元素的集合，可以使用多个多个，多个使用逗号‘,’ 隔开
1
2
3

实例：

# 返回一个无返回值的集合交集
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
x.intersection_update(y)
print(x) # {'apple'}

x = {"a", "b", "c"}
y = {"c", "d", "e"}
z = {"f", "g", "c"}
x.intersection_update(y, z)
print(x) # {'c'}

1
2
3
4
5
6
7
8
9
10
11
12

4.5 union()

union() 方法返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次，返回值返回一个新的集合

语法：

union() 方法语法：set.union(set1, set2...)
# 参数set1 -- 必需，合并的目标集合
# set2 -- 可选，其他要合并的集合，可以多个，多个使用逗号 , 隔开。
1
2
3

实例：

# 合并两个集合，重复元素只会出现一次：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"} 
z = x.union(y)  
print(z)
# 输出结果为：{'cherry', 'runoob', 'google', 'banana', 'apple'}

# 合并多个集合：
x = {"a", "b", "c"}
y = {"f", "d", "a"}
z = {"c", "d", "e"} 
result = x.union(y, z)  
print(result)
# 输出结果为：{'c', 'd', 'f', 'e', 'b', 'a'}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4.6 isdisjoint()

isdisjoint() 方法用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。

语法：

isdisjoint() 方法语法：set.isdisjoint(set)
1

实例：

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
#　判断集合 y 中是否包含集合 x 中的元素，如果没有返回 True, 有则返回 False
z = x.isdisjoint(y)
print(z) # False
# 结果返回 False,说明集合 y 中有和 x 中相同的元素


x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "baidu"}
#　判断集合 y 中是否包含集合 x 中的元素，如果没有返回 True, 有则返回 False
z = x.isdisjoint(y)
print(z) # True
# 结果返回 True,说明集合 y 中没有和 x 中相同的元素


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

4.7 issubset()

issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False。

语法:

issubset() 方法语法：set.issubset(set)
参数set -- 必需，要比查找的集合返回值返回布尔值，如果都包含返回 True，否则返回 False。
1
2

实例:

# 判断集合 x 的所有元素是否都包含在集合 y 中：
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b", "a"} 
z = x.issubset(y)  
print(z)  # True
# 说明 集合 x 中的元素都包含在 y 中
1
2
3
4
5
6

注意：必须是集合中的元素都包含在内，否则结果为false

#　集合 y 中只有元素 b 和 c ，执行结果为False 
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b","y"}
z = x.issubset(y)
print(z) # False

1
2
3
4
5
6

4.8 issuperset()

issuperset() 方法用于判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False。

语法：

set.issuperset(set)
1

实例：

# 判断集合 y 的所有元素是否都包含在集合 x 中：
x = {"f", "e", "d", "c", "b", "a"}
y = {"a", "b", "c"} 
z = x.issuperset(y)  
print(z)  # 输出结果为：True

# 如果没有全部包含返回 False：
x = {"f", "e", "d", "c", "b"}
y = {"a", "b", "c"} 
z = x.issuperset(y)  
print(z)  # 输出结果为：False
1
2
3
4
5
6
7
8
9
10
11

4.9 symmetric_difference()

symmetric_difference() 方法返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素，结果返回一个新的集合。

语法：

set.symmetric_difference(set)
1

实例：

# 返回两个集合组成的新集合，但会移除两个集合的重复元素：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.symmetric_difference(y)
print(z)
# 输出结果：{'banana', 'google', 'cherry', 'runoob'}
1
2
3
4
5
6

4.10 symmetric_difference_update()

symmetric_difference_update() 方法移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

语法：

set.symmetric_difference_update(set)
1

实例：

# 在原始集合 x 中移除与 y 集合中的重复元素，并将不重复的元素插入到集合 x 中：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
x.symmetric_difference_update(y)
print(x)
# 输出结果：{'runoob', 'cherry', 'banana', 'google'}
1
2
3
4
5
6

Dictionary（字典）

Python 中的字典提供了一种灵活的访问和组织数据的方式
字典是一种映射类型，它的元素是键值对，字典的关键字必须为不可变类型，且不能重复。创建空字典使用 {} 。

• 字典是由很多值组成的集合
• 字典的索引可以是不同的数据类型，同样也不止是整数，也有字符串
• 字典的索引被称为“键”，键及键所关联的值叫键值对（类似于Java中的Map集合）
• 字典是另一种可变容器模型，且可存储任意类型对象。
• 字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

示例：

Logo_code = { 'BIDU':'Baidu', 'SINA':'Sina', 'YOKU':'Youku' }
print(Logo_code)
# 输出{'BIDU': 'Baidu', 'YOKU': 'Youku', 'SINA': 'Sina'}
print (Logo_code['SINA'])       # 输出键为 'one' 的值
print (Logo_code.keys())   # 输出所有键
print (Logo_code.values()) # 输出所有值
print (len(Logo_code))  # 输出字段长度
1
2
3
4
5
6
7

字典的遍历

# 可以使用keys() values() items()
d = {1:'a',2:'b',3:'c'}
for k,v in d.items():
    print(k,v)
1
2
3
4

dictionary  = {'url1':'baidu', 'url':'google', 'num1':12, 'num2':34};
1

键一般是唯一的，如果键重复，最后的一个键值对会替换前面的键值对，值没有唯一性要求，如下：

dic1 ={'name':'zhangsan','age':23,'address':'BeiJing','name':'lisi'}
# 查看字典值发现重复的键值后面的替换前面的
>>> dic1
{'name': 'lisi', 'age': 23, 'address': 'BeiJing'}

>>> dic1['name']
'lisi'
1
2
3
4
5
6
7

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组，如下：

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258',('a','b'):(12,43)}
1

1. 访问字典数据

创建一个字典，并访问数据字典内容，以下字典的键是‘size’,‘color’,‘character’,这些键对应的值是‘big’,‘white’,‘gentle’,访问字典的值通过方括号里面添加键就可以直接进行访问，例如：

MyDog = {'size':'big','color':'white','character':'gentle'}
# 字典值通过[‘键’]来访问
print(MyDog['size']) 
big   #输出结果

print('My Dog has '+MyDog['color']+' fur.' + ' and it has a ' + MyDog['character']+' character')
My Dog has white fur. and it has a gentle character #输出结果
1
2
3
4
5
6
7

同样的，字典也可以用整数作为键，和列表的索引类似，只是字典的值是任何整数类型都行，不必要从0开始，因为键值的数据类型是任意的，如下：

MyCon = {12:'big',0:'white',354:'gentle',1:'good'}
# 访问键为 12 的字典值
>>> MyCon[12]
'big'

# 访问键为 0 的字典值
>>> MyCon[0]
'white'
1
2
3
4
5
6
7
8

因为字典是不排序的，所以不能像列表那样切片。如果访问字典中不存在的键，将导致 KeyError 出错信息。这很像列表的“越界” IndexError 出错信息。在交互式环境中输入以下代码，并注意显示的出错信息，因 为没有’color’键：

dic1 = {'name':'zhangsan','age':23,'address':'BeiJing'}
#找字典中键为 'color' 的值
dic1['color']
Traceback (most recent call last):  
    File "<input>", line 1, in <module>KeyError: 'color'
1
2
3
4
5

2、修改字典元素

2.1 添加和更新字典数据

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

dict = {'Name': 'Fiona', 'Age': 10, 'Class': 'Three'}
# 更新
dict['Age'] = 8 
# 添加
dict['School'] = "Middle School" 
# 查看字典数据 
dict
{'Name': 'Fiona', 'Age': 8, 'Class': 'Three', 'School': 'Middle School'}
1
2
3
4
5
6
7
8

2.2 删除字典元素

对字典元素的删除操作能单一删除也能将整个字典清空，显示的删除一个字典使用 del 命令“

dict = {'Name': 'Fiona', 'Age': 10, 'Class': 'Three'}
# 删除键是'Name'的条目 
del dict['Name']  
# 清空字典所有条目
dict.clear()  
# 删除整个字典元素del dict           
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])
1
2
3
4
5
6
7
8

以上打印语句这会引发一个异常，因为用 del 后的字典不再存在：

Traceback (most recent call last): 
    File "test.py", line 12, in <module>    
    print("dict['Age']: ", dict['Age'])
    TypeError: 'type' object is not subscriptable
1
2
3
4

3、字典键的特性

字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

实例

dict = {'Name': 'Fiona', 'Age': 10, 'Name': 'Manni'}  
print ("dict['Name']: ", dict['Name'])
# 以上实例输出结果：dict['Name']:  Manni
1
2
3

2）键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，如下实例：

dict = {['Name']: 'Fiona', 'Age': 10}  
print ("dict['Name']: ", dict['Name'])
# 以上实例输出结果：
Traceback (most recent call last): 
    File "test.py", line 3, in <module>    
    dict = {['Name']: 'Zara', 'Age': 7} 
    TypeError: list objects are unhashable
1
2
3
4
5
6
7

4、字典的函数

4.1 len()

len() 方法计算字典元素个数（键的总个数）

>>> dict = {'Name': 'Fiona', 'Age': 10, 'class': 'Three'}  
>>> len(dict)     
3
1
2
3

4.2 str()

str() 方法输出字典中可以打印的字符串标识

>>> dict = {'Name': 'Runoob', 'Age': 10, 'Class': 'Three'}
>>> str(dict)
"{'Name': 'Runoob', 'Age': 10, 'Class': 'Three'}"
1
2
3

4.3 type()

type() 方法返回输入的变量类型，如果变量是字典就返回字典类型

>>> dict = {'Name': 'Runoob', 'Age': 10, 'Class': 'Three'}
>>> type(dict)
<class 'dict'>
1
2
3

5、字典的方法

5.1 dict.clear()

删除字典内所有元素，clear() 方法没有任何返回值,实例如下：

dict = {'Name': 'Fiona', 'Age': 10}
print ("字典长度 : %d" %  len(dict))
dict.clear()
print ("字典删除后长度 : %d" %  len(dict))
# 输出结果为：字典长度 : 2字典删除后长度 : 0
1
2
3
4
5

5.2 dict.copy()

copy() 方法对字典进行复制

浅拷贝与深拷贝的区别

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict11 = dict.copy()
print("新复制的字典为 : ", dict11) # {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict1 = {'user': 'runoob', 'num': [1, 2, 3]}
# 浅拷贝: 引用对象  赋值
dict2 = dict1  
print("dict2",dict2)  # dict2 {'user': 'runoob', 'num': [1, 2, 3]}
# 深拷贝
dict3 = dict1.copy()  
print("dict3",dict3)  # dict3 {'user': 'runoob', 'num': [1, 2, 3]}
# 修改 data 数据
dict1['user'] = 'root'
dict1['num'].remove(1)
# 输出结果
print(dict1) # {'user': 'root', 'num': [2, 3]}
print(dict2)  # {'user': 'root', 'num': [2, 3]}
print(dict3)  # {'user': 'runoob', 'num': [2, 3]}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

实例中 dict2 其实是 dict1 的引用，即别名，所以输出结果都是一致的，dict3 对父对象进行了深拷贝，深拷贝不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改，即赋值会随父对象的修改而修改，拷贝不会随父对象的修改而修改。

5.3 dict.fromkeys()

创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值，该方法返回一个新的字典

fromkeys() 方法语法

dict.fromkeys(seq[, value])
# 参数seq -- 字典键值列表。
# value -- 可选参数, 设置键序列（seq）对应的值，默认为 None。
1
2
3

实例：

# dict.fromkeys(seq[, value])
seq = ('name', 'age', 'class')
# 不指定值
dict = dict.fromkeys(seq)
print("新的字典为 : %s" % str(dict))
# 赋值 10
dict = dict.fromkeys(seq, 10)
print("新的字典为 : %s" % str(dict))
#　赋值一个元组
dict = dict.fromkeys(seq,('zs',8,'Two'))
print("新的字典为 : %s" % str(dict))
1
2
3
4
5
6
7
8
9
10
11

执行结果返回一个新的字典，如果不指定值默认为None,以上结果输出结果为：

新的字典为 : {'name': None, 'age': None, 'class': None}
新的字典为 : {'name': 10, 'age': 10, 'class': 10}
新的字典为 : {'name': ('zs', 8, 'Two'), 'age': ('zs', 8, 'Two'), 'class': ('zs', 8, 'Two')}
1
2
3

5.4 dict.get()

返回指定键的值，如果值不在字典中返回default值

get() 方法语法

dict.get(key, default=None)
# 参数key -- 字典中要查找的键。
# default -- 如果指定键的值不存在时，返回该默认值值。
1
2
3

实例：

# get ()方法的应用举例
dict = {'Name': 'Mary', 'Age': 20}
print ("Age 值为 : %s" %  dict.get('Age'))
print ("Name 值为 : %s" %  dict.get('Name'))
print ("Sex 值为 : %s" %  dict.get('Sex', "NA"))
1
2
3
4
5

以上结果输出为：

Age 值为 : 20
Name 值为 : Mary
Sex 值为 : NA
1
2
3

5.5 key in dict

如果键在字典dict里返回true，否则返回false

dict = {'Name': 'Mary', 'Age': 20,'Address':'BeiJing'}
# 检测键 Age 是否存在
if 'Age' in dict:    
    print("键 Age 存在")
else:    
    print("键 Age 不存在")

# 检测键 Sex 是否存在
if 'Sex' in dict:    
    print("键 Sex 存在")
else:    
    print("键 Sex 不存在")
    
# not in
# 检测键 Name 是否存在
if 'Name' not in dict:    
    print("键 Name 不存在")
else:    
    print("键 Name 存在")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

以上结果输出为：

# 键 Age 存在
# 键 Sex 不存在
# 键 Name 存在
1
2
3

5.6 dict.items()

item() 方法以列表返回可遍历的(键, 值) 元组数组

dict = {'Name': 'Mary', 'Age': 17} 
print ("Value : %s" %  dict.items())
# 输出结果为：Value : dict_items([('Age', 17), ('Name', 'Mary')])
1
2
3

可遍历的元组数组举例：

dict1 = {'老大':'25岁','老二':'20岁','老三':'12岁',        }
print(dict1.items())
for key,values in dict1.items():    
    print(key + '已经' + values + '了')
1
2
3
4

以上结果输出为：

# 老大已经25岁了
# 老二已经20岁了
# 老三已经12岁了
1
2
3

5.7 dict.keys()

返回一个迭代器，可以使用 list() 来转换为列表

keys()方法语法：

dict.keys()
1

实例：

dict = {'Name': 'Mary', 'Age': 17}
print(dict.keys())
1
2

以上结果输出为：

dict_keys(['Name', 'Age'])
1

由结果看出结果返回一个迭代对象，这时候我们可以使用 list 转换为列表：

list1 = list(dict.keys())
print ("转换后的结果为 : %s" % list1)
# 输出结果为一个列表，后续可以对其进行相应操作：转换后的结果为 : ['Name', 'Age']
1
2
3

5.8 dict…setdefault()

Python 字典 setdefault() 方法和 get() 方法类似, 如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。

setdefault()方法语法：

dict.setdefault(key, default=None)
# 参数key -- 查找的键值。
# default -- 键不存在时，设置的默认键值。
1
2
3

实例：

dict = {'Name': 'Mary', 'Age': 17} 
print ("Age 键的值为 : %s" %  dict.setdefault('Age', None))
print ("Sex 键的值为 : %s" %  dict.setdefault('Sex', None))
print ("新字典为：", dict)
1
2
3
4

以上结果输出为：

Age 键的值为 : 17
Sex 键的值为 : None
新字典为：{'Age': 17, 'Name': 'Mary', 'Sex': None}
1
2
3

5.9 dict.update(dict2)

Python 字典 update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。

语法：

dict.update(dict2)
# 参数 dict2 -- 添加到指定字典dict里的字典。
1
2

实例：

dict = {'Name': 'Mary', 'Age': 17}
dict2 = {'Sex': 'female' }
# 将 dict2 中的结果添加到字典 dict 中　
dict.update(dict2)
print ("更新字典 dict : ", dict)
1
2
3
4
5

以上结果输出为：

更新字典 dict :  {'Name': 'Mary', 'Age': 17, 'Sex': 'female'}
1

5.10 dict.values()

Python 字典 values() 方法返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。

dict = { 'Name': 'Mary','Sex': 'male', 'Age': 7}
print("字典所有值为 : ", list(dict.values()))
1
2

以上结果输出为：

字典所有值为 :  ['Mary', 'male', 7]
1

5.11 dict.pop(key[,default])

Python 字典 pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值。

pop()方法语法：

pop(key[,default])
#参数key: 要删除的键值default: 如果没有 key，返回 default 值
# 返回值返回被删除的值。
1
2
3

实例：

dict = {'Name': 'Mary', 'Age': 17}
result = dict.pop('Age') # 删除

print(result)
17
1
2
3
4
5

5.12 dict.popitem()

Python 字典 popitem() 方法随机返回一个键值对(key,value)形式，按照 LIFO（Last In First Out 后进先出法） 顺序规则，即最末尾的键值对。如果字典已经为空，却调用了此方法，就报出KeyError异常。

实例：

dict = {'Name': 'Mary', 'Age': 17}
pop_obj=dict.popitem()
print(pop_obj)
print(dict)
1
2
3
4

以上结果输出为：

('Age', 17)
{'Name': 'Mary'}
1
2

将字典清空：

dict = {'Name': 'Mary', 'Age': 17}
del dict
print(dict.popitem())
1
2
3

结果输出为：

Traceback (most recent call last):  
    File "test.py", line 4, in <module>    
    print(dict.popitem())
    TypeError: descriptor 'popitem' of 'dict' object needs an argument
1
2
3
4

6、字典和列表

6.1 字典和列表差异

列表中的元素表项由于元素通过序列从 0 开始递增存放，所以列表中的表项是排序的，而字典的内容的表项是不排序的，如下例子就很好的说明列表和字典的区别：

list1 = ['zhangsan',23,'BeiJing']
list2 = ['BeiJing','zhangsan',23]
list1 == list2  # False

dic1 = {'name':'zhangsan','age':23,'address':'BeiJing'}
dic2 = { 'age':23,'name':'zhangsan','address':'BeiJing'}
dic1 == dic2  # True

1
2
3
4
5
6
7
8

由以上实例可以看出，当列表元素内容一致，顺序不同再对比内容时匹配不成功，同理字典值匹配成功，说明字典中元素内容不按顺序存放。Python 中的字典提供了一种灵活的访问和组织数据的方式

• 字典是由很多值组成的集合
• 字典的索引可以是不同的数据类型，同样也不止是整数，也有字符串
• 字典的索引被称为“键”，键及键所关联的值叫键值对（类似于Java中的Map集合）
• 字典是另一种可变容器模型，且可存储任意类型对象。
• 字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

dictionary  = {'url1':'baidu', 'url':'google', 'num1':12, 'num2':34}
1

键一般是唯一的，如果键重复，最后的一个键值对会替换前面的键值对，值没有唯一性要求，如下：

dic1 = {'name':'zhangsan','age':23,'address':'BeiJing','name':'lisi'}
# 查看字典值发现重复的键值后面的替换前面的
dic1{'name': 'lisi', 'age': 23, 'address': 'BeiJing'}
dic1['name']
'lisi'
1
2
3
4
5

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组，如下：

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258',('a','b'):(12,43)}
1