Numpy数值计算基础（1）

NumPy是Python的一种开源的数值计算扩展库。

ndarray:是存储单一数据类型的多维数组，

ufunc:是一种能够对数组进行处理的函数。

常用的导入格式： import  numpy as np

1. NumPy多维数组

创建数组对象

通过NumPy库的array函数可以创建ndarray数组。同构数据容器，即所有元素需要相同的类型。

使用array函数的格式： np.array(object, dtype, ndmain)

import numpyas np

d1 = [1, 3, 5, 7]    # 列表

w1 = np.array(d1)

d2 = (2, 4, 6, 8)

w2 = np.array(d2)      # 元组

d3 = [[1, 2, 3, 4], [5, 6, 7, 8]]

w3 = np.array(d3)    # 多维数组

print(‘W1’, w1)

print(‘W2’, w2)

print(‘W3’, w3)

#  为新建的数组推断出一个合适的数据类型，并保存在dtype

w4 = np.array([1, 2, 3, 4], dtype=‘float64’)

print(w4.dtype)

print(w4)

输出：

W1 [1 3 5 7]

W2 [2 4 6 8]

W3 [[1 2 3 4]

[5 6 7 8]]

float64

[1. 2. 3. 4.]

专门创建数组的函数

arange函数，主要用来创建数组。可以指定初始值，步长，数组不包含终值。

a1 = np.arange(10)

print(a1)   #    [0 1 2 3 4 5 6 7 8 9]

a = np.arange(1, 10, 2)

print(a) # [1 3 5 7 9]

a2 = np.arange(0, 1, 0.2)

print(a2)  #  [0. 0.2 0.4 0.6 0.8]

linspace函数

当arrange的参数是浮点型时，由于浮点型的精度有限，通常不太可能去预测获得元素的数量。更好的选择函数linspace

w = np.linspace(0, 1, 5)

print(w)    #   [0. 0.25 0.5 0.75 1. ]

logspace函数

创建的时等比数列

w = np.logspace(0, 1, 5)

print(w)      # [ 1. 1.77827941 3.16227766 5.62341325 10. ]

logspace的参数中，起始位和终止位代表的是10的幂(默认基数为10)，第3个参数表示元素个数

zeros函数

可创建指定长度或形状的全0数组，。

如，创建全零矩阵

print(np.zeros(4))  # [0. 0. 0. 0.]

print(np.zeros([3, 3]))

输出：

[[0. 0. 0.]

[0. 0. 0.]

[0. 0. 0.]]

ones函数

可创建指定长度或形状的全1数组

print(np.ones(5))

输出：[1. 1. 1. 1. 1.]

print(np.ones([2, 3]))

输出：

[[1. 1. 1.]

[1. 1. 1.]]

diag函数

可以创建对角矩阵，即对角元素为0或者指定值，其它元素为0

print(np.diag([1, 2, 3, 4]))

输出：

[[1 0 0 0]

[0 2 0 0]

[0 0 3 0]

[0 0 0 4]]

ndarry对象属性和数据转换

创建的ndarry对象属性主要有shape， size等属性：

ndim:  秩，即数据轴的个数

shape: 数组的维度

size: 数组元素个数

dtype: 数据类型

itemsize: 数组中每个元素的字节大小

测试代码：

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

print(“秩：”, warray.ndim)

print(“形状为：”, warray.shape)

print(“元素个数:”, warray.size)

输出：

秩： 2

形状为： (2, 3)

元素个数: 6

设置数组的shape属性：

warray.shape =3, 2

print(warray)

输出：

[[1 2]

[3 4]

[5 6]]

数组类型转换

对于创建好的ndarry,可以通过astype方法进行数据类型的转换

arr1 = np.arange(6)

print(arr1.dtype)

arr2 = arr1.astype(np.float64)

print(arr2.dtype)

print(arr1)

print(arr2)

输出：

int32

float64

[0 1 2 3 4 5]

[0. 1. 2. 3. 4. 5.]

生成随机数

在Numpy.random模块中，提供了许多随机数的生成函数，如 randint,可生成指定范围的随机数。

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

a = np.random.randint(100, 200, size=(2, 4))

print(a)

输出：

[[104 164 111 128]

[195 118 152 175]]

生成【0， 1】的随机数

r1 = np.random.rand(5)

print(r1)

输出：

[0.12335986 0.42162639 0.97246396 0.52114664 0.71535294]

r2 = np.random.rand(4, 2)

print(r2)

输出：

[[0.22090604 0.9399978 ]

[0.61356375 0.09882253]

[0.74484144 0.77596951]

[0.93574769 0.11303797]]

random模块常用的随机数生成函数

seed: 确定随机数生成器的种子

permutation : 返回一个序列的随机排列或返回一个随机排列的范围

shuffle: 对一个序列进行随机排列

binomial: 产生二项分布的随机数

normal: 产生正态分布的随机数(高斯分布)

beta: 产生beta分布的随机数

chisquare: 产生卡方分布的随机数

gamma: 产生gamma分布的随机数

uniform: 产生在[0,1）中均匀分布的随机数

数组变换

数组重塑

对于定义好的数组，可以使用reshape方法改变其维度，传入的参数为新维度的元组。

a1 = np.arange(8)

print(a1)

a2 = a1.reshape(4, 2)

print(a2)

输出：

[0 1 2 3 4 5 6 7]

[[0 1]

[2 3]

[4 5]

[6 7]]

reshape中的一个参数可设置为 -1，表示数组的维度可以通过数据本身来推断。

a1 = np.arange(12)

print("a1: ", a1)

a2 = a1.reshape(2, -1)

print("a2: ", a2)

输出：

a1: [ 0 1 2 3 4 5 6 7 8 9 10 11]

a2:  [[ 0  1  2  3  4  5]

[ 6  7  8  9 10 11]]

与reshape 相反的方法是数据散开 ravel，或者数据扁平化 flatten

数据散开

a1 = np.arange(12).reshape(3, 4)

print(“a1:”, a1)

a2 = a1.ravel()

print("a2: ", a2)

输出：

a1: [[ 0 1 2 3]

[ 4  5  6  7]

[ 8  9 10 11]]

a2:  [ 0  1  2  3  4  5  6  7  8  9 10 11]

数据重塑不会改变元素组的

数组合并

多个数组间的操作。使用hstack, vstack, concatenate函数完成数组的合并。

横向合并是将ndarray对象构成的元组作为参数，传递给hstack函数。

2个数组的横向合并

a1 = np.arange(6).reshape(3, 2)

a2 = a1 *2

print("a1: ", a1)

print("a2: ", a2)

a3 = np.hstack((a1, a2))

print("a3: ", a3)

输出：

a1: [[0 1]

[2 3]

[4 5]]

a2:  [[ 0  2]

[ 4  6]

[ 8 10]]

a3:  [[ 0  1  0  2]

[ 2  3  4  6]

[ 4  5  8 10]]

数组纵向合并

a1 = np.arange(6).reshape(3, 2)

print(“a1：”, a1)

a2 = a1 *2

print("a2: ", a2)

a3 = np.vstack((a1, a2))

print(a3)

输出：

a1： [[0 1]

[2 3]

[4 5]]

a2:  [[ 0  2]

[ 4  6]

[ 8 10]]

[[ 0  1]

[ 2  3]

[ 4  5]

[ 0  2]

[ 4  6]

[ 8 10]]