Python数据分析笔记#2 数据结构
Yuan的学习笔记
作者 Yuan
目录
- 元组
- 列表
- 字典
- 集合
Python的数据结构和序列
本篇写的是Python的内置功能，从最基本的数据结构开始：元组，列表，字典和集合。
元组
元组是一个固定长度，不可改变的Python序列对象。创建元组的最简单方式，是用逗号分隔一组值：
In [1]: tup = 4, 5, 6
In [2]: tup
Out[2]: (4, 5, 6)
或者把值放入括号里面：
In [3]: tup = (4, 5, 6), (7, 8)
In [4]: tup
Out[4]: ((4, 5, 6), (7, 8))
用tuple可以将任意序列或迭代器转换成元组：
In [5]: tuple([4, 0, 2])
Out[5]: (4, 0, 2)
In [6]: tuple('string')
Out[6]: ('s', 't', 'r', 'i', 'n', 'g')
可以用方括号访问元组中的元素，序列从0开始：
In [7]: tup = tuple('string')
In [8]: tup[0]
Out[8]: 's'
可以用加号运算符将元组合并：
In [9]: (4, None, 'foo') + (6, 0) + ('bar',)
Out[9]: (4, None, 'foo', 6, 0, 'bar')
元组乘以一个整数会将几个元组复制串联起来：
In [10]: ('foo', 'bar') * 4
Out[10]: ('foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'bar')
我们可以将元组赋给类似元组的变量
In [11]: tup = (4, 5, 6)
In [12]: a, b, c = tup
In [13]: c
Out[13]: 6
Python还有更高级的元组拆分功能，使用*rest(rest是任意名字)可以抓取剩下的元素：
In [14]: values = 1, 2, 3, 4, 5
In [15]: a, b, *rest = values
In [16]: a, b
Out[16]: (1, 2)
In [17]: rest
Out[17]: [3, 4, 5]
如果rest部分不想要，许多程序员的惯用写法是用下划线代替不需要的变量名：
a, b, *_ = values
元组的大小和内容不能修改，所以元组的方法较少。但我们可以用count统计某个值出现的次数：
In [18]: a = (1, 2, 2, 2, 3, 4, 2)
In [19]: a.count(2)
Out[19]: 4
列表
与元组对比，列表的长度可变，内容可以被修改。可以用方括号或list函数定义：
a_list = [2, 3, 7, None]
tup = ('foo', 'bar', 'baz')
b_list = list(tup)
1.添加或删除元素
可以用append在列表末尾添加元素
In [20]: b_list = ['apple', 'banana', 'orange']
In [21]: b_list.append('grape')
In [22]: b_list
Out[22]: ['apple', 'banana', 'orange', 'grape']
可以用insert在特定的位置插入元素：
In [23]: b_list.insert(1, 'peach')
In [24]: b_list
Out[24]: ['apple', 'peach', 'banana', 'orange', 'grape']
pop是insert的逆运算，它移除并返回指定位置的元素：
In [25]: b_list.pop(2)
Out[25]: 'banana'
remove可以去除某个值，remove会先寻找第一个值并除去：
In [26]: b_list.append('apple')
In [27]: b_list
Out[27]: ['apple', 'peach', 'orange', 'grape', 'apple']
In [28]: b_list.remove('apple')
In [29]: b_list
Out[29]: ['peach', 'orange', 'grape', 'apple']
in可以检查列表是否包含某个值：
In [30]: 'orange' in b_list
Out[30]: True
In [31]: 'orange' not in b_list
Out[31]: False
在列表中检查是否存在某个值远比字典和集合速度慢，因为Python是线性搜索列表中的值，但在字典和集合中同样时间可以检查更多项(基于哈希表)。
2.串联和组合列表
与元组类似，可以用加号将两个列表合并
已经定义一个列表后，用extend方法可以追加多个元素：
In [32]: x = ['a', 'b', 'c']
In [33]: x.extend(['d', 'e', 'f'])
In [34]: x
Out[34]: ['a', 'b', 'c', 'd', 'e', 'f']
通过加法将列表组合的计算量较大，因为要新建列表，再复制对象
3.排序
sort函数可以将一个列表原地排序
In [35]: a = [7, 2, 5, 1, 3]
In [36]: a.sort()
In [37]: a
Out[37]: [1, 2, 3, 5, 7]
sort函数括号中可以加排序关键字key，例如按长度对字符串进行排序：
In [38]: b = ['apple', 'orange', 'pie', 'lemon']
In [39]: b.sort(key=len)
In [40]: b
Out[40]: ['pie', 'apple', 'lemon', 'orange']
sorted函数则可以产生一个排好序的副本
4.二分搜索
bisect模块支持二分查找和向已排序的列表插入值，bisect.bisect可以找到插入值后仍保持顺序的位置，bisect.insort会向这个位置插入值：
In [41]: import bisect
In [42]: c = [1, 2, 2, 2, 3, 4, 7]
In [43]: bisect.bisect(c, 2)
Out[43]: 4
In [44]: bisect.bisect(c, 5)
Out[44]: 6
In [45]: bisect.insort(c, 6)
In [46]: c
Out[46]: [1, 2, 2, 2, 3, 4, 6, 7]
5.切片
切片可以选取序列的一部分，基本形式是：
sequence[start:end]
In [47]: seq = [7, 2, 3, 7, 5, 6, 0, 1]
In [48]: seq[1:5]
Out[48]: [2, 3, 7, 5]
切片可以被序列赋值：
In [49]: seq[3:4] = [6, 3]
In [50]: seq
Out[50]: [7, 2, 3, 6, 3, 5, 6, 0, 1]
切片的开始和结束可以省略：
In [51]: seq[:5]
Out[51]: [7, 2, 3, 6, 3]
In [52]: seq[3:]
Out[52]: [6, 3, 5, 6, 0, 1]
负数的话可以从后往前开始：
In [53]: seq[-4:]
Out[53]: [5, 6, 0, 1]
In [54]: seq[-6:-2]
Out[54]: [6, 3, 5, 6]
通过第二个冒号可以选择步伐：
In [55]: seq[::2]
Out[55]: [7, 3, 3, 6, 1]
6.列表推导式
列表推导式允许用户从一个集合方便的过滤元素或者修改元素：
In [56]: strings = {
'a', 'as', 'bat', 'car', 'dove'}
In [57]: [x.upper() for x in strings if len(x) > 2]
Out[57]: ['DOVE', 'BAT', 'CAR']
这个列表推导式等同于
strings = ['a', 'as', 'bat', 'car', 'dove']
a = []
for x in strings:
if len(x) > 2:
a.append(x.upper())
字典
字典是键值对的可变集合，创建字典的方法之一是使用花括号，用冒号分隔键和值：
empty_dict = {
}
d1 = {
'a':'some value', 'b':[1, 2, 3, 4]}
添加新的键值对：
In [58]: d1 = {
'a':'some value', 'b':[1, 2, 3, 4]}
In [59]: d1[7] = 'an integer'
In [60]: d1
Out[60]: {
'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}
del和pop方法可以删除键值对：
In [63]: d1['dummy'] = 'another value'
In [64]: d1
Out[64]:
{
'a': 'some value',
'b': [1, 2, 3, 4],
7: 'an integer',
5: 'some value',
'dummy': 'another value'}
In [65]: del d1[5]
In [66]: d1
Out[66]:
{
'a': 'some value',
'b': [1, 2, 3, 4],
7: 'an integer',
'dummy': 'another value'}
In [67]: ret = d1.pop('dummy')
In [68]: ret
Out[68]: 'another value'
In [69]: d1
Out[69]: {
'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}
查看字典的键：
In [70]: list(d1.keys())
Out[70]: ['a', 'b', 7]
查看字典的值：
n [71]: list(d1.values())
Out[71]: ['some value', [1, 2, 3, 4], 'an integer']
update方法可以将两个字典融合：
In [72]: d1.update({
'b':'foo', 'c':12})
In [73]: d1
Out[73]: {
'a': 'some value', 'b': 'foo', 7: 'an integer', 'c': 12}
字典的键通常是不可变的标量类型(整数，浮点型，字符串)或元组，字典的值可以是任意类型
集合
集合是无序的不可重复的元素的集合。可以用set函数或花括号创建。
In [74]: set([2, 2, 2, 1, 3, 3])
Out[74]: {
1, 2, 3}
In [75]: {
2, 2, 2, 1, 3, 3}
Out[75]: {
1, 2, 3}
用union方法或|运算符对两个集合求并集：
In [76]: a = {
1, 2, 3, 4, 5}
In [77]: b = {
3, 4, 5, 6, 7, 8}
In [78]: a.union(b)
Out[78]: {
1, 2, 3, 4, 5, 6, 7, 8}
In [79]: a | b
Out[79]: {
1, 2, 3, 4, 5, 6, 7, 8}
用intersection或&运算符对两个集合求交集：
In [80]: a.intersection(b)
Out[80]: {
3, 4, 5}
In [81]: a & b
Out[81]: {
3, 4, 5}
下面这张表列出了常用的集合方法
记得帮忙点赞，分享，微信公众号回复“pdNote2”，领取本篇笔记的代码(.pynb格式，可直接在jupyter notebook中运行)
下一篇的笔记是函数相关的，那下篇见吧！
关注我的微信公众号，一起学习，一起进步
微信公众号 知乎 今日头条：Yuan的学习笔记
作者 Yuan