人工智能之Numpy与Pandas培训文档
创建时间:2018-09-09  访问量:3294  4  0

人工智能之Numpy与Pandas培训文档

Pandas基本操作

Pandas中的操作基本上都是通过Series中的属性与方法进行处理的,下面就详细说明一下Pandas中常用的属性与方法。

其它可以参考:http://pandas.pydata.org/pandas-docs/stable/api.html

下面通过Series或DataFrame数据结构来进行说明,Series与DataFrame中的大部分方法与属性都是通用的。

 

Pandas中的属性

首先创建一个Series结构的数据:

>>> import numpy as np # 导入numpy
>>> import pandas as pd # 导入pandas
>>> arr = np.random.random((10,)) # 创建一个随机的ndarray
>>> arr
array([0.59436217, 0.04949077, 0.21551616, 0.07938885, 0.17764792,
       0.96580564, 0.96470404, 0.75143313, 0.24486558, 0.76379286])
>>> series1 = pd.Series(arr) # 根据ndarray创建一个Series
>>> series1
0    0.594362
1    0.049491
2    0.215516
3    0.079389
4    0.177648
5    0.965806
6    0.964704
7    0.751433
8    0.244866
9    0.763793
dtype: float64

index属性:显示或设置Series结构的索引

>>> series1.index # 黙认是RangeIndex
RangeIndex(start=0, stop=10, step=1)
>>> series1.index = ['a','b','c','d','e','f','g','h','i','j'] # 通过赋值修改索引
>>> series1
a    0.594362
b    0.049491
c    0.215516
d    0.079389
e    0.177648
f    0.965806
g    0.964704
h    0.751433
i    0.244866
j    0.763793
dtype: float64

values属性:以ndarray形式返回Series中的数据

>>> series1.values
array([0.59436217, 0.04949077, 0.21551616, 0.07938885, 0.17764792,
       0.96580564, 0.96470404, 0.75143313, 0.24486558, 0.76379286])

能不能修改其中的元素值呢?看官可能自己试下。

dtype属性:显示数据的类型

>>> series1.dtype # 显示数据类型
dtype('float64')

能不能通过赋值改变数据类型呢?自己试下~

shape属性:显示数据的形状

>>> series1.shape
(10L,)

怎么修改它的形状,想想Series的数据结构,能吗?看看后文能不能找到答案。

nbytes属性:返回底层数据的字节数

>>> series1.nbytes
80
>>>

为什么是80个字节,dtype=float64可知,一个元素占8个字节,总共10个元素,一共80个字节,有人可能会问,那索引不占空间吗?其实这个属性的目的就只是返回底层数组的长度,并不是Series结构所占空间。

ndim属性:返回底层数组的维数

>>> series1.ndim
1

Series只能是一维的吗?任何东西都不是绝对的吧。大家可以用二维数据创建一个Series,看看行不行,说实话,可以的。

size属性:返回底层数组元素的个数

>>> series1.size
10

这个我没话说。

itemsize属性:返回底层数组元素的类型长度。

>>> series1.itemsize
__main__:1: FutureWarning: Series.itemsize is deprecated and will be removed in a future version
8

每人元素占8个字节,上面有条警告说,这个属性以以后的版本中就被干掉了,不要再用了。

T属性:获取Series的转置

>>> series1.T # 本来就是1维的,转置后还是自己
a    0.500000
b    0.049491
c    0.215516
d    0.079389
e    0.177648
f    0.965806
g    0.964704
h    0.751433
i    0.244866
j    0.763793
dtype: float64

name属性:

>>> series1.name = 'product' # 为Series指定名称
>>> series1.name # 查看名称
'product'
>>> series1
a    0.500000
b    0.049491
c    0.215516
d    0.079389
e    0.177648
f    0.965806
g    0.964704
h    0.751433
i    0.244866
j    0.763793
Name: product, dtype: float64

at属性:返回对应标签处理的元素

>>> df = pd.DataFrame(series1.values.reshape(2,5))
>>> df
          0         1         2         3         4
0  0.500000  0.049491  0.215516  0.079389  0.177648
1  0.965806  0.964704  0.751433  0.244866  0.763793
>>> df.at[0,0]
'0.5'

我们指定一个df的行与列的标签:

>>> df.columns=['c0','c1','c2','c3','c4']
>>> df.index=['r0','r1']
>>> df
          c0        c1        c2        c3        c4
r0  0.500000  0.049491  0.215516  0.079389  0.177648
r1  0.965806  0.964704  0.751433  0.244866  0.763793
>>> df.at['r0','c0'] # 第一个元素是行标签,第二个元素是列标签
'0.5'

iat属性:通过索引值来获取元素,每个索引标签的背后都有一个RangeIndex索引,这个Iat属性就是通过RangeIndex来取元素值的

>>> df.iat[1,2]
'0.7514331281260235'
>>>

empty属性,判断数据是否为空。

>>> df_empty = pd.DataFrame({'A' : []})
>>> df_empty
Empty DataFrame
Columns: [A]
Index: []
>>> df_empty.empty
True
>>> df = pd.DataFrame({'A' : [np.nan]}) # np.nan并不属于空
>>> df
    A
0 NaN
>>> df.empty
False
>>> df.dropna().empty # dropna就是删除nan数据
True

iloc与loc属性,前面在索引对象中都讲过了。

loc属性是通过行与列的标签索引或通过一个布尔数组来获取一组数据。iloc是位置行列索引获取一组元素。示例:

>>> df.loc['r0',['c0','c4']]
c0    0.500000
c4    0.177648
Name: r0, dtype: float64
>>> df.loc[['r0'],['c0','c4']]
     c0        c4
r0  0.5  0.177648
>>> df.loc[:,['c0','c4']]
          c0        c4
r0  0.500000  0.177648
r1  0.965806  0.763793
>>> df.loc['r0','c2':'c4'] # 获取r0行c2/c3/c4列,注意包括右边界
c2    0.215516
c3    0.079389
c4    0.177648
Name: r0, dtype: float64

axes属性:返回代表轴的列表对象,如下所示:

>>> df.axes
[Index([u'r0', u'r1'], dtype='object'), Index([u'c0', u'c1', u'c2', u'c3', u'c4'], dtype='object')]
>>> df.axes[0]
Index([u'r0', u'r1'], dtype='object')
>>> df.axes[1]
Index([u'c0', u'c1', u'c2', u'c3', u'c4'], dtype='object')

还有其它一些不常用的属性,大家可以自己看看。

 

Pandas中的方法

astype(dtype[, copy, errors])

用于数据类型转换。

>>> series2 = pd.Series([1,2,3,4,5,6,7,8,9],dtype=int)
>>> series2.dtype # 当前数据类型为int
dtype('int32')
>>> series2.astype(float) # 将类型转为float
0    1.0
1    2.0
2    3.0
3    4.0
4    5.0
5    6.0
6    7.0
7    8.0
8    9.0
dtype: float64

copy([deep])

此方法返回原数据的复本,注意与视图的区别,有一个参数deep,这个词大家一看就知道是怎么用的啊,深度copy。

>>> series3 = series2.copy()
>>> series3
0    1
1    2
2    3
3    4
4    5
5    6
6    7
7    8
8    9
dtype: int32

tolist()

将Series转换成Python列表

>>> series2.tolist()
[1, 2, 3, 4, 5, 6, 7, 8, 9]

get_values()

返回底层的Ndarray数组,是视图

>>> series2.get_values()
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>>

get(key[, default])

根据key获取数组中的数据,可以通过detaulf给出黙认值,当给定的key的值不存在时,就返回黙认值。

>>> series1
a    0.500000
b    0.049491
c    0.215516
d    0.079389
e    0.177648
f    0.965806
g    0.964704
h    0.751433
i    0.244866
j    0.763793
Name: product, dtype: float64
>>> series1.get('a')
>>> df
          c0        c1        c2        c3        c4
r0  0.500000  0.049491  0.215516  0.079389  0.177648
r1  0.965806  0.964704  0.000000  0.244866  0.763793
>>> df.get('r1','c2')
'c2'
>>> df.get('c0',1)  # 1是黙认值,对于DataFrame来说第一个参数代表列
r0    0.500000
r1    0.965806
Name: c0, dtype: float64

abs()

此方法返回数值元素的绝对值,这个比较简单。

add(other[, axis, level, fill_value])

将Series或DataFrame与其它Series或DataFrame数据相加,是元素级的加法操作。注索引对齐规则,索引相同才会进行操作。

other:其它Series或DataFrame,也可以是一个标量

axis:轴,值可以是0或1,可以是index或columns

level:广播层级

fill_value:nan的填充值

>>> df1
          c0        c1        c2        c3        c4
r0  0.500000  0.049491  0.215516  0.079389  0.177648
r1  0.965806  0.964704  0.000000  0.244866  0.763793
>>> df2
          c0        c1        c2        c3        c4
r0  0.890621  0.577505  0.116031  0.013687  0.143838
r1  0.498873  0.116245  0.218345  0.265310  0.506490
>>> df1.add(df2)
          c0        c1        c2        c3        c4
r0  1.390621  0.626996  0.331547  0.093076  0.321486
r1  1.464679  1.080949  0.218345  0.510176  1.270283
>>>

agg(funcaxis=0*args**kwargs)

此方法是在指定轴(axis)上根据指定运算函数(func)进行聚合操作。

args是传递给func的位置参数,kwargs是传递给func的关键词参数。

>>> df = pd.DataFrame([[1, 2, 3],
... [4,5,6],[7,8,9],[np.nan,np.nan,np.nan]],columns=['A','B','C'])
>>> df
     A    B    C
0  1.0  2.0  3.0
1  4.0  5.0  6.0
2  7.0  8.0  9.0
3  NaN  NaN  NaN

通过sum和min函数进行聚合

>>> df.agg(['sum', 'min'])
        A     B     C
sum  12.0  15.0  18.0
min   1.0   2.0   3.0

对A列和B列分别进行sum/min和min/max聚合统计。

>>> df.agg({'A' : ['sum', 'min'], 'B' : ['min', 'max']}) # 对A列求和与求最小值,对B列求最小值与最大值
        A    B
max   NaN  8.0
min   1.0  2.0
sum  12.0  NaN

没有聚合的对应位置值是NAN。

对列求平均值。

>>> df.agg("mean", axis="columns")
0    2.0
1    5.0
2    8.0
3    NaN
dtype: float64

aggregate(func[, axis])

这个函数与上述agg函数一样。

all([axis, bool_only, skipna, level])

如果所有元素都为True,此函数就返回True,否则返回False。

any([axis, bool_only, skipna, level])

如果有一个元素为True,则此函数就返回True,否则返回False。

axis:轴参数

bool_only:元素是否仅包括bool列,如果为False可以包括任何东西。

skipna:是否忽略np.nan值。

level:指定层级

>>> pd.Series([True, True]).all()
True
>>> pd.Series([True, False]).all()
False
>>> df = pd.DataFrame({'col1': [True, True], 'col2': [True, False]})
>>> df
   col1   col2
0  True   True
1  True  False
>>> df.all()
col1     True
col2    False
dtype: bool
>>> df.all(axis='columns')
0     True
1    False
dtype: bool
>>> df.all(axis=None)
False

append(other[, ignore_index, …])

向DataFrame中追加行数据

>>> df = pd.DataFrame([[1, 2], [3, 4]], columns=list('AB'))
>>> df
   A  B
0  1  2
1  3  4
>>> df2 = pd.DataFrame([[5, 6], [7, 8]], columns=list('AB'))
>>> df.append(df2)
   A  B
0  1  2
1  3  4
0  5  6
1  7  8
>>> df.append(df2, ignore_index=True)
   A  B
0  1  2
1  3  4
2  5  6
3  7  8
>>> df = pd.DataFrame(columns=['A'])
>>> for i in range(5):
...     df = df.append({'A': i}, ignore_index=True)
>>> df
   A
0  0
1  1
2  2
3  3
4  4

apply(func[, axis, broadcast, raw, reduce, …])

在DataFrame的轴是使用函数

>>> df = pd.DataFrame([[4, 9],] * 3, columns=['A', 'B'])
>>> df
   A  B
0  4  9
1  4  9
2  4  9
>>> df.apply(np.sqrt) # 对每个元素求平方根
     A    B
0  2.0  3.0
1  2.0  3.0
2  2.0  3.0
>>> df.apply(np.sum, axis=0) # 对0轴上对元素进行求和
A    12
B    27
dtype: int64

还可以使用lambda函数

>>> df.apply(lambda x: [1, 2], axis=1) # 将1轴上原元素就转成[1,2]
0    [1, 2]
1    [1, 2]
2    [1, 2]
dtype: object
>>> df.apply(lambda x: [1, 2], axis=1, result_type='expand') # 将对果展开
   0  1
0  1  2
1  1  2
2  1  2
>>> df.apply(lambda x: pd.Series([1, 2], index=['foo', 'bar']), axis=1) # 通过Series与Lambda生成DataFrame
   foo  bar
0    1    2
1    1    2
2    1    2

fillna([value, method, axis, inplace, …])

填充NaN缺失值

>>> df = pd.DataFrame([[np.nan, 2, np.nan, 0],
...                    [3, 4, np.nan, 1],
...                    [np.nan, np.nan, np.nan, 5],
...                    [np.nan, 3, np.nan, 4]],
...                    columns=list('ABCD'))
>>> df
     A    B   C  D
0  NaN  2.0 NaN  0
1  3.0  4.0 NaN  1
2  NaN  NaN NaN  5
3  NaN  3.0 NaN  4
>>> df.fillna(0) # 将NAN用9填充
    A   B   C   D
0   0.0 2.0 0.0 0
1   3.0 4.0 0.0 1
2   0.0 0.0 0.0 5
3   0.0 3.0 0.0 4

describe([percentiles, include, exclude])

此方法用于生成描述性统计结果数据。

>>> s = pd.Series([1, 2, 3])
>>> s.describe()
count    3.0
mean     2.0
std      1.0
min      1.0
25%      1.5
50%      2.0
75%      2.5
max      3.0
>>> s = pd.Series(['a', 'a', 'b', 'c'])
>>> s.describe()
count     4
unique    3
top       a
freq      2
dtype: object
>>> df = pd.DataFrame({ 'object': ['a', 'b', 'c'],
...                     'numeric': [1, 2, 3],
...                     'categorical': pd.Categorical(['d','e','f'])
...                   })
>>> df.describe()
       numeric
count      3.0
mean       2.0
std        1.0
min        1.0
25%        1.5
50%        2.0
75%        2.5
max        3.0
>>> df.describe(include='all') # 不能用于统计的用NAN表示,黙认NAN结果不显示,这里用于include='all'
        categorical  numeric object
count            3      3.0      3
unique           3      NaN      3
top              f      NaN      c
freq             1      NaN      1
mean           NaN      2.0    NaN
std            NaN      1.0    NaN
min            NaN      1.0    NaN
25%            NaN      1.5    NaN
50%            NaN      2.0    NaN
75%            NaN      2.5    NaN
max            NaN      3.0    NaN

groupby([by, axis, level, as_index, sort, …])

此方法用于数组聚合,有点类似于数据库中的groupby

>>> data.groupby(func, axis=0).mean()
>>> data.groupby(['col1', 'col2'])['col3'].mean()
>>> data.groupby(['col1', 'col2']).mean()

 

 

还有很多功能强大的方法这里就不一一介绍了,可以参考: http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.html