# 普通创建
tup_one=(1,2,5,4)
tup_two='a','b','c','d' # 不需要括号也可以
print(type(tup_one),tup_one)
print(type(tup_two),tup_two)
# 传递值方式,类似多变量同时赋值,变量个数与元素个数要一致
tup_one=1,2,5,4
a,b,c,d=tup_one
print('a=',a)
print('b=',b)
print('c=',c)
print('d=',d)
# 如果变量个数与元素个数不一致,则在变量前面加个*号使对应变量变成列表,注意只能在其中一个变量加*号,不能多个变量加
tup_one=1,2,5,4
a,b,*c=tup_one
print('a=',a)
print('b=',b)
print('c=',c)
执行结果:
<class 'tuple'> (1, 2, 5, 4)
<class 'tuple'> ('a', 'b', 'c', 'd')
a= 1
b= 2
c= 5
d= 4
a= 1
b= 2
c= [5, 4]
tup_none=()
tup1=(66)
tup2=(66,)
print(type(tup1)) #
print(type(tup2))
元组与字符串类似,下标索引从0开始,可以进行截取,组合,重复等。
tup2=(2,66,'haha',88,'hello')
print(tup2[2]) # haha
print(tup2[1:3]) # (66, 'haha')
tup3=(33,188)
print(tup2+tup3) # (2, 66, 'haha', 88, 'hello', 33, 188)
print(tup3*3) # (33, 188, 33, 188, 33, 188)
tup4=('p','y','t','h','o','n')
tup4[2]='m' # 'tuple' object does not support item assignment
print(id(tup4)) # 内存地址:42259272
tup4=(1,2,3)
print(id(tup4)) # 内存地址变为:42941392
tup5=(1,2,6,4,5)
print(len(tup5)) # 计算元组的元素个数。
print(max(tup5)) # 返回元组中元素最大值。
print(min(tup5)) # 返回元组中元素最小值。
print(tuple('python')) # 将可迭代系列转换为元组。
字典是一种可变容器模型,可存储任意类型对象
字典的每个键值(key -> value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中:
dictionary={key1:value1,key2:value2,…}
键必须是唯一的,但值则不必。
字典的键和值是一种映射关系,通过唯一的键找对应的值。
不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住。
值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。
# 创建字典
dict_one={'a':1,'b':'hello','c':3,0:4}
print(type(dict_one),dict_one)
# 使用dict()函数来创建字典
dict1=dict(country='China',city='shenzhen') # 向函数传递两个参数
print(dict1)
# 如果序列中的元素也是序列,那么我们称这个元素为子序列
dict11=dict([('name','Jury'),('age',18)]) # 将双值子序列转化为字典
print(dict11)
执行结果:
<class 'dict'> {'a': 1, 'b': 'hello', 'c': 3, 0: 4}
{'country': 'China', 'city': 'shenzhen'}
{'name': 'Jury', 'age': 18}
dict1={'a':1,'b':2,'c':3,'0':4}
print(dict_one['b']) # 注意不要少了单引号,因为键的类型是字符串
print(dict_one['c'])
运行结果为:2 和 3
dict2={'a':1,'b':2,'c':3,'d':4}
dict2['b']='haha' # 更新键'b'的值
print(dict2) # {'a': 1, 'b': 'haha', 'c': 3, 'd': 4}
dict2['e']='new' # 添加新的键值对
print(dict2) # {'a': 1, 'b': 'haha', 'c': 3, 'd': 4, 'e': 'new'}
dict22={'a':{'name':'赵四','age':21},'b':2,'c':3}
print(dict22['a']['age'])
dict3={'name':'张三','age':22,'sex':'男','city':'深圳'}
del dict3['city'] # 删除键 'city'
print(dict3) # {'name': '张三', 'age': 22, 'sex': '男'}
dict3.clear() # 清空字典
print(dict3) # {}
del dict3 # 删除字典
函数 | 描述 |
---|---|
len(dict) | 计算字典元素个数,即键的总数。 |
str(dict) | 输出字典,以可打印的字符串表示。 |
type(variable) | 返回输入的变量类型,如果变量是字典就返回字典类型。 |
方法 | 描述 |
---|---|
dict.clear() | 删除字典内所有键和元素 |
dict.copy() | 返回一个字典的浅复制, |
dict.keys() | 返回一个迭代器(即字典的键),可以使用 list() 来转换为列表 |
dict.values() | 返回一个迭代器(即字典的值),可以使用 list() 来转换为列表 |
dict.fromkeys(seq[,value]) | 创建一个新字典,以序列seq中元素做字典的键,value(可选项)为字典所有键对应的初始值(value值只能有一个) |
dict.get(key,default=None) | 返回指定键的值,如果值不在字典中返回default值 |
dict.setdefault(key,default=None) | 和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default |
key in dict | 如果键在字典dict里返回true,否则返回false |
dict.items | 以列表形式返回可遍历的(键, 值) 元组数组 |
dict.update(dict1) | 把字典dict1的键/值对更新到dict里 |
dict.pop(key[,default]) | 删除字典给定键 key 所对应的值,并返回为被删除的值。key值必须给出。 否则,返回default值。 |
dict.popitem() | 删除字典中的最后一对键和值,并返回一个键值对(key,value)形式,按照 LIFO(Last In First Out 后进先出法) 顺序规则,即最末尾的键值对。 |
dict3={'name':'张三','age':22,'sex':'男','city':'深圳'}
dict4=dict3.copy() # 返回一个字典的浅复制
print(dict4)
d={'a':{'name':'钢铁侠','age':35},'b':2,'c':3}
d1=d.copy()
d1['a']['name']='美国队长'
print(d,id(d))
print(d1,id(d))
print(list(dict3.keys())) # 返回一个迭代器(即字典的键),可以使用 list() 来转换为列表
print(list(dict3.values())) # 返回一个迭代器(即字典的值),可以使用 list() 来转换为列表
dict5={}
dict5=dict5.fromkeys(['a','b','c'],10) # 创建一个新字典,以序列seq中元素做字典的键,value为字典所有键对应的初始值(value值只能有一个)
print(dict5)
print(dict5.get('c'))
print(dict5.get('d',20)) # 返回指定键的值,如果值不在字典中返回default值
dict5.setdefault('e',30) # 和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default
print(dict5)
print('e' in dict5) # 如果键在字典dict里返回true,否则返回false
print(dict5.items()) # 以列表形式返回可遍历的(键, 值) 元组数组
dict6={'old':'aa'}
dict6.update(dict5)
print(dict6)
print(dict6.pop('old')) # 删除字典给定键 key 所对应的值,并返回为被删除的值
print(dict6)
print(dict6.popitem()) # 删除字典中的最后一对键和值,并返回一个键值对(key,value)形式,按照 LIFO(Last In First Out 后进先出法) 顺序规则,即最末尾的键值对。
print(dict6)
运行结果:
{'name': '张三', 'age': 22, 'sex': '男', 'city': '深圳'}
['name', 'age', 'sex', 'city']
['张三', 22, '男', '深圳']
{'a': 10, 'b': 10, 'c': 10}
10
20
{'a': 10, 'b': 10, 'c': 10, 'e': 30}
True
dict_items([('a', 10), ('b', 10), ('c', 10), ('e', 30)])
{'old': 'aa', 'a': 10, 'b': 10, 'c': 10, 'e': 30}
aa
{'a': 10, 'b': 10, 'c': 10, 'e': 30}
('e', 30)
{'a': 10, 'b': 10, 'c': 10}
d={'name':'张三','age':22,'sex':'男','city':'深圳'}
for i in d.keys():
print(i)
for j in d.values():
print(j)
for i,j in d.items():
print(i,j)
运行结果:
name
age
sex
city
张三
22
男
深圳
name 张三
age 22
sex 男
city 深圳
set1={'a','c','a','c'}
print(set1)
set2=set('python')
print(set2)
运行结果:
{'c', 'a'}
{'t', 'n', 'h', 'o', 'p', 'y'}
a={i for i in 'abcdrbcad' if i not in 'abc'}
print(a) # {'r', 'd'}
方法 | 描述 |
---|---|
set.add() | 为集合添加元素,如果元素已存在则不进行任何操作 |
set.clear() | 移除集合中的所有元素 |
set.copy() | 拷贝一个集合 |
set1.difference(set2) | 返回两个集合的差集 |
set1.difference_update(set2) | 移除集合中的元素,该元素在指定的集合也存在。 |
set1.intersection(set2,set3,…) | 返回集合的交集,集合可以是多个,用逗号隔开 |
set1.intersection_update(set2,set3,…) | 返回集合的交集,该元素在指定的集合也存在,集合可以是多个,用逗号隔开 |
set1.symmetric_difference(set2) | 返回两个集合中不重复的元素集合。 |
set1.symmetric_difference_update(set2) | 移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。 |
set1.isdisjoint(set2) | 判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。 |
set1.issubset(set2) | 判断指定集合是否为该方法参数集合的子集。 |
set1.issuperset(set2) | 判断该方法的参数集合是否为指定集合的子集 |
set.pop() | 随机移除元素,并返回删除的元素 |
set.remove(value) | 移除指定元素,元素不存在则会报错 |
set.discard(value) | 删除集合中指定的元素,即使元素不存在也不会报错 |
set1.union(set2) | 返回两个集合的并集 |
set1.update(set2) | 给集合添加元素 |
ps:上面提及的方法可以自行尝试,由于篇幅问题,这里不做展示。