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

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

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

#我們將順序進行改變的話我們?nèi)匀荒苓M行訪問

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

#如果在字典里面出現(xiàn)重復(fù)的鍵，那么前面的鍵值對會被后面的鍵值對給替換掉
'''
因為我們之前就說明了
在字典中對數(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，說明字典里面并沒有這個鍵
'''


#除此之外，我們是可以自己設(shè)置這個提示，提醒我們這個鍵不存在
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)過的
#所以編譯器會將這個鍵和其對應(yīng)的值會作為鍵值對添加到字典中

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

#如果不存在我們想尋找的鍵值對的話，那么編譯器會通過這個函數(shù)將這個鍵值對添加到字典之中
print(d.setdefault('name5',"kaizi"))

print(d)

print(d.setdefault('name'))
#如果這個鍵存在的話，那么setdefault就會返回這個鍵對應(yīng)的值

#{'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的括號內(nèi)添加一個字典

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

'''

#在列表中對元素進行刪除的時候使用pop我們在括號內(nèi)不輸入元素的索引值
#那么默認就是刪除最后一個元素
#但是現(xiàn)在我們這里的字典的話使用刪除的方法的時候我們一定要在括號內(nèi)加上要刪除的鍵值對的鍵

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

#返回關(guān)鍵字和值構(gòu)成的元組

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

#返回的值就是要刪除的鍵值對組成的元組

#返回關(guān)鍵字和值構(gòu)成的元組

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就能獲取這個字典內(nèi)的鍵值對，得到的鍵值對會被存在列表中
#每一個鍵值對在列表中存在的元素是元組形式的
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ù)據(jù)是鍵值對的數(shù)據(jù)，鍵值對輸出的格式是---鍵：值
#因為鍵值對存在列表中，所以我們是可以用下標進行訪問的

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+索引進行元組內(nèi)元素的訪問的操作了
    print(i[0])#訪問的是鍵
    print(i[1])#訪問的是值

    print(f'{i[0]}:{i[1]}')
'''
那么我們通過循環(huán)就打印出這么個樣子
name:小明
age:18
sex:男
name1:小紅

和我們預(yù)期的是一樣的
'''

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]

#將列表轉(zhuǎn)換為集合的類型
j2=set(li)
print(j2)
#{56, 89, 12, 16}
#然后將集合轉(zhuǎn)換為列表，然后這個列表就完成了去重的操作了
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ù)拆開放到集合中

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判斷兩個內(nèi)容是不是同一個地址
#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)正常結(jié)束執(zhí)行，即沒有break語句
    print("用戶名不存在")

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

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

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


#但是我們在內(nèi)循環(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():
        #獲取當前字典內(nèi)的值
        #我們在這里需要用到字典相關(guān)的函數(shù)--values去獲取字典內(nèi)的值
        #查看當前遍歷到的字典有沒有我們輸入的name
        #print("存在")
        for n in range(3):
            pws=int(input("請輸入密碼："))
            if pws==i['password']:
                print("登錄成功")
                exit()
            else:
                print(f"密碼錯誤,還剩{3-n}次機會")


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

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

print(li)

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

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

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


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