元組和字典

時間 2019-11-19

標籤字典简体版

原文原文鏈接

學習目錄綱要

 1 元組tuple
 2     元組是不可變的序列容器
 3 序列的運算:
 4     + * += *=
 5     < <= > >= == !=
 6     in not in
 7     索引和切片
 8 字典dict
 9 鍵————值：
10 鍵不能重複，　且只能用不可變類型做爲字典的鍵
11 字典[鍵]　= 值＃添加和修改鍵－值對
12 del 字典[鍵]
13 {1:100, 2:200}
14 
15 字典的運算
16     鍵索引
17     字典[鍵]　＝　value
18     var = 字典[鍵]
19     in, not in 對鍵
20 
21 字典推導式
22 {鍵表達式：值表達式　for 變量 in 可迭代對象　if 真值表達式　for 變量２　}
23 l = [1, 3, 4, 5, 8, 64, 564, 84, 51, 75, 61]
24 d = {k:None for k in l }
25 8 in l
26 
27 可變的容器
28 列表　字典　集合　字節數組

學習知識點

元組　tuple

容器類，元組是不可變的序列，同list同樣，元組能夠存聽任意類型的數據的容器　數組

''字符串　[]列表　　()元組app

元組的表示方法：
用小括號(), 單個元素括起來後用逗號(,)區分單個對象仍是元組
建立空元組的字面值：
t = () 空元組
建立非空元組的字面值表示：
t = 200,
t = (20,)
t = (200)＃整數，提升優先級
t = (1, 2, 3)
t = 100, 200, 300ide

＃查看類型type(t)用來返回t對應的類型
元組的錯誤
t = (20) #t綁定20這個對象，　不是元組
x, y, z = (100, 200, 300) #序列賦值
x, y, z = 100, 200, 300 #序列賦值
x, y, z　= [100, 200, 300] #序列賦值
x, y, z = "ABC" #序列賦值函數

元組的構造（函數）tuple
tuple() 生成一個空元組，　等同於()
tuple(iterable)用可迭代對象生成一個元組學習

例：
t = tuple() #等同於t = ()
t = tuple(range(1, 10, 3))#t = (1, 4, 7)
t = tuple("ABC")
t = tuple([1, 2, 3 # t = (1, 2, 3)測試

容器都是可迭代的
t = tuple(range(1, 10, 3))
for x in t:
print(x)
　
元組的運算
+ += * *=
< <= >= > == !=
in not in
索引[ 切片[:]/[::]

+ 拼接元組
* 生成重複的元組ui

>>> t = 1, 2, 3
>>> id(t)
140516944054456
>>> t +=('abc',)
>>> t
(1, 2, 3, 'abc')
>>> t += ('A', 'B', 'C')
>>> t
(1, 2, 3, 'abc', 'A', 'B', 'C')
>>> id(t)
140516936989608
>>> t = (1, 2, 3)
>>> t *=2
>>> tspa

>>> (1, 2, 3) < (1, 3, 2)
True
>>> 2 in (1, 2, 3)
True
>>> 2 not in(1, 2, 3)
False3d

>>> t = tuple(range(1, 10))
>>> t
(1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> t[1]
2
>>> t[::2]
(1, 3, 5, 7, 9)
>>> t[1] = 2.2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignmentcode

元祖的比較運算與列表徹底相同
in / not in 運算符與列表徹底相同
索引取值和切片取值的規則徹底相同
元組不支持索引賦值和切片賦值（由於元組不可被改變）

元組的方法：
T.index(v[, begin[, end]])
返回對應元素的索引下標
T.count(x)
返回元組中對應的元素個數
詳見：>>> help(tuple)

序列的種類：
　字符串　str ,列表　list ,　元組　tuple,
字節串　bytes ,字節數組bytearray

序列相關的函數總結：
len(x), max(x), min(x),
sum(x), any(x), all(x)

構造函數：
str(obj) 將對象轉爲字符串
list(iterable)　　將可迭代對象轉爲列表
tuple(iterable) ..............元組

示例：
t= (4,8,6,2,7)
L = [x for x in reversed(t)]
# t= [7,2,6,8,4] # 原來前後順序的反向
for x in reversed(t):
print(x) # 打印：7 2 6 8 4
L2 =sorted(t) # L2=[2,4,6,7,8]
L3=sorted(t,reverse=True)
# [8,7,6,4,2]

>>> for x in reversed("ABCD"):
... print(x)
...
D
C
B
A

>>> L = [4, 8, 6, 2, 7]#列表
>>> L.sort()
>>> L
[2, 4, 6, 7, 8]
>>> t = [4, 8, 6, 2, 7]#元組
>>> sorted(t)
[2, 4, 6, 7, 8]
>>> sorted(t, reverse=True)
[8, 7, 6, 4, 2]
>>> sorted("wold")
['d', 'l', 'o', 'w']

容器小結：
字符串str #不能變的序列，　只能存字符
列表list　　　#可變的序列，　能夠存任意數據
元組tuple　　　#不可變序列，　能夠存任意數據

字典 dict

字典是一種可變的容器，　能夠存儲任意類型的數據
字典中的每一個數據都是用‘鍵’（key)進行索引，　而不像序列能夠用整數下標來進行索引
字典中的數據沒有前後關係，　字典的儲存是無序的
字典中的數據以鍵(key)-值(value)對形式進行映射存儲
字典的鍵不能重複，　且只能用不可變類型做爲字典的鍵

字典的字面值表示方式：
　　字典的表示方式是以{} 括起來　，以冒號(:) 　　　分隔鍵-值對，各鍵-值對用逗號(,)分隔開

建立空字典的字面值　
　d={}　　 # 空字典

建立非空字典
d={'name':{tarena},'age':15}
d={1:'星期一',2:'星期二',3:'three'}
d={'國籍':'中國'}
d={1:[1,2,3],'abc':(1.1,2.2,3.3s)}
d={123:list('123')}
d={'a':{'b':200,'c':[1,2,3]}}
d={(1970,1,1):'computer year'}
　　如下寫法會出錯（由於鍵不能重複）
d={'a':1,'b':2,'a':'一'}

建立非字典的字面值：
d= {'name': 'songzihong', 'aea':19}
d = {1:'one', 2: 'two', 3:'three'}
>>> d = {1:'one', 2: 'two', 3:'three'}
>>> d
{1: 'one', 2: 'two', 3: 'three'}
>>> len(d)
3

d = {'國籍': '中國'}
d = {1: [1, 2, 3], 'abc': (1.1, 2.2, 2.3)}
>>> d = {1: [1, 2, 3], 'abc': (1.1, 2.2, 2.3)}
>>> len(d)
2
d

d = {123: list("123")}
d = {'a': {'b': 200, 'c': [1, 2, 3]}}

>>> d = {'a': {'b': 200, 'c': [1, 2, 3]}}
>>> len(d)
1

d = {(1970, 1, 1): 'computer year'}

字典的構造函數dict
dict() 生成一個字的字典　　等同於{}
dict(iterable) 用可迭代對象初始化一個字典
dict(**kwargs) 用關鍵字

>>> d = dict(name='宋梓鴻')
>>> d
{'name': '宋梓鴻'}

>>> d = dict(([1, 2], "AB"))
>>> d
{1: 2, 'A': 'B'}ｄｉｃｔ

>>> d = dict(("AB", "CD"))
>>> d
{'A': 'B', 'C': 'D'}

>>> d = {'name':'tarena', 'age':15}
>>> d
{'age': 15, 'name': 'tarena'}
>>> d = dict(name= 'tarena', age=15)
>>> d
{'age': 15, 'name': 'tarena'}
>>> print( d['age'])
15
>>> print(d ['name'])
tarena

字典的鍵(key)必須爲不可變類型
bool int float complex str tuple
frozenset bytes(後面再講)

字典的基本操做：
　　字典的鍵索引
　　　用[]運算符能夠獲取和修改鍵所對應的值
　語法：
　　字典[鍵]
示例：
　　d={'name':'tarena','age':15}
print('姓名:',d['name'], '年齡：':d['age'])

添加/修改字典的元素
字典[鍵]＝值

d={}
d['name']='tarena'

字典的值(value)　可使任意類型（不可作鍵）
可變的數據類型四種：
list列表
dict字典
ser集合
bytearray字節數組
其餘不可變的可作鍵

字典的基本操做：
字典的鍵索引
用[]運算符能夠獲取字典裏的'鍵'對應的值，也能夠用[]運算符來修改＇鍵＇對應的值
鍵索引的語法：
字典［鍵］
例
>>> d = {'name':'tarena', 'age':15}
>>> print('姓名是:', d['name'], '的年齡是:':d['age'])

字典的增刪改

添加/修改字典的元素
字典[鍵]＝值

d={}
d['name']='tarena'

鍵索引賦值說明：
　當鍵不存在時，建立鍵並綁定鍵對應的值
　當鍵存在時，修改鍵綁定的對象

說明
>>> d = {}
>>> d['name'] ='tarena'
>>> d
{'name': 'tarena'}
>>> d[0] = 100
>>> d
{0: 100, 'name': 'tarena'}
>>> d ['age'] = 15
>>> d
{0: 100, 'age': 15, 'name': 'tarena'}
>>> d['age'] = 16
>>> d
{0: 100, 'age': 16, 'name': 'tarena'}
>>> d['age'] +=1
>>> d
{0: 100, 'age': 17, 'name': 'tarena'}

賦值運算左邊
變量 =
列表[100]=
字典[鍵］　

刪除字典元素
del 字典[鍵]
例：
d = {'name':'tarena', 'age':15}
del d['name']
>>> d = {'name':'tarena', 'age':15}
>>> del d['name']
>>> d
{'age': 15}
>>> del d['age']
>>> d
{}

字典的成員資格判斷in 運算符
能夠用in 運算符判斷一個鍵是否存在於字典中，　若是'鍵'在則返回True，　不然返回False
不判斷值
not in與in

示例：
　d={1:'a',2:'b','三':'c'}
1 in d # True
'三'　in d # True

>>> d = {'name':'tarena', 'age':15}
>>> 'tarena' in d
False
>>> 'name' in d
True
>>> 'age' not in d
False

１．）
寫程序，將下數據造成一個字典seasons:
'鍵’ '值''
１ '春季有１，　２，　３月'
２ '夏季有４，　５，　６月'
３ ’秋季有７，　８，　９月‘
４ ’冬季有10, 11, 12月‘

月份季節顯示

２．）
讓用戶輸入一個整數，　表明一個季度，　打印這個季度對應的信息，　若是用戶輸入的信息不在字典內，　則打印信息不存在

 1 seasons = {'1':'春季有１，　２，　３月',     #1
 2            '2': '夏季有４，　５，　６月',    #2
 3            '3': '秋季有７，　８，　９月',    #3
 4            '4': '冬季有10, 11, 12月'     #4
 5            }
 6 n = input("請輸入一個：")#或 n = int(input("請輸入整數："))
 7 if n in seasons:
 8     print(seasons[n])
 9 else:
10     print(信息不存在)

季節對應月份顯示

字典的迭代訪問：
　　字典是可迭代對象，字典只能對鍵進行迭代訪問

例：
d = {'name':'tarena', 'age':15}
for k in d:
print(k, '對應的值是:', d[k])

>>> d = {'name':'tarena', 'age':15}
>>> for x in d:
... print(x)
...
age
name

能夠用於字典的內鍵(built-in)函數
len(x) 　　返回字典的鍵值對的個數
man(x)　　返回字典的鍵的最大值
min(x)　　返回字典的鍵的最小值
sum(x)　　返回字典的鍵的和
any(x)　真值測試，若是字典中的一個鍵爲真，則結果爲真True
all(x)　　　真值測試，若是字典中全部鍵爲真，則結果才爲真

例：
d= {0:'零', 5:'伍'，８:'捌', 3:'叄'}
print(len(d)) # 4
print(max(d)) # 8
print(min(d)) # 0
print(sum(d)) # 16
print(any(d)) # True
print(all(d)) # False

字典的方法
函數說明
D表明字典對象
D.clear() 清空字典
D.pop(key) 移除鍵，同時返回此鍵所對應的值
D.copy() 返回字典D的副本,只複製一層(淺拷貝)
D.update(D2) 將字典 D2 合併到D中，若是鍵相同，則此鍵的值取D2的值做爲新值
D.get(key, default) 返回鍵key所對應的值,若是沒有此鍵，則返回default
D.keys() 返回可迭代的 dict_keys 集合對象
D.values() 返回可迭代的 dict_values 值對象
D.items() 返回可迭代的 dict_items 對象

例子：

>>> d1 = {1:'one', 2:'二', 3:'三'}
>>> d1.get(4)
>>> d1.get(3)
'三'
>>> d1.get(3, '不存在此鍵')
'三'
>>> d1.get(100, '不存在此鍵')
'不存在此鍵'

>>> for v in d1.values():
... print(v)
...
one
二
三

>>> for t in d1.items():
... print(t)
...
(1, 'one')
(2, '二')
(3, '三')

>>> d1
{1: 'one', 2: '二', 3: '三'}
>>> for k, v in d1.items():
... print('鍵:', k, '值:', v)
...
鍵: 1 值: one
鍵: 2 值: 二
鍵: 3 值: 三

練習：
輸入一段字符串，　打印出這個字符串中出現過的字符的出現次數
如：
輸入：abcdabcaba
打印： a: 4次
　 b:3次
d:１次
c:２次

 1 s = input("請輸入：")
 2 d = {}#建立字典保存字符的個數
 3 for ch in s:
 4     #先判斷這個字符之前是否出現過
 5     if ch not in d:#第一次出現
 6         d [ch] = 1#將出現次數設置爲１
 7     else:#不是第一次出現
 8         d[ch] +=1
 9 for k in d:
10     print(k, ':', d[k], '次')

單類字符數目計算

字典推導式

　　字典推導式是用可迭代的對象依次生成字典的表達式

語法：
{鍵表達式：值表達式　for 變量　in 可迭代對象　if 真值表達式}
－－－－－比較列表表達式
說明：
if 子句部分可省略
例：
生成一個字典，鍵爲１－９的整數，值爲鍵的平方
d= {x : x ** 2 for x in range(1,10)}

>>> d= {x : x ** 2 for x in range(1,10)}
>>> d
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

練習：
有字符串的列表以下：
L = ['tarena', 'xiaozhang', 'tyke']
用上述列表生成以下字典：
d = {'tarena': 6, 'xianzhang': 9, 'tyke':4}
注：
字典的值爲鍵

 1 # 法一
 2 L = ['tarena', 'xiaozhang', 'tyke']
 3 a = {x : len(x) for x in L}
 4 print(a)
 5 
 6 # 法二
 7 L = ['tarena', 'xiaozhang', 'tyke']
 8 d = {}
 9 for s in L:
10     d[s] = len(s)
11 print(d)
12 
13 
14 # 法三   ???有誤
15 str = input('請輸入：')
16 dict_char_tmp = {i:str.count(i) for i in str}
17 dict_char= {}
18 for k, v in dict_char_tmp.items():
19     if dict_char.get(v):
20         dict_char[v].append(k)
21     else:
22         dict_char[v]=[k]
23 print(dict_char)
24 dict_char_k= sorted(dict_char.items(), key =1)
25 print(dict_char_k)
26 char_l=dict_char_k[0][1]
27 char_l.sort()
28 print('獲得出現最多的：', char_l[0])

字符長度計算

字典　vs 列表
１．都是可變對象
２．索引方式不一樣，列表用整數索引，字典用鍵索引
３．字典的插入，　刪除，　修改數據的速度可能會快於列表（重要）
４．列表的存儲是有序的，字典的存儲是無序的

練習：
１．已知有兩個等長的列表　list1　和 list2 以list1中的元素爲鍵，　以list2中的元素爲值，　生成相應的字典

 1 list1 = [1001, 102, 1003, 1004]
 2 list2 = ['Tom', 'Jerry', 'Spike', 'Tyke']
 3 
 4 s = 0
 5 x ={}
 6 list1 = [1001, 102, 1003, 1004]
 7 list2 = ['Tom', 'Jerry', 'Spike', 'Tyke']
 8 for z in list1:
 9     x[z] = list1[s]
10 a = {x : z for x in list2}
11 print(a)

練習

２．輸入任意個學生的姓名，年齡，成績，每一個學生的信息存入字典中，而後放入到列表中，每一個學生
的信息須要手動輸入，當輸入姓名爲空時結束輸入
如：
　　請輸入姓名：xiaozhang
　　請輸入年齡：20
　　請輸入成績：100
　　請輸入姓名：xiaoli
　　請輸入年齡：18
　　請輸入成績：98
　　請輸入姓名：<回車>結束輸入
要求內部存儲格式以下：
[{'name':'xiaozhang','age':20,'score':100},
{'name':'xiaoli','age':18,'score':98}]
打印全部學生的信息以下：
+--------------------+--------------+-------------+
| name | age | score |
+--------------------+--------------+-------------+
| xiaozhang | 20 | 100 |
| xiaoli | 18 | 98 |
+--------------------+--------------+-------------+

 1 L = []  # 建立一個容器準備放入
 2 while True:
 3     name = input('請輸入姓名: ')
 4     if not name:  # 若是名字爲空,結束輸入操做
 5         break
 6     age = int(input("請輸入年齡: "))
 7     score = int(input("請輸入成績: "))
 8     d = {}  # 每次都會執行{} 來建立新的字典
 9     d['name'] = name
10     d['age'] = age
11     d['score'] = score
12     L.append(d)
13 
14 print(L)
15 
16 # 打印表格
17 print("+---------------+----------+----------+")
18 print("|     name      |   age    |   score  |")
19 print("+---------------+----------+----------+")
20 for d in L:
21     n = d['name'].center(15)
22     a = str(d['age']).center(10)
23     s = str(d['score']).center(10)
24     print("|%s|%s|%s|" % (n, a, s))
25 
26 # print("|   xiaozhang   |    20    |   100    |")
27 # print("|     xiaoli    |    18    |    98    |")
28 print("+---------------+----------+----------+")