正文
Python数据分析之Numpy操作大全
小程序：扫一扫查出行【扫一扫了解最新限行尾号】
复制小程序
从头到尾都是手码的，文中的所有示例也都是在Pycharm中运行过的，自己整理笔记的最大好处在于可以按照自己的思路来构建框架，等到将来在需要的时候能够以最快的速度看懂并应用=_=
注：为方便表述，本章设arr为numpy.ndarray的一个实例化对象
1. NumPy简介
NumPy是python运用于数据分析、科学计算最重要的库之一
由于numpy底层是用C/C++写的，在性能和速度上都有较大的提升，能用NumPy的地方就多用NumPy
官网：www.numpy.org
约定俗成的NumPy模块载入方法：
import numpy as np
2. ndarray简介
numpy.ndarray（n-dimensional array, n维数组）是NumPy中的一个类，它类似于list，是一种数据容器，但是比list功能更强大
ndarray要求它里面的所有元素都是相同的数据类型，以便于向量化（ vectorization ）
ndarray在print时，元素与元素之间无逗号，如
[1 2 3]
ndarray也支持拆包，如
a,b = np.array([1,2])
3. ndarray对象的属性
（1）arr.ndim
ndarray的维度
抽象地说是ndarray有几个坐标轴方向
形象地说是np.array()在定义时，里面的[]加()一共有几层嵌套，维度就是几
（2）arr.shape
ndarray的形状，是衡量各个维度大小的元组，元组中有几项就是几维
一维时等于
(元素个数,)
，二维时等于
(行数,列数)
，三维时等于
(x轴的长度,y轴的长度,z轴的长度)
记住一维和二维代表的具体意义即可
（3）arr.size
ndarray的长度，等于.shape元组中各项的乘积
（4）arr.dtype
dtype是data type的简写，返回ndarray里面的元素的数据类型：整数为
int32
、浮点数为
float64
、字符串为
<U6
（5）arr.itemsize
每个元素的字节长度
（6）arr.nbytes
整个数组的字节长度，等于 arr.itemsize * arr.size
# 一维ndarray
import numpy as np
close_list = [10, 10.5, 11.0, 11.5, 12.0]
close = np.array(close_list)
print(close)
print('ndim: ', close.ndim)
print('shape: ', close.shape)
print('size: ', close.size)
print('dtype: ', close.dtype)
执行结果：
[10. 10.5 11. 11.5 12. ]
ndim: 1
shape: (5,)
size: 5
dtype: float64
# 二维ndarray
import numpy as np
open_list = [10, 11, 12, 13, 14]
close_list = [12, 11, 10, 14, 16]
stock_info = np.array([open_list, close_list])
print(stock_info)
print('ndim: ', stock_info.ndim)
print('shape: ', stock_info.shape)
print('size: ', stock_info.size)
print('dtype: ', stock_info.dtype)
执行结果：
[[10 11 12 13 14]
[12 11 10 14 16]]
ndim: 2
shape: (2, 5)
size: 10
dtype: int32
# 三维ndarray
import numpy as np
arr = np.array([
[[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]],
])
print(arr)
print('ndim: ', arr.ndim)
print('shape: ', arr.shape)
print('size: ', arr.size)
print('dtype: ', arr.dtype)
执行结果：
[[[ 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]]]
ndim: 3
shape: (2, 4, 4)
size: 32
dtype: int32
4. ndarray的创建
（1）使用np.array()或np.asarray()创建
① np.array(list)
最常用的创建方式之一，特别地，一维ndarray本身不区分行和列，二位ndarray用内层[]表示一行的结束，因此
np.array([[1],[2],[3]])
是3行1列的列向量，
np.array([[1,2,3]])
是1行3列的行向量。绝大部分情况下都使用的是列向量，因为ndarray中的所有元素数据类型相同，对应的是数据库中的一列（一个字段）。
若在创建ndarray时里面的元素既有int也有float，则会将所有int转化为float（对其他方式创建也适用）
import numpy as np
a=np.array([1,2.99,3])
print(a,type(a))
执行结果：
[1. 2.99 3. ] <class 'numpy.ndarray'>
若在创建ndarray时里面的元素既有数字又有字符串，则会将所有数字转化为字符串（对其他方式创建也适用）
import numpy as np
a=np.array([1,2.99,'3'])
print(a,type(a))
执行结果：
['1' '2.99' '3'] <class 'numpy.ndarray'>
② np.array(tuple)
import numpy as np
stock_info_tuple = ('000001', '平安银行', '银行', 10.20)
stock_info_array = np.array(stock_info_tuple)
print(stock_info_array)
执行结果：
['000001' '平安银行' '银行' '10.2']
③ np.array(range())
不推荐将range()通过这种方法生成ndarray，繁琐，应使用更为简便的np.arange(n)
import numpy as np
arr = np.array(range(5))
print(arr)
执行结果：[0 1 2 3 4]
④ np.array(pandas.Series)和np.array(pandas.DataFrame)
可以将pandas.Series和pandas.DataFrame转化为ndarray
应用场景：进行技术分析的talib模块只支持ndarray，不支持pandas.Series和pandas.DataFrame数据类型
import pandas as pd
import numpy as np
s = pd.Series([1,2,3],index=['t1','t2','t3'])
df = pd.DataFrame([[44, 55, 66],[77, 88, 99]],columns=['c1','c2','c3'],index=['t1','t2'])
arr1 = np.asarray(s)
arr2 = np.asarray(df)
print(arr1)
print(type(arr1))
print(arr2)
print(type(arr2))
执行结果：
[1 2 3]
<class 'numpy.ndarray'>
[[44 55 66]
[77 88 99]]
<class 'numpy.ndarray'>
⑤ np.asarray()
np.asarray()和np.array用法基本相同，前文所述各种数据类型也都可以使用np.asarray()转换为ndarray
（2）使用np.arange()创建
语法：
np.arange(起始值,结束值,步长)
与range()相同，起始值默认为0，步长默认为1，即可以简写成
np.arange(结束值)
和range()相比，都是顾头不顾尾原则，但是支持步长非整数的情况，同时写起来也比np.array(range(n))更简便
import numpy as np
arr = np.arange(5)
print(arr)
执行结果：[0 1 2 3 4]
import numpy as np
arr = np.arange(0,1,0.1)
print(arr)
执行结果：[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
（3）使用np.zeros()、np.ones()、np.empty()创建
① np.zeros()
语法：
np.zeros(shape,dtype=float)
生成一个由0组成的ndarray
第一个参数shape：一个整数（对应1维）或一个元组（元组中有几个元素就是几维）
第二个参数dtype：默认值是
'f'或float
（浮点数），可以改为
'i'或int
（整数）、
complex
（复数）
import numpy as np
zeros_1d_array = np.zeros(5) # 一维，长度为5
# zeros_1d_array = np.zeros((5,)) # 一维，长度为5，使用元组的表示方法
zeros_2d_array = np.zeros((3,4),int) # 二维，3行4列
zeros_3d_array = np.zeros((2,2,2),dtype='i') # 三维
print(zeros_1d_array); print('==================')
print(zeros_2d_array); print('==================')
print(zeros_3d_array)
执行结果：
[0. 0. 0. 0. 0.]
==================
[[0 0 0 0]
[0 0 0 0]
[0 0 0 0]]
==================
[[[0 0]
[0 0]]
[[0 0]
[0 0]]]
② np.ones()
np.ones()和np.zeros()完全类似，就是把0换成了1，不再赘述
③ np.empty()
与np.zeros()和np.ones()类似，只不过填充的是一些非常小的、接近0的数字
import numpy as np
zeros_1d_array = np.empty(5) # 一维，长度为5
# zeros_1d_array = np.empty((5,)) # 一维，长度为5，使用元组的表示方法
zeros_2d_array = np.empty((3,4)) # 二维，3行4列
zeros_3d_array = np.empty((2,2,2)) # 三维
print(zeros_1d_array); print('==================')
print(zeros_2d_array); print('==================')
print(zeros_3d_array)
执行结果：
[4.58792637e-278 6.47377963e-273 4.24265622e-268 2.78046718e-263
1.74758669e-104]
==================
[[7.e-322 0.e+000 0.e+000 0.e+000]
[0.e+000 0.e+000 0.e+000 0.e+000]
[0.e+000 0.e+000 0.e+000 0.e+000]]
==================
[[[7.76e-322 0.00e+000]
[0.00e+000 0.00e+000]]
[[0.00e+000 9.88e-322]
[0.00e+000 0.00e+000]]]
④ 意义
在实际应用中，一般都是先通过np.zeros()或np.ones()获得一个确定了shape的模子，然后再对里面的具体数据进行修改
（4）使用np.zeros_like()、np.ones_like()、np.empty_like()创建
① np.zeros_like()
语法：
np.zeros_like(ndarray)
输入的参数是一个ndarray，生成一个结构与之相同但全由0填充的ndarray
这里的结构相同是指：shape相同 + 数据类型相同
② np.ones_like()
语法：
np.ones_like(ndarray)
输入的参数是一个ndarray，生成一个结构与之相同但全由1填充的ndarray
这里的结构相同是指：shape相同 + 数据类型相同
③ np.empty_like()
语法：
np.empty_like(ndarray)
输入的参数是一个ndarray，生成一个结构与之相同但全由特别大或特别小的数填充的ndarray
这里的结构相同是指：shape相同 + 数据类型相同
（5）使用np.linspace()创建
linspace是线性等分向量（ linear space ）的缩写，注意方法名中间没有字母e
语法：
np.linspace(起始值,结束值,切分份数=50)
注意：
- 起始值、结束值都是可以取到的（和“顾头不顾尾”原则不同）
- 切分份数指的就是返回的一维ndarray中有几个元素，其默认值为50
import numpy as np
arr = np.linspace(1,5,4) # 从1到5，等距离分成4份
print(arr)
执行结果：
[1. 2.33333333 3.66666667 5.]
（6）使用np.eye()、np.identity()创建
语法：
np.eye(n)
、
np.eye(a,b)
、
np.identity(n)
np.eye()可以生成一个单位矩阵（二维ndarray），可以是n行n列正方形，也可以是a行b列长方形
np.identity()则只能生成正方形的单位矩阵
import numpy as np
arr1 = np.eye(2)
arr2 = np.eye(3,4)
arr3 = np.identity(2)
# arr4 = np.identity((3,4)) # 报错
print(arr1); print('===========')
print(arr2); print('===========')
print(arr3)
执行结果：
[[1. 0.]
[0. 1.]]
===========
[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]]
===========
[[1. 0.]
[0. 1.]]
（7）使用np.diagflat()创建
语法：
np.diagflat(v)
生成以指定列表或一维ndarray为对角线元素的方阵（二维ndarray）
参数v可以是list、ndarray等
import numpy as np
arr1 = np.array([1,2,3])
arr2 = np.diagflat(arr1) # 参数是ndarray
arr3 = np.diagflat([4,5,6]) # 参数是list
print(arr1); print('===========')
print(arr2); print('===========')
print(arr3)
执行结果：
[1 2 3]
===========
[[1 0 0]
[0 2 0]
[0 0 3]]
===========
[[4 0 0]
[0 5 0]
[0 0 6]]
（8）使用随机数方法创建
详见本章“一.9.NumPy随机数”
5. ndarray的索引和切片
（1）一维ndarray的索引和切片方法
与列表的方法大体相同，新增了 花式索引 （ Fancy Indexing ）：
import numpy as np
a = np.arange(10,20)
print(a)
print(a[[8,2,5]])
执行结果：
[10 11 12 13 14 15 16 17 18 19]
[18 12 15]
注意：花式索引通过list实现，因此数字外面要套两层中括号[[]]，如果只有一层将报错
（2）二维ndarray的索引和切片方法
import numpy as np
arr = np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15],[16,17,18,19,20]])
print(arr,'\n')
# 选取某一行
print('选取第一行推荐方法\n', arr[0,:])
print('选取第一行这样也行\n',arr[0])
# 选取某一列
print('选取最后一列\n', arr[:,-1])
# 选取某一行某一列上的元素
print('选取倒数第二行第三列的元素\n', arr[-2,2])
# 选取某几行中的某几列（纯切片）
print('选取倒数第二行到最后一行，列索引号为奇数的元素\n', arr[-2:,1::2])
# 选取某几行中的某几列（切片+花式索引）
print('选取第一行到第三行，第一、五、四列的元素\n', arr[:3,[0,4,3]])
执行结果：
[[ 1 2 3 4 5]
[ 6 7 8 9 10]
[11 12 13 14 15]
[16 17 18 19 20]]
选取第一行推荐方法
[1 2 3 4 5]
选取第一行这样也行
[1 2 3 4 5]
选取最后一列
[ 5 10 15 20]
选取倒数第二行第三列的元素
13
选取倒数第二行到最后一行，列索引号为奇数的元素
[[12 14]
[17 19]]
选取第一行到第三行，第一、五、四列的元素
[[ 1 5 4]
[ 6 10 9]
[11 15 14]]
（3）布尔值索引
对二维ndarray的某行或某几行按照一定的条件进行筛选，返回该ndarray某一行的对应项组成的新的ndarray
多条件筛选时，&代表“且”，|代表“或”（不能写成and、or），并且要注意每个条件外面需要加小括号()
示例代码见“
第五章 Python编程进阶 - 一、NumPy模块 - 8. ndarray对象的方法和NumPy模块的方法 - （2）二元通用函数 - ③ 基本逻辑运算
”
（4）查找非0元素的索引
语法：np.nonzero(arr)
以元组的形式返回一个ndarray中的非0元素索引号，ndarray可以是一维也可以是多维，每个维度分别对应结果元组中的一项
import numpy as np
a = np.array([8,8,0,8]) # 一维ndarray
b = np.array([[3, 0, 0],
[0, 4, 0], # 二维ndarray
[5, 6, 0]])
result_a = np.nonzero(a)
result_b = np.nonzero(b)
print(result_a)
print(result_b)
print(type(result_a))
print(type(result_b))
执行结果：
(array([0, 1, 3], dtype=int64),)
(array([0, 1, 2, 2], dtype=int64), array([0, 1, 0, 1], dtype=int64))
<class 'tuple'>
<class 'tuple'>
解释：
一维的结果说明非0元素的索引号为：0,1,3
二维的结果说明非0元素的索引号为：(0,0),(1,1),(2,0),(2,1)
6. ndarray的向量化和广播
（1）向量化（
vectorization
）
ndarray很重要正是因为它提供了可以批处理数据而不需要写任何for循环的向量化运算。
在向量化运算中，参与运算的都是两个shape相同的ndarray，进行元素级操作，相同位置的元素按照某种运算规则进行运算。
向量化的运算速度比Python的for循环要快上两个数量级，可以有效提升代码性能。
import numpy as np
return_array = np.array([0.1, 0.12, 0.3, 0.06, -0.05])
delta_return_array = np.array([0.05, 0.02, 0.1, 0.02, 0.01])
leverage_array = np.array([2, 1.5, 2, 3, 1])
print(return_array + delta_return_array) # 向量化加法
print(return_array - delta_return_array) # 向量化减法
print(return_array * leverage_array) # 向量化乘法
print(return_array / leverage_array) # 向量化除法
print(return_array ** leverage_array) # 向量化乘方
执行结果：
[ 0.15 0.14 0.4 0.08 -0.04]
[ 0.05 0.1 0.2 0.04 -0.06]
[ 0.2 0.18 0.6 0.18 -0.05]
[ 0.05 0.08 0.15 0.02 -0.05]
[ 0.01 0.04156922 0.09 0.000216 -0.05]
（2）广播（ Broadcasting ）
① ndarray与数字进行计算
对于ndarray与数字进行的+、-、*、/、**、//、%、>、<、>=、<=、==、!=等运算，会将这个ndarray中的每一个元素均与这个数字进行计算，并用这些结果组成一个与原ndarray结构相同的ndarray
import numpy as np
arr=np.array([1,2,3])
print(arr+2)
print(arr>2)
执行结果：
[3 4 5]
[False False True]
② 二维ndarray与一维对象进行计算
这个计算有个前提，即 二维ndarray的列数等于一维对象的长度 ，在满足这个前提的情况下（不满足则报错），会将二维ndarray的每一行均与一维对象进行计算，并用这些结果组成一个与二维ndarray结构相同的ndarray
import numpy as np
arr = np.array([
[1, 2, 3, 4, 5],
[6, 7, 8, 9, 10],
[11, 12, 13, 14, 15]
])
delta = [3,3,2,2,2]
print(arr); print('=====================')
print(arr+delta); print('=====================')
print(arr-delta); print('=====================')
print(arr*delta); print('=====================')
print(arr/delta); print('=====================')
print(arr**delta)
执行结果：
[[ 1 2 3 4 5]
[ 6 7 8 9 10]
[11 12 13 14 15]]
=====================
[[ 4 5 5 6 7]
[ 9 10 10 11 12]
[14 15 15 16 17]]
=====================
[[-2 -1 1 2 3]
[ 3 4 6 7 8]
[ 8 9 11 12 13]]
=====================
[[ 3 6 6 8 10]
[18 21 16 18 20]
[33 36 26 28 30]]
=====================
[[0.33333333 0.66666667 1.5 2. 2.5 ]
[2. 2.33333333 4. 4.5 5. ]
[3.66666667 4. 6.5 7. 7.5 ]]
=====================
[[ 1 8 9 16 25]
[ 216 343 64 81 100]
[1331 1728 169 196 225]]
#练习
import numpy as np
a = np.zeros((5,5))
a += np.arange(5) # 写成Z = Z + np.array([0,1,2,3,4])更便于理解
print(a)
执行结果：
[[0. 1. 2. 3. 4.]
[0. 1. 2. 3. 4.]
[0. 1. 2. 3. 4.]
[0. 1. 2. 3. 4.]
[0. 1. 2. 3. 4.]]
关于两个ndarray之间的乘法
两个ndarray之间的
*
并不是矩阵乘法，对ndarray计算矩阵乘法应使用
np.dot(arr1,arr2)
或
arr1.dot(arr2)
（dot是点乘的意思），不过这样并不严谨，因为一维ndarray本身不区分行和列，分不清到底乘的是行向量还是列向量。
因此矩阵乘法建议使用matrix数据类型进行
*
的计算，详见本章“四.10NumPy线性代数”。
import numpy as np
a = np.array([[3, 1], [1, 2]])
b = np.array([2, 3])
print(a*b) # 基于向量化、广播计算的乘法
print('=========')
print(np.dot(a,b)) # 矩阵乘法（不严谨：这里的b应该是列向量，但是一维ndarray本身不区分行、列）
print('=========')
print(a.dot(b)) # 矩阵乘法
执行结果：
[[6 3]
[2 6]]
=========
[9 8] # 不严谨：这里得到的应该是列向量，但是一维ndarray本身不区分行、列
=========
[9 8] # 不严谨
7. ndarray的修改、变形、转换
（1）修改shape
① 基于arr.reshape()
语法：
arr.reshape(new_shape)
将一个ndarray的shape进行调整
参数new_shape：一个整数（对应1维）或一个元组（元组中有几个元素就是几维）
注意：
- 新的ndarray的size必须等于原ndarray的size（否则报错）
- 当new_shape是二维时，其中一个参数可以是 -1 ，代表此维度由 size/另一维度 自动计算得出。此时另一个维度必须是能size整除的整数（否则报错）。此外，两个维度不能同为 -1 （否则报错）。
- 原ndarray并未发生改变 ，因此需要定义一个新的变量来接收这个新的ndarray
import numpy as np
a = np.arange(1,25)
b = a.reshape((4,6))
c = b.reshape((3,-1))
d = b.reshape((-1,12))
e = b.reshape(24)
# e = b.reshape((24,)) # 这样写e也可以
# f = b.reshape(7,-1) # 报错，7不能被24整除
# g = b.reshape(-1,-1) # 报错，两个维度不能同为-1
print(a); print('===============')
print(b); print('===============')
print(c); print('===============')
print(d); print('===============')
print(e)
执行结果：
[ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]
===============
[[ 1 2 3 4 5 6]
[ 7 8 9 10 11 12]
[13 14 15 16 17 18]
[19 20 21 22 23 24]]
===============
[[ 1 2 3 4 5 6 7 8]
[ 9 10 11 12 13 14 15 16]
[17 18 19 20 21 22 23 24]]
===============
[[ 1 2 3 4 5 6 7 8 9 10 11 12]
[13 14 15 16 17 18 19 20 21 22 23 24]]
===============
[ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]
② 基于np.reshape()
语法：
np.reshape(arr,new_shape)
将一个ndarray的shape进行调整
两个参数：
- arr：numpy.ndarray的一个实例化对象
- new_shape：一个整数（对应1维）或一个元组（元组中有几个元素就是几维）
和arr.reshape()完全相同，不再赘述
import numpy as np
a = np.arange(1,25)
b = np.reshape(a,(4,6))
c = np.reshape(b,(3,-1))
d = np.reshape(b,(-1,12))
e = np.reshape(b,24)
# e = np.reshape(b,(24,)) # 这样写e也可以
# f = np.reshape(b,(7,-1)) # 报错，7不能被24整除
# g = np.reshape(b,(-1,-1)) # 报错，两个维度不能同为-1
print(a); print('===============')
print(b); print('===============')
print(c); print('===============')
print(d); print('===============')
print(e)
执行结果：
[ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]
===============
[[ 1 2 3 4 5 6]
[ 7 8 9 10 11 12]
[13 14 15 16 17 18]
[19 20 21 22 23 24]]
===============
[[ 1 2 3 4 5 6 7 8]
[ 9 10 11 12 13 14 15 16]
[17 18 19 20 21 22 23 24]]
===============
[[ 1 2 3 4 5 6 7 8 9 10 11 12]
[13 14 15 16 17 18 19 20 21 22 23 24]]
===============
[ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]
（2）修改size
① 基于arr.resize()
语法：
arr.resize(new_shape, refcheck=True)
将一个ndarray的size进行调整
参数：
- new_shape：一个整数（对应1维）或一个元组（元组中有几个元素就是几维）
- refcheck：布尔值，是否执行一个检验，一般不用加这个参数，如果未加此参数时报错，可以尝试加上refcheck=False关掉检验
注意：
- 直接在原ndarray上进行原地修改 ，resize()操作无返回值（如果定义新变量来接收，则其为None）
- 新的ndarray的size可以小于、等于、大于原ndarray的size。 若大于，则用0来填补后面的空项
import numpy as np
a = np.arange(1,25)
print(a); print('===============')
a.resize((2,12))
print(a); print('===============')
a.resize((3,3))
print(a); print('===============')
a.resize(12)
# a.resize((12,))
print(a)
执行结果：
[ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]
===============
[[ 1 2 3 4 5 6 7 8 9 10 11 12]
[13 14 15 16 17 18 19 20 21 22 23 24]]
===============
[[1 2 3]
[4 5 6]
[7 8 9]]
===============
[1 2 3 4 5 6 7 8 9 0 0 0]
② 基于np.resize()
语法：
np.size(arr,new_shape)
将一个ndarray的size进行调整
两个参数：
arr：numpy.ndarray的一个实例化对象
new_shape：一个整数（对应1维）或一个元组（元组中有几个元素就是几维）
注意：
- 非原地修改，需要定义一个新的变量来接收np.resize()的返回值
- 新的ndarray的size可以小于、等于、大于原ndarray的size。 若大于，则会回到起始位置来填补后面的空项
import numpy as np
a = np.arange(1, 25)
b = np.resize(a, (2, 12))
c = np.resize(b, (3, 3))
d = np.resize(c, 12)
# d = np.resize(c, (12,))
print(a); print('===============')
print(b); print('===============')
print(c); print('===============')
print(d)
执行结果：
[ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]
===============
[[ 1 2 3 4 5 6 7 8 9 10 11 12]
[13 14 15 16 17 18 19 20 21 22 23 24]]
===============
[[1 2 3]
[4 5 6]
[7 8 9]]
===============
[1 2 3 4 5 6 7 8 9 1 2 3]
（3）转置
语法：
arr.T
或
arr.transpose()
，两种方式等效
将ndarray转置：
- 一维ndarray不分行或列，转置完了还是自己
- 二维ndarray的shape由转置前的(m,n)变为(n,m)
- 多维ndarray的shape由转置前的(k1,k2,...,kn)变为(kn,...,k2,k1)
# 一维ndarray的转置
import numpy as np
a = np.arange(1,7)
print(a,a.shape)
b = a.T
print(a,a.shape); print(b,b.shape)
c = a.transpose()
print(a,a.shape); print(c,c.shape)
执行结果：
[1 2 3 4 5 6] (6,)
[1 2 3 4 5 6] (6,)
[1 2 3 4 5 6] (6,)
[1 2 3 4 5 6] (6,)
[1 2 3 4 5 6] (6,)
# 二维ndarray的转置
import numpy as np
a = np.arange(1,7)
a.resize((2,3))
b = a.T
c = b.transpose()
print(a); print('===============')
print(b); print('===============')
print(c)
执行结果：
[[1 2 3]
[4 5 6]]
===============
[[1 4]
[2 5]
[3 6]]
===============
[[1 2 3]
[4 5 6]]
（4）将多维ndarray变为一维
flatten: v.压平
语法：
arr.flatten(order='C')
参数order：可选参数，为取值顺序，默认为
'C'
，即按行取；也可以是
'F'
，即按列取
import numpy as np
a = np.arange(1,10).reshape(3,3)
print(a); print('===============')
b = a.flatten()
print(a); print('===============')
print(b); print('===============')
c = a.flatten(order='F')
print(c)
执行结果：
[[1 2 3]
[4 5 6]
[7 8 9]]
===============
[[1 2 3]
[4 5 6]
[7 8 9]]
===============
[1 2 3 4 5 6 7 8 9]
===============
[1 4 7 2 5 8 3 6 9]
（5）修改ndarray中指定元素的值
语法：
arr[索引]=值
原则上只能修改成相同数据类型的值。若改变了数据类型，则有以下规则：
- 将已有的int组成的ndarray中的某项元素修改为float时，只会将该float截取整数部分后进行保存
import numpy as np
b=np.array([1,2,3])
print(b,type(b))
b[1]=45.67
print(b,type(b))
执行结果：
[1 2 3] <class 'numpy.ndarray'>
[1 45 3] <class 'numpy.ndarray'>
- 将已有的字符串组成的ndarray中的某项元素修改为数字时，先将数字统一转为字符串，再按照原ndarray最长的元素的长度对替换后的字符串进行截取
import numpy as np
b=np.array(['a','bc','def'])
print(b,type(b))
b[0]=12.34
b[1]=56789
print(b,type(b))
执行结果：
['a' 'bc' 'def'] <class 'numpy.ndarray'>
['12.' '567' 'def'] <class 'numpy.ndarray'>
-
将已有的int组成的ndarray中的某项元素修改为字符串时，会将对应的数字修改为
int(给定的字符串)，当给定的字符串里含有除负号“-”以外的字母或特殊字符时，会报错 -
将已有的float组成的ndarray中的某项元素修改为字符串时，会将对应的数字修改为
float(给定的字符串)，当给定的字符串里含有float()不支持的字母或特殊字符时，会报错
（6）对ndarray中的元素进行排序
语法：arr.sort()或np.sort(arr)
arr.sort()无返回值，直接在原ndarray上执行升序排列；np.sort(arr)不会更改原ndarray，而是产生一个升序排列后的新的ndarray
两种方法都仅支持升序排列， 不支持降序排列
import numpy as np
a1 = np.array([3,1,4,2])
a2 = np.array([3,1,4,2])
b1 = a1.sort()
b2 = np.sort(a2)
print(a1)
print(a2)
print(b1)
print(b2)
执行结果：
[1 2 3 4]
[3 1 4 2]
None
[1 2 3 4]
（7）对两个ndarray进行拼接
横向拼接：
np.hstack([arr1,arr2])
或
np.append(arr1,arr2)
纵向拼接：
np.vstack([arr1,arr2])
注意：np.append()更像是list的extend方法（迭代追加，将arr2中的每个元素追加到arr1中），而不像list的append方法（把整个arr2作为一个元素追加到arr1中）
import numpy as np
a = np.array([1,2,3])
b = np.array([4,5,6])
c = np.append(a,b)
d = np.hstack([a,b])
e = np.vstack([a,b])
print(c); print('========')
print(d); print('========')
print(e)
执行结果：
[1 2 3 4 5 6]
========
[1 2 3 4 5 6]
========
[[1 2 3]
[4 5 6]]
（8）对ndarray进行去重
语法：
np.unique(arr)
将ndarray中的所有元素去重，然后按由小到大顺序排列，无论输入的arr是几维的，都返回一个一维ndarray
import numpy as np
arr1 = np.unique(np.array([6,2,3,1,4,1,2,5]))
arr2 = np.unique(np.array([[6,2,3],[1,4,1],[2,5,3]]))
print(arr1)
print(arr2)
执行结果：
[1 2 3 4 5 6]
[1 2 3 4 5 6]
（9）将ndarray转换为其他数据格式
① 将ndarray转换为list
语法：arr.tolist()
此方法不会对arr本身进行修改，因此需要定义一个新的变量来接收产生的list
② 将ndarray转换为矩阵
语法：np.asmatrix(arr)
特别地，若arr是一个一维ndarray，则得到的将是一个行向量（即1行n列的矩阵）
import numpy as np
a = np.array([1,2,3])
b = a.tolist()
c = np.asmatrix(a)
print(a,type(a))
print(b,type(b))
print(c,type(c))
执行结果：
[1 2 3] <class 'numpy.ndarray'>
[1, 2, 3] <class 'list'>
[[1 2 3]] <class 'numpy.matrix'>
8. ndarray对象的方法和NumPy模块的方法
（1）一元通用函数
通用函数（ universal function ）是指NumPy中对ndarray执行元素级运算的函数
分别对ndarray中的每项进行计算，并将结果组成一个新的ndarray
求绝对值 ：np.abs(arr)
求平方 ：np.square(arr)
求平方根 ：np.sqrt(arr)
指数运算 ：np.exp(arr)
对数运算 ：np.log(arr)
数据近似计算
：
向下取整：np.floor(arr)
向上取整：np.ceil(arr)
四舍五入：arr.round(n)、np.round(arr,n)
符号判断 ：np.sign(arr)，正数项返回1，负数项返回-1，0返回0。此外，也可以使用np.where()来实现更为复杂的根据判断结果返回指定值的功能。
（2）二元通用函数
分别对两个（shape相同的）ndarray中的对应项进行计算，并将结果组成一个新的ndarray
① 基本数学运算
- 加：arr1 + arr2
- 减：arr1 - arr2
- 乘：arr1 * arr2
- 除：arr1 / arr2
- 取余：arr1 % arr2
② 基本比较运算
-
大于：arr1 > arr2
-
大于等于：arr1 >= arr2
-
小于：arr1 < arr2
-
小于等于：arr1 <= arr2
-
等于：arr1 == arr2
-
不等于：arr1 != arr2
import numpy as np
arr1=np.array([1,2,3])
arr2=np.array([0,2,4])
print(arr1>arr2)
print(arr1==arr2)
print(arr1!=arr2) 执行结果：
[ True False False]
[False True False]
[ True False True]
③ 基本逻辑运算
用来对两个ndarray组成的条件（或两个布尔值类型的ndarray）执行逻辑运算，注意不要用Python原生的or、and、not进行运算否则报错，具体的运算符包括：
-
或：
(条件1) | (条件2)、np.logical_or(条件1,条件2) -
且：
(条件1) & (条件2)、np.logical_and(条件1,条件2) -
非：
~(条件1)、np.logical_not(条件)
import numpy as np
code_array = np.array(['000001', '000002', '000003', '000004'])
pe_array = np.array([20, 10, 5, 30])
roe_array = np.array([0.05, -0.10, 0.12, 0.15])
# 单条件筛选
print(code_array[pe_array<=10]); print('===========')
# 单条件筛选（非）
print(code_array[~(pe_array<=10)])
print(code_array[np.logical_not(pe_array<=10)]); print('===========')
# 多条件筛选（且）
print(code_array[(pe_array<=10) & (roe_array>=0)])
print(code_array[np.logical_and(pe_array<=10,roe_array>=0)]); print('===========')
# 多条件筛选（或）
print(code_array[(pe_array<=10) | (roe_array>=0)])
print(code_array[np.logical_or(pe_array<=10,roe_array>=0)])
执行结果：
['000002' '000003']
===========
['000001' '000004']
['000001' '000004']
===========
['000003']
['000003']
===========
['000001' '000002' '000003' '000004']
['000001' '000002' '000003' '000004']
（3）统计相关方法
求和 ：arr.sum()、np.sum(arr)
import numpy as np
arr = np.array([[1,2,-3],[4,5,-6],[7,8,-9]])
print(arr.sum())
执行结果：9
# 将广播与sum()结合实现真值计数
import numpy as np
arr = np.array([[1,2,-3],[4,5,-6],[7,8,-9]])
print(arr); print('===========')
print(arr>0); print('===========')
print((arr>0).sum())
执行结果：
[[ 1 2 -3]
[ 4 5 -6]
[ 7 8 -9]]
===========
[[ True True False]
[ True True False]
[ True True False]]
===========
6
求平均值 ：简单平均arr.mean()、简单平均np.mean(arr)、加权平均np.average(arr)
求标准差 ：arr.std()、np.std(arr)
求Pearson相关系数矩阵 ：np.corrcoef(arr1,arr2)，返回一个n行n列的ndarray
求最值及其索引 ：
-
求最大值 ：arr.max()、np.max(arr)
-
求最大值项的索引值 ：arr.argmax()、np.argmax(arr)
当有多项同为最大时，返回首个索引值
当arr为多维ndarray时，会将其转化为一维ndarray，并返回此一维ndarray的最大项索引值
import numpy as np
arr = np.array([[10,20,30],
[40,50,60],
[70,80,90]])
print(arr.argmax())
print(np.argmax(arr)) 执行结果：
8
8 -
求最小值 ：arr.min()、np.min(arr)
-
求最小值项的索引值 ：arr.argmin()、np.argmin(arr)
当有多项同为最小时，返回首个索引值
当arr为多维ndarray时，会将其转化为一维ndarray，并返回此一维ndarray的最小项索引值
累积计算 ：
-
累积和（ cumulative sum ）：arr.cumsum()、np.cumsum(arr)
-
累积积（ cumulative product ）：arr.cumprod()、np.cumprod(arr)
注意：
- ndarray没有累积最大(cummax)、累积最小(cummin)这两种方法，但是pandas.DataFrame有
- 若计算的ndarray是多维的，会将其变为一维，然后再计算其累积和、累积积，返回的结果也是一维ndarray。这点和pandas.DataFrame不同，pandas.DataFrame直接用多维数据按列（或按行）计算累积值，不会将其变为一维再计算。
import numpy as np
arr = np.array([[2,2,2],[2,2,2],[2,2,2]])
print(arr.cumsum())
print(np.cumsum(arr))
print(arr.cumprod())
print(np.cumprod(arr)) 执行结果：
[ 2 4 6 8 10 12 14 16 18]
[ 2 4 6 8 10 12 14 16 18]
[ 2 4 8 16 32 64 128 256 512]
[ 2 4 8 16 32 64 128 256 512]
求近似分位数 ：np.percentile(arr,rate)，其中rate代表百分之多少的分位数
注意：
- 这个函数计算的近似分位数是基于由小到大排列的分位数，因此如果想计算由大到小排列的分位数，rate应等于100减去目标百分数
- 之所以称为“近似”分位数，是因为Python对返回值进行了处理，得到的结果并不严格等于该位置上数据的值，见下例：
import numpy as np
arr = np.arange(100)
a = np.percentile(arr,10) # 最小的10%分位数
b = np.percentile(arr,20) # 最小的20%分位数
c = np.percentile(arr,80) # 最大的20%分位数
d = np.percentile(arr,90) # 最大的10%分位数
print(arr); print('===========')
print(a)
print(b)
print(c)
print(d); print('===========')
print(arr[arr<a]); print('-----------')
print(arr[arr<b]); print('-----------')
print(arr[arr>c]); print('-----------')
print(arr[arr>d])
执行结果：
[ 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]
===========
9.9
19.8
79.2
89.10000000000001
===========
[0 1 2 3 4 5 6 7 8 9]
-----------
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]
-----------
[80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99]
-----------
[90 91 92 93 94 95 96 97 98 99]
（4）其他重要方法
① np.where()
语法1：
np.where(arr组成的判断条件, x, y)
当x和y都留空时，返回一个由索引号组成的ndarray组成的元组。此时，可以进一步通过
arr[np.where(arr组成的判断条件)]
得到满足条件的项组成的新的arr（这里相当于应用了花式索引）
当x和y是一个具体的值时，返回一个与给定arr具有相同shape的新的arr，新的arr中每一项的值取决于给定arr中对应项的判断结果，为True时赋值x，为False时赋值y
当x和y是与arr具有相同shape的arr时，返回一个与给定arr具有相同shape的新的arr，新的arr中每一项的值取决于给定arr中对应项的判断结果，为True时从x的对应位置取值，为False时从y的对应位置取值
若第二个参数和第三个参数有一个留空、一个不留空，则报错
注意：
-
np.where()是一种重要的方法，它相当于向量化的if，使用它可以避免Python层面的循环嵌套if，应熟练掌握
-
np.where()只能满足状态有两种（True或False）的情况；
若状态有三种，则需要写两句np.where()，此时也可以考虑是否能用np.sign()完成需求；
若状态有N种，则需要写(N-1)句np.where()
# 对一维ndarray应用np.where()（两种状态）
import numpy as np
a = np.array([10,80,20,90])
b = np.where(a<50)
c = a[np.where(a<50)]
d = np.where(a<50, a, 9999)
print(b,type(b))
print(c,type(c))
print(d,type(d))
执行结果：
(array([0, 2], dtype=int64),) <class 'tuple'>
[10 20] <class 'numpy.ndarray'>
[10 9999 20 9999] <class 'numpy.ndarray'>
# 对一维ndarray应用np.where()（三种状态）
import numpy as np
a = np.array([10,-80,0,-20,90])
b = np.where(a>0, 1, 0)
b = np.where(a<0, -1, b)
print(b,type(b))
执行结果：
[ 1 -1 0 -1 1] <class 'numpy.ndarray'>
# 对二维ndaray应用np.where()（两种状态）
import numpy as np
a = np.array([[66,20,20],
[20,99,20],
[88,77,20]])
b = np.where(a>50)
c = a[np.where(a>50)]
d = np.where(a>50, a, 0)
print(b,type(b))
print(c,type(c))
print(d,type(d))
执行结果：
(array([0, 1, 2, 2], dtype=int64), array([0, 1, 0, 1], dtype=int64)) <class 'tuple'>
[66 99 88 77] <class 'numpy.ndarray'>
[[66 0 0]
[ 0 99 0]
[88 77 0]] <class 'numpy.ndarray'>
# 对二维ndarray应用np.where()（三种状态）
import numpy as np
a = np.array([[66,0,-20],
[-20,99,0],
[0,-77,20]])
b = np.where(a>0, 1, 0)
b = np.where(a<0, -1, b)
print(b,type(b))
执行结果：
[[ 1 0 -1]
[-1 1 0]
[ 0 -1 1]] <class 'numpy.ndarray'>
# x和y都是arr时的情况
import numpy as np
condition = np.array([[True,False],[False,True]])
a = np.array([[1,2],[3,4]])
b = np.array([[50,60],[70,80]])
print(a); print('===========')
print(b); print('===========')
print(np.where(condition, a, b))
执行结果：
[[1 2]
[3 4]]
===========
[[50 60]
[70 80]]
===========
[[ 1 60]
[70 4]]
② np.concatenate()
语法：
np.concatenate((arr1, arr2, ...), axis=0)
将若干个ndarray拼接成一个新的ndarray
参数axis：默认值为0，纵向拼接；axis=1时横向拼接
import numpy as np
arr1=np.array([[1, 2],
[3, 4]])
arr2=np.array([[5, 6],
[7, 8]])
arr3=np.array([[9, 10],
[11, 12]])
a = np.concatenate((arr1,arr2,arr3))
b = np.concatenate((arr1,arr2,arr3),axis=1)
print(a); print('===========')
print(b)
执行结果：
[[ 1 2]
[ 3 4]
[ 5 6]
[ 7 8]
[ 9 10]
[11 12]]
===========
[[ 1 2 5 6 9 10]
[ 3 4 7 8 11 12]]
③ np.all()和arr.all()
语法：
np.all(arr)
、
arr.all()
返回一个布尔值，若arr中所有元素都是True，就返回True，否则返回False
import numpy as np
a = np.array([[0,0],[0,0]])
b = np.array([[0,1],[1,0]])
c = np.array([[1,1],[1,1]])
print(a.all()); print('===========')
print(b.all()); print('===========')
print(c.all())
执行结果：
False
===========
False
===========
True
④ np.any()和arr.any()
语法：
np.any(arr)
、
arr.any()
返回一个布尔值，只要arr中有一个元素是True，就返回True，否则返回False
import numpy as np
a = np.array([[0,0],[0,0]])
b = np.array([[0,1],[1,0]])
c = np.array([[1,1],[1,1]])
print(a.any()); print('===========')
print(b.any()); print('===========')
print(c.any())
执行结果：
False
===========
True
===========
True
9. NumPy随机数
（1）产生标准正态分布的随机数
① numpy.random.randn()
randn中的n即代表normal
语法：numpy.random.randn(d0,d1,...,dn)
根据给定的维度生成标准正态分布（均值为0，标准差为1）的数据
d0,d1,...,dn是每个维度的值
参数为空时，返回一个float；参数不为空时，返回指定维度的ndarray
② np.random.standard_normal()
语法：np.random.standard_normal(shape)
根据给定的shape生成标准正态分布（均值为0，标准差为1）的数据
参数：
- 默认值为None，此时返回一个float
- shape = 0时，返回一个空的ndarray
- shape是>=1的整数时，返回一个一维的ndarray
- shape是一个元组时，元组中有几个元素就返回几维的ndarray
import numpy as np
random_1d_array = np.random.standard_normal(5) # 一维，长度为5
# random_1d_array = np.random.standard_normal((5,)) # 一维，长度为5，使用元组的表示方法
random_2d_array = np.random.standard_normal((3,4)) # 二维，3行4列
random_3d_array = np.random.standard_normal((2,2,2)) # 三维
print(random_1d_array); print('==================')
print(random_2d_array); print('==================')
print(random_3d_array)
执行结果：
[1.76405235 0.40015721 0.97873798 2.2408932 1.86755799]
==================
[[-0.97727788 0.95008842 -0.15135721 -0.10321885]
[ 0.4105985 0.14404357 1.45427351 0.76103773]
[ 0.12167502 0.44386323 0.33367433 1.49407907]]
==================
[[[-0.20515826 0.3130677 ]
[-0.85409574 -2.55298982]]
[[ 0.6536186 0.8644362 ]
[-0.74216502 2.26975462]]]
③ np.random.normal()
语法：np.random.normal(loc=0.0, scale=1.0, size=None)
根据给定的shape生成均值为loc、标准差为scale的正态分布数据
参数：
- loc：正态分布的均值（float或list）
- scale：正态分布的标准差（float或list）
-
size：返回对象的shape
- 默认值为None，此时返回一个float
- size= 0时，返回一个空的ndarray
- size是>=1的整数时，返回一个一维的ndarray
- size是一个元组时，元组中有几个元素就返回几维的ndarray
import numpy as np
random_1d_array = np.random.normal(size=5) # 一维，长度为5
# random_1d_array = np.random.normal(size=(5,)) # 一维，长度为5，使用元组的表示方法
random_2d_array = np.random.normal(size=(3,4)) # 二维，3行4列
random_3d_array = np.random.normal(loc=[1,100000],scale=[1,10000],size=(2,2,2)) # 三维
print(random_1d_array); print('==================')
print(random_2d_array); print('==================')
print(random_3d_array)
执行结果：
[ 1.36942258 -0.34075723 -0.09876788 0.77008845 -1.61318133]
==================
[[ 0.91868812 0.66335297 -0.06814506 -0.2185851 ]
[ 0.54239331 0.85372137 -0.56977034 -0.26731383]
[ 1.8548985 -0.21814791 0.42258236 -0.70729847]]
==================
[[[4.04748732e-01 1.00981797e+05]
[5.70581472e-01 1.03409312e+05]]
[[5.03517513e-01 1.05403085e+05]
[1.52392527e+00 9.90583266e+04]]]
（2）产生均匀分布的随机数
① np.random.rand()
语法：
np.random.rand(d0,d1,...,dn)
根据给定的维度生成[0,1)之间均匀分布的数据，包含0，不包含1
d0,d1,...,dn是每个维度的值
参数为空时，返回一个float；参数不为空时，返回指定维度的ndarray
② np.random.random()
语法：
np.random.random(shape)
根据给定的shape生成[0,1)之间均匀分布的数据，包含0，不包含1
参数shape：
- 默认值为None，此时返回一个float
- shape = 0时，返回一个空的ndarray
- shape是>=1的整数时，返回一个一维的ndarray
- shape是一个元组时，元组中有几个元素就返回几维的ndarray
③ np.random.uniform()
语法：
np.random.uniform(low=0.0, high=1.0, size=None)
根据给定的size生成[low,high)之间均匀分布的数据，包含low，不包含high
参数：
- low：均匀分布的下限（float）
- high：均匀分布的上限（float）
-
size：返回对象的shape
- 默认值为None，此时返回一个float
- size= 0时，返回一个空的ndarray
- size是>=1的整数时，返回一个一维的ndarray
- size是一个元组时，元组中有几个元素就返回几维的ndarray
④ np.random.sample()、np.random.random_sample()
语法：
np.random.sample(shape)
、
np.random.random_sample(shape)
根据给定的shape生成[0,1)之间均匀分布的数据，包含0，不包含1
参数shape：
- 默认值为None，此时返回一个float
- shape = 0时，返回一个空的ndarray
- shape是>=1的整数时，返回一个一维的ndarray
- shape是一个元组时，元组中有几个元素就返回几维的ndarray
（3）产生随机整数 np.random.randint()
语法：
np.random.randint(low, high=None, size=None, dtype='l')
其中low为最小值，high为最大值，dtype为数据类型（默认的数据类型是np.int）
生成随机整数的范围区间为[low,high)，包含low不包含high，high没有填写时默认生成随机数的范围是[0，low)
参数size：
- 默认值为None，此时返回一个np.int
- size = 0时，返回一个空的ndarray
- size是>=1的整数时，返回一个一维的ndarray
- size是一个元组时，元组中有几个元素就返回几维的ndarray
（4）抽样 np.random.choice()
语法：
np.random.choice(a, size=None, replace=True, p=None)
从给定的离散有限数据集中执行若干次抽样（可以是放回抽样，也可以是不放回抽样）
参数：
-
a为给定的数据集：
- a为ndarray时，选取此ndarray中的元素执行抽样
- a为list、tuple时，选取里面的元素执行抽样
- a为int时，选取np.arange(a)里面的元素执行抽样，即从0, 1, 2, ..., a-1里抽样
-
size为数组维度：
- 默认值为None，此时执行一次抽样，返回元素本身的数据类型（不返回ndarray）
- size = 0时，返回一个空的ndarray
- size是>=1的整数时，返回一个一维的ndarray
- size是一个元组时，元组中有几个元素就返回几维的ndarray
-
replace为抽样种类
- 默认值为True，放回抽样
- replace = False时是不放回抽样，此时应确保size大于a中的元素个数，否则报错
- p是a中的元素出现的概率（list形式），默认值为None（均匀分布）
# 例1
import numpy as np
a = np.random.choice(5,20) # 从0,1,2,3,4中抽样，抽20次
print(a)
执行结果：
[1 4 4 1 2 2 1 3 0 4 3 3 2 3 4 4 0 0 3 0]
# 例2
import numpy as np
demo_list = ['python', 'linux','go','c++']
demo_choice = np.random.choice(demo_list, size=(3,5), p=[0.4,0.2,0.1,0.3])
print(demo_choice)
执行结果：
[['linux' 'go' 'linux' 'c++' 'python']
['python' 'c++' 'c++' 'python' 'linux']
['python' 'python' 'c++' 'c++' 'c++']]
（5）随机数种子 np.random.seed()
由于方法每次产生的随机数都不同，不便于对相同数据进行不同算法的比较，可以使用随机数种子来锁定产生的随机数，即每个随机数种子产生的随机数都是相同的
语法：
np.random.seed(n=None)
其中n为随机数种子序号，默认值为None（无种子，即每次产生的随机数均不同），n可以取任意一个非负整数，如0、1、2……
np.random.seed(n)应写在py文件中的第一个np.random.xxx之前，它对整个脚本中的np.random.xxx都有效，但是对其他模块的随机数方法无效
只要随机数种子序号相同，且随机数的概率分布相同，即使调用的函数（方法）不同，得到的结果也一定相同，见下面两个例子：
import numpy as np
np.random.seed(0)
a = np.random.standard_normal((2,2)) # standard_normal()方法
print(a)
执行结果：
[[1.76405235 0.40015721]
[0.97873798 2.2408932 ]]
import numpy as np
np.random.seed(0)
b = np.random.randn(2,2) # randn()方法
print(b)
执行结果：
[[1.76405235 0.40015721]
[0.97873798 2.2408932 ]]
10. NumPy线性代数
（1）矩阵及其基本运算方法
① 矩阵的定义
在NumPy中，矩阵是numpy.matrix的实例化对象
由于矩阵本身就是二维的（行、列的概念本身就是建立在二维基础上的，因此行向量、列向量也是二维的）因此矩阵在定义时，np.matrix()里面有且只能有两层中括号[[]]
import numpy as np
# 一行形式
a = np.matrix([[a11,a12,...,a1n],[a21,a22,...,a2n],...,[am1,am2,...,amn]])
# 多行形式
b = np.matrix([
[a11,a12,...,a1n],
[a21,a22,...,a2n],
...,
[am1,am2,...,amn]
])
# 行向量
c = np.matrix([[1,2,3,4,5]])
# c = np.matrix([1,2,3,4,5]) # 这样写也行，但是不规范，NumPy会自动将其解析成两层中括号[[]]
# 列向量
d = np.matrix([[1],[2],[3],[4],[5]])
② 矩阵的乘法
注意：
- 两个矩阵只有满足乘法前提条件（第一个矩阵的列数等于第二个矩阵的行数）时，才能计算它们的乘法，否则会报错
-
只有当a和b都是matrix数据类型时，
a*b算出来的才是矩阵乘法。如果a和b是ndarray数据类型，那a*b算出来的是向量化的乘法（元素级别的乘法），此时需要使用np.dot(a,b)或a.dot(b)计算他们的矩阵乘法，详见本章“四.7向量化和广播”
import numpy as np
a = np.matrix([[3, 1], [1, 2]]) # a是2x2矩阵
b = np.matrix([[2],[3]]) # b是2x1矩阵（列向量）
print(a*b)
执行结果： # 得到一个2x1矩阵（列向量）
[[9]
[8]]
③ 矩阵的转置
import numpy as np
b = np.matrix([[2],[3]])
print(b.T)
print('===========')
print(b.transpose())
执行结果：
[[2 3]]
===========
[[2 3]]
（2）求解线性方程
'''
求解线性方程：
3x+y=9
x+2y=8
'''
import numpy as np
a = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])
x = np.linalg.solve(a, b) # linalg是linear algebra（线性代数）的简写
print(x)
执行结果：[2. 3.] # 即x=2、y=3
（3）回归计算
求回归系数除了可以用Numpy的函数以外，用statsmodels或者sk-learn也是可以很快求出来的；但是追根溯源，sk-learn也是用的numpy来求的
① 使用np.polyfit()返回回归系数
语法：
np.polyfit(x,y,deg)
返回基于最小二乘法的多项式回归的所有回归系数组成的ndarray（里面有deg+1个回归系数）
参数：
-
x：自变量序列
-
y：因变量序列
-
deg：多项式的次数，必须为int类型
-
deg=1时为线性回归，y=ax+b，函数返回值为一个ndarray，里面有两项：a,b
import numpy as np
x = np.array([1,2,3,4,5])
y = x * 5 + 2
reg = np.polyfit(x, y ,1)
slope,interception = np.polyfit(x, y ,1)
print(reg,type(reg))
print(slope,interception) 执行结果：
[5. 2.] <class 'numpy.ndarray'>
5.000000000000001 1.999999999999991
-
deg=2时为二次回归，y=ax**2+bx+c，函数返回值为一个ndarray，里面有三项：a,b,c
import numpy as np
x = np.array([1,2,3,4,5])
y = 8 * x ** 2 - 5 * x - 10
reg = np.polyfit(x, y ,2)
a,b,c = np.polyfit(x, y ,2)
print(reg)
print(a,b,c) 执行结果：
[ 8. -5. -10.]
8.000000000000028 -5.000000000000143 -9.999999999999758
-
② 使用np.polyval()返回回归的预测结果
语法：
np.polyval(回归系数序列,x)
返回基于最小二乘法的多项式回归的预测结果（即返回y的理论值组成的ndarray）
参数：
-
回归系数序列：是一个由回归系数组成的list或一维array，线性回归有两个系数（如
[5,2]），二次回归有三个系数（如[8,-5,-10]）……以此类推，n次回归有(n-1)个系数 - x：自变量序列，可以是一个数字或一个序列，返回值的数据结构与x相同
import numpy as np
x = [13,15,12,14]
y_predict = np.polyval([5,2],x) # 有两个回归系数，说明是线性回归
print(y_predict, type(y_predict))
执行结果：
[67 77 62 72] <class 'numpy.ndarray'>
