Numpy 常用属性和方法

属性;

data.shape              #用来表征数组每个维度的数量。
data.dtype              #用来描述数组的类型
data.ndim               #用来查看数据的维度

方法:

.reshape(())

生成ndarray

np.array                  #将输入数据(列表,元组,数据以及其他序列)转换为ndarray,默认复制所有输入的数据
np.asarray                #将输入转换为ndarray.但如果输入已经是ndarray则不再复制
np.ones                   #根据给定形状和数据类型生成全1数组
np.ones_like              #根据给定的数组生成一个形状一样的全1数组
np.zeros                  #根据给定形状和数据类型生成全0数组
np.zeros_like             #根据给定的数组生成一个形状一样的全0数组
np.empty                  #根据给定形状生成一个没有初始化数值的空数组
np.empty_like             #根据所给数组生成一个形状一样但没有初始化数值的空数组
np.full                   #根据给定形状和数据类型生成指定数值的数组
np.full_like              #根据给定的数组生成一个形状一样但内容是指定数值的数组
np.eye                    #生成一个N*N的特征矩阵

数组的类型:

int           i1 i2 i4 i8
float         f2 f4 f8 f16
bool          ?
object        O
string        S

数组的类型转换:  data.astype(np.float64  /  data.dtype)

数组算术

标量计算:会将计算参数应用到数组中的每一个元素
同尺寸数组的比较运算 :产生一个bool数组

布尔索引

布尔数组的长度必须和数组轴索引长度一致
names = np.array(['Bob','Joe','Bob','Will','Will','Joe','Joe'])
data = np.random.randn(7,4)

names
array(['Bob', 'Joe', 'Bob', 'Will', 'Will', 'Joe', 'Joe'], dtype='<U4')
data
array([[ 0.12321991, -1.09632626, -0.30461838,  2.48481254],
   [ 0.9913972 ,  0.88999478, -0.47208552, -0.26930907],
   [-2.33000677, -0.1476485 , -0.59621164,  1.89350542],
   [-0.02867256,  0.23359139, -0.3729644 , -1.91841038],
   [ 0.80456444, -0.02035105,  1.38518404,  1.25534382],
   [-0.77081481, -0.75201718, -0.50267916, -0.4025687 ],
   [-1.34663732, -0.5083561 ,  1.0521195 ,  0.80214868]])
   
names == 'Bob'
array([ True, False,  True, False, False, False, False])	

data[names == 'Bob']
array([[ 0.12321991, -1.09632626, -0.30461838,  2.48481254],
   [-2.33000677, -0.1476485 , -0.59621164,  1.89350542]])
   
data[names == 'Bob',2]
array([-0.30461838, -0.59621164])

data[names == 'Bob',2:]
array([[-0.30461838,  2.48481254],
   [-0.59621164,  1.89350542]])
   
data[~(names == 'Bob')]      #使用  != 或者在条件表达式前加 ~ 对条件取反
array([[ 0.9913972 ,  0.88999478, -0.47208552, -0.26930907],
   [-0.02867256,  0.23359139, -0.3729644 , -1.91841038],
   [ 0.80456444, -0.02035105,  1.38518404,  1.25534382],
   [-0.77081481, -0.75201718, -0.50267916, -0.4025687 ],
   [-1.34663732, -0.5083561 ,  1.0521195 ,  0.80214868]])
   
mask = (names == 'Bob') | (names == 'Will')    ***#当要选择多个值时,对多个布尔值条件联合,用and(&)和 or(|)***
mask
array([ True, False,  True,  True,  True, False, False])

data[mask]
array([[ 0.12321991, -1.09632626, -0.30461838,  2.48481254],
   [-2.33000677, -0.1476485 , -0.59621164,  1.89350542],
   [-0.02867256,  0.23359139, -0.3729644 , -1.91841038],
   [ 0.80456444, -0.02035105,  1.38518404,  1.25534382]])

data[data<0] = 0                         #通过布尔赋值
data
array([[0.12321991, 0.        , 0.        , 2.48481254],
   [0.9913972 , 0.88999478, 0.        , 0.        ],
   [0.        , 0.        , 0.        , 1.89350542],
   [0.        , 0.23359139, 0.        , 0.        ],
   [0.80456444, 0.        , 1.38518404, 1.25534382],
   [0.        , 0.        , 0.        , 0.        ],
   [0.        , 0.        , 1.0521195 , 0.80214868]])

转置和换轴 data.transpose() 和特殊的T属性 data.T 和 data.swapasxes(一对轴编号)

data
array([[ 0.66837421,  0.89010689, -0.01424221,  0.90782448],
       [ 0.37356741, -0.07476905, -0.3653412 ,  1.01533556],
       [-0.0802038 ,  0.17349197, -1.599615  ,  0.56571188],
       [-1.28334251,  0.81426487, -0.923576  ,  1.34439761],
       [ 0.55554439, -0.0075288 , -0.51077055,  1.62667747],
       [-0.72533576, -0.89991397,  0.17066818, -0.64373175],
       [ 0.80755579, -1.0907833 , -0.03899747,  0.61250142]])
       
data.T
array([[ 0.66837421,  0.37356741, -0.0802038 , -1.28334251,  0.55554439,
        -0.72533576,  0.80755579],
       [ 0.89010689, -0.07476905,  0.17349197,  0.81426487, -0.0075288 ,
        -0.89991397, -1.0907833 ],
       [-0.01424221, -0.3653412 , -1.599615  , -0.923576  , -0.51077055,
         0.17066818, -0.03899747],
       [ 0.90782448,  1.01533556,  0.56571188,  1.34439761,  1.62667747,
        -0.64373175,  0.61250142]])
        
data.transpose((1,0))
array([[ 0.66837421,  0.37356741, -0.0802038 , -1.28334251,  0.55554439,
        -0.72533576,  0.80755579],
       [ 0.89010689, -0.07476905,  0.17349197,  0.81426487, -0.0075288 ,
        -0.89991397, -1.0907833 ],
       [-0.01424221, -0.3653412 , -1.599615  , -0.923576  , -0.51077055,
         0.17066818, -0.03899747],
       [ 0.90782448,  1.01533556,  0.56571188,  1.34439761,  1.62667747,
        -0.64373175,  0.61250142]])
        
data.swapaxes(1,0)
array([[ 0.66837421,  0.37356741, -0.0802038 , -1.28334251,  0.55554439,
        -0.72533576,  0.80755579],
       [ 0.89010689, -0.07476905,  0.17349197,  0.81426487, -0.0075288 ,
        -0.89991397, -1.0907833 ],
       [-0.01424221, -0.3653412 , -1.599615  , -0.923576  , -0.51077055,
         0.17066818, -0.03899747],
       [ 0.90782448,  1.01533556,  0.56571188,  1.34439761,  1.62667747,
        -0.64373175,  0.61250142]])

通用函数

一元通用函数

abs                                         逐元素计算整数,浮点数,复数的绝对值
sqrt                                        计算每个元素的平方根
square                                      计算每个元素的平方
exp                                         计算每个元素的自然指数值
log  log10 log2  log1p                      计算元素的对数
sign                                        计算每个元素的符号值:1(正数),0(0),-1(负数)
ceil                                        计算每个元素的最高整数值
floor                                       计算每个元素的最小整数值
rint                                        将元素保留到整数位,并保持dtype
modf                                        分别将数组的小数部分和整数部分按数组的形式返回
isnan                                       返回数组中的的元素是否是一个Nan,形式为布尔值数组
isfinite    isinf                           分别返回数组中的元素是否有限,是否无限的,形式为布尔值数组
cos   cosh   sin                            常规的双曲线函数
sinh   tan   tanh
logical_not                                 对数组的元素按位取反(与-arr效果一致)

二元通用函数

add                                         将数组的对应元素相加
subtract                                    在第二个数组中,将第一个数组中包含的元素去除
multiply                                    将数组的对应元素相乘
divide   floor_divide                       除   整除(放弃余数)
power                                       将第二个数组中的元素作为第一个数组对应元素的幂次方
maximum   fmax                              逐个元素计算最大值   fmax 忽略NaN
minmum    fmin                              逐个元素计算最小值   fmin 忽略NaN
mod                                         按元素的求模运算
copysign                                    将第一个数组的符号值改为第二个数组的符号值
>  >=  <  <=  ==   !=                       逐元素比较运算
logical_and   logical_or   logical_xor      逐元素进行逻辑操作

将条件逻辑作为数组操作 np.where(expr,xarr,yarr)

当   expr   成立时 取xarr         不成立时 取    yarr            也可以进行嵌套
np.where() 的数组既可以是同等大小的数组,也可以是标量

数学统计方法

  arr.sum()                          沿着轴向计算所有元素的累和,0长度的数组,累计为0
  arr.mean()                         数学平均,0长度的数组平均值为NaN
  arr.std()  var()                   标准差,方差,可以选择自由度的调整(默认分母为n)
  arr.min()  max()                   最小值,最大值
  arr.argmin()   argmax()            最小值和最大值的位置
  cumsum                             从0开始元素累计和
  cumprod                            从0开始元素的累计积

布尔数组的方法(any 和 all)

排序 arr.sort() arr.sort(1)

唯一值与其他集合逻辑 np.unique(arr)

     数组的集合操作:
unique(x)                     计算x的唯一值,并排序
intersect1d(x,y)              计算x与y的交集,并排序
union1d(x,y)                  计算x与y的并集,并排序
in1d(x,y)                     计算x中的元素是否包含在y中,返回一个布尔值数组
setdiff1d(x,y)                计算x与y的差集
setxor1d(x,y)                 异或集 ,在x或y中,但不属于x,y 的交集元素

线性代数

                       from numpy.linalg import   
diag
dot                      矩阵点乘
trace                    计算对角元素和
det                      计算矩阵的行和列
eig                      计算方阵的特征值和特征向量
inv                      计算方阵的逆矩阵
pinv                     计算矩阵的Moore-Penrose伪逆
qr                       计算QR分解
svd                      计算奇异值分解(SVD)
solve                        
lstsq                    计算 Ax = b  的最小二乘解

伪随机数生成

                    numpy.random中的常用函数
 seed                    向随机数生成器传递随机状态种子
 permutation             返回一个序列的随机排列,或者返回一个乱序的整数范围序列
 shuffle                 随机排列一个序列
 rand                    从均匀分布中抽取样本
 randint                 根据给定的由低到高的范围抽取随机整数
 randn                   从均值为0方差为1的正态分布中抽取样本
 binomial                从二项分布中抽取样本
 normal                  从正态分布中抽取样本
 beta                    从beta分布中抽取样本
 chisquare               从卡方分布中抽取样本
 gamma                   从伽马分布中抽取样本
 uniform                 从均匀【0,1)分布中抽取样本