一文带你手撕Python之散列类型

d={'name':'凯子','age':19,'sex':'男'}
print(d)
#{'name': '凯子', 'age': 19, 'sex': '男'}
print(type(d))
#<class 'dict'>

#上面已经将字典定义好了，但是我们现在怎么进行拿值的操作呢？

#获取值---字典[键]：
#序列类型是有顺序的，散列类型是没有顺序的
#字典也是没有顺序的，如果想访问值的话，我们是需要通过键进行获取的
print(d['name'])
#凯子

#我们将顺序进行改变的话我们仍然能进行访问

#键必须是唯一的
d={'name': '凯子', 'age': 19, 'sex': '男',"name":"小明"}
print(d)
#{'name': '小明', 'age': 19, 'sex': '男'}
#之前定义的凯子就被这个小明给替换掉了

#如果在字典里面出现重复的键，那么前面的键值对会被后面的键值对给替换掉
'''
因为我们之前就说明了
在字典中对数值的访问我们只能通过键
那么现在有两个一样的键，那么我们是不知道访问谁的
所以在字典中键必须是唯一的

如果同时出现一样的键，那么前面的键值对会被后面键值对提坏

如果确实要定义两个名字的话，我们可以在name后面加上数字进行区分
'''

#获取小明这个值
#字典[键]
print(d['name'])

d={'name':'凯子','age':19,'sex':'男'}
d['name']="小红"
print(d)
#{'name': '小红', 'age': 19, 'sex': '男'}

d['name3']='小兰'
print(d)
#{'name': '小红', 'age': 19, 'sex': '男', 'name3': '小兰'}

print(d.get('name'))
#小红
print(d.get('age'))
#19

print(d.get('age1'))
#None
'''
这种方式就会进行一个提示，如果我们输入的键是不存在的话
那么就会提示我们None，说明字典里面并没有这个键
'''


#除此之外，我们是可以自己设置这个提示，提醒我们这个键不存在
print(d.get('age1','键不存在'))
#键不存在

d={'name':'凯子','age':19,'sex':'男'}
print(d.setdefault('name5','kk'))
print(d)

#{'name': '凯子', 'age': 19, 'sex': '男', 'name5': 'kk'}
#这里的name5就是不存在的键
#通过这种方法我们直接将这个键放到字典中

print(d.setdefault('name5','55'))
print(d)
#{'name': '凯子', 'age': 19, 'sex': '男', 'name5': 'kk'}
#r如果我们输入的键是存在的话，那么我们就不进行额外的操作了

#当前字典里面有三对键值对
#键和值之间的分割符是冒号
#键值对之间的分隔符是逗号
#用花括号将所有的键值对进行包裹
d={'name':"小明",'age':18,'sex':'男'}

#获取小明这个值
#字典[键]
print(d['name'])

#修改值---字典[键]=新值
d['name']="小红"
print(d)


#添加值--字典[新键]=新值
d['name1']="小工"
print(d)

#这个name1这个键是之前没出现过的
#所以编译器会将这个键和其对应的值会作为键值对添加到字典中

print(d.get('name'))
#小红

#如果不存在我们想寻找的键值对的话，那么编译器会通过这个函数将这个键值对添加到字典之中
print(d.setdefault('name5',"kaizi"))

print(d)

print(d.setdefault('name'))
#如果这个键存在的话，那么setdefault就会返回这个键对应的值

#{'name': '小红', 'age': 18, 'sex': '男', 'name1': '小工', 'name5': 'kaizi'}
#在原有的字典中添加键值对
d.update({'name2':"小李",'age2':'15'})
print(d)
'''
{'name': '小红', 'age': 18, 'sex': '男', 'name1': '小工', 'name5': 'kaizi', 'name2': '小李', 'age2': '15'}
'''
#这个就是在update的括号内添加一个字典

#{'name': '小红', 'age': 18, 'sex': '男', 'name1': '小工', 'name5': 'kaizi'}
#删除小红
d.pop('name')
print(d)
'''
{'age': 18, 'sex': '男', 'name1': '小工', 'name5': 'kaizi', 'name2': '小李', 'age2': '15'}

'''

#在列表中对元素进行删除的时候使用pop我们在括号内不输入元素的索引值
#那么默认就是删除最后一个元素
#但是现在我们这里的字典的话使用删除的方法的时候我们一定要在括号内加上要删除的键值对的键

d.popitem()
print(d)
#{'age': 18, 'sex': '男', 'name1': '小工', 'name5': 'kaizi', 'name2': '小李'}
d.popitem()
print(d)
#{'age': 18, 'sex': '男', 'name1': '小工', 'name5': 'kaizi'}

#返回关键字和值构成的元组

print(d.popitem())
#('name5', 'kaizi')
print(d)
#{'age': 18, 'sex': '男', 'name1': '小工'}
print(d.popitem())
#('name1', '小工')

#返回的值就是要删除的键值对组成的元组

#返回关键字和值构成的元组

print(d.popitem())
#('name5', 'kaizi')
print(d)
#{'age': 18, 'sex': '男', 'name1': '小工'}
print(d.popitem())
#('name1', '小工')

#返回的值就是要删除的键值对组成的元组

d={'name':"小明",'age':18,'sex':'男',"name1":"小红"}
print(d.values())
#dict_values(['小明', 18, '男', '小红'])

for i in d.values():
    print(i)

'''
小明
18
男
小红

对于这个循环的写法，我们编译器会先执行这个d.values的方法，
print(d.values())
#dict_values(['小明', 18, '男', '小红'])
获取到字典中的值
这些值都被存在一个列表中
然后我们i遍历这个列表打印每一个值
'''

d={'name':"小明",'age':18,'sex':'男',"name1":"小红"}
print(d.keys())
#dict_keys(['name', 'age', 'sex', 'name1'])
#同样，获取的键也会存在列表中
#那么我们也可以同样利用for循环遍历这个链表进行键的打印

for i in d.keys():
    print(i)

'''
name
age
sex
name1

'''

#利用items就能获取这个字典内的键值对，得到的键值对会被存在列表中
#每一个键值对在列表中存在的元素是元组形式的
d={'name':"小明",'age':18,'sex':'男',"name1":"小红"}
print(d.items())
'''
dict_items([('name', '小明'), ('age', 18), ('sex', '男'), ('name1', '小红')])
'''

#我们从这个存储键值对的列表中进行遍历，打印每一个键值对

for i in d.items():
    print(i)
'''
('name', '小明')
('age', 18)
('sex', '男')
('name1', '小红')
'''

#键值对存在列表中
#对于这个循环来说，i存放的数据是键值对的数据，键值对输出的格式是---键：值
#因为键值对存在列表中，所以我们是可以用下标进行访问的

d={'name':"小明",'age':18,'sex':'男',"name1":"小红"}
print(d.items())
#dict_items([('name', '小明'), ('age', 18), ('sex', '男'), ('name1', '小红')])
for i in d.items():
    #print(i)
    #通过索引的方式将键和值单独的获取
    #键值对在这个列表中存在的形式是元组
    #通过i的变化，我们访问每一个键值对
    #那么我们就可以用i+索引进行元组内元素的访问的操作了
    print(i[0])#访问的是键
    print(i[1])#访问的是值

    print(f'{i[0]}:{i[1]}')
'''
那么我们通过循环就打印出这么个样子
name:小明
age:18
sex:男
name1:小红

和我们预期的是一样的
'''

d={'name':"小明",'age':18,'sex':'男',"name1":"小红"}
print(d.items())
#dict_items([('name', '小明'), ('age', 18), ('sex', '男'), ('name1', '小红')])
for i in d.items():
    a,b=i
##    print(a)
##    print(b)
    print(f'{a}:{b}')
'''
随着i的遍历，每次都指向着不同的元组，就是指向不同的键值对
那么所以说i种存在两个值，就是键和键指向的值
那么我们就利用元组的拆包的操作
将键值对这两个值存在我们创建的两个变量中
a就是存储键
b就是存储值了
那么我们利用循环，i遍历整个列表我们将整个列表中的元素都进行打印了
'''
#两种方法都能实现我们想要的效果
'''
name:小明
age:18
sex:男
name1:小红

'''

i={1,5,6}
print(type(i))
#<class 'set'>

q={}
print(type(q))
#<class 'dict'>

o=set()
print(type(o))
#<class 'set'>

j={1,2,3,'hu',5,6,1,5}
print(j)

#{1, 2, 3, 5, 6, 'hu'}

#对列表进行去重的操作
li=[12,56,89,56,16]

#将列表转换为集合的类型
j2=set(li)
print(j2)
#{56, 89, 12, 16}
#然后将集合转换为列表，然后这个列表就完成了去重的操作了
li=list(j2)
print(li)

#添加操作
j={1,2,3,'hu',5,6,1,5}
j.add("你好啊")
print(j)
#{1, 2, 3, 'hu', 5, 6, '你好啊'}

#添加序列的话
#update(序列/散列)
j.update("你好")
print(j)
#{1, 2, 3, 5, 6, 'hu', '你', '好', '你好啊'}
#可以发现我们后面输入的被拆开了
#将我们输入的序列或者是散列类型的数据拆开放到集合中

j={1,2,3,'hu',5,6,1,5}
j.remove("hu")
print(j)
#{1, 2, 3, 5, 6}
j.remove(5)
print(j)
#{1, 2, 3, 6}

#{1, 2, 3, 6}

j.pop()

print(j)
#{2, 3, 6}

a={1,2,3,4}
b={3,4,5,6}
print(a&b)
#{3, 4}

a={1,2,3,4}
b={3,4,5,6}
print(a|b)
#{1, 2, 3, 4, 5, 6}

#判断字符p是不是python的成员
print('p'in'pyhton')
#True

li=['李四''张三''王二']
if "小明" in li:#判断小明在不在名字列表里面
    print(True)
else:
    print(False)
#False

#判断字符q是否不是python的成员
print('q'not in'pyhton')
#not in 的操作就是和in的操作是相反的

a=1
b=a
c=2
print(a is b)#True
#a和b指定同一块空间
print(a is c)#False
#a和c不指向同一块空间

print(f'a:{id(a)}')
print(f'b:{id(b)}')
print(f'c:{id(c)}')
#a:1535758792
#b:1535758792
#c:1535758808


#可见， 我们通过id()这个函数我们就能看的出a和b二档地址与c是不同的

#is判断两个内容是不是同一个地址
#is  not相反

li=[1,2,3,4,5]
print(id(li))#72456872
li1=li.copy()
print(li1)
#[1, 2, 3, 4, 5]
print(id(li1))#72456840

students =[
{'name':'张三','password':123},
{'name':'王五','password':888},
{'name':'赵六','password':456}
]
name=input("请输入用户名：")
for i in students:
    #i存在的是用户的信息字典
    if name==i['name']:
        #对输入的用户名进行判断
        for n in range(1,4):
            #循环3次进行输入密码的操作，如果输入正确直接跳出循环
            pwd=eval(input("请输入密码："))
            if pwd==i['password']:
                print('登录成功')
                exit()
                #break#只能退出当前所在的循环，就是跳出了里面的循环，还是处于外部循环
            else:
                print(f'密码错误,还剩{3-n}次机会')
    #if name==i['name'] and pwd==i['password'] :
        break
else:#循环正常结束执行，即没有break语句
    print("用户名不存在")

#对于这个程序的话，我们 不管输入什么最后都会打印这个用户名不存在
#我们内循环里面的break仅仅只够我们跳出内部循环
#但是没有跳出外部循环，这就是为什么会打印else的那句话
#那么我们就在外部循环加上一个判断语句，如果条件成立就直接跳出
#那么就不会进行这个循环后面的代码了

#总结，就是break只能退出当前所在的循环，所以在外边循环中我们需要再写一个break跳出外部循环

#对于后面的这个else语句来说
#循环正常结束执行，即没有break语句


#但是我们在内循环break的位置加一个exit()
#我们直接退出这个程序，那么就没有后面else的事了

#如果后面有代码的话，这个exit()影响到了后面代码的执行的话
#那么我们就使用break来跳出
#两个break

students =[
{'name':'张三','password':123},
{'name':'王五','password':888},
{'name':'赵六','password':456}
]
name=input("请输入用户名：")
for i in students:
    #print(i)
    if name in i.values():
        #获取当前字典内的值
        #我们在这里需要用到字典相关的函数--values去获取字典内的值
        #查看当前遍历到的字典有没有我们输入的name
        #print("存在")
        for n in range(3):
            pws=int(input("请输入密码："))
            if pws==i['password']:
                print("登录成功")
                exit()
            else:
                print(f"密码错误,还剩{3-n}次机会")


else:#循环正常结束才会执行
    print("用户名不存在")
#在这个代码里面只有一个循环
#那么我们在break之后我们就不会触发这个else了，我们直接跳出循环了
#我们这里的break跳出循环是非正常循环的

'''
数字重复统计：
(1)随机生成1000个整数  
import.random
random.randint
(2)数字的范围[20,100]
(3)升序输出所有不同的数字及每个数字重复的次数
'''
import random
li=[]#创建一个空列表
for i in range(1000):
    num=random.randint(20,100)
    print(num)
    li.append(num)#我们将每次循环产生的数添加到这个列表中

print(li)

#升序输出所有不同的数字---去重(转换为集合)，排序(sort)
li1=list(set(li))
#先转换为集合再转换为列表，我们就达到了去重的效果
print(li1)
li1.sort()#默认是从小到大，升序的
print(li1)

#每个数字重复的次数---统计数字出现的次数(序列.count(数据))
for i in li1:#遍历去重的列表
    #进行统计，对没有机芯工去重的列表进行统计
    x=li.count(i)
    print(f'{i}出现了{x}次')

#我们所有的数字已经在li1里面了，而且没有重复的
#那么我们将这个列表作为外循环的条件进行遍历
#然后我们在li这个链表即兴每次遍历的数字的出现次数的计算


#我们需要将元素存储起来
#那么存放多个元素的有什么呢？
#列表、元组（不可修改）、字典（键值对）、集合
#那么最后只有列表和集合方便
#这个题的要求是还要统计重复数字的次数而且保存重复的数字
#那么我们直接将字典排除了
#因为字典是去重的
#那么最后我们就使用列表来对这些数字进行存储