科学计算基础包

Numpy

量化投资实际上就是分析数据从而做出决策的过程

Python数据处理相关模块：

NumPy：数组批量计算

pandas：灵活的表计算

Matplotlib：数据可视化

1，IPython

交互式的python命令行，在上面运行很直截了当

安装可直接通过pip进行安装：pip install ipython

anacoda发行版中包括了ipython和上面三个模块

IPython高级功能

①TAB键自动完成

②?: 内省，命名空间搜索

问号后面写入命令，可以列出相近的命令，第三个为命名空间搜索

亦或直接打印出命令后加问号，可以显示该命令在python解释器中的具体信息。

碰见函数，函数名后加一个问号表示显示函数相关信息，两个问号则打印出函数体。

③!: 执行系统命令

叹号后面可写入系统命令，然后执行系统命令

④丰富的快捷键

⑤魔术命令

魔术命令是以%开始的命令

%run：后跟要执行的文件代码

%paste：执行剪贴板代码

%timeit：评估运行时间

%pdb：自动调试

　　　　调试之前%pdb on，调试时，定在出错的那一步

　　　　调试结束%pdb off，%pdb主要功能还是查找出错在哪一步

其他魔术命令：

演示如下图：

%pdb调试器中常用命令合集：

⑥使用命令历史

当在ipython中执行命令时，可以通过按键盘上下方向键来获得曾执行过的命令历史。

也可输入前面执行过的命令前部分，按方向上键来切换选择符合要求的命令历史。

⑦获取输入输出结果

获取输出结果：

通过下划线获得，若前面有若干已知结果，则可用下划线表示上面产生的结果。

一个下划线表示上面倒数第一个结果，以此类推。

获取输入结果：

_i后加上中括号的数字，比如 _i72表示

⑧目录标签系统

%bookmark

设置标签和目录：

%bookmark + 自己设置的标签 + 目录（如：%bookmark proj /Users/qiuma/Documents/work/PyProjects）

切换目录：

cd + 自己设置的标签（如：cd proj 则可以切换到相应目录下）

查看所有标签目录：

%bookmark -l

删除某一个设置的标签和目录：

%bookmark -d + 设置的标签

删除所有标签：

%bookmark -r

⑧IPython Notebook（升级版的解释器）

安装jupyter：

!pip3 install jupyter

运行notebook:

jupyter notebook

2，NumPy: 数组批量计算

1，简介：

NumPy时高性能科学计算和数据分析的基础包。它是pandas等其他各种工具的基础。

NumPy的主要功能：

　　①ndarray，一个多维数组结构，高效节省空间。（最主要功能）

　　②无需循环对整组数据进行快速运算的数学函数。

　　③线性代数，随机数生成和傅里叶变换功能。

安装方法：pip install numpy

引用方式：在ipython界面：import numpy as np

实例一：

已知若干家跨国公司的市值（美元），将其换算为人民币

import numpy as np
import random

a = [random.uniform(100.0, 200.0) for i in range(50)]  # 得到50个100到200之间的浮点数，作为50家公司的各个市值
b = []
x = 6.8  # 美元兑换汇率
print(a)

for ele in a:
    b.append(ele*x)

print(b)
a = np.array(a)
print(a*x)

示例运行结果：

[112.48218047778754, 154.3964189281224, 126.6564687724279, 140.7159469183412, 196.12837897320816, 128.98351120042096, 117.63731081020956, 128.39360699508416, 198.23248616705578, 130.80467752193297, 119.66972136557385, 137.18004817748528, 152.37208333942348, 100.07894707157213, 154.97705379903817, 134.05761429076242, 153.04847207369724, 192.06685116566732, 143.51752975643961, 129.4848889046978, 139.92121971390807, 134.36074381683443, 161.64704453396354, 110.25732640486731, 180.37276902905649, 148.46831390171718, 157.5093766230885, 192.16505851660793, 148.18398878746865, 109.2532506149139, 154.17242953490353, 120.31526151128904, 175.46121275197, 112.20930006649692, 132.77392894374492, 170.02561393749522, 163.08450343763423, 108.81452103896359, 122.97118088431432, 136.92810986572331, 115.01847895746945, 123.74027791188705, 186.44587713561134, 107.04788928648148, 112.14516176414944, 185.45777045970377, 188.25578876113082, 162.97689872192018, 167.49402672551025, 195.58102286249198]
[764.8788272489552, 1049.8956487112323, 861.2639876525097, 956.86843904472, 1333.6729770178154, 877.0878761628625, 799.9337135094249, 873.0765275665723, 1347.9809059359793, 889.4718071491442, 813.7541052859021, 932.8243276068998, 1036.1301667080797, 680.5368400866905, 1053.8439658334596, 911.5917771771844, 1040.7296101011411, 1306.0545879265378, 975.9192023437894, 880.4972445519451, 951.4642940545749, 913.6530579544741, 1099.199902830952, 749.7498195530977, 1226.534829397584, 1009.5845345316768, 1071.0637610370018, 1306.722397912934, 1007.6511237547868, 742.9221041814145, 1048.372520837344, 818.1437782767655, 1193.136246713396, 763.023240452179, 902.8627168174654, 1156.1741747749675, 1108.9746233759126, 739.9387430649524, 836.2040300133374, 931.1111470869185, 782.1256569107923, 841.4338898008319, 1267.831964522157, 727.9256471480741, 762.5870999962161, 1261.1128391259856, 1280.1393635756895, 1108.2429113090573, 1138.9593817334696, 1329.9509554649453]
[ 764.87882725 1049.89564871  861.26398765  956.86843904 1333.67297702
  877.08787616  799.93371351  873.07652757 1347.98090594  889.47180715
  813.75410529  932.82432761 1036.13016671  680.53684009 1053.84396583
  911.59177718 1040.7296101  1306.05458793  975.91920234  880.49724455
  951.46429405  913.65305795 1099.19990283  749.74981955 1226.5348294
 1009.58453453 1071.06376104 1306.72239791 1007.65112375  742.92210418
 1048.37252084  818.14377828 1193.13624671  763.02324045  902.86271682
 1156.17417477 1108.97462338  739.93874306  836.20403001  931.11114709
  782.12565691  841.4338898  1267.83196452  727.92564715  762.5871
 1261.11283913 1280.13936358 1108.24291131 1138.95938173 1329.95095546]

2，ndarray-多维数组对象

①创建ndarray：np.array(array_like)

②数组array与列表list的区别：

　　数组对象内的元素类型必须相同，列表中的数据类型不必相同；

　　数组大小不可修改；

　　列表中的数据类型保存的是数据存放的地址，即指针，并非数据，这样保存一个list就太麻烦了，例如list1=[1,2,3,'a']需要4个指针和四个数据，增加了存储和消耗cpu。

3，ndarray-常用属性

①dtype 数组元素的数据类型，表示一个数能到多大，和cpu位数有关(32位64位)。能存多少数的个数取决于内存。

②size：数组元素的个数

③ndim：数组的维数

④shape：数组的维度大小（元组形式）。返回几乘几，元组，几行几列。

⑤dtype：数组元素的数据类型

⑥T：数组的转置（对高维数组而言）

In [16]: a = np.array(range(10))

In [17]: a.dtype  # 返回数组元素的数据类型
Out[17]: dtype('int32')

In [18]: a.size  # 返回元素的个数
Out[18]: 10

In [19]: a.ndim  # 返回数组的维数
Out[19]: 1

In [20]: a.shape  # 以元组形式返回数组的维度大小
Out[20]: (10,)

In [21]: a = np.array([[1,2,3],[4,5,6]])  # 二维数组

In [22]: a
Out[22]:
array([[1, 2, 3],
       [4, 5, 6]])

In [23]: a.dtype  # 返回数据类型，int32表示数的位数大小为32位。
Out[23]: dtype('int32')

In [24]: a.size
Out[24]: 6

In [25]: a.shape
Out[25]: (2, 3)

In [27]: a = np.array([[[1,2,3],[4,5,6]],[[1,2,3],[4,5,6]]])  # 三维数组

In [28]: a
Out[28]:
array([[[1, 2, 3],
        [4, 5, 6]],

       [[1, 2, 3],
        [4, 5, 6]]])

In [29]: a.shape  # 三维数组，返回三个数字，两页，两行，三列
Out[29]: (2, 2, 3)
In [30]: a = np.array([[1,2,3],[4,5,6]])

In [31]: a
Out[31]:
array([[1, 2, 3],
       [4, 5, 6]])

In [32]: a.T  # 转置，行列互换。
Out[32]:
array([[1, 4],
       [2, 5],
       [3, 6]])

4，ndarray-数据类型

①布尔型：bool_

②整型：int_ int8 int16 int32 int64   # int8表示存了8个字节的长度的数，占8位的数。

③无符号整型：uint8 unit16 unit32 unit64

④浮点型：float_ float16 float32 float64

⑤复数型：complex_ complex64 complex128

5，ndarray-创建

①array()  将列表转换为数组，可选择显式指定dtype

②arange()  range的numpy版，支持浮点数（浮点数步长），数组范围前包后不包

③linspace()  类似arange()，第三个参数为数组长度，数组范围前包后也包。

　　　　　　三个参数linspace(起始数，中止数，份数)，份数表示分割相同的多少份。

④zeros()  根据指定形状和dtype创建全0数组，默认创建的数类型为浮点类型，以下三种同理

⑤ones()  根据指定形状和dtype创建全1数组

⑥empty()  根据指定形状和dtype创建空数组（随机值）

⑦eye()  根据指定形状和dtype创建单位矩阵(线性代数单位矩阵)

In [6]: np.zeros(10)  # 取的10个0，可规定数字类型
Out[6]: array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])

In [7]: np.zeros(10,dtype='int')
Out[7]: array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

In [8]: a = np.zeros(10,dtype='int')

In [10]: a.dtype
Out[10]: dtype('int32')

In [10]: a.dtype
Out[10]: dtype('int32')

In [11]: np.arange(1,10,2)
Out[11]: array([1, 3, 5, 7, 9])

In [12]: np.arange(1,10,0.8)
Out[12]: array([1. , 1.8, 2.6, 3.4, 4.2, 5. , 5.8, 6.6, 7.4, 8.2, 9. , 9.8])

In [13]: np.linspace(0,100,101) #0-100，前包后也包，包括100在内。所以101个数，恰好分割101份
Out[13]:
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.,
11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21.,
22., 23., 24., 25., 26., 27., 28., 29., 30., 31., 32.,
33., 34., 35., 36., 37., 38., 39., 40., 41., 42., 43.,
44., 45., 46., 47., 48., 49., 50., 51., 52., 53., 54.,
55., 56., 57., 58., 59., 60., 61., 62., 63., 64., 65.,
66., 67., 68., 69., 70., 71., 72., 73., 74., 75., 76.,
77., 78., 79., 80., 81., 82., 83., 84., 85., 86., 87.,
88., 89., 90., 91., 92., 93., 94., 95., 96., 97., 98.,
99., 100.])

In [14]: np.linspace(0,100,100) #99个数字分割成100份，所以不齐
Out[14]:
array([ 0. , 1.01010101, 2.02020202, 3.03030303,
4.04040404, 5.05050505, 6.06060606, 7.07070707,
8.08080808, 9.09090909, 10.1010101 , 11.11111111,
12.12121212, 13.13131313, 14.14141414, 15.15151515,
16.16161616, 17.17171717, 18.18181818, 19.19191919,
20.2020202 , 21.21212121, 22.22222222, 23.23232323,
24.24242424, 25.25252525, 26.26262626, 27.27272727,
28.28282828, 29.29292929, 30.3030303 , 31.31313131,
32.32323232, 33.33333333, 34.34343434, 35.35353535,
36.36363636, 37.37373737, 38.38383838, 39.39393939,
40.4040404 , 41.41414141, 42.42424242, 43.43434343,
44.44444444, 45.45454545, 46.46464646, 47.47474747,
48.48484848, 49.49494949, 50.50505051, 51.51515152,
52.52525253, 53.53535354, 54.54545455, 55.55555556,
56.56565657, 57.57575758, 58.58585859, 59.5959596 ,
60.60606061, 61.61616162, 62.62626263, 63.63636364,
64.64646465, 65.65656566, 66.66666667, 67.67676768,
68.68686869, 69.6969697 , 70.70707071, 71.71717172,
72.72727273, 73.73737374, 74.74747475, 75.75757576,
76.76767677, 77.77777778, 78.78787879, 79.7979798 ,
80.80808081, 81.81818182, 82.82828283, 83.83838384,
84.84848485, 85.85858586, 86.86868687, 87.87878788,
88.88888889, 89.8989899 , 90.90909091, 91.91919192,
92.92929293, 93.93939394, 94.94949495, 95.95959596,
96.96969697, 97.97979798, 98.98989899, 100. ])

In [15]: np.eye(5)
Out[15]:
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.]])

　　

6，ndarray-批量运算

①数组和标量之间的运算

　　a+1 a*3 1//a a**0.5 a>5

②同样大小数组之间的运算

　　a+b a/b a**b a%b a==b

In [16]: a = np.arange(10)

In [17]: a
Out[17]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [18]: a+1
Out[18]: array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])

In [19]: a*3
Out[19]: array([ 0,  3,  6,  9, 12, 15, 18, 21, 24, 27])

In [20]: b = np.arange(10,20)

In [21]: b
Out[21]: array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])

In [22]: a
Out[22]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [23]: a+b
Out[23]: array([10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

In [24]: a>b
Out[24]:
array([False, False, False, False, False, False, False, False, False,
       False])

In [25]: a[0] = 20

In [26]: a>b
Out[26]:
array([ True, False, False, False, False, False, False, False, False,
       False])

In [27]: np.arange(15).reshape((3,5))  #shape返回(3,5)，reshape是重新变形
Out[27]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

In [29]: np.arange(15).shape  #一维数组返回的是15
Out[29]: (15,)

In [31]: a = np.arange(15).reshape((3,5))

In [32]: a
Out[32]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

In [33]: a[0][0]  # 索引取值一
Out[33]: 0

In [34]: a[0,0]  # 索引取值二
Out[34]: 0

7，ndarray-索引

一维数组的索引：a[5]

多维数组的索引：

　　列表式写法：a[2][3]

　　新式写法：a[2, 3]

8，ndarray-切片

一维数组的切片：a[5, 8]   a[4:]   a[2:10] = 1

多维数组的切片：a[1:2, 3:4]    a[:,3:5]    a[:,1]

数组切片与列表切片的不同：数组切片时并不会自动复制（而是创建一个视图），在切片数组上的修改会影响数组。

　　copy()方法可以创建数组的深拷贝。

对于二维数组，切片第一组参数行切，第二组列切。

In [61]: a = np.arange(0,10) #创建一个数组

In [62]: b = list(range(0,10)) #创建一个列表

In [63]: a
Out[63]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [64]: b
Out[64]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [65]: c = a[:4]

In [66]: d = b[:4]

In [67]: c
Out[67]: array([0, 1, 2, 3])

In [68]: d
Out[68]: [0, 1, 2, 3]

In [69]: c[0] = 20

In [70]: d[0] = 20

In [71]: c
Out[71]: array([20,  1,  2,  3])

In [72]: d
Out[72]: [20, 1, 2, 3]

In [73]: a
Out[73]: array([20,  1,  2,  3,  4,  5,  6,  7,  8,  9])

In [74]: b
Out[74]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [77]: c = a[0:4].copy()

In [78]: c
Out[78]: array([20, 1, 2, 3])

In [79]: a
Out[79]: array([20, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [80]: c[0] = 0

In [81]: a
Out[81]: array([20, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [82]: c
Out[82]: array([0, 1, 2, 3])

In [86]: a = np.arange(15).reshape(3,5)  #创建一个三列五行的数组

In [87]: a
Out[87]:
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])

In [89]: a[1:2,2:4]  # 切片：第一组横切，第二组列切
Out[89]: array([[7, 8]])

9，ndarray-布尔型索引

①问题：给一个数组，选出数组中所有大于5的数。

　　答案：a[a>5]

原理：

　　数组与标量的运算：a>会对a中的每一个元素进行判断，返回一个布尔数组

　　布尔型索引：将同样大小的布尔数组传进索引，会返回一个由所有True对应位置的元素的数组

②问题2：给一个数组，选出数组中所有大于5的偶数。

　　答案：a[(a>5) & (a%2==0)]

③问题3：给一个数组，选出数组中所有大于5的数和偶数

　　答案：a[(a>5) | (a%2==0)]

In [96]: a = [random.randint(1,10) for i in range(20)]  # 创建一个随机列表

In [97]: a
Out[97]: [6, 3, 5, 1, 8, 10, 9, 9, 4, 4, 3, 3, 3, 4, 7, 7, 9, 4, 9, 10]

In [98]: list(filter(lambda x:x>5, a))  # 利用匿名函数求出列表中大于5的数
Out[98]: [6, 8, 10, 9, 9, 7, 7, 9, 9, 10]

In [99]: a = np.array(a)  # 将a转换成数组

In [100]: a
Out[100]:
array([ 6,  3,  5,  1,  8, 10,  9,  9,  4,  4,  3,  3,  3,  4,  7,  7,  9,
        4,  9, 10])

In [101]: a[a>5]  # 利用数组方法求出大于5的数
Out[101]: array([ 6,  8, 10,  9,  9,  7,  7,  9,  9, 10])

10，ndarray-花式索引

问题1：对于一个数组，选出其第1，3，4，6，7个元素，组成新的二维数组。

　　答案：a[[1, 3, 4, 6, 7]]   # 直接一个逗号外加一个中括号表示分的行和列

问题2：对一个二维数组，选出其第一列和第三列，组成新的二维数组。

　　答案：a[:, [1, 3]]  # 冒号表示取整行，不能不写。

利用切片，中间逗号相隔，左边行，右边为列。分别进行设置。

In [13]: a = np.arange(20).reshape(4,5)

In [14]: a
Out[14]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])

In [15]: a[[1,3],:][:,[1,3]]  # 冒号表示取整列或者整行，这里先切行，列保留，然后切列，行保留。
Out[15]:
array([[ 6,  8],
       [16, 18]])

11，NumPy-通用函数

通用函数：能同时对数组中所有元素进行运算的函数。

常见通用函数：

　　一元函数（一个参数）：abs, sqrt, exp, log, ceil, floor, rint, trunc, modf, isnan, isinf, con, sin, tan

abs	绝对值	sqrt	开方运算	exp
int	向0取整	ceil	向上取整	floor	向下取整
rint	和round相同	trunc	向0取整	modf	返回两个值
isnan	判断是否为nan	isinf	判断是否为inf	log
sin		tan		con
round	用法和py版本有关，四舍五入，和rint一样

一次函数示例：

In [20]: import math

In [21]: a = -1.6

In [22]: math.floor(a)
Out[22]: -2

In [23]: a = 1.6

In [24]: math.floor(a)
Out[24]: 1

In [25]: a = -1.6

In [26]: math.ceil(a)
Out[26]: -1

In [27]: a = 1.6

In [28]: math.ceil(a)
Out[28]: 2

In [29]: a = np.arange(-5.5,5.5)

In [30]: a
Out[30]: array([-5.5, -4.5, -3.5, -2.5, -1.5, -0.5,  0.5,  1.5,  2.5,  3.5,  4.5])

In [31]: math.floor(a)
---------------------------------------------------------------------
TypeError                           Traceback (most recent call last)
<ipython-input-31-7f610b8c39f3> in <module>
----> 1 math.floor(a)

TypeError: only size-1 arrays can be converted to Python scalars

In [32]: np.floor(a)
Out[32]: array([-6., -5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])

In [33]: np.ceil(a)
Out[33]: array([-5., -4., -3., -2., -1., -0.,  1.,  2.,  3.,  4.,  5.])

In [34]: np.round(a)
Out[34]: array([-6., -4., -4., -2., -2., -0.,  0.,  2.,  2.,  4.,  4.])

In [35]: x,y = np.modf(a)

In [36]: x
Out[36]: array([-0.5, -0.5, -0.5, -0.5, -0.5, -0.5,  0.5,  0.5,  0.5,  0.5,  0.5])

In [37]: y
Out[37]: array([-5., -4., -3., -2., -1., -0.,  0.,  1.,  2.,  3.,  4.])

In [38]:

In [38]: a = np.arange(a)
---------------------------------------------------------------------
ValueError                          Traceback (most recent call last)
<ipython-input-38-aef0836fa12d> in <module>
----> 1 a = np.arange(a)

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

In [39]: a = np.arange(0,5)

In [40]: a
Out[40]: array([0, 1, 2, 3, 4])

In [41]: 5/a
C:UsersAppDataLocalProgramsPythonPython37-32Scriptsipython:1: RuntimeWarning: divide by zero encountered in true_divide
Out[41]: array([       inf, 5.        , 2.5       , 1.66666667, 1.25      ])

判断是否为nan值：

In [49]: a = np.arange(5)

In [50]: b = a/a
C:UsersAppDataLocalProgramsPythonPython37-32Scriptsipython:1: RuntimeWarning: invalid value encountered in true_divide

In [51]: b
Out[51]: array([nan,  1.,  1.,  1.,  1.])

In [52]: np.isnan(b)
Out[52]: array([ True, False, False, False, False])

In [53]: b[~(np.isnan(b))]
Out[53]: array([1., 1., 1., 1.])

　　二元函数（两个参数）：add, substract, multiply, divide, power, mod, maximum, mininum

add		power
substract		mod
multiply		maximum
divide		minimum

In [76]: a
Out[76]: array([3, 4, 5, 6])

In [77]: b
Out[77]: array([3, 0, 5, 0])

In [78]: c = np.maximum(a,b)  # 两个数组纵向取最大值，minimum同理

In [79]: c
Out[79]: array([3, 4, 5, 6])

12，补充-浮点数特殊值

nan(Not a Number):不等于任何浮点数(标记不存在的数，甚至不等于自己，nan! = nan)

inf(infinity): 比任何浮点数都大。和nan类似，但是np.inf == np.inf为True

In [66]: a
Out[66]: array([3, 4, 5, 6])

In [67]: b
Out[67]: array([3, 0, 5, 0])

In [68]: a/b
C:UsersAppDataLocalProgramsPythonPython37-32Scriptsipython:1: RuntimeWarning: divide by zero encountered in true_divide
Out[68]: array([ 1., inf,  1., inf])

In [69]: np.inf == np.inf  # 可以相等
Out[69]: True

In [70]: np.inf
Out[70]: inf

In [71]: c = a/b
C:UsersAppDataLocalProgramsPythonPython37-32Scriptsipython:1: RuntimeWarning: divide by zero encountered in true_divide

In [72]: c
Out[72]: array([ 1., inf,  1., inf])

In [74]: c[c != np.inf]  # 法一：去除inf
Out[74]: array([1., 1.])

In [75]: c[~np.isinf(c)]  # 法二：去除inf
Out[75]: array([1., 1.])

NumPy中创建特殊值: np.nan    np.inf

在数据分析中，nan常被用作表示数据缺失值

In [43]: np.nan == np.nan
Out[43]: False

In [44]: np.nan is np.nan
Out[44]: True

13，NumPy-数学和统计方法

sum	求和	min	求最小值
mean	求平均数	max	求最大值
std	求标准差	argmin	求最小值索引
var	求方差	argmax	求最大值索引

 示例：

In [82]: a
Out[82]: array([3, 4, 5, 6])

In [83]: a.sum()
Out[83]: 18

In [84]: a.mean()
Out[84]: 4.5

In [85]: a.var()
Out[85]: 1.25

14，随机数函数在np.random子包内

rand	给定形状产生随机数组（0到1之间的数）
randint	给定形状产生随机整数，原版为产生给定范围内的一个整数
choice	给定形状产生随机选择，原版为产生给出列表中随机的一个数
shuffle	与random.shuffle相同，原版为打乱一个列表
uniform	给定形状产生随机数组
romdom	y返回0-1之间的随机数

在numpy中，相同属性，都能同时产生多个所需要的数，并且可以产生多维。

In [86]: import random

In [87]: random.random()  # 随机产生0-1之间的一个数
Out[87]: 0.09135811946312578

In [88]: random.randint(1,20)  # 产生给定范围内的一个整数
Out[88]: 9

In [89]: random.randint(1,20)
Out[89]: 13

In [91]: a = [1, 5, 7, 9, 4]

In [92]: random.choice(a)  # 在给出的列表中随机选一个数
Out[92]: 7

In [93]: random.choice(a)
Out[93]: 4

In [94]: a
Out[94]: [1, 5, 7, 9, 4]

In [96]: random.shuffle(a) # 打乱一个列表

In [97]: a
Out[97]: [5, 9, 1, 4, 7]

In [100]: random.shuffle(a)

In [101]: a
Out[101]: [7, 9, 4, 5, 1]

##np，和原版类似，但是能够产生多个数以及多维度
In [102]: np.random.randint(0,10)
Out[102]: 0

In [103]: np.random.randint(0,10)
Out[103]: 6

In [104]: np.random.randint(0,10,3)
Out[104]: array([1, 8, 5])

In [105]: np.random.randint(0,10,3)
Out[105]: array([7, 1, 5])

In [106]: np.random.randint(0,10,(3,5))
Out[106]:
array([[6, 8, 4, 5, 5],
[1, 6, 0, 3, 4],
[0, 9, 7, 2, 0]])

In [107]: np.random.randint(0,10,(3,5))
Out[107]:
array([[5, 1, 3, 3, 2],
[7, 5, 1, 0, 3],
[4, 6, 9, 3, 2]])

In [108]: np.random.randint(0,10,(3,5,4))
Out[108]:
array([[[8, 2, 1, 2],
[4, 4, 3, 3],
[9, 5, 3, 7],
[9, 8, 7, 4],
[8, 5, 7, 6]],

[[7, 1, 9, 5],
[1, 2, 9, 0],
[4, 6, 7, 8],
[4, 7, 2, 0],
[2, 1, 5, 5]],

[[6, 2, 5, 9],
[1, 4, 7, 0],
[9, 6, 6, 3],
[6, 3, 0, 3],
[5, 7, 9, 3]]])

In [109]: np.random.randint(0,10,(3,5,4))
Out[109]:
array([[[2, 8, 7, 1],
[9, 2, 5, 3],
[4, 0, 4, 5],
[8, 7, 2, 0],
[0, 1, 4, 0]],

[[0, 5, 4, 3],
[0, 5, 2, 7],
[5, 5, 2, 9],
[8, 4, 3, 0],
[8, 3, 7, 1]],

[[5, 7, 6, 7],
[5, 8, 3, 6],
[7, 7, 5, 0],
[5, 2, 6, 4],
[0, 2, 4, 7]]])

In [110]: _.shape
Out[110]: (3, 5, 4)

In [111]: np.random.rand(10)
Out[111]:
array([0.30994908, 0.01725835, 0.20814649, 0.28246789, 0.02701042,
0.7190864 , 0.08727593, 0.43659853, 0.97699448, 0.93614408])

In [112]: np.random.choice([1,2,3,4,5])
Out[112]: 5

In [113]: np.random.choice([1,2,3,4,5])
Out[113]: 3

In [114]: np.random.choice([1,2,3,4,5],10)
Out[114]: array([1, 1, 2, 5, 2, 2, 2, 3, 5, 4])

In [115]: np.random.choice([1,2,3,4,5],10)
Out[115]: array([1, 4, 3, 4, 2, 4, 5, 1, 2, 3])

In [116]: random.uniform(2.0,4.0)
Out[116]: 3.168521010890534

In [117]: random.uniform(2.0,4.0)
Out[117]: 2.379716927986004

In [118]: np.random.uniform(2.0,4.0)
Out[118]: 3.3321816601572776

In [119]: np.random.uniform(2.0,4.0)
Out[119]: 3.228000422054651

In [120]: np.random.uniform(2.0,4.0,10)
Out[120]:
array([2.01656946, 3.0348116 , 3.60585797, 2.73685864, 3.3046432 ,
3.92284631, 2.97615921, 2.79362946, 2.99863154, 3.73438379])

这些只是numpy常用的一些功能，如果还有更多好用的功能，欢迎探讨。