Python数据分析笔记#2 数据结构

目录

• 元组
• 列表
• 字典
• 集合

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]

查看字典的值：

In [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}

下面这张表列出了常用的集合方法