Pandas数据规整 - 转换

In [1]:

import numpy as np
import pandas as pd

Pandas数据排序

.sort_index() 在指定轴上根据索引进行排序，索引排序后内容会跟随排序

In [2]:

b = pd.DataFrame(np.arange(20).reshape(4,5),index=['c','a','d','b'])
b

Out[2]:

sort_index() 按索引排序

In [3]:

b.sort_index()  # 默认按行索引排序，默认升序

Out[3]:

In [4]:

b.sort_index(axis=1, ascending=False)  # 按列索引排序，降序

Out[4]:

sort_values() 按值排序

In [5]:

dates = pd.date_range('20130101', periods = 10)
dates
df = pd.DataFrame(np.random.randn(10,4), index = dates, columns = ['A','B','C','D'])
df

Out[5]:

In [7]:

# 默认按行排序（这一列的所有行）
df.sort_values(by='A')  # 指定排序基准列
df.sort_values(by='A', ascending=False)  # 倒序

Out[7]:

In [8]:

# 按列排序（一行的所有列）
df.sort_values(axis=1, by='2013-01-01', ascending=False)

Out[8]:

关于排序中的缺失值问题

排序不论升序降序，缺失值永远排在最后

In [9]:

a = pd.DataFrame(np.arange(12).reshape(3,4), index=['a','b','c'])
a
b = pd.DataFrame(np.arange(20).reshape(4,5), index=['c','a','d','b'])
b

c = a + b
c

Out[9]:

In [11]:

c.sort_values(by=0)  # 升序，缺失值在最后
c.sort_values(by=0, ascending=False)  # 降序，缺失值还在最后

Out[11]:

随机排列和随机采样

随机排列

利用numpy.random.permutation函数可以实现对Series或DataFrame的列的随机排序工作（permuting，随机重排序）

通过需要排列的轴的长度调用permutation，可产生一个表示新顺序的整数数组：

In [23]:

# 随机排列序列
a = [1,2,3,4,5,6,7]
a
np.random.permutation(a)

Out[23]:

array([6, 3, 4, 7, 5, 1, 2])

In [24]:

df = pd.DataFrame(np.arange(5 * 4).reshape((5, 4)))
df

Out[24]:

In [25]:

df.index
df.columns

Out[25]:

RangeIndex(start=0, stop=4, step=1)

In [26]:

# 打乱行索引
np.random.permutation(df.index)

Out[26]:

array([4, 3, 2, 1, 0], dtype=int64)

In [38]:

df.loc[[2,3,4,1,0]]
df.loc[np.random.permutation(df.index)]

Out[38]:

随机重排行索引和列索引

In [47]:

index = np.random.permutation(df.index)
index

columns = np.random.permutation(df.columns)
columns

df.loc[index, columns]

Out[47]:

随机采样

choice(),从一个序列中随机抽取某些值

In [95]:

a = [1,2,3,4,5,6,7]
np.random.choice(a)
np.random.choice(a, size=3)  # 放回抽样
np.random.choice(a, size=3, replace=False)  # 不放回抽样，不重复抽取

Out[95]:

array([1, 7, 6])

随机采样

In [96]:

df

Out[96]:

In [106]:

# 按行随机采样
df.index

index = np.random.choice(df.index, size=3, replace=False)

df.loc[index]

Out[106]:

In [118]:

# 按行、按列随机采样
df.index
df.columns

index = np.random.choice(df.index, size=3, replace=False)
columns = np.random.choice(df.columns, size=2, replace=False)

df.loc[index, columns]

Out[118]:

重新索引（修改索引）

reindex() ，重新索引，创建一个适应新索引的新对象

一种变相的查询方式，类似在查询中加入新行新列

• rename是将原索引某些值替换为新值
• reindex则是将整个索引重建（并不替换索引值，而是增减索引或改变顺序，原索引对应的值关系不变）

In [119]:

obj = pd.Series([4.5,7,2,-5.3], index = ['d','b','a','c'])
obj

Out[119]:

d    4.5
b    7.0
a    2.0
c   -5.3
dtype: float64

In [120]:

obj.index
obj.index.values

Out[120]:

array(['d', 'b', 'a', 'c'], dtype=object)

直接修改索引

有问题，不合适

• 索引修改后，值没有跟着变化
• 修改值必须和原索引长度保持一致，不能增加或删除索引

In [121]:

obj.index = ['a','b','c','d']
obj

Out[121]:

a    4.5
b    7.0
c    2.0
d   -5.3
dtype: float64

In [230]:

# obj.index = ['a','b','c']  # 长度不一致，报错

使用rename修改索引

In [122]:

obj

Out[122]:

a    4.5
b    7.0
c    2.0
d   -5.3
dtype: float64

In [123]:

obj.rename({'a': 'aa', 'b': 'ccc', 'x': 'xx'})

Out[123]:

aa     4.5
ccc    7.0
c      2.0
d     -5.3
dtype: float64

正规做法：使用reindex()修改索引

In [125]:

obj

Out[125]:

a    4.5
b    7.0
c    2.0
d   -5.3
dtype: float64

In [126]:

obj.reindex(['b','d','a','c','e'])

Out[126]:

b    7.0
d   -5.3
a    4.5
c    2.0
e    NaN
dtype: float64

In [127]:

# 新增的缺失值，填充默认值
obj.reindex(['b','d','a','c','e'], fill_value=0)

Out[127]:

b    7.0
d   -5.3
a    4.5
c    2.0
e    0.0
dtype: float64

实际应用

In [128]:

obj2 = pd.Series(['blue','purple','yellow'], index = [0,2,4])
obj2

Out[128]:

0      blue
2    purple
4    yellow
dtype: object

In [129]:

range(6)

Out[129]:

range(0, 6)

In [130]:

obj2.reindex(range(6))

Out[130]:

0      blue
1       NaN
2    purple
3       NaN
4    yellow
5       NaN
dtype: object

In [131]:

# 填充缺失值，指定填充值
obj2.reindex(range(6), fill_value=0)

Out[131]:

0      blue
1         0
2    purple
3         0
4    yellow
5         0
dtype: object

In [133]:

# 前向，后向填充
obj2.reindex(range(6), method='ffill')
obj2.reindex(range(6), method='bfill')

Out[133]:

0      blue
1    purple
2    purple
3    yellow
4    yellow
5       NaN
dtype: object

DataFrame的索引重建

In [134]:

frame = pd.DataFrame(np.random.randint(0,100,(3,3)), index = ['语文','数学','英语'], columns = ['张三','李四','王五'])
frame

Out[134]:

In [136]:

# 重建行索引
frame.reindex(['语文', '数学', '英语'])
frame.reindex(['语文', '编程', '英语'])

Out[136]:

In [138]:

# 重建列索引
frame.reindex(['张三', '赵六', '王五'], axis=1)
frame.reindex(columns=['张三', '赵六', '王五'])

Out[138]:

In [139]:

# 重建行列索引
frame.reindex(index=['语文', '编程', '英语'], columns=['张三', '赵六', '王五'])

Out[139]:

In [140]:

frame.loc[['语文', '编程', '英语'], ['张三', '赵六', '王五']]  # 警告，建议使用reindex方法

e:\Anaconda3\lib\site-packages\ipykernel_launcher.py:1: FutureWarning: 
Passing list-likes to .loc or [] with any missing label will raise
KeyError in the future, you can use .reindex() as an alternative.

See the documentation here:
https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike
  """Entry point for launching an IPython kernel.

Out[140]:

例2

In [141]:

frame.index = [1,2,4]
frame.columns = [1,2,3]
frame

Out[141]:

In [142]:

# 重建行列索引
frame.reindex(index=[1,2,10,4], columns=[3,1,5,2])

Out[142]:

In [252]:

# frame.loc[[1,2,10,4], [3,1,5,2]]  # 弃用写法，使用上面写法

In [143]:

frame.reindex([1,2,10,4])
frame.reindex([1,2,10,4], method='ffill')  # 前向填充，按实际行索引排序填充

Out[143]:

带有重复值的轴索引

许多Pandas函数要求标签唯一，但这不是强制的

In [144]:

obj = pd.Series(range(5), index=['a','a','b','b','c'])
obj

Out[144]:

a    0
a    1
b    2
b    3
c    4
dtype: int64

In [145]:

obj['a']

Out[145]:

a    0
a    1
dtype: int64

In [258]:

obj['a'].values
obj['a'].values[0]

Out[258]:

0

In [146]:

# 索引的is_unique属性判断索引值是否唯一
obj.index.is_unique

Out[146]:

False