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有以下几个特点：

1. 1. 查找和插入的速度极快，不会随着key的增加而变慢；
   2. 需要占用大量的内存，内存浪费多。

而list相反：

1. 1. 查找和插入的时间随着元素的增加而增加；
   2. 占用空间小，浪费内存很少。

所以，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