Python的基础数据类型2

数据类型介绍

基础数据类型1点这里
书接上回：

字符串

字符串的常见操作

s.find(sub[,start[,end]]) --> 返回该元素最小的索引(从左到右)

• 查找s中在start到end范围内的第一个sub的索引，返回sub的索引位置。若在指定范围内没有sub，则返回-1需要变量接收。

s.rfind(sub[,start[,end]]) --> 返回该元素最小的索引(从右到左)

s1 = "hello world"
#     012345678910
print(s1.find('o'))             # 在 s1 中查找 o 的索引
print(s1.rfind('o'))            # 在 s1 中查找 o 的索引(从右边开始)
print(s1.find('o', 6, 10))      # 在 s1 中查找 o 的索引，指定索引范围：索引值在6-10之间
print(s1.find('a'))             # 在 s1 中查找 a 的索引



4
7
7
-1

s.index(sub[,start[,end]]) --> 返回该元素最小的索引

• 查找s中在start到end范围内的第一个sub的索引，返回sub的索引位置。若在指定范围内没有sub，则触发ValueError需要变量接收。

s1 = "hello world"
print(s1.index('o'))            # 在 s1 中查找 o 的索引
print(s1.index('o', 6, 10))     # 在 s1 中查找 o 的索引，指定索引范围：索引值在6-10之间
print(s1.index('a'))            # 在 s1 中查找 a 的索引

4
7
Traceback (most recent call last):
    print(s1.index('a'))
ValueError: substring not found

S.replace(old, new[, count]) --> 替换

• 用new替代s中的old。count表示替换的次数，如果不指定次数，则有多少替换多少，返回值：返回替换后的字符串。

s1 = "hello world"
print(s1.replace('o', 'a'))       # 在 s1 中用 a 替代 o ，默认全部替换
print(s1.replace('o', 'a', 1))    # 在 s1 中用 a 替代 o ，替换 1 次


hella warld
hella world

S.split(sep=None) --> 以sep来分割字符串,并返回列表。sep默认为None,分割默认为空格

• 以参数sep作为分隔符分隔字符串s，分隔符必须在字符串s中存在，默认是空格，返回值：返回分隔后的字符串列表。若sep不在s中，返回的也是列表，列表元素是字符串s

s1 = "hello world"
print(s1.split())       # 分割字符串 s1 ，默认为以空格为分隔符进行分割
print(s1.split('o'))    # 分割字符串 s1 ，以 o 为分隔符进行分割
print(s1.split('a'))    # 分割字符串 s1 ，以 a 为分隔符进行分割


['hello', 'world']
['hell', ' w', 'rld']
['hello world']

S.startswith(prefix[, start[, end]]) --> 判断字符串是否以前缀开始，返回为bool值。

• prefix，必选 。start，end 可选 指定prefix在s中的查找范围，判断在s中指定的范围内是否以prefix开头，返回值：布尔值，True或False。在指定范围内以的字符串以prefix开头则返回True，否则返回False，需要变量接收

s1 = "hello world"
print(s1.startswith('h'))         # 判断字符串 s1 是否以 h 为前缀
print(s1.startswith('o'))         # 判断字符串 s1 是否以 h 为前缀
print(s1.startswith('o', 7, 10))  # 判断字符串 s1 中在索引值为7-10的范围内是否以 o 为前缀


True
False
True

S.endswith(suffix[, start[, end]]) --> 判断字符串是否以尾缀结束，返回为bool值。

• suffix，必选。start，end 可选 指定suffix在s中的查找范围。判断在s中指定的范围的字符串是否以suffix结尾。返回值：布尔值。True或False。在指定范围内以的字符串以suffix结尾则返回True，否则返回False，需要变量接收。

s1 = "hello world"
print(s1.endswith('d'))         # 判断字符串 s1 是否以 d 为后缀
print(s1.endswith('o'))         # 判断字符串 s1 是否以 o 为后缀
print(s1.endswith('o', 0, 5))  # 判断字符串 s1 中在索引值为0-5的范围内是否以 o 为后缀


True
False
True

S.lower() --> 将字符串全部转为小写

• 将s中的大写英文字母转换为小写英文字母。若s中没有大写英文字母，则返回的就是s。返回值：返回转换后的字符串。需要变量接收。

s1 = "Hello world"
print(s1.lower())      # 将 s1 中的字母全部转为小写


hello world

S.upper() --> 将字符串全部转为大写

• 将s中的小写英文字母转换为大写字母，返回值：返回转换后的字符串。若s中没有小写英文字母，则返回的就是s。

s1 = "hello world"
print(s1.upper())        # 将 s1 中的字母全部转为大写


HELLO WORLD

S.strip([chars]) --> 默认去掉字符串左右的空格

• 去除字符串s两边的字符chars（类型为字符串），默认为空格，返回值：返回去除chars后的字符串。需要变量接收。

s1 = "hello world"
print(s1.strip())         # 默认为去掉 s1 左右的空格
print(s1.strip('d'))      # 去掉 s1 左右两边的 d 


hello world
hello worl

S.isalpha() --> 判断字符串是否全为字母，返回的是bool值

• 判断字符串s是否全为字母，返回值：布尔值，True或False。如果字符串s中至少有一个字符并且所有字符都是字母，返回True，否则返回False，需要变量接收

s1 = "hello world"
s2 = 'helloworld'
print(s1.isalpha())         # 判断 s1 是否全为字母
print(s2.isalpha())         # 判断 s1 是否全为字母


False
True

S.isdigit() --> 判断字符串是否全为数字，返回的是bool值

• 判断字符串 s 的字符是否全是是数字，返回值：布尔值，True或False。若s字符全为数字，返回True，否则返回False，需要变量接收。

s1 = '123'
s2 = '123abc'
print(s1.isdigit())         # 判断 s1 是否全为数字
print(s2.isdigit())         # 判断 s1 是否全为数字


True
False

S.isalnum() --> 判断字符串是否全为数字或者字母，不存在特殊字符，返回的是bool值

• 判断字符串 s 的字符是否全是全为数字或字母，返回值：布尔值，True或False。s中至少有一个字符且如果S中的所有字符都是字母数字，那么返回结果就是True；否则，就返回False

s1 = '123abc'
s2 = '123+abc'
print(s1.isalnum())         # 判断 s1 是否全为字母或数字
print(s2.isalnum())         # 判断 s1 是否全为字母或数字


True
False

S.join(iterable) --> 将序列中的元素以指定的字符连接生成一个新的字符串

• 以字符串s作为分隔符分隔字符串iterable，返回值：返回分隔后的字符串

s1 = "hello world"
print(s1.join('123456'))


1hello world2hello world3hello world4hello world5hello world6

字节（bytes）

字节的介绍

• 在 Python3 以后，字符串 和 bytes 类型彻底分开了。字符串 是以 字符 为单位进行处理的，bytes 类型是以 字节 为单位处理的。
• bytes 数据类型在所有的操作和使用甚至内置方法上和字符串数据类型基本一样，也是不可变的序列对象。
• Python3 中，bytes 通常用于网络数据传输、二进制图片和文件的保存等等。

字节创建

• 可以通过调用 bytes() 生成 bytes 实例，其值形式为 b’xxxxx’，对于同一个字符串如果采用不同的编码方式生成 bytes 对象，就会形成不同的值。

bt_1 = bytes('hello world', encoding='utf-8')
print(bt_1)


b'hello world'

字节类型常用转换

• 在实际应用中，我们通常会将 bytes类型 与 str类型 做转换。

• bytes→str bytes.decode()

• str→bytes S.encode()

列表

列表介绍

• 列表是 Python 中最基本也是最常用的数据结构之一，它是一个 有序可重复的元素序列。从数据结构角度看,Python 的列表是一个 可变长度 的顺序存储结构，每一个位置存放的都是对象的指针。
• 我们可对列表进行 修改、切片、追加、删除、嵌套、迭代、成员判断 等操作。

列表创建

• 创建一个列表，只要把 逗号 分隔的 不同的数据元素 使用 方括号 括起来即可。

li = []
li1 = [1, 22, 333, '123']
print(li)
print(li1)


[]
[1, 22, 333, '123']

• 也可以直接使用list()来进行创建列表

print(list('hello'))


['h', 'e', 'l', 'l', 'o']

注意:

• 变量名最好不使用 list
• 列表里的 元素 可以是 任意类型
• 列表里的元素可重复
• iterable 表示 可迭代的对象，简单来说就是可以一个一个元素取出来的。比如：str

访问列表内的元素

• 列表 从0开始 为它的每一个元素顺序创建 下标索引，直到 总长度减一 。要访问它的某个元素，以方括号加下标值的方式即可。
• 注意要确保索引不越界，一旦访问的 索引超过范围，会抛出异常。所以，一定要记得最后一个元素的索引是 len(list)-1。

li1 = [1, 22, 333, '123']
print(li1[3])
print(li1[-1])


123
123

修改列表内的元素

• 直接取出元素进行重新赋值

li1 = [1, 22, 333, '123']
li1[2] = 444
print(li1)


[1, 22, 444, '123']

删除列表内的元素

• 直接 取出元素，再通过 del语句 或者 list.remove() 或者 list.pop() 进行删除

li1 = [1, 22, 333, '123']
del li1[0]          # 删除 索引值为 0 的元素
print(li1)


[22, 333, '123']

li1 = [1, 22, 333, '123']
li1.remove(1)         # 移除列表中的元素 1
print(li1)


[22, 333, '123']

注意:remove()是对值进行删除

li1 = [1, 22, 333, '123']
li1.pop()           # 默认弹出最后一个元素
print(li1)
li1.pop(2)          # 指定弹出索引值为 2 的元素
print(li1)


[1, 22, 333]
[1, 22]

列表的特殊操作

列表相加

• 不是对应位置相加,而是拼接

li1 = [1, 22, 333]
li2 = [4444, 55555]
print(li1 + li2)


[1, 22, 333, '123', 4444, 55555]

成员判断

• 用in进行判断

li1 = [1, 22, 333]
print(1 in li1)


True

与整数相乘

li1 = [1, 22, 333]
print(li1 * 2)


[1, 22, 333, 1, 22, 333]

li1 = [1, 22, 333]
li2 = [4444, 55555]
print(li1 * li2)   # 列表与列表不能相乘

Traceback (most recent call last):
    print(li1 * li2)
TypeError: can't multiply sequence by non-int of type 'list'

迭代

li1 = [1, 22, 333]
for i in li1:
    print(i)


1
22
333

相当于快速取出每一个元素

列表的常用内置函数

li1 = [1, 22, 333]
li2 = [1, 2, 3, '4']
print(len(li1))        # 输出 li1 的长度即元素的个数
print(max(li1))        # 输出 li1 的最大元素(比较ascii码)
print(min(li1))        # 输出 li1 的最小元素(比较ascii码)
print(max(li2))        # int 与 str 不能作比较


3
333
1
Traceback (most recent call last):
    print(max(li2))
TypeError: '>' not supported between instances of 'str' and 'int'

列表的排序与反转

li2 = [1, 2, 3, 4, 5, 6, 2, 4, 1]
li2.sort()                  # 对 li2 进行排序默认升序
print(li2)
li2.sort(reverse=True)      # 对 li2 进行降序排列
print(li2)


[1, 1, 2, 2, 3, 4, 4, 5, 6]
[6, 5, 4, 4, 3, 2, 2, 1, 1]

li2 = [1, 2, 3, 4, 5, 6, 2, 4, 1]
li2.reverse()           # 将 li2 进行反转/逆序取出，没有返回值
print(li2)


[1, 4, 2, 6, 5, 4, 3, 2, 1]

列表的切片

slice(start, stop[, step])
切片模式:

a[start:stop:step]

start为起始位置默认为0
stop为结束位置默认最后一个元素
step可选参数:步长,默认为1

li2 = [1, 2, 3, 4, 5, 6, 2, 4, 1]
print(li2[3:7:2])
'''
对列表 li2 进行切片
起始位置为索引值为3的元素，
结束位置为索引值为7的元素，
步长为2
'''

[4, 6]

注意:取值左闭右开

列表的常见操作

L.append(object) --> 在列表末尾添加新的对象

li1 = [1, 2, 3, 4, 5, 6, 2, 4, 1]
li1.append(10)				# 在列表末尾添加元素10
li1.append([10])			# 在列表末尾添加元素[10]
li1.append('hhhh')			# 在列表末尾添加元素'hhhh'
print(li1)


[1, 2, 3, 4, 5, 6, 2, 4, 1, 10, [10], 'hhhh']

L.count(object) --> 统计某个元素在列表中出现的次数,返回整数

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


1
2
1

L.extend(iterable) --> 用新列表扩展原来的列表
将列表元素直接扩展至原列表之后

li1 = [1, 2, 3, 4, 5]
li2 = [6, 7]
li1.extend(li2)         # 将li2扩展至li1中
print(li1)
li1.extend([8, 9])      # 将[8,9]扩展至li1中
print(li1)


[1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

L.index(value） --> 从列表中找出某个值第一个匹配项的索引位置

li1 = [1, 2, 3, 4, 5, 6, 2, 4, 1, [3, 3, 3]]
print(li1.index(2))         # 在列表li1中找到2的索引位置(第一个匹配项)


1

L.insert(index, object)–> 将对象插入列表

li1 = [1, 2, 3, 4, 5, 6, 2, 4, 1, [3, 3, 3]]
li2 = [7, 8, 9]
li1.insert(6, li2)          # 在列表索引值为6的位置插入li2
print(li1)


[1, 2, 3, 4, 5, 6, [7, 8, 9], 2, 4, 1, [3, 3, 3]]

L.pop([index]) --> 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

li1 = [1, 2, 3, 4, 5, 6, 2, 4, 1, [3, 3, 3]]
li1.pop(3)      # 弹出列表li1中索引值为3的元素
print(li1)
li1.pop()       # 弹出列表li1中的元素(默认最后一个) 
print(li1)


[1, 2, 3, 5, 6, 2, 4, 1, [3, 3, 3]]
[1, 2, 3, 5, 6, 2, 4, 1]

L.remove(value) --> 移除列表中某个值的第一个匹配项

li1 = [1, 2, 3, 4, 5, 6, 2, 4, 1, [3, 3, 3]]
li1.remove(4)    # 移除列表li1中的元素4
print(li1)
li1.remove(3)    # 移除列表li1中的元素3
print(li1)


[1, 2, 3, 5, 6, 2, 4, 1, [3, 3, 3]]
[1, 2, 5, 6, 2, 4, 1, [3, 3, 3]]

L.reverse() --> 反向列表中元素

li1 = [1, 2, 3, 4, 5, 6, 2, 4, 1, [3, 4, 5]]
li1.reverse()       # 反向列表li1中的元素
print(li1)


[[3, 4, 5], 1, 4, 2, 6, 5, 4, 3, 2, 1]

L.sort(reverse=False) --> 对原列表进行排序

li1 = [1, 2, 3, 4, 5, 6, 2, 4, 1]
li1.sort()                  # 对列表进行排序
print(li1)
li1.sort(reverse=True)      # 对列表进行排序后反向列表的元素
print(li1)
li1.sort(reverse=False)     # 对列表进行排序
print(li1)


[1, 1, 2, 2, 3, 4, 4, 5, 6]
[6, 5, 4, 4, 3, 2, 2, 1, 1]
[1, 1, 2, 2, 3, 4, 4, 5, 6]

L.copy() --> 复制列表

li1 = [1, 2, 3, 4, 5, 6, 2, 4, 1]
li2 = li1
li3 = li1.copy()     # 把li1的复制赋值给li3
print(li1)
print(li2)
print(li3)
print(type(li1))
print(type(li2))
print(type(li3))
print(id(li1))
print(id(li2))
print(id(li3))


[1, 2, 3, 4, 5, 6, 2, 4, 1]
[1, 2, 3, 4, 5, 6, 2, 4, 1]
[1, 2, 3, 4, 5, 6, 2, 4, 1]
<class 'list'>
<class 'list'>
<class 'list'>
1754170372352
1754170372352
1754170268928

L.clear() --> 清空列表

li1 = [1, 2, 3, 4, 5, 6, 2, 4, 1]
li1.clear()         # 清空列表
print(li1)


[]

删除列表的元素用del

li1 = [1, 2, 3, 4, 5, 6, 2, 4, 1]
del li1[7]        # 删除索引值为7的元素
print(li1)


[1, 2, 3, 4, 5, 6, 2, 1]

扩展 转化列表元素的属性

li1 = list('123456')
print(li1)
print(map(int, li1))      # map对象：映射，将li1中的每个元素传到了int（）中，之后再返回
print(list(map(int, li1)))      # 将map对象转为list呈现


['1', '2', '3', '4', '5', '6']
[1, 2, 3, 4, 5, 6]

元组

元组的介绍

• 元组也是 序列结构，但是是一种 不可变序列，你可以简单的理解为内容不可变的列表。除了在内部元素不可修改的区别外，元组和列表的用法差不多。

元组创建

• 创建一个元组，只要把 逗号 分隔的 不同的数据元素 使用 小括号 括起来即可。
• 还可以直接通过 tuple() 来进行创建元组。

tu = ()
print(type(tu))
print(tuple('123456789'))
print(tuple('abcdef'))


<class 'tuple'>
('1', '2', '3', '4', '5', '6', '7', '8', '9')
('a', 'b', 'c', 'd', 'e', 'f')

• 注意:只有一个元素时记得跟上英文状态下的逗号,否则就是普通小括号

tu1 = (123)
tu2 = (123,)
print(type(tu1))
print(type(tu2))


<class 'int'>
<class 'tuple'>

元组与列表相同的操作

• 使用 方括号加下标 访问元素
• 切片（形成新元组对象）
• tuple.count() / tuple.index()
• python内置函数：reversed()，sorted()
• 加法(拼接)及乘法(扩展)

tu1 = tuple("123456789123456")
print(tu1)
print(tu1[5])                   # 输出元组中索引值为5的值
print(tu1[2:6])                 # 切片，输出索引值2-6的元素(生成新元组对象)
print(tu1.count('2'))           # 输出元组tu1中2的个数
print(tu1.index('4'))           # 输出元组tu1中元素4的索引位置
print(tuple(reversed(tu1)))     # 使用内置函数reversed进行元素反转排列
print(sorted(tu1))              # 使用内置函数sorted进行排序，注意这里返回值为列表并非元组
print(tu1[::-1])                # 切片在这里也同样适用



('1', '2', '3', '4', '5', '6', '7', '8', '9', '1', '2', '3', '4', '5', '6')
6
('3', '4', '5', '6')
2
3
('6', '5', '4', '3', '2', '1', '9', '8', '7', '6', '5', '4', '3', '2', '1')
['1', '1', '2', '2', '3', '3', '4', '4', '5', '5', '6', '6', '7', '8', '9']
('6', '5', '4', '3', '2', '1', '9', '8', '7', '6', '5', '4', '3', '2', '1')

元组中不允许的操作

• 不允许 修改 、新增 元素。(一级为元组)

tu1 = (1, 2, 3, 4, [1, 2, 3])
tu1[3] = 5   # 对元组第三个索引值的元素进行赋值


Traceback (most recent call last):
  File "D:/python/stone/作业/2020-12-24.py", line 196, in <module>
    tu1[3] = 5   # 对元组第三个索引值的元素进行赋值
TypeError: 'tuple' object does not support item assignment

仅在一级元素是元组时不允许修改,例如当一级为列表时允许修改

tu1 = (1, 2, 3, 4, [1, 2, 3])

tu1[4][2] = 5   # 对元组第四个索引值列表的第三个索引值进行赋值，在一级元素是元组时不允许修改

(1, 2, 3, 4, [1, 2, 5])

• 不允许 删除 某个元素（但可以删除整个元组）
• 实际上，元组没有任何会对内部元素发生 修改 动作的方法。例如，元组没有remove，append，pop 等方法.
• 元组消耗的内存比列表要少

元组与列表的转换

• list→ tuple tuple(iterable)
• tuple→list list(iterable)

tu1 = (1, 2, 3,)
li1 = list(tu1)  # 将tu1转化为列表赋值给li1
print(li1)
print(type(li1))
tu2 = tuple(li1)  # 将li1转化为元组赋值给tu2
print(tu2)
print(type(tu2))


[1, 2, 3]
<class 'list'>
(1, 2, 3)
<class 'tuple'>

字典

字典的介绍

• Python 的字典数据类型是基于 hash 散列算法实现的，采用 键值对 (key:value) 的形式，根据 key 的值计算 value 的地址，具有非常快的查取和插入速度。它是一种 可变对象 ，所以支持修改、插入、删除等操作。

字典的创建

{ key1 : value1, key2 : value2}
dict()
dict(**kwargs)
dict(mapping)

dic1 = {
     'name': 'china', 'capital': 'beijing', 'population': '1.4 billion'}
dic2 = dict(name='china', capital='beijing', population='1.4 billion')  # dict(**kwargs)键对值
dic3 = dict([('name', 'china'), ('capital', 'beijing'), ('population', '1.4 billion')])  # dict(mapping)  映射
print(dic1)
print(dic2)
print(dic3)
print(dic1 == dic2 == dic3)


{
     'name': 'china', 'capital': 'beijing', 'population': '1.4 billion'}
{
     'name': 'china', 'capital': 'beijing', 'population': '1.4 billion'}
{
     'name': 'china', 'capital': 'beijing', 'population': '1.4 billion'}
True

注意：

• 在 Python3.6 开始，字典对象会保持键值插入时的 顺序，并且其包含的 元素个数不限，值的类型 也可以是其它任何数据类型。
• 字典的 key 必须是 不可变的对象，例如整数、字符串、bytes 和元组，但使用最多的还是字符串。 列表、字典、集合等就不可以作为 key。同时，同一个字典内的 key 必须是唯一 的，但值则不必。

字典的访问

• 字典是 集合类型，不是序列类型，因此 没有索引下标 的概念，更 没有切片 的说法。但是，与 list 类似，字典采用把 相应的键 放入 方括号 内获取 对应值 的方式取值。如果访问的值不存在则会报错.
  如：dic[exit_key]

dic1 = {
     'name': 'china', 'capital': 'beijing', 'population': '1.4 billion'}
print(dic1['name'])


china

字典的增加与修改

• 增加 就是往字典 插入新的键值对

dic1 = {
     'name': 'china', 'capital': 'beijing', 'population': '1.4 billion'}
dic1['the measure of area'] = '9.6 million square kilometers'
print(dic1)


{
     'name': 'china', 'capital': 'beijing', 'population': '1.4 billion', 'the measure of area': '9.6 million square kilometers'}

• 修改 就是给 原有的键赋予新的值。由于一个 key 只能对应一个值，所以，多次对一个 key 赋值，后面的值会把前面的值 覆盖 掉。

di1 = {
     'a': '2', 'b': '4', 'c': '6'}
di1['c'] = '8'
print(di1)


{
     'a': '2', 'b': '4', 'c': '8'}

字典的一系列删除

• 删除字典元素：del dic[exit_key] 或 dic.pop(exit_key)

di1 = {
     'a': '2', 'b': '4', 'c': '6'}
del di1['b']        # 删除 b
print(di1)

{
     'a': '2', 'c': '6'}

di1 = {
     'a': '2', 'b': '4', 'c': '6'}
di1.pop('c')
print(di1)


{
     'a': '2', 'b': '4'}

• 删除整个字典：del dic

di1 = {
     'a': '2', 'b': '4', 'c': '6'}
del di1
print(di1)

Traceback (most recent call last):
    print(di1)
NameError: name 'di1' is not defined

• 清空整个字典：dic.clear()

di1 = {
     'a': '2', 'b': '4', 'c': '6'}
di1.clear()
print(di1)

{
     }

字典的常见操作

• D.get(k[,d]) --> 返回指定键的值，如果值不在字典中，则返回default值

dic1 = {
     'name': 'china', 'capital': 'beijing', 'population': '1.4 billion'}
print(dic1.get('name'))
print(dic1.get('names'))


china
None

• D.items() --> 以列表返回可遍历的(键, 值) 元组对

dic1 = {
     'name': 'china', 'capital': 'beijing', 'population': '1.4 billion'}
for key, value in dic1.items():
    print(key, value)


name china
capital beijing
population 1.4 billion

• D.keys() --> 以列表返回字典所有的键

dic1 = {
     'name': 'china', 'capital': 'beijing', 'population': '1.4 billion'}
print(dic1.keys())


dict_keys(['name', 'capital', 'population'])

• D.values() --> 以列表返回字典所有的值

dic1 = {
     'name': 'china', 'capital': 'beijing', 'population': '1.4 billion'}
print(dic1.values())

dict_values(['china', 'beijing', '1.4 billion'])

li1 = ('name', 'capital', 'population')
li2 = ('china', 'beijing', '1.4 billion')
print(list(zip(li1, li2)))      # zip对象：打包，将可迭代对象里的元素一一对应进行


[('name', 'china'), ('capital', 'beijing'), ('population', '1.4 billion')]