pandas is a fast, powerful, flexible and easy to use open source data analysis and manipulation tool, built on top of the Python programming language.

 

pandas是一个灵活而强大的数据处理与数据分析工具集。它高度封装了NumPy(高性能的N维数组运算库)、Matplotlib(可视化工具)、文件读写等等，广泛应用于数据清洗、数据分析、数据挖掘等场景。

 

对NumPy完全不了解的朋友，建议翻阅前文：

https://www.cnblogs.com/bytesfly/p/numpy.html

In [1]:
  1. # 这里先导入下面会频繁使用到的模块
  2. import numpy as np
  3. import pandas as pd
  4. import matplotlib.pyplot as plt
  5.  
  6. # 或者pd.show_versions()
  7. pd.__version__
Out[1]:
  1. '1.1.3'
 

刚接触Python的朋友可能不知道help()命令能随时查看帮助文档, 这里顺便提一下：

In [2]:
  1. # help(np.random)
  2. # help(pd)
  3. # help(plt)
  4. # help(pd.DataFrame)
  5.  
  6. # help参数也可以传入 实例对象的方法
  7. # df = pd.DataFrame(np.random.randint(50, 100, (6, 5)))
  8. # help(df.to_csv)
 

pandas数据结构

 

pandas中有三种数据结构，分别为：Series(一维数据结构)、DataFrame(二维表格型数据结构)和MultiIndex(三维数据结构)。

 

Series

 

Series is a one-dimensional labeled array capable of holding any data type (integers, strings, floating point numbers, Python objects, etc.). The axis labels are collectively referred to as the index.

 

Series是一个类似于一维数组的数据结构，主要由一组数据(data)和与之相关的索引(index)两部分构成。如下图所示：

 

 

下面看如何创建Series：

 
  • 不指定index，使用默认index(0-N)
In [3]:
  1. s1 = pd.Series([12, 4, 7, 9])
  2. s1
Out[3]:
  1. 0    12
  2. 1     4
  3. 2     7
  4. 3     9
  5. dtype: int64
 

通过index来获取数据：

In [4]:
  1. s1[0]
Out[4]:
  1. 12
In [5]:
  1. s1[3]
Out[5]:
  1. 9
 
  • 指定index
In [6]:
  1. s2 = pd.Series([12, 4, 7, 9], index=["a", "b", "c", "d"])
  2. s2
Out[6]:
  1. a    12
  2. b     4
  3. c     7
  4. d     9
  5. dtype: int64
 

通过index来获取数据：

In [7]:
  1. s2['a']
Out[7]:
  1. 12
In [8]:
  1. s2['d']
Out[8]:
  1. 9
 

Series can be instantiated from dicts

In [9]:
  1. s3 = pd.Series({"d": 12, "c": 4, "b": 7, "a": 9})
  2. s3
Out[9]:
  1. d    12
  2. c     4
  3. b     7
  4. a     9
  5. dtype: int64
 

When the data is a dict, and an index is not passed, the Series index will be ordered by the dict’s insertion order, if you’re using Python version >= 3.6 and pandas version >= 0.23.

 

通过index来获取数据：

In [10]:
  1. s3['d']
Out[10]:
  1. 12
In [11]:
  1. s3['a']
Out[11]:
  1. 9
 

Series也提供了两个属性index和values：

In [12]:
  1. s1.index
Out[12]:
  1. RangeIndex(start=0, stop=4, step=1)
In [13]:
  1. s2.index
Out[13]:
  1. Index(['a', 'b', 'c', 'd'], dtype='object')
In [14]:
  1. s3.index
Out[14]:
  1. Index(['d', 'c', 'b', 'a'], dtype='object')
In [15]:
  1. s3.values
Out[15]:
  1. array([12,  4,  7,  9])
 

If an index is passed, the values in data corresponding to the labels in the index will be pulled out.

In [16]:
  1. pd.Series({"a": 0.0, "b": 1.0, "c": 2.0}, index=["b", "c", "d", "a"])
Out[16]:
  1. b    1.0
  2. c    2.0
  3. d    NaN
  4. a    0.0
  5. dtype: float64
 

NaN (not a number) is the standard missing data marker used in pandas.

 

注意：这里的NaN是一个缺值标识。

 

如果data是一个标量，那么必须要传入index：

 

If data is a scalar value, an index must be provided. The value will be repeated to match the length of index.

In [17]:
  1. pd.Series(5.0, index=["c", "a", "b"])
Out[17]:
  1. c    5.0
  2. a    5.0
  3. b    5.0
  4. dtype: float64
 

其实上面的创建相当于：

In [18]:
  1. pd.Series([5.0, 5.0, 5.0], index=["c", "a", "b"])
Out[18]:
  1. c    5.0
  2. a    5.0
  3. b    5.0
  4. dtype: float64
 

ndarray上的一些操作对Series同样适用：

 

Series is ndarray-like. Series acts very similarly to a ndarray, and is a valid argument to most NumPy functions. However, operations such as slicing will also slice the index.

In [19]:
  1. # 取s1前3个元素
  2. s1[:3]
Out[19]:
  1. 0    12
  2. 1     4
  3. 2     7
  4. dtype: int64
In [20]:
  1. # 哪些元素大于10
  2. s1 > 10
Out[20]:
  1. 0     True
  2. 1    False
  3. 2    False
  4. 3    False
  5. dtype: bool
 

更多操作请翻阅上文对NumPy中的ndarray的讲解。见：https://www.cnblogs.com/bytesfly/p/numpy.html

In [21]:
  1. s1.dtype
Out[21]:
  1. dtype('int64')
 

If you need the actual array backing a Series, use Series.array

In [22]:
  1. # Series转为array
  2. s1.array
Out[22]:
  1. <PandasArray>
  2. [12, 4, 7, 9]
  3. Length: 4, dtype: int64
 

While Series is ndarray-like, if you need an actual ndarray, then use Series.to_numpy()

In [23]:
  1. # Series转为ndarray
  2. s1.to_numpy()
Out[23]:
  1. array([12,  4,  7,  9])
 

dict上的一些操作对Series也同样适用：

 

Series is dict-like. A Series is like a fixed-size dict in that you can get and set values by index label

In [24]:
  1. s3['a'] = 100
  2. s3
Out[24]:
  1. d     12
  2. c      4
  3. b      7
  4. a    100
  5. dtype: int64
In [25]:
  1. "a" in s3
Out[25]:
  1. True
In [26]:
  1. "y" in s3
Out[26]:
  1. False
In [27]:
  1. # 获取不到给默认值NAN
  2. s3.get("y", np.nan)
Out[27]:
  1. nan
 

DataFrame

 

DataFrame is a 2-dimensional labeled data structure with columns of potentially different types. You can think of it like a spreadsheet or SQL table, or a dict of Series objects. It is generally the most commonly used pandas object.

 

DataFrame是一个类似于二维数组或表的对象，既有行索引，又有列索引。如下图所示：

 

 
  • 行索引(或者叫行标签)，表明不同行，横向索引，叫index，0轴，axis=0
  • 列索引(或者叫列标签)，表名不同列，纵向索引，叫columns，1轴，axis=1
 

下面看如何创建DataFrame：

 
  • 不指定行、列标签，默认使用0-N索引
In [28]:
  1. # 随机生成6名学生，5门课程的分数
  2. score = np.random.randint(50, 100, (6, 5))
  3.  
  4. # 创建DataFrame
  5. pd.DataFrame(score)
Out[28]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  0 1 2 3 4
0 69 90 56 97 79
1 57 98 70 57 82
2 63 66 98 78 63
3 74 58 75 57 68
4 94 78 83 72 73
5 60 73 62 72 79
 
  • 指定行、列标签
In [29]:
  1. # 列标签
  2. subjects = ["语文", "数学", "英语", "物理", "化学"]
  3.  
  4. # 行标签
  5. stus = ['学生' + str(i+1) for i in range(score.shape[0])]
  6.  
  7. # 创建DataFrame
  8. score_df = pd.DataFrame(score, columns=subjects, index=stus)
  9.  
  10. score_df
Out[29]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  语文 数学 英语 物理 化学
学生1 69 90 56 97 79
学生2 57 98 70 57 82
学生3 63 66 98 78 63
学生4 74 58 75 57 68
学生5 94 78 83 72 73
学生6 60 73 62 72 79
 

加了行列标签后，显然数据可读性更强了，一目了然。

 

同样再看DataFrame的几个基本属性：

In [30]:
  1. score_df.shape
Out[30]:
  1. (6, 5)
In [31]:
  1. score_df.columns
Out[31]:
  1. Index(['语文', '数学', '英语', '物理', '化学'], dtype='object')
In [32]:
  1. score_df.index
Out[32]:
  1. Index(['学生1', '学生2', '学生3', '学生4', '学生5', '学生6'], dtype='object')
In [33]:
  1. score_df.values
Out[33]:
  1. array([[69, 90, 56, 97, 79],
  2.        [57, 98, 70, 57, 82],
  3.        [63, 66, 98, 78, 63],
  4.        [74, 58, 75, 57, 68],
  5.        [94, 78, 83, 72, 73],
  6.        [60, 73, 62, 72, 79]])
In [34]:
  1. # 转置
  2. score_df.T
Out[34]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  学生1 学生2 学生3 学生4 学生5 学生6
语文 69 57 63 74 94 60
数学 90 98 66 58 78 73
英语 56 70 98 75 83 62
物理 97 57 78 57 72 72
化学 79 82 63 68 73 79
In [35]:
  1. # 显示前3行内容
  2. score_df.head(3)
Out[35]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  语文 数学 英语 物理 化学
学生1 69 90 56 97 79
学生2 57 98 70 57 82
学生3 63 66 98 78 63
In [36]:
  1. # 显示后3行内容
  2. score_df.tail(3)
Out[36]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  语文 数学 英语 物理 化学
学生4 74 58 75 57 68
学生5 94 78 83 72 73
学生6 60 73 62 72 79
 

修改行标签：

In [37]:
  1. stus = ['stu' + str(i+1) for i in range(score.shape[0])]
  2.  
  3. score_df.index = stus
  4.  
  5. score_df
Out[37]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  语文 数学 英语 物理 化学
stu1 69 90 56 97 79
stu2 57 98 70 57 82
stu3 63 66 98 78 63
stu4 74 58 75 57 68
stu5 94 78 83 72 73
stu6 60 73 62 72 79
 

重置行标签：

In [38]:
  1. # drop默认为False,不删除原来的索引值
  2. score_df.reset_index()
Out[38]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  index 语文 数学 英语 物理 化学
0 stu1 69 90 56 97 79
1 stu2 57 98 70 57 82
2 stu3 63 66 98 78 63
3 stu4 74 58 75 57 68
4 stu5 94 78 83 72 73
5 stu6 60 73 62 72 79
In [39]:
  1. # drop为True, 则删除原来的索引值
  2. score_df.reset_index(drop=True)
Out[39]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  语文 数学 英语 物理 化学
0 69 90 56 97 79
1 57 98 70 57 82
2 63 66 98 78 63
3 74 58 75 57 68
4 94 78 83 72 73
5 60 73 62 72 79
In [40]:
  1. score_df
Out[40]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  语文 数学 英语 物理 化学
stu1 69 90 56 97 79
stu2 57 98 70 57 82
stu3 63 66 98 78 63
stu4 74 58 75 57 68
stu5 94 78 83 72 73
stu6 60 73 62 72 79
 

将某列值设置为新的索引：

 

set_index(keys, drop=True)

  • keys : 列索引名成或者列索引名称的列表
  • drop : boolean, default True.当做新的索引，删除原来的列
In [41]:
  1. hero_df = pd.DataFrame({'id': [1, 2, 3, 4, 5],
  2.                         'name': ['李寻欢', '令狐冲', '张无忌', '郭靖', '花无缺'],
  3.                         'book': ['多情剑客无情剑', '笑傲江湖', '倚天屠龙记', '射雕英雄传', '绝代双骄'],
  4.                         'skill': ['小李飞刀', '独孤九剑', '九阳神功', '降龙十八掌', '移花接玉']})
  5.  
  6. hero_df.set_index('id')
Out[41]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  name book skill
id      
1 李寻欢 多情剑客无情剑 小李飞刀
2 令狐冲 笑傲江湖 独孤九剑
3 张无忌 倚天屠龙记 九阳神功
4 郭靖 射雕英雄传 降龙十八掌
5 花无缺 绝代双骄 移花接玉
 

设置多个索引，以id和name：

In [42]:
  1. df = hero_df.set_index(['id', 'name'])
  2. df
Out[42]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill
id name    
1 李寻欢 多情剑客无情剑 小李飞刀
2 令狐冲 笑傲江湖 独孤九剑
3 张无忌 倚天屠龙记 九阳神功
4 郭靖 射雕英雄传 降龙十八掌
5 花无缺 绝代双骄 移花接玉
In [43]:
  1. df.index
Out[43]:
  1. MultiIndex([(1, '李寻欢'),
  2.             (2, '令狐冲'),
  3.             (3, '张无忌'),
  4.             (4,  '郭靖'),
  5.             (5, '花无缺')],
  6.            names=['id', 'name'])
 

此时df就是一个具有MultiIndex的DataFrame。

 

MultiIndex

In [44]:
  1. df.index.names
Out[44]:
  1. FrozenList(['id', 'name'])
In [45]:
  1. df.index.levels
Out[45]:
  1. FrozenList([[1, 2, 3, 4, 5], ['令狐冲', '张无忌', '李寻欢', '花无缺', '郭靖']])
 

数据操作与运算

In [46]:
  1. df
Out[46]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill
id name    
1 李寻欢 多情剑客无情剑 小李飞刀
2 令狐冲 笑傲江湖 独孤九剑
3 张无忌 倚天屠龙记 九阳神功
4 郭靖 射雕英雄传 降龙十八掌
5 花无缺 绝代双骄 移花接玉
 

索引操作

 
  • 直接使用行列索引(先列后行)：
In [47]:
  1. df['skill']
Out[47]:
  1. id  name
  2. 1   李寻欢      小李飞刀
  3. 2   令狐冲      独孤九剑
  4. 3   张无忌      九阳神功
  5. 4   郭靖      降龙十八掌
  6. 5   花无缺      移花接玉
  7. Name: skill, dtype: object
In [48]:
  1. df['skill'][1]
Out[48]:
  1. name
  2. 李寻欢    小李飞刀
  3. Name: skill, dtype: object
In [49]:
  1. df['skill'][1]['李寻欢']
Out[49]:
  1. '小李飞刀'
 
  • 使用loc(指定行列索引的名字)
In [50]:
  1. df.loc[1:3]
Out[50]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill
id name    
1 李寻欢 多情剑客无情剑 小李飞刀
2 令狐冲 笑傲江湖 独孤九剑
3 张无忌 倚天屠龙记 九阳神功
In [51]:
  1. df.loc[(2, '令狐冲'):(4, '郭靖')]
Out[51]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill
id name    
2 令狐冲 笑傲江湖 独孤九剑
3 张无忌 倚天屠龙记 九阳神功
4 郭靖 射雕英雄传 降龙十八掌
In [52]:
  1. df.loc[1:3, 'book']
Out[52]:
  1. id  name
  2. 1   李寻欢     多情剑客无情剑
  3. 2   令狐冲        笑傲江湖
  4. 3   张无忌       倚天屠龙记
  5. Name: book, dtype: object
In [53]:
  1. df.loc[df.index[1:3], ['book', 'skill']]
Out[53]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill
id name    
2 令狐冲 笑傲江湖 独孤九剑
3 张无忌 倚天屠龙记 九阳神功
 
  • 使用iloc(通过索引的下标)
In [54]:
  1. # 获取前2行数据
  2. df.iloc[:2]
Out[54]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill
id name    
1 李寻欢 多情剑客无情剑 小李飞刀
2 令狐冲 笑傲江湖 独孤九剑
In [55]:
  1. df.iloc[0:2, df.columns.get_indexer(['skill'])]
Out[55]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    skill
id name  
1 李寻欢 小李飞刀
2 令狐冲 独孤九剑
 

赋值操作

In [56]:
  1. # 添加新列
  2. df['score'] = 100
  3. df['gender'] = 'male'
  4.  
  5. df
Out[56]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill score gender
id name        
1 李寻欢 多情剑客无情剑 小李飞刀 100 male
2 令狐冲 笑傲江湖 独孤九剑 100 male
3 张无忌 倚天屠龙记 九阳神功 100 male
4 郭靖 射雕英雄传 降龙十八掌 100 male
5 花无缺 绝代双骄 移花接玉 100 male
In [57]:
  1. # 修改列值
  2. df['score'] = 99
  3.  
  4. df
Out[57]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill score gender
id name        
1 李寻欢 多情剑客无情剑 小李飞刀 99 male
2 令狐冲 笑傲江湖 独孤九剑 99 male
3 张无忌 倚天屠龙记 九阳神功 99 male
4 郭靖 射雕英雄传 降龙十八掌 99 male
5 花无缺 绝代双骄 移花接玉 99 male
In [58]:
  1. # 或者这样修改列值
  2. df.score = 100
  3.  
  4. df
Out[58]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill score gender
id name        
1 李寻欢 多情剑客无情剑 小李飞刀 100 male
2 令狐冲 笑傲江湖 独孤九剑 100 male
3 张无忌 倚天屠龙记 九阳神功 100 male
4 郭靖 射雕英雄传 降龙十八掌 100 male
5 花无缺 绝代双骄 移花接玉 100 male
 

排序

 
  • sort_index
In [59]:
  1. # 按索引降序
  2. df.sort_index(ascending=False)
Out[59]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill score gender
id name        
5 花无缺 绝代双骄 移花接玉 100 male
4 郭靖 射雕英雄传 降龙十八掌 100 male
3 张无忌 倚天屠龙记 九阳神功 100 male
2 令狐冲 笑傲江湖 独孤九剑 100 male
1 李寻欢 多情剑客无情剑 小李飞刀 100 male
 
  • sort_values
 

先把score设置为不同的值：

In [60]:
  1. df['score'][1]['李寻欢'] = 80
  2. df['score'][2]['令狐冲'] = 96
  3. df['score'][3]['张无忌'] = 86
  4. df['score'][4]['郭靖'] = 99
  5. df['score'][5]['花无缺'] = 95
  6.  
  7. df
Out[60]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill score gender
id name        
1 李寻欢 多情剑客无情剑 小李飞刀 80 male
2 令狐冲 笑傲江湖 独孤九剑 96 male
3 张无忌 倚天屠龙记 九阳神功 86 male
4 郭靖 射雕英雄传 降龙十八掌 99 male
5 花无缺 绝代双骄 移花接玉 95 male
In [61]:
  1. # 按照score降序
  2. df.sort_values(by='score', ascending=False)
Out[61]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill score gender
id name        
4 郭靖 射雕英雄传 降龙十八掌 99 male
2 令狐冲 笑傲江湖 独孤九剑 96 male
5 花无缺 绝代双骄 移花接玉 95 male
3 张无忌 倚天屠龙记 九阳神功 86 male
1 李寻欢 多情剑客无情剑 小李飞刀 80 male
In [62]:
  1. # 按照book名称字符串长度 升序
  2. df.sort_values(by='book', key=lambda col: col.str.len())
Out[62]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill score gender
id name        
2 令狐冲 笑傲江湖 独孤九剑 96 male
5 花无缺 绝代双骄 移花接玉 95 male
3 张无忌 倚天屠龙记 九阳神功 86 male
4 郭靖 射雕英雄传 降龙十八掌 99 male
1 李寻欢 多情剑客无情剑 小李飞刀 80 male
 

算术运算

In [63]:
  1. # score+1
  2. df['score'].add(1)
Out[63]:
  1. id  name
  2. 1   李寻欢      81
  3. 2   令狐冲      97
  4. 3   张无忌      87
  5. 4   郭靖      100
  6. 5   花无缺      96
  7. Name: score, dtype: int64
In [64]:
  1. # score-1
  2. df['score'].sub(1)
Out[64]:
  1. id  name
  2. 1   李寻欢     79
  3. 2   令狐冲     95
  4. 3   张无忌     85
  5. 4   郭靖      98
  6. 5   花无缺     94
  7. Name: score, dtype: int64
In [65]:
  1. # 或者直接用 + - * / // %等运算符
  2. (df['score'] + 1) % 10
Out[65]:
  1. id  name
  2. 1   李寻欢     1
  3. 2   令狐冲     7
  4. 3   张无忌     7
  5. 4   郭靖      0
  6. 5   花无缺     6
  7. Name: score, dtype: int64
 

逻辑运算

 

先回顾一下数据内容：

In [66]:
  1. df
Out[66]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill score gender
id name        
1 李寻欢 多情剑客无情剑 小李飞刀 80 male
2 令狐冲 笑傲江湖 独孤九剑 96 male
3 张无忌 倚天屠龙记 九阳神功 86 male
4 郭靖 射雕英雄传 降龙十八掌 99 male
5 花无缺 绝代双骄 移花接玉 95 male
 

逻辑运算结果：

In [67]:
  1. df['score'] > 90
Out[67]:
  1. id  name
  2. 1   李寻欢     False
  3. 2   令狐冲      True
  4. 3   张无忌     False
  5. 4   郭靖       True
  6. 5   花无缺      True
  7. Name: score, dtype: bool
In [68]:
  1. # 筛选出分数大于90的行
  2. df[df['score'] > 90]
Out[68]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill score gender
id name        
2 令狐冲 笑傲江湖 独孤九剑 96 male
4 郭靖 射雕英雄传 降龙十八掌 99 male
5 花无缺 绝代双骄 移花接玉 95 male
In [69]:
  1. # 筛选出分数在85到90之间的行
  2. df[(df['score'] > 85) & (df['score'] < 90)]
Out[69]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill score gender
id name        
3 张无忌 倚天屠龙记 九阳神功 86 male
In [70]:
  1. # 筛选出分数在85以下或者95以上的行
  2. df[(df['score'] < 85) | (df['score'] > 95)]
Out[70]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill score gender
id name        
1 李寻欢 多情剑客无情剑 小李飞刀 80 male
2 令狐冲 笑傲江湖 独孤九剑 96 male
4 郭靖 射雕英雄传 降龙十八掌 99 male
 

或者通过query()函数实现上面的需求：

In [71]:
  1. df.query("score<85 | score>95")
Out[71]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill score gender
id name        
1 李寻欢 多情剑客无情剑 小李飞刀 80 male
2 令狐冲 笑傲江湖 独孤九剑 96 male
4 郭靖 射雕英雄传 降龙十八掌 99 male
 

此外，可以用isin(values)函数来筛选指定的值，类似于SQL中in查询：

In [72]:
  1. df[df["score"].isin([99, 96])]
Out[72]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

    book skill score gender
id name        
2 令狐冲 笑傲江湖 独孤九剑 96 male
4 郭靖 射雕英雄传 降龙十八掌 99 male
 

统计运算

 

describe()能够直接得出很多统计结果：count, mean, std, min, max 等：

In [73]:
  1. df.describe()
Out[73]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  score
count 5.000000
mean 91.200000
std 7.918333
min 80.000000
25% 86.000000
50% 95.000000
75% 96.000000
max 99.000000
In [74]:
  1. # 使用统计函数：axis=0代表求列统计结果，1代表求行统计结果
  2. df.max(axis=0, numeric_only=True)
Out[74]:
  1. score    99
  2. dtype: int64
 

其他几个常用的聚合函数都类似。不再一一举例。

 

下面重点看下累计统计函数。

 
函数 作用
cumsum 计算前1/2/3/…/n个数的和
cummax 计算前1/2/3/…/n个数的最大值
cummin 计算前1/2/3/…/n个数的最小值
cumprod 计算前1/2/3/…/n个数的积
 

下面是某公司近半年以来的各部门的营业收入数据：

In [75]:
  1. income = pd.DataFrame(data=np.random.randint(60, 100, (6, 5)),
  2.                       columns=['group' + str(x) for x in range(1, 6)],
  3.                       index=['Month' + str(x) for x in range(1, 7)])
  4.  
  5. income
Out[75]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  group1 group2 group3 group4 group5
Month1 97 89 62 82 71
Month2 68 69 82 66 79
Month3 77 87 66 94 82
Month4 69 76 99 79 61
Month5 77 94 76 70 70
Month6 89 64 92 63 60
 

统计group1的前N个月的总营业收入：

In [76]:
  1. group1_income = income['group1']
  2.  
  3. group1_income.cumsum()
Out[76]:
  1. Month1     97
  2. Month2    165
  3. Month3    242
  4. Month4    311
  5. Month5    388
  6. Month6    477
  7. Name: group1, dtype: int64
 

用图形展示会更加直观：

In [77]:
  1. group1_income.cumsum().plot(figsize=(8, 5))
  2.  
  3. plt.show()
 
 

同理，统计group1的前N个月的最大营业收入：

In [78]:
  1. group1_income.cummax().plot(figsize=(8, 5))
  2.  
  3. plt.show()
 
 

其他运算

 

先看下近半年以来前3个部门的营业收入数据：

In [79]:
  1. income[['group1', 'group2', 'group3']]
Out[79]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  group1 group2 group3
Month1 97 89 62
Month2 68 69 82
Month3 77 87 66
Month4 69 76 99
Month5 77 94 76
Month6 89 64 92
In [80]:
  1. # 近半年 前3个部门 每月营业收入极差
  2. income[['group1', 'group2', 'group3']].apply(lambda x: x.max() - x.min(), axis=1)
Out[80]:
  1. Month1    35
  2. Month2    14
  3. Month3    21
  4. Month4    30
  5. Month5    18
  6. Month6    28
  7. dtype: int64
In [81]:
  1. # 近半年 前3个部门 每个部门营业收入极差
  2. income[['group1', 'group2', 'group3']].apply(lambda x: x.max() - x.min(), axis=0)
Out[81]:
  1. group1    29
  2. group2    30
  3. group3    37
  4. dtype: int64
 

文件读写

 

The pandas I/O API is a set of top level reader functions accessed like pandas.read_csv() that generally return a pandas object. The corresponding writer functions are object methods that are accessed like DataFrame.to_csv(). Below is a table containing available readers and writers.

 
Format Type Data Description Reader Writer
text CSV read_csv to_csv
text Fixed-Width Text File read_fwf  
text JSON read_json to_json
text HTML read_html to_html
text Local clipboard read_clipboard to_clipboard
binary MS Excel read_excel to_excel
binary OpenDocument read_excel  
binary HDF5 Format read_hdf to_hdf
binary Feather Format read_feather to_feather
binary Parquet Format read_parquet to_parquet
binary ORC Format read_orc  
binary Msgpack read_msgpack to_msgpack
binary Stata read_stata to_stata
binary SAS read_sas  
binary SPSS read_spss  
binary Python Pickle Format read_pickle to_pickle
SQL SQL read_sql to_sql
SQL Google BigQuery read_gbq to_gbq
 

CSV

 

这里用下面网址的csv数据来做一些测试：

https://www.stats.govt.nz/large-datasets/csv-files-for-download/

In [82]:
  1. path = "https://www.stats.govt.nz/assets/Uploads/Employment-indicators/Employment-indicators-Weekly-as-at-24-May-2021/Download-data/Employment-indicators-weekly-paid-jobs-20-days-as-at-24-May-2021.csv"
  2. # 读csv
  3. data = pd.read_csv(path, sep=',', usecols=['Week_end', 'High_industry', 'Value'])
  4. data
Out[82]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  Week_end High_industry Value
0 2019-05-05 Total 1828160.00
1 2019-05-05 A Primary 79880.00
2 2019-05-05 B Goods Producing 344320.00
3 2019-05-05 C Services 1389220.00
4 2019-05-05 Z No Match 14730.00
... ... ... ...
2095 2021-05-02 Total 700.94
2096 2021-05-02 A Primary 680.20
2097 2021-05-02 B Goods Producing 916.42
2098 2021-05-02 C Services 649.92
2099 2021-05-02 Z No Match 425.65

2100 rows × 3 columns

In [83]:
  1. # 写csv
  2. data[:20].to_csv("./test.csv", columns=['Week_end', 'Value'],
  3.                  header=True, index=False, mode='w')
 

输出如下：

  1. Week_end,Value
  2. 2019-05-05,1828160.0
  3. 2019-05-05,79880.0
  4. 2019-05-05,344320.0
 

JSON

 

更多Json格式数据，google关键词site:api.androidhive.info

In [84]:
  1. path = "https://api.androidhive.info/json/movies.json"
  2. # 读json
  3. data = pd.read_json(path)
  4. data = data.loc[:2, ['title', 'rating']]
  5. data
Out[84]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  title rating
0 Dawn of the Planet of the Apes 8.3
1 District 9 8.0
2 Transformers: Age of Extinction 6.3
 
  • records
In [85]:
  1. data.to_json("./test.json", orient='records', lines=True)
 

输出如下：

  1. {"title":"Dawn of the Planet of the Apes","rating":8.3}
  2. {"title":"District 9","rating":8.0}
  3. {"title":"Transformers: Age of Extinction","rating":6.3}
 

如果lines=False，即：

In [86]:
  1. data.to_json("./test.json", orient='records', lines=False)
 

输出如下：

  1. [
  2.     {
  3.         "title":"Dawn of the Planet of the Apes",
  4.         "rating":8.3
  5.     },
  6.     {
  7.         "title":"District 9",
  8.         "rating":"8.0"
  9.     },
  10.     {
  11.         "title":"Transformers: Age of Extinction",
  12.         "rating":6.3
  13.     }
  14. ]
 
  • columns
In [87]:
  1. data.to_json("./test.json", orient='columns')
 

输出如下：

  1. {
  2.     "title":{
  3.         "0":"Dawn of the Planet of the Apes",
  4.         "1":"District 9",
  5.         "2":"Transformers: Age of Extinction"
  6.     },
  7.     "rating":{
  8.         "0":8.3,
  9.         "1":"8.0",
  10.         "2":6.3
  11.     }
  12. }
 
  • index
In [88]:
  1. data.to_json("./test.json", orient='index')
 

输出如下：

  1. {
  2.     "0":{
  3.         "title":"Dawn of the Planet of the Apes",
  4.         "rating":8.3
  5.     },
  6.     "1":{
  7.         "title":"District 9",
  8.         "rating":"8.0"
  9.     },
  10.     "2":{
  11.         "title":"Transformers: Age of Extinction",
  12.         "rating":6.3
  13.     }
  14. }
 
  • split
In [89]:
  1. data.to_json("./test.json", orient='split')
 

输出如下：

  1. {
  2.     "columns":[
  3.         "title",
  4.         "rating"
  5.     ],
  6.     "index":[
  7.         0,
  8.         1,
  9.         2
  10.     ],
  11.     "data":[
  12.         [
  13.             "Dawn of the Planet of the Apes",
  14.             8.3
  15.         ],
  16.         [
  17.             "District 9",
  18.             "8.0"
  19.         ],
  20.         [
  21.             "Transformers: Age of Extinction",
  22.             6.3
  23.         ]
  24.     ]
  25. }
 
  • values
In [90]:
  1. data.to_json("./test.json", orient='values')
 

输出如下：

  1. [
  2.     [
  3.         "Dawn of the Planet of the Apes",
  4.         8.3
  5.     ],
  6.     [
  7.         "District 9",
  8.         "8.0"
  9.     ],
  10.     [
  11.         "Transformers: Age of Extinction",
  12.         6.3
  13.     ]
  14. ]
 

Excel

In [91]:
  1. # 读Excel
  2. team = pd.read_excel('https://www.gairuo.com/file/data/dataset/team.xlsx')
  3.  
  4. team.head(5)
Out[91]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  name team Q1 Q2 Q3 Q4
0 Liver E 89 21 24 64
1 Arry C 36 37 37 57
2 Ack A 57 60 18 84
3 Eorge C 93 96 71 78
4 Oah D 65 49 61 86
In [92]:
  1. # 末尾添加一列sum, 值为Q1、Q2、Q3、Q4列的和
  2. team['sum'] = team['Q1'] + team['Q2'] + team['Q3'] + team['Q4']
  3.  
  4. team.head(5)
Out[92]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  name team Q1 Q2 Q3 Q4 sum
0 Liver E 89 21 24 64 198
1 Arry C 36 37 37 57 167
2 Ack A 57 60 18 84 219
3 Eorge C 93 96 71 78 338
4 Oah D 65 49 61 86 261
In [93]:
  1. # 写Excel
  2. team.to_excel('test.xlsx', index=False)
 

HDF5

 

HDF5（Hierarchical Data Format）是用于存储大规模数值数据的较为理想的存储格式。

 

优势：

  • HDF5在存储的时候支持压缩，从而提磁盘利用率，节省空间
  • HDF5跨平台的，可轻松迁移到Hadoop上
In [94]:
  1. score = pd.DataFrame(np.random.randint(50, 100, (100000, 10)))
  2.  
  3. score.head()
Out[94]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  0 1 2 3 4 5 6 7 8 9
0 76 53 51 94 84 77 56 82 56 50
1 93 59 84 83 77 67 52 52 53 62
2 96 98 88 72 96 64 58 67 89 95
3 57 75 89 73 72 73 58 93 72 92
4 50 50 52 57 72 76 78 52 90 93
In [95]:
  1. # 写HDF5
  2. score.to_hdf("./score.h5", key="score", complevel=9, mode='w')
In [96]:
  1. # 读HDF5
  2. new_score = pd.read_hdf("./score.h5", key="score")
  3.  
  4. new_score.head()
Out[96]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  0 1 2 3 4 5 6 7 8 9
0 76 53 51 94 84 77 56 82 56 50
1 93 59 84 83 77 67 52 52 53 62
2 96 98 88 72 96 64 58 67 89 95
3 57 75 89 73 72 73 58 93 72 92
4 50 50 52 57 72 76 78 52 90 93
 

注意：HDF5文件的读取和存储需要指定一个键(key)，值为要存储的DataFrame。

In [97]:
  1. score.to_csv("./score.csv", mode='w')
 

同时，来对比一下写HDF5与写csv的占用磁盘情况：

 
  1. -rw-r--r--  1 wind  staff   3.4M  6 13 10:24 score.csv
  2. -rw-r--r--  1 wind  staff   763K  6 13 10:23 score.h5
 

其他格式的文件读写也都类似，这里不再举例说明。

 

画图

 

Pandas的DataFrame和Series，在matplotlib基础上封装了一个简易的绘图函数, 使得在数据处理过程中可以方便快速可视化数据。

 

相关文档：

 

折线图 line

 

折线图用于分析事物随时间或有序类别而变化的趋势。

 

先来个快速入门的案例，绘制sin(x)的一个周期内(0, 2π)的函数图像：

In [98]:
  1. # 中文字体
  2. plt.rc('font', family='Arial Unicode MS')
  3. plt.rc('axes', unicode_minus='False')
  4.  
  5. x = np.arange(0, 6.29, 0.01)
  6. y = np.sin(x)
  7.  
  8. s = pd.Series(y, index=x)
  9. s.plot(kind='line', title='sin(x)图像',
  10.        style='--g', grid=True, figsize=(8, 6))
  11.  
  12. plt.show()
 
 

注意：中文显示有问题的，可用如下代码查看系统可用字体。

In [99]:
  1. from matplotlib.font_manager import FontManager
  2. # fonts = set([x.name for x in FontManager().ttflist])
  3. # print(fonts)
 

如果要绘制DataFrame数据的某2列数据的折线图，传入x='列1'，y='列2'，就能得到以'列1'为x轴，'列2'为y轴的线型图。如果没有指明x，x轴默认用index。如下例子：

In [100]:
  1. df = pd.DataFrame({'x': x, 'y': y})
  2. df.plot(x='x', y='y', kind='line', ylabel='y=sin(x)',
  3.         style='--g', grid=True, figsize=(8, 6))
  4.  
  5. plt.show()
 
 

再看一个实际的案例。下面是北京、上海、合肥三个城市某天中午气温的数据。

In [101]:
  1. x = [f'12点{i}分' for i in range(60)]
  2.  
  3. y_beijing = np.random.uniform(18, 23, len(x))
  4. y_shanghai = np.random.uniform(23, 26, len(x))
  5. y_hefei = np.random.uniform(21, 28, len(x))
  6.  
  7. df = pd.DataFrame({'x': x, 'beijing': y_beijing, 'shanghai': y_shanghai, 'hefei': y_hefei})
  8.  
  9. df.head(5)
Out[101]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  x beijing shanghai hefei
0 12点0分 21.516230 24.627902 25.232748
1 12点1分 22.601501 25.982331 26.403320
2 12点2分 19.739455 23.602787 25.569943
3 12点3分 21.741182 25.102164 24.400619
4 12点4分 19.888968 23.995114 22.879671
 

绘制北京、上海、合肥三个城市气温随时间变化的情况如下：

In [102]:
  1. df.plot(x='x', y=['beijing', 'shanghai', 'hefei'], kind='line',
  2.         figsize=(12, 6), xlabel='时间', ylabel='温度')
  3. plt.show()
 
 

添加参数subplots=True, 可以形成多个子图，如下：

In [103]:
  1. df.plot(x='x', y=['beijing', 'shanghai', 'hefei'], kind='line',
  2.         subplots=True, figsize=(12, 6), xlabel='时间', ylabel='温度')
  3. plt.show()
 
 

另外，参数layout=(m,n)可以指明子图的行列数，期中m*n的值要大于子图的数量，如下：

In [104]:
  1. df.plot(x='x', y=['beijing', 'shanghai', 'hefei'], kind='line',
  2.         subplots=True, layout=(2, 2), figsize=(12, 6), xlabel='时间', ylabel='温度')
  3. plt.show()
 
 

柱状图 bar

 

柱状图最适合对分类的数据进行比较。

 

武林大会上，每个英雄参加10个回合的比拼，每人 胜局(wins)、平局(draws)、败局(losses)的统计如下：

In [105]:
  1. columns = ['hero', 'wins', 'draws', 'losses']
  2.  
  3. score = [
  4.     ['李寻欢', 6, 1, 3],
  5.     ['令狐冲', 5, 4, 1],
  6.     ['张无忌', 5, 3, 2],
  7.     ['郭靖', 4, 5, 1],
  8.     ['花无缺', 5, 2, 3]
  9. ]
  10.  
  11. df = pd.DataFrame(score, columns=columns)
  12.  
  13. df
Out[105]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  hero wins draws losses
0 李寻欢 6 1 3
1 令狐冲 5 4 1
2 张无忌 5 3 2
3 郭靖 4 5 1
4 花无缺 5 2 3
In [106]:
  1. df.plot(kind='bar', x='hero', y=['wins', 'draws', 'losses'],
  2.         rot=0, title='柱状图', xlabel='', figsize=(10, 6))
  3. plt.show()
 
 

添加stacked=True可以绘制堆叠柱状图，如下：

In [107]:
  1. df.plot(kind='bar', x='hero', y=['wins', 'draws', 'losses'],
  2.         stacked=True, rot=0, title='堆叠柱状图', xlabel='', figsize=(10, 6))
  3. plt.show()
 
 

另外使用plot(kind='barh')或者plot.barh()可以绘制水平柱状图。下面rot参数设置x标签的旋转角度，alpha设置透明度，align设置对齐位置。

In [108]:
  1. df.plot(kind='barh', x='hero', y=['wins'], xlabel='',
  2.         align='center', alpha=0.8, rot=0, title='水平柱状图', figsize=(10, 6))
  3. plt.show()
 
 

同样添加参数subplots=True，可以形成多个子图，如下：

In [109]:
  1. df.plot(kind='bar', x='hero', y=['wins', 'draws', 'losses'],
  2.         subplots=True, rot=0, xlabel='', figsize=(10, 8))
  3. plt.show()
 
 

饼图 pie

 

饼图最显著的功能在于表现“占比”。

 

每当某些机构或者平台发布编程语言排行榜以及市场占有率时，相信行业内的很多朋友会很自然地瞄上几眼。

 

这里举个某互联网公司研发部使用的后端编程语言占比：

In [110]:
  1. colors = ['#FF6600', '#0099FF', '#FFFF00', '#FF0066', '#339900']
  2. language = ['Java', 'Python', 'Golang', 'Scala', 'Others']
  3.  
  4. s = pd.Series([0.5, 0.3, 0.1, 0.06, 0.04], name='language',
  5.               index=language)
  6.  
  7. s.plot(kind='pie', figsize=(7, 7),
  8.        autopct="%.0f%%", colors=colors)
  9. plt.show()
 
 

散点图 scatter

 

散点图适用于分析变量之间是否存在某种关系或相关性。

 

先造一些随机数据，如下：

In [111]:
  1. x = np.random.uniform(0, 100, 100)
  2. y = [2*n for n in x]
  3.  
  4. df = pd.DataFrame({'x': x, 'y': y})
  5. df.head(5)
Out[111]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  x y
0 10.405567 20.811134
1 24.520765 49.041530
2 32.735258 65.470516
3 90.868823 181.737646
4 21.875188 43.750377
 

绘制散点图，如下：

In [112]:
  1. df.plot(kind='scatter', x='x', y='y', figsize=(12, 6))
  2. plt.show()
 
 

从图中，可以看出y与x可能存在正相关的关系。

 

直方图 hist

 

直方图用于表示数据的分布情况。一般用横轴表示数据区间，纵轴表示分布情况，柱子越高，则落在该区间的数量越大。

 

构建直方图，首先要确定“组距”、对数值的范围进行分区，通俗的说即是划定有几根柱子（例如0-100分，每隔20分划一个区间，共5个区间）。接着，对落在每个区间的数值进行频次计算（如落在80-100分的10人，60-80分的20人，以此类推）。 最后，绘制矩形，高度由频数决定。

 

注意：直方图并不等于柱状图，不能对离散的分类数据进行比较。

 

 

在前文 快速上手NumPy 中，简单讲过正态分布，也画过正态分布的直方图。下面看用pandas如何画直方图：

 

已知某地区成年男性身高近似服从正态分布。下面生成均值为170，标准差为5的100000个符合正态分布规律的样本数据。

In [113]:
  1. height = np.random.normal(170, 5, 100000)
  2.  
  3. df = pd.DataFrame({'height': height})
  4. df.head(5)
Out[113]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  height
0 166.547946
1 166.847060
2 166.887866
3 175.607073
4 181.527058
 

绘制直方图，其中分组数为100：

In [114]:
  1. df.plot(kind='hist', bins=100, figsize=(10, 5))
  2.  
  3. plt.grid(True, linestyle='--', alpha=0.8)
  4. plt.show()
 
 

从图中可以直观地看出，大多人身高集中在170左右。

 

箱形图 box

 

箱形图多用于数值统计，它不需要占据过多的画布空间，空间利用率高，非常适用于比较多组数据的分布情况。通过箱形图，可以很快知道一些关键的统计值，如最大值、最小值、中位数、上下四分位数等等。

 

 

某班级30个学生在期末考试中，语文、数学、英语、物理、化学5门课的成绩数据如下：

In [115]:
  1. count = 30
  2.  
  3. chinese_score = np.random.normal(80, 10, count)
  4. maths_score = np.random.normal(85, 20, count)
  5. english_score = np.random.normal(70, 25, count)
  6. physics_score = np.random.normal(65, 30, count)
  7. chemistry_score = np.random.normal(75, 5, count)
  8.  
  9. scores = pd.DataFrame({'Chinese': chinese_score, 'Maths': maths_score, 'English': english_score,
  10.                        'Physics': physics_score, 'Chemistry': chemistry_score})
  11.  
  12. scores.head(5)
Out[115]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  Chinese Maths English Physics Chemistry
0 81.985202 77.139479 78.881483 98.688823 75.849040
1 71.597557 69.960533 98.784664 72.140422 73.179419
2 80.581071 75.501743 99.491803 18.579709 67.963091
3 82.396994 113.018430 83.224544 38.406359 75.713590
4 83.153492 103.378598 59.399535 78.381277 77.020693
 

绘制箱形图如下：

In [116]:
  1. scores.plot(kind='box', figsize=(10, 6))
  2.  
  3. plt.grid(True, linestyle='--', alpha=1)
  4. plt.show()
 
 

添加参数vert=False将箱形图横向展示：

In [117]:
  1. scores.plot(kind='box', vert=False, figsize=(10, 5))
  2.  
  3. plt.grid(True, linestyle='--', alpha=1)
  4. plt.show()
 
 

添加参数subplots=True，可以形成多个子图：

In [118]:
  1. scores.plot(kind='box', y=['Chinese', 'Maths', 'English', 'Physics'],
  2.             subplots=True, layout=(2, 2), figsize=(10, 8))
  3.  
  4. plt.show()
 
 

面积图 area

 

面积图，或称区域图，是一种随有序变量的变化，反映数值变化的统计图表，原理与折线图相似。而面积图的特点在于，折线与自变量坐标轴之间的区域，会由颜色或者纹理填充。

 

适用场景：

在连续自变量下，一组或多组数据的趋势变化以及相互之间的对比，同时也能够观察到数据总量的变化趋势。

例如，位移 = 速度 x 时间：即s=v*t; 那么x 轴是时间 t，y 轴是每个时刻的速度 v，使用面积图，不仅可以观察速度随时间变化的趋势，还可以根据面积大小来感受位移距离的长度变化。

 

秋名山某段直线赛道上，AE86与GC8在60秒时间内的车速与时间的变化数据如下：

In [119]:
  1. t = list(range(60))
  2.  
  3. v_AE86 = np.random.uniform(180, 210, len(t))
  4. v_GC8 = np.random.uniform(190, 230, len(t))
  5.  
  6. v = pd.DataFrame({'t': t, 'AE86': v_AE86, 'GC8': v_GC8})
  7.  
  8. v.head(5)
Out[119]:
 

.dataframe tbody tr th:only-of-type { vertical-align: middle }
.dataframe tbody tr th { vertical-align: top }
.dataframe thead th { text-align: right }

  t AE86 GC8
0 0 198.183060 215.830409
1 1 190.186453 195.316343
2 2 180.464073 210.641824
3 3 194.842767 219.794681
4 4 194.620050 204.215492
 

面积图默认情况下是堆叠的。

In [120]:
  1. v.plot(kind='area', x='t', y=['AE86', 'GC8'], figsize=(10, 5))
  2. plt.show()
 
 

要生成未堆积的图，可以传入参数stacked=False：

In [121]:
  1. v.plot(kind='area', x='t', y=['AE86', 'GC8'],
  2.        stacked=False, figsize=(10, 5), alpha=0.4)
  3. plt.show()
 
 

从图形与x轴围成的面积看，很显然该60秒内，GC8是略领先AE86的。温馨提示，文明驾驶，切勿飙车！

 

同样，添加参数subplots=True，可以形成多个子图，如下：

In [122]:
  1. v.plot(kind='area', x='t', y=['AE86', 'GC8'],
  2.        subplots=True, figsize=(10, 5), rot=0)
  3. plt.show()
 
 

总结

 

本文是快速上手pandas的上篇，先介绍了为什么选用pandas，接下来介绍pandas的常用数据结构Series、DataFrame以及一系列的操作与运算，然后尝试了用pandas来读写文件，最后重点介绍了如何使用pandas快速便捷地可视化数据。

 

在快速上手pandas的下篇中，会涉及如何用pandas来进行数据清洗、数据合并、分组聚合、数据透视、文本处理等，敬请期待。

快速上手pandas(上)的更多相关文章

  1. 快速上手pandas(下)

      和上文一样,先导入后面会频繁使用到的模块: In [1]: import numpy as np import pandas as pd import matplotlib.pyplot as p ...

  2. 【转】Webpack 快速上手（上）

    嫌啰嗦想直接看最终的配置请戳这里 webpack-workbench (https://github.com/onlymisaky/webpack-workbench) 由于文章篇幅较长,为了更好的阅 ...

  3. Pandas快速上手（一）：基本操作

    本文包含一些 Pandas 的基本操作,旨在快速上手 Pandas 的基本操作. 读者最好有 NumPy 的基础,如果你还不熟悉 NumPy,建议您阅读NumPy基本操作快速熟悉. Pandas 数据 ...

  4. 用Docker在一台笔记本电脑上搭建一个具有10个节点7种角色的Hadoop集群（上）-快速上手Docker

    如果想在一台电脑上搭建一个多节点的Hadoop集群,传统的方式是使用多个虚拟机.但这种方式占用的资源比较多,一台笔记本能同时运行的虚拟机的数量是很有限的.这个时候我们可以使用Docker.Docker ...

  5. 【opencv入门篇】 10个程序快速上手opencv【上】

    导言:本系列博客目的在于能够在vs快速上手opencv,理论知识涉及较少,大家有兴趣可以查阅其他博客深入了解相关的理论知识,本博客后续也会对图像方向的理论进一步分析,敬请期待:) PS:官方文档永远是 ...

  6. 三分钟快速上手TensorFlow 2.0 （上）——前置基础、模型建立与可视化

    本文学习笔记参照来源:https://tf.wiki/zh/basic/basic.html 学习笔记类似提纲,具体细节参照上文链接 一些前置的基础 随机数 tf.random uniform(sha ...

  7. 【Python五篇慢慢弹】快速上手学python

    快速上手学python 作者:白宁超 2016年10月4日19:59:39 摘要:python语言俨然不算新技术,七八年前甚至更早已有很多人研习,只是没有现在流行罢了.之所以当下如此盛行,我想肯定是多 ...

  8. [译]：Xamarin.Android开发入门——Hello,Android Multiscreen快速上手

    原文链接:Hello, Android Multiscreen Quickstart. 译文链接:Hello,Android Multiscreen快速上手 本部分介绍利用Xamarin.Androi ...

  9. [译]：Xamarin.Android开发入门——Hello,Android快速上手

    返回索引目录 原文链接:Hello, Android_Quickstart. 译文链接:Xamarin.Android开发入门--Hello,Android快速上手 本部分介绍利用Xamarin开发A ...

随机推荐

  1. FreeSql之Expression表达式拼接参数扩展

    在FreeSql源码中Expression表达式拼接默认最多支持到5个泛型参数,当我们使用表关联比较多的时候,就需要进行扩展. 新建一个类,将命名空间改为System.Linq.Expressions ...

  2. 通过Dapr实现一个简单的基于.net的微服务电商系统(十)——一步一步教你如何撸Dapr之绑定

    如果说Actor是dapr有状态服务的内部体现的话,那绑定应该是dapr对serverless这部分的体现了.我们可以通过绑定极大的扩展应用的能力,甚至未来会成为serverless的基础.最开始接触 ...

  3. MySQL锁等待与死锁问题分析

    前言: 在 MySQL 运维过程中,锁等待和死锁问题是令各位 DBA 及开发同学非常头痛的事.出现此类问题会造成业务回滚.卡顿等故障,特别是业务繁忙的系统,出现死锁问题后影响会更严重.本篇文章我们一起 ...

  4. pytest用法---学习篇1

    一.pytest运行规则: pytest可以收集所有以test_*.py文件,Test开头的类,和以test_开头的函数和方法,都能识别成测试用例. 当然也可以改变这个的识别规则 二.常用参数 -k ...

  5. [DB] ElasticSearch

    安装 root用户解压,修改配置文件 创建新用户es 修改文件权限:chown -R es:es /kkb/install/elasticsearch-6.7.0/ 用es用户启动ElasticSea ...

  6. Canal和Otter讨论二(原理与实践)

    上次留下的问题 问题一: 跨公网部署Otter 参考架构图 解析 ​ a. 数据涉及网络传输,S/E/T/L几个阶段会分散在2个或者更多Node节点上,多个Node之间通过zookeeper进行协同工 ...

  7. LDAP协议入门

    LDAP协议入门(轻型目录访问协议) LDAP简介 轻型目录访问协议,全称:Lightweight Directory Access Protocol,缩写:LDAP,它是基于X.500标准的,但是简 ...

  8. Linux_搭建NFS服务（基础）

    [RHEL8]-NFSserver :[Centos7]-NFSclient !!!测试环境我们首关闭防火墙和selinux(NFSserver和NFSclient都需要) [root@localho ...

  9. Linux_yum仓库管理

    一.yum配置本地仓库 1.挂载光盘 [root@localhost ~]# mount /dev/sr0 /mnt/ [root@localhost ~]# df -hT 文件系统 类型 容量 已用 ...

  10. 【转载】ltp压力测试结果分析脚本

    博客园 首页 新随笔 联系 管理 订阅 随笔- 8  文章- 0  评论- 0  ltp压力测试结果分析脚本   最近工作性质发生了改变,在做操作系统方面的测试.接手的第一个任务是做ltp stres ...