Day2：数据类型（列表、元组、字典）
一.列表
定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素。
特性：
1.可存放多个值。
2.可修改指定索引位置对应的值，可变。
3.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序。
1.列表创建
list_test=['lhf',12,'ok']
或
list_test=list('abc')
或
list_test=list(['lhf',12,'ok'])
2.列表常用操作
>>> classmates = ['Michael', 'Bob', 'Tracy'] >>> classmates ['Michael', 'Bob', 'Tracy']
索引
>>> classmates = ['Michael', 'Bob', 'Tracy'] >>> classmates[0] 'Michael' >>> classmates[1] 'Bob' >>> classmates[2] 'Tracy' >>> classmates[3] Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: list index out of range >>> classmates[-1] 'Tracy'
切片
>>> classmates = ['Michael', 'Bob', 'Tracy'] >>> classmates[0:] ['Michael', 'Bob', 'Tracy'] >>> classmates[0::2] ['Michael', 'Tracy'] >>> classmates[:2] ['Michael', 'Bob'] >>> classmates[-2:-1] ['Bob'] >>> classmates[-2:0] [] >>> classmates[-3:-1] ['Michael', 'Bob']
追加：append(向后追加)，insert(想指定索引位置添加数据)
>>> classmates = ['Michael', 'Bob', 'Tracy'] >>> classmates.append('Adam') >>> classmates ['Michael', 'Bob', 'Tracy', 'Adam'] >>> classmates.insert(1, 'Jack') >>> classmates ['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
删除
>>> classmates = ['Michael', 'Bob', 'Tracy','Adam'] >>> classmates.pop() 'Adam' >>> classmates ['Michael', 'Jack', 'Bob', 'Tracy'] >>> classmates.pop(1) 'Jack' >>> classmates ['Michael', 'Bob', 'Tracy']
长度
>>> len(classmates) 3
循环
>>> classmates = ['Michael', 'Bob', 'Tracy'] >>> for i in classmates: ... print(i) ... Michael Bob Tracy
包含
>>> classmates = ['Michael', 'Bob', 'Tracy'] >>> 'Bob' in classmates True >>> 'ogen' in classmates False
3.常用函数
.copy() 复制
.append() 在列表后增加元素
.insert() 在索引号前增加元素
.pop() 默认从后面删除元素
.remove() 按照元素进行删除
.index() 按照元素进行查找
.clear() 清楚列表元素，原列表为空
.count() 查找元素的个数
.extend([1,2,3]) 扩展列表，将[1,2,3]列表和原列表合成一个列表
.reverse() 将列表进行倒序
.sort() 将列表中的元素按顺序排列。字符创和数字不能同时排序。.sort(reverse=True)倒序排列。
二.元组
定义：与列表类似，只不过［］改成（）
特性：
1.可存放多个值。
2.不可变。
3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序。
1.元组创建
ages = (11, 22, 33, 44, 55)
或
ages = tuple((11, 22, 33, 44, 55))
定义一个空的元组 t=()
定义只有1个元素的元组
t=(1) 这样t的类型就是整形
t=(1,) 这样t的类型就是元组
一个“可变的”tuple：
>>> t = ('a', 'b', ['A', 'B']) >>> t[2][0] = 'X' >>> t[2][1] = 'Y' >>> t ('a', 'b', ['X', 'Y'])
定义的时候tuple包含的3个元素：
当我们把list的元素'A'和'B'修改为'X'和'Y'后，tuple变为：
表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！
2.元组的操作
索引
>>> ages = (11, 22, 33, 44, 55) >>> ages[0] 11
切片
>>> ages = (11, 22, 33, 44, 55) >>> ages[0:] (11, 22, 33, 44, 55) >>> ages[0:3] (11, 22, 33) >>> ages[:3] (11, 22, 33) >>> ages[:3:2] (11, 33) >>> ages[-3:-1] (33, 44)
循环
ages = (11, 22, 33, 44, 55) >>> for i in ages: ... print(i) ... 11 22 33 44 55
包含
>>> ages = (11, 22, 33, 44, 55) >>> 11 in ages True >>> 12 in ages False
三.字典
定义：｛key1:value1,key2:value2｝,key-value结构，key必须可hash
特性：
1.可存放多个值。
2.可修改指定key对应的值，可变。
3.无序。
1.字典的创建
person = {"name": "sb", 'age': 18}
或
person = dict(name='sb', age=18)
person = dict({"name": "sb", 'age': 18})
person = dict((['name','sb'],['age',18]))
{}.fromkeys(seq,100) #不指定100默认为None
注意：
>>> dic={}.fromkeys(['k1','k2'],[])
>>> dic
{'k1': [], 'k2': []}
>>> dic['k1'].append(1)
>>> dic
{'k1': [1], 'k2': [1]}
2.字典的操作
索引
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
新增
>>> d['alex']=100 >>> d {'Michael': 95, 'Bob': 75, 'Tracy': 85, 'alex': 100}
如果key不存在，就会报错。
避免key不存在的错误，有两种判断key是否存在的方式
1.通过in判断
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> 'Thomas' in d
False
2.通过get()判断，如果key不存在，可以返回None，或者自己指定的value：
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1
删除
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}
循环
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> for i in d:
... print(i,d[i])
...
Michael 95
Bob 75
Tracy 85
长度
>>> len(d) 4
请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。
和list比较，dict有以下几个特点：
- 查找和插入的速度极快，不会随着key的增加而变慢；
- 需要占用大量的内存，内存浪费多。
而list相反：
- 查找和插入的时间随着元素的增加而增加；
- 占用空间小，浪费内存很少。
所以，dict是用空间来换取时间的一种方法。
dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。
这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。
要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key：
.pop(key,'str') 删除key对应的键值对，返回value。key不存在返回str。
.popitem() 随机删除键值对
.keys() 返回字典的所有key到dict_keys中。可以使用list(d.keys())
.values() 返回字典的valu到dict_values中，可以使用list(d.keys())
.items() 返回键值对。
.get(key,'str') 返回key对应的值value，key不存在返回自定义的str。
.clear() 清空字典
.copy() 复制字典
{}.fromkeys([],None) 初始化字典
.updae() 将新字典更新到原字典中
四.数据类型分类
1、可变不可变
可变：列表，字典
不可变：数字，字符串，元组
2、存放值的个数
一个值：数字，字符串
多个值(容器类型)：列表，元组，字典
3、取值方式
直接取值：数字
序列类型：字符串，元组，列表
映射类型：字典
参考博客：http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431658624177ea4f8fcb06bc4d0e8aab2fd7aa65dd95000
