Numpy的基础用法

1.用Numpy创建数组

numpy.array(object)：创建数组，与array.array(typecode[, initializer])不同，array.array()只能创建一维数组

numpy.arange(start, stop, step, dtype=None)：创建一个从start开始，stop结束(不包含stop)，以step为步长的一维数组(step最好为整数)，dtype默认为整数(int32)

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)：创建一个从start开始，stop结束（默认包含stop），默认50个元素的数组；num规定了数组元素的个数；当endpoint为False时，数组不包含stop；输出的数组元素默认为float

上述函数创建的数组全部返回ndarray类型

import numpy as np

ndarray_1 = np.array([[1,2,3], [4,5,6], (7,8,9)])
print(ndarray_1)

ndarray_2 = np.arange(1, 9)
print(ndarray_2)

ndarray_3 = np.linspace(1, 9, 9)
print(ndarray_3)

2.ndarray对象的方法

1.ndarray.ndim：返回数组的维数

2.ndarray.shape：返回数组的大小

3.ndarray.reshape(shape)：返回一个以shape为格式的新数组

4.ndarray.size：返回数组元素的总个数

5.ndarray.dtype：返回数组元素的类型

6.ndarray.itemsize：返回数组元素的大小（以字节为单位）

import numpy as np

x = np.linspace(1,18,18,dtype=int).reshape(2,3,3)
print(x.ndim)#
print(x.shape)#(2,3,3)
print(x.size)#
print(x.dtype)# int32
print(x.itemsize)#

3.numpy创建特殊数组(数组的元素类型默认为float)

numpy.empty(shape, dtype=float, order=‘C’)：创建一个随机数组

numpy.empty_like(prototype，dtype = None，order ='K'，subok = True，shape = None)：返回一个形状和类型与给定数组相同的新数组

shape：控制数组的形状，为int或int元组，例如：shape是3，则创建一个1x3的数组，shape是(2,3)，则创建一个2x3的数组

order：控制存储时以行为主还是以列为主

import numpy as np

arr = np.empty((2,3))
print(arr)

a = np.arange(6).reshape(2,3)
arr_like = np.empty_like(a)
print(arr_like)

numpy.zeros(shape, dtype=float, order='C')：创建一个全零数组

numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)：创建一个和给定的数组a形状和类型相同的全零新数组

import numpy as np

arr_zero = np.zeros((2,3), dtype=int)
print(arr_zero)

a = np.arange(6, dtype=float).reshape(2,3)
arr_zero_like = np.zeros_like(a)
print(arr_zero_like)

numpy.ones(shape, dtype=None, order='C')：创建一个全1数组

numpy.ones_like(a, dtype=None, order='K', subok=True, shape=None)：创建一个和给定的数组a形状和类型相同的全1数组

import numpy as np

arr_ones = np.ones((3,3), dtype=int)
print(arr_ones)

a = np.arange(9, dtype=float).reshape(3,3)
arr_ones_like = np.ones_like(a)
print(arr_ones_like)

numpy.full(shape, fill_value, dtype=None, order='C')：创建一个用fill_value填充的填充数组

numpy.full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None)：创建一个和给定数组a形状和类型相同的填充数组

import numpy as np

arr_full = np.full((2,3), 3)
print(arr_full)

a = np.arange(6)
arr_full_like = np.full_like(a, 1)
print(arr_full_like)

numpy.eye(N, M=None, k=0, dtype=<class 'float'>, order='C')：创建一个对角线元素为1，其余元素为0的数组

M：默认等于N，就是创建一个NxN的数组

k：k为正数，则对角线上移k位；k为负数，则对角线下移k位；若|k|>=M，则数组元素全为0

numpy.identity(n, dtype=None)：创建一个nxn的，对角线元素为1的数组，元素类型默认为float

import numpy as np

arr_eye = np.eye(3)
print(arr_eye)

arr_eye2 = np.eye(3, k=1)
print(arr_eye2)

arr_eye3 = np.eye(3, k=3)
print(arr_eye3)

arr_id = np.identity(3)
print(arr_id)

4.数组的索引

4.1 一维数组的索引

一维数组的索引与列表的索引类似

import numpy as np

a = np.arange(10)
print(a[-1])#
print(a[5:])#[5 6 7 8 9]
print(a[-5:10])#[5 6 7 8 9]
# 第一个参数小于第二个时，最后一个参数要为负数，表示从后向前索引
print(a[-2:2:-1])#[8 7 6 5 4 3]
# 翻转
print(a[::-1])#[9 8 7 6 5 4 3 2 1 0]
print(a[5::2])#[5 7 9]
# 整数索引,索引数组中的第2个，倒数第4个，第5个元素
print(a[[2,-4,5]])#[2 6 5]

# 下标索引方式和原数组占用同样的存储空间，修改b时，a也会被修改
b = a[1:3]
b[0] = 100
print(a)#[0,100,2,3,4,5,6,7,8,9]
# 列表索引和原数组不占用同样的存储空间，修改c时，a2不会被修改
a2 = np.arange(10)
c = a2[[0,1,2]]
c[0] = 100
print(a2)#[0,1,2,3,4,5,6,7,8,9]

4.2 二维数组的索引

import numpy as np

a = np.arange(24).reshape(4,6)
# 取第一、二行的第一个元素
print(a[0,0], a[1,0])
# 取第一行的所有元素，第一行和第一列的索引下标为0，以此类推
print(a[0])
# 取第一列的所有元素
print(a[:, 0])
# 取第一行到第三行的部分元素
print(a[0:3, :3])
# 翻转
print(a[::-1, ::-1])

#a[i:j, i:j] 逗号前面的表示取行，逗号后面的表示取列

4.3 三维数组的索引

import numpy as np

a = np.arange(24).reshape(2,3,4)
# 可以把数组a看做一个2层楼的房子，每层有3x4个房间，第一个索引值表示位于哪一个楼层，后面的两个索引与二维数组类似
print(a[0, :, :])
# 当后面都为:时，可以用一个...代替
print(a[0,...])
# 索引第一层的第一行，第一列的元素
print(a[0, 0, 0])
# 索引两层的最后一列元素
print(a[:,:,-1])

5.Numpy.random模块

numpy.random.rand(d0, d1, d2,..., dn)：生成一个元素值为0-1之间的随机数组，数组的形状由传入的参数决定：当不传入参数时，生成一个元素；传入一个参数时，根据参数的大小生成一个一维数组；传入两个参数时，生成一个二维数组

numpy.random.randn(d0,d1,d2,...,dn)：生成一个服从标准正态分布的数或数组，数组的形状由传入的参数(d1,d2,...dn)决定

import numpy as np

arr1 = np.random.rand()
print(arr1, '\n')
arr2 = np.random.rand(6)
print(arr2, '\n')
arr3 = np.random.rand(2,3)
print(arr3, '\n')
arr4 = np.random.randn(2,3,4)
print(arr4)

numpy.random.randint(low, high=None, size=None, dtype='l')：从小到大返回随机整数，如果high=None，则整数的范围是[0, low)，否则为[low, high)；若size=None，则生成一个随机整数，否则根据size来生成相对应的数组，下同

import numpy as np

arr1 = np.random.randint(5)
print(arr1)
arr2 = np.random.randint(1, 10, (2,3))
print(arr2)
# 当size前面只有一个参数时，size参数要写成size=(a,b)
arr3 = np.random.randint(10,size=(2,3))
print(arr3)

numpy.random.normal(loc=0.0, scale=1.0, size=None)：生成一个服从正态分布的数或数组，loc为正态分布的均值，scale为正态分布的标准差

numpy.random.uniform(low=0.0, high=1.0, size=None)：生成一个服从均匀分布的数或数组，生成的所有值都大于等于low，小于high

numpy.random.poisson(lam=1.0, size=None)：生成一个服从lam=1.0的泊松分布的数或数组

import numpy as np

arr1 = np.random.normal(0, 1, (2,3))# 服从标准正态分布
print(arr1)
arr2 = np.random.uniform(3, 5, (2,3))
print(arr2)
arr3 = np.random.poisson(size=(2,3))
print(arr3)

numpy.random.choice(a, size=None, replace=True, p=None)：从给定的一维数组a中生成一个随机样本，replace设定样本是否更换；p设定a中每个数被选中的概率，未给出则每个数服从均匀分布；

import numpy as np

a = np.arange(5)
arr1 = np.random.choice(a, (2,3))
print(arr1)
arr2 = np.random.choice(a, 5, p=[0.1,0.2,0,0.7,0])
print(arr2)

numpy.random.shuffle(a)：随机打乱一个数组，多维数组则仅沿第一个轴随机排列，函数返回None，原数组被改变

import numpy as np

a = np.arange(12)
np.random.shuffle(a)
print(a)

b = np.arange(12).reshape(3,4)
np.random.shuffle(b)
print(b)

 numpy.random.seed(seed=None)：用于设定随机数种子

6.统计函数

Numpy可以用于求数组的和与平均值

numpy.sum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>): 用于求数组元素的和，axis=0：求每列的和，axis=1：求每行的和

import numpy as np

data1 = np.sum(np.arange(10).reshape(2,5))
print(data1)

data2 = np.sum(np.arange(10).reshape(2,5), axis=0)
print(data2)

data3 = np.sum(np.arange(10).reshape(2,5), axis=1)
print(data3)

data = np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32)#手册的例子，不懂结果为什么为1
print(data)

numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>)：用于求均值

import numpy as np

data1 = np.mean(np.arange(10).reshape(2,5))
print(data1)

data2 = np.mean(np.arange(10).reshape(2,5), axis=0)
print(data2)

data3 = np.mean(np.arange(10).reshape(2,5), axis=1)
print(data3)

numpy.average(a, axis=None, weights=None, returned=Flase)：用于求加权平均值，weights是用于加权的数组

import numpy as np

data = np.average([5,10],weights=[1,2])#相当于(1*5+2*10)/(1+2)
print(data)

 numpy.var(a，axis=None)：用于求方差；

numpy.std(a, axis=None)：用于求标准差;

numpy.max(a, axis=None)：用于求最大值；

numpy.min(a，axis=None)：用于求最小值；

7.矩阵运算（用matlab更好一点）

Numpy用于矩阵运算的模块是numpy.linalg

numpy.transpose(a, axes=None)：用于矩阵转置，或者可以直接用 ndarray.T

numpy.dot(a, b)：一维时计算向量内积；二维时计算矩阵乘法，或者 ndarray.dot(b)

numpy.trace(a，offset=0)：用于计算矩阵的对角线元素之和

linalg.det(a)：用于计算行列式

linalg.eig(a)：用于计算方阵的特征值和特征向量

linalg.inv(a)：用于求逆矩阵

linalg.solve(a, b)：解线性方程组Ax=b

linalg.qr(a,mode='reduced')：用于矩阵的QR分解

linalg.svd(a,full_matrices=1,compute_uv=1)：用于矩阵的奇异值分解

 更多用法请参考：Numpy手册