Python numpy资料整理记录

最新推荐文章于 2024-02-28 10:16:23 发布

荼蘼不谢

最新推荐文章于 2024-02-28 10:16:23 发布

阅读量340

点赞数 1

分类专栏：神经网络 python 文章标签： numpy python

转载请注明出处，谢谢

本文链接：https://blog.csdn.net/qq_26967299/article/details/82251149

版权

神经网络同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

python

1 篇文章 0 订阅

订阅专栏

1 numpy基础：数组和矢量计算

1.1 创建ndarray
- 1.1.1 使用array函数，它接受一切序列型对象
- 1.1.2 使用zeros和ones函数创建数组
1.2 ndarray的数据类型
1.3 数组和标量之间的运算
1.4 基本的索引和切片
- 1.4.1 切片索引
1.5 布尔型索引
- 1.5.1 利用布尔型数组调整数值
- 1.5.2 通过一维布尔数组设置整行或整列
1.6 花式索引
1.7 数组转置和轴对换
1.8 通用函数：快速的元素级数组函数
1.9 利用数组进行数据处理
1.10 用于数组的文件输入输出
- 1.10.1 将数组以二进制的形式保存（暂时用不到）
- 1.10.2 作为文本文件存取数组（暂时用不到，相关读写操作可以用pandas组件实现）
1.11 线性代数
1.12 随机数生成

随着机器学习等相关学科的兴起，python的使用量和关注程度日益上升，而numpy作为机器学习中必不可少的一个库，特地整理并记录如下。中间省略了一些我认为十分基础的部分，同时也增加了一些我认为十分有意思值得关注或者有益于理解numpy逻辑的部分。

numpy基础：数组和矢量计算

import numpy as np

data = np.array([[0.95, -0.24, -0.88], [0.56, 0.23, 0.91]])

data * 10
data

data

data * 10

ndarray 是一个同构数据多维容器，即所有数据为相同类型

data.shape  # shape为属性   表示各维度大小的元组
data.dtype  # dtype说明数组数据类型的对象

创建ndarray

使用array函数，它接受一切序列型对象

data1 = [6, 7, 8, 6.5, 0, 1]
arr1 = np.array(data1)
arr1

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

使用zeros和ones函数创建数组

np.zeros(10)

np.zeros((2, 3))

np.empty((2, 2, 3))

arange 是Python内置函数range的数组版本

np.arange(10)

ndarray的数据类型

dtype用来将ndarray解释为特定数据类型

arr1 = np.array([1, 2], dtype=np.float64)

arr2 = np.array([1, 2], dtype=np.int32)

print(arr1.dtype)
print(arr2.dtype)

通过astype可以显示地转换dtype

arr = np.array([1.2, 1.3, 1, 3, 4])
arr.dtype

int_arr = arr.astype(np.int32)
int_arr.dtype

如果某字符串全部为数字，可以用astype将其转化为数值

numeric_strings = np.array(['1.2', '1.5'], dtype=np.string_)
numeric_strings.dtype

numeric_strings.astype(np.float64)

astype可以接受其他ndarray.dtype作为输入。这应该不难理解。
second
```
 print('hi')
```

数组和标量之间的运算

大小相等的数组之间的所有运算都是元素级的

arr = np.arange(10)

arr + arr

arr ** 0.5     # ** 表示指数

arr

基本的索引和切片

arr

切片时为左包含右不包含

arr[5:8]

arr[5:8] = 12

数组切片后依旧是一个数组

arr

数组切片后，对切片的操作直接作用在源数组上

arr_slice = arr[5:8]
arr_slice[1] = 12345
arr

arr_slice[:] = 64

arr

如果要得到一个切片的副本而非视图，需要显示的使用arr[5:8].copy

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

对于2d数组的索引以下两种方式是等价的

arr2d[0][2]

arr2d[0, 2]

下图为ndarrary数组的索引方式

arr3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

arr3d

arr3d[0]

切片索引

arr[1:6]

对于多维度的数组，可以一次传入多个切片，中间用逗号，隔开

arr2d[:2, 1:]

通过将索引和切片结合，可以获得低维的切片

arr2d[1, :2]

arr2d[1]

arr2d

值得注意地：冒号表示选取整个轴

arr2d[:, :1]

二维数组切片示意图

布尔型索引

使用randn函数生成一些正态分布的随机数据

names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
data = np.random.randn(7, 4)  # 书中只使用了 randn 有误

names

data

data[:2, 2:]

names == 'Bob'

这个布尔数组可以用于索引 数组长度必须和被索引数组长度一致

data[names == 'Bob']

- 可以用来对布尔值进行取反
在Python中与和或只用一个符号来表示

mask = (names == 'Bob') | (names == 'Will')

mask

data[mask]

利用布尔型数组调整数值

data[data < 0] = 0

data

通过一维布尔数组设置整行或整列

data[names != 'Joe'] = 7

data

花式索引

利用整数数组进行索引

arr = np.empty((8, 4))
for i in range(arr.shape[0]):
    arr[i] = i

arr

# 在选取特定顺序行子集时，可以传入一个用于指定顺序的整数列表或ndarray

arr[[4, 3, 0, 6]]

使用负数索引会从末尾开始选取行

arr[[-1, -5, -7]]

一次传入多个索引数组，相当于是分别对行和列索引，返回对应位置的元素

arr = np.arange(32).reshape((8, 4))
arr  # arange 和 reshape 搭配使用可以快速构造一些简单数组

arr[[1, 5, 7, 3], [0, 3, 1, 2]]

arr[[1, 5, 7, 3]][:, [0, 3, 1, 2]]

np.ix_可以将连个一维整数数组转换为选取方形区域的索引器

arr[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])]

花式索引会复制一个数组的副本

数组转置和轴对换

转置时重塑的一种特殊形式，它返回源数据的视图

arr = np.arange(15).reshape((3, 5))
arr

arr.T

arr = np.random.randn(6, 3)

np.dot(arr.T, arr)

arr = np.arange(16).reshape((2, 2, 4))
arr

arr.transpose((1, 0, 2))

通用函数：快速的元素级数组函数

arr = np.arange(10)
np.sqrt(arr)

np.exp(arr)

x = np.random.randn(8)
y = np.random.randn(8)

np.maximum(x, y)

arr = np.random.randn(8) * 5
np.modf(arr)

arr

利用数组进行数据处理

points = np.arange(-5, 5, 0.01)
xs, ys = np.meshgrid(points, points)
ys

ys.shape

import matplotlib.pyplot as plt
z = np.sqrt(xs ** 2 + ys ** 2)
z

plt.imshow(z, cmap=plt.cm.gray)

plt.title('Image plot of $\sqrt{x^2 + y^2}$ for a grid of values')

将条件逻辑表述为数组运算

xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
cond = np.array([True, False, True, True, False])

result = [(x if c else y) for x, y, c in zip(xarr, yarr, cond)]
result

# 使用np.where来实现
result = np.where(cond, xarr, yarr)
result

arr = np.random.randn(4, 4)
arr

np.where(arr > 0, 2, -2)

np.where(arr > 0, 2, arr)

数学和统计方法

arr = np.random.randn(5, 4)

arr.mean()

np.mean(arr)

既可以作为数组的一个实例方法调用，也可以作为Numpy的顶级函数使用。

arr.mean(1)

arr = np.arange(9).reshape((3, 3))

arr.cumsum(0)

arr.cumsum(1)  # cumsum 为依次相加，参数为轴的方向

arr.cumprod(0)

基本数组统计方法

用于布尔型数组的方法

arr = np.random.randn(100)

(arr > 0 ).sum()   # 可以用sum函数对布尔值进行计数

bools = np.random.randn(5)

bools = np.where(bools > 0 , True,False)

bools

array([False, False,  True, False, False], dtype=bool)

bools.any()

True

bools.all()  # any 和 all 用来检测数组中真值的数量，存在，全部都是

False

排序

arr = np.random.randn(9)

arr

array([ 0.56648394,  0.09646596,  2.52960358,  1.01392528,  1.01635798,
        0.50707351,  0.6003978 ,  0.40438106, -0.40787323])

arr.sort()

arr

array([-0.40787323,  0.09646596,  0.40438106,  0.50707351,  0.56648394,
        0.6003978 ,  1.01392528,  1.01635798,  2.52960358])

arr = np.random.randn(5,3)

arr.sort(1)
arr        # sort函数可以用来对数组进行排序

array([[-0.09580399,  0.29251832,  1.03958502],
       [-0.56989704, -0.53186181,  0.5750816 ],
       [-0.8406608 ,  0.68156895,  2.12098301],
       [-0.35232795,  0.44457186,  1.13045437],
       [-0.74018734, -0.31642068,  1.46136771]])

np.sort 方法会返回一个数组的副本；而实例本身调用sort方法则会修改数组本身

large_arr = np.random.randn(1000)
large_arr.sort()

large_arr[int(0.05 * len(large_arr))] # 计算 5% 分位数

-1.5427390296814982

唯一化以及其他的集合逻辑

names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
np.unique(names)

array(['Bob', 'Joe', 'Will'],
      dtype='<U4')

数组的集合运算

用于数组的文件输入输出

将数组以二进制的形式保存（暂时用不到）

作为文本文件存取数组（暂时用不到，相关读写操作可以用pandas组件实现）

线性代数

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

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

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

x.dot(y)

array([[10, 13],
       [28, 40]])

y.dot(x)

array([[ 3,  4,  5],
       [ 9, 14, 19],
       [15, 24, 33]])

numpy.linalg 中有一组标准的矩阵分解运算之类的函数

from numpy.linalg import inv,qr

X = np.random.randn(5,5)

mat = X.T.dot(X)

mat

array([[ 6.6222079 ,  2.37024094,  3.04849725, -6.13510153, -2.06561393],
       [ 2.37024094,  8.98202163,  4.6212979 , -3.02490862,  4.15413675],
       [ 3.04849725,  4.6212979 ,  5.14422425, -1.59640215,  2.76677395],
       [-6.13510153, -3.02490862, -1.59640215,  8.14871046,  4.16424202],
       [-2.06561393,  4.15413675,  2.76677395,  4.16424202,  6.8966607 ]])

inv(mat)

array([[  6.92376649,   7.23887753,  -2.51673305,  11.65615503,
         -8.31493388],
       [  7.23887753,   8.55271051,  -2.51461368,  13.22100216,
         -9.95764339],
       [ -2.51673305,  -2.51461368,   1.39594234,  -3.84337402,
          2.52150043],
       [ 11.65615503,  13.22100216,  -3.84337402,  21.04459734, -15.6373916 ],
       [ -8.31493388,  -9.95764339,   2.52150043, -15.6373916 ,  12.0828665 ]])

I = mat.dot(inv(mat))

np.where(np.fabs(I) < 0.01,0,I)

array([[ 1.,  0.,  0.,  0.,  0.],
       [ 0.,  1.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  1.,  0.],
       [ 0.,  0.,  0.,  0.,  1.]])

q,r = qr(mat)

array([[-0.66000935,  0.16706919, -0.25898634, -0.58912734, -0.34975791],
       [-0.23623257, -0.76590412,  0.41085523,  0.11550852, -0.41885655],
       [-0.3038317 , -0.28146184, -0.73802815,  0.52204446,  0.10606395],
       [ 0.61146138, -0.07062138, -0.41330024, -0.13285758, -0.65776848],
       [ 0.2058716 , -0.54888124, -0.22050263, -0.59110507,  0.50825156]])

array([[-10.03350621,  -6.08472005,  -5.07325425,  11.08876476,
          3.50744819],
       [  0.        ,  -9.85059669,  -5.88395418,  -1.12001765,
         -8.38504438],
       [  0.        ,   0.        ,  -2.63770457,  -2.76179267,
         -3.04205653],
       [  0.        ,   0.        ,   0.        ,  -1.11256208,
         -1.48877537],
       [  0.        ,   0.        ,   0.        ,   0.        ,
          0.04206382]])