Basic Data Structure：元组（tuple）、列表（list）、字典（dictionary）和集合（set）。
1. Tuple
1.1 tuple是长度固定，不可改变的序列。
tup = 1,2,3
type(tup)
存放在tuple中的object本身无法更改。
tuple = 1,[1,2,3],'ok'
tuple[2] = 'okok' #会报错
但是如果tuple内部的object是可更改的，（如tuple内部的一个object为list）那么我们可以试着更改一下
tuple[1].append(4)
#运行后tuple为(1,[1,2,3,4],'ok')
1.2 用+来合并多个tuple
tup = 1,2,3
tup1 = 4,5,6
tup + tup1
#result = (1,2,3,4,5,6)
1.3 * 相当于copy多份，也可以用在list上
tup = 1,2,3
tup1 = tup*2
tup + tup1
1.4 unpacking tuples（取出元组）
1.5 元组方法
1.5.1 count
2. List
2.1 列表的灵活性就很强了，大小和内容都可以变
2.2 list函数通常用来具现化迭代器或生成器
2.3 添加和移除元素
2.3.1 Append
直接在list后面添加
a_list.append('very much')
a_list
2.3.2 Insert
insert可以把元素插入到特定的位置
a_list.insert( 0,'hey' )
a_list
#result: ['hey', 'yes', 'i', 'hate', 'you', 'very much']
2.3.3 pop
insert的反向操作叫pop, 能移除序列中特定位置的元素：
a_list.pop( 0 )
a_list
#result: ['yes', 'i', 'hate', 'you', 'very much']
2.3.4 remove
remove可以通过值移除指定的element，如果同一个值在序列中多次出现，只移除第一个
a_list.remove('very much')
a_list
#result: ['yes', 'i', 'hate', 'you']
2.3.5 in/not in
检查一个值是否在list中，用in
'yes' in a_list
#result: True
2.4 合并list（extend/+）
2.4.1 用+合并list。
c_list = a_list + b_list
c_list
#result: ['yes', 'i', 'hate', 'you', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2.4.2 extend
通过entend方法，可以添加多个元素
a_list.extend(['but','now','i','dont'])
a_list
#result: ['yes', 'i', 'hate', 'you', 'but', 'now', 'i', 'dont']
append和extend的区别：
append是把元素添加到一个list里
extend是把两个list结合在一起
extend和+的区别：
+是创建了一个新的list并返回，运算量大
extend是在原本的list上做了更改，运算量小
2.5 排序
sort函数/设置key的sort函数
a_list.sort()
a_list
#result: ['but', 'dont', 'hate', 'i', 'i', 'now', 'yes', 'you']
a_list.sort(key=len)
a_list
#result: ['i', 'i', 'but', 'now', 'yes', 'you', 'dont', 'hate']
另外，Python中的bisect模块可以实现二分搜索和维持一个排好序的list
import bisect
c_list = [9,2,5,3,7]
c_list.sort()
c_list
bisect.bisect(c_list,10)
bisect.insort(c_list,10)
c_list
#result: [2,3,5,7,9]
#5（10在这个排好序的list中可以插入的位置）
#[2, 3, 5, 7, 9, 10]
2.6 切片
[start:stop], 输出的结果包含开头，不包含结尾。所以输出的结果的数量是stop-start
c_list[1:4]
#result: [3, 5, 7]
可以用来赋值
c_list[0:1] = [0,1,1.5]
c_list
#将元素2换成0，1，1.5
#result: [0, 1, 1.5, 3, 5, 7, 9, 10]
等等等等。
2.7 内建的序列函数
2.7.1 enumerate
enumerate通常用来把一个list中的位置和值映射到一个dcit字典里
Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身
i=0
#for value in a_list:
# i+=1
mapping={} #mapping是一个字典
for i,value in enumerate(a_list):
mapping[value] = i
mapping
#result: {'but': 2, 'dont': 6, 'hate': 7, 'i': 1, 'now': 3, 'yes': 4, 'you': 5}
2.7.2 sorted
sorted函数(函数≠方法！函数需要参数，方法直接通过对象调用)返回一个新的排好序的序列，而之前提到的.sort方法是直接更改原有的序列，不产生新序列
c_list = [9,2,5,3,7]
sorted(c_list)
#result: [2, 3, 5, 7, 9]
2.7.3 zip
用于"pairs"(成对)。把多个序列中每个对应的元素变成一对，最后返回一个含有tuple的list
zip1 = [1,2,3,4]
zip2 = [5,6,7]
zipped = zip(zip1,zip2)
zipped
#result: <zip at 0x19b93fb0788>
list(zipped)
#result: [(1, 5), (2, 6), (3, 7)]
zip可以接收任意长度的序列，最后返回的结果取决于最短的序列.
zip与enumerate合用：
for i,(a,b) in enumerate(zip(zip1,zip2)):
print('{0},({1},{2})'.format(i,a,b))
#result:
#0,(1,5)
#1,(2,6)
#2,(3,7)
还可以解压被压缩的序列。
(需要注意，序列被压缩后的类型是zip，需要用list()进行类型转换，转换为list类型后，才可以解压）
解压后返回的序列类型是元组（tuple）。
zip_list = list(zipped)
former,latter = zip(*zip_list)
former
#result: (1, 2, 3)
2.7.4 reversed
3. 字典（dict）
3.1
key-value pairs.创建方式是用{}
a_dict = {'amy':1,'paul':2,'summer':0} #创建
a_dict['allen']=1 #插入
a_dict
#result: {'allen': 1, 'amy': 1, 'paul': 2, 'summer': 0}
del a_dict['summer']#删除
a_dict
#result: {'allen': 1, 'amy': 1, 'paul': 2}
a_dict.pop('allen')#删除
a_dict
#result: {'amy': 1, 'paul': 2}
3.2 keys和values方法能返回dict中key-value组合的迭代器，不过并不按什么顺序。
a_dict.keys()
#result: dict_keys(['amy', 'paul'])
a_dict.values()
#result: dict_values([1, 2])
注意这两个方法返回的类型分别是dict_keys和dict_values，可以用list（）函数将他们转为list类型，让keys和values每次打印的顺序相同
3.3 可以用update方法来合并两个dict。
b_dict = {'elisa':4,'noodle':0}
a_dict.update(b_dict)
a_dict
#result: {'amy': 1, 'elisa': 4, 'noodle': 0, 'paul': 2}
3.4 把两个独立的序列按照key-value的方式生成一个dict
方法一：先将两个序列用zip方法pair起来，在遍历组合起来
key = ['a','b','c']
value = [1,2,3]
mapping = {}
for key,value in zip(key,value):
mapping[key]=value
mapping
#result: {'a': 1, 'b': 2, 'c': 3}
方法二：使用dict（）方法
key = ['d','e','f']
value = [1,2,3]
mapping = dict(zip(key,value))
mapping
#result: {'d': 1, 'e': 2, 'f': 3}
但这个方法也一定要先将key和value zip起来，让他们组合起来变成含有两个元素的一个整体。因为dict（）里面只接受一个object。
3.5 在dict的value值中添加值
？？？？
3.6 Valid dict key types(有效的key类型)
通常key的类型是不可更改的常量类型（int，float，string）或tuple。专业的叫法是hashability。可以查看一个object是否是hashable，只要是hashable的，就可以当做dict中的key。这里用hash函数查看
4. 集合Set
set是无序且元素不重复的。就像是key唯一，且没有value的字典。
4.1 创建
两种方式可以创建，一个是用set函数，一个是用花括号
a_set = set([1,2,3,4,5])
a_set
#result: {1, 2, 3, 4, 5}
b_set = {6,7,8,9,0}
b_set
#result: {0, 6, 7, 8, 9}
4.2 基本操作
集合的操作也支持，比如并集，交集，差集
a_set.union(b_set) #并集
#result: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
a_set.intersection(b_set) #交集
#result: set() 空集
4.3 set的元素必须是不可更改的。如果用list类型来创建set，只能先将其变为tuple
list = [10,20,30,40,50]
c_set = {list}
c_set
报错：
TypeError Traceback (most recent call last)
<ipython-input-35-0cabeb1b8f87> in <module>()
1 list = [10,20,30,40,50]
----> 2 c_set = {list}
3 c_set
TypeError: unhashable type: 'list'
Let's rectify it.
list = [10,20,30,40,50]
c_set = {tuple(list)}
c_set
5. List, Set, and Dict Comprehensions(推导式)
list推导式：
[expr for val in collection if condiction]
dict推导式：
dict_comp = {key-expr: value-expr / for value in collection if condition}
set的推导式：
set_comp = {expr for value in collection if condition}
map
????????
例子
name_dict = ['tom','rose','jack','icy']
d_dict = {val: i for i,val in enumerate(name_dict)}
d_dict
#result： {'icy': 3, 'jack': 2, 'rose': 1, 'tom': 0}
注意： dict会自动排序（字符串的话会按照首字母），list不会（按照创建的顺序）
6.Nested list comprehensions（嵌套列表表达式）
若list里面嵌套list，要如何将里面的元素取出来呢。
方法一：用一个for loop
all_data = [['John', 'Emily', 'Michael', 'Mary', 'Steven'],
['Maria', 'Juan', 'Javier', 'Natalia', 'Pilar']]
names_i_want = []
for names in all_data: #这里的names是list中的list
contain_i = [name for name in names if name.count('i')>0] #从list中list中取出元素
names_i_want.**append**(contain_i)
names_i_want
#result: [['Emily', 'Michael'], ['Maria', 'Javier', 'Natalia', 'Pilar']]
all_data = [['John', 'Emily', 'Michael', 'Mary', 'Steven'],
['Maria', 'Juan', 'Javier', 'Natalia', 'Pilar']]
names_i_want = []
for names in all_data:
contain_i = [name for name in names if name.count('i')>0]
names_i_want.**extend**(contain_i)
names_i_want
#result: ['Emily', 'Michael', 'Maria', 'Javier', 'Natalia', 'Pilar']
方法二：嵌套
all_data = [['John', 'Emily', 'Michael', 'Mary', 'Steven'],
['Maria', 'Juan', 'Javier', 'Natalia', 'Pilar']]
names_i_want = [name for names in all_data for name in names if name.count('i')>0]
names_i_want
#result: ['Emily', 'Michael', 'Maria', 'Javier', 'Natalia', 'Pilar']
记住嵌套的顺序跟写for loop是一样的。
生成a list of list的嵌套方法。
some_tuples = [(1,2,3),(4,5,6),(7,8,9)]
new_list = [[x for x in tup] for tup in some_tuples]
new_list
#result: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
