700字范文 > Python的数据类型（二）：字符串类型布尔类型列表元组字典集合

Python的数据类型（二）：字符串类型布尔类型列表元组字典集合

时间：2019-01-13 22:40:28

文章目录

一.字符串类型1.字符串的表示方式2.字符串的下标和切片3.字符串常见的内置函数4.字符串的运算符5.字符编码6.字符串格式化7.字符串format方法的使用二.布尔类型三.列表1.列表的基本使用2.列表的增删改查3.列表的排序和反转4.列表的遍历5.列表的嵌套6.列表的推导式7.列表的复制四.元组1.元组的定义2.元组的访问3.元组的修改4.元组的删除5.元组的运算符6.元组的遍历7.元组的内置函数五.字典1.字典的定义2.字典的增删改查3.字典的遍历六.集合1.集合的定义2.集合的基本操作3.集合使用运算符七.其他知识点1.JSON的相关知识2.带下标的遍历(enumerate)

一.字符串类型

1.字符串的表示方式

字符串是 Python 中最常用的数据类型。在Python中，可以使用一对单引号、一对双引号或者一对三个单引号、一对三个双引号来创建字符串。（通常使用一对单引或一对双引号）

a = 'hello'b = "world"c = '''你好'''d = """世界"""

如果字符串里还有双引号，外面就可以使用单引号

a = 'I said:" I am happpy"'

在需要在字符中使用特殊字符时，python用反斜杠(“\”)转义字符:

\ ’ ==> 显示一个普通的单引号
\ " ==> 显示一个普通的双引号
\ n ==> 表示一个换行
\ t ==> 表示显示一个制表符
\ \ ==> 表示一个普通的反斜线
作用：对 \ 后面的字符进行转义

x1 = '你好\t世界'print(x1)#你好世界x2 = 'hello wo\\rld' print(x2)#hello wo\rld

在字符串的前面添加 r / R ，在Python里表示的是原生字符串

x3 = r'你好\t世界'print(x3) #你好\t世界

2.字符串的下标和切片

下标又称为索引，表示第几个数据。

在计算机里面，下标都是从0开始的。我们可以通过下标来获取或者修改指定位置的数据。

x = 'hello world'print(x[4]) # o

字符串是不可变的数据类型
对于字符串的任何操作，都是不会改变原有的字符串!

切片就是从字符串里复制一段指定的内容，生成一个新的字符串.

切片语法：x[start : end : step]
包含start，不包含end
step指的是步长，可理解为间隔。每隔step-1个取一次，步长默认为1，不能够为0。
step为负数时，表示从右往左获取

x = 'hello world'print(x[1:3])# el 包含start，不包含end，默认步长为1print(x[1:]) # ello world 如果只设置了start，会"截取"到最后print(x[:3]) # hel 如果只设置了end，会从头开始"截取"print(x[1:3:2]) # e print(x[:]) # hello world 从头到尾的复制print(x[::-1])# dlrow olleh 从尾到头的复制print(x[-3:-1]) # rl 如果start和end是负数，表示从右边数

3.字符串常见的内置函数

使用内置函数len可以获取字符串的长度。

y='hello world'print(len(y)) # 11

内置函数 find，index，rfind，rindex查找内容，可以获取指定字符的下标。

print(y.find('w')) # 6 如果字符在字符串里不存在，结果为-1print(y.index('w')) # 6 如果字符在字符串里不存在，会报错print(y.rfind('w')) # 6 类似于 find()函数，不过是从右边开始查找.print(y.rindex('w')) # 6 类似于 index()函数，不过是从右边开始查找.

index()：找出参数字符串中第一个查询参数的地址，然后将该字符出现的地址返回。
rindex()：找出参数字符串中最后一个查询参数的地址，然后将该字符出现的地址返回。

内置函数startswith，endswith，isalpha，isdigit，isalnum，isspace是判断，结果是一个布尔类型。

print('hello'.startswith('he')) # True 判断是否以'he'开头，是则True，反之Falseprint('hello'.endswith('o')) # True 判断是否以'o'结尾，是则True，反之Falseprint('he45llo'.isalpha()) # False 判断是否都是字母，是则True，反之Falseprint('good'.isdigit()) # False 判断是否都是数字，是则True，反之Falseprint('abc123'.isalnum()) # True 判断是否都是字母或者数字，是则True，反之Falseprint('abc 123'.isspace()) #False 判断是否只包含空白，是则True，反之False

内置函数capitalize，upper，lower，title，swapcase有关的大小写的操作。

y ='hEllo woRld'print(y.capitalize()) #Hello world 将字符串的第一个字符转换为大写print(y.upper()) #HELLO WORLD 将字符串中所有字母转换为大写print(y.lower()) #hello world 将字符串中所有字母转换为小写print(y.title()) #Hello World 所有单词都是以大写开始，其余字母均为小写print(y.swapcase()) #HeLLO WOrLD 将字符串中大写转换为小写，小写转换为大写

内置函数split，rsplit，partition，rpartition，ljust，rjust，center，lstrip，rstrip，strip对字符串的格式等修改操作。

y ='hEllo-woRld-你好-世界'print(y.split('-', 2)) # ['hEllo', 'woRld', '你好-世界']print(y.rsplit('-', 2)) # ['hEllo-woRld', '你好', '世界']print(y.partition('R')) # ('hEllo-wo', 'R', 'ld-你好-世界')print(y.rpartition('R')) # ('hEllo-wo', 'R', 'ld-你好-世界')print(y.ljust(20, '+')) # hEllo-woRld-你好-世界+++print(y.rjust(20, '-')) # ---hEllo-woRld-你好-世界print(y.center(20, '*')) # *hEllo-woRld-你好-世界**print('+++++hello+++'.lstrip('+')) # hello+++print('+++++hello+++'.rstrip('+')) # +++++helloprint('+++++hello+++'.strip('+')) # hello

split：按照字符串左边的空格或指定字符切割成一个列表
rsplit：按照字符串右边的空格或指定字符切割成一个列表
partition：从左边开始，指定一个字符串作为分隔符，分为三部分：前面分隔符后面
rpartition：从右边开始，指定一个字符串作为分隔符，分为三部分：前面分隔符后面
ljust：返回一个原字符串左对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
rjust：返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
center：返回一个原字符串居中对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
lstrip：截掉字符串左边的空格或指定字符。
rstrip：截掉字符串右边的空格或指定字符。
strip：在字符串上执行 lstrip()和 rstrip()

内置函数replace替换字符串

y = 'hello world'z = y.replace('l', 'x') # replace 将字符串里 l 替换成 xprint(y) # hello world 字符串是不可变数据类型!!!print(z) # hexxo worxd 原来的字符串不会改变，而是生成一个新的字符串来保存替换后的结果

4.字符串的运算符

1.字符串和字符串之间可以使用加法运算，作用是拼接两个字符串。

x = 'abc'y = '123'print(x + y) # abc123

2.字符串和数字之间可以使用乘法运算，目的是将指定的字符串重复多次。

x = 'abc'print(x * 2) # abcabc

3.字符串可以使用成员运算符，以此来判断给定的字符是否在字符串中。

x = 'abc'print('d' in x) # False

4.字符串和数字之间做 == 运算结果是False,做！= 运算，结果是True。

x = 'a'y = 97print(x == y) # False

5.字符串之间做比较运算，会逐个比较字符串的编码值。

x = 'ab'y = 'ac'print(x < y) # True

5.字符编码

计算机只能处理数字(0和1)，如果要处理文本，就必须先把文本转换为数字才能处理。

计算机编码的发展：ASCII --> Latin1 --> Unicode编码（统一码、万国码、单一码）。

1.字符和编码的转换

使用内置函数chr和ord的方法，能够查看数字和字符的对应关系，也可以实现字符和编码之间的相互转换。

chr 根据编码获取对应的字符；ord 获取字符对应的编码。

print(chr(65)) # Aprint(ord('a')) # 字符对应的编码是 97

2.encode和decode的方法使用

在中国常用的字符编码有 GBK,BIG5和utf8这三种编码规则。

GBK编码，一个汉字占两个字节
utf8编码，一个汉字占三个字节

使用encode方法，可以将字符串按照指定的编码格式转换称为二进制；

使用decode方法，可以将一个二进制数据按照指定的编码格式转换成为字符串。

print('你'.encode('gbk')) # b'\xc4\xe3'print('你'.encode('utf8')) # b'\xe4\xbd\xa0'x = b'\xe4\xbd\xa0'print(x.decode('utf8'))# 你

6.字符串格式化

在字符串里可以使用 % 占位符来表示格式化一个字符串。

%s ==> 表示的是字符串的占位符
%d ==> 表示的整数的占位符
%nd ==> 打印时，显示n位，如果不够，在前面使用空格补齐
%f ==> 表示的浮点数的占位符
%.nf ==> 保留小数点后n位
%x ==> 将数字使用十六进制输出
%% ==> 输出一个 %

name = 'jack'age = 20print('我的名字是%s,我今年%d岁,我今天身高%f厘米' % (name, age, 180))#我的名字是jack,我今年20岁,我今天身高180.000000厘米print('我的座位号是%3d位' % 13)#我的座位号是 13位print('我的座位号是%-3d位' % 13)#我的座位号是13 位print('我的座位号是%03d位' % 13)#我的座位号是013位print('我身高%.2f厘米' % 180) #我身高180.00厘米a = 164print('%x' % a) #a4print('%X' % a) #A4print('大家好，我是%%s,今年%d岁' % 20)#大家好，我是%s,今年20岁

7.字符串format方法的使用

str.format() 方法通过字符串中的大括号{} 来识别替换字段 replacement field，从而完成字符串的格式化，{}也可以进行占位。

1.{ } 什么都不写，会读取后面的内容，一一对应填充

x = '大家好，我是{},我今年{}岁了'.format('张三', 22)print(x) # 大家好，我是张三,我今年22岁了

2.{数字} 根据数字的顺序来进行填入。数字从 0 开始。

y = '大家好，我是{1},我今年{0}岁了'.format(20, 'jerry')print(y) #大家好，我是jerry,我今年20岁了

3.{变量名}

z = '大家好，我是{name},我今年{age}岁了,我来自{addr}'.format(age=18, name='jack', addr='安徽')print(z) #大家好，我是jack,我今年18岁了,我来自安徽

4.混合使用： {数字} {变量}

a = '大家好，我是{name},我今年{1}岁了,我来自{0}'.format('泰国', 23, name='tony')print(a) #大家好，我是tony,我今年23岁了,我来自泰国

5.{}什么都不写 {数字} 不能混合使用

6.可以使用 *元组和 **字典的形式传参，两者可以混合使用。

info = {'name': 'chris', 'age': 23, 'addr': '北京', 'height': 190}c = '大家好，我是{name},我来自{addr},身高{height}cm,我今年{age}岁了'.format(**info)print(c) # 大家好，我是chris,我来自北京,身高190cm,我今年23岁了

位置参数、关键字参数、*元组和 **字典也可以同时使用，但是要注意，位置参数要在关键字参数前面，*元组要在 **字典前面。

二.布尔类型

布尔类型只有两个值：True和False。

三.列表

1.列表的基本使用

1.列表的格式

定义列表的格式：[元素1, 元素2, 元素3, …, 元素n]

list1 = ['张三',18, 66.0]

列表中的元素可以是不同类型的。

2.使用下标获取列表元素

列表和字符串一样，都可以使用下标来获取元素和对元素进行切片，同时还可以使用下标来修改列表的元素。

list1 = ['张三',18, 66.0]print(list1[1]) # 18print(list1[1:]) #[18, 66.0]list1[2]='shanghai'print(list1) #['张三', 18, 'shanghai']

可以使用list（可迭代对象）将可迭代对象转换成为一个列表。

names = list(('zhangsan', 'lisi', 'wangwu', 'maliu'))print(names) # ['zhangsan', 'lisi', 'wangwu', 'maliu']

2.列表的增删改查

列表使用来保存多个数据的，是有序可变的。

操作列表，一般都包括添加数据、删除数据、修改数据以及查询数据。

1.添加元素

添加元素的几个方法：append、insert、extend

append:会把新元素添加到列表末尾。

heros = ['亚索', '佐伊', '赵信', '铁男']heros.append('锤石')print(heros) #['亚索', '佐伊', '赵信', '铁男', '锤石']

insert：insert（index，object）在指定位置index前插入元素object。

index 表示下标，在哪个位置插入数据
object 表示对象，具体插入哪个数据

heros = ['亚索', '佐伊', '赵信', '铁男']heros.insert(2, '鳄鱼')print(heros) # ['亚索', '佐伊', '鳄鱼', '赵信', '铁男']

extend: 通过extend可以将另一个集合中的元素逐一添加到列表中。

extend(iterable) 需要一个可迭代对象
A.extend(B) ==> 将可迭代对象 B 添加到 A 里

heros = ['亚索', '佐伊', '赵信', '铁男']x =['牛头','布隆']heros.extend(x)print(heros) #['亚索', '佐伊', '赵信', '铁男', '牛头', '布隆']

2.删除元素

删除元素的几个方法：pop、remove、clear、del

pop:此方法默认会删除列表里最后一个数据，并且返回这个数据，也可以传入index参数，用来删除指定位置上的数据。

heros = ['亚索', '佐伊', '赵信', '铁男']m = heros.pop(2)print(m) #赵信print(heros)#['亚索', '佐伊', '铁男']

remove：用来删除指定的元素。

heros = ['亚索', '佐伊', '赵信', '铁男']heros.remove('佐伊')print(heros) #['亚索', '赵信', '铁男']

如果数据在列表中不存在，会报错。

clear:用来清空一个列表。

heros = ['亚索', '佐伊', '赵信', '铁男']heros.clear()print(heros) #[]

del:根据下标进行删除

heros = ['亚索', '佐伊', '赵信', '铁男']del heros[0]print(heros) #['佐伊', '赵信', '铁男']

3.修改元素

使用下标就可以直接修改列表里的元素

heros = ['亚索', '佐伊', '赵信', '铁男']heros[3]='霞'print(heros) #['亚索', '佐伊', '赵信', '霞']

4.查询元素

查询元素可以使用in和not in，index和count

in，not in

in（存在）,如果存在那么结果为true，否则为false
not in（不存在），如果不存在那么结果为true，否则false

heros = ['亚索', '佐伊', '赵信', '铁男']print('女枪' in heros)# Falseprint('女枪' not in heros) # True

index,count

index用来查找元素所在的位置，如果未找到则会报错；
count用来计算某个元素出现的次数。
它们的使用和字符串里的使用效果一致。

heros = ['亚索', '佐伊', '赵信', '铁男']print(heros.index('铁男')) # 3print(heros.count('铁男')) # 1

3.列表的排序和反转

sort方法是将list按特定顺序重新排列，默认为由小到大。

x = [3, 5, 1, 9, 7, 2, 6]x.sort()print(x) #[1, 2, 3, 5, 6, 7, 9]

参数reverse=True可改为倒序，由大到小。

x = [3, 5, 1, 9, 7, 2, 6]x.sort(reverse=True)print(x) #[9, 7, 6, 5, 3, 2, 1]

reverse方法是将list逆置。

print(names[::-1])x = [3, 5, 1, 9, 7, 2, 6]x.reverse()print(x) #[6, 2, 7, 9, 1, 5, 3]

内置函数sorted,不会改变原有的列表数据，会生成一个新的有序数据

x = [3, 5, 1, 9, 7, 2, 6]y = sorted(x)print(y) #[1, 2, 3, 5, 6, 7, 9]

4.列表的遍历

遍历：将所有的数据都访问一遍。遍历针对的是可迭代对象。

列表的遍历是：while循环遍历和for···in循环遍历

while循环遍历：

heros = ['亚索', '佐伊', '赵信', '铁男']i = 0while i < len(heros):print(heros[i])i += 1

运行结果：

亚索
佐伊
赵信
铁男

for···in循环遍历：

while 循环是一种基本的遍历列表数据的方式，但是最常用也是最简单的方式是使用 for 循环
for…in循环的本质就是不断的调用迭代器的 next 方法查找下一个数据.

heros = ['亚索', '佐伊', '赵信', '铁男']for k in heros:print(k)

运行结果：

亚索
佐伊
赵信
铁男

5.列表的嵌套

列表的嵌套就是一个列表中的元素又是一个列表。

x = [[1, 2, 3], [11, 22, 33], [111, 222, 333]]print(x[1][2]) #33x[1][1] = 'aa'print(x) #[[1, 2, 3], [11, 'aa', 33], [111, 222, 333]]

操作嵌套列表，只要把要操作元素的下标当作变量名来使用即可。

6.列表的推导式

所谓的列表推导式，就是指的轻量级循环创建列表。

1.基本的方式

nums = [i for i in range(10)]print(nums) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]nums = [i for i in range(5,10)]print(nums) #[5, 6, 7, 8, 9]nums = [i for i in range(5,10,2)]print(nums) #[5, 7, 9]

2.在循环的过程中使用if

nums = [i for i in range(10) if i % 2 == 0]print(nums) #[0, 2, 4, 6, 8]nums = [i for i in range(10) if i % 2 != 0]print(nums) #[1, 3, 5, 7, 9]

3. 2个for循环

nums =[(x,y) for x in range(3) for y in range(3)]print(nums)

运行结果:

[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

4. 3个for循环

nums = [(x, y, z) for x in range(2) for y in range(2) for z in range(2)]print(nums)

运行结果：

[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]

7.列表的复制

Python中的赋值运算都是引用(即内存地址)的传递。

对于可变类型来说，修改原数据的值，会改变赋值对象的值。

使用列表的 copy 方法或者 copy 模块就可以赋值一个列表。

1.copy方法

使用列表的copy方法，可以直接将原来的列表进行复制，变成一个新的列表，这种复制方式是浅复制。

x1=[1,2,3,4,5,6]x2=x1.copy()x2[2]=8print(x2) #[1, 2, 8, 4, 5, 6]print(x1) #[1, 2, 3, 4, 5, 6]

修改新列表里的数据，不会影响到原有列表里的数据.

2.copy模块的使用

除了使用列表的copy方法以外，Python还提供了copy模块来复制一个对象。

copy模块提供了浅复制和深复制两种方式，它们的使用方式相同，但是执行的效果有一定的差异。

浅拷贝（浅复制）：浅拷贝是对于一个对象的顶层拷贝，通俗的理解是：拷贝了引用，并没有拷贝内容。

x1 = [1, 2, 3, [7, 8, 9], 5, 6]x2 = copy.copy(x1)x2[1] = 11x2[3][1]=12print(x1) #[1, 2, 3, [7, 12, 9], 5, 6]print(x2) #[1, 11, 3, [7, 12, 9], 5, 6]

浅拷贝只会拷贝最外层的对象，里面的数据不会拷贝，而是直接指向。

深拷贝（深复制）：深拷贝是对于一个对象所有层次的递归拷贝。

x1 = [1, 2, 3, [7, 8, 9], 5, 6]x3= copy.deepcopy(x1)x3[1] = 11x3[3][1]=12print(x1) # [1, 2, 3, [7, 8, 9], 5, 6]print(x3) # [1, 11, 3, [7, 12, 9], 5, 6]

深拷贝会将对象里的所有数据都进行拷贝。

列表和字符串一样，也支持切片，切片其实就是一种浅拷贝。

四.元组

1.元组的定义

元组和列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

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

ages = (18) # 不加逗号，类型为整型print(type(ages)) #<class 'int'>ages = (18,) # 加上逗号，类型为元组print(type(ages)) #<class 'tuple'>

2.元组的访问

元组与字符串类似，下标索引从0开始，元组可以使用下标索引来访问元组中的值。

x = (1, 5, 98, 7, 'hello')print(x[3]) # 7

3.元组的修改

元组中元素值是不允许修改的，但可以对元组进行连接组合。

x = (1, 5, 98, 7, 'hello')y = ('world', 55, 18)print(x + y) #(1, 5, 98, 7, 'hello', 'world', 55, 18)

4.元组的删除

元组中元素值是不允许删除的，但可以使用del语来删除整个元组。

x = (1, 5, 98, 7, 'hello')del xprint(x) # NameError: name 'x' is not defined

5.元组的运算符

元组与字符串一样，元组之间可以使用+号和*号进行运算。

x = (1, 5, 98, 7, 'hello')y = ('world',)print(x + y) # (1, 5, 98, 7, 'hello', 'world')print(y *3) # ('world', 'world', 'world')print(1 in x) # True

6.元组的遍历

元组可以像列表一样进行遍历

for循环遍历：

x = (1, 5, 98, 7, 'hello')for z in x:print(z)

while 循环遍历：

x = (1, 5, 98, 7, 'hello')j = 0while j < len(x):print(x[j])j += 1

运行结果：

1
5
98
7
hello

7.元组的内置函数

len(tuple):计算元组元素个数。

x = (1, 5, 98, 7, 'hello')print(len(x)) # 5

max(tuple):返回元组中元素最大值。

m =(5,4,9,8)print(max(m)) # 9

min(tuple):返回元组中元素最小值。

m =(5,4,9,8)print(min(m)) # 4

tuple(iterable):将可迭代系列转换为元组。

m =[5,4,9,8]print(tuple(m)) #(5, 4, 9, 8)

五.字典

1.字典的定义

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个元素由两个部分组成：键：值

键可以使用数字、布尔值、布尔值、元组等不可变数据类型，但是一般习惯使用字符串

键必须是唯一的，但值则不必。如果出现了多个相同的键,后面的值会覆盖前一个相同键对应的值.

dict1 = {'name': 'zhangsan', 'age': 18, 'score': 98}print(dict1) # {'name': 'zhangsan', 'age': 18, 'score': 98}

2.字典的增删改查

1.查看元素

字典的数据在保存时，是无序的，不能通过下标来获取。

我们可以通过使用key获取到对应的value。

student ={'name':'zhangsan','age':22,'score':98}print(student['name']) # zhangsan print(student['math']) # 报错

如果要查找的key不存在，会直接报错

为了获取一个不存在的key时，不报错。如果这个key不存在，将使用默认值。我们可以使用字典的get方法。

student ={'name':'zhangsan','age':22,'score':98}print(student.get('math')) # 返回值默认是None，不报错print(student.get('math',99)) # 99

2.添加元素

使用变量名[‘键’] = 数据，如果这个“键”在字典中不存在，那么就会新增这个元素。

student = {'name': 'zhangsan', 'age': 22, 'math': 98}print(student) #{'name': 'zhangsan', 'age': 22, 'math': 98}student['english'] = 99print(student) #{'name': 'zhangsan', 'age': 22, 'math': 98, 'english': 99}

还可以使用update的方法

student = {'name': 'zhangsan', 'age': 22}score = {'math': 98, 'english': 99}student.update(score)print(student) #{'name': 'zhangsan', 'age': 22, 'math': 98, 'english': 99}

3.修改元素

字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改。

student = {'name': 'zhangsan', 'age': 22, 'math': 98}print(student) #{'name': 'zhangsan', 'age': 22, 'math': 98}student['name'] = 'lisi'print(student) #{'name': 'lisi', 'age': 22, 'math': 98}

4.删除元素

字典的删除操作有这几种：pop、popitem、del、clear

pop：删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。

student = {'name': 'zhangsan', 'age': 22, 'math': 98}x = student.pop('math')print(x) #98print(student)#{'name': 'zhangsan', 'age': 22}

popitem:随机返回并删除字典中的最后一对键和值。

student = {'name': 'zhangsan', 'age': 22, 'math': 98}result = student.popitem()print(result) # ('math', 98)print(student) # {'name': 'zhangsan', 'age': 22}

del:删除字典给定键和它的值

student = {'name': 'zhangsan', 'age': 22, 'math': 98}del student['math']print(student) #{'name': 'zhangsan', 'age': 22}

clear:删除字典内所有元素

student = {'name': 'zhangsan', 'age': 22, 'math': 98}student.clear()print(student) #{}

3.字典的遍历

1.遍历字典的key

student={'name': 'zhangsan', 'age': 22, 'math': 98}for key in student.keys():print(key)

运行结果：

name
age
math

2.遍历字典的value

student={'name': 'zhangsan', 'age': 22, 'math': 98}for value in student.values():print(value)

运行结果：

zhangsan
22
98

3.遍历字典的元素

student={'name': 'zhangsan', 'age': 22, 'math': 98}for item in student.items():print(item)

运行结果：

(‘name’, ‘zhangsan’)
(‘age’, 22)
(‘math’, 98)

4.遍历字典的key-value

student = {'name': 'zhangsan', 'age': 22, 'math': 98}for key, value in student.items():print('key=%s,value=%s'% (key, value))

运行结果：

key=name,value=zhangsan
key=age,value=22
key=math,value=98

六.集合

1.集合的定义

集合（set）是一个无序的不重复元素序列。

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

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

m = {'hello','world',2,4}print(m) # {'hello', 'world', 2, 4}print(type(m))#<class 'set'>

2.集合的基本操作

1.添加元素

使用add方法添加一个元素，如果元素已存在，则不进行任何操作。

heros = {'亚索', '佐伊', '女枪'}heros.add('锤石')print(heros) #{'佐伊', '亚索', '锤石', '女枪'}

还能使用update方法，也可以添加元素，且参数可以使列表、元组、字典等。

heros = {'亚索', '佐伊', '女枪'}heros.update({'牛头','铁男'})print(heros) #{'佐伊', '铁男', '亚索', '女枪', '牛头'}

2.删除元素

可以使用pop方法，随机删除一个元素。

heros = {'亚索', '佐伊', '女枪'}heros.pop()print(heros) #{'女枪', '亚索'}

还可以使用remove方法，删除一个指定的元素，如果元素不存在，则会发生错误。

heros = {'亚索', '佐伊', '女枪'}heros.remove('亚索')print(heros) #{'佐伊', '女枪'}

还能使用discard方法，删除一个指定的元素，如果元素不存在，不会发生错误。

heros = {'亚索', '佐伊', '女枪'}heros.discard('女枪')print(heros) #{'佐伊', '亚索'}

使用clear方法，直接清空一个集合。

heros = {'亚索', '佐伊', '女枪'}heros.clear()print(heros) #set()

3.查询元素

可以使用成员运算符来查看指定元素是否在集合中。

heros = {'亚索', '佐伊', '女枪'}print('女枪' in heros) # True

3.集合使用运算符

first = {1, 2, 3, 4, 5, 6}second = {4, 5, 6, 7, 8, 9}print(first - second) # A - B 求A和B的差集print(second - first)print(first & second) # A & B 求A和B的交集print(first | second) # A | B 求A和B的并集print(first ^ second) # A ^ B 求A和B差集的并集

运行结果：

{1, 2, 3}
{8, 9, 7}
{4, 5, 6}
{1, 2, 3, 4, 5, 6, 7, 8, 9}
{1, 2, 3, 7, 8, 9}

七.其他知识点

1.JSON的相关知识

JSON(JavaScriptObjectNotation, JS对象简谱)是一种轻量级的数据交换格式，它基于 ECMAScript 的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。JSON本质是一个字符串

JSON的功能强大，使用场景也非常的广，目前我们只介绍如何使用Python的内置JSON模块，实现字典、列表或者元组与字符串之间的相互转换。

使用json的dumps方法，可以将字典、列表或者元组转换成为字符串。

student = {'name': 'zhangsan', 'age': 22, 'english': 99}m = json.dumps(student) print(m) # {"name": "zhangsan", "age": 22, "english": 99}print(type(m)) # <class 'str'>

使用json的loads方法，可以将格式正确的字符串转换成为字典、列表。

student = '{"name": "zhangsan", "age": 22, "english": 99}'x = json.loads(student)print(x) # {'name': 'zhangsan', 'age': 22, 'english': 99}print(type(x)) # <class 'dict'>