numpy

numpy是一个开源的python科学计算库，使用ndarray对象处理任意维度的数组

1.ndarray相对原生python列表优势：

1.内存块存储优势：ndarray在存储元素是内存连续，而python原生list存储元素是选择元素外置的形式，查找时通过寻址方式找到下一个元素，在科学计算时，ndarray的速度快于list。

2.ndarray支持并行化运算（向量化运算）

3.numpy底层编写使用c语言，内部解除了GIL（全局解释锁）

2.ndarray的属性：

import numpy as np

a = np.array([[1,2,3],[4,5,6]])

a

array([[1, 2, 3],

      [4, 5, 6]])

ndarray.shape 数组维度的元组

a.shape

(2, 3)

ndarray.ndim数组维数

a.ndim

2

ndarray.size 数组众元素的数量

a.size

6

ndarray.itemsize 一个数组元素的长度（字节）

a.itemsize

4

ndarray.dtype  数组元素的类型

a.dtype

dtype('int32')

3.创建数组的时候指定 数组 类型

a = np.array([[1, 2, 3],[4, 5, 6]], dtype=np.float32)

a.dtype

dtype('float32')

4.astype方法显式地转换其dtype类型

a.astype(np.int64)

array([[1, 2, 3],

      [4, 5, 6]], dtype=int64)

5. 生成数组的方法

1 生成0和1的数组 

np.ones([3,4]) 

array([[1., 1., 1., 1.],

      [1., 1., 1., 1.],

      [1., 1., 1., 1.]])

np.zeros([3,4])

array([[0., 0., 0., 0., 0.],

      [0., 0., 0., 0., 0.]])

2.从现有数组生成

b = np.array(a)

c = np.copy(a)

d = np.asarray(a)

array([[1, 2, 3],

      [4, 5, 6]], dtype=int64)

当改变a中元素时，b,c中元素不改变，d中元素也随之改变

b,c相当于深拷贝，d相当于浅拷贝

3.生成固定范围的数组

np.linspace(start,stop,num,endpoint,retstep,dtype)

start 序列的起始值   stop 序列的终止值，

如果endpoint为true，该值包含于序列中

num 要生成的等间隔样例数量，默认为50

endpoint 序列中是否包含stop值，默认为ture

retstep 如果为true，返回样例，以及连续数字之间的步长

dtype 输出ndarray的数据类型

np.linspace(0,100,10)

array([ 0. , 11.11111111, 22.22222222, 33.33333333,

        44.44444444,  55.55555556,  66.66666667,  77.77777778,

        88.88888889, 100.        ])

numpy.arange(start,stop, step, dtype)

np.arange(0,100,10)

array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])

4 生成随机数组 

均匀分布：

np.random.rand(d0, d1, ..., dn)

返回[0.0，1.0)内的一组均匀分布的数。

np.random.uniform(ow=0.0, high=1.0, size=None)

从一个均匀分布[low,high)中随机采样，注意定义域是左闭右开，即包含low，不包含high.

size: 输出样本数目，为int或元组(tuple)类型

返回值：ndarray类型，其形状和参数size中描述一致。

np.random.randint(low, high=None, size=None, dtype='l')

从一个均匀分布中随机采样，生成一个整数或N维整数数组，取数范围：若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数。

正态分布：

np.ramdom.randn(d0, d1, …, dn)

功能：从标准正态分布中返回一个或多个样本值

np.random.normal(loc=0.0, scale=1.0, size=None)

loc：float   此概率分布的均值（对应着整个分布的中心centre）

scale：float 此概率分布的标准差（对应于分布的宽度，scale越大越矮胖，scale越小，越瘦高）

size：int or tuple of ints​ 输出的shape，默认为None，只输出一个值

np.random.standard_normal(size=None)

返回指定形状的标准正态分布的数组。

5.数组的索引、切片 先行后列

a[0][1] 或a[0,1]  单个

2 

a[0][1:3] 或a[0,1:3] 多个

array([2, 3], dtype=int64)

6.形状修改

ndarray.reshape(shape[, order])

a.reshape([3,2])  只是将形状进行了修改，但并没有将行列进行转换

array([[ 1, 2],

      [  3,  4],

      [100,  6]], dtype=int64)

a.reshape([-1,3])  数组的形状被修改为:[-1,3], -1: 表示通过待计算,确定好了列，行通过计算，自动得到，但列也必须能和行相乘，等于元素总数。

array([[ 1, 2, 3],

      [  4, 100,  6]], dtype=int64)

ndarray.T 数组的转置

将数组的行、列进行互换

a.T

array([[ 1, 4],

      [  2, 100],

      [  3,  6]], dtype=int64)

ndarray.resize(new_shape[, refcheck]) ,直接修改原数组形状

a.resize([3,2])

a

array([[ 1, 2],

      [  3,  4],

      [100,  6]], dtype=int64)

7.ndarray对象转化为其它类型对象

a.tostring(),a.tobytes(),a.tolist()

type(a)

numpy.ndarray

b = a.tobytes()

type(b)

bytes

8.数组的去重,变为一维的ndarray对象

ndarray.unique（）

a[0,0] = 2

a

np.unique(a)

array([ 2, 3, 4, 6, 100], dtype=int64)

9.ndarray运算

逻辑运算

a > 3

array([[False, False],

      [False,  True],

      [ True,  True]])

通用判断函数

np.all(),只要有一个false，返回false，全是True,就返回True

np.all(a>3)

False

np.any()只要有一个true，返回true，全是False,就返回False

np.any(a>3)

True

np.where 三元运算符

np.where(a>3,1111111111,0)

array([[ 0, 0],

      [        0, 1111111111],

      [1111111111, 1111111111]])

进行复合逻辑，联合np.logical_and和np.logical_or

np.where(np.logical_and(a>3,a<5),222,0),在数组a中，大于3并且小于5的换为222，其它0.

array([[ 0, 0],

      [  0, 222],

      [  0,  0]])

统计运算

np.min(a[, axis,  keepdims]

axis=0/1 按行，还是按列

keedims=true:保存矩阵的二维特性

a

array([[ 2, 2],

      [  3,  4],

      [100,  6]], dtype=int64)

np.min(a) 数组中最小元素

2 

np.min(a,axis=0) 每列最小，跨行

array([2, 2], dtype=int64)

np.min(a,axis=1)  每行最小，跨列

array([2, 3, 6], dtype=int64)

 max  mean  median var std同理

返回最大值、最小值所在位置，若有axis，则返回一维ndarray对象，记录每行或者每列中最大值或者最小值的下标位置。

np.argmax()  

np.argmax(a,axis=0)  按每列，跨行

array([2, 2], dtype=int64)

np.argmax(a,axis=1) 按每行，跨列

array([0, 1, 0], dtype=int64)

np.argmin()同理

10.数组间的运算：

数组与数的运算

a*10

array([[ 20, 20],

      [  30,  40],

      [1000,  60]], dtype=int64)

数组与数组的运算

广播机制：只有在以下情况，两个数组才能够进行数组与数组的运算。

    维度相等：相同维度，元素数量一致。

    shape（其中相对应的一个地方为1）

a.shape

(3, 2)

b.shape

(3,1)

a+b

array([[ 3, 3],

      [  4,  5],

      [101,  7]], dtype=int64)

矩阵运算：

矩阵，英文matrix，矩阵 一定是 二维数组，二维数组 不一定是 矩阵

矩阵乘法 

形状要求

A(m, n) * B(n, l) = AB(m, l)

 运算规则

A(2, 3) * B(3, 2) = AB(2, 2)

二维数组转化为矩阵：

np.mat()

a_mat = np.mat(a)

b_mat= np.mat(b)

a_mat * b_mat

matrix([[ 4, 4, 4, 4],

        [  7,  7,  7,  7],

        [106, 106, 106, 106]], dtype=int64)

直接使用np.dot()/np.matmul(),进行二维数组矩阵乘法运算

np.dot(a,b)

array([[ 4, 4, 4, 4],

      [  7,  7,  7,  7],

      [106, 106, 106, 106]], dtype=int64)

使用@，也能使二维数组进行矩阵乘法运算

a @ b

array([[ 4, 4, 4, 4],

      [  7,  7,  7,  7],

      [106, 106, 106, 106]], dtype=int64)

11.合并与分割

水平拼接

np.hstack()

np.hstack((a,b))    a,b行数相等

array([[ 2, 2, 1, 1, 1, 1],

      [  3,  4,  1,  1,  1,  1],

      [100,  6,  1,  1,  1,  1]], dtype=int64)

   竖直拼接

 np.vstack()   a,b行数相等

np.concatenate((a1, a2), axis=)

 axis=1时候，按照数组的列方向拼接在一起， a,b行数相等

axis=0时候，按照数组的行方向拼接在一起 a,b列数相等

分割

np.split(ary, indices_or_sections, axis=0) 

ary：分割数组对象

indices_or_sections：整数：分为几分，列表：列表中的元素作为边界

axis=0/1:按行方向还是按列方向

np.split(a,2,axis=1)

[array([[ 2],

        [  3],

        [100]], dtype=int64), array([[2],

        [4],

        [6]], dtype=int64)]

x = np.arange(8.0)

array([0.,1.,2.,3.,4.,5.,6.,7.])

>>> np.split(x, [3,5,6,10])

[array([0.,1.,2.]), array([3.,4.]), array([5.]), array([6.,7.]), array([], dtype=float64)]