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

一.字符串类型

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，默认步长为1
print(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 如果字符在字符串里不存在，结果为-1
print(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，反之False
print('hello'.endswith('o'))  # True    判断是否以'o'结尾，是则True，反之False
print('he45llo'.isalpha())  # False  判断是否都是字母，是则True，反之False
print('good'.isdigit())  # False  判断是否都是数字，是则True，反之False
print('abc123'.isalnum())  # True   判断是否都是字母或者数字，是则True，反之False
print('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('+'))   #   +++++hello
print('+++++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 替换成 x
print(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 = 97
print(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))   # A
print(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 = 20
print('我的名字是%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 = 164
print('%x' % a)   #a4
print('%X' % a)   #A4
print('大家好，我是%%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])    # 18
print(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)     # False
print('女枪' not in heros) # True

index,count

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

heros = ['亚索', '佐伊', '赵信', '铁男']
print(heros.index('铁男'))  # 3
print(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 = 0
while 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])    #33
x[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]=8
print(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] = 11
x2[3][1]=12
print(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] = 11
x3[3][1]=12
print(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 x
print(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 = 0
while 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'] = 99
print(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)  #98
print(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'>

2.带下标的遍历(enumerate)

可迭代对象都可以使用 enumerate 内置类进行包装成一个 enumerate 对象。对enumerate进行遍历，可以同时得到一个可迭代对象的下标和元素。

nums = (2, 5, 7, 8, 4, 6)
for i, j in enumerate(nums):
    print('第%d个数据是%d' % (i, j))

运行结果：

第0个数据是2
第1个数据是5
第2个数据是7
第3个数据是8
第4个数据是4
第5个数据是6