数据分析之numpy

一、NumPy Ndarray 对象

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。

ndarray 对象是用于存放同类型元素的多维数组。

ndarray 中的每个元素在内存中都有相同存储大小的区域。

ndarray 内部由以下内容组成：

• 一个指向数据（内存或内存映射文件中的一块数据）的指针。

• 数据类型或 dtype，描述在数组中的固定大小值的格子。

• 一个表示数组形状（shape）的元组，表示各维度大小的元组。

• 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
"""
object    数组或嵌套的数列
dtype    数组元素的数据类型，可选
copy    对象是否需要复制，可选
order    创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok    默认返回一个与基类类型一致的数组
ndmin    指定生成数组的最小维度
"""

二、Numpy数据类型

numpy 支持的数据类型比 Python 内置的类型要多很多，基本上可以和 C 语言的数据类型对应上，其中部分类型对应为 Python 内置的类型。

bool_    布尔型数据类型（True 或者 False）
int_    默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
intc    与 C 的 int 类型一样，一般是 int32 或 int 64
intp    用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
int8    字节（-128 to 127）
int16    整数（-32768 to 32767）
int32    整数（-2147483648 to 2147483647）
int64    整数（-9223372036854775808 to 9223372036854775807）
uint8    无符号整数（0 to 255）
uint16    无符号整数（0 to 65535）
uint32    无符号整数（0 to 4294967295）
uint64    无符号整数（0 to 18446744073709551615）
float_    float64 类型的简写
float16    半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32    单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64    双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_    complex128 类型的简写，即 128 位复数
complex64    复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128    复数，表示双 64 位浮点数（实数部分和虚数部分）

三、Numpy数组属性

NumPy 数组的维数称为秩（rank），一维数组的秩为 1，二维数组的秩为 2，以此类推。

在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴（axis），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。

ndarray.ndim    秩，即轴的数量或维度的数量
ndarray.shape    数组的维度，对于矩阵，n 行 m 列
ndarray.size    数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype    ndarray 对象的元素类型
ndarray.itemsize    ndarray 对象中每个元素的大小，以字节为单位
ndarray.flags    ndarray 对象的内存信息
ndarray.real    ndarray元素的实部
ndarray.imag    ndarray 元素的虚部
ndarray.data    包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

四、数组的创建

numpy.empty(shape, dtype = float, order = 'C')
shape    数组形状
dtype    数据类型，可选
order    有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

numpy.zeros(shape, dtype = float, order = 'C')
shape    数组形状
dtype    数据类型，可选
order    'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组

numpy.ones(shape, dtype = None, order = 'C')
shape    数组形状
dtype    数据类型，可选
order    'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组

从已有的数组创建数组：

numpy.asarray(a, dtype = None, order = None)
a    任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组
dtype    数据类型，可选
order    可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

numpy.frombuffer 用于实现动态数组。
numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
buffer    可以是任意对象，会以流的形式读入。
dtype    返回数组的数据类型，可选
count    读取的数据数量，默认为-1，读取所有数据。
offset    读取的起始位置，默认为0。

numpy.fromiter(iterable, dtype, count=-1)
iterable    可迭代对象
dtype    返回数组的数据类型
count    读取的数据数量，默认为-1，读取所有数据

从数值范围创建数组：

创建数值范围并返回 ndarray 对象

numpy.arange(start, stop, step, dtype)
start    起始值，默认为0
stop    终止值（不包含）
step    步长，默认为1
dtype    返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

创建一个一维数组，数组是一个等差数列构成的
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
start    序列的起始值
stop    序列的终止值，如果endpoint为true，该值包含于数列中
num    要生成的等步长的样本数量，默认为50
endpoint    该值为 ture 时，数列中中包含stop值，反之不包含，默认是True。
retstep    如果为 True 时，生成的数组中会显示间距，反之不显示。
dtype    ndarray 的数据类型

用于创建一个于等比数列

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
start    序列的起始值为：base ** start
stop    序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中
num    要生成的等步长的样本数量，默认为50
endpoint    该值为 ture 时，数列中中包含stop值，反之不包含，默认是True。
base    对数 log 的底数。
dtype    ndarray 的数据类型

五、Numpy数组的切片与索引

ndarray对象的内容可以通过索引或切片来访问和修改，与 list 的切片操作一样。

高级索引：

import numpy as np 
 
x = np.array([[1,  2],  [3,  4],  [5,  6]]) 
y = x[[0,1,2],  [0,1,0]]  
print (y)



[1  4  5]

布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。

import numpy as np 
 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print ('我们的数组是：')
print (x)
print ('\n')
# 现在我们会打印出大于 5 的元素  
print  ('大于 5 的元素是：')
print (x[x >  5])

我们的数组是：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]


大于 5 的元素是：
[ 6  7  8  9 10 11]

花式索引指的是利用整数数组进行索引。
花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素；如果目标是二维数组，那么就是对应下标的行。

import numpy as np 
 
x=np.arange(32).reshape((8,4))
print (x[[4,2,1,7]])

[[16 17 18 19]
 [ 8  9 10 11]
 [ 4  5  6  7]
 [28 29 30 31]]

六、NumPy 广播

广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。

广播的规则:

• 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
• 输出数组的形状是输入数组形状的各个维度上的最大值。
• 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
• 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。

简单理解：对两个数组，分别比较他们的每一个维度（若其中一个数组没有当前维度则忽略），满足：

• 数组拥有相同形状。
• 当前维度的值相等。
• 当前维度的值有一个是 1。

若条件不满足，抛出 "ValueError: frames are not aligned" 异常。

七、NumPy 迭代数组

np.nditer(ndarray，order， op_flags， flags)　　将ndarray对象转换为迭代器

c_index    可以跟踪 C 顺序的索引
f_index    可以跟踪 Fortran 顺序的索引
multi-index    每次迭代可以跟踪一种索引类型
external_loop    给出的值是具有多个值的一维数组，而不是零维数组

广播迭代，如果两个数组是可广播的，nditer 组合对象能够同时迭代它们。

八、Numpy数组操作

numpy.reshape(arr, newshape, order='C')
arr：要修改形状的数组
newshape：整数或者整数数组，新的形状应当兼容原有形状
order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序。


numpy.ndarray.flat   一个数组元素迭代器


numpy.ndarray.flatten    返回一份数组拷贝，对拷贝所做的修改不会影响原始数组


numpy.ravel
展平的数组元素，顺序通常是"C风格"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。

用于对换数组的维度
numpy.transpose(arr, axes)
arr：要操作的数组
axes：整数列表，对应维度，通常所有维度都会对换。


向后滚动特定的轴到一个特定位置
numpy.rollaxis(arr, axis, start)
arr：数组
axis：要向后滚动的轴，其它轴的相对位置不会改变
start：默认为零，表示完整的滚动。会滚动到特定位置。    


用于交换数组的两个轴
numpy.swapaxes(arr, axis1, axis2)
arr：输入的数组
axis1：对应第一个轴的整数
axis2：对应第二个轴的整数

numpy.broadcast                模仿广播的对象，它返回一个对象，该对象封装了将一个数组广播到另一个数组的结果。


numpy.broadcast_to            numpy.broadcast_to 函数将数组广播到新形状。它在原始数组上返回只读视图。 它通常不连续。 如果新形状不符合 NumPy 的广播规则，该函数可能会抛出ValueError。


numpy.expand_dims             通过在指定位置插入新的轴来扩展数组形状


numpy.squeeze                   从给定数组的形状中删除一维的条目

用于沿指定轴连接相同形状的两个或多个数组
numpy.concatenate((a1, a2, ...), axis)
a1, a2, ...：相同类型的数组
axis：沿着它连接数组的轴，默认为 0


用于沿新轴连接数组序列
numpy.stack(arrays, axis)
arrays相同形状的数组序列
axis：返回数组中的轴，输入数组沿着它来堆叠


numpy.hstack       numpy.stack 函数的变体，它通过水平堆叠来生成数组。      
numpy.vstack       numpy.stack 函数的变体，它通过垂直堆叠来生成数组。

沿特定的轴将数组分割为子数组
numpy.split(ary, indices_or_sections, axis)
ary：被分割的数组
indices_or_sections：果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
axis：沿着哪个维度进行切向，默认为0，横向切分。为1时，纵向切分

numpy.hsplit        用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。
numpy.vsplit        沿着垂直轴分割，其分割方式与hsplit用法相同。

返回指定大小的新数组。
numpy.resize(arr, shape)
arr：要修改大小的数组
shape：返回数组的新形状



函数在数组的末尾添加值。 追加操作会分配整个数组，并把原来的数组复制到新数组中。 此外，输入数组的维度必须匹配否则将生成ValueError。
numpy.append(arr, values, axis=None)
arr：输入数组
values：要向arr添加的值，需要和arr形状相同（除了要添加的轴）
axis：默认为 None。当axis无定义时，是横向加成，返回总是为一维数组！当axis有定义的时候，分别为0和1的时候。当axis有定义的时候，分别为0和1的时候（列数要相同）。当axis为1时，数组是加在右边（行数要相同）。



给定索引之前，沿给定轴在输入数组中插入值。
numpy.insert(arr, obj, values, axis)
arr：输入数组
obj：在其之前插入值的索引
values：要插入的值
axis：沿着它插入的轴，如果未提供，则输入数组会被展开



返回从输入数组中删除指定子数组的新数组。 
Numpy.delete(arr, obj, axis)
arr：输入数组
obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开



用于去除数组中的重复元素
numpy.unique(arr, return_index, return_inverse, return_counts)
arr：输入数组，如果不是一维数组则会展开
return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数

九、Numpy位运算

bitwise_and    对数组元素执行位与操作
bitwise_or    对数组元素执行位或操作
invert    按位取反
left_shift    向左移动二进制表示的位
right_shift    向右移动二进制表示的位

十、Numpy字符串处理

与python str类型类似

add()    对两个数组的逐个字符串元素进行连接
multiply()    返回按元素多重连接后的字符串
center()    居中字符串
capitalize()    将字符串第一个字母转换为大写
title()    将字符串的每个单词的第一个字母转换为大写
lower()    数组元素转换为小写
upper()    数组元素转换为大写
split()    指定分隔符对字符串进行分割，并返回数组列表
splitlines()    返回元素中的行列表，以换行符分割
strip()    移除元素开头或者结尾处的特定字符
join()    通过指定分隔符来连接数组中的元素
replace()    使用新字符串替换字符串中的所有子字符串
decode()    数组元素依次调用str.decode
encode()    数组元素依次调用str.encode

十一、Numpy计算类函数

数学函数：

NumPy 提供了标准的三角函数：sin()、cos()、tan()。

可以通过 numpy.degrees() 函数将弧度转换为角度。

numpy.around() 函数返回指定数字的四舍五入值。

numpy.floor() 返回数字的下舍整数。

numpy.ceil() 返回数字的上入整数。

算数函数：

NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。

numpy.reciprocal() 函数返回参数逐元素的倒数。

numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。

numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。

统计函数：

numpy.amin() 用于计算数组中的元素沿指定轴的最小值。

numpy.amax() 用于计算数组中的元素沿指定轴的最大值。

numpy.ptp() 函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。

numpy.percentile() 百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。

numpy.percentile(a, q, axis)
a: 输入数组
q: 要计算的百分位数，在 0 ~ 100 之间
axis: 沿着它计算百分位数的轴
第 p 个百分位数是这样一个值，它使得至少有 p% 的数据项小于或等于这个值，且至少有 (100-p)% 的数据项大于或等于这个值。



import numpy as np 
 
a = np.array([[10, 7, 4], [3, 2, 1]])
print ('我们的数组是：')
print (a)
 
print ('调用 percentile() 函数：')
# 50% 的分位数，就是 a 里排序之后的中位数
print (np.percentile(a, 50)) 
 
# axis 为 0，在纵列上求
print (np.percentile(a, 50, axis=0)) 
 
# axis 为 1，在横行上求
print (np.percentile(a, 50, axis=1)) 
 
# 保持维度不变
print (np.percentile(a, 50, axis=1, keepdims=True))



我们的数组是：
[[10  7  4]
 [ 3  2  1]]
调用 percentile() 函数：
3.5
[6.5 4.5 2.5]
[7. 2.]
[[7.]
 [2.]]

numpy.median() 函数用于计算数组 a 中元素的中位数（中值）

numpy.mean() 函数返回数组中元素的算术平均值。

numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。

np.std() 标准差是一组数据平均值分散程度的一种度量。

np.var() 方差

十二、Numpy排序与条件筛选

numpy.sort(a, axis, kind, order)
a: 要排序的数组
axis: 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序， axis=0 按列排序，axis=1 按行排序
kind: 默认为'quicksort'（快速排序）
order: 如果数组包含字段，则是要排序的字段

numpy.argsort() 函数返回的是数组值从小到大的索引值。

numpy.lexsort() 用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。

msort(a)    数组按第一个轴排序，返回排序后的数组副本。np.msort(a) 相等于 np.sort(a, axis=0)。
sort_complex(a)    对复数按照先实部后虚部的顺序进行排序。
partition(a, kth[, axis, kind, order])    指定一个数，对数组进行分区
argpartition(a, kth[, axis, kind, order])    可以通过关键字 kind 指定算法沿着指定轴对数组进行分区

numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引。

numpy.nonzero() 函数返回输入数组中非零元素的索引。

numpy.where() 函数返回输入数组中满足给定条件的元素的索引。

numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。

十三、Numpy字节交换

在几乎所有的机器上，多字节对象都被存储为连续的字节序列。字节顺序，是跨越多字节的程序对象的存储规则。

• 大端模式：指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；这和我们的阅读习惯一致。

• 小端模式：指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低。

例如在 C 语言中，一个类型为 int 的变量 x 地址为 0x100，那么其对应地址表达式&x的值为 0x100。且x的四个字节将被存储在存储器的 0x100, 0x101, 0x102, 0x103位置。

numpy.ndarray.byteswap() 函数将 ndarray 中每个元素中的字节进行大小端转换。

十四、副本与视图

副本是一个数据的完整的拷贝，如果我们对副本进行修改，它不会影响到原始数据，物理内存不在同一位置。

视图是数据的一个别称或引用，通过该别称或引用亦便可访问、操作原有数据，但原有数据不会产生拷贝。如果我们对视图进行修改，它会影响到原始数据，物理内存在同一位置。

视图一般发生在：

• 1、numpy 的切片操作返回原数据的视图。
• 2、调用 ndarray 的 view() 函数产生一个视图。

副本一般发生在：

• Python 序列的切片操作，调用deepCopy()函数。
• 调用 ndarray 的 copy() 函数产生一个副本。

十五、Numpy矩阵

函数返回一个新的矩阵
numpy.matlib.empty(shape, dtype, order)
shape: 定义新矩阵形状的整数或整数元组
Dtype: 可选，数据类型
order: C（行序优先） 或者 F（列序优先）

numpy.matlib.zeros() 函数创建一个以 0 填充的矩阵。

numpy.matlib.ones()函数创建一个以 1 填充的矩阵。

函数返回一个矩阵，对角线元素为 1，其他位置为零。
numpy.matlib.eye(n, M,k, dtype)
n: 返回矩阵的行数
M: 返回矩阵的列数，默认为 n
k: 对角线的索引
dtype: 数据类型    

numpy.matlib.identity() 函数返回给定大小的单位矩阵。

numpy.matlib.rand() 函数创建一个给定大小的矩阵，数据是随机填充的。

十六、Numpy线性代数

对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为内积)；对于二维数组，计算的是两个数组的矩阵乘积；对于多维数组，它的通用计算公式如下，即结果数组中的每个元素都是：数组a的最后一维上的所有元素与数组b的倒数第二位上的所有元素的乘积和： dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])。
numpy.dot(a, b, out=None) 
a : ndarray 数组
b : ndarray 数组
out : ndarray, 可选，用来保存dot()的计算结果

numpy.vdot() 函数是两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。

numpy.inner() 函数返回一维数组的向量内积。对于更高的维度，它返回最后一个轴上的和的乘积。

numpy.matmul 函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。

numpy.linalg.det() 函数计算输入矩阵的行列式。

numpy.linalg.solve() 函数给出了矩阵形式的线性方程的解。

numpy.linalg.inv() 函数计算矩阵的乘法逆矩阵。