Python字典,元组与集合

Python字典,元组与集合

字典

什么是字典

• Python内置的数据结构之一，与列表一样是一个可变序列
• 以键值对的方式存储数据，字典是一个无序的序列
  

字典示意图

字典的实现原理

• 字典的实现原理与查字典类似，查字典是先根据部首或拼音查找汉字对应的页码，Python中的字典是根据key查找value所在的位置

字典的创建

字典的创建
最常用的方式：使用花括号

使用内置函数dict()

'''字典的创建方式'''
'''使用{}创建字典'''
scores={'张三':100,'李四':98,'王五':45}
print(scores)
print(type(scores))

'''第二种创建dict()'''
student=dict(name='jack',age=20)
print(student)

'''空字典'''
d={}
print(d)

字典的常用操作

字典中元素的获取

[]取值与使用get()取值的区别

• []如果字典中不存在指定的key，抛出keyError异常
• get()方法取值，如果字典中不存在指定的key，并不会抛出KeyError而是返回None，可以通过参数设置默认的value，以便指定的key不存在时返回

'''获取字典的元素'''
scores={'张三':100,'李四':98,'王五':45}
'''第一种方式，使用[]'''
print(scores['张三'])
#print(scores['陈六']) #KeyError: '陈六'

'''第二种方式，使用get()方法'''
print(scores.get('张三'))
print(scores.get('陈六')) #None
print(scores.get('麻七',99)) #99是在查找'麻七'所对的value不存在时，提供的一个默认值

字典的常用操作

• key的判断

• 字典元素的删除

• 字典元素的新增

'''key的判断'''
scores={'张三':100,'李四':98,'王五':45}
print('张三' in scores)
print('张三' not in scores)

del scores['张三']  #删除指定的key-value对
#scores.clear()  #清空字典的元素
print(scores)
scores['陈六']=98   #新增元素
print(scores)

scores['陈六']=100  #修改元素
print(scores)

字典的常用操作

• 获取字典视图的三个方法
  
• 字典元素的遍历

scores={'张三':100,'李四':98,'王五':45}
#字典元素的遍历
for  item  in scores:
    print(item,scores[item],scores.get(item))


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

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

lst=[10,20,30]
lst.insert(1,100)
print(lst)
d={lst:100}
print(d)

字典的特点

• 字典中的所有元素都是一个 key-value对，key不允许重复， value可以重复
• 字典中的元素是无序的
• 字典中的key必须是不可变对象
• 字典也可以根据需要动态地伸缩
• 字典会浪费较大的内存，是一种使用空间换时间的数据结构

字典生成式

• 内置函数zip()
• 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表

items=['Fruits','Books','Others']
prices=[96,78,85,100,120]

d={item.upper():price    for item ,price in zip(items,prices)  }
print(d)

总结

元组

'''不可变序列，可变序列'''
'''可变序列  列表，字典'''
lst=[10,20,45]
print(id(lst))
lst.append(300)
print(id(lst))
'''不可变序列，字符串,元组'''
s='hello'
print(id(s))
s=s+'world'
print(id(s))
print(s)

什么是元组

元组

• Python内置的数据结构之一，是一个不可变序列

不可变序列与可变序列

• 不变可变序:字符串、元组

不变可变序列：没有增、删，改的操作

• 可变序列:列表、字典

可变序列：可以对序列执行增、删、改操作，对象地址不发生更改

元组的创建方式

• 直接小括号

• 使用内置函数tuple()

• 只包含一个元组的元素需要使用逗号和小括号

'''元组的创建方式'''
'''第一种创建方式，使用()'''
t=('Python','world',98)
print(t)
print(type(t))

t2='Python','world',98  #省略了小括号
print(t2)
print(type(t2))

t3=('Python',)  #如果元组中只有一个元素，  逗号不能省
print(t3)
print(type(t3))

'''第二种创建方式，使用内置函数tuple()'''
t1=tuple(('Python','world',98))
print(t1)
print(type(t1))

'''空元组的创建方式'''
'''空列表的创建方式'''
lst=[]
lst1=list()

d={}
d2=dict()

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

print('空列表',lst,lst1)
print('空字典',d,d2)
print('空元组',t4,t5)

为什么要将元组设计成不可变序列

为什么要将元组设计成不可变序列

• 在多任务环境下，同时操作对象时不需要加锁
• 因此，在程序中尽量使用不可变序列

注意事项：元组中存储的是对象的引用
a)如果元组中对象本身不可对象，则不能再引用其它对象
b)如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变

t=(10,[20,30],9)
print(t)
print(type(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))
'''尝试将t[1]修改为100'''
print(id(100))
#t[1]=100   #元组是不允许修改元素的
'''由于[20,30]列表，而列表是可变序列，所以可以向列中添加元素，而列表的内存地址不变'''
t[1].append(100)  #向列表中添加元素
print(t,id(t[1]))

元组的遍历

元组是可迭代对象，所以可以使用for…in进行遍历

'''元组的遍历'''
t=('Python','world',98)
'''第一种获取元组元组的方式，使用索引'''
print(t[0])
print(t[1])
print(t[2])
#print(t[3]) #IndexError: tuple index out of range
'''遍历元组'''
for item in t:
    print(item)

集合

什么是集合

• Python语言提供的内置数据结构
• 与列表、字典一样都属于可变类型的序列
• 集合是没有value的字典

集合的创建方式

直接{}

使用内置函数set()

'''第一种创建方式使用{}'''
s={2,3,4,5,5,6,7,7} #集合中的元素不允许重复
print(s)

'''第二种创建方式使用set()'''

s1=set(range(6))
print(s1,type(s1))

s2=set([1,2,4,5,5,5,6,6])
print(s2,type(s2))

s3=set((1,2,4,4,5,65))  #集合中的元素是元序的
print(s3,type(s3))

s4=set('python')
print(s4,type(s4))

s5=set({12,4,34,55,66,44,4})
print(s5,type(s5))

#定义一个空集合
s6={}   #dict字典类型
print(type(s6))

s7=set()
print(type(s7))

集合的相关操作

• 集合元素的判断操作

in或not in

• 集合元素的新增操作

调用add()方法，一次添中一个元素
调用update()方法至少添中一个元素

• 集合元素的删除操作

调用remove()方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError
调用discard()方法，一次删除一个指定元素，如果指定的元素不存在不抛异常
调用pop()方法，一次只删除一个任意元素
调用clear()方法，清空集合

#集合的相关操作
s={10,20,30,405,60}
'''集合元素的判断操作'''
print(10 in s)  #True
print(100 in s) # False
print(10 not in s) #False
print(100 not in s) #True
'''集合元素的新增操作'''
s.add(80)  #add一次添加一个元素
print(s)
s.update({200,400,300})  #一次至少添加一个元素
print(s)
s.update([100,99,8])
s.update((78,64,56))
print(s)

'''集合元素的删除操作'''
s.remove(100)
print(s)
#s.remove(500) #KeyError: 500
s.discard(500)
s.discard(300)
print(s)
s.pop()
s.pop()

#s.pop(400) #TypeError: pop() takes no arguments (1 given)
print(s)
s.clear()
print(s)

集合间的关系

• 两个集合是否相等

可以使用运算符==或!=进行判断

• 一个集合是否是另一个集合的子集

可以调用方法issubset进行判断
B是A的子集

• 一个集合是否是另一个集合的超集

可以调用方法issuperset进行判断
A是B的超集

• 两个集合是否没有交集

可以调用方法isdisjoint进行判断

'''两个集合是否相等（元素相同，就相等）'''
s={10,20,30,40}
s2={30,40,20,10}
print(s==s2)   #True
print(s!=s2)   #False

'''一个集合是否是另一个集合的子集'''
s1={10,20,30,40,50,60}
s2={10,20,30,40}
s3={10,20,90}
print(s2.issubset(s1))  #True
print(s3.issubset(s1))  #False

'''一个集合是否是另一个集合的超集'''
print(s1.issuperset(s2))  #True
print(s1.issuperset(s3))  #False

'''两个集合是否含有交集'''
print(s2.isdisjoint(s3))  #False   有交集为False
s4={100,200,300}

print(s2.isdisjoint(s4))  #True    没有交集为True

集合的数学操作

#（1）交集
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2))
print(s1 & s2)    #intersection()与 & 等价，交集操作

print(s1)
print(s2)
#(2)并集操作
print(s1.union(s2))
print( s1| s2)  #union与  | 等价，并集操作
print(s1)
print(s2)

#(3)差集操作
print(s1.difference(s2))
print(s1-s2)

print(s1)
print(s2)

#（4）对称差集
print(s1.symmetric_difference(s2))
print(s1^ s2)

集合生成式

• 将{}修改为[]就是列表生成式^_
• 没有元组生成式

#列表生成式
lst=[ i*i for i in range(10)]
print(lst)


#集合生成式
s={ i*i for i in range(10)}
print(s)

列表、字典、元组、集合总结