第一章 numpy入门

第一章 numpy入门
- 1.3 NmuPy数组的计算：通用函数
  - 1.3.1 NumPy的通用函数
  - 1.3.2 高级通用函数特性
1.3 NmuPy数组的计算：通用函数

1.3.1 NumPy的通用函数

1.数组的运算

import numpy as np
x = np.arange(4)
print("x      =",x)      # 原数组
print("x + 4  =",x + 4)  # 等价于np.add
print("x - 2  =",x - 2)  # 等价于np.subtract
print("x * 10 =",x * 10) # 等价于np.multiply
print("x / 10 =",x / 10) # 等价于np.divide
print("x // 2 =",x // 2) # 等价于np.floor_divide 地板除法 3 // 2 = 1
print("-x     =",-x)     # 等价于np.negative
print("x ** 2 =",x ** 2) # 等价于np.power
print("x % 2  =",x % 2)  # 等价于np.mod 模/余数
print("-(0.5*x + 1) ** 2 =",-(0.5*x + 10) ** 2)
# 所有这些算术运算都是Numpy内置函数的简单封装器，例如+运算就是一个add函数的封装器：
print(np.add(x,100))
x      = [0 1 2 3]
x + 4  = [4 5 6 7]
x - 2  = [-2 -1  0  1]
x * 10 = [ 0 10 20 30]
x / 10 = [ 0.   0.1  0.2  0.3]
x // 2 = [0 0 1 1]
-x     = [ 0 -1 -2 -3]
x ** 2 = [0 1 4 9]
x % 2  = [0 1 0 1]
-(0.5*x + 1) ** 2 = [-100.   -110.25 -121.   -132.25]
[100 101 102 103]
2.绝对值
x = np.array([-2,-3,3,5,7])
print("x的本身只为：\n",x)
print("x的绝对值为：\n",np.abs(x))
print("x的绝对值为：\n",np.absolute(x))
# 这个通用函数可以处理复数，当处理复数时，绝对值返回的是该复数的幅度：
x = np.array([3 - 5j,6 - 4j,3 + 0j,0 + 5j])
print("复数本身为：\n",x)
print("复数绝对值为：\n",np.abs(x))
x的本身只为：
 [-2 -3  3  5  7]
x的绝对值为：
 [2 3 3 5 7]
x的绝对值为：
 [2 3 3 5 7]
复数本身为：
 [ 3.-5.j  6.-4.j  3.+0.j  0.+5.j]
复数绝对值为：
 [ 5.83095189  7.21110255  3.          5.        ]
3.三角函数
theta = np.linspace(0,np.pi,3)
print("三角函数：")
print("theta      =",theta)
print("sin(theta) =",np.sin(theta))
print("cos(theta) =",np.cos(theta))
print("tan(theta) =",np.tan(theta))
# 这些值有些应该为0 ，由于机器精度没有精确到0.
x = [-1,0,1]
print("反三角函数：")
print("x         =",x)
print("arcsin(x) =",np.arcsin(x))
print("arccos(x) =",np.arccos(x))
print("arctan(x) =",np.arctan(x))
三角函数：
theta      = [ 0.          1.57079633  3.14159265]
sin(theta) = [  0.00000000e+00   1.00000000e+00   1.22464680e-16]
cos(theta) = [  1.00000000e+00   6.12323400e-17  -1.00000000e+00]
tan(theta) = [  0.00000000e+00   1.63312394e+16  -1.22464680e-16]
反三角函数：
x         = [-1, 0, 1]
arcsin(x) = [-1.57079633  0.          1.57079633]
arccos(x) = [ 3.14159265  1.57079633  0.        ]
arctan(x) = [-0.78539816  0.          0.78539816]
4.指数和对数
x = [1,2,3]
print("指数函数：")
print("x        =",x)
print("e^x      =",np.exp(x))
print("2^x      =",np.exp2(x))
print("3^x      =",np.power(3,x))
x = [1,2,4,10]
print("对数函数：")
print("x        =",x)
print("ln(x)    =",np.log(x))
print("log2(x)  =",np.log2(x))
print("log10(x) =",np.log10(x))
指数函数：
x        = [1, 2, 3]
e^x      = [  2.71828183   7.3890561   20.08553692]
2^x      = [ 2.  4.  8.]
3^x      = [ 3  9 27]
对数函数：
x        = [1, 2, 4, 10]
ln(x)    = [ 0.          0.69314718  1.38629436  2.30258509]
log2(x)  = [ 0.          1.          2.          3.32192809]
log10(x) = [ 0.          0.30103     0.60205999  1.        ]
5.专用的通用函数
# 除了以上函数，Numpy还提供很多通用的函数，包括双曲线函数、比特位函数、比较运算符、弧度转化为角度的运算、取整和求余运算，等等。
# 子模块scipy.special将提供更有趣的数学计算，详细见Numpy文档。
from scipy import special
# Gamma函数（广义阶乘，generalized factorials）和相关函数
x = [1,5,10]
print("Gamma函数（广义阶乘，generalized factorials）和相关函数")
print("x            =",x)
print("gamma(x)     =",special.gamma(x))
print("ln|gamma(x)| =",special.gammaln(x))
print("beta(x,2)    =",special.beta(x,2))
# 误差函数（高斯积分）
# 它的实现与你实现
x = np.array([0,0.2,0.7,1.0])
print("误差函数（高斯积分）")
print("x     =",x)
print("erf(x)",special.erf(x))
print("erfc(x) =",special.erfc(x))
print("erfinv(x) =",special.erfinv(x))
Gamma函数（广义阶乘，generalized factorials）和相关函数
x            = [1, 5, 10]
gamma(x)     = [  1.00000000e+00   2.40000000e+01   3.62880000e+05]
ln|gamma(x)| = [  0.           3.17805383  12.80182748]
beta(x,2)    = [ 0.5         0.03333333  0.00909091]
误差函数（高斯积分）
x     = [ 0.   0.2  0.7  1. ]
erf(x) [ 0.          0.22270259  0.67780119  0.84270079]
erfc(x) = [ 1.          0.77729741  0.32219881  0.15729921]
erfinv(x) = [ 0.          0.17914345  0.73286908         inf]
1.3.2 高级通用函数特性
注意：以上通用函数都拥有次节的特性！！！！！！！！！！！！！！！！！！！！！！
1.指定输出
# 在进行大量运算时，有时候指定一个用于存放运算结果的数组是非常有用的。不同于创建零时数组，
# 你可以用这个特性将计算结果写入到你期望的存储位置。
# 所有的通用函数都可以通过out参数来指定计算结果的存放位置：
x = np.arange(5)
y = np.empty(5)
print(x,y)
np.multiply(x,10,out=y)
print(x,y)
# 这个特性可以被用作数据的视图
y = np.zeros(10)
np.power(2,x,out=y[::2])
print(y)
# 如果这里写的是y[::2] = 2 ** 2，那么结果将是创建一个临时数组，该数组存放的是 2 ** x 的结果，并将接下来会将这些值赋值到y数组中。
# 但对于大数组时 out参数会更节约内存。
[0 1 2 3 4] [  1.   2.   4.   8.  16.]
[0 1 2 3 4] [  0.  10.  20.  30.  40.]
[  1.   0.   2.   0.   4.   0.   8.   0.  16.   0.]
x = np.arange(1,6)
print(x)
print(np.add.reduce(x))
print(np.multiply.reduce(x))
# 存储每次计算的中间结果
print(np.add.accumulate(x))
print(np.multiply.accumulate(x))
[1 2 3 4 5]
[ 1  3  6 10 15]
[  1   2   6  24 120]
x = np.arange(1,6)
print(x)
print(np.multiply.outer(x,x))
# 更多通用函数见 
    # Numpy（http://www.numpy.org）和SciPy(http://www.scipy.org)文档。
[1 2 3 4 5]
[[ 1  2  3  4  5]
 [ 2  4  6  8 10]
 [ 3  6  9 12 15]
 [ 4  8 12 16 20]
 [ 5 10 15 20 25]]