写在前面：之前学习了很多深度学习的东东，不过方向被毙掉之后，那些也用不上了…（基本上用不上了），现在用的大多是机器学习的内容，然后我现在的研究领域是大数据分析，所以说，要重新把python的东西复习复习，拾起来拾起来…
1 元组、拆分、tuple方法
1.1 元组（tuple）：固定长度、不可改变的Python序列对象
- 创建方式：用逗号分隔一列值
In [1]: tup = 4, 5, 6
In [2]: tup
Out[2]: (4, 5, 6)
- 复杂表示
In [3]: nested_tup = (4, 5, 6), (7, 8)
In [4]: nested_tup
Out[4]: ((4, 5, 6), (7, 8))
- 利用函数
tuple， 可以将任意序列或者迭代器转换为元组
In [5]: tuple([4, 0, 2])
Out[5]: (4, 0, 2)
In [6]: tup = tuple('string')
In [7]: tup
Out[7]: ('s', 't', 'r', 'i', 'n', 'g')
- 元组中的对象（对象是常量，不可变的话），一旦创建之后是不能修改的；但是！如果是列表的话，是可以在原位修改的，这是因为，列表是可变的。
In [9]: tup = tuple(['foo', [1, 2], True])
In [10]: tup[2] = False # 这里会报错的
In [11]: tup[1].append(3) # 这样做是没问题的
In [12]: tup
Out[12]: ('foo', [1, 2, 3], True)
- 加号+ 表示串联；乘号 * 表示复制后串联
In [13]: (4, None, 'foo') + (6, 0) + ('bar',)
Out[13]: (4, None, 'foo', 6, 0, 'bar')
In [14]: ('foo', 'bar') * 4
Out[14]: ('foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'bar')
1.2 拆分元组，这个操作非常灵活！
In [15]: tup = (4, 5, 6)
In [16]: a, b, c = tup
In [17]: b
Out[17]: 5
In [18]: tup = 4, 5, (6, 7)
In [19]: a, b, (c, d) = tup
In [20]: d
Out[20]: 7
- 替换操作变得非常简单！
In [21]: a, b = 1, 2
In [22]: a
Out[22]: 1
In [23]: b
Out[23]: 2
# 无需像c语言那样，需要一个中间变量
In [24]: b, a = a, b
In [25]: a
Out[25]: 2
In [26]: b
Out[26]: 1
- 变量的拆分，在迭代元组 或者是 列表中，非常常用！
In [27]: seq = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
In [28]: for a, b, c in seq:
....: print('a={0}, b={1}, c={2}'.format(a, b, c))
a=1, b=2, c=3
a=4, b=5, c=6
a=7, b=8, c=9
- 当然了，这也可以延伸到，可以使得函数返回多个值！（c语言就只能返回一个值）
- 这地方没有具体代码示例，举个例子：
def function():
...
return tuple1, tuple2
# 在调用的时候：
t1, t2 = function()
# 如果等号左边是两个值，就会一一对应过去
t = function()
# 如果是一个值，那么t[0]相当于t1，t[1]相当于t2
1.3 "舍弃”操作
- Python最近新增了更多高级的元组拆分功能，允许从元组的开头“摘取”几个元素。它使用了特殊的语法*rest，这也用在函数签名中以抓取任意长度列表的位置参数
In [29]: values = 1, 2, 3, 4, 5
In [30]: a, b, *rest = values
In [31]: a, b
Out[31]: (1, 2)
In [32]: rest
Out[32]: [3, 4, 5]
rest的部分是想要舍弃的部分，rest的名字不重要。作为惯用写法，许多Python程序员会将不需要的变量使用下划线：
In [33]: a, b, *_ = values
1.4 count：统计某个值出现频率
- 因为元组的大小和内容不能修改，它的实例方法都很轻量。其中一个很有用的就是count（也适用于列表），它可以统计某个值得出现频率：
In [34]: a = (1, 2, 2, 2, 3, 4, 2)
In [35]: a.count(2)
Out[35]: 4
2 列表、添加和删除、串联和组合、排序、切片
2.1 列表[list]：可变长度，内容可修改
- 与元组对比，列表的长度可变、内容可以被修改。你可以用方括号定义，或用
list函数： - 元组tuple是用圆括号定义的
In [36]: a_list = [2, 3, 7, None]
In [37]: tup = ('foo', 'bar', 'baz')
In [38]: b_list = list(tup) # 元组转换为列表
In [39]: b_list
Out[39]: ['foo', 'bar', 'baz']
In [40]: b_list[1] = 'peekaboo' # 修改下标为1的列表值
In [41]: b_list
Out[41]: ['foo', 'peekaboo', 'baz']
2.2 实体化迭代器或生成器
In [42]: gen = range(10)
In [43]: gen
Out[43]: range(0, 10)
In [44]: list(gen) # 实体化
Out[44]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2.3 添加和删除元素
- 利用
append在列表末尾添加元素
In [41]: b_list
Out[41]: ['foo', 'peekaboo', 'baz']
In [45]: b_list.append('dwarf')
In [46]: b_list
Out[46]: ['foo', 'peekaboo', 'baz', 'dwarf']
insert在指定的位置插入元素
In [47]: b_list.insert(1, 'red')
In [48]: b_list
Out[48]: ['foo', 'red', 'peekaboo', 'baz', 'dwarf']
与append相比，insert耗费的计算量大，因为对后续元素的引用必须在内部迁移，以便为新元素提供空间
【注意：插入的序号必须在0和列表长度之间。】
insert的逆运算是pop，它删除并返回指定位置的元素。
In [49]: b_list.pop(2)
Out[49]: 'peekaboo'
In [50]: b_list
Out[50]: ['foo', 'red', 'baz', 'dwarf']
remove可以指定删除一个值，删除的是第一个值
In [52]: b_list
Out[52]: ['foo', 'red', 'baz', 'dwarf', 'foo']
In [53]: b_list.remove('foo')
In [54]: b_list
Out[54]: ['red', 'baz', 'dwarf', 'foo']
2.4 【如果不考虑性能，append和remove 就可以把python列表当做“多重集”】
2.5 解释列表是否包含某个值：in
In [55]: 'dwarf' in b_list
Out[55]: True
In [56]: 'dwarf' not in b_list
Out[56]: False
2.6 在列表中检查是否存在某个值，速度远远小于字典和集合。
因为在python中是线性搜索列表的值，但是在字典和集合中，在同样的时间内还可以检查其他项。
2.7 串联和组合列表
- 与元组类似，可以用加号将两个列表串联起来：
In [57]: [4, None, 'foo'] + [7, 8, (2, 3)]
Out[57]: [4, None, 'foo', 7, 8, (2, 3)]
- 如果已经定义了一个列表，用
extend方法可以追加多个元素：
In [58]: x = [4, None, 'foo']
In [59]: x.extend([7, 8, (2, 3)])
In [60]: x
Out[60]: [4, None, 'foo', 7, 8, (2, 3)]
- 通过加法将列表串联的计算量较大，因为要新建一个列表，并且要复制对象。用extend追加元素，尤其是到一个大列表中，更为可取。因此代码a比代码b快。
代码a：
everything = []
for chunk in list_of_lists:
everything.extend(chunk)
代码b：
everything = []
for chunk in list_of_lists:
everything = everything + chunk
2.8 排序：sort
sort是原地排序，不创建新的对象
In [61]: a = [7, 2, 5, 1, 3]
In [62]: a.sort()
In [63]: a
Out[63]: [1, 2, 3, 5, 7]
- 可以按照长度对字符串排序。
key==len
In [64]: b = ['saw', 'small', 'He', 'foxes', 'six']
In [65]: b.sort(key=len)
In [66]: b
Out[66]: ['He', 'saw', 'six', 'small', 'foxes']
2.8 排序：sorted
sorted函数可以从任意序列的元素返回一个新的排好序的列表
In [87]: sorted([7, 1, 2, 6, 0, 3, 2])
Out[87]: [0, 1, 2, 2, 3, 6, 7]
In [88]: sorted('horse race')
Out[88]: [' ', 'a', 'c', 'e', 'e', 'h', 'o', 'r', 'r', 's']
sorted函数可以接受和sort相同的参数。
2.9 二分搜索+维护已排序的列表
bisect模块，支持二分查找，以及向已经排好序的列表中插入值。（import bisect）bisect.bisect插入之后仍然保证排序的位置bisect.insert是向指定位置插入数据
In [67]: import bisect
In [68]: c = [1, 2, 2, 2, 3, 4, 7]
In [69]: bisect.bisect(c, 2)
Out[69]: 4
In [70]: bisect.bisect(c, 5)
Out[70]: 6
In [71]: bisect.insort(c, 6)
In [72]: c
Out[72]: [1, 2, 2, 2, 3, 4, 6, 7]
注意：bisect模块不会检查列表是否已排好序，进行检查的话会耗费大量计算。因此，对未排序的列表使用bisect不会产生错误，但结果不一定正确。
2.10 切片 [start:stop]
- 使用切片，可以在一个很大的数据中，选择一部分连续的数据。
[start : stop]注意是左开右闭，是包含左边不包含右边的
In [73]: seq = [7, 2, 3, 7, 5, 6, 0, 1]
In [74]: seq[1:5]
Out[74]: [2, 3, 7, 5]
- 切片也可以被赋值
In [73]: seq = [7, 2, 3, 7, 5, 6, 0, 1]
# 把6，3 赋值给下标为3的元素
In [75]: seq[3:4] = [6, 3]
In [76]: seq
Out[76]: [7, 2, 3, 6, 3, 5, 6, 0, 1]
start或stop都可以被省略，省略之后，分别默认序列的开头和结尾
In [77]: seq[:5]
Out[77]: [7, 2, 3, 6, 3]
In [78]: seq[3:]
Out[78]: [6, 3, 5, 6, 0, 1]
- 负数表示从后向前切片，最后一个元素是
-1
In [76]: seq
Out[76]: [7, 2, 3, 6, 3, 5, 6, 0, 1]
In [79]: seq[-4:]
Out[79]: [5, 6, 0, 1]
In [80]: seq[-6:-2]
Out[80]: [6, 3, 5, 6]
- 在第二个冒号后面使用
step，可以隔一个取一个元素
In [81]: seq[::2]
Out[81]: [7, 3, 3, 6, 1]
- 一个聪明的方法是使用-1，它可以将列表或元组颠倒过来
In [82]: seq[::-1]
Out[82]: [1, 0, 6, 5, 3, 6, 3, 2, 7]
3 序列函数 enumerate
在c语言中，如果你想在循环中跟踪当前项的序号，需要下面的这段代码
i = 0
for value in collection:
# do something with value
i += 1
Python 内建立了一个 enumerate 函数，可以返回(i, value) 的元组序列
for i, value in enumerate(collection):
# do something with value
那么，当你索引数据时，就可以使用enumerate 来计算序列 dict映射到的位置的值了！
In [83]: some_list = ['foo', 'bar', 'baz']
In [84]: mapping = {
}
In [85]: for i, v in enumerate(some_list):
....: mapping[v] = i
In [86]: mapping
Out[86]: {
'bar': 1, 'baz': 2, 'foo': 0}
3.1 zip函数
zip 可以将多个列表、元组或其他序列 成对 组合成一个元组列表。
通过代码示例来深入理解 成对 的含义：
In [89]: seq1 = ['foo', 'bar', 'baz']
In [90]: seq2 = ['one', 'two', 'three']
In [91]: zipped = zip(seq1, seq2)
In [92]: list(zipped)
Out[92]: [('foo', 'one'), ('bar', 'two'), ('baz', 'three')]
zip可以处理任意多的序列，元素的个数取决于最短的序列
In [93]: seq3 = [False, True]
In [94]: list(zip(seq1, seq2, seq3))
Out[94]: [('foo', 'one', False), ('bar', 'two', True)]
zip的常见用法之一是同时迭代多个序列，与enumerate结合使用：
In [95]: for i, (a, b) in enumerate(zip(seq1, seq2)):
....: print('{0}: {1}, {2}'.format(i, a, b))
....:
0: foo, one
1: bar, two
2: baz, three
- 给出一个“被压缩的”序列，zip可以被用来解压序列。也可以当作把行的列表转换为列的列表。
In [96]: pitchers = [('Nolan', 'Ryan'), ('Roger', 'Clemens'),
....: ('Schilling', 'Curt')]
In [97]: first_names, last_names = zip(*pitchers)
In [98]: first_names
Out[98]: ('Nolan', 'Roger', 'Schilling')
In [99]: last_names
Out[99]: ('Ryan', 'Clemens', 'Curt')
3.2 reversed函数
- 就是反转一下序列
In [100]: list(reversed(range(10)))
Out[100]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
- 这里需要复习一下，
range生成的序列，是需要实体化的（也就是需要list或者是for循环），这里同理 - 而且反转的话，也可以通过
[::-1]来实现！