Python学习day4

元组

1.元组的创建

a=(40,50,60)
a=40,50,60
a=(100,)    #单元素的元组对象必须要加一个逗号，否则会被识别成整型

a=tuple("abc")
b=tuple([1,2,3])    #tuple里面数字必须是列表对象构成，否则就直接填入元素创建
c=tuple(range(3))
print(a)
print(b)
print(c)
#元组与字符串相同，本身不可以被修改
'''
slice操作、index、count等操作与列表完全相同
'''
a=tuple([10,20,30,40,50])
b=sorted(a)
print(b)
#元组的排序只能用sorted()进行，会生成一个新的对象，且新对象是一个列表

a=[10,20,30]
b=[40,50,60]
c=[70,80,90]
d=zip(a,b,c)    #一列为一个元组
print(list(d))
#zip函数会生成一个迭代器，将列表转化为元组，个数与最短的列表保持一致

2.生成器创建元组

a=(x for x in range(10))
print(tuple(a)) #元组
'''
a是一个推导式生成的生成器对象，并不是元组本身，它可以通过list或者tuple创建为列表或元组
生成器是一次性的，它依次取出生成器里面的对象，类似指针，生成完成就会把指针放到末尾
再次访问必须新建一个生成器
'''
#也可以利用a.__next__()进行遍历，依次返回一个对象，并将指针后移

字典

1.字典的创建

#字典通过任意不可变对象作为键来找到值，而其他的序列主要通过下标
a={"name":"jim","age":18,"job":"student"}
print(a.get("name"))
#字典的标准创建，用大括号、冒号组合

b=dict(name="jim",age=18)
print(b)
#dict()创建的项目名称不需要引号，只需要字符串和=组合
#也可以用 b=dict([("name","jim"),("age",18)]) 与上面的相同

'''
a=["name","age","job"]
b=["jim",18,"student"]
c=zip(a,b)
print(list(c))
#这是创建一个含有元组的列表,将列表压缩
'''

a=["name","age"]    #一组是键
b=["jim",18]    #一组是值
c=zip(a,b)
d=dict(c)
print(d)
#这是用压缩命令将两个列表压缩起来以后，用dict()创建，不能压缩两个以上，只适用于键、值两个列表的情况
#{'name': 'jim', 'age': 18} 一个个对应的是键值对

#但是以上方式都不能创建值为空的字典

a=dict.fromkeys(["name","age","job"])
print(a)
#{'name': None, 'age': None, 'job': None} 值为空

2.字典元素的增加、删除和修改

a={"name":"jim","age":18,"job":"student"}
a["address"]="toilet"
a["age"]=38 #已经存在的键值对可以重新定义
print(a)


a={"name":"jim","age":18,"job":"student"}
b={"name":"Jim","age":21,"job":"student","sex":"male"}
a.update(b)
print(a)
#会用新的字典更新老的字典，同名被覆盖，不同的新增

a={"name":"jim","age":18,"job":"student"}
del a["name"]
print(a)
#与列表中的相同

a={"name":"jim","age":18,"job":"student"}
b=a.pop("age")  #指定删除并返回
c=a.popitem()   #随机删除并返回，因为字典无序，当需要清空时可以用
print(b,c)

3.字典元素的访问和查询

a={"name":"jim","age":18,"job":"student"}
print(a["name"])    #如果查询的键不存在会抛出异常
print(a.get("name"))
print(a.get("num","不存在"))   #查询不到，可以设定一个返回值，默认返回None
'''
字典是一个无序可改变序列，所以不能通过0，1，2的位置进行索引
'''

a={"name":"jim","age":18,"job":"student"}
print(a.items())    #键值对
print(a.values())   #值
print(a.keys())     #键

print(len(a))   #键值对个数，len函数可以应用于所有序列中
print("name" in a)  #判断是否存在

4.字典序列解包赋值

#序列解包可以应用于整数，列表，元组等等
a,b,c=1,2,3
print(a)
(a,b,c)=(4,5,6)
print(a)
[a,b,c]=(7,8,9)
print(a)
'''
序列解包赋值的应用
'''

s={"name":"jim","age":18,"job":"student"}
#a,b,c=s    默认是对键的赋值 即a="name"
a,b,c=s.items() #修改为键值对输出是一个元组
print(a)
a,b,c=s.keys()
print(a)
a,b,c=s.values()
print(a)

5.字典存储和查找的底层原理

a={}
a["name"]="Jim"
'''
a是一个空字典，此时加入一个键值对("name","Jim")
如果数组长度假设为8，那么就会取"name"这个键名的散列值的右边3位 bin(hash("name"))
找到索引的bucket，如果为空则放入，如果已有键值对，则左移三位继续依次比较，直至可以放入
而当数组被填充到2/3时，便会扩容
'''
a.get("name")
'''
过程同样是对于键名散列值的查询，查询到bucket后计算二者散列值是否相等，相等则取出
不相等时继续向左次依次比较散列值
'''

6.字典和列表的综合嵌套

用于存储多项平行的数据

r1={"name":"高小一","age":18,"salary":30000,"city":"北京"}
r2={"name":"高小二","age":19,"salary":20000,"city":"上海"}
r3={"name":"高小三","age":21,"salary":10000,"city":"深圳"}
#每一行的信息存入一个字典中
tb=[r1,r2,r3]
#放入列表中
print(tb)
#获得第二个人的薪资
print(tb[1].get("salary"))

#打印所有人的薪资
for i in range(3):
    print(tb[i].get("salary"),end="\t")
print()

for i in range(len(tb)):
    if tb[i].get("salary") > 15000:
        print(tb[i].get("salary"))

#打印所有数据
for i in range(3):
    print(tb[i].get("name"),tb[i].get("age"),tb[i].get("salary"),tb[i].get("city"))

7.集合

集合的底层是字典，本质上存储的都是键，是无序可变的序列

#集合也是字典的一种，无序可变序列，且元素不可以重复
a={20,30,40,"jim"}
#集合本质上是一个个的键，键名不可能重复

a.add(50)
print(a)
#添加元素使用add函数，但并不会在末尾，这与键的hash有关;remove函数与列表相同

a=[20,30,40,50,20]
b=set(a)    #list->集合
print(b)
#可以将列表转化为集合，且消除相同元素

a="jim happy"
b=set(a)
print(b)
#字符串也可以变为集合，拆分为单个的字符

a={1,2,3,4,"jim"}
b={2,"jim",4,5,6,"sxt"}
print(a|b)
print(a&b)
print(a-b)  #差集是指a里面与b有差异的部分，输出的是a去掉交集后的内容
'''
union 并集；intersection 交集；difference 差集
'''