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

#上面已經將字典定義好了，但是我們現(xiàn)在怎么進行拿值的操作呢？

#獲取值---字典[鍵]：
#序列類型是有順序的，散列類型是沒有順序的
#字典也是沒有順序的，如果想訪問值的話，我們是需要通過鍵進行獲取的
print(d['name'])
#凱子

#我們將順序進行改變的話我們仍然能進行訪問

#鍵必須是唯一的
d={'name': '凱子', 'age': 19, 'sex': '男',"name":"小明"}
print(d)
#{'name': '小明', 'age': 19, 'sex': '男'}
#之前定義的凱子就被這個小明給替換掉了

#如果在字典里面出現(xiàn)重復的鍵，那么前面的鍵值對會被后面的鍵值對給替換掉
'''
因為我們之前就說明了
在字典中對數(shù)值的訪問我們只能通過鍵
那么現(xiàn)在有兩個一樣的鍵，那么我們是不知道訪問誰的
所以在字典中鍵必須是唯一的

如果同時出現(xiàn)一樣的鍵，那么前面的鍵值對會被后面鍵值對提壞

如果確實要定義兩個名字的話，我們可以在name后面加上數(shù)字進行區(qū)分
'''

#獲取小明這個值
#字典[鍵]
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這個鍵是之前沒出現(xiàn)過的
#所以編譯器會將這個鍵和其對應的值會作為鍵值對添加到字典中

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

#如果不存在我們想尋找的鍵值對的話，那么編譯器會通過這個函數(shù)將這個鍵值對添加到字典之中
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我們在括號內不輸入元素的索引值
#那么默認就是刪除最后一個元素
#但是現(xiàn)在我們這里的字典的話使用刪除的方法的時候我們一定要在括號內加上要刪除的鍵值對的鍵

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
男
小紅

對于這個循環(huán)的寫法，我們編譯器會先執(zhí)行這個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循環(huán)遍歷這個鏈表進行鍵的打印

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', '小紅')
'''

#鍵值對存在列表中
#對于這個循環(huán)來說，i存放的數(shù)據是鍵值對的數(shù)據，鍵值對輸出的格式是---鍵：值
#因為鍵值對存在列表中，所以我們是可以用下標進行訪問的

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]}')
'''
那么我們通過循環(huán)就打印出這么個樣子
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}:')
'''
隨著i的遍歷，每次都指向著不同的元組，就是指向不同的鍵值對
那么所以說i種存在兩個值，就是鍵和鍵指向的值
那么我們就利用元組的拆包的操作
將鍵值對這兩個值存在我們創(chuàng)建的兩個變量中
a就是存儲鍵
b就是存儲值了
那么我們利用循環(huán)，i遍歷整個列表我們將整個列表中的元素都進行打印了
'''
#兩種方法都能實現(xiàn)我們想要的效果
'''
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', '你', '好', '你好啊'}
#可以發(fā)現(xiàn)我們后面輸入的被拆開了
#將我們輸入的序列或者是散列類型的數(shù)據拆開放到集合中

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()這個函數(shù)我們就能看的出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):
            #循環(huán)3次進行輸入密碼的操作，如果輸入正確直接跳出循環(huán)
            pwd=eval(input("請輸入密碼："))
            if pwd==i['password']:
                print('登錄成功')
                exit()
                #break#只能退出當前所在的循環(huán)，就是跳出了里面的循環(huán)，還是處于外部循環(huán)
            else:
                print(f'密碼錯誤,還剩{3-n}次機會')
    #if name==i['name'] and pwd==i['password'] :
        break
else:#循環(huán)正常結束執(zhí)行，即沒有break語句
    print("用戶名不存在")

#對于這個程序的話，我們 不管輸入什么最后都會打印這個用戶名不存在
#我們內循環(huán)里面的break僅僅只夠我們跳出內部循環(huán)
#但是沒有跳出外部循環(huán)，這就是為什么會打印else的那句話
#那么我們就在外部循環(huán)加上一個判斷語句，如果條件成立就直接跳出
#那么就不會進行這個循環(huán)后面的代碼了

#總結，就是break只能退出當前所在的循環(huán)，所以在外邊循環(huán)中我們需要再寫一個break跳出外部循環(huán)

#對于后面的這個else語句來說
#循環(huán)正常結束執(zhí)行，即沒有break語句


#但是我們在內循環(huán)break的位置加一個exit()
#我們直接退出這個程序，那么就沒有后面else的事了

#如果后面有代碼的話，這個exit()影響到了后面代碼的執(zhí)行的話
#那么我們就使用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():
        #獲取當前字典內的值
        #我們在這里需要用到字典相關的函數(shù)--values去獲取字典內的值
        #查看當前遍歷到的字典有沒有我們輸入的name
        #print("存在")
        for n in range(3):
            pws=int(input("請輸入密碼："))
            if pws==i['password']:
                print("登錄成功")
                exit()
            else:
                print(f"密碼錯誤,還剩{3-n}次機會")


else:#循環(huán)正常結束才會執(zhí)行
    print("用戶名不存在")
#在這個代碼里面只有一個循環(huán)
#那么我們在break之后我們就不會觸發(fā)這個else了，我們直接跳出循環(huán)了
#我們這里的break跳出循環(huán)是非正常循環(huán)的

'''
數(shù)字重復統(tǒng)計：
(1)隨機生成1000個整數(shù)  
import.random
random.randint
(2)數(shù)字的范圍[20,100]
(3)升序輸出所有不同的數(shù)字及每個數(shù)字重復的次數(shù)
'''
import random
li=[]#創(chuàng)建一個空列表
for i in range(1000):
    num=random.randint(20,100)
    print(num)
    li.append(num)#我們將每次循環(huán)產生的數(shù)添加到這個列表中

print(li)

#升序輸出所有不同的數(shù)字---去重(轉換為集合)，排序(sort)
li1=list(set(li))
#先轉換為集合再轉換為列表，我們就達到了去重的效果
print(li1)
li1.sort()#默認是從小到大，升序的
print(li1)

#每個數(shù)字重復的次數(shù)---統(tǒng)計數(shù)字出現(xiàn)的次數(shù)(序列.count(數(shù)據))
for i in li1:#遍歷去重的列表
    #進行統(tǒng)計，對沒有機芯工去重的列表進行統(tǒng)計
    x=li.count(i)
    print(f'{i}出現(xiàn)了{x}次')

#我們所有的數(shù)字已經在li1里面了，而且沒有重復的
#那么我們將這個列表作為外循環(huán)的條件進行遍歷
#然后我們在li這個鏈表即興每次遍歷的數(shù)字的出現(xiàn)次數(shù)的計算


#我們需要將元素存儲起來
#那么存放多個元素的有什么呢？
#列表、元組（不可修改）、字典（鍵值對）、集合
#那么最后只有列表和集合方便
#這個題的要求是還要統(tǒng)計重復數(shù)字的次數(shù)而且保存重復的數(shù)字
#那么我們直接將字典排除了
#因為字典是去重的
#那么最后我們就使用列表來對這些數(shù)字進行存儲