2017/10/10
元組，字典
==================================================================================================
元組 tuple
元組是不可改變的序列（像字符,元素個數和元素數據能夠保證其可靠性），同list一樣，元組可以存放任意的值
(1)表示方法：
小括號()括起來
單個元素括起來後加逗號(,)區分單個對象還是元組
(2)創建空元組
t = () #空元組
t = tuple() #空元組
創建一個非空的元組
t = (20,) >>>(20,) 含有一個元素的元組
t = 20, >>>(20,) 含有一個元素的元組
t = (1,2,3) >>>(1,2,3) 含有三個元素的元組
t = 1,2,3
t = 'hello',
t = ('1',2,'tree')
創建元組錯誤實例（實際是序列賦值）：
t = (20) >>>20
創建元組錯誤實例（實際是序列賦值）：
x,y = 100,200 #x綁定100，y綁定200，這是序列賦值
x,y = (100,200) #元組會拆開，分別賦值給x，y，x綁定100，y綁定200，這也是序列賦值
x,y = [100,200] #x綁定100，y綁定200，這是序列賦值
x,y = "AB" #這是序列賦值
(3)元組的構造（生成）函數tuple
tuple() 生成一個空元組
tuple(iterable) 用可迭代對象生成一個元組
實例：
tuple("abcd")
tuple([1,2,3])
tuple(("q","c"))
元組的運算：
算數運算:+ += * *=
+ 拼接
+= 拼接後對變量賦值
* 生成重複的元組
*= 生成重複的元組並賦值給變量
實例：
x = (1,2,3) + (4,5,6)
x += (7,)
x = (1,2)
x *= 3
比較運算：
<<= >>= == !=
(1,2,3) < (1,2,4) #True
x = (1,2,3)
y = 1,3,2
x != y #True
x == y #False
y > x #True
元組的 in / not in 運算符
同字符串和列表的in運算符相同，用於判斷一個值是否存在於元組中，存在返回True，不存在返回False
實例：
x = (1,"two",3.1)
2 in x #False
"2" not in x #True
索引 index
等同於字符串的索引規則
元組不能索引賦值
t = (1,2,3)
t[0]
切片 slice
等同於字符串的切片規則
元組不能切片賦值
可用於序列的函數總結：
len(s)
max(x)
min(s)
sum(x)
any(x)
all(x)
reversed(seq) 返回反向順序的迭代器,是全局的函數
sorted（iterable,key=None,reverse=False）返回已排序的列表
實例：
s = 'ABC'
for x in reversed(s):
print(x)
s = "AMCBJ"
sorted(s) #['A','B','C','J','M']
ss = ''.join(sorted(s))
t = (8,3,6,2,7)
sorted(t,)
sorted(t,reverse=True)
元組的方法：
T.index(v[,begin[,end]]) 返回對應元素的索引下標，begin爲開始索引，end爲結束索引（不包含end）
T.count(x) 返回元組中對應元素的個數
------------------------------------------------------------------------------------------------------------
1.字典 dict:字典是一種可變的容器，可以存儲任意類型的數據
2.字典中每個數據都是用"鍵"（key）進行索引，而不像序列可以用下標進行索引
3.字典中的數據沒有先後關係，字典的存儲是無序的
4.字典的數據是以鍵(key) - 值（value）對的形式進行存儲的
5.字典的表示方法是以{}括起來，以冒號(:)分割的鍵值對，各鍵值對之間用逗號隔開
6.字典的鍵不能重複
7.字典的優勢：在數據結構中，在龐大的數據流中，能迅速定位數據的位置，找到想要的數據，字典的優點是查找，刪除，插入的速度快
(1)創建空字典的方法：
d = {} #空字典
d = dict() #空字典
(2)創建非空字典的方法：
實例1：
d = {"name":"xiaoyu","age":22}
說明："name":"xiaoyu"爲一個鍵值對，各個鍵值對之間用逗號隔開，各個鍵值對內用冒號表示索引
字典取值：d['name'] >>>"xiaoyu"
實例2：
d = {"name":"xiaoyu","name":22} #這個不會報錯，但是會留下唯一一個“鍵”（隨機刪除重複的鍵），留下後一個對應“22”的鍵
(3)字典的值(value)可以爲任意類型:
字典的值可以是布爾值，數據，字符串，None，列表，元組，字典，以及後面要學到的集合，函數，類對象等所有類型
實例：
{"a":100}
{"a":"abc"}
{"a":True}
{"a":"None}
{"a":[1,2,3]} 放列表
{"a":(1,2,3)} 放元組
{"a":{"aa":11}} 放字典
說明：字典的鍵(key)必須爲不可變類型的值：
不可變類型，即可以充當鍵的類型：None(特殊),bool,int,float,complex,str,tuple，frozenset(固定集合)
不能充當鍵的類型：列表，字典，集合
實例：
{"a","a"}
{100,"100"}
{True,"True"}
{"None","abc"}
{(1907,1,1):"computer year!"}
(4)字典的基本操作：
字典的訪問：用[]訪問字典內的成員 字典[鍵]
實例：
d = {"name":"tarena","age":15}
print("姓名：",d["name"],"年齡：",d["age"])
(5)添加/修改字典的元素： 字典[鍵]=值
實例：
d = {}
d['name'] = 'tarena' #創建新的鍵值對
d['age'] = 15 #創建新的鍵值對
d['age'] = 16 #修改age鍵對應的值
#插入鍵後，打印出的字典中鍵出現的順序是隨機的@@@@@@@@@@@@
鍵不存在時創建鍵，並綁定鍵對應的值，鍵存在時，修改鍵綁定的值
(6)刪除字典元素 del
del 字典[鍵]
實例：
d = {}
d['name'] = 'tarena' >>>{'name': 'tarena'}
d['age'] = 15 >>>{'name': 'tarena', 'age': 15}
del d['age'] >>>{'name': 'tarena' #刪除年齡和其對應的值
(7)獲取字典中元素(指鍵值對的個數)個數：len函數
len(字典) 返回字典中元素(指鍵值對的個數)個數
實例：
len(d)
(8)字典的成員資格判斷 in / not in 運算符
可以用 in / not in 運算符來判斷一個鍵是否存在於字典中，如果存在則返回True，否則返回False
實例：
d = {"name":"tarena","age":15}
"age" in d #True
15 in d #False 只判斷鍵，不判斷值（鍵不能重複，但是值是可以重複的）
(9)字典的生成函數：
dict() 生成一個字典，等同於{}
dict(iterable) 用可迭代對象初始化一個字典(列表就是一個可迭代對象)
dict(**kwargs) 關鍵字參數形式生成一個字典
實例：
d = dict()
d = dict([('name','tarena'),('age',15)]) #可迭代對象是個列表，元素是兩個元組，可以返回 一個字典
d = dict(name="tarena",age=16)
name = 'xiaoyu'
{'name':xiaoyu}
(10)字典的方法字典推導式：
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.valuas() 返回可迭代的dict_values集合對象
D.items() 返回可迭代的dict_items集合對象
實例：
d = {1:"1",2:"2"}
d2 = {1:"2.2",3:"3.3"}
d.update(d2) >>>{1: '2.2', 2: '2', 3: '3.3'}
d.keys()
dict_keys([1, 2, 3]) #生成了可迭代對象，這樣就可以進行for遍歷,可以當做列表
for k in d.keys():
print(k) #1 2 3 打印鍵
for v in d.values():
print(v) #2.2 2 3 打印所有的值
d.items() #在不知道鍵的個數的情況下使用
>>>dict_items([(1, '2.2'), (2, '2'), (3, '3.3')])
for i in d.items():
print(i)
結果如下(打印出的是一系列元組，指的是變量列表)：
(1,'1')
(2,'2.2')
(3,'3.3')
for k,v in d.items():
print('鍵',k,'--->',v)
>>>
鍵 1 --> 2.2
鍵 2 --> 2
鍵 3 --> 3.3
(11)字典推導式：
語法：
{鍵表達式：值表達式 for 變量 in 可迭代對象 （if條件表達式）}
實例：
numbers = [1001,1002,1003,1004]
names = ["Tom","Jerry","Spike","Tyke"]
animals = { numbers[i]:names[i] for i in range(4) } #i = 0 1 2 3
print(animals)
>>>{1001: 'Tom', 1002: 'Jerry', 1003: 'Spike', 1004: 'Tyke'}
animals = { numbers[i]:names[i] for i in range(4) if numbers[i] % 2 == 0 }
>>>{1002: 'Jerry', 1004: 'Tyke'}
------------------------------------------------------------------------------------------------------------
練習：
1.字符串"hello",生成新字符串"h e l l o"和"h-e-l-l-o"
解法1：
L1 = list("hello") #生成列表，列表中每個元素都是單獨的字符
L2 = ' '.join(L1)
L3 = '-'.join(L2)
print(L2)
print(L3)
解法2：
s = "hello"
print(' '.join("hello"))
print('-'.join("hello")) #字符串本身就是可迭代的
--------------------------------------------------------------
2.輸入任意一個字符串或數字，判斷是否爲迴文數
12321 迴文數
ABCDCBA 迴文
abccba 迴文
解法1：
s=input("輸入一個數或字符串：")
n=len(s)//2
for x in range(0,n+1):
if s[x] != s[-(x+1)]:
print("不是迴文！")
break
else:
print("是迴文")
解法2：
L = list(s)
L2 = list(reversed(s))
if L==L2:
print("是迴文")
else:
print("不是迴文")
方法3:
if s == s[::-1]:
print("是迴文")
else:
print("不是迴文")
--------------------------------------------------------------
3.編寫程序，獲取一個數值，計算併發音其中每個數字出現個數
如：鍵入2234524
打印如下:
數字2出現3次
數字3出現1次
數字4出現2次
數字5出現1次
解法1：
exist = [] #已訪問過的列表
s = input("請輸入一串數字：")
for x in s:
if x in exist:
pass
else:
print(x,'出現',s.count(x),'次')
exist.append(x)
解法2：
exist = []
s = input("請輸入一串數字：")
for x in s:
if x not in exist:
print(x,'出現',s.count(x),'次')
exist.append(x)
解法3：
s = input("請輸入一串數字：")
for x in range(10):
if str(x) in s:
print(x,'出現',s.count(str(x)),'次')
--------------------------------------------------------------
4.已知兩個等長的列表list1和list2，以list1中的元素爲鍵，以list2中的元素爲值，生成相應字典
如：
list1 = ["a","b","c"]
list2 = [1,2,3]
生成字典爲:{'a': 1, 'b': 2, 'c': 3}
解：
list1 = ["a","b","c"]
list2 = [1,2,3]
A = { list1[i]:list2[i] for i in range(3) }
print(A)
>>>{'a': 1, 'c': 3, 'b': 2}