🍦 NumPy数组存储在内存中的一个连续位置，因此进程可以非常有效地访问和操作，此行为在计算机科学中被称为局部性。

1 Ufunc

Ufunc
- 即通用函数，指对ndarray对象进行操作的NumPy函数，用于实现矢量化。
- ufunc提供了广播和其他方法，对计算非常有帮助，也提供了额外的参数。
  - out：复制返回值的输出数组。
  - dtype：定义元素的返回类型。
  - where：布尔数组或条件定义操作应在哪里发生。
- 矢量化：将迭代语句转换为基于向量的操作，现代CPU优化了此类操作，速度更快。
- 例如：添加两个列表[1、2、3、4]和[4、5、6、7]的元素。
  - 方法一：先遍历两个列表，然后再对列表的每个元素求和。
  - 方法二：ufunc提供了add(x, y)函数，会产生相同的结果。

import numpy as np

x = [1, 2, 3, 4]
y = [4, 5, 6, 7]
z = []
for i, j in zip(x, y):              # 使用Python的内置zip()
    z.append(i + j)
print(z)

k = np.add(x, y)                    # 使用ufunc的add()函数
print(k)

创建Ufunc
- 创建ufunc，必须定义一个函数，类似Python中使用普通函数。
- 用frompyfunc()将其添加到NumPy ufunc库中，有以下参数。
  - function：函数名称。
  - inputs：输入参数(数组)的数量。
  - outputs：输出参数(数组)的数量。
- 检查是否为ufunc函数，应返回<class 'numpy.ufunc'>。
- if语句中测试函数是否为ufunc，需要使用numpy.ufunc值。

import numpy as np


def myadd(x, y):
    return x+y


myadd = np.frompyfunc(myadd, 2, 1)  # 创建ufunc函数
print(myadd([1, 2, 3, 4], [5, 6, 7, 8]))

print(type(np.concatenate))
print(type(myadd))
print(type(np.add))                 # 检查函数是否为ufunc
# print(type(np.blahblah))          # 函数无法识别，返回错误

if type(np.add) == np.ufunc:        # numpy.ufunc
    print("Add is ufunc.")
else:
    print("Add is not ufunc.")

2 简单算术

简单算术
- 加：add()函数将两个数组的内容相加，并在一个新数组中返回结果。
- 减：subtract()函数将两个数组的内容相减，并在一个新数组中返回结果。
- 乘：multiply()函数将两个数组的内容相乘，并在一个新数组中返回结果。
- 除：divide()函数将两个数组的内容相除，并且在一个新数组中返回结果。
- 幂：power()函数将一个数组的值乘以另一个数组值的幂并在新数组中返回结果。
- 余：mod()和remainder()函数都会在一个新数组中返回两个数组值相除的余数。
- 商和模：divmod()函数，返回值是两个数组，第一个数组包含商，第二个数组包含模。
- 绝对值：absolute()和abs()函数，尽量用absolute()，避免与math.abs()混淆。

import numpy as np

arr1 = np.array([10, 11, 12, 13, 14, 15])
arr2 = np.array([20, 22, 24, 26, 28, 30])
arr3 = np.add(arr1, arr2)           # 将arr1的值添加到arr2中
print(arr3)
arr4 = np.subtract(arr2, arr1)      # 将arr2的值减去arr1的值
print(arr4)
arr4 = np.absolute(arr4)            # 返回arr4值的绝对值
print(arr4)
arr5 = np.divide(arr2, arr1)        # 将arr2的值除以arr1的值
print(arr5)

arr6 = np.array([3, 2, 1, 2, 3, 2])
arr7 = np.mod(arr1, arr6)           # 返回arr1除以arr6值的余数
print(arr7)
arr7 = np.remainder(arr1, arr6)     # 返回arr1除以arr6值的余数
print(arr7)
arr8 = np.power(arr1, arr6)         # 将arr1的值提高到arr6值的幂
print(arr8)
arr9 = np.divmod(arr1, arr6)        # 返回arr1除以arr6的商和模
print(arr9)

2-1 四舍五入

四舍五入
- NumPy中主要有如下五种对小数进行四舍五入的方法。
- 通过around()函数将元素四舍五入到小数点后的指定位。
- trunc()和fix()函数删除小数并返回最接近零的浮点数。
- 使用ceil()函数将小数四舍五入到最接近的较高整数(向上取整)。
- 使用floor()函数将小数四舍五入到最接近的较低整数(向下取整)。

import numpy as np

arr1 = np.around(3.1666, 2)
print(arr1)                         # 将3.1666四舍五入到小数点后2位

arr2 = np.trunc([-3.1666, 3.6667])
print(arr2)                         # 截断数组元素

arr3 = np.fix([-3.1666, 3.6667])
print(arr3)

arr4 = np.ceil([-3.1666, 3.6667])
print(arr4)                         # 向上取整

arr5 = np.floor([-3.1666, 3.6667])
print(arr5)                         # 返回一个浮点数，向下取整，与trunc()函数返回的不同

2-2 对数函数

对数函数
- NumPy提供了以e、2和10为底的log函数，不提供指定底数的log函数。
- 若无法计算log函数，那么所有的log函数都将在元素中放置-inf或inf。

import numpy as np
from math import log

arr = np.arange(1, 10)              # 返回一个从1-10的整数数组
print(np.log(arr))                  # 自然对数
print(np.log2(arr))
print(np.log10(arr))

nplog = np.frompyfunc(log, 2, 1)
print(nplog(100, 15))               # 指定底数为15的log函数

2-3 数组求和

数组求和
- 加法是在两个参数之间完成的，而求和则是在n个元素之间进行的。
- 轴上求和：指定axis=1，NumPy将对每个数组中的数字进行求和。
- 部分求和：使用cumsum()函数，例如[1, 2, 3]部分求和为[1, 1+2, 1+2+3]。

import numpy as np

arr1 = np.array([1, 2, 3])
arr2 = np.array([1, 2, 3])

arr3 = np.sum([arr1, arr2])         # 将arr1的值与arr2的值相加，求和
print(arr3)

arr4 = np.sum([arr1, arr2], axis=1)
print(arr4)                         # 在arr1的轴上求和

arr5 = np.add(arr1, arr2)           # 将arr1的值添加到arr2的值，加法
print(arr5)

arr6 = np.cumsum(arr1)              # 累计求和(部分求和)
print(arr6)

2-4 数组乘积

数组乘积
- 查找数组中元素的乘积，可以使用prod()函数。
- 轴上乘积：该乘积方式指定了axis=1，NumPy将会返回每个数组的乘积。
- 部分乘积：使用cumprod()函数，如[1, 2, 3]部分乘积[1, 1*2, 1*2*3]。

import numpy as np

arr1 = np.array([1, 2, 3, 4])
arr2 = np.array([5, 6, 7, 8])
arr3 = np.prod(arr1)                # arr1数组元素的乘积，1*2*3*4
print(arr3)
arr3 = np.prod([arr1, arr2])        # arr1和arr2元素的乘积，1*2*3*4*5*6*7*8
print(arr3)

arr4 = np.prod([arr1, arr2], axis=1)
print(arr4)                         # 在arr1的轴上乘积

arr5 = np.cumprod(arr2)             # 累计乘积(部分乘积)
print(arr5)

2-5 数组差集

数组差集
- 使用diff()函数，例如：数组[1, 2, 3]的差集是[2-1, 3-2]。
- 通过给定参数n重复执行操作，如n=2，[1, 2, 3]差集再差集是[1-1]。

import numpy as np

arr1 = np.array([10, 15, 25, 5])

arr2 = np.diff(arr1, n=2)            # arr1数组元素的差集再差集，[10-5, -20-10]
print(arr2)

arr3 = np.diff(arr1)                 # arr1数组元素的差集，[15-10, 25-15, 5-25]
print(arr3)

3 三角函数

三角函数
- NumPy提供正弦函数sin()、余弦函数cos()和正切函数tan()。
- 三角函数默认将弧度作为参数
  - 通过deg2rad()函数，可以将数组中的所有值转换为弧度。
  - 使用rad2deg()函数，可以将数组中的所有值转换为度数。
- 并且提供了反正弦arcsin()、反余弦arccos()以及反正切arctan()，生成弧度值(角度)。
- NumPy提供hypot()函数，基于毕达哥拉斯定理(即勾股定理)获取基值和垂直值并产生斜边。

import numpy as np

base = 3
perp = 4
x = np.hypot(base, perp)            # 勾股定理求斜边
print(x)
y = np.sin(np.pi/2)                 # PI/2的正弦值
print(y)
z = np.arcsin(1.0)                  # 1.0的角度
print(z)

arr1 = np.array([1, -1, 0.1])
arr2 = np.arcsin(arr1)              # 数组arr1中所有正弦值的角度
print(arr2)
arr3 = np.array([np.pi/2, np.pi/3, np.pi/4, np.pi/5])
arr4 = np.sin(arr3)                 # 数组arr3所有值的正弦值
print(arr4)
arr5 = np.array([90, 180, 270, 360])
arr6 = np.deg2rad(arr5)             # 将数组arr5所有值转换为弧度
print(arr6)
arr7 = np.array([np.pi/2, np.pi, 1.5*np.pi, 2*np.pi])
arr8 = np.rad2deg(arr7)             # 将数组arr7所有值转换为度数
print(arr7)

4 双曲函数

双曲函数
- NumPy提供双曲正弦函数sinh()、双曲余弦函数cosh()和双曲正切函数tanh()。
- 还提供了反双曲正弦arcsinh()、反双曲余弦arccosh()和反双曲正切arctanh()。

import numpy as np

x = np.sinh(np.pi/2)                # PI/2的双曲正弦值
print(x)
y = np.arcsinh(1.0)                 # 1.0的角度
print(y)

arr1 = np.array([0.1, 0.2, 0.5])
arr2 = np.arctanh(arr1)             # 数组arr1所有tanh值的角度
print(arr2)
arr3 = np.array([np.pi/2, np.pi/3, np.pi/4, np.pi/5])
arr4 = np.cosh(arr3)                # 数组arr3所有值的双曲余弦值
print(arr4)

5 集合操作

集合操作
- 创建一个集合数组，集合数组只能是一维数组。
- unique()：可以从数组中查找唯一元素(集合)。
- union1d()：可以查找两个数组的唯一值(并集)。
- intersect1d()：仅查找两个数组都存在的值(交集)。
  - 可选参数assume_unique为True时，加快计算速度。
  - 在处理集合时，assume_unique应始终设置为True。
- setdiff1d()：仅查找一个数组中不存在于另一个数组中的值(差集)，参数assume_unique同上。
- setxor1d()：只属于一个集合不属于另一集合的元素集合(对称差集)，参数assume_unique同上。

import numpy as np

arr1 = np.array([1, 2, 3, 4])
arr2 = np.array([3, 4, 5, 6])
arr3 = np.intersect1d(arr1, arr2, assume_unique=True)
print(arr3)                         # arr1和arr2的交集
arr4 = np.setdiff1d(arr1, arr2, assume_unique=True)
print(arr4)                         # arr1和arr2的差集
arr5 = np.setxor1d(arr1, arr2, assume_unique=True)
print(arr5)                         # arr1和arr2的对称差集
arr6 = np.union1d(arr1, arr2)       # arr1和arr2的并集
print(arr6)

arr7 = np.array([1, 1, 1, 2, 3, 4, 5, 5, 6, 7])
arr8 = np.unique(arr7)              # 将具有重复元素的数组转换为集合
print(arr8)

6 最小公倍数

最小公倍数
- 使用lcm()函数，可以查找两个数的最小公倍数。
- 查找数组中所有值的最小公倍数用reduce()方法。

import numpy as np

num1 = 4
num2 = 6
x = np.lcm(num1, num2)              # num1和num2的最小公倍数
print(x)

arr1 = np.array([3, 6, 9])
y = np.lcm.reduce(arr1)             # 数组arr1所有元素的最小公倍数
print(y)

arr2 = np.arange(1, 11)             # 包含1-10所有整数的数组最小公倍数
z = np.lcm.reduce(arr2)
print(z)

7 最大公约数

最大公约数
- 使用gcd()函数，可以查找两个数的最大公约数。
- 查找数组中所有值的最大公约数用reduce()方法。

import numpy as np

num1 = 6
num2 = 9
x = np.gcd(num1, num2)              # num1和num2的最大公约数
print(x)

arr = np.array([20, 8, 32, 36, 16])
y = np.gcd.reduce(arr)              # 数组arr所有元素的最大公约数
print(y)

Python

#NumPy #数据处理 #通用函数

Python NumPy 函数

https://stitch-top.github.io/2021/05/05/python/python06-python-numpy-han-shu/

作者

Dr.626

发布于

2021年5月5日 23:00:00

许可协议

Python Pandas 上一篇

Python NumPy 随机下一篇