欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Python字典和集合講解

 更新時間:2021年10月18日 14:36:31   作者:J.Feng  
這篇文章主要給大家假關節(jié)的是Python字典和集合,字典是Python內置的數(shù)據(jù)結構之一,是一個無序的序列;而集合是python語言提供的內置數(shù)據(jù)結構,沒有value的字典,集合類型與其他類型最大的區(qū)別在于,它不包含重復元素。想具體了解有關python字典與集合,請看下面文章內容

一、Python字典

1.什么是字典

  • Python內置的數(shù)據(jù)結構之一,與列表一樣是一個可變序列
  • 以鍵值對的方式存儲數(shù)據(jù),字典是一個無序的序列
  • 在存儲數(shù)據(jù)時要經(jīng)過hash(key)的計算,計算的結果就是存儲的位置,因此字典的鍵值對順序并不是按照存儲時的先后順序決定的,而是經(jīng)過計算得到的存儲位置。
  • 字典中的鍵必    時不可變序列,否則當鍵改變時,hash計算的結果就會發(fā)生變化,導致存儲位置發(fā)生變化。因此鍵必須要使用不可變序列

字典的實現(xiàn)原理:

  • 與查新華字典類似,差字典是先根據(jù)部首或者拼音查找相應的頁碼,Python中的字典是根據(jù) key去查找value的所在位置

2.字典的創(chuàng)建方式

#字典創(chuàng)建的兩種方式
#第一種,使用花括號
dict_1 = {'num':'20210101','name':'Liming','sex':'male'}
print(dict_1)
#第二種,使用內置函數(shù)dict()


2.1 通過其他字典創(chuàng)建

dict_2 = dict(dict_1)
print(dict_2)
print(dict_2 is dict_2)     # True

2.2 通過關鍵字參數(shù)創(chuàng)建

dict_3 = dict(num = "20210101",name = "Liming",sex = 'male')
print(dict_3)
print(dict_1 == dict_3)     #True
print(dict_1 is dict_3)     #False

2.3 通過鍵值對的序列創(chuàng)建

dict_4 = dict([('num',"20210101"),('name',"Liming"),('sex',"male")])
print(dict_3)

2.4 通過dict和zip結合創(chuàng)建

dict_5 = dict(zip(['num','name','sex'],['20210101','Liming','male']))
print(dict_5)

if dict_1 == dict_2 == dict_3 == dict_4 == dict_5:   #判斷字典的值是否相同
    print("創(chuàng)建字典的5種方式相同")    
else:
    print("創(chuàng)建字典的5種方式不同")

字典種的鍵是唯一的,創(chuàng)建字典時若出現(xiàn)“鍵”相同的情況,則后定義的“鍵-值”對將覆蓋先定義的“鍵-值”對。

x = {'a':1,'b':2,"b":3}
print(x)
#運行結果
{'a': 1, 'b': 3}
 
  • fromkeys()方法創(chuàng)建字典:當所有的鍵對應同一個值的時候,可以使用fromkeys創(chuàng)建字典
  • dict.fromkeys(seq[,value]):seq:為字典“鍵”的值列表   value:為設置鍵序列(seq)的值,省略時默認為None
dict_1 = dict.fromkeys(['zhangsan','wangwu'])
print(dict_1)
dict_2 = dict.fromkeys(['zhang_san','wang_wu'],18)
print(dict_2)
dict_3 = dict.fromkeys(['zhang_san','wang_wu'],b)
print(dict_3)
#從下面四行代碼可以看出,當他們值為可變序列并且引用地址相同時,類似于淺copy
dict_3['wang_wu'].pop()
print(dict_3)
dict_3['wang_wu'].append(10)
print(dict_3)

#運行結果
{'zhangsan': None, 'wangwu': None}
{'zhang_san': 18, 'wang_wu': 18}
{'zhang_san': [18], 'wang_wu': [18]}
{'zhang_san': [], 'wang_wu': []}
{'zhang_san': [10], 'wang_wu': [10]}
 

3.字典的訪問

3.1 根據(jù)鍵訪問值

  • 字典中每個元素表示一種映射關系,將提供的“鍵‘作為下標可以訪問對應的值
  • 如果字典中不存在這個”鍵“,則會拋出異常
#根據(jù)鍵訪問值
dict_1 = {"name":"張飛","age":18,"sex":"male"}
print(dict_1["name"])
print(dict_1["sex"])
#print(dict_1["x"])   指定的鍵不存在,拋出異常
 

3.2 使用get()方法訪問值

  • 在訪問字典時,若不確定字典中是否由某個鍵,可通過get()方法進行獲取。
  • 若該鍵存在,則返回對應的值
  • 若該鍵不存在,則返回默認值
  • 語法格式

語法格式:

  • dict.get([key[,default = None])  
  • key:要查找的鍵
  • default:默認值,默認為None,可自行設置需要輸出的默認值。如果指定的鍵不存在,則返回默認值,當default為空時,返回None
#使用get()方法訪問值
dict_1 = {"name":"張飛","age":18,"sex":"male"}
print(dict_1.get("name"))
print(dict_1.get("x"))    #返回None
print(dict_1.get("x",18))   #當鍵不存在時,輸出設置的默認值,并不會把鍵x存入dect_1
print(dict_1.get("age",19))   #當鍵存在時,輸出age原本的值

4.in 和 not in 在字典中的使用

判斷鍵是否在字典中

#in和not in在字典中的使用:判斷鍵是否在字典中
dict_1 = {"name":"張飛","age":18,"sex":"male"}
print("name" in dict_1)           #True
print("張飛" in dict_1)            #False
print("張飛" not in dict_1)        #True
 

5.修改和添加字典中的元素

當以指定鍵為下標為字典元素賦值時,有兩種含義:

  • 若該鍵存在字典中,則表示修改該鍵對應的值
  • 若該鍵不存在字典中,則表示添加一個新的鍵值對,也就是添加一個新元素到字典中
dict_1 = {"name":"張飛","age":18}
print(dict_1)
dict_1["name"] = "李四"   #name鍵存在字典dict_1中,所以此處為修改name的值
print(dict_1)
dict_1["sex"] = "male"    #sex鍵不存在字典dict_1中,所以此處為添加新的鍵值對
print(dict_1)

#輸出結果
{'name': '張飛', 'age': 18}
{'name': '李四', 'age': 18}
{'name': '李四', 'age': 18, 'sex': 'male'}

6.刪除字典中的元素

  刪除字典元素: del命令   clear()方法  pop()方法   popitem()方法

del命令:根據(jù)”鍵“刪除字典中的元素

dict_1 = {"name":"張飛","age":18,"sex":"male"}
del dict_1["name"]
print(dict_1)
#運行結果
{'age': 18, 'sex': 'male'}


clear()方法:用于清除字典中所有元素,其語法格式如下:

dict_1 = {"name":"張飛","age":18,"sex":"male"}
dict_1.clear()
print(dict_1)
#運行結果
{}


pop()方法:用于獲取指定”鍵“的值,并將這個鍵值對從字典中移除,并返回該鍵的值。

  • dict.pop(key[,default])
  • key:要被刪除的鍵
  • default:默認值,當字典中沒有要被刪除的key時,該方法返回指定的默認值
dict_1 = {"name":"張飛","age":18,"sex":"male"}
print(dict_1.pop("age"))     #刪除鍵age與其值,pop()方法的返回值為,刪除的該鍵的值
print(dict_1)
print(dict_1.pop('age',17))
print(dict_1)
print(dict_1.pop('name',"里斯"))
print(dict_1)

 popitem()方法:用于隨機獲取一個鍵值對,將其刪除,并以元組的方式返回被刪除的鍵值對

  • dict.popitem() :該方法無參數(shù)
dict_1 = {"name":"張飛","age":18,"sex":"male"}
x = dict_1.popitem()
print(x,type(x))
print(dict_1)
#運行結果
('sex', 'male') <class 'tuple'>
{'name': '張飛', 'age': 18}


7.更新字典

使用update()方法:可以將新字典的鍵值對,一次性全部添加到當前字典中
如果兩個字典存在相同的鍵,則以新字典中的值為準,更新當前字典
dict.updata(dict2)

  • dict:當前字典
  • dict2:新字典
dict_1 = {"name":"張飛","age":18}
dict_2 = {"name":"李四","sex":"male"}
dict_1.update(dict_2)
print(dict_1)
print(dict_2)
#運行結果
{'name': '李四', 'age': 18, 'sex': 'male'}
{'name': '李四', 'sex': 'male'}

8.獲取字典視圖的三個方法

key()方法

#keys()方法:獲取字典中所有的key
dict_1 = {"name":"張飛","age":18,"sex":"male"}
key_1 = dict_1.keys()
print(key_1,type(key_1)) #可以看出獲取到了字典所有的鍵,并存放在了一個貌似列表的dict_keys視圖中
key_2 = list(key_1)    #將對象key_1視圖變成列表,并不改變原來的key_1視圖
print(key_1)
print(key_2)
#運行結果
dict_keys(['name', 'age', 'sex']) <class 'dict_keys'>
dict_keys(['name', 'age', 'sex'])
['name', 'age', 'sex']

values()方法

#values()方法:獲取字典中所有的value
dict_1 = {"name":"張飛","age":18,"sex":"male"}
value_1 = dict_1.values()
print(value_1,type(value_1)) #可以看出獲取到了字典所有的值,并存放在了一個貌似列表的dict_values視圖中
value_2 = list(value_1)
print(value_1)
print(value_2)
#運行結果
dict_values(['張飛', 18, 'male']) <class 'dict_values'>
dict_values(['張飛', 18, 'male'])
['張飛', 18, 'male']

items()方法

#items()方法:獲取字典中所有的鍵值對
dict_1 = {"name":"張飛","age":18,"sex":"male"}
items_1 = dict_1.items()
#可以看出獲取到了字典所有的鍵值對,并將鍵值對存放在了元組中,再把元組存放在列表中,視圖類型為:dict_items
print(items_1,type(items_1))
items_2 = list(items_1)     #將視圖轉換成列表
print(items_2)
items_3 = tuple(items_2)    #將列表轉換成元組
print(items_2)
print(items_3)
#運行結果
dict_items([('name', '張飛'), ('age', 18), ('sex', 'male')]) <class 'dict_items'>
[('name', '張飛'), ('age', 18), ('sex', 'male')]
[('name', '張飛'), ('age', 18), ('sex', 'male')]
(('name', '張飛'), ('age', 18), ('sex', 'male'))

 9.遍歷字典

使用for循環(huán)遍歷,列表、元組和集合的組合時

  • 當變量x為一個時,x會直接獲取列表(元組)的值
  • 當變量x,y···的個數(shù)剛好與列表(元組)的個數(shù)相同時,則直接將值依次賦給變量

注意:只有在使用列表和元組和集合的兩兩組合時才能這樣使用。

"""
使用for循環(huán)遍歷,列表和元組的組合時,
    ·當變量x為一個時,x會直接獲取列表(元組)的值
    ·當變量x,y···的個數(shù)剛好與列表(元組)的個數(shù)相同時,則直接將值依次賦給變量
"""
a = [('Mary', 'C',"d"),('Jone', 'java',"d"),('Lily', 'Python',"d"),('Lily', 'Python',"d")]
for x in a:
    print(x)        #列表里面存儲的元組,只有一個變量x,所以將元組直接賦值給x
print("============================================")
for x,y,z in a:     #列表里面存儲的元組,每個元組里面存儲了3個元素,剛好可以用三個變量xyz接收這三個元素
    print(x,y,z)
print("============================================")

a = (['Mary', 'C',"d"],['Jone', 'java',"d"],['Lily', 'Python',"d"],['Lily', 'Python',"d"])
for x in a:         #元組里面存儲的列表,只有一個變量x,所以將元組直接賦值給x
    print(x)
print("============================================")
for x,y,z in a:     #元組里面存儲的列表,每個列表里面存儲了3個元素,剛好可以用三個變量xyz接收這三個元素
    print(x,y,z)
#運行結果
('Mary', 'C', 'd')
('Jone', 'java', 'd')
('Lily', 'Python', 'd')
('Lily', 'Python', 'd')
============================================
Mary C d
Jone java d
Lily Python d
Lily Python d
============================================
['Mary', 'C', 'd']
['Jone', 'java', 'd']
['Lily', 'Python', 'd']
['Lily', 'Python', 'd']
============================================
Mary C d
Jone java d
Lily Python d
Lily Python d

a = {('Mary', 'C',"A"),('Jone', 'java',"B"),('Lily', 'Python',"C"),('Lily', 'Python',"D")}
for x in a:         #集合里面存儲的元組,只有一個變量x,所以將元組直接賦值給x
    print(x)
for x,y,z in a:      #集合里面存儲的元組,每個元組里面存儲了3個元素,剛好可以用三個變量xyz接收這三個元素
    print(x,y,z)
#運行結果
('Mary', 'C', 'A')
('Lily', 'Python', 'D')
('Jone', 'java', 'B')
('Lily', 'Python', 'C')
Mary C A
Lily Python D
Jone java B
Lily Python C
 

遍歷字典中所有的鍵值對

使用items()方法,該方法以列表的形式返回可遍歷的鍵值對元組

stu_class = {
    'Mary': 'C',
    'Jone': 'java',
    'Lily': 'Python',
    'Lilo': 'Python'
}
for name,cla in stu_class.items():
    print(name,"選修的課程為:",cla)
#運行結果
Mary 選修的課程為: C
Jone 選修的課程為: java
Lily 選修的課程為: Python
Lilo 選修的課程為: Python

遍歷字典中所有的鍵

當不需要字典中的值時,可使用keys()方法,只遍歷字典中的鍵,該方法以列表返回一個字典中所有的鍵

stu_class = {
    'Mary': 'C',
    'Jone': 'java',
    'Lily': 'Python',
    'Lilo': 'Python'
}
for name in stu_class.keys():
    print(name)
#運行結果
Mary
Jone
Lily
Lilo

 遍歷字典中所有的值

當只關心字典所包含的值時,可以使用values()方法,該方法以列表形式返回字典中所有的值

stu_class = {
    'Mary': 'C',
    'Jone': 'java',
    'Lily': 'Python',
    'Lilo': 'Python'
}
for cla in stu_class.values():
    print(cla)
#運行結果
C
java
Python
Python

10.字典的特點

  • 字典中所有的元素都是一個鍵值對(key - value) ,key不允許重復,但是value可以重復
  • 字典中的元素是無序的
  • 字典中的key是不可變對象(不可變序列)
  • 字典頁可以根據(jù)需要動態(tài)伸縮
  • 字典會浪費較大的內存,是一種使用空間換時間的數(shù)據(jù)

11.復制字典

直接賦值:對象的引用
淺復制(copy()方法):拷貝父對象,引用對象內部的子對象
深復制(deepcopy()方法):copy模塊的deepcopy()方法,完全復制父對象及其子對象

dict1 = {'user':'runoob','num':[123]}
dict2 = dict1       #引用對象
dict3 = dict1.copy()    #淺復制,深復制父對象,子對象不復制,還是引用
import copy
dict4 = copy.deepcopy(dict1) #深復制,完全復制父對象和子對象
print(1,dict1,id(dict1))                #1 {'user': 'runoob', 'num': [123]} 1630766832896
dict1['user'] = 'root'                  
print(1,dict1,id(dict1))                #1 {'user': 'root', 'num': [123, 23]} 1630766832896
print(2,dict2,id(dict2))                #2 {'user': 'root', 'num': [123, 23]} 1630766832896
print(3,dict3,id(dict3))                #3 {'user': 'runoob', 'num': [123, 23]} 1630766833088
print(4,dict4,id(dict4))                #4 {'user': 'runoob', 'num': [123]} 1630767214080
 

二、Python集合(set)

1.什么是集合

  • python語言提供的內置數(shù)據(jù)結構
  • 與列表和字典一樣,都屬于可變序列
  • 集合是沒有value的字典
  • 集合類型與其他類型最大的區(qū)別在于,它不包含重復元素

2.集合創(chuàng)建

#集合創(chuàng)建方式一:使用{}
set_1 = {"Python","Hello",90}
print(set_1)
set_2 = {1,1,2,3,4,4,"Python","Python"}    #集合中的元素不允許重復
print(set_2)
set_3 = {1,2.2,(1,2,3,4),"Python"}
print(set_3)
#set_4 = {1,2.2,[1,2,3,4]}    # 代碼報錯:集合中的元素不允許為 可變數(shù)據(jù)類型(可變序列)

#集合創(chuàng)建方式二:使用內置函數(shù) set():將字符出、列表、元組、range()等對象轉化成集合
set_4 = set("python")
print(set_4)
set_5 = set([1,2,3,4,5])
print(set_5)
set_6 = set((1,2,"Hello"))
print(set_6)
set_7 = set(range(5))
print(set_7)
set_8 = set()          #創(chuàng)建空集合
print(set_8)
set_9 = {}
print(type(set_9))     # <class 'dict'> :所以創(chuàng)建空集合的時候,不能直接使用{}

3.集合的判斷操作

in  或者  not  in :   判斷元素是否在集合中

set_1 = {10,20,30,40,50}
print(10 in set_1)          #True
print(100 in set_1)         #False
print(20 not in set_1)      #False
print(100 not in set_1)     #True

4.集合添加元素

集合添加元素:add()方法、update()方法

set_1.add(x)方法:如果數(shù)據(jù)項x不在結合set_1中,將x添加到set_1中    (一次添加一個元素,元素不重復的前提下)

set_1.update(T)方法:合并結合T中的元素到當前集合set_1中,并自動去除重復元素  (至少添加一個元素,元素不重復的前提下)

#集合添加元素
set_1 = {1,2.2,"Python"}
set_2 = {(1,2,True,"Hello"),2.2,"Python","China"}
set_1.add((1,2,True,"Hello"))
print(set_1)
set_1.update(set_2)
print(set_1)
set_1.update([10,20,30])   #可以添加集合中的元素
print(set_1)
set_1.update((40,50,60))   #可以添加元組中過的元素
print(set_1)
#運行結果
{1, 2.2, (1, 2, True, 'Hello'), 'Python'}
{1, 2.2, 'China', (1, 2, True, 'Hello'), 'Python'}
{1, 2.2, 'China', 10, (1, 2, True, 'Hello'), 20, 'Python', 30}
{1, 2.2, 'China', 40, 10, (1, 2, True, 'Hello'), 50, 20, 'Python', 60, 30}

5.集合刪除元素

集合刪除元素:remove()方法  discard()方法  pop()方法   clear()方法

S.remove(x)方法:如果x在集合S中,移除該元素;如果x不存在則拋出異常

S.discard(x)方法:如果x在集合S中,移除該元素;如果x不存在不會報錯

set_1 = {1,(1,2,True,"Hello"),2.2,"Python"}
set_1.remove(1)
print(set_1)
# set_1.remove(1)   #集合中無元素1,執(zhí)行此代碼會拋出異常
set_1.discard(2.2)
print(set_1)
set_1.discard(2.2)  #集合中無元素2.2,不過執(zhí)行此代碼不會拋出異常
print(set_1)
#運行結果
{(1, 2, True, 'Hello'), 2.2, 'Python'}
{(1, 2, True, 'Hello'), 'Python'}
{(1, 2, True, 'Hello'), 'Python'}

S.pop()方法:隨機刪除并返回集合中過的一個元素,如果集合為空則拋出異常

S.clear()方法:清空集合

set_1 = {1,(1,2,True,"Hello"),2.2,"Python"}
print(set_1.pop())
print(set_1)
set_1.clear()
print(set_1)
#set_1.pop() #集合為空,執(zhí)行此行代碼,會拋出異常
#運行結果
1
{2.2, 'Python', (1, 2, True, 'Hello')}
set()

6.集合間的關系

兩個集合是否相等  ==  、  !=   、  is   、not  is

set_1 = {10,20,30,40}
set_2 = {40,30,10,20}
print(set_1 == set_2)   #True    比較集合的值是否相等
print(set_1 is set_2)   #False   比較集合的引用地址是否相等


一個集合是否是另一個集合的子集

可以調用方法 issubset() 判斷
B是A的子集
A = {1,2,3,4,5,6}
B = {1,2,3,4}
print(B.issubset(A))     #True  B是A的子集


一個集合是否是另一個集合的超集

可以調用方法 issuperset()  判斷
A是B的子集
A = {1,2,3,4,5,6}
B = {1,2,3,4}
print(A.issuperset(B))   #True  A是B的超集


兩個集合是否沒有交集  

可以調用方法 isdisjoint() 判斷  
A = {1,2,3,4,5,6}
B = {1,2,3,4}
print(A.isdisjoint(B))   #False  判斷A和B是否沒有交集
B = {7,8,9,10}
print(A.isdisjoint(B))   #True  判斷A和B是否沒有交集

到此這篇關于Python字典和集合講解的文章就介紹到這了,更多相關Python字典和集合內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家!

相關文章

  • python之Django自動化資產(chǎn)掃描的實現(xiàn)

    python之Django自動化資產(chǎn)掃描的實現(xiàn)

    這篇文章主要介紹了python之Django自動化資產(chǎn)掃描的實現(xiàn),文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
    2021-04-04
  • 在NumPy中創(chuàng)建空數(shù)組/矩陣的方法

    在NumPy中創(chuàng)建空數(shù)組/矩陣的方法

    今天小編就為大家分享一篇在NumPy中創(chuàng)建空數(shù)組/矩陣的方法,具有很好的參考價值,希望對大家有所幫助。一起跟隨小編過來看看吧
    2018-06-06
  • python實現(xiàn)nao機器人手臂動作控制

    python實現(xiàn)nao機器人手臂動作控制

    這篇文章主要為大家詳細介紹了python實現(xiàn)nao機器人手臂動作控制,具有一定的參考價值,感興趣的小伙伴們可以參考一下
    2019-04-04
  • 從django的中間件直接返回請求的方法

    從django的中間件直接返回請求的方法

    今天小編就為大家分享一篇從django的中間件直接返回請求的方法,具有很好的參考價值,希望對大家有所幫助。一起跟隨小編過來看看吧
    2018-05-05
  • python刷投票的腳本實現(xiàn)代碼

    python刷投票的腳本實現(xiàn)代碼

    這篇文章主要介紹了寫了個python刷投票的腳本,需要的朋友可以參考下
    2014-11-11
  • pandas如何計算同比環(huán)比增長

    pandas如何計算同比環(huán)比增長

    這篇文章主要介紹了pandas如何計算同比環(huán)比增長,具有很好的參考價值,希望對大家有所幫助。如有錯誤或未考慮完全的地方,望不吝賜教
    2022-05-05
  • python3 中文亂碼與默認編碼格式設定方法

    python3 中文亂碼與默認編碼格式設定方法

    今天小編就為大家分享一篇python3 中文亂碼與默認編碼格式設定方法,具有很好的參考價值,希望對大家有所幫助。一起跟隨小編過來看看吧
    2018-10-10
  • 提高?Python?開發(fā)效率的3個小工具

    提高?Python?開發(fā)效率的3個小工具

    這篇文章主要給大家分享得事提高?Python?開發(fā)效率的3個小工具,它們能夠幫助我們提高工作效率。本文將介紹筆者在近一周發(fā)現(xiàn)的三個小工具,寫文章以做記錄,希望能對大家有所幫助
    2022-01-01
  • python支持多繼承嗎

    python支持多繼承嗎

    在本篇文章里小編給大家整理的是關于python支持多繼承的相關基礎知識點,需要的朋友們跟著學習參考下。
    2020-06-06
  • Python中的左斜杠、右斜杠(正斜杠和反斜杠)

    Python中的左斜杠、右斜杠(正斜杠和反斜杠)

    這篇文章主要介紹了Python中的左斜杠、右斜杠(正斜杠和反斜杠)的相關資料,非常不錯,具有參考借鑒價值,需要的朋友可以參考下
    2016-08-08

最新評論