Python学习笔记5:字典、集合、序列

字典、集合、序列

可变类型与不可变类型

  • 序列以连续的整数为索引,字典以”关键字”为索引,关键字可以是任意不可变类型,通常用字符串或数值。
  • 字典是 Python 唯一的一个 映射类型,字符串、元组、列表属于序列类型。

那么如何快速判断一个数据类型 X 是不是可变类型的呢?两种方法:

  • id(X) 函数,对 X 进行某种操作,比较操作前后的 id,如果不一样,则 X 不可变,如果一样,则 X 可变。
  • 用 hash(X),只要不报错,证明 X 可被哈希,即不可变,反过来不可被哈希,即可变。
a=2
print(id(a))
# 140708864382016
a=a+1
print(id(a))
# 140708864382048

l=[1,2,3,4,5]
print(id(l))
# 2283131856328
l.remove(2)
print(id(l))
# 2283131856328
  • 整数a在加 1 之后的 id 变了,因此整数是不可变类型。
  • 列表 l 在删除 2 之后的 id 不变,因此列表是可变类型。
print(hash(5))
# 5
print(hash('hello'))
# -1588137811634571395
print(hash((1,2,3,'a')))
# 1145584121287932706
print(hash([1,2,3,4,5]))
# Traceback (most recent call last):
# File "<pyshell#12>", line 1, in <module>
# print(hash([1,2,3,4,5]))
# TypeError: unhashable type: 'list'
print(hash({ 1,2,3,4,5}))
# Traceback (most recent call last):
# File "<pyshell#13>", line 1, in <module>
 # print(hash({1,2,3,4,5}))
# TypeError: unhashable type: 'set'
print(hash({ 1:'a',2:'b',3:'c'}))
# Traceback (most recent call last):
# File "<pyshell#16>", line 1, in <module>
# print(hash({1:'a',2:'b',3:'c'}))
# TypeError: unhashable type: 'dict'
  • 数值、字符和元组 都能被哈希,因此它们是不可变类型。
  • 列表、集合、字典不能被哈希,因此它是可变类型。

一、字典

字典:无序的 键:值(key:value)对集合,键必须是唯一的(在同一个字典之内)。
d = {key1 : value1, key2 : value2 }

  • dict 内部存放的顺序和 key 放入的顺序是没有关系的。
  • dict 查找和插入的速度极快,不会随着 key 的增加而变慢,但是需要占用大量的内存。

1.创建和访问

  • 通过字符串或数值作为key来创建字典
dic = { '李宁': '一切皆有可能', '耐克': 'Just do it', '阿迪达斯': 'Impossible is nothing'}
print('耐克的口号是:', dic['耐克'])  
# 耐克的口号是: Just do it

dic1 = { 1: 'one', 2: 'two', 3: 'three'}
print(dic1)  
# {1: 'one', 2: 'two', 3: 'three'}
print(dic1[1])  
# one
print(dic1[4])  
# KeyError: 4

如果我们取的键在字典中不存在,会直接报错KeyError

  • 通过元组作为key来创建字典,但一般不这样使用
dic = { (1, 2, 3): "Tom", "Age": 12, 3: [3, 5, 7]}
print(dic,type(dic))
# {(1, 2, 3): 'Tom', 'Age': 12, 3: [4, 5, 6]} <class 'dict'>
  • 通过构造函数dict()来创建字典
    通过key直接把数据放入字典中,但一个key只能对应一个value,多次对一个key放入 value,后面的值会覆盖前面的值。
dic = dict()
dic['a'] = 1
dic['b'] = 2
dic['c'] = 3

print(dic)
# {'a': 1, 'b': 2, 'c': 3}

dic['a'] = 11
print(dic)
# {'a': 11, 'b': 2, 'c': 3}

dic['d'] = 4
print(dic)
# {'a': 11, 'b': 2, 'c': 3, 'd': 4}

dict(mapping) new dictionary initialized from a mapping object’s (key, value) pairs

dic1 = dict([('apple', 4139), ('peach', 4127), ('cherry', 4098)])
print(dic1)  
# {'cherry': 4098, 'apple': 4139, 'peach': 4127}

dic2 = dict((('apple', 4139), ('peach', 4127), ('cherry', 4098)))
print(dic2) 
 # {'peach': 4127, 'cherry': 4098, 'apple': 4139}

dict(**kwargs) new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)
这种情况下,键只能为字符串类型,并且创建的时候字符串不能加引号,加上就会直接报语法错误。

dic = dict(name='Tom', age=10)
print(dic,type(dic))  
# {'name': 'Tom', 'age': 10} <class 'dict'>

2.字典的内置方法

  • dict.fromkeys(seq[, value]) 用于创建一个新字典,以序列 seq 中元素做字典的键,value 为字典所有键对应的初始值。
seq = ('name', 'age', 'sex')
dic1 = dict.fromkeys(seq)
print(dic1)
# {'name': None, 'age': None, 'sex': None}

dic2 = dict.fromkeys(seq, 10)
print(dic2)
# {'name': 10, 'age': 10, 'sex': 10}

dic3 = dict.fromkeys(seq, ('小明', '10', '男'))
print(dic3)
# {'name': ('小明', '10', '男'), 'age': ('小明', '10', '男'), 'sex': ('小明', '10', '男')}
  • dict.keys()返回一个可迭代对象,可以使用 list() 来转换为列表,列表为字典中的所有键。
  • dict.values()返回一个迭代器,可以使用 list() 来转换为列表,列表为字典中的所有值。
  • dict.items()以列表返回可遍历的 (键, 值) 元组数组。
dic = { 'Name': '小明', 'Age': 10}
print(dic.keys())  
# dict_keys(['Name', 'Age'])
lst = list(dic.keys())  
# 转换为列表
print(lst)  
# ['Name', 'Age']

print(dic.values())
# dict_values(['小明', 10])
lst=list(dic.values())
print(lst)
# ['小明', 10]

print(dic.items())
# dict_items([('Name', '小明'), ('Age', 10)])
print(list(dic.items()))
# [('Name', '小明'), ('Age', 10)]
print(tuple(dic.items()))
# (('Name', '小明'), ('Age', 10))
  • dict.get(key, default=None) 返回指定键的值,如果值不在字典中返回默认值。
  • dict.setdefault(key, default=None)get()方法 类似, 如果键不存在于字典中,将会添加键并将值设为默认值。
dic={ 'Name':'小明','Age':10,'Sex':'男'}
print(dic.get('Age'))
# 10
print(dic.get('School'))
# None

print(dic.setdefault('Name',None))
# 小明
print(dic.setdefault('School',None))
# None
print(dic)
# {'Name': '小明', 'Age': 10, 'Sex': '男', 'School': None
  • key in dictkey not in dict:判断键是否存在于字典中。
dic={ 'Name':'小明','Age':10,'Sex':'男','School': None}
print('Name' in dic)
# True
print('weight' in dic)
# False
print('Age' not in dic)
# False
  • dict.pop(key[,default])删除字典给定键 key 所对应的值,并返回被删除的值。key 值必须给出,若key不存在,则返回 default值。
  • del dict[key] 删除字典给定键 key 所对应的值。
  • dict.popitem()随机返回并删除字典中的一对键和值,如果字典已经为空,却调用了此方法,就报出KeyError异常。
  • dict.clear() 删除字典内所有元素。
dic={ 'Name':'小明','Age':10,'Sex':'男','School': None}
print(dic.pop('School'))
# None
print(dic)
# {'Name': '小明', 'Age': 10, 'Sex': '男'}
print(dic.pop('Weight'))
# Traceback (most recent call last):
# File "<pyshell#23>", line 1, in <module>
# print(dic.pop('Weight'))
# KeyError: 'Weight'

del dic['Age']
print(dic)
# {'Name': '小明', 'Sex': '男'}

print(dic.popitem())
# ('Sex', '男')
print(dic)
# {'Name': '小明'}

print(dic.clear())
# None
print(dic.popitem())
# Traceback (most recent call last):
# File "<pyshell#30>", line 1, in <module>
# print(dic.popitem())
# KeyError: 'popitem(): dictionary is empty'
  • dict.copy()返回一个字典的浅拷贝
dic={ 'Name': '小明', 'Age': 10, 'Sex': '男'}
dic1=dic.copy()
print(dic1)
# {'Name': '小明', 'Age': 10, 'Sex': '男'}

直接赋值和浅拷贝

dic={ 'Name': '小明', 'Age': 10, 'Sex': '男'}
dic1=dic.copy()
dic2=dic
print(id(dic))      # 2292380500256
print(id(dic1))     # 2292381296752
print(id(dic2))     # 2292380500256
dic['Age']=11
print(dic)
# {'Name': '小明', 'Age': 11, 'Sex': '男'}
print(dic1)
# {'Name': '小明', 'Age': 10, 'Sex': '男'}
print(dic2)
# {'Name': '小明', 'Age': 11, 'Sex': '男'}
  • dict.update(dict2)把字典参数 dict2key:value对 更新到字典 dict 里。
dic={ 'Name': '小明', 'Age': 10, 'Sex': '男'}
dic2={ 'Weight':40}
dic.update(dic2)
print(dic)
# {'Name': '小明', 'Age': 10, 'Sex': '男', 'Weight': 40}

练习题

1、字典基本操作

dic = { 
    'python': 95,
    'java': 99,
    'c': 100
    }

用程序解答下面的题目

  • 字典的长度是多少
  • 请修改’java’ 这个key对应的value值为98
  • 删除 c 这个key
  • 增加一个key-value对,key值为 php, value是90
  • 获取所有的key值,存储在列表里
  • 获取所有的value值,存储在列表里
  • 判断 javascript 是否在字典中
  • 获得字典里所有value 的和
  • 获取字典里最大的value
  • 获取字典里最小的value
  • 字典 dic1 = {‘php’: 97}, 将dic1的数据更新到dic中
print(len(dic))
# 3

dic['java']=98
print(dic)
# {'python': 95, 'java': 98, 'c': 100}

print(dic.pop('c'))
# 100
print(dic)
# {'python': 95, 'java': 98}

dic1={ 'php':90}
dic.update(dic1)
print(dic)
# {'python': 95, 'java': 98, 'php': 90}

lst=list(dic.keys())
print(lst)
# ['python', 'java', 'php']

lst=list(dic.values())
print(lst)
# [95, 98, 90]

print('javascript' in dic)
# False
print(sum(dic.values()))
# 283

print('javascript' in dic)
# False

print(sum(dic.values()))
# 283

print(max(dic.values()))
# 98

print(min(dic.values()))
# 90

dic1={ 'php':97}
dic.update(dic1)
print(dic)
# {'python': 95, 'java': 98, 'php': 97}

2、字典中的value
有一个字典,保存的是学生各个编程语言的成绩,内容如下

data = { 
        'python': { '上学期': '90', '下学期': '95'},
        'c++': ['95', '96', '97'],
        'java': [{ '月考':'90', '期中考试': '94', '期末考试': '98'}]
        }

各门课程的考试成绩存储方式并不相同,有的用字典,有的用列表,但是分数都是字符串类型,请实现函数transfer_score(score_dict),将分数修改成int类型

def transfer_score(data):
    lst=list(data.keys())
    for i in lst:
        v=data.get(i)
        if isinstance(v,dict):
            transfer_score(v)
        if isinstance(v,list):
            n=0
            for k in v:
                if isinstance(k,dict):
                    transfer_score(k)
                if isinstance(k,str):
                    data[i][n]=int(k)
                    n=n+1
        if isinstance(v,str):
            data[i]=int(v)

transfer_score(data)
print(data)

# { 
# 'python': {'上学期': 90, '下学期': 95}, 
# 'c++': [95, 96, 97], 
# 'java': [{'月考': 90, '期中考试': 94, '期末考试': 98}]
# }

二、集合

Python 中setdict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key

注意,key为不可变类型,即可哈希的值。

num = { }
print(type(num))  
# <class 'dict'>
num = { 1, 2, 3, 4}
print(type(num))  
# <class 'set'>

1.创建

  • 先创建对象再加入元素。
  • 在创建空集合的时候只能使用s = set(),因为s = {}创建的是空字典。
basket = set()
basket.add('apple')
basket.add('banana')
print(basket)  
# {'banana', 'apple'}
  • 直接把所有元素用花括号括起来{元素1, 元素2, ..., 元素n}
  • 重复元素在set中会被自动被过滤。
basket = { 'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)  
# {'banana', 'apple', 'pear', 'orange'}

# 去掉列表中重复的元素
lst=[1,2,3,4,5,2,3]
x=set(lst)
lst1=list(x)
print(lst1)
# [1, 2, 3, 4, 5]
  • 使用set(value)工厂函数,把列表或元组转换成集合。
a=set('agergvdvrbbgt')
print(a)
# {'t', 'd', 'r', 'a', 'v', 'e', 'g', 'b'}
x=set(('a','b','c'))
print(x)
# {'a', 'b', 'c'}
x=set(['a','b','c'])
print(x)
# {'a', 'b', 'c'}

集合特点:无序、唯一
由于 set 存储的是无序集合,所以不可以为集合创建索引或执行切片操作,也没有键可用来获取集合中元素的值,但是可以判断一个元素是否在集合中。

2.访问

  • len()返回集合的大小
s=set([1,2,3,4,5,6])
print(len(s))
# 6

# 把集合中的数据一个个读取出来。
for i in s:
	print(i)	
# 1
# 2
# 3
# 4
# 5
# 6
  • innot in判断一个元素在集合中是否存在
print('d' in s)
# False
print('a' not in s)
# False

3.集合的内置方法

  • set.add(elmnt)用于给集合添加元素,如果添加的元素在集合中已存在,则不执行任何操作。
fruits = { "apple", "banana", "cherry"}
fruits.add("orange")
print(fruits)  
# {'orange', 'cherry', 'banana', 'apple'}
fruits.add("apple")
print(fruits)  
# {'orange', 'cherry', 'banana', 'apple'}
  • set.update(set)用于修改当前集合,可以添加新的元素或集合到当前集合中,如果添加的元素在集合中已存在,则该元素只会出现一次,重复的会忽略。
x={ "apple", "banana", "cherry"}
y={ "pear","peach","banana"}
x.update(y)
print(x)
# {'banana', 'cherry', 'pear', 'peach', 'apple'}
  • set.remove(item) 用于移除集合中的指定元素。如果元素不存在,则会发生错误。
  • set.discard(value) 用于移除指定的集合元素。如果元素不存在,则不执行任何操作。
x={ "apple", "banana", "cherry"}
x.remove("cherry")
print(x)
# {'banana', 'apple'}
x.remove("cheryy")
# Traceback (most recent call last):
# File "<pyshell#35>", line 1, in <module>
# x.remove("cheryy")
# KeyError: 'cheryy'

x.discard("apple")
print(x)
# {'banana'}
x.discard("apple")
print(x)
# {'banana'}
  • set.pop() 用于随机移除一个元素,并返回该元素。
fruits = { "apple", "banana", "cherry"}
x = fruits.pop()
print(x)  
# banana
print(fruits)  
# {'cherry', 'apple'}

由于 set 是无序和无重复元素的集合,所以两个或多个 set 可以做数学意义上的集合操作。

  • set1.intersection(set2) 返回两个集合的交集。
  • set1 & set2 返回两个集合的交集。
  • set1.intersection_update(set2) 交集,在原始的集合上移除不重叠的元素。
x=set('pear')
y=set('peach')
print(x)
# {'r', 'a', 'e', 'p'}
print(y)
# {'a', 'e', 'c', 'h', 'p'}

print(x.intersection(y))
# {'a', 'e', 'p'}
print(x & y)
# {'a', 'e', 'p'}
x.intersection_update(y)
print(x)
# {'a', 'e', 'p'}
  • set1.union(set2) 返回两个集合的并集。
  • set1 | set2 返回两个集合的并集。
x=set('pear')
y=set('peach')
print(x)
# {'r', 'a', 'e', 'p'}
print(y)
# {'a', 'e', 'c', 'h', 'p'}

print(x.union(y))
# {'r', 'a', 'e', 'c', 'h', 'p'}
print(x | y)
# {'r', 'a', 'e', 'c', 'h', 'p'}
  • set.difference(set) 返回集合的差集。
  • set1 - set2 返回集合的差集。
  • set.difference_update(set) 集合的差集,直接在原来的集合中移除元素,没有返回值。
x=set("pear")
y=set("peach")
print(x)
# {'r', 'a', 'e', 'p'}
print(y)
# {'a', 'e', 'c', 'h', 'p'}

print(x.difference(y))
# {'r'}
print(x-y)
# {'r'}
x.difference_update(y)
print(x)
# {'r'}
  • set1.symmetric_difference(set2)返回集合的异或。
  • set1 ^ set2 返回集合的异或。
  • set1.symmetric_difference_update(set2)移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。
x=set("pear")
y=set("peach")
print(x)
# {'r', 'a', 'e', 'p'}
print(y)
# {'a', 'e', 'c', 'h', 'p'}
print(x.symmetric_difference(y))
# {'c', 'h', 'r'}
print(x^y)
# {'c', 'h', 'r'}
x.symmetric_difference_update(y)
print(x)
# {'c', 'h', 'r'}
  • set1.issubset(set2)判断集合是不是被其他集合包含,如果是则返回 True,否则返回 False。
  • set1 <= set2 判断集合是不是被其他集合包含,如果是则返回 True,否则返回 False。
  • set1.issuperset(set2)用于判断集合是不是包含其他集合,如果是则返回 True,否则返回 False。
  • set1 >= set2 判断集合是不是包含其他集合,如果是则返回 True,否则返回 False。
x={ "a","b","c"}
y={ "a","b","c","d","e","f"}
print(x.issubset(y))
# True
print(x<=y)
# True

print(y.issuperset(x))
# True
print(y>=x)
# True
  • set1.isdisjoint(set2) 用于判断两个集合是不是不相交,如果是返回 True,否则返回 False。
x={ 'a','b','c'}
y={ 'e','f','g'}
print(x.isdisjoint(y))
# True
z={ 'a','e','f','g'}
print(x.isdisjoint(z))
# False

4.集合的转换

se = set(range(4))
li = list(se)
tu = tuple(se)

print(se, type(se))  # {0, 1, 2, 3} <class 'set'>
print(li, type(li))  # [0, 1, 2, 3] <class 'list'>
print(tu, type(tu))  # (0, 1, 2, 3) <class 'tuple'>

5.不可变集合

Python 提供了不能改变元素的集合的实现版本,即不能增加或删除元素,类型名叫frozenset。需要注意的是frozenset仍然可以进行集合操作,只是不能用带有updateremove的方法。

  • frozenset([iterable]) 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。
x=frozenset([1,2,3,4,5])
print(x)
# frozenset({1, 2, 3, 4, 5})
x.remove(2)
# Traceback (most recent call last):
# File "<pyshell#133>", line 1, in <module>
# x.remove(2)
# AttributeError: 'frozenset' object has no attribute 'remove'
x.update(6)
# Traceback (most recent call last):
# File "<pyshell#134>", line 1, in <module>
# x.update(6)
# AttributeError: 'frozenset' object has no attribute 'update'

练习题

  1. 怎么表示只包含⼀个数字1的元组。
t=(1,)
print(t,type(t))
# (1,) <class 'tuple'>
  1. 创建一个空集合,增加 {‘x’,‘y’,‘z’} 三个元素。
s=set()
s.add('x')
s.add('y')
s.add('z')
print(s)
# {'y', 'x', 'z'}
  1. 列表[‘A’, ‘B’, ‘A’, ‘B’]去重。
lst=['A','B','A','B']
lst=list(set(lst))
pprint(lst)
# ['A', 'B']
  1. 求两个集合{6, 7, 8},{7, 8, 9}中不重复的元素(差集指的是两个集合交集外的部分)。
s1=set([6,7,8])
s2=set([7,8,9])
print(s1.symmetric_difference(s2))
# {9, 6}
  1. 求{‘A’, ‘B’, ‘C’}中元素在 {‘B’, ‘C’, ‘D’}中出现的次数。
s1={ 'A','B','C'}
s2={ 'B','C','D'}
for i in s1:
    if i in s2:
        print(i,'出现次数:1')

# B 出现次数:1
# C 出现次数:1
# (集合的元素是无序、不重复的)

三、序列

在 Python 中,序列类型包括字符串、列表、元组、集合和字典,这些序列支持一些通用的操作,但比较特殊的是,集合和字典不支持索引、切片、相加和相乘操作。

1.序列的内置函数

  • list(sub) 把一个可迭代对象转换为列表。
  • tuple(sub) 把一个可迭代对象转换为元组。
  • str(obj)把obj对象转换为字符串。
s={ 1,3,5,7,9}
s1=list(s)
print(s1,type(s1))       # [1, 3, 5, 7, 9] <class 'list'>

s2=tuple(s)
print(s2,type(s2))       # (1, 3, 5, 7, 9) <class 'tuple'>

s3=str(s)
print(s3,type(s3))       # {1, 3, 5, 7, 9} <class 'str'>
  • len(s)返回对象(字符、列表、元组等)长度或元素个数。
  • max(sub)返回序列或者参数集合中的最大值。
  • min(sub)返回序列或者参数集合中的最小值。
  • sum(iterable[, start=0]) 返回序列iterable与可选参数start的总和。
  • reversed(seq) 函数返回一个反转的迭代器。要转换的序列,可以是 tuple, string, list 或 range。
s=[1,3,5,7,9]
print(len(s))
# 5
print(max(s))
# 9
print(min(s))
# 1
 print(sum(s[1:4]))
# 15

x=reversed(s)
print(list(x))
# [9, 7, 5, 3, 1]
  • sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序操作,并返回重新排序的列表。
  1. iterable :可迭代对象。
  2. key:主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
  3. reverse :排序规则,reverse = True 降序 , reverse = False 升序(默认)。
x=[1,5,8,12,3,6,9,11,25]
print(sorted(x))
# [1, 3, 5, 6, 8, 9, 11, 12, 25]
print(sorted(x,reverse=True))
# [25, 12, 11, 9, 8, 6, 5, 3, 1]

x=[('Age', 15),('Age',70),('Age',20)]
x2=sorted(x,key=lambda x:x[1])
print(x2)
# [('Age', 15), ('Age', 20), ('Age', 70)]
  • enumerate(sequence, [start=0])用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
fruits=['apple','pear','peach','orange']
for i in enumerate(fruits,1):
	print(i)
# (1, 'apple')
# (2, 'pear')
# (3, 'peach')
# (4, 'orange')
  • zip(iter1 [,iter2 [...]])
    1.用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。
    2.可以使用 list() 转换来输出列表。
    3.如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。
x=[1,2,3]
y=[4,5,6]
z=[1,2,3,4,5]
t=zip(x,y)
print(t)
# <zip object at 0x000001FD3765A948>
print(list(t))
# [(1, 4), (2, 5), (3, 6)]

t=zip(x,z)
print(list(t))
# [(1, 1), (2, 2), (3, 3)]

a,b=zip(*zip(x,y))
print(list(a))
# [1, 2, 3]
print(list(b))
# [4, 5, 6]

练习题

  1. 怎么找出序列中的最⼤、⼩值?
    max()min()函数
  2. sort() 和 sorted() 区别
  • sort() 是应用在list上的方法,属于列表的成员方法,sorted() 可以对所有可迭代的对象进行排序操作。
  • sort() 方法会在原list上直接进行排序,不会创建新的list。而sorted()方法不会对原来的数据做任何改动,排序后的结果是新生成的。
  • sort()使用方法为list.sort(),而sorted()使用方法为sorted(obj)
  1. 怎么快速求 1 到 100 所有整数相加之和?
print(sum(range(101)))
# 5050
  1. 求列表 [2,3,4,5] 中每个元素的立方根。
x=[2,3,4,5]
>>> for i in x:
	print(i,'的立方根:',pow(i,3))
# 2 的立方根: 8
# 3 的立方根: 27
# 4 的立方根: 64
# 5 的立方根: 125
  1. 将[‘x’,‘y’,‘z’] 和 [1,2,3] 转成 [(‘x’,1),(‘y’,2),(‘z’,3)] 的形式。
a=['x','y','z']
b=[1,2,3]
c=zip(a,b)
print(list(c))
# [('x', 1), ('y', 2), ('z', 3)]
    原文作者:evenw_
    原文地址: https://blog.csdn.net/evenw_/article/details/107700306
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞