注意：我使用的Python代碼版本一律是3.x
數字
Python 支持三種不同的數值類型：整型(Int)、浮點型(float) 、復數( (complex)) 。
注意：Python3 整型是沒有限制大小的，可以當作 Long 類型使用，所以 Python3 沒有 Python2 的 Long 類型。
可以使用十六進制和八進制來代表整數：
In [66]:number = 0xA0F # 十六進制表示，以0x開頭
In [67]:number
Out[67]: 2575
In [68]:number = 0o37 # 八進制表示，以0o開頭
In [69]:number
Out[69]: 31```
可以使用以下下方法進行數字類型轉換：
int(x)、float(x) 、complex(x)、complex(x, y)
In [71]:a = 1.0
In [72]:int(a) # 將a由浮點數轉換為整數
Out[72]: 1
進行數字運算：
In [74]: 17 / 3 # 注意這里計算會和Py2.x有所不同
Out[74]: 5.666666666666667
In [75]: 17 // 3 # 整數除法返回向下取整后的結果
Out[75]: 5
In [76]: 17 % 3 # %操作符返回除數的余數
Out[76]: 2
In [77]: 5 * 3 +2
Out[77]: 17```
等號（=）用于給變量賦值，可以使用 ** 操作來進行冪運算：
In [79]: width = 20
In [80]: height = 5*9
In [81]: width * height
Out[81]: 900
In [82]: 2 ** 7
Out[82]: 128
不同類型的數混合運算時會將整數轉換為浮點數：
In [83]: 3 * 3.75 / 1.5
Out[83]: 7.5
In [84]: 7.0 / 2
Out[84]: 3.5
<br />?<br />
字符串
字符串是 Python 中最常用的數據類型。我們可以使用引號('或")來創建字符串。
# 創建字符串：
In [85]: var1 = 'Hello World!'
In [86]: var2 = 'Runoob'
# 用切片來截取字符串：
In [87]: var1[0]
Out[87]: 'H'
In [88]: var2[1:5]
Out[88]: 'unoo'
# 對已存在的字符串進行修改：
In [89]: var1 = var1[:6] + 'Runoob!'
In [90]: var1
Out[90]: 'Hello Runoob!'
支持格式化字符串的輸出,最基本的用法是將一個值插入到一個有字符串格式符 %s 的字符串中。
In [91]: print ("我叫 %s 今年 %d 歲!" % ('小明', 10))
我叫 小明 今年 10 歲!
三引號允許一個字符串跨多行，字符串中可以包含換行符、制表符以及其他特殊字符。
In [93]: para_str = """這是一個多行字符串的實例
...: 多行字符串可以使用制表符
...: TAB ( \t )。
...: 也可以使用換行符 [ \n ]。
...: """
In [94]: print (para_str) # 這里要print出來，才會格式化輸出
這是一個多行字符串的實例
多行字符串可以使用制表符
TAB ( )。
也可以使用換行符 [
]。
關于unicode 字符串，在Python2中，普通字符串是以8位ASCII碼進行存儲的，而Unicode字符串則存儲為16位unicode字符串，這樣能夠表示更多的字符集。使用的語法是在字符串前面加上前綴 u。 在Python3中，所有的字符串都是Unicode字符串。
?
<br />?<br />
列表
列表是最常用的Python數據類型，它可以作為一個方括號內的逗號分隔值出現。列表的數據項不需要具有相同的類型。列表是一種有序的集合，可以隨時添加和刪除其中的元素。
訪問及刪除列表中的元素
In [96]: list1 = ['Google', 'Runoob', 1997, 2000]
In [97]: list1[0]
Out[97]: 'Google'
In [98]: list2 = [1, 2, 3, 4, 5, 6, 7 ]
In [99]: list2[1:5]
Out[99]: [2, 3, 4, 5]
In [100]: list = ['Google', 'Runoob', 1997, 2000]
In [101]: list
Out[101]: ['Google', 'Runoob', 1997, 2000]
In [102]: del list[2]
In [103]: list
Out[103]: ['Google', 'Runoob', 2000]
列表腳本操作符
In [104]: len([1,2,3]) # 求取列表長度
Out[104]: 3
In [105]: [1,2,3]+[4,5,6] # 對列表組合
Out[105]: [1, 2, 3, 4, 5, 6]
In [106]: ['hi']*4 # 重復列表中的元素
Out[106]: ['hi', 'hi', 'hi', 'hi']
In [107]: 3 in [1,2,3] # 元素是否存在于列表中
Out[107]: True
In [108]: for x in [1, 2, 3]: print (x) # 對列表元素進行迭代
1
2
3
列表截取
In [109]: L=['Google', 'Runoob', 'Taobao']
In [110]: L[2] # 讀取第三個元素
Out[110]: 'Taobao'
In [111]: L[-2] # 從右側開始讀取倒數第二個元素
Out[111]: 'Runoob'
In [112]: L[1:] # 輸出從第二個元素開始后的所有元素
Out[112]: ['Runoob', 'Taobao']
列表拼接與嵌套
In [113]: squares = [1, 4, 9, 16, 25]
In [114]: squares + [36, 49, 64, 81, 100] # 對列表進行拼接
Out[114]: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
In [115]: a = ['a', 'b', 'c']
In [116]: n = [1, 2, 3]
In [117]: x = [a, n] # 對列表進行嵌套
In [118]: x
Out[118]: [['a', 'b', 'c'], [1, 2, 3]]
In [119]: x[0]
Out[119]: ['a', 'b', 'c']
In [120]: x[0][1] # 類似于二維Numpy數組
Out[120]: 'b'
列表包含以下函數
len(list) #列表元素個數
max(list) #返回列表元素最大值
min(list) #返回列表元素最小值
list(seq) #將元組轉換為列表
列表包含以下方法
list.append(obj) 在列表末尾添加新的對象
list.count(obj) 統計某個元素在列表中出現的次數
list.extend(seq) 在列表末尾一次性追加另一個序列中的多個值（用新列表擴展原來的列表）
list.index(obj) 從列表中找出某個值第一個匹配項的索引位置
list.insert(index, obj) 將對象插入列表
list.pop(obj=list[-1]) 移除列表中的一個元素（默認最后一個元素），并且返回該元素的值
list.remove(obj) 移除列表中某個值的第一個匹配項
list.reverse() 反向列表中元素
list.sort([func]) 對原列表進行排序
list.clear() 清空列表
list.copy() 復制列表
<br />?<br />
元組
元組與列表類似，不同之處在于元組的元素不能修改。元組使用元括號，列表使用方括號。
#創建元組
In [121]: tup1 = (1, 2, 3, 4, 5)
In [122]: tup2 = 'a','b','c','d'
In [123]: tup1
Out[123]: (1, 2, 3, 4, 5)
In [124]: tup2
Out[124]: ('a', 'b', 'c', 'd')
#創建空元組
In [125]: tup3 = ()
In [126]: tup3
Out[126]: ()
#元組中只包含一個元素時，需要在元素后面添加逗號
In [127]: tup = (50,)
In [128]: tup
Out[128]: (50,)
訪問及修改元組
In [129]: tup1 = ('Google', 'Runoob', 1997, 2000)
In [130]: tup2 = (1, 2, 3, 4, 5, 6, 7 )
In [131]: tup1[0]
Out[131]: 'Google'
In [132]: tup2[1:5]
Out[132]: (2, 3, 4, 5)
In [135]: tup1 = (12, 34.56)
In [136]: tup2 = ('abc', 'xyz')
In [137]: tup3 = tup1 + tup2
In [138]: tup3
Out[138]: (12, 34.56, 'abc', 'xyz')
# tup1[0] = 100，根據索引賦值來修改元組元素操作是非法的。
#對元組中的列表元素修改是可以的。如下：
In [207]: t = (1,2,['a','b'])
In [208]: t
Out[208]: (1, 2, ['a', 'b'])
In [209]: t[2][0] = 'c'
In [210]: t
Out[210]: (1, 2, ['c', 'b'])
刪除元組
#元組中的元素值是不允許刪除的，但我們可以使用del語句來刪除整個元組
In [140]: tup = ('Google', 'Runoob', 1997, 2000)
In [141]: tup
Out[141]: ('Google', 'Runoob', 1997, 2000)
In [142]:del tup #刪除整個元組，再打印會出現tup沒定義的提示
元組運算符
In [145]: len((1, 2, 3)) #求元組元素個數
Out[145]: 3
In [146]: (1, 2, 3) + (4, 5, 6) #對元組進行連接
Out[146]: (1, 2, 3, 4, 5, 6)
In [147]: ('Hi',) * 4 #對元組元素進行復制
Out[147]: ('Hi', 'Hi', 'Hi', 'Hi')
In [148]: 3 in (1, 2, 3) #判斷元素是否存在
Out[148]: True
In [149]: for x in (1, 2, 3): print (x) #對元組元素進行迭代
1
2
3
元組索引與截取
In [150]: L = ('Google', 'Taobao', 'Runoob')
In [151]: L[2] #讀取第三個元素
Out[151]: 'Runoob'
In [152]: L[-2] #反向讀取，讀取倒數第二個元素
Out[152]: 'Taobao'
In [153]: L[1:] #截取元素，從第二個開始后的所有元素
Out[153]: ('Taobao', 'Runoob')
元組包含了以下內置函數
len(tuple) 計算元組元素個數。
max(tuple) 返回元組中元素最大值。
min(tuple) 返回元組中元素最小值。
tuple(seq) 將列表轉換為元組。
元組其他Tips
#獲取取item的索引，可以使用下面的遍歷方法
In [194]: for index in range(len(tuple1)):
...: print (tuple1[index])
#運用內置函數enumerate來獲取對應的索引和元素
In [195]: for index, item in enumerate(tuple1):
...: print ('%i, %s' % (index, item))
<br />?<br />
字典
字典是另一種可變容器模型，且可存儲任意類型對象。字典的每個鍵值(key=>value)對用冒號(:)分割，每個對之間用逗號(,)分割，整個字典包括在花括號({})中。鍵必須是唯一的，但值則不必。值可以取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組
創建及訪問字典中的值
In [157]: dict3 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} #創建字典
In [158]: dict3['Name'] #通過字典中的鍵訪問對應的值
Out[158]: 'Runoob'
In [159]: dict3['Age']
Out[159]: 7
修改字典。向字典添加新內容的方法是增加新的鍵/值對。
In [160]: dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
In [161]: dict['Age'] = 8
In [162]: dict['School'] = '菜鳥教程'
#可以看到已做更改和增加
In [163]: dict
Out[163]: {'Age': 8, 'Class': 'First', 'Name': 'Runoob', 'School': '菜鳥教程'}
刪除字典元素、清空及刪除字典
In [172]: dict1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
In [173]: del dict1['Name'] #刪除字典元素
In [174]: dict1.clear() #清空字典，但是字典還存在，只是是空的
In [175]: dict1
Out[175]: {}
In [176]: del dict1 #刪除字典，再輸出字典dict1會顯示未定義錯誤
字典鍵的特性
字典值可以沒有限制地取任何python對象，既可以是標準的對象，也可以是用戶定義的，但鍵不行。
特性有二：
1、字典值可以沒有限制地取任何python對象，既可以是標準的對象，也可以是用戶定義的，但鍵不行。
In [178]: dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鳥'}
In [179]: dict['Name']
Out[179]: '小菜鳥'
2、鍵必須不可變，所以可以用數字，字符串或元組充當，而用列表就不行，如下實例：
In [180]: dict = {['Name']: 'Runoob', 'Age': 7}
#這樣定義會顯示錯誤：TypeError: unhashable type: 'list'
字典內置函數&內置方法：
len(dict) 計算字典元素個數，即鍵的總數。
str(dict) 輸出字典以可打印的字符串表示。
type(variable) 返回輸入的變量類型，如果變量是字典就返回字典類
radiansdict.clear() 刪除字典內所有元素
radiansdict.copy() 返回一個字典的淺復制
radiansdict.fromkeys() 創建一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應的初始值
radiansdict.get(key, default=None) 返回指定鍵的值，如果值不在字典中返回default值
key in dict 如果鍵在字典dict里返回true，否則返回false
radiansdict.items() 以列表返回可遍歷的(鍵, 值) 元組數組
radiansdict.keys() 以列表返回一個字典所有的鍵
radiansdict.setdefault(key, default=None) 和get()類似, 但如果鍵不存在于字典中，將會添加鍵并將值設為default
radiansdict.update(dict2) 把字典dict2的鍵/值對更新到dict里
radiansdict.values() 以列表返回字典中的所有值
<br />?<br />
集合
集合（set）是一個無序不重復元素的序列。基本功能是進行成員關系測試和刪除重復元素。
In [181]: student = ({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'})
In [182]: student #可以發現重復的Tom刪除了
Out[182]: {'Jack', 'Jim', 'Mary', 'Rose', 'Tom'}
In [185]: a = set('abcabcef')
In [186]: b = set('abclmn')
In [187]: a
Out[187]: {'a', 'b', 'c', 'e', 'f'}
In [188]: b
Out[188]: {'a', 'b', 'c', 'l', 'm', 'n'}
#集合的一些運算
In [189]: a-b #a和b的差集
Out[189]: {'e', 'f'}
In [190]: a | b #a和b的并集
Out[190]: {'a', 'b', 'c', 'e', 'f', 'l', 'm', 'n'}
In [191]: a & b #a和b的交集
Out[191]: {'a', 'b', 'c'}
In [192]: a ^ b # a和b中不同時存在的元素
Out[192]: {'e', 'f', 'l', 'm', 'n'}
集合的其他操作
set.add(obj) # 添加新元素
#集合也存在不可變形式,frozenset為固定集合.
set3 = frozenset(list1) #創建一個固定集合，固定集合不能添加元素
# 刪除元素
set2.discard(6) # 當元素不存在時,不會引發異常
set2.remove(6) # 與discard的區別在于，如果沒有要刪除的元素，remove會引發一個異常
set2.pop() # 因為set是無序的，所以pop會隨機的從set中刪除一個元素
set.update('python') #傳入的元素python拆分，做為個體傳入到集合中
set.remove('obj') #傳入的元素做為個體從集合中全部刪除
