从零开始学Python 7

Python字典

Python内置的数据结构之一，与列表一样是一个可变序列，以键值对的方式存储数据，字典是一个无序的序列
scores={‘张三’:100,‘李四’:98,‘王五’:45}
其中冒号前面的时键，冒号后面的是值

字典的实现原理
Python字典的实现原理是根据key值查找value所在的位置

字典的创建
1.使用花括号：scores={‘张三’:100,‘李四’:98,‘王五’:45}
2.使用内置函数dict()：dict(name=‘jack’,age=20)

'''第一种使用{}'''
scores={'张三':100,'李四':98,'王五':45}
print(scores)
print(type(scores))

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

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

字典的常用操作

字典中元素的获取
第一种：使用[ ], scores[‘张三’]
第二种:get()方法，scores.get(‘张三’)

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

'''第二种方式，使用get()'''
print(scores.get('张三'))
print(scores.get('陈留'))  #None 不报错，会输出None
print(scores.get('玛琪玛',99)) #99是在查找玛琪玛不存在时提供的默认值

key的判断
in:指定的key在字典中存在返回True
not in：指定的key在字典中不存在返回会True
字典元素的删除
del scores[‘张三’]
字典元素的新增
scores[‘jack’]=90

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

'''字典元素的删除'''
del scores['张三']  #删除指定的键值对
print(scores)

'''删除字典中的元素'''
scores.clear()
print(scores)  #清空字典元素

'''添加元素'''
scores['陈六']=98  #新增元素
print(scores)

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

获取字典视图的三个方法
key():获取字典中所有的key
values():获取字典中所有的value
item():获取字典中所有的key，value对

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

#获取所有的value
values=scores.values()
print(values)
print(type(values))
print(list(values))

#获取所有的键值对
items=scores.items()
print(items)
print(list(items))  #转换之后的列表元素是由元组组成

字典元素的遍历
for item in scores：
print(item)

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

for item in scores:
    print(item,scores.get(item))

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

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

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

lst=[10,20,30]
lst.insert(1,100)
print(lst)  #列表可以根据索引插入value，字典不行，因为字典是无序的

#d={lst:100}  #报错，lst是可变对象不能用于字典
#print(d)

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

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

d={items:prices for items, prices in zip(items,prices)}
print(d)

Python元组

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

'''可变序列 列表、字典'''
lst=[1.,20,45]
print(id(lst))
lst.append(300)
print(id(lst))  #内存地址不变

'''不可变序列，字符串、元组'''
s='hello'
print(id(s))
s=s+'world'
print(id(s))  #内存地址发生改变

元组的创建方式

'''元组的创建方式'''
'''第一种'''
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))

'''空元组'''
t4=()
t5=tuple()
print(t4)
print(type(t4))
print(t5)
print(type(t5))

元组中存储的是对象的引用
如果元组中对象本身时不可变对象，则不能再引用其他对象
如果元组中对象是可变对象，则可变对象的引用不允许改变，但数据可以改变

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=('拉姆','雷姆',486)
'''第一种使用索引'''
print(t[0])
print(t[1])
print(t[2])
'''第二种遍历元组'''
for item in t:
    print(item)

集合

与列表、字典一样都属于可变类型的序列，集合时没有value的字典
集合的创建方式
直接创建：s={‘Python’,‘hello’,90}
使用内置函数set()

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

'''第二种方式使用内置函数set()'''
s1=set(range(6))
print(s1,type(s1))
s2=set([1,2,3,4,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,3,3,456,45,5})
print(s5,type(s5))

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

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

集合的判断操作
in 或 not in

s={2,3,4,456,48,6,5,5}
print(2 in s)
print(10 in s)
print(2 not in s)
print(10 not in s)

集合元素的新增操作
调用add()方法，一次添加一个元素
调用update()方法至少添加一个元素

s={2,3,4,456,48,6,5,5}
#集合元素的添加操作
s.add(100)   #一次添加一个元素
print(s)
s.update({200,300,400})  #一次至少添加一个元素
print(s)
s.update([10,20,32,60])
print(s)
s.update((23,21,123))
print(s)

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

s={32, 2, 3, 4, 5, 6, 100, 456, 200, 10, 300, 48, 400, 20, 21, 23, 123, 60}
#集合元素的删除操作
s.remove(100)
print(s)
s.discard(400)
print(s)
s.pop()
print(s)
s.clear()
print(s)

集合间的关系
两个集合是否相等可以用运算符==或！=进行判断

一个集合是否是另一个集合的子集可以调用issubset进行判断

一个集合是否是另一个集合的超集可以调用issuperset进行判断

两个集合是否没有交集可以调用方法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  没有交集

集合的数学操作

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

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

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

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

集合生成式
用于生成集合的公式
{ i*i for i in range(1,10)}

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

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