Python中數據類型
時間：2019-03-20 來源：華清遠見
一、Python中五種標準數據類型
數字（Number）
字符串（String）
列表（list）
元組（tuple）
字典（Dictionary）
二、數字（Number）
數字不可變數據類型，分為以下四種數值類型：
整型(int)
長整型（long）
浮點型（float）
復數（complex）
數值類型實例如下：
三、字符串（String）
字符串不可變的數據類型，是一個序列，序列是Python中最基本的數據結構。序列中的每個元素都分配一個數字 - 它的位置，第一個索引是0，第二個索引是1，依此類推。在python中’’ 和 “ ”號都表示字符串。
S1 = ‘hello’
S2 = “world”
1.字符串索引
（1）下標從左向右索引：
name = 'hello'
name[0] ===> ‘h’
name[1] ===> ‘e’
name[2] ===> ‘l’
name[3] ===> ‘l’
name[4] ===> ‘o’
#起始下標： 0
#終止下標： 元素個數n - 1（len(name)-1） len(name)得到字符串序列長度
（2）下標從右向左索引
name = 'hello'
name[-5] ===> ‘o’
name[-4] ===> ‘l’
name[-3] ===> ‘l’
name[-2] ===> ‘e’
name[-1] ===> ‘h’
#起始下標： -len(name)
#終止下標： -1
2.字符串切片
name[i:j] ### i起始下標 j終止下標：只能切到終止下標的前一個
name[i:j:stride] ### i起始下標 j終止下標：只能切到終止下標的前一個
### stride 步長，步長為正數：正切
### 步長，步長為負數: 反切
切片實例
In [1]: name = 'abcdefghijk'
In [2]: name[1:5]##起始下標 終止下標，注意切到終止下標的前一個
Out[2]: 'bcde'
In [4]: name[0:5]
Out[4]: 'abcde'
In [5]: name[:5] ###如果左面省略不寫，默認為0
Out[5]: 'abcde'
In [6]: name[6:] ###如果右面省略不寫，默認為len(name)
Out[6]: 'ghijk'
In [7]: name[6:len(name)]
Out[7]: 'ghijk'
In [9]: name[0:5:1]
Out[9]: 'abcde'
In [10]: name[0:5:2] ### 2 代表步長，間距數為 步長-1
Out[10]: 'ace'
In [11]: name[0:5:3]
Out[11]: 'ad'
In [12]: name[0:5:-1]## 負數代表反切
Out[12]: ''
In [14]: name[5:0:-1]
Out[14]: 'fedcb'
In [15]: name[5::-1]
Out[15]: 'fedcba'
In [16]: name[::-1]
Out[16]: 'kjihgfedcba'
In [17]: name
Out[17]: 'abcdefghijk'
In [18]: a = name[::-1]###相當于將字符串轉置
In [19]: a
Out[19]: 'kjihgfedcba'
In [20]: a = name[::-4] ###可以將結果賦值給另一個變量保存
In [21]: a
Out[21]: 'kgc'
In [26]: name[0] ###不能修改元素的值，字符串是不可變類型
Out[26]: 'a'
In [27]: name[0] = 'm' ###修改會掛掉
3.字符串加乘
字符串與字符串之間可以進行相加，字符串與整數之間可以相乘
（1）相加實例
In [29]: xing = 'zhang'
In [30]: ming = ' san'
In [31]: xing + ming
Out[31]: 'zhang san'
In [32]: xing ###注意此處：xing沒變
Out[32]: 'zhang'
In [33]: ming ###注意此處：ming沒變
Out[33]: ' san'
In [34]: xingming = xing + ming ###可以將相加的值賦值給另一個變量保存
In [35]: xingming
Out[35]: 'zhang san'
In [36]:
In [36]: xing + 3 ###字符串只能與字符串相加
（2）相乘實例
In [39]: 'hello'*10 ##字符串可以與整數相乘
Out[39]: 'hellohellohellohellohellohellohellohellohellohello'
In [40]: 'hello'*5
Out[40]: 'hellohellohellohellohello'
4.字符串操作（增、刪、改、查）
4.1 字符串為不可變類型，增刪改不探討
4.2 查
（1）下標索引
（2）in 和 not in
##in 在里面， not in 不在里面
In [42]: name
Out[42]: 'abcdefghijk'
In [43]: if 'a' in name: ##在里面為True，不在為False
....: print 'a is in'
....:
a is in
In [44]: if 'Z' not in name: ##'Z'代表的是字符串，不是字符
....: print 'Z is not in'
Z is not in
四、列表（List）
列表可變數據類型，是一個序列。列表是最常用的Python數據類型，它可以作為一個方括號內的逗號分隔值出現，列表的數據項不需要具有相同的類型。
nums = [0, ”zhangsan”, 4.5 , 5] ###定義一個列表
nums ###列表名
= ###賦值
[] ###代表列表
0,”zhangsan”,4.5,5 ###代表列表中的元素，用,號隔開
1.列表下標索引
列表索引 同上 字符串索引
索引實例：
In [27]: names = ['zhangsan',13,98.7,[180,100]] ###列表里面可以嵌套列表
In [29]: names[3]
Out[29]: [180, 100]
2.列表切片
列表切片 同上 字符串切片
切片實例：
In [38]: nums
Out[38]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
In [39]: nums[2:5] ###注意返回值為列表，如果想保存起來需要賦值到變量里
Out[39]: [3, 4, 5]
In [40]: nums ###nums切完并沒有改變
Out[40]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
In [41]: newnums = nums[2:5]
In [42]: newnums
Out[42]: [3, 4, 5]
In [43]: nums
Out[43]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
In [44]: nums[::-1] ###相當于轉置列表
Out[44]: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
3.列表加乘
列表加乘 同上 字符串加乘
加乘實例：
In [45]: names = ['zhangsan','lisi','wangwu']
In [46]: nums
Out[46]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
In [47]: names + nums
Out[47]: ['zhangsan', 'lisi', 'wangwu', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
In [48]: nums ###注意此處相加后 nums沒變
Out[48]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
In [49]: names ###注意此處相加后 names沒變
Out[49]: ['zhangsan', 'lisi', 'wangwu']
In [50]: names*2 ###與整數相乘
Out[50]: ['zhangsan', 'lisi', 'wangwu', 'zhangsan', 'lisi', 'wangwu']
1.列表的操作（增、刪、改、查）
4.1增
（1）List.append(obj)
##功能：將對象追加列表尾
In [54]: names
Out[54]: ['zhangsan', 'lisi', 'wangwu']
In [55]: names.append('xiaotaoqi')
In [56]: names ###注意此處names發生變化
Out[56]: ['zhangsan', 'lisi', 'wangwu', 'xiaotaoqi']
（2）List.insert(post,obj)
##功能： post代表插入的位置，obj插入的對象，指定下標位置插入 In [56]: names
Out[56]: ['zhangsan', 'lisi', 'wangwu', 'xiaotaoqi']
In [57]: names.insert(0,'budaode') ##0代表下標
In [58]: names
Out[58]: ['budaode', 'zhangsan', 'lisi', 'wangwu', 'xiaotaoqi']
In [59]: names.insert(3,'yibandaode')###3代表下標，其他元素向后移動
In [60]: names
Out[60]: ['budaode', 'zhangsan', 'lisi', 'yibandaode', 'wangwu', 'xiaotaoqi']
（3）Lsit.extend(seq)
##功能：將整個序列插入的列表尾
In [63]: names.extend('wangwu') ###將序列中的每個元素，插入的列表尾
In [64]: names
Out[64]: ['zhangsan', 'lisi', 'w', 'a', 'n', 'g', 'w', 'u']
In [65]: nums = [1,2,3]
In [66]: names.extend(nums)##將序列中的每個元素，插入的列表尾
In [67]: names
Out[67]: ['zhangsan', 'lisi', 'w', 'a', 'n', 'g', 'w', 'u', 1, 2, 3]
4.2 刪
（1）List.pop()
##功能：默認無參數刪除列表中最后一個元素，如果有參數，代表刪 除的位置下標
##返回值：返回值為pop掉元素的值
In [91]: names = ['zhangsan','lisi','wangwu']
In [92]: names.pop()
Out[92]: 'wangwu'
In [93]: names.pop()
Out[93]: 'lisi'
In [94]: names.pop()
Out[94]: 'zhangsan'
In [96]: names = ['zhangsan','lisi','wangwu']
In [97]: names.pop(1) ###如果有參數，1代表下標，刪除的names[1]
Out[97]: 'lisi'
In [98]: names
Out[98]: ['zhangsan', 'wangwu']
In [99]: names.pop(0) ###刪除的是names[0]
Out[99]: 'zhangsan'
（2）List.remove(obj)
##功能：根據列表中的元素的值進行刪除元素，如果值不存在會報錯出現 異常
In [115]: names = ['zhangsan','lisi','zhangsan','wangwu','lisi']
In [116]: names.remove('zhangsan') ###當出現重名時，刪除的是從左到右 第一次出現的值
In [117]: names
Out[117]: ['lisi', 'zhangsan', 'wangwu', 'lisi']
In [118]: names.remove('lisi')
In [119]: names
Out[119]: ['zhangsan', 'wangwu', 'lisi']
（3）del 元素
##功能：刪除指定元素
del 元素### 類似于pop( ),根據下標刪除
In [125]: names = ['zhangsan','lisi','zhangsan','wangwu','lisi']
In [126]: del names[2] ##直接刪除指定元素
In [127]: names
Out[127]: ['zhangsan', 'lisi', 'wangwu', 'lisi']
In [128]: del names[0]
In [129]: names
Out[129]: ['lisi', 'wangwu', 'lisi']
2.4.3改
通過下標進行修改
In [130]: names
Out[130]: ['lisi', 'wangwu', 'lisi']
In [131]: names[0] = 100 ##可以直接通過下標對元素進行賦值修改
In [132]: names
Out[132]: [100, 'wangwu', 'lisi']
In [133]: names[1] = [1,2,3] ###直接通過下標對元素進行賦值修改
In [135]: names
Out[135]: [100, [1, 2, 3], 'lisi']
3.4.4查
（1）下標索引 name[0]
（2）in 和 not in
##用法和字符串相同
（3）List.index(value)
###功能： 查找對應value值出現的位置下標，如果出現多個值重復， 返回是從左到右第一次出現的位置小標
###返回值： 出現的下標
In [27]: nums
Out[27]: [1, 2, 2, 3, 4, 5, 2]
In [28]: nums.index(2)
Out[28]: 1
In [29]: nums.index(5)
Out[29]: 5
五、元組（Tuple）
元組不可變數據類型，是一個序列。Python的元組與列表類似，不同之處在于元組的元素不能修改。元組使用小括號()，列表使用方括號[]。元組內元素可以是相同數據類型也可以是不同數據類型。
nums = (1,2,3) ###定義一個元組
nums ###元組名
= ###賦值
() ###代表元組
1,2,3 ###代表元組中的元素，用,號分隔
In [1]: nums = (1,2,3) ###元組保存相同的數據類型
In [3]: names = ('zhangsan','lisi')###元組保存相同的數據類型
In [7]: name = ('zhangsan',18,98.8)###元組保存不同的數據類型
4.元組的下標索引、切片、加乘
元組的索引和切片 同上 列表索引和切片
5.元組操作（增、刪、改、查）
（1）元組是不可變數據類型，對增、刪、改不做探討
（2）查 同上 字符串
六、字典（Dictionary）
字典可變數據類型，是無序對象的集合。字典是另一種可變容器模型，且可存儲任意類型對象，如其他容器模型。字典由鍵和對應值成對組成。字典也被稱作關聯數組或哈希表。
d1 = {'gong':1000,'xi':5,'fa':100,'cai':500 }
#d1 ###字典名
#= ###賦值
#{} ###代表字典
# 'gong':1000,'xi':5,'fa':100,'cai':500 ###字典中的元素，用,號分隔
#'gong':1000 ###鍵值對
#'gong' ###key鍵
# ： ###鍵和值之間的分隔
#1000 ###值 value
#d1['gong']
In [70]: d1 = {1:1000}
In [71]: d1 = {1.1:1000}
In [72]: d1 = {(1,1):1000}
In [73]: d1 = {[1,2]:1000} #### 錯誤：列表是可變類型，可變類型不能當做key
6.字典索引
In [63]: d1 = {'gong':1000,'xi':5,'fa':100,'cai':500 }
In [65]: d1['gong'] ###只能通過key索引，不能通過下標索引
Out[65]: 1000
7.字典切片和加乘
字典不可以進行索引和切片
8.字典操作（增、刪、改、查）
3.1 增
（1）key不存在，直接進行相加
In [96]: d1
Out[96]: {'zhangsan': 89}
In [97]: d1['lisi'] = 90
In [98]: d1
Out[98]: {'lisi': 90, 'zhangsan': 89}
In [100]: d1[1] = 'wangwu' ###1代表的是key 1， 'wangwu'作為值添加
In [101]: d1
Out[101]: {1: 'wangwu', 'lisi': 90, 'zhangsan': 89}
（2）d1.update(d2)
###功能：將d2字典中的所有元素，添加到d1中，
###如果d2和d1存在相同的key，更新后重復的key，值為d2中的值
In [105]: d1
Out[105]: {1: 'wangwu', 'lisi': 90, 'zhangsan': 89}
In [106]: d2
Out[106]: {1: 'haha', 'lisi': 100, 'wangwu': 1000}
In [107]: d3 = {'zhaoliu':98}
In [108]: d1.update(d3)
In [109]: d1
Out[109]: {1: 'wangwu', 'lisi': 90, 'zhangsan': 89, 'zhaoliu': 98}
In [110]: d1
Out[110]: {1: 'wangwu', 'lisi': 90, 'zhangsan': 89, 'zhaoliu': 98}
In [111]: d2
Out[111]: {1: 'haha', 'lisi': 100, 'wangwu': 1000}
In [112]: d1.update(d2) ###發現d1中的key 1 和 key 'lisi'為d2中的值
In [113]: d1
Out[113]: {1: 'haha', 'lisi': 100, 'wangwu': 1000, 'zhangsan': 89, 'zhaoliu': 98}
3.2 刪
（1）del d1["score"]
##通過key直接刪除字典中的元素
In [114]: d1 = {'name':'zhangsan','age':18,'score':98.6}
In [115]: d1
Out[115]: {'age': 18, 'name': 'zhangsan', 'score': 98.6}
In [116]: del d1['age']
In [117]: d1
Out[117]: {'name': 'zhangsan', 'score': 98.6}
In [118]:
（2）dict.pop(key,default)
##功能：刪除字典中對應key的值
##返回值：返回值key對應的值
In [120]: d1
Out[120]: {'age': 18, 'name': 'zhangsan', 'score': 98.6}
In [121]: d1.pop('name') ###當一個參數key存在的時候，刪除的key對應的鍵值對
Out[121]: 'zhangsan'
In [122]: d1.pop('weight') ###當一個參數key不存在的時候，會掛掉，因為key不存在
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-122-b92dacda62dd> in <module>()
----> 1 d1.pop('weight')
KeyError: 'weight'
In [123]: d1.pop('weight','weight is not in') ###如果key不存在的時候，避免掛掉，可以多加一個參數，defalut 當key不存在的時候，可以返回default對應的值，防止掛掉
Out[123]: 'weight is not in'
（3）dict.popitem()
##功能： 從字典中隨機刪除一個鍵值對
##返回值： 有key和value組成的元組
In [125]: d1 = {'name':'zhangsan','age':18,'score':98.6}
In [126]: d1.popitem()
Out[126]: ('age', 18)
In [127]: d1.popitem()
Out[127]: ('score', 98.6)
In [128]: d1.popitem()
Out[128]: ('name', 'zhangsan')
In [129]: d1.popitem() ##當字典為空的時候，會掛掉
In [48]:
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-129-82c59cddf420> in <module>()
----> 1 d1.popitem()
KeyError: 'popitem(): dictionary is empty'
（4）dict.clear()
##功能：清空字典中的元素
In [134]: d1
Out[134]: {'name': 'zhangsan', 'score': 98.6}
In [135]: d1.clear()
In [136]: d1
Out[136]: {}
（5）del d1
##功能：刪除字典對象
In [141]: d1 = {'name':'zhangsan','age':18,'score':98.6}
In [142]: d1
Out[142]: {'age': 18, 'name': 'zhangsan', 'score': 98.6}
In [143]: del d1
In [144]: d1
---------------------------------------------------------------------------
NameError Traceback (most recent call last)<ipython-input-144-fcd78e20c918> in <module>()----> 1 d1
NameError: name 'd1' is not defined
3.3 改
（1）通過對應的key值直接進行修改
In [146]: d1 = {'name':'zhangsan','age':18,'score':98.6}
In [147]: d1
Out[147]: {'age': 18, 'name': 'zhangsan', 'score': 98.6}
In [148]: d1['age'] = 1000 ###注意此處，'age'key是存在的，如果不存在相當于添加key和value
In [149]: d1
Out[149]: {'age': 1000, 'name': 'zhangsan', 'score': 98.6}
In [150]:
3.4 查
(1) 通過key索引
In [150]: d1
Out[150]: {'age': 1000, 'name': 'zhangsan', 'score': 98.6}
In [151]: d1['age']
Out[151]: 1000
In [152]: d1['weight'] ###如果key不存在，會掛掉
（2）dict.get(key, default=None)
key -- 字典中要查找的鍵。
default -- 如果指定鍵的值不存在時，返回該默認值。
返回指定鍵的值，如果值不在字典中返回默認值None。
In [153]: d1
Out[153]: {'age': 1000, 'name': 'zhangsan', 'score': 98.6}
In [154]: d1.get('age') ###key存在，返回key對應的值
Out[154]: 1000
In [155]: d1.get('weight') ###'weight'key不存在，返回值為defalut的值None 空，可以避免key不存在時，程序掛掉
In [156]: d1.get('weight','I miss you !!')####如果給defalut指定值，也就是 多了第二個參數，當key不存在的時候返回第二個參數的值
Out[156]: 'I miss you !!'
In [157]: d1.get('weight')
In [158]: d1.get('age','I miss you !!') ##只要key存在，第二個參數沒有作用，返回值依然為key的值
Out[158]: 1000
In [159]:
（3）dict.setdefault(key, default=None)
key -- 查找的鍵值。
default -- 鍵不存在時，設置的默認鍵值。
如果字典中包含有給定鍵，則返回該鍵對應的值，否則返回為該鍵設置的值。
In [159]: d1
Out[159]: {'age': 1000, 'name': 'zhangsan', 'score': 98.6}
In [160]: d1.setdefault('age') ###如果key存在，返回key對應的值
Out[160]: 1000
In [161]: d1.setdefault('weight') ###如果key不存在，相當于字典中添加一個key 'weight'對應的值為默認None
In [162]: d1
Out[162]: {'age': 1000, 'name': 'zhangsan', 'score': 98.6, 'weight': None}
In [163]: d1.setdefault('height',180) ###如果key不存在，相當于字典中添加一個key 'height',對應的值為180
Out[163]: 180
In [164]: d1
Out[164]: {'age': 1000, 'height': 180, 'name': 'zhangsan', 'score': 98.6, 'weight': None}
（4）in 和 not in
##注意字典在使用in 和 not in的時候，判斷是key是否存在字典中
In [165]: d1
Out[165]: {'age': 1000, 'height': 180, 'name': 'zhangsan', 'score': 98.6, 'weight': None}
In [166]: if 1000 in d1: ####只能判斷key是否在里面，1000是值，當做key搜索時沒有。
