多维数据与计算(numpy库)知识点归纳总结及练习题

IT机器猫

已于 2023-05-02 16:45:15 修改

阅读量1.4k

点赞数 1

分类专栏：数据科学文章标签： numpy python jupyter pycharm ipython

于 2022-11-07 20:18:43 首次发布

本文链接：https://blog.csdn.net/cgrs5572/article/details/127737023

版权

数据科学专栏收录该内容

8 篇文章 4 订阅

订阅专栏

额外知识点

np.where(条件,1,2)
满足条件执行1，不满足则执行2

怎么判断数组是一维的还是二维的？

要判断一个数组是一维的还是二维的，可以通过查看数组元素的类型来确定。如果数组元素的类型是基本数据类型（如int、float等），那么该数组就是一维的；如果数组元素的类型是数组类型，那么该数组就是二维的。另外，还可以通过查看数组的长度来判断，如果数组的长度为1，那么该数组就是一维的；如果数组的长度大于1，那么该数组就可能是二维的。

axis=0和axis=1的区别？
在Python中，axis=0和axis=1是用于沿着数组的特定轴执行操作的参数。
当axis=0时，操作将沿着数组的第一个维度进行计算（二维数组的第一个维度是行（row）。行是沿着垂直方向的元素集合）。例如，在一个二维数组中，axis=0表示对每一列进行计算。
当axis=1时，操作将沿着数组的第二个维度进行计算（二维数组的第二个维度是列（column），列是沿着水平方向的元素集合）。例如，在一个二维数组中，axis=1表示对每一行进行计算。

多维数据结构

numpy库提供了多维数组ndarray
创建多维数组时需导入库numpy，即：
import numpy as np

一维数组

np.array()—基于列表创建一维数组（即数组创建用到列表）

一维数组的创建

import numpy as np
#一维数组的创建
names= np.array(['李白', '苏轼', '白居易', '雷锋', '焦裕禄'])
subjects= np.array(['Math', 'English', 'Python', 'Chinese', 'Art', 'Database', 'Physics'])
#一维数组的访问
print(names, subjects)
	>>> ['李白' '苏轼' '白居易' '雷锋' '焦裕禄'] ['Math' 'English' 'Python' 'Chinese' 'Art' 'Database' 'Physics']

数组特性

注意：一维数组与二维数组的数组特性函数相同，唯一不同就是多了个obj.shape)

obj.ndim#数组的维度
obj.size#数组中元素的个数
obj.dtype#数组中元素的数据类型
obj.astype#用于将数组中的元素转换为指定的数据类型。它返回一个新的数组，其中的元素类型被转换为指定的数据类型。

a0= names.ndim#数组维度
a1= names.size#数组元素个数
a2= names.dtype#数组数据类型
print(a0, a1, a2)#由结果可看出数组中元素的类型为U3
	>>> 1 5 <U3
a= np.array([2,5,13,56,95])
a.astype(float)
	>>> array([ 2.,  5., 13., 56., 95.])

数组切片

索引序号范围为[0,n-1]或者[-n,-1] n为数组大小

一维数组切片
抽取数组的一部分元素生成新数组成为切片操作
obj[index]
obj[indexlist]
obj[start: end: step]—step缺省为0

a3= names[1]
a4= names[[0,2]]
a5= names[0:4]
a6= names[-3:]
print(a3,a4,a5,a6)
	>>> 苏轼 ['李白' '白居易'] ['李白' '苏轼' '白居易' '雷锋'] ['白居易' '雷锋' '焦裕禄']

根据条件筛选数组元素—举例说明

names== '李白'
	>>> array([ True, False, False, False, False])
names[names== '李白']
	>>> array(['李白'], dtype='<U3')

使用条件表达式和关系运算符

names[(names== '李白') | (names== '焦裕禄')]
	>>> array(['李白', '焦裕禄'], dtype='<U3')

生成布尔型数组

mask=(names== '李白') | (names== '焦裕禄')
mask
	>>> array ([ True, False, False, False,  True])
names[mask]
	>>> names[mask]
names[mask]
array(['李白', '焦裕禄'], dtype='<U3')

二维数组

np.array()—基于列表创建二维数组（即数组的创建用到表）

np.array()所创建的一维数组的每个元素均为np.array()所创建的二维数组的行索引

import numpy as np
一维数组的创建
names= np.array([‘李白’,‘苏轼’,‘白居易’,‘雷锋’,‘焦裕禄’])
subjects= np.array([‘Math’, ‘English’, ‘Python’,‘Chinese’,‘Art’, ‘Database’, ‘Physics’])
对应二维数组的创建
scores= np.array([[70,85,77,90,82,84,89],[60,64,80,75,80,92,90], [90,93,88,87,86,90,91],[80,82,91,88,83,86,80], [88,72,78,90,91,73,80]])
数组创建后names、subjects自动对应二维数组的行和列。
可能会有的疑问：为什么系统自动匹配names为二维数组的行索引，subjects为二维数组的列索引？
原因：系统会自动检测一维数组元素的个数并与二维数组的m和n进行对应。
另一个疑问：当names和subjects的元素个数都为5，且二维数组为5*5，此时names和 subjects哪一个为行索引，哪一个为列索引？
解答：此时不会自动匹配行或列索引，你自己进行代码查找时，将names放到行索引的代码处时则names为行索引，subjects为列索引；将subjects放到行索引代码处时则subjects为行索引，names为列索引（注：可以写代码进行验证）

二维数组的创建

方式1：

scores=np.array([[70,85,77,90,82,84,89],[60,64,80,75,80,92,90], [90,93,88,87,86,90,91],[80,82,91,88,83,86,80],[88,72,78,90,91,73,80]])
scores
	>>> array([[70, 85, 77, 90, 82, 84, 89],
      		[60, 64, 80, 75, 80, 92, 90],
       		[90, 93, 88, 87, 86, 90, 91],
       		[80, 82, 91, 88, 83, 86, 80],
       		[88, 72, 78, 90, 91, 73, 80]])

二维数组创建方式2：

b0=[[70,85,77,90,82,84,89],[60,64,80,75,80,92,90], [90,93,88,87,86,90,91],[80,82,91,88,83,86,80],[88,72,78,90,91,73,80]]
score=np.array(b0)
score
	>>> array([[70, 85, 77, 90, 82, 84, 89],
       		[60, 64, 80, 75, 80, 92, 90],
      		[90, 93, 88, 87, 86, 90, 91],
      		[80, 82, 91, 88, 83, 86, 80],
       		[88, 72, 78, 90, 91, 73, 80]])

此处仅列举了两种创建方式，并不等于就只有两种创建方式。

数组特性

数组特性(一维数组与二维数组的数组特性函数相同，唯一不同就是多了个obj.shape)
obj.ndim
obj.size
obj.dtype
obj.shape

b1=scores.ndim
b2= scores.size
b3=scores.dtype
b4=scores.shape
print(b1,b2,b3,b4)
	>>> 2 35 int32 (5, 7)

二维数组切片

arr[row,column]
row–行序号 column–列序号
行列切片的表示方式与一维数组相同
用：来代替所有行或所有列
arr[a,b]—访问a行b列所对应的那个元素
arr[[a,b]]等同于arr[[a,b],:] —取第a、b两行的所有元素
arr[[a,b],[c,d]]------取第a行c列的那一个元素和第b行d列的那一个元素
price[(supmarkets==‘大润发’)|(supmarkets==‘联华’),(fruits==‘苹果’)|(fruits==‘香蕉’)]—取大润发的苹果和联华的香蕉的价格–此为代码中带文字的形式
arr[:,[a,b]]—取第a、b两列的所有元素
arr[[a,b],c:d]等同于arr[[a,b]][:,[c,d]]—取第a、b两行的第c到d-1列的元素

c0=score[0,1]
c1=score[[1,3]]
c11=score[[1,3],:]
c2=score[:,[0,1]]
c3=score[[1,3],0:2]
c33=score[[1,3]][:,0:2]
c333=score[[1,3]][:,[0,1]]
c4=score[]
print("c0:{}\nc1:{}\nc11:{}\nc2:{}\nc3:{}\nc33:{}\nc333:{}\n".format(c0,c1,c11,c2,c3,c33,c333))
	>>>c0:85
		c1:[[60 64 80 75 80 92 90]
 			[80 82 91 88 83 86 80]]
		c11:[[60 64 80 75 80 92 90]
 			[80 82 91 88 83 86 80]]
		c2:[[70 85]
 			[60 64]
 			[90 93]
 			[80 82]
 			[88 72]]
		c3:[[60 64]
 			[80 82]]
		c33:[[60 64]
 			[80 82]]
		c333:[[60 64]
 			 [80 82]]

条件筛选

使用条件表达式和关系运算符

import numpy as np
#一维数组的创建
names=np.array(['李白','苏轼','白居易','雷锋','焦裕禄'])
subjects=np.array(['Math', 'English', 'Python','Chinese','Art', 'Database', 'Physics'])
#对应二维数组的创建
scores=np.array([[70,85,77,90,82,84,89],[60,64,80,75,80,92,90], [90,93,88,87,86,90,91],[80,82,91,88,83,86,80],[88,72,78,90,91,73,80]])
#条件筛选
scores[:,subjects=='Math']
	>>> array([[70],
      		  [60],
      		  [90],
		      [80],
     		  [88]])
scores[names=='李白']
	>>>array([[70, 85, 77, 90, 82, 84, 89]])
scores[(names=='苏轼') | (names=='焦裕禄')]
	>>> array([[60, 64, 80, 75, 80, 92, 90],
       			[88, 72, 78, 90, 91, 73, 80]])
scores[(names=='雷锋')|(names=='焦裕禄')][:,(subjects=='Math') | (subjects=='Python')]
	>>> array([[80, 91],
       		  [88, 78]])

生成布尔型数组

mask=(names=='苏轼') | (names=='焦裕禄')
scores[mask]
	>>>array([[60, 64, 80, 75, 80, 92, 90],
      		 [88, 72, 78, 90, 91, 73, 80]])

创建和初始化多维数组的常用方法

np.arange(a,b)—创建一个一维数组—数组元素为从a到b-1
reshape(n,m)—将一维数组转换为指定的多维数组
np.arange(a,b).reshape(m,n)
np.zeros((m,n))—创建一个m行n列元素均为0的数组
np.ones((m,n))—创建一个m行n列元素均为1的数组

d1=np.arange(0,15)
d2=np.arange(0,15).reshape(3,5)
d3=np.zeros((2,3))
d4=np.ones((5,6))
print("{}\n{}\n{}\n{}\n".format(d1,d2,d3,d4))
	>>>[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
		[[ 0  1  2  3  4]
		 [ 5  6  7  8  9]
 		[10 11 12 13 14]]
		[[0. 0. 0.]
		 [0. 0. 0.]]
		[[1. 1. 1. 1. 1. 1.]
		 [1. 1. 1. 1. 1. 1.]
 		[1. 1. 1. 1. 1. 1.]
 		[1. 1. 1. 1. 1. 1.]
		 [1. 1. 1. 1. 1. 1.]]

思考与练习1

一维数组访问。
① 在subjects数组中选择并显示序号1、2、4门课的名称，使用负值序号选择并
显示names数组中 ‘方绮雯’。
② 选择并显示names数组从2到最后的数组元素；选择并显示subjects数组2到4
的数组元素。
③ 使用布尔条件选择并显示subjects数组中的英语和物理科目名称。
二维数组访问。
① 选择并显示scores数组的1、4行。
② 选择并显示scores数组中行号2、4同学的数学和Python成绩。
③ 选择并显示scores数组中所有同学的数学和艺术课成绩
4.选择并显示王微和刘旭阳的英语和艺术课成绩
5.生成由整数10~19组成的2×5的二维数组

import numpy as np
names = np.array(['王微', '肖良英', '方绮雯', '刘旭阳','钱易铭'])
subjects=np.array(['Math', 'English', 'Python','Chinese','Art', 'Database', 'Physics'])
scores=np.array([[70,85,77,90,82,84,89],[60,64,80,75,80,92,90], [90,93,88,87,86,90,91],[80,82,91,88,83,86,80],[88,72,78,90,91,73,80]])
scores
	>>> array([[70, 85, 77, 90, 82, 84, 89],
      		 [60, 64, 80, 75, 80, 92, 90],
       		 [90, 93, 88, 87, 86, 90, 91],
      		 [80, 82, 91, 88, 83, 86, 80],
       		 [88, 72, 78, 90, 91, 73, 80]])
#一维数组访问
subjects[[1,2,4]]
	>>> array(['English', 'Python', 'Art'], dtype='<U8')
names[-3]
	>>>'方绮雯'
names[2:]
	>>>array(['方绮雯', '刘旭阳', '钱易铭'], dtype='<U3')
subjects[2:5]
	>>>array(['Python', 'Chinese', 'Art'], dtype='<U8')
mask=(subjects=='English') | (subjects=='Physics')
subjects[mask]
	>>>array(['English', 'Physics'], dtype='<U8')
#二维数组访问
scores[[1,4],:]
	>>>array([[60, 64, 80, 75, 80, 92, 90],
       		 [88, 72, 78, 90, 91, 73, 80]])
scores[[2,4]][:,(subjects=='Math') | (subjects=='Python')]
	>>>array([[90, 88],
       		[88, 78]])
scores[:, (subjects=='Math') | (subjects=='Art')]
	>>>array([[70, 82],
       		[60, 80],
       		[90, 86],
       		[80, 83],
       		[88, 91]])
scores[(names=='王微')| (names=='刘旭阳')][:, (subjects=='English') | (subjects=='Art')]
	>>>array([[85, 82],
       		[82, 83]])
np.arange(10,20).reshape(2,5)#生成由整数10~19组成的2×5的二维数组
	>>>array([[10, 11, 12, 13, 14],
       		[15, 16, 17, 18, 19]])

多维数组运算

scores+5等同scores+np.ones((5,7))*5或scores+np.zeros((5,7))+5–数组中的每个元素加5
每行科目基础分不同，为各科目增加相应的基础分：scores+np.array([3,4,5,3,6,7,2])
修改限定数据,如：scores[names=‘王微’,subjects=‘Math’]+5

scores
	>>> array([[70, 85, 77, 90, 82, 84, 89],
       			[60, 64, 80, 75, 80, 92, 90],
       			[90, 93, 88, 87, 86, 90, 91],
       			[80, 82, 91, 88, 83, 86, 80],
       			[88, 72, 78, 90, 91, 73, 80]])

scores+5#等同于scores+np.ones((5,7))*5或scores+np.zeros((5,7))+5
	>>> array([[75, 90, 82, 95, 87, 89, 94],
       			[65, 69, 85, 80, 85, 97, 95],
       			[95, 98, 93, 92, 91, 95, 96],
      			[85, 87, 96, 93, 88, 91, 85],
      			[93, 77, 83, 95, 96, 78, 85]])

scores+np.array([3,4,5,3,6,7,2])#每行科目基础分不同，为各科目增加相应的基础分
	>>> array([[73, 89, 82, 93, 88, 91, 91],
       		  [63, 68, 85, 78, 86, 99, 92],
      		  [93, 97, 93, 90, 92, 97, 93],
       		  [83, 86, 96, 91, 89, 93, 82],
       		  [91, 76, 83, 93, 97, 80, 82]])
scores[names=='王微',subjects=='Math']+5#修改限定数据
array([75])

课后作业1

“大润发”、“沃尔玛”、“联华”和“农工商”四个超市都卖苹果、香蕉、桔子、猕猴桃和芒果5种水果。使用NumPy的ndarray实现以下功能。
a) 创建2个一维数组分别存储超市名称和水果名称；
b) 创建1个4×5的二维数组存储不同超市的水果价格，的二维数组存储不同超市的水果价格，其中价格由4到10范围内的随机数生成；
c) 选择“大润发”的苹果和“联华”的香蕉，并将价格增加1元；
d) “农工商”水果大减价，所有水果价格减少2元
e)统计四个超市苹果和芒果的销售均价
f)找出桔子价格最贵的超市名称（不是序号）

import numpy as np
supmarkets=np.array(['大润发', '沃尔玛', '联华', '农工商'])
fruits=np.array(['苹果', '香蕉', '桔子', '猕猴桃', '芒果'])
price=np.random.randint(4,11,(4,5))
price
	>>> array([[4, 8, 4, 9, 7],
       		  [8, 9, 9, 5, 4],
      		  [6, 5, 8, 4, 7],
       		  [7, 5, 5, 9, 6]])
#选择“大润发”的苹果和“联华”的香蕉，并将价格增加1元
price[(supmarkets=='大润发')|(supmarkets=='联华'),(fruits=='苹果')|(fruits=='香蕉')]+1
	>>> array([5, 6])
#“农工商”水果大减价，所有水果价格减少2元
price[supmarkets=='农工商']-2
	>>> array([[5, 3, 3, 7, 4]])
#统计四个超市苹果和芒果的销售均价
price[:,(fruits=='苹果') | (fruits=='芒果')].mean(axis=0)

#找出桔子价格最贵的超市名称（不是序号）
#argmax--求最大值的索引（注意：求出的索引为行索引）
supmarkets[price[:,fruits=='桔子'].argmax()]
#注意由于随机生成的价格数组中的元素不同，所以最终得到的桔子价格最贵的超市也就可能不同
	>>> '沃尔玛'

通用函数–均需引入numpy库

一元通用函数—一个输入数组，返回一个数组

abs、fabs—计算整数、浮点数或复数的绝对值
sqrt—计算各元素的平方根
square—计算各元素的平方
exp—计算各元素的指数
log、log10—自然对数、底数为10的log
sign—计算各元素的正负号
ceil—计算各元素的ceiling值，即大于等于该值的最小整数
floor—计算各元素的floor值，即小于等于该值的最大整数
cos、cosh、sin、sinh、tan、tanh—普通和双曲型三角函数

scores
	>>> array([[70, 85, 77, 90, 82, 84, 89],
       		   [60, 64, 80, 75, 80, 92, 90],
       		   [90, 93, 88, 87, 86, 90, 91],
      		   [80, 82, 91, 88, 83, 86, 80],
       		   [88, 72, 78, 90, 91, 73, 80]])
np.floor(scores/10)
	>>> array([[7., 8., 7., 9., 8., 8., 8.],
       		   [6., 6., 8., 7., 8., 9., 9.],
       		   [9., 9., 8., 8., 8., 9., 9.],
       		   [8., 8., 9., 8., 8., 8., 8.],
       		   [8., 7., 7., 9., 9., 7., 8.]])

二元通用函数—2个输入数组，返回一个数组

add—将数据中对应的元素相加
subtract—从第一个数组中减去第二个数组中的元素
multiply—数组元素相乘
divide—数组元素对应相除
power—对第一个数组中的元素A，根据第二个数组中的相应元素B，计算A的B次方
mod—元素级的求模运算
copysign—将第二个数组中的值的符号复制给第一个数组中的值
equal,not_equal—执行元素级的比较运算，产生布尔型数组

np.subtract(scores,3)
	>>> array([[67, 82, 74, 87, 79, 81, 86],
       		   [57, 61, 77, 72, 77, 89, 87],
       		   [87, 90, 85, 84, 83, 87, 88],
       		   [77, 79, 88, 85, 80, 83, 77],
       		   [85, 69, 75, 87, 88, 70, 77]])

聚合函数—需引入numpy库

支持在行、列或者全体数组元素上的聚集函数

sum—求和—当不加axis=0或axis=1时，代表求整个数组所有元素之和
mean—算术平均值
min、max—最小值和最大值
argmin、argmax—最小值和最大值的索引
cumsum—从索引0开始向前累加各元素
cumprod—从索引1开始向前累乘各元素

scores.sum(axis=0)#等同于np.sum(scores,axis=0)---统计不同科目的成绩总分
	>>> array([388, 396, 414, 430, 422, 425, 430])
scores[names=='王微'].mean()#等同于np.mean(scores[names=='王微'])
	>>> 82.42857142857143
scores[names=='王微'].mean(axis=1)#np.mean(scores[names=='王微'],axis=1)
	>>> array([82.42857143])
names[scores[:,subjects=='English'].argmax()]
	>>> '方绮雯'
c=np.arange(0,9).reshape(3,3)
c
	>>> array([[0, 1, 2],
       		   [3, 4, 5],
      		   [6, 7, 8]])
c.cumsum(axis=1)
	>>> array([[ 0,  1,  3],
      		   [ 3,  7, 12],
               [ 6, 13, 21]], dtype=int32)
c.cumprod(axis=1)
	>>> array([[  0,   0,   0],
       		   [  3,  12,  60],
       		   [  6,  42, 336]], dtype=int32)

随机数组生成函数—np.random模块

np.random()—随机产生[0，1)之间的浮点值
np.random()为以下函数使用前所需要调用的模块对象，不可单独用

np.random.randint(start,end,size)—随机生成给定范围内的一组整数
np.random.uniform(start,end,size)—随机生成给定范围内服从均匀分布的一组浮点数

np.random.choice(a,size=None,replace=True,p=None)在给定的序列内随机选择元素
a—为一维数组 size—组成指定大小的数组，可指定元素个数，也可指定生成m行,n列的数组，缺省则为生成一个元素
replace—是否可以取相同的数字，缺省为True p—与数组a一一对应，表示取数组a中每个元素的概率，缺省则每个概率默认相同

np.random.normal(loc,scale,size)—随机生成一组服从给定均值和方差的正态分布随机数
loc—正态分布的均值 scale—正态分布的方差

np.random.randint(10,19,5)
	>>> array([14, 15, 17, 11, 17])
np.random.uniform(10,19,2)
	>>> array([13.81561143, 13.44078392])
np.random.choice([3,6,9,11,13,15],(2,3))
	>>> array([[ 3,  9,  3],
       		   [13,  3, 13]])
np.random.choice([5,9,2,3,7,19],1)
	>>> array([7])
np.random.normal(5,6.3,(2,3))
	>>> array([[-2.05382256,  8.62472444,  5.44788843],
       		   [10.73136156, -2.6621716 , -4.06645548]])

思考与练习2

将scores数组中所有同学的英语成绩减去3分并显示。
统计scores数组中每名同学所有科目的平均分并显示。
使用随机函数生成[-1,1]之间服从均匀分布的3×4二维数组，并计算所有元素的和
4.随机生成一个5*5且元素为0到25之间的随机数的二维数组

import numpy as np
names = np.array(['王微', '肖良英', '方绮雯', '刘旭阳','钱易铭'])
subjects=np.array(['Math', 'English', 'Python','Chinese','Art', 'Database', 'Physics'])
scores=np.array([[70,85,77,90,82,84,89],[60,64,80,75,80,92,90], [90,93,88,87,86,90,91],[80,82,91,88,83,86,80],[88,72,78,90,91,73,80]])
scores
	>>> array([[70, 85, 77, 90, 82, 84, 89],
       		   [60, 64, 80, 75, 80, 92, 90],
       		   [90, 93, 88, 87, 86, 90, 91],
       		   [80, 82, 91, 88, 83, 86, 80],
       		   [88, 72, 78, 90, 91, 73, 80]])
scores[:,subjects=='English']-3
	>>> array([[82],
       		   [61],
      		   [90],
       		   [79],
       		   [69]])
scores.mean(axis=1)
	
a=np.random.uniform(-1,1,(3,4))
a
	>>> array([[-0.73668702, -0.63676295, -0.47805166,  0.76894485],
      		   [ 0.77358615,  0.2179409 , -0.47824175, -0.1142311 ],
		       [ 0.99910732, -0.07576017, -0.23266867, -0.69512014]])
a.sum()
	>>> -0.687944231976956
b=np.arange(0,25).reshape(5,5)
b
	>>> 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]])
b.sum()
	>>> 300

案例：随机游走轨迹模拟

如：花粉的布朗运动、证券的涨跌
利用numpy的随机生成函数np.random.randint(0,2,(2,steps))以及ndarray实现
初始位置：（0，0）
每一步随机地沿着x轴方向左移或右移一个单位
同时沿着y轴方向左移或右移一个单位
左移或右移的概率相等

"""
Step1:创建一个2*n的二维数组
    2行分别表示在x、y轴上的运动
    n为移动总步数，每列记录一步
    数组元素取值为-1或1
"""
steps=10#随机游走走了10步
rndwlk=np.random.randint(0,2,(2,10))
#判断rndwlk中的元素是否满足条件:大于0,若为True则将大于0的元素均改为1，反之改为-1
rndwlk=np.where(rndwlk>0,1,-1)
rndwlk
	>>> array([[ 1, -1,  1, -1, -1,  1,  1,  1,  1, -1],
       		   [-1,  1, -1, -1,  1,  1, -1, -1, -1, -1]])
"""
Step2:计算每步游走后的位置：第n步位置为前n-1步位置+第n步
        用到了累加和函数cumsum()--从0开始向前累加各元素
"""
position=rndwlk.cumsum(axis=1)
position
#注意：随机游走可视化图在第四次课介绍，此处省略
	>>> array([[ 1,  0,  1,  0, -1,  0,  1,  2,  3,  2],
       		   [-1,  0, -1, -2, -1,  0, -1, -2, -3, -4]], dtype=int32)
"""
Step3:计算每步游走后距离原点的距离
    sqrt---计算各元素的平方根
    square---计算各元素的平方
"""
dists=np.sqrt(np.square(position[0])+np.square(position[1]))
dists
	>>> array([1.41421356, 0.        , 1.41421356, 2.        , 1.41421356,0.        , 1.41421356, 2.82842712, 4.24264069, 4.47213595])
np.set_printoptions(precision=4)#设置数组元素的显示位数-小数点后四位
dists
	>>> array([1.4142, 0.    , 1.4142, 2.    , 1.4142, 0.    , 1.4142, 2.8284,4.2426, 4.4721])
dists.max()#游走的最远距离
	>>> 4.47213595499958
dists.min()#游走的最短距离
	>>> 0.0
dists.mean()#游走的平均距离
	>>> 1.9200058016357435
(dists>dists.mean()).sum()#超出平均距离的次数
	>>> 4

思考与练习3

将随机游走的步数增加到100步，计算物体距离原点的距离。
重复多次随机游走过程，物体距离原点距离的变化趋势是什么？

import numpy as np
walk=np.random.randint(0,2,(2,100))
walk
	>>> array([[1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0,
        		1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1,
        		1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0,
        		1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1,
        		1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1],
       		   [0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0,
        		0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1,
        		1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1,
        		1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
       		 	1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1]])
walk=np.where(walk>0,1,-1)
walk
	>>> array([[ 1,  1,  1,  1, -1,  1,  1,  1,  1,  1, -1, -1,  1, -1, -1,  1,
        		-1,  1, -1, -1,  1, -1,  1, -1,  1,  1,  1, -1, -1,  1,  1, -1,
         		1,  1, -1,  1, -1,  1, -1,  1,  1, -1, -1,  1,  1,  1, -1,  1,
        		-1, -1,  1, -1,  1, -1,  1,  1,  1, -1,  1,  1,  1,  1,  1, -1,
         		1, -1,  1, -1,  1,  1,  1, -1,  1,  1, -1, -1, -1,  1,  1,  1,
         		1, -1, -1,  1, -1,  1, -1,  1,  1,  1,  1,  1, -1,  1, -1,  1,
        		-1,  1,  1,  1],
       		   [-1, -1, -1,  1,  1, -1, -1, -1, -1,  1, -1,  1, -1,  1, -1, -1,
        		-1, -1,  1,  1,  1, -1, -1,  1,  1, -1, -1,  1,  1,  1,  1, -1,
         		 1,  1, -1, -1,  1, -1,  1,  1, -1, -1, -1,  1,  1,  1,  1,  1,
        		-1,  1,  1, -1,  1, -1,  1, -1,  1, -1,  1, -1, -1,  1, -1, -1,
        		 1,  1,  1, -1, -1,  1,  1, -1,  1,  1, -1, -1,  1,  1, -1, -1,
        		-1, -1,  1,  1, -1, -1, -1, -1,  1,  1, -1,  1, -1,  1,  1, -1,
        		-1, -1,  1,  1]])
pos=walk.cumsum(axis=1)
pos
	>>> array([[ 1,  2,  3,  4,  3,  4,  5,  6,  7,  8,  7,  6,  7,  6,  5,  6,
         		5,  6,  5,  4,  5,  4,  5,  4,  5,  6,  7,  6,  5,  6,  7,  6,
         		7,  8,  7,  8,  7,  8,  7,  8,  9,  8,  7,  8,  9, 10,  9, 10,
        	 	9,  8,  9,  8,  9,  8,  9, 10, 11, 10, 11, 12, 13, 14, 15, 14,
        		15, 14, 15, 14, 15, 16, 17, 16, 17, 18, 17, 16, 15, 16, 17, 18,
        		19, 18, 17, 18, 17, 18, 17, 18, 19, 20, 21, 22, 21, 22, 21, 22,
        		21, 22, 23, 24],
       		   [-1, -2, -3, -2, -1, -2, -3, -4, -5, -4, -5, -4, -5, -4, -5, -6,
        		-7, -8, -7, -6, -5, -6, -7, -6, -5, -6, -7, -6, -5, -4, -3, -4,
        		-3, -2, -3, -4, -3, -4, -3, -2, -3, -4, -5, -4, -3, -2, -1,  0,
        		-1,  0,  1,  0,  1,  0,  1,  0,  1,  0,  1,  0, -1,  0, -1, -2,
        		-1,  0,  1,  0, -1,  0,  1,  0,  1,  2,  1,  0,  1,  2,  1,  0,
        		-1, -2, -1,  0, -1, -2, -3, -4, -3, -2, -3, -2, -3, -2, -1, -2,
        		-3, -4, -3, -2]], dtype=int32)
dist=np.sqrt(np.square(pos[0])+np.square(pos[1]))
dist
#观察发现，物体距离原点的距离会愈来愈远
	>>> array([ 1.4142,  2.8284,  4.2426,  4.4721,  3.1623,  4.4721,  5.831 ,
        		7.2111,  8.6023,  8.9443,  8.6023,  7.2111,  8.6023,  7.2111,
        		7.0711,  8.4853,  8.6023, 10.    ,  8.6023,  7.2111,  7.0711,
        		7.2111,  8.6023,  7.2111,  7.0711,  8.4853,  9.8995,  8.4853,
        		7.0711,  7.2111,  7.6158,  7.2111,  7.6158,  8.2462,  7.6158,
        		8.9443,  7.6158,  8.9443,  7.6158,  8.2462,  9.4868,  8.9443,
       			8.6023,  8.9443,  9.4868, 10.198 ,  9.0554, 10.    ,  9.0554,
        		8.    ,  9.0554,  8.    ,  9.0554,  8.    ,  9.0554, 10.    ,
       			11.0454, 10.    , 11.0454, 12.    , 13.0384, 14.    , 15.0333,
       			14.1421, 15.0333, 14.    , 15.0333, 14.    , 15.0333, 16.    ,
       			17.0294, 16.    , 17.0294, 18.1108, 17.0294, 16.    , 15.0333,
       			16.1245, 17.0294, 18.    , 19.0263, 18.1108, 17.0294, 18.    ,
       			17.0294, 18.1108, 17.2627, 18.4391, 19.2354, 20.0998, 21.2132,
       			22.0907, 21.2132, 22.0907, 21.0238, 22.0907, 21.2132, 22.3607,
       			23.1948, 24.0832])

课后作业2

基于2.3节中随机游走的例子，使用ndarray和随机数生成函数模拟一个物体在三维空间随机游走的过程。
① 创建3×10的二维数组，记录物体每一步在三个轴向上的移动距离。在每个轴向的移动距离服从标准正态分布（期望均值为0，方差为1）。行序0、1、2分别对应x、y和z轴；
② 计算每一步走完后物体在三维空间的位置；
③ 计算每一步走完后物体距离原点的距离；
④ 统计物体在z轴上到达的最远距离；（提示：使用abs()绝对值函数对z轴每一步运动后的位置求绝对值，然后求最大距离）
⑤ 统计物体在三维空间距离原点的最近距离值

import numpy as np
rwlk=np.random.normal(0,1,(3,10))
rwlk
	>>> array([[-0.56073671,  1.49463372, -1.83405033,  0.22394635,  0.33410615,
         		0.54939608,  0.23184523, -0.68564836,  1.78196432, -0.76619736],
       		   [ 0.84420098, -0.7924887 ,  0.39172092,  0.15127783,  1.57640562,
        		-0.5716664 , -0.13114694,  0.90456608,  1.16634997, -0.90540438],
       		   [-2.3822079 ,  0.15890342, -0.67824285, -0.41221766,  1.37896992,
         		0.19670309, -0.0672243 ,  0.0588425 , -1.26970215,  0.34748133]])
rwlk=np.where(rwlk>0,1,-1)
rwlk
	>>> array([[-1,  1, -1,  1,  1,  1,  1, -1,  1, -1],
       		   [ 1, -1,  1,  1,  1, -1, -1,  1,  1, -1],
       		   [-1,  1, -1, -1,  1,  1, -1,  1, -1,  1]])
post=rwlk.cumsum(axis=1)
post
	>>> array([[-1,  0, -1,  0,  1,  2,  3,  2,  3,  2],
       		   [ 1,  0,  1,  2,  3,  2,  1,  2,  3,  2],
       		   [-1,  0, -1, -2, -1,  0, -1,  0, -1,  0]], dtype=int32)
dis0=np.sqrt(np.square(post[0])+np.square(post[1])+np.square(post[2]))
dis0
	>>> array([1.73205081, 0.        , 1.73205081, 2.82842712, 3.31662479,.82842712, 3.31662479, 2.82842712, 4.35889894, 2.82842712]) 
abs(post[2]).max()
	>>> 2
dis0.min()
	>>> 0.0