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

Yuan的学习笔记
作者 Yuan

Python数据分析笔记#2 数据结构_第1张图片

目录

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

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}

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

Python数据分析笔记#2 数据结构_第2张图片

记得帮忙点赞,分享,微信公众号回复“pdNote2”,领取本篇笔记的代码(.pynb格式,可直接在jupyter notebook中运行)

下一篇的笔记是函数相关的,那下篇见吧!

Python数据分析笔记#2 数据结构_第3张图片
关注我的微信公众号,一起学习,一起进步

微信公众号 知乎 今日头条:Yuan的学习笔记
作者 Yuan

你可能感兴趣的:(Python数据分析笔记,python,数据分析)