基礎：
1. 元組由簡單對象組構成。
2. 元組與列表類似，不過不能在原處修改（它們是不可變的），並且通常寫成圓括號()，而不是方框號[]中的一系列項。
==========================================================================
>>> (1,2) + (3,4)
(1,2,3,4)
>>> (1,2)*4
(1,2,1,2,1,2,1,2)
>>> T = (1,2,3,4)
>>> T[0], T[1:3]
(1, (2,3))
===========================================================================
>>> x = (40) # An integer!
>>> x
40
>>> y = (40,) #A tuple containing an integer
>>> y
(40,)
注：在不會引發語法沖突的情況系啊，Python允許忽略元組的圓括號。
如果圓括號里的單一對象是元組對象而不是一個簡單的表達式（圓括號可以把表達式括起來）， 需要對Python進行特別說明。
如果確實像得到一個遠足，只要在這一單個元素之后，關閉圓括號之前加一個逗號即可。
=============================================================================
>>> T = ('cc', 'aa', 'dd', 'bb’）
>>> tmp = list(T) # Make a list from a tuple's items
>>> tmp.sort()
>>> tmp
['aa', 'bb', 'cc', 'dd']
>>> T = tuple(tmp) # Make a tumple from the list's items
>>> T
('aa', 'bb', 'cc', 'dd')
>>> sorted(T) # Or use the sorted built-in
['aa', 'bb', 'cc', 'dd']
=============================================================================
>>> T = (1, [2,3], 4)
>>> T[1] = 'spam' # This fails: can't change tuple itself
TypeError
>>> T[1][0] = 'spam' # This works: can change mutables inside
>>> T
(1, ['spam', 3], 4)
=============================================================================
eval能夠把字符串當做可執行程序代碼（從技術上來講，就是一個含有Python表達式的字符串）
>>> line = "[1,2,3]${'a':1, 'b':2}\n"
>>> line
"[1,2,3]${'a':1, 'b':2}\n"
>>> parts = line.split('$')
>>> parts
['[1,2,3]',"{'a':1, 'b':2}\n"]
>>> eval(parts[0])
[1,2,3]
>>> objects = [eval(P) for P in parts]
>>> objects
[[1,2,3], {'a':1, 'b':2}]
=========================================================
用pickle存儲Python的原生對象
pickle與eval的區別：
eval能夠執行Python的任何表達式，有可能會刪除計算機上所有文件的表達式；
pickle能夠存儲Python原生對象，也不要求把字符串轉換。
>>> D = {'a': 1, 'b': 2}
>>> F = open('datafile.pkl', 'wb')
>>> import pickle
>>> pickle.dump(D, F) # Pickle any object to file
>>> F.close()
之后想要取回字典時，只要簡單的再用一次pickle進行重建就可以了；
>>> F = open('datafile.pkl', 'wb')
>>> E = pickle.load(F)
>>> E
{'a': 1, 'b': 2}
>>> open('datafile.pkl', 'rb').read() # Format is prone to change!
b'\x90\x03}q\x00(X\x01\x00\x00…….'
注：在這里是使用二進制模式打開用於儲存pickle化的對象的文件，因為二進制模式總是Python 3.X中必須的，同時pickle程序創建和使用一個bytes字符串對象，並且這些對象意味着二進制模式文件（文本模式文件意味着Python 3.X中的str字符串）
===========================================================
struct模塊能夠創造並解析打包的二進制數據；
從某種意義上說，它是另一個數據轉換工具。
>>> F = open('data.bin', 'wb')
>>> import struct
>>> data = struct.pack('>i4sh', 7, 'spam', 8) # Make packed binary data
>>> data
b'\x00\x00\x00\x07spam\x00\x08'
>>> F.wirte(data) # Write byte string
>>> F.close()
>>> F = open('data.bin', 'rb')
>>> data = F.read()
>>> data
b'\x00\x00\x00\x07spam\x00\x08'
>>> values = struct.unpack('>i4sh', data) # Convert to Python objects
>>> values
(7, 'spam', 8)
=========================================================
引用：
>>> X = [1,2,3]
>>> L = ['a', X, 'b']
>>> D = {'x': X, 'y': 2}
>>> X[1] = 'surprise'
>>> L
['a', [1, 'surprise', 3], 'b']
>>> D
{'x': [1, 'surprise', 3], 'y': 2}
復制：
>>> L = [1,2,3]
>>> D = {'a': 1, 'b': 2}
>>> A = L[:]
>>> B = D.copy()
>>> A[1] = 'N1'
>>> D['c'] = 'spam'
>>> L,D
([1,2,3], {'a': 1, 'c': 'spam', 'b': 2})
>>> A,B
([1, 'Ni', 3], {'a': 1, 'b': 2})
如果將引用中修改為
>>> X = [1,2,3]
>>> L = ['a': X[:], 'b']
>>> D = {'x': X[:], 'y': 2]
則X的修改不會影響到L與D
========================================================
判斷“一致性”與“相等性”
>>> L1 = [1,('a', 3)]
>>> L2 = [1,('a', 3)]
>>> L1 == L2, L1 is L2
(True, False)
“==”判斷相等性，“is”判斷一致性；
>>> S1 = 'spam'
>>> S2 = 'spam'
>>> S1 == S2, S1 is S2
(True, True)
>>> S1 = 'a longer string'
>>> S2 = 'a longer string'
>>> S1 == S2, S1 is S2
(True, false)
理由：
Python內部暫時存儲並重復使用段字符串作為最佳化，因為'spam'實際上在內存中只存在一個字符串用於分享；
=====================================================================
None對象
None是Python中一種特殊數據類型的唯一值，一般起一個空的占位作用，與C語言中的NULL指針類似。
None不是意味着“未定義”。None是某些內容，而不是沒有內容。它是一個真正的對象，並且有一塊內存，由Python給定一個內置的名稱。
=====================================================================
復制
>>> L = [4, 5, 6]
>>> X = L * 4
>>> Y = [L] * 4
>>> X
[4,5,6,4,5,6,4,5,6,4,5,6]
>>> Y
[[4,5,6],[4,5,6],[4,5,6],[4,5,6]]
>>> L[1] = 0 # Impacts y but not X
>>> X
[4,5,6,4,5,6,4,5,6,4,5,6] # 賦值
>>> Y
[[4,0,6],[4,0,6],[4,0,6],[4,0,6]] # 引用
======================================================================
嵌套，無限循環
無論何時Python在對象中檢測到循環，都會打印成[...]，而不會陷入無限循環
>>> L = ['grail']
>>> L.append(L)
>>> L
['grail', [...]]
=======================================================================
不可變類型不可以在原處改變
如果需要，可以通過分片、合並等操作來，通過創建一個新的對象，然后向后賦值給原因用
T = (1,2,3)
T[2] = 4 #Error!
T = T[:2] +(4,) #OK: (1,2,4)
=======================================================================
元組支持所有一般的序列操作，但是他們沒有方法，因為是不可變的而不能進行任何在原處的修改。
注：
內置函數與表達式可以跨越多種對象類型，如內置的len函數會傳回Python任何容器對象的長度（包含元素的數目），包括元組在內；
方法特定於一種單個的對象類型，盡管通過某些方式可以在多種類型上使用（例如，索引，在列表和元組上都有效）
========================================================================
>>> L = [1,2,3,4]
>>> L[3:1] = ['?']
>>> L
[1,2,3,'?',4]
========================================================================
>>> L = [1,2,3,4]
>>> L[2] = []
>>> L
[1,2,[],4]
>>> L[2:3] = []
>>> L
[1,2,4]
>>> del L[0]
>>> L
[2,4]
>>> del L[1:]
>>> L
[2]
>>> L[1:2] =1
TypeError
=====================================================
元組的賦值運算
>>> X = 'spam'
>>> Y = 'eggs'
>>> X, Y = Y, X
>>> X
'eggs'
>>> Y
'spam'
======================================================
+ 不適用於字典，因為那不是序列；
append方法只適用於列表，不適用於字符串；
append假設其目標是可變的，因為這是一個原地的擴展，字符串是不可變的。
======================================================