Python数据分析之NumPy和Pandas

Python的强大数据处理能力，是依靠其强大的模块库来支持的；以下就介绍一下常用的NumPy与Pandas库（详细说明参见https://www.scipy.org/docs.html）。

NumPy库

NumPy是一个高性能科学计算和数据分析基础包，同时也是其他数据分析模块（如SciPy与Pandas）的基础；其核心功能是高维数组ndarray：

数组对象本身具有大小固定、元素数据类型相同等特性；

提供了大量数值运算函数，以有效地进行向量、矩阵运算；

数组生成：

数组创建：np.array(ary_like, dtype=None, copy=True, order='K', subok=False, ndmin=0)

ary_like：为一个序列（元组、列表等），用于生成新的ndarray；

np.asarray(a, dtype=None, order=None)：以copy方式生成数组；

一维有序数组：np.arange([start,]stop, [step,]dtype=None)

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)：指定范围内指定个数的数据（尽量均匀）；

全零数组：np.zeros(shape, dtype=float, order='C')

全1数组：np.ones(shape, dtype=float, order='C')

未初始化数组：np.empty(shape, dtype=float, order='C')

zero_like/ones_like/empty_like(a, dtype=None, order='K', subok=True)：创建与a（ndarray）维数、类型相同的数组；

指定元素填充：np.full(shape, fill_value, dtype=None, order='C')

np.eye(N)/np.identity(N)：创建N*N的矩阵；

np.where(cond,ary1,ary2)：根据cond返回ary1或ary2中对应值；

np.in1d(ar1, ar2, assume_unique=False, invert=False)：判断ary1中每一个元素是否在ary2中（返回一个True、False数组）；

np.full(2, 5)

array([5, 5])

np.full((2,3), 8)

array([[8, 8, 8],

[8, 8, 8]])

重要属性：

ary.ndim：返回数组的维数；

ary.shape：以元组表示的各维度大小，如(2,3)；

ary.size：元素个数（shape中各值乘积）；

ary.dtype：元素类型；

ary.itemsize：元素所占字节大小（类型大小）；

修改维数：

ary.shape=(...)：重新赋值各维度；

ary.resize(dim1, ...dimNn)：与重赋值shape同；

ary.reshape(dim1, ...dimNn)：返回新数组，原数组不变；

ndarry函数：

ary.astype(dType)：转换元素类型，以新数组（copy）形式返回；

mean：求均值

sum：求和

cumsum：累加；

cumprod：累乘；

std：标准差；

var：方差(std*std)；

max/min：最大最小值；

argmax/argmin：最大值、最小值的索引；

any：至少一个元素为True则返回True；

all：所有元素为True则返回True；

dot(ary2)：计算矩阵内积；

ary=array([1, 2, 3, 4])

ary.cumprod() #array([ 1, 2, 6, 24], dtype=int32)

ary.cumsum() 3array([ 1, 3, 6, 10], dtype=int32)

矩阵函数：

np.diag(d)：以一维数组形式返回方阵的对角线元素；

np.diag([e1, ...en])：将一维数组作为对角线元素（其他元素为0），构造方阵；

np.dot(d1,d2)：点乘；

np.trace(d)：计算对角线元素和；

排序函数：

sort(a, axis=-1, kind='quicksort', order=None)：返回排序后副本；

unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None)：去重并排序；

return_index：返回一个指示每个元素在原序列中的位置序列；

return_inverse：返回一个构造原序列的序列（标识出原序列每个元素在返回序列中的位置）

return_counts：返回每个元素在原序列中重复数；

intersect1d(ar1, ar2, assume_unique=False, return_indices=False)：交集（去重排序）；

union1d(ar1, ar2)：并集（去重排序）；

setdiff1d(ar1, ar2, assume_unique=False)：差（1-2，去重排序）；

setxor1d(ar1, ar2, assume_unique=False)：对称差（去重排序）；

ary=[8,8,8,6,6,5,3,3,3,3]

np.unique(ary,True,True,True)

(array([3, 5, 6, 8]), #out

array([6, 5, 3, 0], dtype=int64), #out中元素在ary中位置

array([3, 3, 3, 2, 2, 1, 0, 0, 0, 0], dtype=int64), #ary中元素在out中位置

array([4, 1, 2, 3], dtype=int64)) #元素的count

文件读写：

save(file, arr, allow_pickle=True, fix_imports=True)：保存数组到文件.npy；savez(...)将多个数组保存到文件.npz；

savetxt(fname, ary, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ', encoding=None)：保存数组到文本文件（若扩展名为.gz，则自动使用gzip压缩）；

load(file, mmap_mode=None, allow_pickle=True, fix_imports=True, encoding='ASCII')：读取npy或npz文件；

loadtxt(fname, dtype=, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes')：读取文本文件到数组；

linalg模块：包含线性代数的函数，可计算逆矩阵、求特征值、解线性方程及行列式：

m=np.mat('1 2 ; 3 4')

# matrix([[1, 2],

[3, 4]])

b=np.array([7,8])

# array([-6. , 6.5])

pandas

pandas 是基于NumPy的，为解决数据分析任务而创建的一种工具。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。

两种主要数据类型：series与dataframe

Series是一维数据结构，类似于列表和Numpy中的ndarray，不同之处在于：Series能存储不同类型的数据，每一个元素都有一个标签。Series实际上是由两个数组组成，因此有两大属性：

index：保存标签信息（从Numpy数组继承的Index对象）

values：保存值，是一维Numpy数组对象；

DataFrame是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。和其他类似的数据结构相比，DataFrame中面向行和面向列的操作基本上是平衡的。

既有行索引也有列索引，它可以被看做由Series组成的字典；

可通过类似字典的方式或者.columnname的方式将列获取为一个Series。行也可以通过位置或名称的方式进行获取。

基本函数

pd.isnull(ser)：判断是否为空（NaN）；

pd.notnull(ser)

Series相关

创建pd.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)

data：可以是array-like, dict or scalar值；

index：array-like or index(1d)

如：pd.Series({'a':1, 'b':'c', 'c':1.2})

Series属性（融合了字典和ndarray的优点，可以运用ndarray或字典的几乎所有索引操作和函数：

values：获取数组（值）；

index：获取索引；

name：values的名称；

index.name：索引的名称；

提取元素：

sr.head(n=5)

sr.tail(n=5)

sr.take(indices, axis=0, convert=None, is_copy=True, **kwargs)

indices : array-like，An array of ints indicating which positions to take.

axis : , default 0，The axis on which to select elements. 0 means that we are selecting rows, 1 means that we are selecting columns.

相关函数：

reindex(index=None, **kwargs)：对序列重新索引；

drop(index)：丢弃指定项；

map(fun)：对元素应用fun；

sort_values(axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')：排序

rank(axis=0, method='average', numeric_only=None, na_option='keep', ascending=True, pct=False)：分级排列；

method : {‘average’, ‘min’, ‘max’, ‘first’, ‘dense’}

average: average rank of group

min: lowest rank in group

max: highest rank in group

first: ranks assigned in order they appear in the array

dense: like ‘min’, but rank always increases by 1 between groups

DataFrame相关

创建pd.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)

data：可以是numpy ndarray, dict or dataframe；

index：array-like or index

columns：array-like or index，指定列名；

横向合并（增加列）concat

纵向合并（增加行）append

填充缺失值：

df.fillna(value=None, method=None, axis=None, inplace=False, limit=None)

value：在缺失值处填充的值；

method：填充方式

ffile/pad：用行或列的上一个观测值填充缺失值；

bfill/backfill：用行或列的下一个观测值填充缺失值；

axis：与method配合使用，=1行方向，=0列方向；

limit：默认会填充连续的缺失值；若指定，则只会填充连续指定个数的缺失值；

inplace：默认不改变原来的值，True在原来df上修改；

删除缺失值：

df.dropna(axis=0, how='any', thresh=None)

axis：=0删除包含缺失值的行，=1删除包含缺失值的列；

how：='any'只要有一个缺失值就删除，='all'只有全为缺失值才删除；

thresh：大于等于指定数量缺失值时才删（=3，有三个或以上缺失值的行/列才会被删除）

df属性：

values：值；

index：行索引；

index.name：行索引名字；

columns：列索引；

columns.name：列索引名字；

ix[[x,y..],[x,y...]]：广义索引与切片。

df.iloc[row_indexer,column_indexer]：位置索引与切片，df.iloc[[1,4],[2,3]]， df.iloc[1:4,2:3]

行切片df[start:end]

列df['A']或df[['A','C' ...]]

相排序函数

reindex(labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill_value=nan, limit=None, tolerance=None)：

labels：array-like，new labels/index to conform the axis；

index, columns：array-like，new index to conform to；

axis：name（'index', 'columns'）or number（0,1）

method：{'backfill'/'bfill', 'pad'/'ffill', 'nearest'}

sort_index(axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, by=None)：根据索引排序

sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')：根据值排序

df.sort_values(by=['col1', 'col2'])：根据1、2列值排序

汇总、统计函数

count：非NaN的数量；

describe：输出count、mean、std、min、max，25/50/75分位数；

min、max；

idxmax、idxmin：含有最大值/最小值的index的series；

quantile：分位数；

sum、mean：求和、均值；

median：中位数；

mad：平均绝对离差；

var：方差

skew：偏度；

kurt：峰度；

cumsum：累计和

cummin、cummax：累计最大最小值；

cumprod：累计积；

diff：差分

pct_change：百分比变化；

索引对象Index：

构建Series或DataFrame时，所有用到的任何数组或其他序列的标签都会被转换成一个Index。Index对象不可修改，从而可在多个数据结构间共享。

主要Index对象：

Index：最常用的Index对象，为一个Numpy数组；

Int64Index：64位整数的Index；

MultiIndex：‘层次化’索引对象，表示单个轴上的多层索引（可看作由元组组成的数组）；

DatetimeIndex：纳秒级的时间戳；可接受str与datetime类型数据；

PeriodIndex：时间间隔的Index；

通过其 .asfreq(freq, method=None, how=None) 方法被转换成别的频率；

以时间戳和以时期为 index 的 Series 和 DataFrame 都有一对 .to_period() 和 to_timestamp(how='start') 方法用于互相转换 index 的类型。

pandas 对象都含有一个.resample(freq, how=None, axis=0, fill_method=None, closed=None, label=None, convention='start', kind=None, loffset=None, limit=None, base=0) 将时间序列从一个频率转换到另一个频率的过程。