Python 数据分析基础包Numpy.docx
《Python 数据分析基础包Numpy.docx》由会员分享，可在线阅读，更多相关《Python 数据分析基础包Numpy.docx（15页珍藏版）》请在冰豆网上搜索。
Python数据分析基础包Numpy
Numpy的核心内容是它的多维数组对象——ndarray（N-DimensionsArray），整个包几乎都是围绕这个对象展开。
Numpy本身并没有提供多么高级的数据结构和分析功能，但它是很多高级工具（如pandas）构建的基础，在结构和操作上具有统一性，因此理解Numpy的数组及面向数组的计算有助于更加高效地使用诸如pandas之类的工具。
数据结构
Numpy的ndarray提供了一种将同质数据块解释为多维数组对象的方式。
同质，表示数组的元素必须都是相同的数据类型（如int，float等）；解释，表示ndarray的数据块其实是线性存储的，并通过额外的元信息解释为多维数组结构：
下面是一个3×4的矩阵：
（使用类似 3×4×2... 这种格式表示多维数组的结构时，从左向右的数字对应表示由表及里的维度，或称为轴，按索引给轴编号后可称为“轴0”、“轴1”等）
>>>foo
array（[[0,1,2,3],
[4,5,6,7],
[8,9,10,11]]）
>>>foo.dtype
dtype（'int32'）
>>>foo.shape
（3,4）
>>>foo.strides
（16,4）
这个矩阵的形状（shape）是（3,4）或3×4，即它有3个长度为4的一维数组；它的 dtype 是 int32 表示它的单位元素是占4字节的整型；跨度（strides）元组指的是在某一维度下为了获取到下一个元素需要“跨过”的字节数。
可见跨度是可以由形状+dtype来确定的。
显然这种同质的静态数据结构在进行数值运算时效率要比Python内建的可以混杂动态类型的列表要快得多。
dtype支持的数字类型有：
######################
***********************************
bool_
占一个字节的布尔类型（True/False）
int_
默认的整数类型
intc
与Cint相同，通常为int32或int64
intp
用于索引的整数（同Cssize_t，int32或int64）
int8、16、32、64
不同位数的整数
uint8、16、32、64
不同位数的无符号整数
float_
float64
float16、32、64
不同位数的浮点数
complex_
complex128
complex64、128
不同位数的复数
上表中加粗的 bool_,int_,float_,complex_ 都与Python的内建类型 bool,int,float,complex 相同，实际上使用Python的类型名称（int,float等）也是合法的。
intc,intp 的大小不定是取决于操作系统。
创建ndarray
创建数组最简单的方法是使用 array（） 函数：
（numpy的公约简称为np—— importnumpyasnp）
array（object,dtype=None,copy=True,order=None,subok=False,ndmin=0）
它接受一切序列类型对象，并将其转化为一个ndarray数组，维度视序列的嵌套深度而定：
>>>np.array（[1,2,3,4]）
array（[1,2,3,4]）
>>>np.array（[[1,2],[3,4]]）
array（[[1,2],
[3,4]]）
数组的dtype会由系统自动推定，除非你显式传递一个参数进去。
（系统一般会默认使用int32或float64）
除 array（） 函数外，还有一些可以用于创建数组的便捷函数：
#####################
*************************************************
asarray
将输入转换为ndarray，若输入本身是ndarray就不复制
arange
类似于内建range函数，不过返回的是一个一维ndarray
ones、ones_like
根据指定形状和dtype创建一个全1数组
zeros、zeros_like
根据指定形状和dtype创建一个全0数组
empty、empty_like
创建新数组，但只分配内存空间不赋值
eye、identity
创建一个正方的N×N单位矩阵（对角线为1，其余为0）
ones（shape,dtype=None,order='C'） 和 ones_like（arr_instance,dtype=None,order='K',subok=True）使用示例，zeros_like 取一个ndarray为参数，并按它的dtype和形状创建全0数组：
>>>foo=np.ones（（3,4）,dtype=np.int32）
>>>foo
array（[[1,1,1,1],
[1,1,1,1],
[1,1,1,1]]）
>>>bar=np.zeros_like（foo）
>>>bar
array（[[0,0,0,0],
[0,0,0,0],
[0,0,0,0]]）
参数中的 order='C'，order='F' 指的是元素在内存中的排序，C代表C顺序，指行优先；F代表Fortran顺序，指列优先。
在pandas中尽量不要使用 np.empty（），这个函数创建的数组里面是有值的，除非你确定创建的这个数组能被完全赋值，否则后面运算起来很麻烦，这些“空值”的布尔类型是True，而且 dropna（） 方法删不掉。
想创建空的Series，可以使用 Series（np.nan,index=?
?
?
） 这样。
ndarray对象的属性
.reshape（shape）
此方法用于改变数组的形状。
虽然我觉得既然ndarray对象的数据块都是线性存储的，按说调用 .reshape（） 方法的话只需要改一下数据头中的shape属性就可以了啊，但实际上不是这样子的！
a.reshape（shape,order='C'） 方法会返回一个新数组，而不是直接改变调用者的形状。
>>>foo=np.arange（9）
>>>bar=foo.reshape（（3,3））
>>>bar
array（[[0,1,2],
[3,4,5],
[6,7,8]]）
>>>foo
array（[0,1,2,3,4,5,6,7,8]）
.astype（dtype）
这是一个用于转换数组dtype的方法，从前面的ndarray数据结构可以猜到，这种转换必然需要创建一个新数组。
如果转换过程因为某种原因而失败了，就会引发一个TypeError异常。
另外，如 np.int32（） 这样把dtype当做函数来用也是可行的，但更推荐 .astype（） 方法：
>>>bar.astype（float）
array（[[0.,1.,2.],
[3.,4.,5.],
[6.,7.,8.]]）
本例中使用Python内建的 float 当做dtype传了进去，也是可行的哦，当对数据大小不敏感时就可以这么做。
.transpose（*axes）
转置方法返回的是原数组的视图（不复制）。
因为我对多维数组也搞不太懂，就只举个二维数组的例子吧（不给axes参数）：
>>>foo=np.arange（8）.reshape（2,4）
>>>foo
array（[[0,1,2,3],
[4,5,6,7]]）
>>>foo.transpose（）
array（[[0,4],
[1,5],
[2,6],
[3,7]]）
>>>foo.T
array（[[0,4],
[1,5],
[2,6],
[3,7]]）
数组的 .T 属性是轴对换的快捷方式。
一般在计算矩阵点积时比较方便：
np.dot（arr,att.T）。
嗯，简单的乘法（星号）是广播运算，点积需要使用 dot（） 函数。
.sort（）
ndarray的 .sort（axis=-1,kind='quicksort',order=None） 方法可用于给数组在指定轴向上排序。
比如一个（4，3，2）的数组，它的对应轴向分别为（2，1，0），方法默认的 axis=-1 代表最外层维度，如“表”里的“行”。
>>>a=np.array（[[1,4],[3,1]]）
>>>a
array（[[1,4],
[3,1]]）
>>>np.sort（a,0）
array（[[1,1],
[3,4]]）
>>>np.sort（a,1）
array（[[1,4],
[1,3]]）
这里使用了外部函数 np.sort（） 是为了在演示过程中不会影响到原数组。
np.sort（） 函数总是返回一份拷贝，而 .sort（） 方法则会更改原数组。
统计方法
ndarray对象还有一些统计方法，可以对整个数组或某个轴向上的数据进行统计计算（轴向数字越大代表的维度越高，从0开始计数）。
这些方法同时也可以当做顶级函数使用。
例如：
>>>arr=np.arange（12）.reshape（3,4）
>>>arr
array（[[0,1,2,3],
[4,5,6,7],
[8,9,10,11]]）
>>>arr.sum（）
66
>>>np.sum（arr）
66
>>>arr.mean（0）
array（[4.,5.,6.,7.]）
>>>arr.mean
（1）
array（[1.5,5.5,9.5]）
>>>arr.mean
（2）
Traceback（mostrecentcalllast）:
File"",line1,in
arr.mean
（2）
items*=arr.shape[ax]
IndexError:
tupleindexoutofrange
基本的数组统计方法有：
#####################
*************************************************
sum
求和
mean
均值
std，var
标准差和方差
min，max
最小值和最大值
argmin，argmax
最小值和最大值的索引
cumsum
累积和
cumprod
累积积
用于布尔型数组的方法
有两个方法 .any（） 和 .all（） 可以用于判断某个数组中是否存在或全部为 True。
这两个方法也同样支持axis轴向参数：
>>>arr=np.arange（12）.reshape（3,4）
>>>arr
array（[[0,1,2,3],
[4,5,6,7],
[8,9,10,11]]）
>>>arr.all
（1）
array（[False,True,True],dtype=bool）
>>>arr.any（）
True
数组之间的运算
形状相同的数组之间的运算都会应用到元素级：
lang：
python
>>>foo=np.arange（6）.reshape（（2,3））
>>>bar=np.arange（5,-1,-1）.reshape（（2,3））
>>>bar
array（[[5,4,3],
[2,1,0]]）
>>>foo
array（[[0,1,2],
[3,4,5]]）
>>>foo+bar
array（[[5,5,5],
[5,5,5]]）
>>>foo*bar
array（[[0,4,6],
[6,4,0]]）
真正的问题在于不同大小的数组间运算时会发生什么。
广播（broadcasting）指的是不同形状的数组之间的算数运算的执行方式，这也是Numpy的核心内容之一。
广播遵循的原则为：
如果两个数组的后缘维度（trailingdimension，即从末尾开始算起的维度）的轴长度相符或其中一方的长度为1，则认为它们是广播兼容的。
广播会在缺失和（或）长度为1的维度上进行。
嗯，反正我是没看明白╮（╯▽╰）╭。
自己的理解是，系统会在可能的条件下把形状不同的数组补完成相同的形状，例：
>>>foo=np.arange（5）
>>>foo
array（[0,1,2,3,4]）
>>>foo*5
array（[0,5,10,15,20]）
这里系统就会自动把 5 补完成 array（[5,5,5,5,5]）。
索引和切片
ndarray的索引和切片语法与Python的列表相似。
都是通过如 [0]，[0:
5:
2] 这样的方括号+冒号来完成。
比较不同之处在于为了方便对多维数组切片，ndarray对象还支持使用逗号间隔的多维切片方法：
[0,3]，[0,3:
9:
2]。
普通索引
>>>foo=np.arange（12）
>>>foo
array（[0,1,2,3,4,5,6,7,8,9,10,11]）
>>>foo[:
5]
array（[0,1,2,3,4]）
>>>foo[:
5]=0
>>>foo
array（[0,0,0,0,0,5,6,7,8,9,10,11]）
>>>bar=foo[:
5]
>>>bar[0]=1024
>>>foo
array（[1024,0,0,0,0,5,6,7,8,9,10,11]）
注意这里，为了节省内存，对ndarray的切片操作获得的都是对原数组的引用，因此对该引用的更改操作都会反映到原数组上。
如果你想复制出一段副本，就应当使用 .copy（） 方法：
>>>bar=foo[:
5].copy（）
>>>bar[:
]=1
>>>foo
array（[1024,0,0,0,0,5,6,7,8,9,10,11]）
也许你会对这里的 foo[:
] 感兴趣，这代表切全部的片，不可以使用 foo=1 这样的赋值语句，这等于给 foo 重新指向一个新的内存地址，而非对切片元素进行操作。
前面提到的使用逗号在多维度下的切片方法：
>>>foo=np.arange（12）.reshape（3,4）
>>>foo
array（[[0,1,2,3],
[4,5,6,7],
[8,9,10,11]]）
>>>foo[0,1]
1
>>>foo[0,:
:
2]
array（[0,2]）
这种切片方法可以看做是一种语法糖，因为最标准的对多维数组的切片方法应该是下面这样子的，包括Python原本对嵌套列表的切片方法也是这样子的：
>>>foo
array（[[0,1,2,3],
[4,5,6,7],
[8,9,10,11]]）
>>>foo[0][1]
1
>>>foo[0][:
:
2]
array（[0,2]）
即 foo[0,1] 与 foo[0][1] 效果相同，这种实现可以节省时间，但不如原始方法更直观一点。
只要记住对多维数组的单层切片总是切的最外层维度这点，操作起来就不容易乱。
布尔型索引
布尔型索引指的是使用一个布尔型数组而非 [:
:
] 作为切片手段，操作会将被切片对象中对应于布尔型数组中 True 元素位置的元素返回，并总是返回一个新的副本。
>>>foo=np.arange（12）.reshape（3,4）
>>>bar=foo.copy（）
>>>bar%2==0
array（[[True,False,True,False],
[True,False,True,False],
[True,False,True,False]],dtype=bool）
>>>foo[bar%2==0]
array（[0,2,4,6,8,10]）
本例中一个值得注意之处在于 bar%2==0 这个表达式，在Python的标准语法中对一个列表和一个整型应用取余操作是非法的，你必须使用循环（如for）遍历列表的单个元素才行。
但numpy很贴心地通过广播解决了这个问题，吊不吊！
花式索引
花式索引（fancyindexing）是一个Numpy术语，它指的是利用整数数组进行索引，这里的整数数组起到了index的作用。
>>>foo=np.empty（（8,4）,int）
>>>foriinrange（8）:
foo[i]=i
>>>foo
array（[[0,0,0,0],
[1,1,1,1],
[2,2,2,2],
[3,3,3,3],
[4,4,4,4],
[5,5,5,5],
[6,6,6,6],
[7,7,7,7]]）
>>>foo[[7,2,5]]
array（[[7,7,7,7],
[2,2,2,2],
[5,5,5,5]]）
>>>foo[[7,2,5],[0,2,2]]
array（[7,2,5]）
上例中 foo[[7,2,5],[0,2,2]] 处两个列表索引之间的逗号，所起的作用与上面普通索引处的作用相同，均为在更低一级维度上索引之用。
通用函数
通用函数（即ufunc）是一种对ndarray执行元素级运算的函数。
通用函数依据参数的数量不同，可分为一元（unary）函数和二元（binary）函数。
（参数一般都是ndarray对象）
一元函数
abs，fabs
整数、浮点、复数的绝对值，对于非复数，可用更快的fabs
sqrt
平方根，等于arr**0.5
square
平方，等于arr**2
exp
以e为底的指数函数
log，log10，log2，log1p
以e为底的对数函数
sign
计算各元素的正负号，1（正），0（零），-1（负）
ceil
计算大于等于该值的最小整数
floor
计算小于等于该值的最大整数
rint
roundint，四舍五入到整数
modf
将数组的整数和小数部分以两个独立数组的形式返回
isnan
返回一个“哪些值是NaN”的布尔型数组
isfinite，isinf
返回是否是有穷（无穷）的布尔型数组
cos，cosh，sin，sinh，tan，tanh
普通和双曲型三角函数
arccos，arccosh...等同上
反三角函数
logical_not
计算个元素notx的真值，等于-arr
unique
计算元素唯一值并返回排序后的结果
二元函数
add
加法，+
subtract
减法，-
multiply
乘法，*
divide，floor_divide
除法和地板除，/和//
power
乘方，**
maximum，fmax
元素级最大值，fmax将忽略NaN
minimum，fmin
同上
mod
取模，%
copysign
将第二数组元素的符号复制给第一数组
greater（_equal），less（_equal），（not_）equal
字面意义，返回布尔数组
logical_and，logical_or，logical_xor
字面意义，返回布尔数组
三元函数
这里的三元函数只有一个，而且不是接受3个数组参数的意思。
它其实是一个条件运算函数，即 fooifcondelsebar这个表达式的numpy版——where（condition,[x,y]）
>>>arr=np.arange（12）.reshape（3,4）
>>>arr
array（[[0,1,2,3],
[4,5,6,7],
[8,9,10,11]]）
>>>np.where（arr%2==0,1,0）
array（[[1,0,1,0],
[1,0,1,0],
[1,0,1,0]]）
升级会员 