http://blog.csdn.net/pipisorry/article/details/39506169

数据分析和建模方面的大量编程工作都是用在数据准备上的：加载、清理、转换以及重 塑。有时候，存放在文件或数据库中的数据并不能满足数据处理应用的要求。

pandas和Python标准库提供了一组高级的、灵活的、高效的核心函数和算法，它们能够轻松地将数据规整化为正确的形式。

数据正则化data normalization

pandas.dataframe每行都减去行平均值

use DataFrame‘s sub method and specify that the subtraction should happen row-wise (axis=0) as opposed to the default column-wise behaviour:

df.sub(df.mean(axis=1), axis=0)

相当于

norm_ui_array = df.values
for i in range(len(norm_ui_array)):
    norm_ui_array[i][norm_ui_array[i] != np.NaN] -= user_rat_mean[i]

[Pandas: Subtract row mean from each element in row]

皮皮Blog

合并数据集

pandas对象中的数据可以通过一些内置的方式进行合并：
pandas .merge可根据一个或多个键将不同DataFrame中的行连接起来。
Pandas.concat可以沿着一条轴将多个对象堆叠到一起。
实例方法combine_first可以将重复数据编接在一起，用一个对象中的值填充另一个对象中的缺失值。

数据库风格的DataFrame合并merge

相当于数据库中的join操作，数据集的合并(merge)或连接(join)运算是通过一个或多个键将行链接起来的。这些运算是关系型数据库的核心。pandas的merge函数是对数据应用这些算法的主要切入点。

merge函数的参数

参数    说明
left    参与合并的左侧DataFrame
right    参与合并的右侧DataFrame
how    “inner”、 “outer”、 “left”、 “right” 其中之一。默认为“inner”
on             用于连接的列名。必须存在于左右两个DataFrame对象中。如果未指定，且其他连接键也未指定，则以left和right列名的交集作为连接键
left_on     左侧DataFrame中用作连接键的列
right_on   右侧DataFrame中用作连接键的列
leftjndex   将左侧的行索引用作其连接键
rightjndex 类似于leftjndex
sort          根据连接键对合并后的数据进行排序，默认为True。有时在处理大数据集时，禁用该选项可获得更好的性能
suffixes    字符串值元组，用于追加到重叠列名的末尾，默认为(‘_x‘, ‘_y‘)。
copy         设置为False,可以在某些特殊情况下避免将数据复制到结果数据结构中。默认总是复制。

多对一合并

>>>import pandas as pd
>>> df1 = pd.DataFrame({‘key‘: [‘b‘, ‘b‘, ‘a‘,‘c‘,‘a‘,‘a‘,‘b‘],‘data1‘: range(7)})
>>>df2 = pd.DataFrame({‘key‘: [‘a‘, ‘b‘, ‘d‘],‘data2‘: range(3)})
df1
Out[5]:
   data1 key
0      0   b
1      1   b
2      2   a
3      3   c
4      4   a
5      5   a
6      6   b

df2
Out[6]:
   data2 key
0      0   a
1      1   b
2      2   d
这是一种多对一的合并。df1中的数据有多个被标记为a和b的行，而df2中key列的每个值 则仅对应一行。对这些对象调用merge即可得到：
pd.merge(df1, df2)
Out[7]:
   data1 key  data2
0      0   b      1
1      1   b      1
2      6   b      1
3      2   a      0
4      4   a      0
5      5   a      0
注意，并没有指明要用哪个列迸行连接。如果没有指定，merge就会将重叠列的列名当做键。不过，最好显式指定一下：
pd.merge(df1, df2, on=‘key‘)

两个对象的列名不同

如果两个对象的列名不同，也可分别进行指定：
>>>df3 = DataFrame({‘lkey‘: [‘b‘, ‘b‘, ‘a‘,‘c‘,‘a‘,‘a‘,‘b‘],
‘data1‘: range(7)})
>>>df4 = DataFrame({‘rkey‘: [‘a‘, ‘b‘,‘d‘],
‘data2‘: range(3)})
>>>pd.merge(df3, df4, left_on=‘lkey‘, right_on=‘rkey‘)
结果里面c和d以及与之相关的数据消失了。默认情况下，merge做的是“inner”连接:结果中的键是交集。其他方式还有“left”、“right”以及 “outer”。外连接求取的是键的并集，组合了左连接和右连接的效果：
pd.merge(df1, df2, how=‘outer‘)
Out[8]:
   data1 key  data2
0    0.0   b    1.0
1    1.0   b    1.0
2    6.0   b    1.0
3    2.0   a    0.0
4    4.0   a    0.0
5    5.0   a    0.0
6    3.0   c    NaN
7    NaN   d    2.0

多对多合并

多对多的合并操作非常简单，无需额外的工作。
>>> df1 = pd.DataFrame({‘key‘: [‘b‘,‘b‘,‘a‘,‘c‘,‘a‘,‘b‘],‘data1‘: range(6)})
>>>df2 = pd.DataFrame({‘key‘: [‘a‘,‘b‘,‘a‘,‘b‘,‘d‘],‘data2‘: range(5)})
>>> pd.merge(df1, df2, on=‘key‘, how=‘left‘)
    data1 key  data2
0       0   b    1.0
1       0   b    3.0
2       1   b    1.0
3       1   b    3.0
4       2   a    0.0
5       2   a    2.0
6       3   c    NaN
7       4   a    0.0
8       4   a    2.0
9       5   b    1.0
10      5   b    3.0
多对多连接产生的是行的笛卡尔积。由于左边的DataFrame有3个“b”行，右边的有2个，所以域终结果中就有6个“b”行。

连接方式只影响出现在结果中的键：
>>> pd.merge(df1, df2, how=‘inner‘)

多键合并

要根据多个键进行合并，传入一个由列名组成的列表即可：
>>>left= pd.DataFrame({‘key1‘: [‘foo‘,‘foo‘,‘bar‘],‘key2‘: [‘one‘, ‘two‘, ‘one‘],‘lval‘: [1,2,3]})
>>>right = pd.DataFrame({‘key1‘: [‘foo‘, ‘foo‘, ‘bar‘, ‘bar‘], ‘key2‘: [‘one‘, ‘one‘, ‘one‘, ‘two‘],‘lval‘: [4, 5, 6, 7]})
>>>pd.merge(left, right, on=[‘key1‘, ‘key2‘], how=‘outer‘)
  key1 key2  lval_x  lval_y
0  foo  one     1.0     4.0
1  foo  one     1.0     5.0
2  foo  two     2.0     NaN
3  bar  one     3.0     6.0
4  bar  two     NaN     7.0
结果中会出现哪些键组合取决于所选的合并方式，也可以这样来理解：多个键形成一系列元组，并将其当做单个连接键（当然，实际上并不是这么回事）。
Note：在进行列-列连接时，DataFrame对象中的索引会被丢弃。

重复列名的处理

对于合并运算需要考虑的最后一个问题是对重复列名的处理。虽然可以手工处理列名重叠的问题，但merge有一个更实用的suffixes选项，用于指定附加到左右两个DataFrame对象的重叠列名上的字符串：
>>>pd.merge(left, right, on=‘key1‘, suffixes=(‘_left‘, ‘_right‘))
Note: 看上面的结果，默认suffixes=(‘_x‘, ‘_y‘)

索引上的合并

有时DataFrame中的连接键位于其索引中。在这种情况下，你可以传入left_index=True或right_index=True (或两个都传）以说明索引应该被用作连接键：
>>>left1 = pd.DataFrame({‘key‘:[‘a‘,‘b‘,‘a‘,‘a‘,‘b‘,‘c‘],‘value‘: range(6)})
>>>right1 = pd.DataFrame({‘group_val‘: [3.5,7]}, index=[‘a‘,‘b‘])
left1
Out[18]:
  key  value
0   a      0
1   b      1
2   a      2
3   a      3
4   b      4
5   c      5
right1
Out[19]:
   group_val
a        3.5
b        7.0
pd.merge(left1, right1, left_on=‘key‘,right_index=True)
Out[20]:
  key  value  group_val
0   a      0        3.5
2   a      2        3.5
3   a      3        3.5
1   b      1        7.0
4   b      4        7.0

merge层次化索引数据

对于层次化索引的数据：
>>>lefth = pd.DataFrame({‘key1‘: [‘Ohio‘,‘Ohio‘,‘Ohio‘,‘Nevada‘,‘Nevada‘],
                    ‘key2‘: [2000, 2001, 2002, 2001, 2002],
                    ‘data‘: np.arange(5.)})
>>>righth = pd.DataFrame(np.arange(12).reshape((6, 2)),
    index=[[‘Nevada‘, ‘Nevada‘, ‘Ohio‘, ‘Ohio‘, ‘Ohio‘, ‘Ohio‘], [2001, 2000, 2000, 2000, 2001, 2002]],
    columns=[‘event1‘, ‘event2‘])
lefth
Out[24]:
   data    key1  key2
0   0.0    Ohio  2000
1   1.0    Ohio  2001
2   2.0    Ohio  2002
3   3.0  Nevada  2001
4   4.0  Nevada  2002
righth
Out[25]:
             event1  event2
Nevada 2001       0       1
       2000       2       3
Ohio   2000       4       5
       2000       6       7
       2001       8       9
       2002      10      11
这种情况下，必须以列表的形式指明用作合并键的多个列（注意对重复索引值的处理）:
pd.merge(lefth, righth, left_on=[‘key1‘,‘key2‘],right_index=True, how= ‘outer‘)
Out[7]:
   data    key1    key2  event1  event2
0   0.0    Ohio  2000.0     4.0     5.0
0   0.0    Ohio  2000.0     6.0     7.0
1   1.0    Ohio  2001.0     8.0     9.0
2   2.0    Ohio  2002.0    10.0    11.0
3   3.0  Nevada  2001.0     0.0     1.0
4   4.0  Nevada  2002.0     NaN     NaN
4   NaN  Nevada  2000.0     2.0     3.0

DataFrame.join实例方法

DataFrame还有一个join实例方法，它能更为方便地实现按索引合并。它还可用于合并多个带有相同或相似索引的DataFrame对象，而不管它们之间有没有重叠的列。
left2.join(right2,how=‘outer‘)
由于一些历史原因（早期版本的pandas)，DataFrame的join方法是在连接键上做左连接。
它还支持参数DataFrame的索引跟调用者DataFrame的某个列之间的连接：
left1.join(right1, on=‘key‘)
最后，对于简单的索引合并，还可以向join传入一组DataFrame (后面会介绍更为通用的concat函数，它也能实现此功能）：
>>>another = DataFrame([[7.,8.], [9.,10.], [11.,12.], [16.,17.]],index=[‘a‘, ‘c‘,‘e‘,‘f‘], columns=[‘New York‘,‘Oregon‘])
>>>left2.join([right2, another])
>>>left2.join([right2, another], how=‘outer‘)

轴向连接concat

另一种数据合并运算concat也被称作连接（concatenation)、绑定（binding)或堆叠(stacking)。

concat函数的参数

objs    参与连接的pandas对象的列表或字典。唯一必需的参数
axis    指明连接的轴向，默认为0
join     “inner”、 “outer”其中之_，默认为“outer”。指明其他轴向上的索引是按交集（inner)还是并集（outer)进行合并
join_axes  指明用于其他n-1条轴的索引，不执行并集/交集运算
keys    与连接对象有关的值，用于形成连接轴向上的层次化索引。可以是任 意值的列表或数组、元组数组、数组列表（如果将levels设置成多级数组的话）
levels   指定用作层次化索引各级别上的索引，如果设置了keys的话
names  用于创建分层级别的名称，如果设置了keys和（或）levels的话
verify_integrity   检查结果对象新轴上的重复情况，如果发现则引发异常。默认(False)允许重复
ignore_index      不保留连接轴上的索引，产生一组新索引range(total_length)

NumPy的concatenation函数

NumPy有一个用于合并原始NumPy数组的concatenation函数:
>>>arr = np.arange(12).reshape((3, 4))
>>> arr
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> np.concatenate([arr, arr], axis=1)
array([[ 0,  1,  2,  3,  0,  1,  2,  3],
       [ 4,  5,  6,  7,  4,  5,  6,  7],
       [ 8,  9, 10, 11,  8,  9, 10, 11]])

pandas对象连接运算concat

对于pandas对象（如Series和DataFrame)，带有标签的轴能够进一步推广数组的连接运算。

假设有三个没有重叠索引的Series:
s1 = pd.Series([0, 1], index=[‘a‘,‘b‘])
s2 = pd.Series([2, 3, 4], index=[‘c‘,‘d‘,‘e‘])
s3 = pd.Series([5, 6], index=[‘f‘, ‘g‘])
对这些对象调用concat可以将值和索引粘合在一起：
>>> pd.concat([s1,s2,s3])
a    0
b    1
c    2
d    3
e    4
f    5
g    6
dtype: int64
默认情况下，concat是在axis=0上工作的，最终产生一个新的Series。如果传入axis=1， 则结果就会变成一个DataFrame (axis=1是列）：
pd.concat([s1, s2, s3], axis=1)
Out[18]:
     0    1    2
a  0.0  NaN  NaN
b  1.0  NaN  NaN
c  NaN  2.0  NaN
d  NaN  3.0  NaN
e  NaN  4.0  NaN
f  NaN  NaN  5.0
g  NaN  NaN  6.0
这种情况下，另外一条轴上没有重叠，从索引的有序并集（外连接）上就可以看出来。 传入join=‘inner’即可得到它们的交集：
s4 = pd.concat([s1 * 5, s3])
Out[20]:
a    0
b    5
f    5
g    6
dtype: int64
pd.concat([s1,s4], axis=1)
Out[21]:
     0  1
a  0.0  0
b  1.0  5
f  NaN  5
g  NaN  6
pd.concat([s1,s4], axis=1, join=‘inner‘)
Out[22]:
   0  1
a  0  0
b  1  5
可以通过join_axes指定要在其他轴上使用的索引：
pd.concat([s1, s4], axis=1, join_axes=[[‘a‘,‘c‘,‘b‘,‘e‘]])
     0    1
a  0.0  0.0
c  NaN  NaN
b  1.0  5.0
e  NaN  NaN

连接轴上创建层次化索引区分连接片段

想要参与连接的片段在结果中区分开。可在连接轴上创建一个层次化索引。使用keys参数即可达到这个目的：
pd.concat([s1,s1,s3])
a    0
b    1
a    0
b    1
f    5
g    6
dtype: int64
pd.concat([s1,s1,s3], keys=[‘one‘,‘two‘,‘three‘])
one    a    0
       b    1
two    a    0
       b    1
three  f    5
       g    6
dtype: int64
如果沿着axis=1对Series进行合并，则keys就会成为DataFrame的列头：
pd.concat([s1,s2,s3], axis=1, keys=[‘one‘,‘two‘,‘three‘])

同样的逻辑对DataFrame对象

>>>df1 = pd.DataFrame(np.arange(6).reshape(3,2),index=[‘a‘,‘b‘,‘c‘],columns=[‘one‘,‘two‘])
>>>df2 = pd.DataFrame(5 + np.arange(4).reshape(2,2), index=[‘a‘,‘c‘],columns=[‘three‘,‘four‘])
In [29]: df1
Out[29]:
   one  two
a    0    1
b    2    3
c    4    5

In [30]: df2
Out[30]:
   three  four
a      5     6
c      7     8
In [31]: pd.concat([df1,df2],axis=1,keys=[‘level1‘,‘level2‘])
Out[31]:
  level1     level2     
     one two  three four
a      0   1    5.0  6.0
b      2   3    NaN  NaN
c      4   5    7.0  8.0
如果传入的不是列表而是一个字典，则字典的键就会被当做keys选项的值
>>>pd.concat({‘level1‘:df1,‘level2‘:df2}, axis=1)

两个用于管理层次化索引创建方式的参数

>>>  pd.concat([df1, df2], axis=1, keys=[‘level1‘,‘level2‘],names=[‘upper‘,‘lower‘])
DataFrame行索引:
>>>df1 = pd.DataFrame(np.random.randn(3,4),columns=[‘a‘,‘b‘,‘c‘,‘d‘])
>>>df2 = pd.DataFrame(np.random.randn(2,3), columns=[‘b‘,‘d‘,‘a‘])
In [36]: df1
Out[36]:
          a         b         c         d
0  0.208624 -1.061705 -0.517955 -1.131341
1 -0.554871 -1.162995 -2.177741 -0.148387
2 -2.521862 -1.307174 -0.505220  0.560942

In [37]: df2
Out[37]:
          b         d         a
0  0.508929  0.002077 -1.851976
1  2.745318  0.087151  0.951520
在这种情况下，传入ignore_index=True即可：
In [38]: pd.concat([df1, df2],ignore_index=True)
Out[38]:
          a         b         c         d
0  0.208624 -1.061705 -0.517955 -1.131341
1 -0.554871 -1.162995 -2.177741 -0.148387
2 -2.521862 -1.307174 -0.505220  0.560942
3 -1.851976  0.508929       NaN  0.002077
4  0.951520  2.745318       NaN  0.087151
皮皮Blog

Indexing and Selecting Data

...

冗余数据处理Duplicate Data

DataFrame的duplicated方法返回一个布尔型Series,表示各行是否重复行。而 drop_duplicates方法，它用于返回一个移除了重复行的DataFrame

data.drop_duplicates(inplace=True) 或者data = http://www.mamicode.com/data.drop_duplicates()

只对某一列有重复则删除：

df.drop_duplicates(subset=0, inplace=True)

[Duplicate Data]

[Indexing and Selecting Data]

皮皮Blog

..

from: http://blog.csdn.net/pipisorry/article/details/39506169

ref: [API Reference]

[pandas 数据规整]

pandas小记：pandas数据规整化