2. 程式人生 > >Python列表、集合與字典（3）

Python列表、集合與字典（3）

阿新 • • 發佈：2019-01-27
插入 更多 rev port 之前 表操作 clear 位置 end

目錄

  • 一、列表
  • 二、集合
  • 三、字典

一、列表

1. 列表初識

??列表的使用為處理特定順序排列的數據提供了便利，列表元素可以是字母、數字或者其他信息，同時所加元素之間不存在任何關系。

??在Python中，用方括號表示列表，並用逗號分隔各個元素，具體如下所示：

names = [‘ZhangYi‘,‘SuQin‘,‘SunBin‘,‘PangJuan‘,‘LvBu‘]
nums = [1,2,3,4,5]

??上行代碼定義了一個names和nums的列表，列表長度（即列表包含元素數量）均為5個，其中names元素以字符形式（str型）表示，nums元素以數字形式（int型）表示。

2.列表訪問

??列表通過index訪問，即通過列表下表訪問列表元素，需要註意的是Python列表index和C語言一樣，都是從0開始而非1開始。

# 輸出列表元素和相應元素的下標
names = [‘ZhangYi‘,‘SuQin‘,‘SunBin‘,‘PangJuan‘,‘LvBu‘]
print(names[0])
print(names.index(‘ZhangYi‘))
>>> ZhangYi
>>> 0

3.列表操作

?&emsp實際使用中，創建列表是動態的，即我們依據需要對列表進行添加、修改、刪除等一系列操作，這樣將導致列表發生變化，下面將介紹列表主要的屬性或方法的操作。

names = [‘ZhangYi‘,‘SuQin‘,‘SunBin‘,‘PangJuan‘,‘LvBu‘]
# 列表元素修改
names[0] = ‘GuanYu‘
print(‘1:\t‘,names)
>>> 1:  [‘GuanYu‘,‘SuQin‘,‘SunBin‘,‘PangJuan‘,‘LvBu‘]
# 列表元素增添
names.append(‘BaiQi‘)
print(‘2:\t‘,names)
>>> 2:  [‘GuanYu‘, ‘SuQin‘, ‘SunBin‘, ‘PangJuan‘, ‘LvBu‘, ‘BaiQi‘]
# 列表元素刪除(remove del pop)
names.remove(‘SunBin‘)
print(‘3:\t‘,names)
>>> 3:  [‘GuanYu‘, ‘SuQin‘, ‘PangJuan‘, ‘LvBu‘, ‘BaiQi‘]
del names[1]
print(‘4:\t‘,names)
>>> 4:  [‘GuanYu‘, ‘PangJuan‘, ‘LvBu‘, ‘BaiQi‘]
names.pop(1)
print(‘\t‘,names.pop(1))  # 假如未指定下標，則默認刪除列表最後一個元素
print(‘5:\t‘,names)
>>>     ‘PangJuan‘
>>> 5:  [‘GuanYu‘, ‘LvBu‘, ‘BaiQi‘]

names = [‘ZhangYi‘,‘SuQin‘,‘SunBin‘,‘PangJuan‘,‘LvBu‘,‘ZhangYi‘]
# 列表元素下標
print(‘\t‘,names.index(‘ZhangYi‘))
print(‘6:\t‘,names[names.index(‘ZhangYi‘)])
>>> 0
>>> 6:  ZhangYi
# 列表元素統計
print(‘7:\t‘,names.count(‘ZhangYi‘))
>>> 7:  2
# 列表元素反轉
names.reverse()
print(‘8:\t‘,names)
>>> 8:  [‘ZhangYi‘, ‘LvBu‘, ‘PangJuan‘, ‘SunBin‘, ‘SuQin‘, ‘ZhangYi‘]
# 列表元素排序
# 排序順序：特殊字符->數字->字母->漢字
char_ = [‘#‘,‘12‘,‘Hello‘,‘$‘,‘54‘,‘霓虹‘,‘飛天‘]
char_.sort()
print(‘9:\t‘,char_)
>>> 9:  [‘#‘, ‘$‘, ‘12‘, ‘54‘, ‘Hello‘, ‘霓虹‘, ‘飛天‘]
# 列表元素擴展
names.extend(char_)
print(‘10:\t‘,names)
print(‘11:"\t‘,names+char_)
>>> 10: [‘ZhangYi‘, ‘LvBu‘, ‘PangJuan‘, ‘SunBin‘, ‘SuQin‘, ‘ZhangYi‘, ‘#‘, ‘$‘, ‘12‘, ‘54‘, ‘Hello‘, ‘霓虹‘, ‘飛天‘]
>>> 11: [‘ZhangYi‘, ‘LvBu‘, ‘PangJuan‘, ‘SunBin‘, ‘SuQin‘, ‘ZhangYi‘, ‘#‘, ‘$‘, ‘12‘, ‘54‘, ‘Hello‘, ‘霓虹‘, ‘飛天‘]
# 列表元素插入
names = [‘ZhangYi‘,‘SuQin‘,‘SunBin‘,‘PangJuan‘,‘LvBu‘]
names.insert(6,‘ZhaoYun‘)
print(‘12:\t‘,names)
>>> 12: [‘ZhangYi‘, ‘SuQin‘, ‘SunBin‘, ‘PangJuan‘, ‘LvBu‘, ‘ZhaoYun‘]
names = [‘ZhangYi‘,‘SuQin‘,‘SunBin‘,‘PangJuan‘,‘LvBu‘]
char_ = [‘#‘,‘12‘,‘Hello‘,‘$‘,‘54‘,‘霓虹‘,‘飛天‘]
names.insert(6,char_)
print(‘13:\t‘,names)
>>> 13: [‘ZhangYi‘, ‘SuQin‘, ‘SunBin‘, ‘PangJuan‘, ‘LvBu‘, [‘#‘, ‘12‘, ‘Hello‘, ‘$‘, ‘54‘, ‘霓虹‘, ‘飛天‘]]
# 列表元素清空
names.clear()
print(‘14:\t‘,names)
>>> 14: []

??以上是關於列表元素的主要操作，並給出了相應的運算結果，此處只列舉常用的列表屬性或方法（除copy屬性外），其他的在此不再過多介紹。

??下面單獨進行列表copy屬性的介紹，此處涉及可能有些繁瑣，所以大家運行代碼時請註意區分相應的元素變化。

??首先是進行基本復制的介紹：

# copy()方法復制
names = [‘ZhangYi‘,‘SuQin‘,‘SunBin‘,‘PangJuan‘,‘LvBu‘]
print(names.copy())
>>> [‘ZhangYi‘, ‘SuQin‘, ‘SunBin‘, ‘PangJuan‘, ‘LvBu‘]
# 數量復制
print(names*5)
>>> [‘ZhangYi‘, ‘SuQin‘, ‘SunBin‘, ‘PangJuan‘, ‘LvBu‘, ‘ZhangYi‘, ‘SuQin‘, ‘SunBin‘, ‘PangJuan‘, ‘LvBu‘]

??接下來重點介紹下列表復制中的淺復制和深復制：

# 導入copy模塊
import copy

str_c = [‘ZhangFei‘,‘SunBin‘,‘PangTong‘,[‘孫臏‘,‘龐涓‘],‘LiBai‘]
print(‘orig:\t‘,str_c)
>>> orig:   [‘ZhangFei‘, ‘SunBin‘, ‘PangTong‘, [‘孫臏‘, ‘龐涓‘], ‘LiBai‘]
# 以下orig簡稱為原本，copy版本簡稱為復制本 
# 使用.copy()方法
# (1) 淺層（外層）列表原本元素修改,觀察復制本中相應元素
str_c_1 = copy.copy(str_c)
str_c[1] = ‘孫臏‘
print(‘cp_1:\t‘,str_c_1)
print(‘orig:\t‘,str_c)
>>> cp_1:   [‘ZhangFei‘, ‘SunBin‘, ‘PangTong‘, [‘孫臏‘, ‘龐涓‘], ‘LiBai‘]
>>> orig:   [‘ZhangFei‘, ‘孫臏‘, ‘PangTong‘, [‘孫臏‘, ‘龐涓‘], ‘LiBai‘]
# ***********************************************************************
# (1) 原本淺層列表元素變化後，復制本並未產生變化！相應修改復制本中的元素，相應原本中的元素也不會發生變化（此處不再驗證，有興趣可以自行驗證）
# ***********************************************************************

# 接續上次運行結果進行元素修改
# 使用.copy()方法
# (2) 深層（嵌套層）列表復制本元素修改,觀察原本中相應元素
str_c_1[3][0] = ‘SunBin‘
print(‘cp_1:\t‘,str_c_1)
print(‘orig:\t‘,str_c)
>>> cp_1:   [‘ZhangFei‘, ‘SunBin‘, ‘PangTong‘, [‘SunBin‘, ‘龐涓‘], ‘LiBai‘]
>>> orig:   [‘ZhangFei‘, ‘孫臏‘, ‘PangTong‘, [‘SunBin‘, ‘龐涓‘], ‘LiBai‘]
# ***********************************************************************
# (2) 復制本深層列表元素變化後，原本相應元素也產生變化！相應修改原本中的元素，相應復制本中的元素也不會發生變化（此處不再驗證，有興趣可以自行驗證）
# ***********************************************************************

# 接續上次運行結果進行元素修改
# 使用.deepcopy()方法
# (3) 淺層（外層）列表原本元素修改,觀察復制本中相應元素
str_c_2 = copy.deepcopy(str_c)
str_c[1] = ‘SunBin‘
print(‘cp_2:\t‘,str_c_2)
print(‘orig:\t‘,str_c)
>>> cp_2:   [‘ZhangFei‘, ‘孫臏‘, ‘PangTong‘, [‘SunBin‘, ‘龐涓‘], ‘LiBai‘]
>>> orig:   [‘ZhangFei‘, ‘SunBin‘, ‘PangTong‘, [‘SunBin‘, ‘龐涓‘], ‘LiBai‘]
# ***********************************************************************
# (3) 原本淺層列表元素變化後，復制本相應元素未產生變化！相應修改復制本中的元素，相應原本中的元素也不會發生變化（此處不再驗證，有興趣可以自行驗證）
# ***********************************************************************

# 接續上次運行結果進行元素修改
# 使用.deepcopy()方法
# (4) 深層（嵌套層）列表復制本元素修改,觀察原本中相應元素
str_c_2[3][0] = ‘孫臏‘
print(‘cp_2:\t‘,str_c_2)
print(‘orig:\t‘,str_c)
>>> cp_2:   [‘ZhangFei‘, ‘孫臏‘, ‘PangTong‘, [‘孫臏‘, ‘龐涓‘], ‘LiBai‘]
>>> orig:   [‘ZhangFei‘, ‘SunBin‘, ‘PangTong‘, [‘SunBin‘, ‘龐涓‘], ‘LiBai‘]
# ***********************************************************************
# (4) 復制本深層列表元素變化後，原本相應元素未產生變化！相應修改原本本中的元素，相應復制本中的元素也不會發生變化（此處不再驗證，有興趣可以自行驗證）
# ***********************************************************************

??在復制過程中存在淺復制(shallow copy)和深復制(deepcopy)，這兩種復制的區別主要體現在對列表深層結構的復制，在淺層復制上兩者相同。通過上述試驗，我們能夠具體總結出：

  • 當原本只存在一層結構（淺層結構）時，兩種復制方法不存在什麽差別，即不論復制本變化還是原本變化，都不影響對方內容；
  • 當原本具有嵌套結構（深層結構）時，在淺層結構復制上，兩種復制方法變化機制和單一結構復制時的情況相同；
  • 當進行原本深層結構復制時，利用淺復制時，無論原本或時復制本哪一方發生變化，對方對應的元素都將產生同樣的更改，而利用深復制時，在深層結構元素變化後，例如原本發生變化，則復制本相應元素不變化，相應的復制本變化，原本相應元素不變化。

??淺復制主要由以下集中形式，同時需要註意的是，利用淺復制和深復制時，需導入copy模塊：

import copy
a = copy.copy(b)
a = b[:]
a = list(b)

??列表除了上述方法和屬性外，還有一項很重要的內容就是切片功能，利用列表切片可能很方便的控制元素的輸出。

names = [‘ZhangYi‘,‘SuQin‘,‘SunBin‘,‘PangJuan‘,‘LvBu‘]
print(‘1:\t‘,names)
>>> 1:  [‘ZhangYi‘, ‘SuQin‘, ‘SunBin‘, ‘PangJuan‘, ‘LvBu‘]
print(‘2:\t‘,names[1:4])      # names[1-3]
>>> 2:   [‘SuQin‘, ‘SunBin‘, ‘PangJuan‘]
print(‘3:\t‘,names[-1])       # names[4]
>>> 3:   LvBu
print(‘4:\t‘,names[-1:-3])    # names[]
>>> 4:   []
print(‘5:\t‘,names[-3:-1])    # names[2-3]
>>> 5:   [‘SunBin‘, ‘PangJuan‘]
print(‘6:\t‘,names[-2:-1])    # names[3]
>>> 6:   [‘PangJuan‘]
print(‘7:\t‘,names[-1:])      # names[4]
>>> 7:   [‘LvBu‘]
print(‘8:\t‘,names[-1:0])     # names[]
>>> 8:   []
print(‘9:\t‘,names[:3])       # names[0-2]
>>> 9:   [‘ZhangYi‘, ‘SuQin‘, ‘SunBin‘]
print(‘10\t‘,names[0:-1])     # names[0-3]
>>> 10:  [‘ZhangYi‘, ‘SuQin‘, ‘SunBin‘, ‘PangJuan‘]
print(‘11:\t‘,names[0:-1:2])  # names[0,2]
>>> 11:  [‘ZhangYi‘, ‘SunBin‘]
print(‘12:\t‘,names[::2])     # names[0,2,4]
>>> 12:  [‘ZhangYi‘, ‘SunBin‘, ‘LvBu‘]
print(‘13:\t‘,names[:])       # names[0-4]
>>> 13:  [‘ZhangYi‘, ‘SuQin‘, ‘SunBin‘, ‘PangJuan‘, ‘LvBu‘]

??上述對列表的主要用法都進行了介紹，主要歸結有以下規律：

  • names[a?:c:?i?] —— 對於列表names，在切片處理中，a表示切片元素起始下標，c為切片元素終止下標，i為切片切取步長，切取順序按照 names[a], names[a+i], names[a+2*i]……進行，其中names[c]為檢索的最大上限，即邊界，可以用集合中的開區間概念理解，即無法取到，只能取到names[c]之前的元素，另外 i 不寫情況下，默認取1。
  • names[-1] —— 表示列表names列表的最後一個元素，相對應的names[-2]表示倒數第二個元素。
  • names[:]——表示列表中的所有元素。

4.列表的循環

??上述操作主要針對列表元素進行處理專項處理，當列表元素數量較多，且需要對每個元素進行同質化操作時，列表所有元素挨個處理就顯得本笨拙了，因此列表循環在此刻就顯得十分有用。

??在使用過程中過程中，有兩種循環方式用的比較常見：

names = [‘ZhangYi‘,‘SuQin‘,‘SunBin‘,‘PangJuan‘,‘LvBu‘]
# 列表items循環，即列表元素循環
for name in names:
    print(name)
>>> ZhangYi
    SuQin
    SunBin
    PangJuan
    LvBu
# 列表index循環，即列表下標循環
for index in range(len(names)):
    print(names[index])
>>> ZhangYi
    SuQin
    SunBin
    PangJuan
    LvBu

??以上主要是針對淺層列表的循環繼續講解，至於深層列表，可以利用循環嵌套進行處理，在此不再多做贅述。另外再介紹下enumerate，它能夠同時返回列表元素的index和items，方便循環處理：

names = [‘ZhangYi‘,‘SuQin‘,‘SunBin‘,‘PangJuan‘,‘LvBu‘]
for index,items in enumerate(names):
    print(index,items)
>>> 0 ZhangYi
    1 SuQin
    2 SunBin
    3 PangJuan
    4 LvBu

??列表主要內容基本就是上述這些，最後再講解點元組（tuple）類型，元組類型形式很簡單，就是元組元素用小括號括起來，與列表相比，元組只能進行元素下標和元素計數兩種方法的處理，其他方法對元組元素不適用，因為元組與列表不同，一旦創建便不可更改。

names = (‘ZhangFei‘,‘MaChao‘,‘GuanYu‘,‘ZhangFei‘)
# 元組元素循環
for name in names:
    print(name)
>>> ZhangFei
    MaChao
    GuanYu
    ZhangFei
# 元組列表循環
for i in range(len(names)):
    print(names[i])
>>> ZhangFei
    MaChao
    GuanYu
    ZhangFei
# 元組元素計數
print(names.count(‘ZhangFei‘))
>>> 2

二、集合

1.集合初識

??Python中的集合在意義上同數學上的集合意義相同，即集合元素具有唯一性，無序性。在Python中，集合定義不像 tuple()、list[]、dict{} 可以直接通過括號進行定類，在定義集合類型時可以利用函數 set() 進行定義，而集合輸出時則以大括號進行表示，具體如下所示：

set_0 = set(‘Hello‘)
set_1 = set([‘Hello‘])
set_2 = set({‘Hello‘})
print(‘0:\t{}\n{}\n{}‘.format(set_0,set_1,set_2))
>>> 0:  {‘l‘, ‘H‘, ‘e‘, ‘o‘} 
        {‘Hello‘} 
        {‘Hello‘}
set_3 = set([‘1‘,‘2‘,‘3‘,‘4‘])
set_4 = set({‘1‘,‘2‘,‘3‘,‘4‘})
print(‘1:\t{}\n{}‘.format(set_3,set_4))
>>> 1:  {‘2‘, ‘3‘, ‘1‘, ‘4‘}
        {‘2‘, ‘3‘, ‘1‘, ‘4‘}

??通過上述代碼可以看出，利用集合表示字符串時：

  • 使用小括號表示單個字符串時，集合將以每個字符作為集合元素表示；
  • 使用中括號和大括號表示單個字符串時，集合將以整個字符串作為一個元素表示；
  • 表示多個元素時，必須使用中括號或者大括號表示；

2.集合訪問

??集合不能像元組、列表那些可以通過指定下標訪問元素，因此集合訪問元素只能通過對元素進行遍歷：

set_ = set([‘1‘,‘2‘,‘3‘,‘4‘])
for index,items in enumerate(set_):
    print(index,‘*‘+items+‘*‘)
>>> 0 *1*
    1 *3*
    2 *2*
    3 *4*

3.集合操作

??數學意義上的集合有許多關系，在Python中，可以利用一些函數或者關系將這些關系表示出來：

# 交集
list_1 = set([1,2,3,4,5])
list_2 = set([1,2,8,9,12])
list_3 = set([1,2])
print(‘1:\t‘,list_1.intersection(list_2))
>>> 1:  {1, 2}
print(‘2:\t‘,list_1.intersection(list_3))
>>> 2:  {1, 2}
print(‘3:\t‘,list_1 & list_3)
>>> 3:  {1, 2}
# 並集
print(‘4:\t‘,list_1.union(list_3))
>>> 4:  {1, 2, 3, 4, 5}
print(‘5:\t‘,list_1 | list_3)
>>> 5:  {1, 2, 3, 4, 5}
# 差集
print(‘6:\t‘,list_1.difference(list_3))
>>> 6:  {3, 4, 5}
print(‘7:\t‘,list_1 - list_3)
>>> 7:  {3, 4, 5}
# 子集
print(‘8:\t‘,list_1.issubset(list_2))
>>> 8:  False
print(‘9:\t‘,list_3.issubset(list_1))
>>> 9:  True
# 父集
print(‘10:\t‘,list_1.issuperset(list_2))
>>> 10: False
print(‘11:\t‘,list_1.issuperset(list_3))
>>> 11: True
# 子父集符號判斷
print(‘12:\t‘,list_3 in list_1)
>>> 12: False
print(‘13:\t‘,list_3 not in list_1)
>>> 13: True
print(‘14:\t‘,list_3 <= list_1)
>>> 14: True
print(‘15:\t‘,list_3 >= list_1)
>>> 15: False
# 對稱差集
print(‘16:\t‘,list_1.symmetric_difference(list_3))
>>> 16: {3, 4, 5}
print(‘17:\t‘,list_1 ^ list_3)
>>> 17: {3, 4, 5}
# 判斷交集
print(‘18:\t‘,list_1.isdisjoint(list_2))
>>> 18: False

??集合的邏輯關系基本就是上述這些，除了上述關系外，集合還有一些常用的操作方法：

list_1 = set([1,2,3,4,5])
# 集合元素添加
# 單項添加
list_1.add(212)
print(‘1:\t‘,list_1)
>>> 1:  {1, 2, 3, 4, 5, 212}
# 多項添加
list_1.update([200,201,202])
print(‘2:\t‘,list_1)
>>> 2:  {1, 2, 3, 4, 5, 200, 201, 202, 212}
# 集合元素刪除
list_1.remove(212)
print(‘3:\t‘,list_1)
>>> 3:  {1, 2, 3, 4, 5, 200, 201, 202}
list_1.pop()
print(‘4:\t‘,list_1)
>>> 4:  {2, 3, 4, 5, 200, 201, 202}
# discard()刪除時假如集合中沒有該元素，不報錯，返回None，
# 假如存在，則刪除，相對應的，remove則在沒有該元素時，會報錯
list_1.discard(5)
print(‘5:\t‘,list_1)
>>> 5:  {2, 3, 4, 200, 201, 202}
# 集合長度
print(‘6:\t‘,len(list_1))
>>> 6:  6

三、字典

1.字典初識

??Python中，字典就是一系列的鍵-值對。每個鍵與一個值相關聯，通過鍵的使用可以訪問該鍵所對應的值，而值可以是Python中的任何對象，如數字、字符串、列表甚至是字典等。

MaChao = {‘Country‘:‘Shu‘,‘Gender‘:‘Male‘}

??如上所示，Python字典使用{ }包含元素，即字典一系列鍵-值對就放在字典打括號內，鍵和值使用冒號分隔，而鍵-值對之間使用都好分隔，字典內能夠存儲無限個鍵-值對。

2.字典訪問

??字典和列表兩種結構間共有著一種一一對應關系，即列表每個下標對應相應的元素，而字典通過鍵對應對應相應的值，列表通過下標訪問元素，字典則需要利用值所對應的鍵進行訪問。

info = {
    ‘Shu‘:‘ZhaoYun‘,
    ‘Wu‘:[‘LuXun‘,‘TaiShici‘],
    ‘Wei‘:‘DianWei‘
}
print(info[‘Wu‘])
print(info[‘Shu‘])

>>> [‘LuXun‘, ‘TaiShici‘]
>>> ZhaoYun

3.字典操作

??字典的值操作也很簡單，找到所需修改值所對應的鍵，然後進行查找即可操作。

# 字典元素替換
info = {
    ‘Shu‘:‘ZhaoYun‘,
    ‘Wu‘:[‘LuXun‘,‘TaiShici‘],
    ‘Wei‘:‘DianWei‘
}
info[‘Shu‘] = ‘GuanYu‘
print(info)

>>> {‘Shu‘: ‘GuanYu‘, ‘Wu‘: [‘LuXun‘, ‘TaiShici‘], ‘Wei‘: ‘DianWei‘}
# 字典元素刪除
del info[‘Wei‘]
print(‘del:\t‘,info)
info.pop(‘Shu‘)
print(‘pop:\t‘,info)
>>> del:    {‘Shu‘: ‘GuanYu‘, ‘Wu‘: [‘LuXun‘, ‘TaiShici‘]}
>>> pop:    {‘Wu‘: [‘LuXun‘, ‘TaiShici‘]}
# popitem()隨機返回並刪除字典中的一堆鍵—值
info = {
    ‘Shu‘:‘ZhaoYun‘,
    ‘Wu‘:[‘LuXun‘,‘TaiShici‘],
    ‘Wei‘:‘DianWei‘
}
info_pop = info.popitem()
print(‘\t‘,info_pop)
print(‘popitem:\t‘,info)
>>> (‘Wei‘, ‘DianWei‘)
    popitem:    {‘Shu‘: ‘GuanYu‘, ‘Wu‘: [‘LuXun‘, ‘TaiShici‘]}
# 字典元素查找
info = {
    ‘Shu‘:‘ZhaoYun‘,
    ‘Wu‘:[‘LuXun‘,‘TaiShici‘],
    ‘Wei‘:‘DianWei‘
}
print(info.get(‘Shu‘))
print(‘Shu‘ in info)  # info.has_key(‘Shu‘) in py2.x
>>> ZhaoYun
    True
# 字典元素更新-update()
# 字典更新時，假如新字典中有和原字典相同的鍵，則
# 新字典中該鍵的內容將完全替代原字典中該鍵所對應的值
# 假如沒有相同的鍵，則直接在原字典後進行新的添加
b = {
    ‘Shu‘:‘GuanYu‘,
    ‘Song‘:‘LiuYu‘
}
info.update(b)
print(info)
print(info.items())
>>> {‘Shu‘: ‘GuanYu‘, ‘Wu‘: [‘LuXun‘, ‘TaiShici‘], ‘Wei‘: ‘DianWei‘, ‘Song‘:     ‘LiuYu‘}
    dict_items([(‘Shu‘, ‘GuanYu‘), (‘Wu‘, [‘LuXun‘, ‘TaiShici‘]), (‘Wei‘,         ‘DianWei‘), (‘Song‘, ‘LiuYu‘)])
# 字典元素更新-setdefault()
# setdefault()假如查找在字典裏查找到，則返回查找到的值，
# 假如沒有則創建新值，新值信息是setdefault()後面的信息
infos = {
    ‘三國‘:
    {‘Shu‘:[‘ZhaoYun‘,‘GuanYu‘],
    ‘Wu‘:[‘LuXun‘,‘TaiShici‘],
    ‘Wei‘:[‘DianWei‘,‘ZhangHe‘]
},
    ‘西晉‘:{
        ‘Sima‘:[‘SimaZhao‘,‘SimaYan‘]
    },
    ‘東晉‘:{
        ‘Xie‘:[‘Xiean‘,‘Xiexuan‘]
    }
}

infos[‘東晉‘][‘Xie‘][0] = ‘謝安‘
print(infos)
>>> {‘三國‘: {‘Shu‘: [‘ZhaoYun‘, ‘GuanYu‘], ‘Wu‘: [‘LuXun‘, ‘TaiShici‘],          ‘Wei‘: [‘DianWei‘, ‘ZhangHe‘]}, ‘西晉‘: {‘Sima‘: [‘SimaZhao‘,                  ‘SimaYan‘]}, ‘東晉‘: {‘Xie‘: [‘謝安‘, ‘Xiexuan‘]}}

infos.setdefault(‘東晉‘,{‘Wang‘:[‘WangDao‘,‘WangRong‘]})
>>> {‘Xie‘: [‘Xiean‘, ‘Xiexuan‘]}
infos.setdefault(‘宋朝‘,{‘Liu‘:[‘LiuYu‘]})
>>> {‘Liu‘: [‘LiuYu‘]}
print(infos)
>>> {‘三國‘: {‘Shu‘: [‘ZhaoYun‘, ‘GuanYu‘], ‘Wu‘: [‘LuXun‘, ‘TaiShici‘],          ‘Wei‘: [‘DianWei‘, ‘ZhangHe‘]}, ‘西晉‘: {‘Sima‘: [‘SimaZhao‘,‘SimaYan‘]},      ‘東晉‘: {‘Xie‘: [‘Xiean‘, ‘Xiexuan‘]}, ‘宋朝‘: {‘Liu‘: [‘LiuYu‘]}}  
# 字典元素更新-fromkeys()
# fromkeys()在每個鍵（前面參數中的每個元素都是一個獨立的鍵）
# 後面都添加後面參數內的全部元素作為值,假如修改其中的一個值，
# 則字典中同樣位置的元素都將發生改變
ele = dict.fromkeys([6,7,8],[1,{‘Shu‘:‘ZhangFei‘},4])
print(ele)
>>> {6: [1, {‘Shu‘: ‘ZhangFei‘}, 4], 7: [1, {‘Shu‘: ‘ZhangFei‘}, 4], 8: [1,       {‘Shu‘: ‘ZhangFei‘}, 4]}

ele[7][1][‘Shu‘] = ‘HuangZhong‘
print(ele)
>>> {6: [1, {‘Shu‘: ‘HuangZhong‘}, 4], 7: [1, {‘Shu‘: ‘HuangZhong‘}, 4], 8:       [1, {‘Shu‘: ‘HuangZhong‘}, 4]}

4.字典循環

??字典結構相對來說比較復雜，因此在遍歷時，會和其他結構稍微有些不同。

（1）遍歷字典中的所有的鍵-值對

??遍歷鍵值對的遍歷有兩種方法，一種是常規的遍歷，另一種時運用字典特定的屬性方法遍歷：

info = {
    ‘Shu‘:‘ZhaoYun‘,
    ‘Wu‘:[‘LuXun‘,‘TaiShici‘],
    ‘Wei‘:‘DianWei‘
}
# 常規遍歷方法
for i in info:
    print(i + ‘:\t‘,info[i])
>>> Shu:    ZhaoYun
    Wu:     [‘LuXun‘, ‘TaiShici‘]
    Wei:    DianWei
# itmes()遍歷
for key,value in info.items():
    print(key + ‘:\t‘,value)
>>> Shu:    ZhaoYun
    Wu:     [‘LuXun‘, ‘TaiShici‘]
    Wei:    DianWei

??需要註意的是，當數據量較小時，應用上述兩種方法都行，但是當數據量比較大時，使用items()會比較耗費CPU，而相比之下，第一種常規的遍歷方法更適合處理數量比較大時的情況。

（2）遍歷字典中的鍵/值

??前面有了對整個鍵-值對的遍歷，再對鍵進行遍歷就比較容易了：

info = {
    ‘Shu‘:‘ZhaoYun‘,
    ‘Wu‘:[‘LuXun‘,‘TaiShici‘],
    ‘Wei‘:‘DianWei‘
}
# 遍歷字典中的鍵
for key in info.keys():
    print(key)
>>> Shu
    Wu
    Wei
# 遍歷字典中的值
for value in info.values():
    print(value)
>>> ZhaoYun
>>> [‘LuXun‘, ‘TaiShici‘]
>>> DianWei

（3）遍歷字典中的所有值

??最後對字典嵌套循環進行簡要的介紹。
??很多情況下，字典並不是如我們上述所寫的這麽簡單，有時我們會遇到在字典中有多重嵌套的情況，而同時我們又需要將整個字典的所有值給打印出來，而面對多重嵌套，我們常常會抓耳撓腮，實際上，打印這些值，根本方法還是利用循環，下面將以一個兩重嵌套的字典進行所有制的打印說明，之後再遇到更多重的嵌套，原理都是一樣的，跳出代碼，掌握核心觀念，方可靈活運用。

infos = {
    ‘三國‘:
    {‘蜀‘:[‘趙雲‘,‘關羽‘],
     ‘吳‘:[‘陸遜‘,‘甘寧‘],
     ‘魏‘:[‘典韋‘,‘張郃‘]
},
    ‘西晉‘:{‘司馬‘:[‘司馬炎‘,‘司馬昭‘]
    },
    ‘東晉‘:{
        ‘謝‘:[‘謝安‘,‘謝玄‘]
    }
}
# 以列表形式顯示值
for info in infos:
    for info_inner in infos[info]:
        print(info_inner + ‘:\t‘,infos[info][info_inner])
>>> 蜀:   [‘趙雲‘, ‘關羽‘]
    吳:   [‘陸遜‘, ‘甘寧‘]
    魏:   [‘典韋‘, ‘張郃‘]
    司馬:  [‘司馬炎‘, ‘司馬昭‘]
    謝:   [‘謝安‘, ‘謝玄‘]
# 以單個元素顯示值
for info in infos:
    for info_inner in infos[info]:
        info_show = infos[info][info_inner]
        for i in range(len(info_show)):
            print(info + ‘--‘ + info_inner + ‘:\t‘,info_show[i])
>>> 三國--蜀:   趙雲
    三國--蜀:   關羽
    三國--吳:   陸遜
    三國--吳:   甘寧
    三國--魏:   典韋
    三國--魏:   張郃
    西晉--司馬:  司馬炎
    西晉--司馬:  司馬昭
    東晉--謝:   謝安
    東晉--謝:   謝玄

Python列表、集合與字典（3）

相關推薦

Python列表、集合與字典（3）

插入 更多 rev port 之前 表操作 clear 位置 end 目錄 一、列表 二、集合 三、字典 一、列表 1. 列表初識 ??列表的使用為處理特定順序排列的數據提供了便利，列表元素可以是字母、數字或者其他信息，同時所加元素之間不存在任何關系。 ??在Pyth

【Python】11、集合與字典的實現

python一、字典的實現dict是在list之上實現的 i（索引） = hash(key) % solt(槽位數)此時i重復了怎麽辦（hash沖突）？1、拉鏈法 每個槽位上拉一個List，就是拉鏈法2、開地址法 使用某個算法重新計算i，就交開地址法 常用，效率更高，i = fn(key, i)【Pyt

21、SSM框架-Mybatis多引數查詢與列表查詢不同方式實現（3）

本文要實現Mybatis多引數查詢與列表查詢不同方式實現，以一個例項來說明。 一、查詢所有資料，返回List 查詢出列表，也就是返回list, 在我們這個例子中也就是 List<Employeer> , 這種方式返回資料，需要在Employeer.xml 裡面

python---django中orm的使用（3）admin配置與使用

pro field 管理 self settings logs ring web try 新建項目，並開啟 python manage.py runserver 8080 訪問admin頁面 http://127.0.0.1:8080/admin 此時並沒有賬號和

西遊之路——python全棧——ORM之SQLAlchemy（3）外來鍵與relationship的關係

  目錄   relationship是為了簡化聯合查詢join等，建立的兩個表之間的虛擬關係，這種關係與標的結構時無關的。他與外來鍵十分相似，確實，他必須在外來鍵的基礎上才允許使用 不然會

python-序列、集合及字典

組合資料型別 1.集合型別 集合是多種元素的無序組合，(元素獨一性) 集合用大括號{}表示，元素用，分隔。 用set函式建立：        A=set(“python123”)      

java 列表、集合與陣列之間的轉化

package test; import java.util.ArrayList; import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util

吳裕雄 python深度學習與實踐（3）

strftime print sleep .com 實踐 info str def col import threading, time def doWaiting(): print(‘start waiting:‘, time.strftime(‘%S‘))

列表、集合與陣列之間的轉化

陣列和List、Set都可以存放多個元素，陣列的特點是長度固定，訪問速度非常快，元素型別單一；List的特點是長度可以動態增加，能夠維護元素的次序，存入的所有元素都當做Object，允許元素重複；Set的特點是長度可以動態增加，能夠保證元素不重複，存入的所有元素都當做Object。本節例項介紹Set

針對《面試心得與總結—BAT、網易、蘑菇街》一文中出現的技術問題的收集與整理（3）

JVM 1. 記憶體模型以及分割槽，需要詳細到每個區放什麼 JVM記憶體區域模型 1.方法區 也稱”永久代” 、“非堆”，  它用於儲存虛擬機器載入的類資訊、常量、靜態變數、是各個執行緒共享的記憶體區域。預設最小值為16MB，最大值為64MB，可以通過-X

轉:MySQL下載安裝、配置與使用（win7x64）

服務端 oot 路徑 source password ade cto 麻煩 全部 1 第一大步：下載。 a.俗話說：“巧婦難為無米之炊”嘛！我這裏用的是 ZIP Archive 版的，win7 64位的機器支持這個，所以我建議都用這個。因為這個簡

Python列表list詳解篇（七）

python list 介紹：列表是最常用的python數據類型，它可以作為一個方括號內的逗號用分隔值出現。列表的數據項不需要具有相同的類型。創建一個列表，只要逗號分隔的不同數據項用方括號括起來即可。name=[‘’beijing,’shenzhen’,’nanjing’] 訪問列表的值：（列表的下標

Python之模塊與包（下）

dir 模塊 關於 mode 二層 man manage 組織 否則 1、什麽是包 #官網解釋 Packages are a way of structuring Python’s module namespace by using “dotte

Python從菜鳥到高手（3）：聲明變量

ble href edi 一個 android 聲明變量 字符串類型 的人 重要 變量（variable）是Python語言中一個非常重要的概念。變量的主要作用就是為Python程序中的某個值起一個名字。類似於“張三”、“李四”、“王二麻子”一樣的人名，便於記憶。 ??在P

服務搭建與管理（3）

code use 添加 pass 指定 緩沖 work shell 系統 服務器192.168.9.38 work-1192.168.9.39 work-2 添加普通用戶2.1 創建用戶文件夾[root@work-1 ~]# mkdir /app/userhome -p[r

繼承與派生（3）：多繼承

多繼承可以看作是單繼承的擴 展。所謂多繼承是指派生類具有多個基類，派生類與每個基類之間的關係仍可看作是一個單繼承。  • 多繼承是指派生類可以有一個以上的直接基類。多繼承的派 生類定義格式為： class <派生類名>： [<繼承方式>] <基類名

成員函式的過載、覆蓋與隱藏（詳細）【轉】

（轉自：https://blog.csdn.net/weixin_42205987/article/details/81569744） 成員函式的過載、覆蓋與隱藏 成員函式的過載（overload）、覆蓋/重寫（override）與隱藏/重定義（hide）很容易混淆，C++程式設計師必須要搞

python實現人臉檢測及識別（3）---- 識別真正的boss

    現在模型訓練已經完成，只需要一個預測函式判斷拍攝的照片是否是boss即可，在boss_train.py裡的Model新增predeict實現函式。 def predict(self, image): # 依然是根據後端系統確定維度順序

資料結構——排序與查詢（3）——氣泡排序（C++實現）

交換排序演算法 所謂交換，意思是說根據所給的序列，對其中的兩個元素進行大小比較，若為逆序，那麼我們就交換它。這樣就達到了排序的目的。接下來介紹最簡單的交換排序——氣泡排序。 氣泡排序的原理 氣泡排序的原理很簡單，它反覆遍歷要排序的列表，比較每對相鄰的專案，如果它們的順序錯誤則

深入淺出搜尋架構引擎、方案與細節（上）

深入淺出搜尋架構引擎、方案與細節（上） 原創： 58沈劍 架構師之路 2017-02-14 一、緣起 《100億資料1萬屬性資料架構設計》文章釋出後，不少朋友對58同城自研搜尋引擎E-search比較感興趣，故專門撰文體系化的聊聊搜尋引擎，從巨集觀到細節，希望