NumPy 学习笔记
NumPy 是一个 Python 库。
NumPy 用于处理数组。
NumPy 是“Numerical Python”的缩写。
创建一个 NumPy 数组：
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr)
print(type(arr))
输出：
[1 2 3 4 5]
<class 'numpy.ndarray'>
NumPy 介绍
在 Python 中，我们有用于数组目的的列表，但它们的处理速度很慢。
NumPy 旨在提供比传统的 Python 快的列表。
NumPy 中的数组对象称为ndarray， 它提供了许多支持功能，使使用变得非常容易。
数组在数据科学中非常频繁地使用，其中速度和资源 都非常重要。
数据科学：是计算机科学的一个分支，我们研究如何存储、使用和分析数据以从中获取信息。
与列表不同，NumPy 数组存储在内存中的一个连续位置，因此进程可以非常有效地访问和操作它们。
这种行为在计算机科学中称为参考局部性。
这就是 NumPy 比传统python列表更快的主要原因。此外，它还经过优化，可与最新的 CPU 架构配合使用。
NumPy是一个Python库，部分是用Python编写的，但大多数需要快速计算的部分都是用C或C++编写的。
NumPy 的源代码位于此 github 存储库 Numpy
NumPy 入门
pip install numpy安装numpy
导入 NumPy
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr)
NumPy 创建数组
可以将列表、元组或任何类似数组的对象传递到方法中，它将被转换为：ndarray
arr = np.array((1, 2, 3, 4, 5))
arr = np.array([1, 2, 3, 4, 5])
创建一个值为 42 的 0-D 数组:
arr = np.array(42)
创建一个包含值 1、2、3、4、5 的 1-D 数组：
arr = np.array([1, 2, 3, 4, 5])
创建一个包含两个数组的 2-D 数组，其值分别为 1,2,3 和 4,5,6：
arr = np.array([[1, 2, 3], [4, 5, 6]])
创建一个具有两个二维数组的三维数组:
arr = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])
检查数组有多少个维度:
arr.ndim
数组可以具有任意数量的维度。
创建一个具有 5 个维度的数组，并验证它是否具有 5 个维度：
arr = np.array([1, 2, 3, 4], ndmin=5)
print(arr)
print('number of dimensions :', arr.ndim)
[[[[[1 2 3 4]]]]]
number of dimensions : 5
NumPy 数组索引
从以下数组中获取第一个元素：
arr = np.array([1, 2, 3, 4])
print(arr[0])
1
二维数组想象成一个包含行和列的表格，其中维度 表示行，索引表示列。
arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])
print('2nd element on 1st row: ', arr[0, 1])
2
三维数组，访问第一个数组的第二个数组的第三个元素：
arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print(arr[0, 1, 2])
6
也和python一样支持负索引
NumPy 数组切片
一维的和python一样
二维的:
arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
print(arr[1, 1:4])
输出：
[7 8 9]
arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
print(arr[0:2, 2])
输出：
[3 8]
NumPy 数据类型
i - integer
b - boolean
u - unsigned integer
f - float
c - complex float
m - timedelta
M - datetime
O - object
S - string
U - unicode string
V - fixed chunk of memory for other type ( void )
获取数组对象的数据类型：
arr = np.array([1, 2, 3, 4])
arr = np.array(['apple', 'banana', 'cherry'])
print(arr.dtype)
print(arr.dtype)
int32
<U6 (长度不超过6的Unicode字符串)
创建数据类型为字符串的数组：
arr = np.array([1, 2, 3, 4], dtype='S')
print(arr)
print(arr.dtype)
[b'1' b'2' b'3' b'4']
|S1 (长度为1的字符串)
在现有数组上转换数据类型:
arr = np.array([1.1, 2.1, 3.1])
newarr = arr.astype('i')
print(newarr)
print(newarr.dtype)
[1 2 3]
int32
NumPy 数组副本与视图
副本拥有数据，对副本所做的任何更改都不会影响原始数组，并且对原始数组所做的任何更改都不会影响副本。
视图不拥有数据，对视图所做的任何更改都将拥有影响原始数组，对原始数组所做的任何更改都将影响视图。
副本：
arr = np.array([1, 2, 3, 4, 5])
x = arr.copy()
视图：
arr = np.array([1, 2, 3, 4, 5])
x = arr.view()
检查数组是否拥有其数据：
arr = np.array([1, 2, 3, 4, 5])
x = arr.copy()
y = arr.view()
print(x.base)
print(y.base)
输出：
None (如果数组拥有数据，则返回None)
[1 2 3 4 5] (否则，该属性引用原始对象)
NumPy 数组形状
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
print(arr.shape)
输出：
(2, 4) (这意味着数组有 2 个维度， 其中第一个维度有 2 个元素，第二个维度有 4 个元素)
再例：
arr = np.array([1, 2, 3, 4], ndmin=5)
print(arr)
print('shape of array :', arr.shape)
输出：
[[[[[1 2 3 4]]]]]
shape of array : (1, 1, 1, 1, 4)
# 可以说第 5 个维度有 4 个元素
NumPy 数组reshape
即：改变数组的形状。
通过重塑，我们可以添加或删除维度或更改每个维度中的元素数量。
从一维到二维重塑：
将以下具有 12 个元素的一维数组转换为二维数组。
最外层的维度将有 4 个数组，每个数组有 3 个元素：
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
newarr = arr.reshape(4, 3)
print(newarr)
输出：
[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]
从一维到三维重塑：
将以下具有 12 个元素的一维数组转换为三维数组。
最外层维度将有 2 个数组，每个数组包含 3 个数组 有 2 个元素：
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
newarr = arr.reshape(2, 3, 2)
print(newarr)
输出：
[[[ 1 2]
[ 3 4]
[ 5 6]]
[[ 7 8]
[ 9 10]
[11 12]]]
返回 Copy 还是 View？
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
print(arr.reshape(2, 4).base)
输出：
[1 2 3 4 5 6 7 8]
# 因此它是一个视图。
未知维度
这意味着您不必为其中一个指定确切的数字 Reshape 方法中的尺寸。
传递-1作为值，NumPy 将为您计算这个数字。
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
newarr = arr.reshape(2, 2, -1)
print(newarr)
输出：
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
展平数组
意味着将多维数组转换为一维数组。
我们可以用它来做到这一点。reshape(-1)
arr = np.array([[1, 2, 3], [4, 5, 6]])
newarr = arr.reshape(-1)
print(newarr)
输出：
[1 2 3 4 5 6]
NumPy 数组迭代
迭代一维数组
arr = np.array([1, 2, 3])
for x in arr:
print(x)
输出：
1
2
3
迭代二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
for x in arr:
print(x)
输出：
[1 2 3]
[4 5 6]
# 如果我们迭代一个 n 维数组，它将一个接一个地经历 n-1 维。
逐一遍历：
arr = np.array([[1, 2, 3], [4, 5, 6]])
for x in arr:
for y in x:
print(y)
输出：
1
2
3
4
5
6
迭代以下 3-D 数组的元素：
arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
for x in arr:
print(x)
输出：
[[1 2 3]
[4 5 6]]
[[ 7 8 9]
[10 11 12]]
使用 nditer（） 迭代数组
在基本循环中，遍历数组的每个标量，我们需要使用 n 个for循环，这对于具有非常高维数的数组来说可能很难编写
arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
for x in np.nditer(arr):
print(x)
输出：
1
2
3
4
5
6
7
8
使用不同的步长进行迭代
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
for x in np.nditer(arr[:, ::2]):
print(x)
输出：
1
3
5
7
使用 ndenumerate（） 的枚举迭代
枚举意味着逐个提及序列号。
有时我们在迭代时需要元素的相应索引
arr = np.array([1, 2, 3])
for idx, x in np.ndenumerate(arr):
print(idx, x)
输出：
(0,) 1
(1,) 2
(2,) 3
NumPy 连接数组
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
arr = np.concatenate((arr1, arr2))
#沿行堆叠 arr = np.hstack((arr1, arr2))
print(arr)
输出：
[1 2 3 4 5 6]
沿行连接两个二维数组 （axis=1）
arr1 = np.array([[1, 2],
[3, 4]])
arr2 = np.array([[5, 6],
[7, 8]])
arr = np.concatenate((arr1, arr2), axis=1)# 沿行
arr1 = np.concatenate((arr1, arr2), axis=0)# 沿列
print(arr)
print(arr1)
# 维数不变
输出：
[[1 2 5 6]
[3 4 7 8]]
[[1 2]
[3 4]
[5 6]
[7 8]]
使用堆栈函数联接数组
堆叠与串联相同，唯一的区别是堆叠是沿着新轴完成的。
我们可以沿第二个轴连接两个一维数组，这将导致将它们一个放在另一个上
沿列竖着堆叠（axis = 0可以省略）维数+1：
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
arr = np.stack((arr1, arr2), axis=0)
# axis=0 可以省略
# 等于 arr = np.vstack((arr1, arr2))
print(arr)
输出：
[[1 2 3]
[4 5 6]]
沿高度(深度)堆叠：
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
arr = np.stack((arr1, arr2), axis=1)
# arr = np.dstack((arr1, arr2))
print(arr)
输出：
[[1 4]
[2 5]
[3 6]]
NumPy 拆分数组
我们用于拆分数组，我们将要拆分的数组传递给它 以及拆分次数。
arr = np.array([1, 2, 3, 4, 5, 6])
newarr = np.array_split(arr, 3)
print(newarr)
输出：
[array([1, 2]), array([3, 4]), array([5, 6])]
如果数组的元素少于所需的元素，它将相应地从末尾进行调整。
arr = np.array([1, 2, 3, 4, 5, 6])
newarr = np.array_split(arr, 4)
print(newarr)
输出：
[array([1, 2]), array([3, 4]), array([5]), array([6])]
访问拆分的数组：
arr = np.array([1, 2, 3, 4, 5, 6])
newarr = np.array_split(arr, 3)
print(newarr[0])
print(newarr[1])
print(newarr[2])
输出：
[1 2]
[3 4]
[5 6]
拆分二维阵列
将二维数组拆分为三个二维数组。
arr = np.array([[1, 2],
[3, 4],
[5, 6],
[7, 8],
[9, 10],
[11, 12]])
newarr = np.array_split(arr, 3)
print(newarr)
输出：
[array([[1, 2],
[3, 4]]),
array([[5, 6],
[7, 8]]),
array([[ 9, 10],
[11, 12]])]
此外，还可以指定要围绕哪个轴进行分割。
下面的示例还返回三个二维数组，但它们沿着深度 （axis=1）
arr = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
[10, 11, 12],
[13, 14, 15],
[16, 17, 18]])
newarr = np.array_split(arr, 3, axis=1)
# 沿深度 newarr = np.hsplit(arr, 3)
print(newarr)
输出：
[array([[ 1],
[ 4],
[ 7],
[10],
[13],
[16]]),
array([[ 2],
[ 5],
[ 8],
[11],
[14],
[17]]),
array([[ 3],
[ 6],
[ 9],
[12],
[15],
[18]])]
NumPy 搜索数组
在数组中搜索特定值，并返回获得匹配项的索引。
若要搜索数组，请使用以下方法。where()
arr = np.array([1, 2, 3, 4, 5, 4, 4])
x = np.where(arr == 4)
# 查找值为偶数的索引： x = np.where(arr%2 == 0)
# 查找值为奇数的索引： x = np.where(arr%2 == 1)
print(x)
输出：
(array([3, 5, 6], dtype=int64),)
搜索排序
在数组中执行二进制搜索， 并返回将插入指定值的索引，以保持 搜索顺序。searchsorted()
arr = np.array([6, 7, 8, 9])
x = np.searchsorted(arr, 7)
print(x)
输出：
1
从右侧搜索：
arr = np.array([6, 7, 8, 9])
x = np.searchsorted(arr, 7, side='right')
print(x)
多个值：
arr = np.array([1, 3, 5, 7])
x = np.searchsorted(arr, [2, 4, 6])
print(x)
输出：
[1 2 3]
NumPy 排序数组
arr = np.array([3, 2, 0, 1])
print(np.sort(arr))
输出：
[0 1 2 3]
对布尔数组进行排序：
arr = np.array([True, False, True])
print(np.sort(arr))
输出：
[False True True]
对二维数组进行排序
如果对二维数组使用 sort（） 方法，则两个数组都将进行排序：
arr = np.array([[3, 2, 4], [5, 0, 1]])
print(np.sort(arr))
输出：
[[2 3 4]
[0 1 5]]
NumPy 过滤数组
从现有数组中获取一些元素并创建一个新数组 其中称为过滤。
在 NumPy 中，使用布尔索引列表筛选数组。
如果该索引处的值是False，则从筛选数组中排除该元素。
arr = np.array([41, 42, 43, 44])
x = [True, False, True, False]
newarr = arr[x]
print(newarr)
输出：
[41 43]
创建筛选器数组
创建一个仅返回大于 42 的值的筛选器数组：
arr = np.array([41, 42, 43, 44])
filter_arr = []
for element in arr:
if element > 42: # 根据任务修改这行
filter_arr.append(True)
else:
filter_arr.append(False)
newarr = arr[filter_arr]
print(filter_arr)
print(newarr)
直接从数组创建过滤器
arr = np.array([41, 42, 43, 44])
filter_arr = arr > 42
newarr = arr[filter_arr]
print(filter_arr)
print(newarr)
输出：
[False False True True]
[43 44]
NumPy random库-暂略
NumPy 以下介绍ufuncs
ufuncs 代表“通用函数”，它们是 NumPy 函数， 对ndarray对象进行操作
ufuncs 用于在 NumPy 中实现矢量化（将迭代语句转换为基于向量的操作称为矢量化。），这比迭代元素要快得多。
由于现代 CPU 针对此类操作进行了优化，因此速度更快。
没有 ufunc，我们可以使用 Python 的内置方法：
x = [1, 2, 3, 4]
y = [4, 5, 6, 7]
z = []
for i, j in zip(x, y):
z.append(i + j)
print(z)
输出：
[5, 7, 9, 11]
使用 ufunc，我们可以使用以下函数：add()
x = [1, 2, 3, 4]
y = [4, 5, 6, 7]
z = np.add(x, y)
print(z)
输出相同
创建自己的 ufunc
要创建自己的 ufunc，您必须定义一个函数，就像您在 Python 中使用普通函数一样，然后使用frompyfunc()方法将其添加到您的 NumPy ufunc 库中。
该方法采用以下参数：frompyfunc()
function- 函数的名称。
inputs- 输入参数（数组）的数量。
outputs- 输出数组的数量。
def myadd(x, y):
return x+y
# 输入2个，输出1个
myadd = np.frompyfunc(myadd, 2, 1)
print(myadd([1, 2, 3, 4], [5, 6, 7, 8]))
检查函数的类型以检查它是否是 ufunc。
print(type(np.add))
输出：
<class 'numpy.ufunc'>
ufunc 简单算术
加法：上述已说明（np.add()）
减法：
arr1 = np.array([10, 20, 30, 40, 50, 60])
arr2 = np.array([20, 21, 22, 23, 24, 25])
newarr = np.subtract(arr1, arr2)
print(newarr)
输出：
[-10 -1 8 17 26 35]
乘法：
arr1 = np.array([10, 20, 30, 40, 50, 60])
arr2 = np.array([20, 21, 22, 23, 24, 25])
newarr = np.multiply(arr1, arr2)
print(newarr)
输出：
[ 200 420 660 920 1200 1500]
除法：
arr1 = np.array([10, 20, 30, 40, 50, 60])
arr2 = np.array([3, 5, 10, 8, 2, 33])
newarr = np.divide(arr1, arr2)
print(newarr)
输出：
[ 3.33333333 4. 3. 5. 25. 1.81818182]
幂运算：
arr1 = np.array([10, 20, 30, 40, 50, 60])
arr2 = np.array([3, 5, 6, 8, 2, 33])
newarr = np.power(arr1, arr2)
print(newarr)
输出：
[1000 3200000 729000000 6553600000000 2500 0]
求余：
arr1 = np.array([10, 20, 30, 40, 50, 60])
arr2 = np.array([3, 7, 9, 8, 2, 33])
newarr = np.mod(arr1, arr2)
# newarr = np.remainder(arr1, arr2)
print(newarr)
输出：
[1 6 3 0 0 27]
商和余数：
arr1 = np.array([10, 20, 30, 40, 50, 60])
arr2 = np.array([3, 7, 9, 8, 2, 33])
newarr = np.divmod(arr1, arr2)
print(newarr)
输出：
(array([ 3, 2, 3, 5, 25, 1]), array([ 1, 6, 3, 0, 0, 27]))
绝对值：
arr = np.array([-1, -2, 1, 2, 3, -4])
newarr = np.absolute(arr)
print(newarr)
ufunc 四舍五入
截断
删除小数，并返回最接近零的浮点数。trunc()和fix()
arr = np.trunc([-3.1666, 3.6667])
# arr = np.fix([-3.1666, 3.6667])
print(arr)
输出：
[-3. 3.]
四舍五入
如果 >=5，则该函数将前面的数字或十进制递增 1，否则什么都不做。
arr = np.around(3.1666, 2)
print(arr)
输出：
3.17
下取整
将小数四舍五入到最接近的下整数
arr = np.floor([-3.1666, 3.6667])
print(arr)
输出：
[-4. 3.]
上取整
将小数四舍五入到最接近的大整数
arr = np.ceil([-3.1666, 3.6667])
print(arr)
输出：
[-3. 4.]
ufunc log()对数函数
NumPy 提供了在基数 2、e 和 10 上执行对数函数。
log2()
使用该函数在基数 2 处执行日志。log2()
arr = np.arange(1, 10)
print(np.log2(arr))
输出：
[0. 1. 1.5849625 2. 2.32192809 2.5849625
2.80735492 3. 3.169925 ]
log10()
arr = np.arange(1, 10)
print(np.log10(arr))
输出：
[0. 0.30103 0.47712125 0.60205999 0.69897 0.77815125
0.84509804 0.90308999 0.95424251]
自然对数
arr = np.arange(1, 10)
print(np.log(arr))
输出：
[0. 0.69314718 1.09861229 1.38629436 1.60943791 1.79175947
1.94591015 2.07944154 2.19722458]
在任何基底的log
from math import log
import numpy as np
nplog = np.frompyfunc(log, 2, 1)
print(nplog(100, 15))
输出：
ufunc add()和sum()求和
arr1 = np.array([1, 2, 3])
arr2 = np.array([1, 2, 3])
前面
newarr = np.add(arr1, arr2)
# [2 4 6]
是对应求和
下面 将 arr1 中的值和 arr2 中的值相加：
newarr = np.sum([arr1, arr2])
# 12
newarr = np.sum([arr1, arr2], axis=1)
# [6 6]
累计求和
例如，[1， 2， 3， 4] 的部分和将是 [1， 1+2， 1+2+3， 1+2+3+4] = [1， 3， 6， 10]
newarr = np.cumsum(arr1)
# [1 3 6]
ufunc prod()乘积
arr = np.array([1, 2, 3, 4])
x = np.prod(arr)
print(x)
输出：
返回：因为 1*2*3*4 = 2424
求两个数组元素的乘积：
arr1 = np.array([1, 2, 3, 4])
arr2 = np.array([5, 6, 7, 8])
x = np.prod([arr1, arr2])
# newarr = np.prod([arr1, arr2], axis=1)
print(x)
# print(newarr)
输出：
返回：因为 1*2*3*4*5*6*7*8 = 40320
# 输出[24 1680]
累计求积
# 例如，[1， 2， 3， 4] 的偏积为 [1， 1*2， 1*2*3， 1*2*3*4] = [1， 2， 6， 24]
arr = np.array([5, 6, 7, 8])
newarr = np.cumprod(arr)
print(newarr)
输出：
[5 30 210 1680]
ufunc diff()
离散差值意味着减去两个连续的元素。
例如，对于 [1， 2， 3， 4]，离散差为 [2-1， 3-2， 4-3] = [1， 1， 1]
可以通过给出参数来重复执行此操作。
arr = np.array([10, 15, 25, 5])
newarr = np.diff(arr)
print(newarr)
输出：
返回：因为 15-10=5、25-15=10 和 5-25=-20[5 10 -20]
计算以下数组的离散差值两次：
arr = np.array([10, 15, 25, 5])
newarr = np.diff(arr, n=2)
print(newarr)
输出：
返回：因为：15-10=5、25-15=10、5-25=-20、10-5=5 和 -20-10=-30[5 -30]
ufunc 查找 LCM（最小公倍数）
num1 = 4
num2 = 6
x = np.lcm(num1, num2)
print(x)
输出：
12
在阵列中查找 LCM
arr = np.array([3, 6, 9])
x = np.lcm.reduce(arr)
print(x)
输出：
18
求数组包含从 1 到 10 的所有整数的数组的所有值的 LCM：
arr = np.arange(1, 11)
x = np.lcm.reduce(arr)
print(x)
输出：
2520
ufunc GCD（最大公约数）
num1 = 6
num2 = 9
x = np.gcd(num1, num2)
print(x)
在以下数组中查找所有数字的 GCD：
arr = np.array([20, 8, 32, 36, 16])
x = np.gcd.reduce(arr)
print(x)
输出：
4
ufunc 三角函数
x = np.sin(np.pi/2)
print(x)
查找 arr 中所有值的正弦值：
arr = np.array([np.pi/2, np.pi/3, np.pi/4, np.pi/5])
x = np.sin(arr)
print(x)
输出：
[1. 0.8660254 0.70710678 0.58778525]
将度数转换为弧度deg2rad()
注意：弧度值为 pi/180 * degree_values。
arr = np.array([90, 180, 270, 360])
x = np.deg2rad(arr)
print(x)
输出：
[1.57079633 3.14159265 4.71238898 6.28318531]
弧度到度rad2deg()
arr = np.array([np.pi/2, np.pi, 1.5*np.pi, 2*np.pi])
x = np.rad2deg(arr)
print(x)
输出：
[ 90. 180. 270. 360.]
寻找角度arcsin()、arccos()、arctan()
x = np.arcsin(1.0)
print(x)
输出：
1.5707963267948966（pi/2）
斜边hypot()
base = 3
perp = 4
x = np.hypot(base, perp)
print(x)
输出：
5
NumPy 双曲函数暂略
NumPy 集合操作暂略
学习地址W3S
标签：arr,newarr,print,数组,np,array,Numpy From： https://www.cnblogs.com/dxlindex/p/18122477