Numpy库与多维数组-CFTA注册金融科技分析师一级考点

Numpy库与多维数组

NumPy库简介

NumPy（Numerical Python）是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix）），支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

一个用python实现的科学计算，包括：1、一个强大的N维数组对象Array；2、比较成熟的（广播）函数库；3、用于整合C/C++和Fortran代码的工具包；4、实用的线性代数、傅里叶变换和随机数生成函数。numpy和稀疏矩阵运算包scipy配合使用更加方便。

NumPy（Numeric Python）提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库。专为进行严格的数字处理而产生。多为很多大型金融公司使用，以及核心的科学计算组织如：Lawrence Livermore，NASA用其处理一些本来使用C++，Fortran或Matlab等所做的任务。

NumPy 的前身为 Numeric ，最早由 Jim Hugunin 与其它协作者共同开发，2005 年，Travis Oliphant 在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色，并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。

创建数组和操作

array函数创建多维数组

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。

ndarray 对象是用于存放同类型元素的多维数组。

ndarray 中的每个元素在内存中都有相同存储大小的区域。

按参数创建

创建一个 ndarray 只需调用 NumPy 的 array 函数即可：

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

参数说明：

名称 描述

object 数组或嵌套的数列

dtype 数组元素的数据类型，可选

copy 对象是否需要复制，可选

order 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）

subok 默认返回一个与基类类型一致的数组

ndmin 指定生成数组的最小维度

实例

接下来可以通过以下实例帮助我们更好的理解。

实例 1

import numpy as np

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

print (a)

输出结果如下：

[1 2 3]

实例 2

# 多于一个维度

import numpy as np

a = np.array([[1, 2], [3, 4]])

print (a)

输出结果如下：

[[1 2]

[3 4]]

实例 3

# 最小维度

import numpy as np

a = np.array([1, 2, 3, 4, 5], ndmin = 2)

print (a)

输出如下：

[[1 2 3 4 5]]

实例 4

# dtype 参数

import numpy as np

a = np.array([1, 2, 3], dtype = complex)

print (a)

输出结果如下：

[1.+0.j 2.+0.j 3.+0.j]

ndarray 对象由计算机内存的连续一维部分组成，并结合索引模式，将每个元素映射到内存块中的一个位置。内存块以行顺序(C样式)或列顺序(FORTRAN或MatLab风格，即前述的F样式)来保存元素。

创建全部为1的数组

示例代码：

x=np.ones((2,2)) #构建2行、2列，数值为1的数组

print(x)

返回：

[[1. 1.]

[1. 1.]]

创建全部为0的数组

x=np.zeros((2,2)) #构建2行、2列，数值为0的数组

print(x)

返回：

[[0. 0.]

[0. 0.]]

创建无意义数组

x=np.empty([5,6]) #构建5行、6列数组

print(x[0,1])

注意：由于不需指定具体值，该方法是创建数组最快的方法，但是由于创建的是无意义的数组，结果不可控，可能是任意未初始化的垃圾值，尽量少用，了解即可

arange函数生成数组

说明：

Numpy 中 arange() 主要是用于生成数组，具体用法如下

语法

numpy.arange(start, stop, step, dtype = None)

在给定间隔内返回均匀间隔的值。

值在半开区间 [开始，停止]内生成（换句话说，包括开始但不包括停止的区间）,返回的是 ndarray 。

参数

start —— 开始位置，数字，可选项，默认起始值为0

stop —— 停止位置，数字

step —— 步长，数字，可选项， 默认步长为1，如果指定了step，则还必须给出start。

dtype —— 输出数组的类型。 如果未给出dtype，则从其他输入参数推断数据类型。

返回：

arange：ndarray

均匀间隔值的数组。

注意：对于浮点参数（参数为浮点），结果的长度为ceil（（stop - start）/ step）） 由于浮点溢出，此规则可能导致最后一个元素大于stop。因此要特别注意

实例

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

from numpy import * # 引入numpy

A = arange(5) # 只有结束项

print(A) # 结果 [0 1 2 3 4] 结果不包含结束项

print(type(A)) # 结果 <class 'numpy.ndarray'>

A = arange(1, 5) # 起点为1，步长默认为1

print(A) # 结果 [1 2 3 4]

A = arange(1, 5, 2) # 步长默认为2

print(A) # 结果 [1 3]

A = arange(1, 5.2, 0.6) # 浮点数参数，结果就不一定完全符合了

print(A) # 结果 [1. 1.6 2.2 2.8 3.4 4. 4.6 5.2]

数组元素索引与切片

基本切片操作

>>> import numpy as np

>>> arr=np.arange(10)

>>> arr

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

>>> arr[5]

5

>>> arr[5:8]

array([5, 6, 7])

切片赋值操作

通过索引提取：array[start:end:step] 提取单个元素：array[start]

特殊方法提取：提取多个元素：array[start：end]

通过索引值来提取数组中的元素或者对数组进行切片，提取的新数组与原来数组共享数据内存空间。

1.切片赋一个值对应原来数组中的值也会变

>>> arr[5:8]=12

>>> arr

array([ 0, 1, 2, 3, 4, 12, 12, 12, 8, 9])

>>> import numpy as np

>>> arr=np.arange(10)

>>> arr_slice=arr[5:8]

>>> arr_slice[0]=-1

>>> arr_slice

array([-1, 6, 7])

>>> arr

array([ 0, 1, 2, 3, 4, -1, 6, 7, 8, 9])

2.给数组中所有元素赋值

>>> arr[:]=-1

>>> arr

array([-1, -1, -1, -1, -1, -1, -1, -1, -1, -1])

3.如果想使用复制的方法,使用copy方法

>>> arr_copy=arr[:].copy()

>>> arr_copy

array([-1, -1, -1, -1, -1, -1, -1, -1, -1, -1])

>>> arr_copy[:]=0

>>> arr_copy

array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

>>> arr

array([-1, -1, -1, -1, -1, -1, -1, -1, -1, -1])

高阶数组索引

二维及以上数组元素提取：思维与一维相同，只不过要考虑各个维度上的索引值。

除了整型数组以外,整型列表也可以当作索引。若提取三维数组的多个值,则可以在每一轴上分别定义一个整型数组或者整型列表作为索引值,但是三个轴上的整型数组或者整型列表的长度要相等。

1. 单个元素的索引

#1.1.一维array,单个元素的索引使用整数

import numpy as np

a = np.array([3, 5, 1, 2, 7, 9])

print('a:', a)

b = a[1]

print('b:', b)

b = 77

print('a:', a)#改变b的值不会影响a的值

输出：

a: [3 5 1 2 7 9]

b: 5

a: [3 5 1 2 7 9]

# 1.2.多维array，单个元素的索引使用整数序列

#1.2.1 二维array

a = np.arange(12).reshape((3, 4))

print('a:\n', a)

b = a[1, 2] #注意b = a[1, 2]等价于b = a[1][2], 索引a中第2行第3列的值， 实际上a[1][2]是先索引第一个维度得到一个array,在此基础上再索引

print('b:\n', b)

b = 77

print('a:\n', a) #改变b的值不会影响a

输出：

a:

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

b:

6

a:

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

#1.2.2 多维array

a = np.arange(96).reshape((2,3,4,4))

print('a:\n', a)

b = a[1, 2, 2, 2] #注意b = a[1, 2, 2, 2]等价于b = a[1][2][2][2], 按每个维度一次索引，可以把a看做两张4*4的RGB图片，

# 则索引的是第2张图的第三个通道的第3行第3列

print('b:\n', b)

b = 9999

print('a:\n', a) #改变b的值不会影响a

输出：

a:

[[[[ 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]]]]

b:

90

a:

[[[[ 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]]]]

2.多个元素的索引

#2.1用少于array的维度的个数索引值去索引该array

a = np.arange(12).reshape((3, 4))

print('a:\n', a)

b = a[2] #a的维度为2，但是只用一个索引值去索引第一个维度，得到b为一个array,shape由未被索引的维度组成

print('b:\n', b)

print('改变b中的值，会影响a')

b[1] = 77

print('a:\n', a) #改变b中的值，会影响a

print('给b整体赋值并不会影响a')

b = np.array([11, 11, 11, 11])

print('a:\n', a) #给b整体赋值并不会影响a

print('改变a中对应的值， 会影响b')

a[2, 3] = 88

print('b:\n', b) #改变a中对应的值， 会影响b

输出：

a:

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

b:

[ 8 9 10 11]

改变b中的值，会影响a

a:

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 77 10 11]]

给b整体赋值并不会影响a

a:

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 77 10 11]]

改变a中对应的值， 会影响b

b:

[11 11 11 11]

#应用：用少于array的维度的个数索引值去索引该array

#假设a为一个4维array，表示N个图像，（N,C,H,W），则从中取一张图像就可以直接这样索引：a[i]

a = np.arange(96).reshape((2, 4, 4, 3))

print(a[1])

print(a[1].shape) #shape由未被索引的维度组成

输出：

[[[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]]]

(4, 4, 3)

In [6]:

#2.2切片索引

a = np.arange(12).reshape((3, 4))

print('a:\n', a)

b = a[1:3, 2:4] #对每个维度依次切片，注意a[1:3][2:4]并不等价于a[1:3, 2:4], a[1:3][2:4]是先对a在第一个维度上切片后再切片

print('b:\n', b)

b[0][0] = 88

print('a:\n', a) #改变a的值会影响b

输出：

a:

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

b:

[[ 6 7]

[10 11]]

a:

[[ 0 1 2 3]

[ 4 5 88 7]

[ 8 9 10 11]]

总结：用小于array维度的个数的索引值索引和切片索引创建的新的array都为原array的第一视图，改变新array中的值（不是对新的array整体赋值）会影响原array的值；改变原array对应的值也会影响新array的值

3.用array索引array

#3.1一维array索引一维array

a = np.array([1, 7, 8, 9, 11, 3])

print('a:\n', a)

b = a[np.array([1, 2, 4])] #用被索引的array的值替换索引array([1, 2, 4])

print('b:\n', b)

b[1] = 333

print('a:\n', a) #用array索引array创建的新的array是原array的一个copy，所以改变新的array不会改变原的array，下面不再验证这一点

输出：

a:

[ 1 7 8 9 11 3]

b:

[ 7 8 11]

a:

[ 1 7 8 9 11 3]

#3.2多维array索引一维array

a = np.array([1, 7, 8, 9, 11, 3])

print('a:\n', a)

b = a[np.array([[1, 2, 3], [4, 1, 2]])] #用被索引的array的值替换索引array（[[1, 2, 3], [4, 1, 2]]）

print('b:\n', b)

输出：

a:

[ 1 7 8 9 11 3]

b:

[[ 7 8 9]

[11 7 8]]

#3.3索引多维array

a = np.arange(12).reshape((3, 4))

print('a:\n', a)

b = a[np.array([1, 2]), np.array([1, 2])] #索引出的是a[1][1], a[2][2]

print('b:\n', b)

输出：

a:

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

b:

[ 5 10]

a = np.arange(12).reshape((3, 4))

print('a:\n', a)

b = a[np.array([1, 2])] #索引出的是第2,3行

print('b:\n', b)

输出：

a:

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

b:

[[ 4 5 6 7]

[ 8 9 10 11]]

4布尔值(mask)索引

In [11]:

a = np.arange(12).reshape((3, 4))

print('a:\n', a)

idx = a > 5

print('idx:\n', idx)

b = a[idx]

print('b:\n', b) #返回的值为一维array（ The elements in the indexed array are always iterated and returned in row-major (C-style) order. ）

b[1] = 77

print('a:\n', a)

输出：

a:

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

idx:

[[False False False False]

[False False True True]

[ True True True True]]

b:

[ 6 7 8 9 10 11]

a:

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

idx_slice = idx[:,1]

print('idx_slice:\n', idx_slice) #布尔索引值个数等于第一个维度

b = a[idx_slice] #索引第三行

print('b:\n', b)

输出

idx_slice:

[False False True]

b:

[[ 8 9 10 11]]

总结：用array去索引和布尔值索引都为高级索引，由此创建的新array为原array的一个copy，改变新array的值不会对旧array的值产生影响

图形化补充：

>>> import numpy as np

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

>>> arr2d[2]

array([7, 8, 9])

>>> arr2d[0][2]

3

>>> arr2d[0,2] #写法与上面等同

3

>>> import numpy as np

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

>>> arr2d[2]

array([7, 8, 9])

>>> arr2d[0][2]

3

>>> arr2d[0,2]

3

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

>>> arr3d

array([[[ 1, 2, 3],

[ 4, 5, 6]],

[[ 7, 8, 9],

[10, 11, 12]]])

>>> arr3d[0]

array([[1, 2, 3],

[4, 5, 6]])

>>> old_values=arr3d[0].copy()

>>> arr3d[0]=42

>>> arr3d

array([[[42, 42, 42],

[42, 42, 42]],

[[ 7, 8, 9],

[10, 11, 12]]])

>>> arr3d[1,0]

array([7, 8, 9])

>>> x=arr3d[1]

>>> x

array([[ 7, 8, 9],

[10, 11, 12]])

>>> x[0]

array([7, 8, 9])

高维数组切片

>>> arr2d[:2]

array([[1, 2, 3],

[4, 5, 6]])

>>> arr2d[:2,1:]

array([[2, 3],

[5, 6]])

>>> arr2d[1,:2]

array([4, 5])

>>> arr2d[:2,2]

array([3, 6])

>>> arr2d[:,:1]

array([[1],

[4],

[7]])

布尔型索引

1.假设我们有一个用于存储数据的数组以及一个存储姓名的数组（含有重复项）。在这里，将使用numpy.random中的randn函数生成一些正态分布的随机数据：

>>> import numpy as np

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

>>> data=np.random.randn(7,4)#7行4列正太分布随机数组

>>> names

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

>>> data

array([[ 0.24724057, 2.86939948, -0.82061782, -0.65745818],

[-0.98602372, -0.69305692, -1.44431904, -0.85490816],

[-0.73613349, 0.12700976, -1.00588979, 1.10646269],

[ 1.59110894, 1.68597758, 0.39414277, 2.02308399],

[-1.05607115, -0.50354292, -0.65820553, -0.77610316],

[ 1.72237936, -0.07726577, 1.63462647, -0.41943148],

[ 0.66744687, -1.01756773, -0.59254343, 0.19080575]])

2.假设每个名字都对应data数组中的一行，而我们想要选出对应于名字"Bob"的所有行。跟算术运算一样，数组的比较运算（如==）也是矢量化的。因此，对names和字符串"Bob"的比较运算将会产生一个布尔型数组：

>>> names=='Bob'

array([ True, False, False, True, False, False, False])

3.布尔数组可以用于数组的索引

获取等于'Bob'的行

>>> data[names=='Bob']

array([[ 0.24724057, 2.86939948, -0.82061782, -0.65745818],

[ 1.59110894, 1.68597758, 0.39414277, 2.02308399]])

获取不同于'Bob'的行

>>> data[names!='Bob']

array([[-0.98602372, -0.69305692, -1.44431904, -0.85490816],

[-0.73613349, 0.12700976, -1.00588979, 1.10646269],

[-1.05607115, -0.50354292, -0.65820553, -0.77610316],

[ 1.72237936, -0.07726577, 1.63462647, -0.41943148],

[ 0.66744687, -1.01756773, -0.59254343, 0.19080575]])

4.对布尔索引进行列索引

>>> data[names=='Bob',2:]

array([[-0.82061782, -0.65745818],

[ 0.39414277, 2.02308399]])

>>> data[names=='Bob',3]

array([-0.65745818, 2.02308399])

5.反转条件符

>>> cond=names=='Will'

>>> cond

array([False, False, True, False, True, False, False])

>>> data[~cond]

array([[ 0.24724057, 2.86939948, -0.82061782, -0.65745818],

[-0.98602372, -0.69305692, -1.44431904, -0.85490816],

[ 1.59110894, 1.68597758, 0.39414277, 2.02308399],

[ 1.72237936, -0.07726577, 1.63462647, -0.41943148],

[ 0.66744687, -1.01756773, -0.59254343, 0.19080575]])

6.布尔条件的运算

除此之外，连接符还有|、&之类

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

>>> mask

array([ True, False, True, True, True, False, False])

>>> data[mask]

array([[ 0.24724057, 2.86939948, -0.82061782, -0.65745818],

[-0.73613349, 0.12700976, -1.00588979, 1.10646269],

[ 1.59110894, 1.68597758, 0.39414277, 2.02308399],

[-1.05607115, -0.50354292, -0.65820553, -0.77610316]])

7.条件选取

普通条件选取

>>> data[data<0]=0

>>> data

array([[0.24724057, 2.86939948, 0. , 0. ],

[0. , 0. , 0. , 0. ],

[0. , 0.12700976, 0. , 1.10646269],

[1.59110894, 1.68597758, 0.39414277, 2.02308399],

[0. , 0. , 0. , 0. ],

[1.72237936, 0. , 1.63462647, 0. ],

[0.66744687, 0. , 0. , 0.19080575]])

布尔条件选取

>>> import numpy as np

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

>>> data=np.random.randn(7,4)#7行4列正太分布随机数组

>>> data

array([[-1.24077681, -0.48320904, 1.22145611, 0.00666619],

[-0.65078721, -0.03482355, 1.74232625, 0.2979584 ],

[-1.51669752, 2.04245014, 0.09453898, -0.85531867],

[-1.51334497, 0.36947066, -0.87016919, 1.35107873],

[-1.11285867, -2.20906849, 0.38269412, 1.85375798],

[ 0.95132554, -1.54193589, 1.98741745, -0.60608077],

[ 0.78902133, 1.41593836, 0.09430052, -0.25057659]])

>>> data[names!='Joe']=7

>>> data

array([[ 7. , 7. , 7. , 7. ],

[-0.65078721, -0.03482355, 1.74232625, 0.2979584 ],

[ 7. , 7. , 7. , 7. ],

[ 7. , 7. , 7. , 7. ],

[ 7. , 7. , 7. , 7. ],

[ 0.95132554, -1.54193589, 1.98741745, -0.60608077],

[ 0.78902133, 1.41593836, 0.09430052, -0.25057659]])

>>>

花式索引

1.传入单个索引数组

>>> import numpy as np

>>> arr=np.empty((8,4))#创建8行4列内容为空的数组

>>> for i in range(8):

arr[i]=i

>>> arr

array([[0., 0., 0., 0.],

[1., 1., 1., 1.],

[2., 2., 2., 2.],

[3., 3., 3., 3.],

[4., 4., 4., 4.],

[5., 5., 5., 5.],

[6., 6., 6., 6.],

[7., 7., 7., 7.]])

>>> arr[[4,3,0,6]]#选特定的索引下标,选取第4，3，0，6行

array([[4., 4., 4., 4.],

[3., 3., 3., 3.],

[0., 0., 0., 0.],

[6., 6., 6., 6.]])

花式索引高阶玩法：

import numpy as np

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

print(na1[[1,2,1],[2,1,2]]) #可以拆成：左边的1,2,1代表分别选择第2行、第3行、第2行；右边的2,1,2代表分别选择对应行的第3列、第2列、第3列

#输出：

array([6, 8, 6])

2.传入多个索引数组

>>> arr=np.arange(32).reshape((8,4))

>>> arr

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]])

>>> arr[[1,5,7,2],[0,3,1,2]]#选取(1,0),(5,3),(7,1),(2,2)对应元素

array([ 4, 23, 29, 10])

>>> arr[[1,5,7,2]][:,[0,3,1,2]]#先选取第1,5,7,2行，再将每行按照0,3,1,2这个顺序交换

array([[ 4, 7, 5, 6],

[20, 23, 21, 22],

[28, 31, 29, 30],

[ 8, 11, 9, 10]])

数组运算

数组的乘法

>>> import numpy as np

>>> arr=np.array([[1,2,3],[4,5,6]])

>>> arr

array([[1, 2, 3],

[4, 5, 6]])

>>> arr*arr

array([[ 1, 4, 9],

[16, 25, 36]])

数组的减法

>>> arr-arr

array([[0, 0, 0],

[0, 0, 0]])

数组的标量运算

数组的标量运算会传播到数组中的每一个元素

>>> import numpy as np

>>> arr=np.array([[1,2,3],[4,5,6]])

>>> arr

array([[1, 2, 3],

[4, 5, 6]])

>>> 1/arr

array([[1. , 0.5 , 0.33333333],

[0.25 , 0.2 , 0.16666667]])

>>> arr**2

array([[ 1, 4, 9],

[16, 25, 36]], dtype=int32)

数组比较

大小相同的数组之间的比较会生成布尔值数组：

>>> import numpy as np

>>> arr1=np.array([[1,2,3],[4,5,6]])

>>> arr2=np.array([1,1,1],[1,1,1])

>>> arr2=np.array([[1,1,1],[1,1,1]])

>>> arr2>arr1

array([[False, False, False],

[False, False, False]])

产生随机数

numpy中的random模块包含了很多方法可以用来产生随机数

1、numpy.random.rand(d0, d1, ..., dn)

作用：产生一个给定形状的数组（其实应该是ndarray对象或者是一个单值），数组中的值服从[0, 1)之间的均匀分布。

参数：d0, d, ..., dn : int，可选。如果没有参数则返回一个float型的随机数，该随机数服从[0, 1)之间的均匀分布。

返回值：ndarray对象或者一个float型的值

例子：

# [0, 1)之间均匀分布的随机数，3行2列

a = np.random.rand(3, 2)

print(a)

# 不提供形状

b = np.random.rand()

print(b)

输出：

[[0.26054323 0.28184468]

[0.7783674 0.71733674]

[0.90302256 0.49303252]]

0.6022098740124009

2、numpy.random.uniform(low=0.0, high=1.0, size=None)

作用：返回一个在区间[low, high)中均匀分布的数组，size指定形状。

参数：

low, high：float型或者float型的类数组对象。指定抽样区间为[low, high)，low的默认值为0.0，hign的默认值为1.0

size：int型或int型元组。指定形状，如果不提供size，则返回一个服从该分布的随机数。

例子：

# 在[1, 10)之间均匀抽样，数组形状为3行2列

a = np.random.uniform(1, 10, (3, 2))

print(a)

# 不提供size

b = np.random.uniform(1, 10)

print(b)

输出：

[[5.16545387 6.3769087 ]

[9.98964899 7.88833885]

[1.37173855 4.19855075]]

3.899250175275188

3、numpy.random.randn(d0, d1, ..., dn)

作用：返回一个指定形状的数组，数组中的值服从标准正态分布（均值为0，方差为1）。

参数：d0, d, ..., dn : int，可选。如果没有参数，则返回一个服从标准正态分布的float型随机数。

返回值：ndarray对象或者float

例子：

# 3行2列

a = np.random.randn(3, 2)

print(a)

# 不提供形状

b = np.random.randn()

print(b)

输出：

[[-1.46605527 0.35434705]

[ 0.43408199 0.02689309]

[ 0.48041554 1.62665755]]

-0.6291254375915813

4、numpy.random.normal(loc=0.0, scale=1.0, size=None)

作用：返回一个由size指定形状的数组，数组中的值服从 μ=loc,σ=scale 的正态分布。

参数：

loc : float型或者float型的类数组对象，指定均值 μ

scale : float型或者float型的类数组对象，指定标准差 σ

size : int型或者int型的元组，指定了数组的形状。如果不提供size，且loc和scale为标量（不是类数组对象），则返回一个服从该分布的随机数。

输出：ndarray对象或者一个标量

例子：

# 标准正态分布，3行2列

a = np.random.normal(0, 1, (3, 2))

print(a)

# 均值为1，标准差为3

b = np.random.normal(1, 3)

print(b)

输出：

[[ 0.34912031 -0.08757564]

[-0.99753101 0.37441719]

[ 2.68072286 -1.03663963]]

5.770831320998463

5、numpy.random.randint(low, high=None, size=None, dtype='l')

作用：返回一个在区间[low, high)中离散均匀抽样的数组，size指定形状，dtype指定数据类型。

参数：

low, high：int型，指定抽样区间[low, high)

size：int型或int型的元组，指定形状

dypte：可选参数，指定数据类型，比如int,int64等，默认是http://np.int

返回值：如果指定了size，则返回一个int型的ndarray对象，否则返回一个服从该分布的int型随机数。

例子：

# 在[1, 10)之间离散均匀抽样，数组形状为3行2列

a = np.random.randint(1, 10, (3, 2))

print(a)

# 不提供size

b = np.random.randint(1, 10)

print(b)

# 指定dtype

c = np.random.randint(1, 10, dtype=np.int64)

print(c)

type(c)

输出：

[[3 1]

[3 3]

[5 8]]

6

2

numpy.int64

6、numpy.random.random(size=None)

作用：返回从[0, 1)之间均匀抽样的数组，size指定形状。

参数：

size：int型或int型的元组，如果不提供则返回一个服从该分布的随机数

返回值：float型或者float型的ndarray对象

例子：

# [0, 1)之间的均匀抽样，3行2列

a = np.random.random((3, 2))

print(a)

# 不指定size

b = np.random.random()

print(b)

输出：

[[0.80136714 0.63129059]

[0.04556679 0.04433006]

[0.09643599 0.53312761]]

0.32828505898057136