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搜索时没有。
