积累一下，熟悉了这些函数之后会大大提升编程速度，要特别注意这些函数有没有返回值，是否需要接受，否则会因此浪费时间。
https://blog.csdn.net/jxfullstack/article/details/53408751 （这篇博客讲了Python中常见的数据结构，Python中常见的数据结构可以统称为容器（Container）。而序列（如列表和元组）、映射（如字典）以及集合（set）是三类主要的容器。）
序列中的每个元素都有自己的编号。Python中有6种内建的序列。其中列表和元组是最常见的类型。其他包括字符串、Unicode字符串、buffer对象和xrange对象。
字典（也叫散列表）是Python中唯一内建的映射类型。 字典的键可以是数字、字符串或者是元组，键必须唯一,键可以为不同的数据类型。在Python中，数字、字符串和元组都被设计成不可变类型，而常见的列表以及集合（set）都是可变的，所以列表和集合不能作为字典的键。键可以为任何不可变类型，这正是Python中的字典最强大的地方。
集合内部是基于hash结构的，元素的顺序是随意的，且不重复，这一点和字典非常像，可以简单理解集合为没有value的字典。
列表
https://www.cnblogs.com/chendai21/p/8125422.html （总结得很详细的博客）
list是有序的。
1.跟添加相关的函数：
list.append() 在list 末尾增加一个元素
list.insert（n,'4'） 在指定位置添加元素，如果指定的下标不存在，那么就是在末尾添加
list1.extend(list2) 合并两个list list2中仍有元素
这边注意一下extend()和list直接相加的区别。
a = [1, 2, 3]
b = [3, 4, 5]
c = a + b
print c
[1, 2, 3, 3, 4, 5]
list的乘法操作，也是属于添加元素，n * a
a = ["hello", "ad", "ai"]
print 3 * a
['hello', 'ad', 'ai', 'hello', 'ad', 'ai', 'hello', 'ad', 'ai']
相加不会改变a 和 b这两个list的值，而extend()没有返回值，会直接改变调用这个函数的list变量的值。
a.extend(d)
print a
[1, 2, 3, 3, 4, 5]
2.跟查找相关的函数：
print(list.count(xx)) 查看某个元素在这个列表里的个数，如果该元素不存在，那么返回0。
print(list.index(xx))找到这个元素的小标，如果有多个，返回第一个，如果找一个不存在的元素会报错。
如果想得到某个重复元素的所有下标，可以通过写循环来得到。
a = [1,2,3,1]
a.count(1) # 2
a.index(1) # 0
[x for x in range(len(a)) if a[x] == 1] # 一次获得所有位置返回结果为 [0, 3]
3.跟删除相关的函数：
list.pop() 删最后一个元素，有返回值，会返回这个要删除的元素。
list.pop(n)指定下标，删除指定的元素的下标，如果删除一个不存在的下标会报错。
list.remove(xx) 通过指定元素，删除list 里面的一个元素，如果有多个相同的元素，删除第一个 ，没有返回值。
那如果想删除所有的指定元素怎么办呢？
1）使用count和remove的方法。
def delList(L, i):
# if L.count(i) != 0:
for x in range(L.count(i)):
L.remove(i)
return L
if __name__ == "__main__":
# print(delList([1, 2, 2, 3, 3, 4, 5]))
print delList([1, 8, 8, 3, 9, 3, 3, 3, 3, 3, 6, 3], 3)2）重新构造一个list，遍历原始list，添加不等于要删除元素的其他元素：
a = [1, 8, 8, 3, 9, 3, 3, 3, 3, 3, 6, 3]
print [x for x in a if x != 3]list中如何删除重复元素？
1）可以使用将list转为set的方法，但这种方法会改变list中元素的顺序，因为Set是基于哈希，是无序的。
a = ['he', 'llo', 'hs', 'lulu', 'ai', 'he']
print list(set(a))
['ai', 'hs', 'lulu', 'llo', 'he']
2）也可以使用字典的方法，将list中的元素变为字典的key，这个方法其实和集合的方法类似，因为字典中的key不允许有重复值，但同样的，也会改变list中元素的顺序。
a = [1,2,4,2,4,5,6,5,7,8,9,0]
b = {}
b = b.fromkeys(a)
c = list(b.keys())
print c
[0, 1, 2, 4, 5, 6, 7, 8, 9]
3)使用count和remove的方法，如果某个元素的count不为1，则remove它出现的次数-1次，重复元素只会保留最后一个。
# -*- coding:utf-8 -*-
def delList(L):
for i in L:
if L.count(i) != 1:
for x in range((L.count(i) - 1)):
L.remove(i)
return L
if __name__ == "__main__":
# print(delList([1, 2, 2, 3, 3, 4, 5]))
print(delList([1, 8, 8, 3, 9, 3, 3, 3, 3, 3, 6, 3]))
返回的结果为：
[1, 8, 9, 6, 3]
4）使用重新构造一个list，然后添加要去除重复元素的list中的元素的方法。这种方法重复元素会保留第一个。
def delList_1(L):
L1 = []
for i in L:
if i not in L1:
L1.append(i)
return L1
if __name__ == "__main__":
# print(delList([1, 2, 2, 3, 3, 4, 5]))
print(delList_1([1, 8, 8, 3, 9, 3, 3, 3, 3, 3, 6, 3]))返回的结果为：
[1, 8, 3, 9, 6]
del list[n] 删除指定下标对应的元素,无返回值。
del list 删除整个列表， list删除后无法访问。
4.用来反转和排序的函数：
list.reverse()将列表反转，没有返回值，直接改变原来的list。
list.sort()排序，默认升序，没有返回值，直接改变原来的list。
list.sort(reverse=True) 降序排列
注：list 中有字符串，数字时不能排序，排序针对同类型
5.用来切片的函数：
name[n:m] 切片是不包含后面那个元素的值（顾头不顾尾）
这边注意-1的用法，表示最后一个元素。
name[:m] 如果切片前面一个值缺省的话，从开头开始取
name[n:] 如果切片后面的值缺省的话，取到末尾
name[:] 如果全部缺省，取全部
name[n:m：s] s：步长 隔多少个元素取一次
步长是正数，从左往右取
步长是负数，从右往左取
注：切片同样适用于字符串，字符串也有下标
6.其他的常用操作：
1）、len(list)：列表元素个数
2）、max(list)：返回列表元素最大值
3）、min(list)：返回列表元素最小值
4）、list(seq)：将元组转换为列表
5）、enumerate 用法（打印元素对应的下标）,这个很常用，注意别漏了enumerate。
同时取下标，元素
结果如下：
6）、将list的值转成字符串。
a = ["hello", "world", "ai"]
print ",".join(a) #可以指定分隔符，返回使用分隔符进行拼接的字符串。
hello,world,ai
7.列表生成的方法：
实例1：要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用list = list(range(1,11))
实例2：生成[1x1, 2x2, 3x3, ..., 10x10]可以用 list = list(x * x for x in range(1,11))
实例3：for循环后面还可以加上if判断，这样我们就可以筛选出仅偶数的平方：list = list(x * x for x in range(1,11) if x%2== 0)
实例4：使用两层循环，可以生成全排列：
list = [m + n for m in 'ABC' for n in 'XYZ'] print(list)
输出结果：['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
实例5：通过list函数（其实list是一种类型而不是函数）对字符串创建列表非常有效：
print list("hello")
['h', 'e', 'l', 'l', 'o']
8.检测元素是否在list中，使用in或者not in，这两个保留字在string、dict中同样适用。
元组
元组与列表一样，也是一种序列，唯一不同的是元组不能被修改（字符串其实也有这种特点）。
http://www.runoob.com/python/python-tuples.html （tuple和list的区别就是tuple不能修改，其他的都差不多啦）
1.创建元组
tuple函数和序列的list函数几乎一样：以一个序列（注意是序列）作为参数并把它转换为元组。如果参数就算元组，那么该参数就会原样返回：
元组不可以修改，因此也不可以删除元组中的元素。
字符串
字符串也是一种序列，因此序列可以使用的 + 、 * 、 []、切片、in、not in都是可以用的。
需要记住字符串和元组一样，是不可以改变的。
还可以直接定义unicode字符串，如 u'中文' 可得到 u'\u4e2d\u6587'。有时候在进行数据解析时，中文在str中出现，但使用"中文" in str 得不到返回结果，就可能是编码问题，使用u'中文' in str 就会得到正确的结果。
Python 中字符串的一些内建函数：
http://www.cnblogs.com/khaha/p/7725071.html (此博客详细介绍了字符串常用的一些内建函数，并且都链接到了菜鸟上)
稍微归下类记一下，之后想实现的功能，先看看用内建函数能不能完成。
1. 判断类函数，例如判断字符串中有无全为数字、空格等。
isalnum() 如果字符串至少有一个字符并且所有字符都是数字或字母，则返回True,否则返回 False。
isalpha() 如果字符串至少有一个字符并且所有字符都是字母，则返回 True, 否则返回 False。
isdigit() 如果字符串只包含数字则返回 True 否则返回 False。
islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False。
isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False。
isspace() 如果字符串中只包含空白，则返回 True，否则返回 False。
istitle() 如果字符串是标题化的(见 title())则返回 True，否则返回 False，这个指的是所有的单词都是首字母大写的，则认为是标题化的。
isupper() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False。
endswith(suffix, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False。
startswith(str, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范 围内检查。
isdecimal() 检查unicode字符串是否只包含十进制字符，如果是返回 true，否则返回 false。
2.转换类函数，例如将字符串都转为大写、小写字母等。
capitalize() 返回将字符串的第一个字符转换为大写字母的字符串，注意字符串是不可以被改变的，只能新建一个字符串来接收这些函数的返回值。
center(width, fillchar) 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
a = 'hellohcuk111'
a.center(20)
' hellohcuk111 '
expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
ljust(width[, fillchar]) 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
rjust(width,[, fillchar]) 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串。
zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充0。
lower() 转换字符串中所有大写字符为小写。
upper() 转换字符串中的小写字母为大写。
lstrip() 截掉字符串左边的空格或指定字符。
rstrip() 删除字符串字符串末尾的空格。
strip([chars]) 在字符串上执行 lstrip()和 rstrip()。
swapcase() 将字符串中大写转换为小写，小写转换为大写。
title() 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())。
translate(table, deletechars="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中。python3中才有的功能。
replace(old, new [, max]) 把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
splitlines([keepends]) 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果 为 True，则保留换行符。
str = "this is string example....\nwow!!!"
a = str.splitlines()
print a结果为：
['this is string example....', 'wow!!!']
3.查找类及其他一些函数。
count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数。
find(str, beg=0 end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值 ，否则返回-1。
index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常。
rfind(str, beg=0,end=len(string)) 类似于 find()函数，不过是从右边开始查找。
rindex( str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始。
join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串。
res = [1, 2, 3, 4, 5]
print ','.join(str(i) for i in res)
将列表中的元素打印出来。
结果为：1, 2, 3, 4, 5
len(string) 返回字符串长度。
split(str="", num=string.count(str)) num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串。
字典
字典由键和对应值成对组成。字典也被称作关联数组或哈希表。
key必须可hash、且必须为不可变数据类型、必须唯一，如数字、字符串、元组。
值可存放任意多个值、可修改、可以不唯一。
两个特点：无序，查找速度快。
参考文献：
https://www.jb51.net/article/133981.htm
1. 字典的创建及基本操作
1）dict()→ dict: empty dictionary (like {}),创建一个空的字典。
2）使用for循环来创建字典：
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
3）dict(**kwargs)→ dict: from named parameters and their values。利用python中的可变参数来创建字典。
https://www.cnblogs.com/goodhacker/p/3360721.html （这个博客讲了*args和**kwargs的区别）
*args表示任何多个无名参数，它是一个tuple；**kwargs表示关键字参数，它是一个 dict。并且同时使用*args和**kwargs时，*args参数列必须要在**kwargs前。
>>> def foo(*args, **kwargs):
print 'args =', args
print 'kwargs = ', kwargs
print '-----------------------'
>>> if __name__ == '__main__':
foo(1, 2, 3, 4)
foo(a=1, b=2, c=3)
foo(1,2,3,4, a=1, b=2, c=3)
foo('a', 1, None, a=1, b='2', c=3)
输出结果为：
args = (1, 2, 3, 4)
kwargs = {}
-----------------------
args = ()
kwargs = {'a': 1, 'c': 3, 'b': 2}
-----------------------
args = (1, 2, 3, 4)
kwargs = {'a': 1, 'c': 3, 'b': 2}
-----------------------
args = ('a', 1, None)
kwargs = {'a': 1, 'c': 3, 'b': '2'}
-----------------------
还可以这样：
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}4）dict(iterable)→ dict: from (key,value) by iterable
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}5）dict(otherdict)→ dict: duplicated from another one (first level),通过其他的字典来创建新的字典。
6）还可以通过python中的collections中的defaultdict来创建指定值的格式的字典，这种方式对于事先确定了值的类型是list或者set的话特别好使，使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，也可以使用defaultdict。关于defaultdict的更多方法可以看 https://www.cnblogs.com/jidongdeatao/p/6930325.html
7）collections中还有一个OrderedDict，本来的dict是无序的，如果要保持Key的顺序，可以用OrderedDict：
8）Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。返回值为一个新字典。
9）Python 字典(Dictionary) copy() 函数返回一个字典的浅复制。
http://www.runoob.com/w3cnote/python-understanding-dict-copy-shallow-or-deep.html 讲了直接赋值、浅拷贝和深度拷贝的区别。
基本操作：
(1)len()：返回字典中键—值对的数量；
(2)d[k]:返回关键字k对应的值；
(3)d[k]=v:将值v关联到键值k上；
(4)del d[k]:删除键值为k的项；
(5)key in/not in d:键值key是否在d中。
字典的迭代，别忘了iteritems：
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.iteritems():
... print k, v
...
gallahad the pure
robin the brave
d.iteritems()→ iterator over (key, value) pairs 键值对
d.iterkeys()→ iterator over keys 键
d.itervalues()→ iterator over values 值
2.字典的删除类的函数，以下实例来自菜鸟教程。
1）dict.clear()：没有返回值，clear() 函数用于删除字典内所有元素。
2）Python 字典 pop() 方法删除字典给定键 key 及对应的值，返回值为被删除的值。key 值必须给出。 否则，返回 default 值。如果给出的key在字典中不存在，会报KeyError异常。
3）Python 字典 popitem() 方法随机返回并删除字典中的一对键和值，返回一个键值对(key,value)形式。
如果字典已经为空，却调用了此方法，就报出KeyError异常。
3.字典的查询类的函数
1）Python 字典(Dictionary) get() 函数返回指定键的值，如果值不在字典中返回默认值。
2）Python 字典(Dictionary) has_key() 函数用于判断键是否存在于字典中，如果键在字典dict里返回true，否则返回false。
3）Python 字典(Dictionary) keys() 函数以列表返回一个字典所有的键。
4）Python 字典(Dictionary) values() 函数以列表返回字典中的所有值。
5）Python 字典(Dictionary) items() 函数以列表返回可遍历的(键, 值) 元组数组。
6）Python 字典 setdefault() 函数和get() 方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
4.字典的修改类的函数
Python 字典(Dictionary) update() 函数把字典dict2的键/值对更新到dict里。该方法没有任何返回值。
5.其他函数
1)Python中对dict的key和value进行排序。
https://www.cnblogs.com/harvyxu/p/8547458.html （详细讲了Python中字典的排序）
按照key进行排序，一句话搞定：
d = {1: 'lulu', 2: 'sk', 3: 'lala', 100: 'xx', 10: 'yy', 18: 'qq'}
e = {k:d[k] for k in sorted(d.keys())}
e = {1: 'lulu', 2: 'sk', 3: 'lala', 100: 'xx', 10: 'yy', 18: 'qq'}
按照value进行排序，需要用到Python的内建函数sorted，然后使用key指定要排序的对象，这边要特别注意sorted()的返回值为一个排好序的list，对字典使用sorted返回的将是一个由tuple组成的list。如果想返回一个dict，可以用collections中的OrderedDict进行接收。
a = {'sk': 2, 'yy': 10, 'xx': 100, 'qq': 18, 'lulu': 1, 'lala': 3}
c = collections.OrderedDict(sorted(a.iteritems(), key = lambda x: x[1], reverse = True))
c = OrderedDict([('xx', 100), ('qq', 18), ('yy', 10), ('lala', 3), ('sk', 2), ('lulu', 1)])
2)将字典中的key和value值互换，将原来的value值作为key，原来的key值作为value。
d = {v:k for k , v in c.iteritems()}
d = {1: 'lulu', 2: 'sk', 3: 'lala', 100: 'xx', 10: 'yy', 18: 'qq'}
dict 先写到这，之后再遇到相关的用法，再更新，也欢迎大家留言补充呀~
集合
set是无序的，无重复元素的数据类型。set中的值和list一样可改变。Frozen sets 是一旦创建就不可改变的。
集合最常用的场景：去重，关系运算（取交/并/差集）
1）集合的创建及基本操作
s = set() #定义空集合
set([iterable]) → set: using values from iterable, 这边注意[]
frozenset([iterable]) → frozenset: using values from iterable 通过可迭代的对象创建集合。
集合的基本操作：
http://blog.51cto.com/10616534/1944841
set1 = set([1,2,3,4,5])
set2 = set([3,4,5,6,7])交集：
set3 = set1 & set2
set3 = set1.intersection(set2)
set([3, 4, 5])
并集：
set4 = set1 | set2
set4 = set1.union(set2)
set([1, 2, 3, 4, 5, 6, 7])
差集：
set1有而set2没有的元素，即set1与set2的差集。
set5 = set1 - set2
set5 = set1.difference(set2)
set([1, 2])
set2有而set1没有的元素，即set2与set1的差集。
set6 = set2 - set1
set6 = set2.difference(set1)
set([6, 7])
对称差集，即去掉两个集合的共同的部分。
set7 = set1 ^ set2
set 7 = set1.symmetric_difference(set2)
set([1, 2, 6, 7])
子、父集判断:
判断set1是否为set2的子集。
set1.issubset(set2)
False
判断set1是否为set2的父集，即set2是否为set1的子集。
set1.issuperset(set2) <=> set2.issubset(set1)
False
2)集合的增、删、更新类的函数
set1 = set([1,2,3,4])
#向集合中添加一个元素
set1.add(5)
print("向集合中添加一个元素5后：",set1)
output:向集合中添加一个元素5后： {1, 2, 3, 4, 5}
#向集合中添加一组元素
update(iterable) ➤ adds all values from iterable to s
set1.update([7,8,9])
print("向集合中添加一组元素[7,8,9]后：",set1)
output: 向集合中添加一组元素[7,8,9]后：{1, 2, 3, 4, 7, 8, 9}
#删除一个元素
set1.remove(1)
print("从集合中删除元素1后：",set1)
output:从集合中删除元素1后： {2, 3, 4, 5}
#计算集合的长度
l = len(set1)
print("集合的长度为：",l)
output:集合的长度为： 4
#判断某个元素是否在集合内
flag1 = 2 in set1
print("判断元素2是否在集合内：",flag1)
output:判断元素2是否在集合内： True
#判断某个元素是否不在集合内
flag2 = 3 not in set1
print("判断元素3是否不在集合内：",flag2)
output：判断元素3是否不在集合内： False
#对集合进行一次浅复制
set2 = set1.copy()
print("对集合进行一次浅复制：",set2
output:对集合进行一次浅复制： {2, 3, 4, 5}
其他的数据结构
Array
python 内置的array模块，和list的区别是array的数据类型必须相同。类似于其他python序列，可以采用同样方式扩展和处理array。
https://www.jb51.net/article/87987.htm （这个博客和他相关的一些博客都讲了array的用法）
array平时用得不多，先放着， 用到再更新。
