Python有着大量功能强大的第三方库。这些第三方库可以大大地扩充Python的功能，我们在实际使用中往往也离不开这些第三方库。
NumPy是Python的一种开源的 数值计算扩展 。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表(nested list structure)结构要高效的多。NumPy(Numeric Python)提供了许多高级的数值编程工具。Numpy的一个重要特性是它的数组计算，是我们做数据分析必不可少的一个包。
导入python库使用关键字import，后面可以自定义库的简称，但是一般都将Numpy命名为np，pandas命名为pd。
使用前一定要先导入Numpy包，导入的方法有以下几种：
import numpy
import numpy as np #推荐写法
from numpy import * #不是很建议这种写法，因为不用加前缀的话有可能会与其他函数名称起冲突，因而报错
import numpy as np
假设我们想将列表中的每个元素增加1，但列表不支持这样的操作：
a = [1,2,3,4]
# a+1 #报错
[x+1 for x in a]
[2, 3, 4, 5]
b = [2,3,4,5]
与另一个数组相加，得到对应元素相加的结果：
a+b #并不是我们想要的结果
[1, 2, 3, 4, 2, 3, 4, 5]
[x+y for(x,y) in zip(a,b)] #都需要利用到列表生成式
[3, 5, 7, 9]
这样的操作比较麻烦，而且在数据量特别大的时候会非常耗时间。
如果我们使用Numpy，就会变得特别简单
a = np.array([1,2,3,4])
a
array([1, 2, 3, 4])
a+1
array([2, 3, 4, 5])
a*2
array([2, 4, 6, 8])
b = np.array([2,3,4,5])
a + b
array([3, 5, 7, 9])
从列表产生数组：
l = [0,1,2,3]
a = np.array(l)
a
array([0, 1, 2, 3])
从列表传入：
a = np.array([1,2,3,4])
a
array([1, 2, 3, 4])
生成全0数组：
np.zeros(5) #括号内传个数，默认浮点数
array([0., 0., 0., 0., 0.])
生成全1的数组：
np.ones(5,dtype='int') #括号内传个数，默认浮点数
array([1, 1, 1, 1, 1])
np.ones(5,dtype="bool") #可以自己指定类型，np.zeros函数同理
array([ True, True, True, True, True])
可以使用 fill 方法将数组设为指定值
import numpy
a = numpy.array([1,2,3,4])
a
array([1, 2, 3, 4])
a.fill(5) #让数组中的每一个元素都等于5
a
array([5, 5, 5, 5])
与列表不同，数组中要求所有元素的 dtype 是一样的，如果传入参数的类型与数组类型不一样，需要按照已有的类型进行转换。
a.fill(2.5) #自动进行取整
a
array([2, 2, 2, 2])
a = a.astype("float") #强制类型转换
a.fill(2.5)
a
array([2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5])
还可以使用一些特定的方法生成特殊的数组
生成整数序列：
a = np.arange(1,10) #左闭右开区间，和range的使用方式同理
a#【1~10，默认步长为1】
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
生成等差数列：
a = np.linspace(1,10,21) #右边是包括在里面的，从a-b一共c个数的等差数列，其实np.arange好像也可以做...
a#【1~10总共21个等差数列】
array([ 1. , 1.45, 1.9 , 2.35, 2.8 , 3.25, 3.7 , 4.15, 4.6 ,
5.05, 5.5 , 5.95, 6.4 , 6.85, 7.3 , 7.75, 8.2 , 8.65,
9.1 , 9.55, 10. ])
生成随机数
np.random.rand(10)
array([0.88335817, 0.52082158, 0.79041143, 0.75974014, 0.46029764,
0.79041567, 0.54375634, 0.05655977, 0.68340517, 0.7925515 ])
np.random.randn(10) #标准正态分布
array([-0.65212612, -0.7637054 , -0.42912921, -0.43338831, -0.63975307,
0.45317441, -0.78020802, 1.18765512, -1.18985217, -1.20140891])
np.random.randint(1,20,10) #生成随机整数【从1-20中随机10个】
array([ 1, 1, 18, 18, 16, 4, 1, 1, 5, 15])
查看类型：
a
array([ 1. , 1.45, 1.9 , 2.35, 2.8 , 3.25, 3.7 , 4.15, 4.6 ,
5.05, 5.5 , 5.95, 6.4 , 6.85, 7.3 , 7.75, 8.2 , 8.65,
9.1 , 9.55, 10. ])
type(a)
numpy.ndarray
查看数组中的数据类型：
a.dtype
dtype('float64')
查看形状，会返回一个元组，每个元素代表这一维的元素数目：
a.shape
(21,)
或者使用：
np.shape(a)
(21,)
要看数组里面元素的个数：
a.size
21
查看数组的维度：
a.ndim
1
和列表相似，数组也支持索引和切片操作。
索引第一个元素：
a = np.array([0,1,2,3])
a[0]
0
修改第一个元素的值
a[0] = 10
a
array([10, 1, 2, 3])
`切片，支持负索引：
a = np.array([11,12,13,14,15])
a[1:3] #左闭右开，从0开始算
array([12, 13])
a[1:-2] #等价于a[1:3]
array([12, 13])
a[-4:3] #仍然等价a[1:3]
array([12, 13])
省略参数：
a[-2:] #从倒数第2个取到底
array([14, 15])
a[::2] #从头取到尾，间隔2
array([11, 13, 15])
假设我们记录一部电影的累计票房：
ob = np.array([21000,21800,22240,23450,25000])
ob
array([21000, 21800, 22240, 23450, 25000])
可以这样计算每天的票房：
ob2 = ob[1:]-ob[:-1]
ob2
array([ 800, 440, 1210, 1550])
array还可以用来生成多维数组：
a = np.array([[0,1,2,3],[10,11,12,13]])
a
array([[ 0, 1, 2, 3],
[10, 11, 12, 13]])
事实上我们传入的是一个以列表为元素的列表，最终得到一个二维数组。
查看形状：
a.shape
(2, 4)
查看总的元素个数：
a.size
8
查看维数：
a.ndim
2
对于二维数组，可以传入两个数字来索引：
a
array([[ 0, 1, 2, 3],
[10, 11, 12, 13]])
a[1,3]
13
其中，1是行索引，3是列索引，中间用逗号隔开。事实上，Python会将它们看成一个元组（1,3），然后按照顺序进行对应。
可以利用索引给它赋值：
a[1,3] = -1
a
array([[ 0, 1, 2, 3],
[10, 11, 12, -1]])
事实上，我们还可以使用单个索引来索引一整行内容：
a[1]
array([10, 11, 12, -1])
Python会将这单个元组当成对第一维的索引，然后返回对应的内容。
a[:,1]
array([ 1, 11])
多维数组，也支持切片操作：
a = np.array([[0,1,2,3,4,5],[10,11,12,13,14,15],[20,21,22,23,24,25],[30,31,32,33,34,35],[40,41,42,43,44,45],[50,51,52,53,54,55]])
a
array([[ 0, 1, 2, 3, 4, 5],
[10, 11, 12, 13, 14, 15],
[20, 21, 22, 23, 24, 25],
[30, 31, 32, 33, 34, 35],
[40, 41, 42, 43, 44, 45],
[50, 51, 52, 53, 54, 55]])
想得到第一行的第4和第5两个元素：
a[0,3:5]
array([3, 4])
得到最后两行的最后两列：
a[4:,4:]
array([[44, 45],
[54, 55]])
得到第三列：
a[:,2]
array([ 2, 12, 22, 32, 42, 52])
每一维都支持切片的规则，包括负索引，省略
[lower:upper:step]
例如，取出3,5行的奇数列：
a[2::2,::2]
array([[20, 22, 24],
[40, 42, 44]])
切片在内存中使用的是引用机制
a = np.array([0,1,2,3,4])
b = a[2:4]
print(b)
[2 3]
引用机制意味着，Python并没有为b分配新的空间来存储它的值，而是让b指向了a所分配的内存空间，因此，改变b会改变a的值：
b[0] = 10
a
array([ 0, 1, 10, 3, 4])
而这种现象在列表中并不会出现：
# a = np.array([1,2,3,4,5])
a=[1,2,3,4,5]
b = a[2:4]
b[0] = 10
print(a)
[1, 2, 3, 4, 5]
这样做的好处在于，对于很大的数组，不用大量复制多余的值，节约了空间。
缺点在于，可能出现改变一个值改变另一个值的情况。
一个解决方法是使用copy()方法产生一个复制，这个复制会申请新的内存：
a = np.array([0,1,2,3,4])
b = a[2:4].copy()
b[0] = 10
a
array([0, 1, 2, 3, 4])
切片只能支持连续或者等间隔的切片操作，要想实现任意位置的操作。需要使用花式索引 fancy slicing。
与range函数类似，我们可以使用arange函数来产生等差数组。
a = np.arange(0,100,10)#【0~100产生10个数据】
a
array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
花式索引需要指定索引位置：
index = [1,2,-3]
y = a[index]
print(y)
[10 20 70]
还可以使用布尔数组来花式索引：
mask = np.array([0,2,2,0,0,1,0,0,1,0],dtype = bool)
mask
array([False, True, True, False, False, True, False, False, True,
False])
mask必须是布尔数组，长度必须和数组长度相等。
a[mask]
array([10, 20, 50, 80])
对于二维花式索引，我们需要给定行和列的值：
a = np.array([[0,1,2,3,4,5],[10,11,12,13,14,15],[20,21,22,23,24,25],[30,31,32,33,34,35],[40,41,42,43,44,45],[50,51,52,53,54,55]])
a
array([[ 0, 1, 2, 3, 4, 5],
[10, 11, 12, 13, 14, 15],
[20, 21, 22, 23, 24, 25],
[30, 31, 32, 33, 34, 35],
[40, 41, 42, 43, 44, 45],
[50, 51, 52, 53, 54, 55]])
返回的是一条次对角线上的5个值。
a[(0,1,2,3,4),(1,2,3,4,5)]
array([ 1, 12, 23, 34, 45])
返回的是最后三行的1,3,5列。
a[3:,[0,2,4]]
array([[30, 32, 34],
[40, 42, 44],
[50, 52, 54]])
也可以使用mask进行索引：
mask = np.array([1,0,1,0,0,1],dtype = bool)
print(mask)
print(a)
a[mask,2]
[ True False True False False True]
[[ 0 1 2 3 4 5]
[10 11 12 13 14 15]
[20 21 22 23 24 25]
[30 31 32 33 34 35]
[40 41 42 43 44 45]
[50 51 52 53 54 55]]
array([ 2, 22, 52])
与切片不同，花式索引返回的是原对象的一个复制而不是引用。
只给定行索引的时候，返回整行：
y = a[:3]
y
array([[ 0, 1, 2, 3, 4, 5],
[10, 11, 12, 13, 14, 15],
[20, 21, 22, 23, 24, 25]])
这时候也可以使用花式索引取出第2,3,5行：
con = np.array([0,1,1,0,1,0],dtype = bool)
a[con]
array([[10, 11, 12, 13, 14, 15],
[20, 21, 22, 23, 24, 25],
[40, 41, 42, 43, 44, 45]])
where(array)
where函数会返回所有非零元素的索引。
先看一维的例子：
a = np.array([0,12,5,20])
a
array([ 0, 12, 5, 20])
判断数组中的元素是不是大于10：
a>10
array([False, True, False, True])
数组中所有大于10的元素的索引位置：
np.where(a>10)#【返回的是索引】
(array([1, 3], dtype=int64),)
注意到where的返回值是一个元组。返回的是索引位置，索引[1,3]大于10的数
也可以直接用数组操作。
a[a>10]
array([12, 20])
a[np.where(a>10)]
array([12, 20])
具体如下：
| 基本类型 | 可用的Numpy类型 | 备注 |
|---|---|---|
| 布尔型 | bool | 占一个字节 |
| 整型 | int8,int16,int32,int64,int128,int | int跟C语言中long一样大 |
| 无符号整型 | uint8,uint16,uint32,uint64,uint128,uint | uint跟C语言中的unsigned long一样大 |
| 浮点数 | float16,float32,float | 默认为双精度float64，longfloat精度大小与系统有关 |
| 复数 | complex64,complex128,complex,longcomplex | 默认为complex128,即实部虚部都为双精度 |
| 字符串 | string,unicode | 可以使用dtype=S4表示一个4字节字符串的数组 |
| 对象 | object | 数组中可以使用任意值 |
| 时间 | datetime64,timedelta64 |
a = np.array([1.5,-3],dtype =int)
a
array([ 1, -3])
a = np.array([1,2,3],dtype=float)#【会拷贝出一个副本】
a=np.asarray(a,dtype = int)#【不会拷贝出一个副本，不占用内存】
a
array([1, 2, 3])
astype 方法返回一个新数组：
a = np.array([1, 2, 3])
a.astype(float) #对数据类型进行转换，a本身没有变化
array([1., 2., 3.])
a #a本身并没有发生变化--拷贝
array([1, 2, 3])
##电影名称
mv_name = ["肖申克的救赎","控方证人","美丽人生","阿甘正传","霸王别姬","泰坦尼克号","辛德勒的名单","这个杀手不太冷","疯狂动物城","海豚湾"]
##评分人数
mv_num = np.array([692795,42995,327855,580897,478523,157074,306904,662552,284652,159302])
##评分
mv_score = np.array([9.6,9.5,9.5,9.4,9.4,9.4,9.4,9.3,9.3,9.3])
##电影时长（分钟）
mv_length = np.array([142,116,116,142,171,194,195,133,109,92])
np.sort(mv_num)
array([ 42995, 157074, 159302, 284652, 306904, 327855, 478523, 580897,
662552, 692795])
mv_num #sort不改变原来数组
array([692795, 42995, 327855, 580897, 478523, 157074, 306904, 662552,
284652, 159302])
argsort返回从小到大的排列在数组中的索引位置：
order = np.argsort(mv_num)#返回索引
order
array([1, 5, 9, 8, 6, 2, 4, 3, 7, 0], dtype=int64)
mv_name[order[0]]
'控方证人'
mv_name[order[-1]]
'肖申克的救赎'
np.sum(mv_num)
3693549
mv_num.sum()
3693549
np.max(mv_length)
195
mv_length.max()
195
np.min(mv_score)
9.3
mv_score.min()
9.3
np.mean(mv_length)
141.0
mv_length.mean()
141.0
np.std(mv_length)
33.713498780162226
mv_length.std()
33.713498780162226
np.cov(mv_score,mv_length)
array([[9.88888889e-03, 4.55555556e-01],
[4.55555556e-01, 1.26288889e+03]])
a = np.arange(6)
a
array([0, 1, 2, 3, 4, 5])
a.shape=(2,3)
a
array([[0, 1, 2],
[3, 4, 5]])
a.shape
(2, 3)
与之对应的方法是reshape，但它不会修改原来数组的值，而是返回一个新的数组：
a = np.arange(6)
a
array([0, 1, 2, 3, 4, 5])
a.reshape(2,3)#【不会修改原来数组的值，而是返回一个新的数组】
array([[0, 1, 2],
[3, 4, 5]])
a #没变
array([0, 1, 2, 3, 4, 5])
a = a.reshape(2,3)
a
array([[0, 1, 2],
[3, 4, 5]])
a.T#[2,3]变[3,2]
array([[0, 3],
[1, 4],
[2, 5]])
a.transpose() #只要没赋值给本身，a的数值不会变换【转置】
array([[0, 3],
[1, 4],
[2, 5]])
有时候我们需要将不同的数组按照一定的顺序连接起来：
concatenate((a0,a1,…,aN),axis = 0)
注意，这些数组要用()包括到一个元组中去。
除了给定的轴外，这些数组其他轴的长度必须是一样的。
x = np.array([[0,1,2],[10,11,12]])
y = np.array([[50,51,52],[60,61,62]])
print(x)
print(y)
[[ 0 1 2]
[10 11 12]]
[[50 51 52]
[60 61 62]]
默认沿着第一维进行连接：
z = np.concatenate((x,y))#默认axis-0是行
z
array([[ 0, 1, 2],
[10, 11, 12],
[50, 51, 52],
[60, 61, 62]])
沿着第二维进行连接：
z = np.concatenate((x,y),axis = 1)
z
array([[ 0, 1, 2, 50, 51, 52],
[10, 11, 12, 60, 61, 62]])
注意到这里x和y的形状是一样的，还可以将它们连接成三维的数组，但是concatenate不能提供这样的功能，不过可以这样：
z = np.array((x,y))
z
array([[[ 0, 1, 2],
[10, 11, 12]],
[[50, 51, 52],
[60, 61, 62]]])
事实上，Numpy提供了分别对应这三种情况的函数：
np.vstack((x,y))#垂直stack
array([[ 0, 1, 2],
[10, 11, 12],
[50, 51, 52],
[60, 61, 62]])
np.dstack((x,y))#深度stack【即三维】
array([[[ 0, 50],
[ 1, 51],
[ 2, 52]],
[[10, 60],
[11, 61],
[12, 62]]])
np.hstack((x,y))#水平stack
array([[ 0, 1, 2, 50, 51, 52],
[10, 11, 12, 60, 61, 62]])
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-40K6StAd-1669869072386)(attachment:image.png)]
a = np.array([-1,2,3,-2])
np.abs(a) #绝对值
array([1, 2, 3, 2])
np.exp(a) #指数
array([ 0.36787944, 7.3890561 , 20.08553692, 0.13533528])
np.median(a) #中值
0.5
np.cumsum(a) #累积和
array([-1, 1, 4, 2], dtype=int32)
numpy的内置函数非常多，不需要死记，懂得查资料。
https://blog.csdn.net/nihaoxiaocui/article/details/51992860?locationNum=5&fps=1
课上只讲了一些常见的，其余感兴趣的同学可以自行学习。
| 调用方法 | 作用 |
|---|---|
| 1 | 基本属性 |
| a.dtype | 数组元素类型float32,uint8,… |
| a.shape | 数组形状(m,n,o,…) |
| a.size | 数组元素数 |
| a.itemsize | 每个元素占字节数 |
| a.nbytes | 所有元素占的字节 |
| a.ndim | 数组维度 |
| - | - |
| 2 | 形状相关 |
| a.flat | 所有元素的迭代器 |
| a.flatten() | 返回一个1维数组的复制 |
| a.ravel() | 返回一个一维数组，高效 |
| a.resize(new_size) | 改变形状 |
| a.swapaxes(axis1,axis2) | 交换两个维度的位置 |
| a.transpose(* axex) | 交换所有维度的位置 |
| a.T | 转置，a.transpose() |
| a.squeeze() | 去除所有长度为1的维度 |
| - | - |
| 3 | 填充复制 |
| a.copy() | 返回数组的一个复制 |
| a.fill(value) | 将数组的元组设置为特定值 |
| - | - |
| 4 | 转化 |
| a.tolist() | 将数组转化为列表 |
| a.tostring() | 转换为字符串 |
| a.astype(dtype) | 转换为指定类型 |
| a.byteswap(False) | 转换大小字节序 |
| a.view(type_or_dtype) | 生成一个使用相同内存，但使用不同的表示方法的数组 |
| - | - |
| 5 | 查找排序 |
| a.nonzero() | 返回所有非零元素的索引 |
| a.sort(axis=-1) | 沿某个轴排序 |
| a.argsort(axis=-1) | 沿某个轴，返回按排序的索引 |
| a.searchsorted(b) | 返回将b中元素插入a后能保持有序的索引值 |
| - | - |
| 6 | 元素数学操作 |
| a.clip(low,high) | 将数值限制在一定范围内 |
| a.round(decimals=0) | 近似到指定精度 |
| a.cumsum(axis=None) | 累加和 |
| a.cumprod(axis=None) | 累乘积 |
| - | - |
| 7 | 约简操作 |
| a.sum(axis=None) | 求和 |
| a.prod(axis=None) | 求积 |
| a.min(axis=None) | 最小值 |
| a.max(axis=None) | 最大值 |
| a.argmin(axis=None) | 最小值索引 |
| a.argmax(axis=None) | 最大值索引 |
| a.ptp(axis=None) | 最大值减最小值 |
| a.mean(axis=None) | 平均值 |
| a.std(axis=None) | 标准差 |
| a.var(axis=None) | 方差 |
| a.any(axis=None) | 只要有一个不为0，返回真，逻辑或 |
| a.all(axis=None) | 所有都不为0，返回真，逻辑与 |
（1）创建一个1到10的数组，然后逆序输出。
import numpy as np
a=np.arange(1,10)
print(a[::-1])
[9 8 7 6 5 4 3 2 1]
（2）创建一个长度为20的全1数组，然后变成一个4×5的二维矩阵并转置。
a=np.ones(20,dtype=int)
a.reshape(4,5).T
array([[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]])
（3）创建一个3x3x3的随机数组。
(提示: np.random.random)
a=np.random.randn(3,3,3)#正态分布
a
array([[[-0.73794688, 0.03351403, -0.72589921],
[ 1.78320661, -0.12607157, 0.06287872],
[-0.26050027, 1.09681543, -1.05399901]],
[[ 2.37191982, 0.1728504 , -1.26655155],
[ 0.04459952, -0.0329599 , 0.85234042],
[ 0.47042474, -0.32523892, 1.4550982 ]],
[[-1.64982444, 0.81207111, 1.19691199],
[-1.24738232, -1.26853671, 0.4317295 ],
[-0.89574131, -1.46853724, -0.74911263]]])
（4）从1到10中随机选取10个数，构成一个长度为10的数组，并将其排序。获取其最大值最小值，求和，求方差。
a=np.random.randint(1,11,10)
a.sort()
print(a,'\n',max(a),'\n',min(a),'\n',sum(a),'\n',a.var())
[1 1 2 2 4 5 6 6 9 9]
9
1
45
8.25
（5）从1到10中随机选取10个数，构成一个长度为10的数组，选出其中的奇数。
a=np.random.randint(1,11,10)
[x for x in a if x & 1]
[5, 3, 7, 5, 1, 7, 9]
（6）生成0到100，差为5的一个等差数列，然后将数据类型转化为整数。
a=np.linspace(0,100,20,dtype=int)#linspace(x1,x2,n) 生成 n 个点。这些点的间距为 (x2-x1)/(n-1)。
a
array([ 0, 5, 10, 15, 21, 26, 31, 36, 42, 47, 52, 57, 63,
68, 73, 78, 84, 89, 94, 100])
（7）从1到10中随机选取10个数，大于3和小于8的取负数。
a=np.random.randint(1,10,10)
print(a)
[-x for x in a if x>3 & x<8]
[8 9 3 6 2 8 7 1 9 4]
[-8, -9, -6, -8, -7, -9, -4]
（8）在数组[1, 2, 3, 4, 5]中相邻两个数字中间插入1个0。
a=np.array([1, 2, 3, 4, 5])
b=np.zeros(10,dtype=int)
b[::2]=a#每隔两个空，将a的值赋给b
b
array([1, 0, 2, 0, 3, 0, 4, 0, 5, 0])
（9）新建一个5乘5的随机二位数组，交换其中两行？比如交换第一二行。
a=np.random.randint(1,10,(5,5))
print(a)
a=a[[1,0,2,3,4]]#行序号分别为1 0 2 3 4
a
[[9 8 2 6 8]
[4 3 2 2 7]
[5 3 2 8 5]
[4 4 9 1 3]
[6 3 5 1 8]]
array([[4, 3, 2, 2, 7],
[9, 8, 2, 6, 8],
[5, 3, 2, 8, 5],
[4, 4, 9, 1, 3],
[6, 3, 5, 1, 8]])
（10）把一个10*2的随机生成的笛卡尔坐标转换成极坐标。
a=np.random.randint(1,10,(10,2))
print(a)
x=a[:,0]
y=a[:,1]
r=np.sqrt(x*x+y*y)
R=np.arctan(y/x)
t=()
for i in range(len(r)):
print("({},{})".format(r[i],R[i]))
[[4 8]
[2 1]
[8 1]
[7 4]
[1 8]
[5 6]
[5 6]
[5 5]
[6 6]
[1 2]]
(8.94427190999916,1.1071487177940904)
(2.23606797749979,0.4636476090008061)
(8.06225774829855,0.12435499454676144)
(8.06225774829855,0.5191461142465229)
(8.06225774829855,1.446441332248135)
(7.810249675906654,0.8760580505981934)
(7.810249675906654,0.8760580505981934)
(7.0710678118654755,0.7853981633974483)
(8.48528137423857,0.7853981633974483)
(2.23606797749979,1.1071487177940904)
（11）创建一个长度为10并且除了第五个值为1其余的值为2的向量。
a=np.ones(10,dtype=int)*2
a[4]=1
a
array([2, 2, 2, 2, 1, 2, 2, 2, 2, 2])
（12）创建一个长度为10的随机向量，并求其累计和。
a=np.random.randint(1,10,10)
print(a)
a.cumsum()#累加和
[2 3 4 5 8 4 3 4 3 6]
array([ 2, 5, 9, 14, 22, 26, 29, 33, 36, 42], dtype=int32)
（13）将数组中的所有奇数替换成-1。
a=np.random.randint(1,11,10)
print(a)
a[a & 1==1]=-1
print(a)
[10 8 7 6 10 3 4 2 5 7]
[10 8 -1 6 10 -1 4 2 -1 -1]
（14）构造两个4乘3的二维数组，按照3种方法进行连接？
a=np.random.randint(1,10,(4,3))
b=np.random.randint(1,10,(4,3))
print('a=',a)
print('b=',b)
print(np.vstack((a,b)))
print(np.hstack((a,b)))
print(np.dstack((a,b)))
a= [[4 7 6]
[1 5 6]
[5 9 1]
[6 4 2]]
b= [[1 6 2]
[8 9 4]
[8 8 9]
[3 9 5]]
[[4 7 6]
[1 5 6]
[5 9 1]
[6 4 2]
[1 6 2]
[8 9 4]
[8 8 9]
[3 9 5]]
[[4 7 6 1 6 2]
[1 5 6 8 9 4]
[5 9 1 8 8 9]
[6 4 2 3 9 5]]
[[[4 1]
[7 6]
[6 2]]
[[1 8]
[5 9]
[6 4]]
[[5 8]
[9 8]
[1 9]]
[[6 3]
[4 9]
[2 5]]]
（15）获取数组 a 和 b 中的共同项（索引位置相同，值也相同）。
a = np.array([1,2,3,2,3,4,3,4,5,6])，b = np.array([7,2,10,2,7,4,9,4,9,8])
a = np.array([1,2,3,2,3,4,3,4,5,6])
b = np.array([7,2,10,2,7,4,9,4,9,8])
c=a-b
print(c)
b[c==0]#花式索引
[-6 0 -7 0 -4 0 -6 0 -4 -2]
array([2, 2, 4, 4])
（16）从数组 a 中提取 5 和 10 之间的所有项。a=np.array([7,2,10,2,7,4,9,4,9,8])
a=np.array([7,2,10,2,7,4,9,4,9,8])
print(a[5:11])#索引
print(a[(a>=5)&(a<=10)])#数值
[4 9 4 9 8]
[ 7 10 7 9 9 8]