Numpy的基础用法

1.numpy创建数组

np.array(object)：创建数组.     与array.array()不同，array.array()只能创建一维数组

np.arange(start, stop, step, dtype=None)：创建一个以step为步长的一维数组(step最好为整数)

np.linspace(start, stop, num=50, endpoint=True, dtype=None)：创建一个默认50个元素的一维数组；当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对象的方法

ndarray.ndim：返回数组的维数

ndarray.shape：返回数组的大小

ndarray.reshape((m,n))：返回一个以(m,n)为格式的新数组

ndarry.reshape((a,))   # 多维变一维
ndarry.reshape((a,1))  # 一维或多维变二维(a行1列)
ndarry.reshape((-1,a)) # 根据已知维度a推算未知维度

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

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

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

import numpy as np

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

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

np.empty(shape, dtype=float)：创建一个随机数组

np.empty_like(prototype, dtype=None, shape=one)：返回一个形状和类型与给定数组相同的新数组

shape：重置数组的形状，为int或int元组，例如：shape是int，则创建一个一维数组，shape是元组，则创建一个多维数组

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)

np.zeros(shape, dtype=float)：创建一个全零数组

np.zeros_like(a, dtype=None, 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)

np.ones(shape, dtype=None)：创建一个全1数组

np.ones_like(a, dtype=None, 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)

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

np.full_like(a, fill_value, dtype=None, 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)

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

M：默认等于N，就是创建一个NxN的全1矩阵

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

np.identity(n, dtype=None)：创建 n 维单位矩阵

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])# 9
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模块

np.random.rand(d0, d1, d2,..., dn)：生成一个元素值为0-1之间的随机数组

数组的形状由传入的参数决定：当不传入参数时，生成一个元素；传入一个参数时，根据参数的大小生成一个一维数组；传入两个参数时，生成一个二维数组

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

import numpy as np

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

np.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)

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

生成一个服从正态分布的数或数组，loc为正态分布的均值，scale为正态分布的标准差

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

生成一个服从均匀分布的数或数组，生成的所有值都大于等于low，小于high

np.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)

np.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)

np.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)

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

np.random.permutation(x)  可以生成x个从0-(x-1)的随机数列

6.统计函数

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

np.sum(a, axis=None, dtype=None): 用于求数组元素的和，axis=0：求每列的和，axis=1：求每行的和  (注意axis的设置)

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,  因为np.int32强制数据类型转换
print(data)

np.mean(a, axis=None, dtype=None)：用于求均值

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)

np.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)

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

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

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

np.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)：用于计算矩阵的对角线元素之和

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

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

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

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

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

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

8.数组的级联

np.concatenate((arr1,arr2,....),axis=0)  (注意级联数组维度)

np.append(arr, value, axis=None)

当axis有值的时候要注意维度一致

制作九宫格

 更多用法请参考：Numpy手册