Python——字典、元组、集合

一.字典

1.定义

是python内置的数据结构之一，是一个可变序列 不可变序列为可执行增删改操作，比如str、int
以键值对的方式存储数据，是一个无序序列 根据hash()函数放（列表为有序序列 按顺序放）

字典名={'键1':值1,'键2':值2}

2.实现原理

根据key查找value所在的位置

3.创建

①字典名={'键key1':值value1,'键2':值2}
②使用内置函数dict()

dict(key1=value1,key2=value2)

③字典生成式：内置函数zip()

{字典key的表达式item.upper():字典value的表达式price  for key的变量item,value的变量price in zip(可迭代对象items,可迭代对象prices)
items=['Fruits','Books','Others']
prices=[96,78,85]
d={item.upper():price for item,price in zip(items,prices)}
print(d)#{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}

4.常用操作

（1）获取元素

①[]
键值不存在抛出KeyError
②get()
键值不存在为None

#获取元素①[]
scores={'张三':100,'李四':98,'王五':45}
print(scores['张三'])#100
#print(scores['张四'])#KeyError: '张四'
#②get()方法
print(scores.get('张三'))#100
print(scores.get('张四'))#None
print(scores.get('张四',99))#99  查找键为张四对应value不存在时，提供一个默认值99

（2）键key的判断、字典元素的删除、新增、修改

①键key的判断：in、not in

scores={'张三':100,'李四':98,'王五':45}
print('张三' in scores)#True

②字典元素的删除

scores={'张三':100,'李四':98,'王五':45}
del scores['张三']
print(scores)#{'李四': 98, '王五': 45}

③字典元素的增加、修改

scores={}
scores['陈六']=98
print(scores)##{'陈六': 98}
scores['陈六']=100
print(scores)##{'陈六': 100}

（3）获取字典视图

①获取所有键key：keys()

scores={'张三':100,'李四':98,'王五':45}
keys=scores.keys()
print(keys)#dict_keys(['张三', '李四', '王五'])  keys的类型为dict_keys
print(list(keys))#将所有键组成的视图转成列表  ['张三', '李四', '王五']

②获取所有值value：values()

scores={'张三':100,'李四':98,'王五':45}
values=scores.values()
print(values)#dict_values([100, 98, 45])  values的类型为dict_values
print(list(values))#将所有值组成的视图转成列表  [100, 98, 45]

③获取所有的键-值对：items()

scores={'张三':100,'李四':98,'王五':45}
items=scores.items()
print(items)#dict_items([('张三', 100), ('李四', 98), ('王五', 45)])  items的类型为dict_items
print(list(items))#[('张三', 100), ('李四', 98), ('王五', 45)]  ()为元祖 转换之后的列表元素是由元组组成

（4）遍历字典元素

scores={'张三':100,'李四':98,'王五':45}
for item in scores:
	#print(item)#张三 李四 王五
    print(item,scores[item],scores.get(item))#张三 100 100 李四 98 98 王五 45 45

5.字典的特点

①键key不允许重复，值value可以重复

d={'name':'张三','name':'李四'}#key不允许重复，若重复则覆盖
print(d)#{'name': '李四'}

d={'name':'张三','nickname':'张三'}#value可重复
print(d)#{'name': '张三', 'nickname': '张三'}

②字典中元素无序，所以不可以指定位置插入新元素
③字典中键key必须是不可变对象：整数、字符串
④字典可以根据需要动态伸缩
⑤字典会浪费较大内存，是一种使用空间换时间的数据结构

二.元组

1.定义：(元素对象1，元素对象2)

是python内置的数据结构之一，是一个不可变序列（没有增删改的操作，比如字符串、元组）
可变序列（可以对序列执行增删改的操作，对象地址不发生更改，比如字典、列表、集合）

2.创建

①直接小括号
②使用内置函数tuple()

#①直接小括号()
t=('Python','world',98)#可以省去()
print(t)#('Python', 'world', 98)
print(type(t))#<class 'tuple'>

#元组只有一个元素，逗号不能少
t2=(10,)#若为t2=(10)，则t2的类型为int
print(t2)

#空元组
t3=()
t4=tuple()

#②使用内置函数tuple()
t1=tuple(('Python','world',98))
print(t1)#('Python', 'world', 98)
print(type(t1))

3.为什么要设计成不可变序列

①在多任务环境下，同时操作对象时不需要加锁
多个用户不可以增删改这个对象，只能看
②注意：元组中存储的对象为对象的引用
如果元组中对象为不可变对象，则不能再引用其他对象
如果元组中对象为可变对象，则可变对象的引用不允许改变，但是数据可以改变

t=(10,[20,30],9)
print(t)
print(t[0],type(t[0]),id(t[0]))#10 <class 'int'> 3065215806032
print(t[1],type(t[1]),id(t[1]))#[20, 30] <class 'list'> 3065221133952
print(t[2],type(t[2]),id(t[2]))#9 <class 'int'> 3065215806000
#t[1]=100#TypeError 元组不允许修改元素
t[1].append(100)
print(t)#(10, [20, 30, 100], 9)

4.元组的遍历

t=('Python','world',98)
for item in t
    print(item)

三.集合

1.定义

是python内置的数据结构之一，是一个可变序列，是没有value的字典

2.创建

①直接{}
②使用内置函数set()

#创建①直接{}
s={2,3,4,5,5,6,7,7}
print(s)#{2, 3, 4, 5, 6, 7} 集合中元素不允许重复
#②使用内置函数set()
s1=set(range(6))
print(s1,type(s1))
s2=set([1,2,3,4,5,5,6,7,7])#把列表中的元素转为集合
print(s2,type(s2))#{1, 2, 3, 4, 5, 6, 7} <class 'set'>
s3=set((1,2,4,4,5,65))#把元组中的元素转为集合
print(s3,type(s3))#{65, 1, 2, 4, 5} <class 'set'> 可以说明集合中的元素无序
s4=set('python')#将字符串转为集合
print(s4,type(s4))#{'t', 'h', 'n', 'p', 'y', 'o'} <class 'set'>
s5=set({1,2,43,5,5})#将集合转为集合
print(s5,type(s5))#{1, 2, 43, 5} <class 'set'>
s6=set()#空集合，不可以为{}为字典

③集合生成式
{集合元素关于i的表达式 for 自定义变量i in 可迭代对象range(1,10)}

set1={i*i for i in range(10)}
print(set1)#{0, 1, 64, 4, 36, 9, 16, 49, 81, 25}

3.操作

（1）判断元素在不在集合中：in、not in

s={2,3,4,5,5,6,7,7}
print(4 in s)#True

（2）新增集合元素

①add()一次添加一个元素
②update()至少添加一个元素

s.add(80)
print(s)#{80, 2, 3, 4, 5, 6, 7}
s.update({200,400,300})#{2, 3, 4, 5, 6, 7, 200, 300, 80, 400}  其中{}还可以为()\[]
print(s)

（3）删除集合元素

①remove()一次删除一个指定元素，若指定元素不存在抛出KeyError
②discard()一次删除一个指定元素，若指定元素不存在不抛出异常
③pop()一次只删除一个任意元素 无参数
④clear()清空集合

s={2,3,4,5,5,6,7,7}
print(s)
s.remove(5)
s.discard(599)
print(s)#{2, 3, 4, 6, 7}
s.pop()
print(s)#{3, 4, 6, 7}
s.clear()
print(s)#set()

4.集合间的关系

①两个集合是否相等：==、!=
②一个集合是否是另一个集合的子集
方法issubset
③一个集合是否是另一个集合的超集
方法issuperset
④两个集合是否没有交集
方法isdisjoint

#相等
s={1,2,3,4}
s1={2,4,1,3}
print(s==s1)#True
#子集
s={1,2,3,4}
s1={2,4,1,3,8}
print(s.issubset(s2))#s是s1的子集吗？ True
#超集
print(s1.issuperset(s))#s1是s的超集吗？ True
#交集
print(s.isdisjoint(s1))#s与s1有交集吗？ 有交集为False

5.数学操作

①交集
②并集
③差集
④对称差集

#交集
s1={6,2,3,9}
s2={2,4,1,3,8}
print(s1.intersection(s2))#{2, 3}
print(s1 & s2)#{2, 3}
#并集
print(s1.union(s2))#{1, 2, 3, 4, 6, 8, 9}
print(s1 | s2)#{1, 2, 3, 4, 6, 8, 9}
#差集
print(s1.difference(s2))#{9, 6}
print(s1-s2)#{9, 6}
#对称差集
print(s1.symmetric_difference(s2))#{1, 4, 6, 8, 9}
print(s1^s2)#{1, 4, 6, 8, 9}