Numpy知识图谱
一、介绍
Numpy —— Python开源的科学计算工具包
高级的数值编程工具，是许多高级工具的构建基础，比如Pandas(重点针对二维数组)
- 强大的N维数组对象：ndarray(二维，三维)
- 对数组结构数据进行矩阵运算(不用遍历循环)
- 随机数、线性代数、傅立叶变换等功能
二、Numpy基础数据结构
Numpy数组是一个多维数组对象，称为ndarray，由两部分组成：
①实际的数据
②描述这些数据的元数据
| 方法 | 作用 |
|---|---|
| ar | 输出数组，注意数组的格式：中括号，元素之间没有逗号。交互方式下输出，会有array(数组) |
| ar.ndim | 输出数组维度的个数(轴数/维度/秩)，维度的数量也称rank |
| ar.shape | 数组的维度，对于n行m列的数组，shape为(n,m) |
| ar.size | 数组的元素总数，对于n行m列的数组，元素总数为n*m |
| type(ar) | 函数，查看变量的类型： |
| ar.dtype | 方法，查看数值的类型：int64 |
| ar.itemsize | 数组中每个元素的字节大小,int32类型字节为4,float64的字节为8 |
| ar.data | 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性 |
import numpy as np
# 一维数组
ar = np.array([1, 2, 3, 4, 5, 6])
print([1, 2, 3, 4, 5, 6]) # [1, 2, 3, 4, 5, 6]
print(ar) # [1 2 3 4 5 6] 数组是没有逗号的
print(ar.ndim) # 看数据有多少个轴，这里是一维数组 1
print(ar.dtype) # int64
print(ar.shape) # (6,)
print(ar.size) # 6
print(type(ar), ar.dtype) # int64
print(ar.itemsize) # 8
print(ar.data) #
---------------------------------------------------------
# 二维数组
ar1 = np.array([[1, 2, 3, 4, 5, 6], [2, 3, 4, 5, 6, 7]])
print(ar1) # [[1 2 3 4 5 6]
# [2 3 4 5 6 7]]
print(ar1.ndim) # 二维数组 2
print(type(ar1), ar1.dtype) # int64
print(ar1.shape) # (2, 6)
print(ar1.size) # 12
print(ar1.itemsize) # 8
print(ar1.data) #
---------------------------------------------------------
# 三维数组(两个二维数组)
ar2 = np.array([[[1, 2, 3, 4, 5, 6], [2, 3, 4, 5, 6, 7], [3, 4, 5, 6, 7, 8]],
[[1, 2, 3, 4, 5, 6], [2, 3, 4, 5, 6, 7], [3, 4, 5, 6, 7, 8]]])
print(ar2) # 生成两个二维数组，就是三维数组
# [[[1 2 3 4 5 6]
# [2 3 4 5 6 7]
# [3 4 5 6 7 8]]
# [[1 2 3 4 5 6]
# [2 3 4 5 6 7]
# [3 4 5 6 7 8]]]
print(ar2.ndim) # 三维数组 3
print(type(ar2), ar2.dtype) # int64
print(ar2.shape) # (2, 3, 6)
print(ar2.size) # 36
print(ar2.itemsize) # 8
print(ar2.data) #
三、数组的创建
1、array()函数，括号内可以是列表、元组、数组、生成器等。
| 方法 | 作用 |
|---|---|
| np.arry(列表、元组、数组、生成器) | 如：np.array(range(10)) ，如果有两个嵌套序列，长度不一样就会变成一维数组 |
| np.arange(5,12,2) | 类似range() 返回5-11的数，步长为2 |
import numpy as np
ar = np.array(range(10))
print(ar) # [0 1 2 3 4 5 6 7 8 9]
print(ar.shape) # (10,)
ar1 = np.arange(10)
print(ar1) # [0 1 2 3 4 5 6 7 8 9]
print(ar1.shape) # (10,)
ar2 = np.array([1, 2, 3, 4, 5, 6])
print(ar2) # [1 2 3 4 5 6]
print(ar2.shape) # (6,)
ar3 = np.array([[1, 2, 3, 4, 5, 6],[1, 2, 3, 4, 5, 6]])
print(ar3) # [[1 2 3 4 5 6]
# [1 2 3 4 5 6]]
print(ar3.shape) # (2, 6)
# 包含字母的话，会将数字也转化为字符串
ar4 = np.array([[1, 2, 3, 4, 5, 6],['a','b','c','d','e','f']])
print(ar4) # [['1' '2' '3' '4' '5' '6']
# ['a' 'b' 'c' 'd' 'e' 'f']]
print(ar4.shape) # (2, 6)
# 两个嵌套序列，长度不一样就会变成一维数组
ar5 = np.array([[1, 2, 3, 4, 5],['a','b','c','d','e','f']])
print(ar5) # [list([1, 2, 3, 4, 5]) list(['a', 'b', 'c', 'd', 'e', 'f'])]
print(ar5.ndim) # 1
# 先得到值，再变成形状
print(np.random.rand(10).reshape(2,5)) # [[0.01606221 0.48034613 0.78372017 0.45386013 0.96975338]
# [0.85711056 0.67823132 0.89495505 0.00421232 0.85041392]]
2、arange()，类似range()，在给定间隔内返回均匀间隔的值。
print(np.arange(10)) # 返回整型0-9 [0 1 2 3 4 5 6 7 8 9]
print(np.arange(10.0)) # 返回浮点型0.0-9.0 [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
print(np.arange(5,12)) # 返回5-11 [ 5 6 7 8 9 10 11]
print(np.arange(5.0,12,2)) # 返回5.0-12.0，步长为2 [ 5. 7. 9. 11.]
print(np.arange(10000)) # 如果数组太大而无法打印，Numpy会自动跳过数组的中心部分，并只打印边角 [ 0 1 2 ... 9997 9998 9999]
3、linspace()：返回在间隔[开始,停止]上计算num个均匀间隔的样本
| np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None) 如np.linspace(10, 20, 11) |
|---|
| 方法 | 作用 |
|---|---|
| start，stop | 起始值，结束值 |
| num | 生成样本数，默认为50 |
| endpoint | 默认值为True，即包含最后一个值，endpoint=False指不包含最后一个值 |
| retstep | 默认值为False，即步长不显示出来，如果retstep=True就会返回样本的步长(间距)。返回(样本，步骤)，其中步长是样本之间的间距—>输出为一个包含2个元素的元组，第一个元素为array，第二个为步长实际值 |
import numpy as np
# 10/19=0.52631579
print(np.linspace(10, 20, num=20))
# 输出>>>：[10. 10.52631579 11.05263158 11.57894737 12.10526316 12.63157895
# 13.15789474 13.68421053 14.21052632 14.73684211 15.26315789 15.78947368
# 16.31578947 16.84210526 17.36842105 17.89473684 18.42105263 18.94736842
# 19.47368421 20. ]
# 10/20=0.5
print(np.linspace(10, 20, num=21))
# 输出>>>：[10. 10.5 11. 11.5 12. 12.5 13. 13.5 14. 14.5 15. 15.5 16. 16.5
# 17. 17.5 18. 18.5 19. 19.5 20. ]
print(np.linspace(10, 20, num=21, endpoint=False)) #endpoint表示是否包含最后一个值，默认为True
# 输出>>>: [10. 10.47619048 10.95238095 11.42857143 11.9047619 12.38095238
# 12.85714286 13.33333333 13.80952381 14.28571429 14.76190476 15.23809524
# 15.71428571 16.19047619 16.66666667 17.14285714 17.61904762 18.0952381
# 18.57142857 19.04761905 19.52380952]
print(np.linspace(10, 20, num=21, retstep=True)) # 默认为False，如果为True，则输出元组和步长；如果为False,则不显示步长
# 输出>>>：retstep=False
# [10. 10.5 11. 11.5 12. 12.5 13. 13.5 14. 14.5 15. 15.5 16. 16.5
# 17. 17.5 18. 18.5 19. 19.5 20. ]
# 输出>>>：retstep=True
# (array([10. , 10.5, 11. , 11.5, 12. , 12.5, 13. , 13.5, 14. , 14.5, 15. ,
# 15.5, 16. , 16.5, 17. , 17.5, 18. , 18.5, 19. , 19.5, 20. ]), 0.5)
4、zeros() | zeros_like() | ones() | ones_like()：自动填充的0，1数组
| np.zeros（(3, 5), dtype=np.int ）、np.ones_like(ar) |
|---|
| 方法 | 作用 |
|---|---|
| np.zeros(shape,dtype=int,order='C') | 返回指定维度和类型的数组，用0填充 |
| shape | 数组维度，二维以上需要用()，且输入参数为整数 |
| dtype | 数据类型，默认numpy.float64 |
| order | 表示是否以行为主存储多维数据(C-style)或以列为主存储column-major (Fortran-style)顺序输入，默认为C，还有F |
import numpy as np
print(np.zeros(10)) # 第一个是参数 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
print(np.zeros((2, 5)))
# >>>输出：[[0. 0. 0. 0. 0.]
# [0. 0. 0. 0. 0.]]
print(np.zeros((3, 5)))
# >>>输出：[[0. 0. 0. 0. 0.]
# [0. 0. 0. 0. 0.]
# [0. 0. 0. 0. 0.]]
print(np.zeros((2, 7),dtype=np.int)) # 浮点数转化为整数
# >>>输出：[[0 0 0 0 0 0 0]
# [0 0 0 0 0 0 0]]
ar = np.array([list(range(10)),list(range(10,20))])
print(ar)
# >>>输出：[[ 0 1 2 3 4 5 6 7 8 9]
# [10 11 12 13 14 15 16 17 18 19]]
print(np.zeros_like(ar)) # 用0填充一个像ar形式的数组
# >>>输出：[[0 0 0 0 0 0 0 0 0 0]
# [0 0 0 0 0 0 0 0 0 0]]
# 用1填充
print(np.ones(9)) # [1. 1. 1. 1. 1. 1. 1. 1. 1.]
print(np.ones((2,3,4))) # 2个3行4列的二维数组
# >>>输出：[[[1. 1. 1. 1.]
# [1. 1. 1. 1.]
# [1. 1. 1. 1.]]
#
# [[1. 1. 1. 1.]
# [1. 1. 1. 1.]
# [1. 1. 1. 1.]]]
print(np.ones_like(ar))
# >>>输出：[[1 1 1 1 1 1 1 1 1 1]
# [1 1 1 1 1 1 1 1 1 1]]
5、eye()：创建一个正方的N*N的单位矩阵，对角线值为1，其余为0
print(np.eye(5))
# >>>输出：[[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.]]
ndarray的数据类型
| 数据类型 | 解释 |
|---|---|
| bool | 用一个字节存储的布尔类型(True或False) |
| inti | 由所在平台决定其大小的整数(一般为int32或int64) |
| int8 | 一个字节大小，-128～127 |
| int16 | 整数，-32768～32767 |
| int32 | 整数，-231~232-1 |
| int64 | 整数，-263~263-1 |
| uint8 | 无符号整数，0～255 |
| uint16 | 无符号整数，0～65535 |
| uint32 | 无符号整数，0～232-1 |
| uint64 | 无符号整数，0～264-1 |
| float16 | 半精度浮点数：16位，正负号1位，指数5位，精度10位 |
| float32 | 单精度浮点数：32位，正负号1位，指数8位，精度23位 |
| float64或float | 双精度浮点数：64位，正负号1位，指数11位，精度52位 |
| complex64 | 复数，分别用两个32位浮点数表示实部和虚部 |
| complex128或complex | 复数，分别用两个64位浮点数表示实部和虚部 |
练习：
import numpy as np
"""1、分别按照要求，生成一个一维数组、二维数组，并且查看其shape"""
# 一维
print(np.array((1, 2, 'a', 'hello', [1, 2, 3], {'two': 200, 'one': 100})))
# >>>输出：[1 2 'a' 'hello' list([1, 2, 3]) {'two': 200, 'one': 100}]
print(np.array((1, 2, 'a', 'hello', [1, 2, 3], {'two': 200, 'one': 100})).shape) # (6,)
# 二维
print(np.array(([0, 1, 2, 3, 4, 5], ['a', 'b', 'c', 'd', 'e', 'f'], ['True', 'False', 'True', 'False', 'True', 'True'])))
# >>>输出：[['0' '1' '2' '3' '4' '5']
# ['a' 'b' 'c' 'd' 'e' 'f']
# ['True' 'False' 'True' 'False' 'True' 'True']]
print(np.array(([0, 1, 2, 3, 4, 5], ['a', 'b', 'c', 'd', 'e', 'f'],['True', 'False', 'True', 'False', 'True', 'True'])).shape) # (3, 6)
# 三维(两个二维)
print(np.array(([[[0, 1, 2, 3, 4, 5],[0, 1, 2, 3, 4, 5]],[['a', 'b', 'c', 'd', 'e', 'f'],['True', 'False', 'True', 'False', 'True', 'True']]])))
# >>>输出：[[['0' '1' '2' '3' '4' '5']
# ['0' '1' '2' '3' '4' '5']]
# [['a' 'b' 'c' 'd' 'e' 'f']
# ['True' 'False' 'True' 'False' 'True' 'True']]]
print(np.array(([[[0, 1, 2, 3, 4, 5],[0, 1, 2, 3, 4, 5]],[['a', 'b', 'c', 'd', 'e', 'f'],['True', 'False', 'True', 'False', 'True', 'True']]])).shape) # (2, 2, 6)
"""2、生成以一个一维数组，起始值为5，终点值为15，样本数为10"""
print(np.arange(5,15)) # [ 5 6 7 8 9 10 11 12 13 14]
"""3、按照要求创建以下数组"""
print(np.zeros((4,4)))
# >>>输出：[[0. 0. 0. 0.]
# [0. 0. 0. 0.]
# [0. 0. 0. 0.]
# [0. 0. 0. 0.]]
print(np.ones((2,3)))
# >>>输出：[[1. 1. 1.]
# [1. 1. 1.]]
print(np.eye((3),dtype=int))
# >>>输出：[[1 0 0]
# [0 1 0]
# [0 0 1]]
四、Numpy通用函数
1、数组形状：.T/.reshape()/.resize()
注意：.T/.reshape()/.resize()都是生成新的数组
| 方法 | 解释 |
|---|---|
| ar.T | 转置，例如原shape为(3,4)/(2,3,4)，转置结果为(4,3)/(4,3,2)，一维数组转置后结果不变 |
| ar.reshape(2,5) | 直接将已有数组改变形状，比如np.zero(2,3).reshape(3,4)生成数组后直接改变形状 |
| re.reshape(np.arange(12),(3,4)) | 参数内添加数组，目标形状 |
| np.resize(np.arange(5),(3,4)) | 数组提供新形状，而不更改其数据，所以元素数量需要一致 |
import numpy as np
ar1 = np.arange(10)
print(ar1) # [0 1 2 3 4 5 6 7 8 9]
print(ar1.T) # 转置 [0 1 2 3 4 5 6 7 8 9]
print(ar1.reshape(5,2))
# >>>输出：[[0 1]
# [2 3]
# [4 5]
# [6 7]
# [8 9]]
ar3 = np.arange(16) # 元素要相同
print(ar3.reshape(4,4))
# >>>输出：[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]
# [12 13 14 15]]
print(ar3.reshape(2,8))
# >>>输出：[[ 0 1 2 3 4 5 6 7]
# [ 8 9 10 11 12 13 14 15]]
ar2 = np.zeros((2,5))
print(ar2)
# >>>输出：[[0. 0. 0. 0. 0.]
# [0. 0. 0. 0. 0.]]
print(ar2.T)
# >>>输出：[[0. 0.]
# [0. 0.]
# [0. 0.]
# [0. 0.]
# [0. 0.]]
print(ar2.reshape(5,2))
# >>>输出：[[0. 0.]
# [0. 0.]
# [0. 0.]
# [0. 0.]
# [0. 0.]]
print(np.ones((10,10)).reshape(5,20))
# >>>输出：[[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.]]
print(np.reshape(np.arange(16),(2,8)))
# >>>输出：[[ 0 1 2 3 4 5 6 7]
# [ 8 9 10 11 12 13 14 15]]
print(np.resize(np.arange(5),(3,4))) # 如果数值不够，会默认排序
# >>>输出：[[0 1 2 3]
# [4 0 1 2]
# [3 4 0 1]]
print(np.resize(np.arange(12),(3,4))) # 如果数值多了，依次做迭代
# >>>输出：[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
print(np.resize(np.arange(14),(3,4)))
# >>>输出：[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
2、数组的复制 (赋值=，copy())
赋值：修改ar1中的值，ar2也会改变，他们指向的是同一个数值。——浅拷贝
copy()：先ar1.copy()，再去修改，就不会改变ar2，copy方法重新开辟一块内存空间，将数组和数据完整拷贝。——深拷贝
import numpy as np
ar1 = np.arange(10)
ar2 = ar1
print(ar1 is ar2) # True
ar1[2] = 100 # 属于浅拷贝
print(ar1, ar2) # [ 0 1 100 3 4 5 6 7 8 9] [ 0 1 100 3 4 5 6 7 8 9]
ar3 = ar1.copy() # 属于深拷贝
ar1[3] = 1000
print(ar1, ar3) # [ 0 1 100 1000 4 5 6 7 8 9] [ 0 1 100 3 4 5 6 7 8 9]
s = np.arange(10)
print(np.resize(s,(2,6)))
# >>>输出：[[0 1 2 3 4 5]
# [6 7 8 9 0 1]]
print(s.resize(2,6)) # None
print(s) # 更改了数据本身
# >>>输出：[[0 1 2 3 4 5]
# [6 7 8 9 0 0]]
3、数组类型的转换：.astype()
ar1.astype(np.int64)
import numpy as np
ar1 = np.arange(10, dtype=float)
ar2 = ar1.astype(np.int64)
print(ar1, ar1.dtype) # [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] float64
print(ar2, ar2.dtype) # [0 1 2 3 4 5 6 7 8 9] int64
4、数组堆叠
| 方法 | 解释 |
|---|---|
| np.hstack((数组1，数组2)) | 水平堆叠数组，括号内的如果是一维数组形状可以不一样，二维数组形状要一致(水平堆叠，堆着堆着缺位了就不行) |
| np.vstack((a,b)) | 垂直堆叠数组 |
| np.stack((a,b),axis=1) | axis默认为0(可不写)，即按照垂直堆叠，注意跟vstack的区别，axis=1即按照横向堆叠 |
import numpy as np
a = np.arange(5)
b = np.arange(5, 9)
print(a) # [0 1 2 3 4]
print(b) # [5 6 7 8]
print(np.hstack((a, b))) # 横向连接 [0 1 2 3 4 5 6 7 8]
a = np.array([[1], [2], [3]])
b = np.array([['a'], ['b'],['c']])
print(a)
print(b)
print(np.hstack((a,b)))
# >>>输出：[['1' 'a']
# ['2' 'b']
# ['3' 'c']]
# ⚠️如果是垂直的，队列数组的列的数量要一致
print(np.vstack((a,b))) # 竖向连接
# >>>输出：[['1']
# ['2']
# ['3']
# ['a']
# ['b']
# ['c']]
a = np.arange(5)
b = np.arange(5,10)
print(np.stack((a,b),axis=1)) # 默认为0，按照行连接，ax-s=1按照列进行连接
# >>>输出：[[0 5]
# [1 6]
# [2 7]
# [3 8]
# [4 9]]
print(np.stack((a,b))) # 默认为0，按照行连接，ax-s=1按照列进行连接
# >>>输出：[[0 1 2 3 4]
# [5 6 7 8 9]]
5、数组拆分
| 方法 | 解释 |
|---|---|
| np.hsplit(ar,n) | 垂直拆分 |
| np.vsplit(ar,n) | 水平拆分 |
import numpy as np
ar = np.arange(16).reshape(4,4)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]
# [12 13 14 15]]
print(np.hsplit(ar,2)) # 横向拆分成列表
# >>>输出：[array([[ 0, 1],
# [ 4, 5],
# [ 8, 9],
# [12, 13]]), array([[ 2, 3],
# [ 6, 7],
# [10, 11],
# [14, 15]])]
print(np.hsplit(ar,2)[0])
# >>>输出：[[ 0 1]
# [ 4 5]
# [ 8 9]
# [12 13]]
print(np.vsplit(ar,2)) # 竖向拆分成两个列表
# >>>输出：[array([[0, 1, 2, 3],
# [4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
# [12, 13, 14, 15]])]
print(np.vsplit(ar,4)) # [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]]), array([[12, 13, 14, 15]])]
6、数组的简单运算
| 方法 | 解释 |
|---|---|
| + | 加法 |
| - | 减法 |
| * | 乘法 |
| / | 除法 |
| ** | 求幂 |
| mean() | 平均值 |
| min() | 最小值 |
| max() | 最大值 |
| std() | 标准差 |
| var() | 方差 |
| sum() | 求和np.sum()——>axis=0按列求和，axis=1按行求和 |
| sort() | 排序 |
ar = np.arange(6).reshape(2,3)
print(ar+10) # 加法
# >>>输出：[[10 11 12]
# [13 14 15]]
print(ar*2) # 乘法
# >>>输出：[[ 0 2 4]
# [ 6 8 10]]
print(1/(ar+1)) # 除法
# >>>输出：[[1. 0.5 0.33333333]
# [0.25 0.2 0.16666667]]
print(ar**0.5) # 幂运算
# >>>输出：[[0. 1. 1.41421356]
# [1.73205081 2. 2.23606798]]
print(ar.mean()) # 求平均值 2.5
print(ar.max()) # 求最大值 5
print(ar.min()) # 求最小值 0
print(ar.std()) # 求标准差 1.707825127659933
print(ar.var()) # 求方差 2.9166666666666665
print(ar.sum(),np.sum(ar,axis=0)) # 求和，np.sum() -> axis为0，按列求和：axis为1，按行求和 15 [3 5 7]
print(np.sort(np.array([1,4,3,2,5,6]))) # 排序 [1 2 3 4 5 6]
练习：
import numpy as np
"""1、创建一个20个元素的数组，分别改变成两个形状:(4,5),(5,6) (提示：超出范围用resize)"""
print(np.arange(20).reshape(4, 5))
# >>>输出：[[ 0 1 2 3 4]
# [ 5 6 7 8 9]
# [10 11 12 13 14]
# [15 16 17 18 19]]
a = np.arange(20) # 直接写会变成None，因为数据本身被改变了
print(np.resize(a,(5,6)))
# >>>输出：[[ 0 1 2 3 4 5]
# [ 6 7 8 9 10 11]
# [12 13 14 15 16 17]
# [18 19 0 1 2 3]
# [ 4 5 6 7 8 9]]
"""2、创建一个(4,4)的数组，把其元素类型改为字符串型"""
a = np.arange(16).reshape(4,4)
print(a.astype(np.str)) # dtype是查看数据类型，astype是转换
# >>>输出：[['0' '1' '2' '3']
# ['4' '5' '6' '7']
# ['8' '9' '10' '11']
# ['12' '13' '14' '15']]
"""3、根据要求创建数组，运用数组的运算方法得到结果：resule=ar*10+100,并求出result的均值及求和"""
ar = np.arange(16).reshape(4,4)
result = ar*10+100
print(result)
# >>>输出：[[100 110 120 130]
# [140 150 160 170]
# [180 190 200 210]
# [220 230 240 250]]
print(np.mean(result)) # 平均值 175.0
print(np.sum(result)) # 求和 2800
五、Numpy索引及切片
核心：基本索引及切片 / 布尔型索引及切片
- 基本索引及切片
ar[2] ar[3][1]
ar[3,1] ar[1:3] ar[:2,1:]
import numpy as np
# 一维数组list
ar = np.arange(20)
print(ar) # [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]
print(ar[4]) # 4
print(ar[:3]) # [0 1 2]
print(ar[::2]) # [ 0 2 4 6 8 10 12 14 16 18]
print('------------')
# 二维数组list(先行后列)
ar1 = np.arange(16).reshape(4,4)
print(ar1)
# >>>输出：[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]
# [12 13 14 15]]
print(ar1[2]) # [ 8 9 10 11] 第三行
print(ar1[2][2]) # 10 第三行的第2个值
print(ar1[2,2]) # 10 第三行第三列
print(ar1[:1,2:]) # [[2 3]] 左闭右开，第一行第二列往后
print(ar1[:2,2:]) # 第一行到第二行的第二列到第三列
# >>输出：[[2 3]
# [6 7]]
print('------------')
# 三维数组
ar3 = np.arange(12).reshape(3,2,2)
print(ar3)
# >>>输出：[[[ 0 1]
# [ 2 3]]
#
# [[ 4 5]
# [ 6 7]]
#
# [[ 8 9]
# [10 11]]]
print(ar3[2])
# >>输出：[[ 8 9]
# [10 11]]
print(ar3[2][1]) # [10 11]
print(ar3[2][1][0]) # 10
- 布尔型索引及切片
用布尔型矩阵进行筛选、用判断矩阵做筛选
ar = np.arange(12).reshape(3,4)
print(ar)
# >>>输出：[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
i = np.array([True, False, True])
j = np.array([True,True,False,False])
print(i) # [ True False True]
print(j) # [ True True False False]
print(ar[i, :]) # i为[True, False, True]，所以保留第一行和第三行。在第一维度做判断，只保留True，这里第一维度就是行，ar[i,:]=ar[i] (简单书写格式)
print(ar[i]) # i为[True, False, True]，所以保留第一行和第三行。
# >>>输出：[[ 0 1 2 3]
# [ 8 9 10 11]]
print(ar[:,j])
# >>>输出：[[0 1]
# [4 5]
# [8 9]]
print(ar>5,type(ar>5)) # 得到布尔型数组
# >>输出[[False False False False]
# [False False True True]
# [ True True True True]]
print(ar[ar>5]) # [ 6 7 8 9 10 11]
m=ar>5
print(ar[m]) # [ 6 7 8 9 10 11]
- 数组索引及切片的值更改、复制
# 一个变量赋值给一个索引/切片时，会自动改变/传播原始数组
ar = np.arange(10)
print(ar) # [0 1 2 3 4 5 6 7 8 9]
ar[5]=100
ar[7:9]=200
print(ar) # [ 0 1 2 3 4 100 6 200 200 9]
# 复制
ar = np.arange(10)
b = ar.copy()
b[7:9]=200
print(ar) # [0 1 2 3 4 5 6 7 8 9]
print(b) # [ 0 1 2 3 4 5 6 200 200 9]
练习：
import numpy as np
"""1、按照要求创建数组，通过索引，其ar[4]、ar[:2,3:]、ar[3][2]分别是多少"""
ar = np.arange(25).reshape(5,5)
print(ar)
# >>>输出：[[ 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]]
print(ar[4]) # [20 21 22 23 24]
print(ar[:2,3:])
# >>>输出：[[3 4]
# [8 9]]
print(ar[3][2]) # 17
"""2、按照要求创建数组，筛选出元素值大于5的值并生成新的数组"""
ar1 = np.arange(10).reshape(2,5)
print(ar1)
# >>>输出：[[0 1 2 3 4]
# [5 6 7 8 9]]
# 先得到数值大于5的布尔型数组
print(ar1>5)
# >>>输出：[[False False False False False]
# [False True True True True]]
print(ar1[ar1>5]) # [6 7 8 9]
六、Numpy随机数
- 生成随机数——标准正态分布
import numpy as np
print(np.random.normal(size=(4,4))) # 标准正太分布在的样本值
# >>>输出：[[ 0.20746965 -0.3569164 0.38399266 -0.23825531]
# [ 1.57586345 0.27676097 1.53261017 -0.67989618]
# [ 0.70885444 2.11183292 -0.26200058 -1.12189412]
# [ 1.30693012 -2.26592066 0.71060149 0.98172181]]
- numpy.random.rand(d0,d1,...,dn)：生成一个[0,1)之间的随机浮点数或N维浮点数组——均匀分布
import matplotlib.pyplot as plt
a = np.random.rand()
print(a,type(a)) # 0.12107076764770552
print(np.random.rand(4)) # [0.80754254 0.08681042 0.2263688 0.75740495]
print(np.random.rand(4,4))
# >>>输出：[[0.10622521 0.1824461 0.43269753 0.50436525]
# [0.62558373 0.62092662 0.21627639 0.33037642]
# [0.21505231 0.62251796 0.25274457 0.31889568]
# [0.8105953 0.25010622 0.2953291 0.35862557]]
print(np.random.rand(2,4)*100)
# >>输出：[[ 2.83133566 83.6997414 39.22047445 82.7726304 ]
# [41.17245844 53.29510729 48.11262487 45.82123088]]
# 随机分布
data1 = np.random.rand(1000)
data2 = np.random.rand(1000)
plt.scatter(data1,data2)
plt.show()
随机均匀分布
- numpy.random.randn(d0,d1,...,dn)：生成一个浮点数或N维浮点数组——正态分布
以给定的形状创建一个数组，数组元素来符合标准正态分布N(0,1)；若要获得的一般正态分布N(μ,σ2)则可用。sigma*np.random.randn(...)+mu进行表示
import matplotlib.pyplot as plt
data3 =np.random.randn(1000)
data4 = np.random.randn(1000)
plt.scatter(data3,data4)
plt.show()
正态分布
- numpy.random.randint(low,high=None,size=None,dtype='l')——生成既定区间内的随机整数或N维整数数组
若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数，且high必须大于low。
dtype参数：只能是int类型
print(np.random.randint(2)) # 1 [0,2)
print(np.random.randint(2,10)) # 7
print(np.random.randint(10,size=10)) # [6 5 9 1 0 7 2 6 8 8]
print(np.random.randint(10,size=(2,5)))
# >>输出：[[9 9 6 8 8]
# [8 4 2 7 6]]
print(np.random.randint(10,50,size=(2,5)))
# >>>输出：[[44 21 12 33 11]
# [26 13 40 48 24]]
练习：
import numpy as np
"""1、请按照要求创建数组ar，再将ar[:2,2:]的值改为[0,1)的随机数"""
# ar = np.arange(25).reshape(5,5)
# print(ar.astype(np.float))
ar = np.arange(25, dtype=np.float32).reshape(5, 5)
print(ar)
# >>>输出：[[ 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.]]
ar[:2, :2] = np.random.rand(2, 2)
print(ar)
# >>>输出：[[ 0.94414437 0.42199293 2. 3. 4. ]
# [ 0.31223404 0.6848395 7. 8. 9. ]
# [10. 11. 12. 13. 14. ]
# [15. 16. 17. 18. 19. ]
# [20. 21. 22. 23. 24. ]]
"""2、创建2个包含10个元素的正态分布一维数组"""
print(np.random.normal(size=(2,5)))
# >>>输出：[[-0.08070309 -0.22007649 -1.64426372 -0.08427305 0.16660503]
# [ 0.78231407 -0.54738434 -0.52553803 0.30823321 0.21906343]]
ar2=np.random.normal(size=(2,5))
print(np.vstack(ar2))
# >>>输出：[[ 0.95997134 0.71845804 1.35903736 -0.87302671 -0.60739824]
# [-2.02281529 0.54761807 0.32981195 -0.99052164 1.74089971]]
七、Numpy数据的输入输出
存储和读取数组数据.npy文件
import numpy as np
import os
path = os.chdir(r'/Users/wpr/Desktop/数据分析笔记')
ar = np.random.rand(5, 5) # 生成均匀分布的二维数组
print(ar)
# 存成一个数组文件
np.save('arraydata.npy', ar)
print('完成')
print(np.load('arraydata.npy')) # 读取
存储和读取文本文件
import numpy as np
import os
# 存成文本文件，默认是科学计数法，fmt是改变存储形式，这里变成了两位浮点数,delimiter是以什么分隔
np.savetxt('arraydate.txt', ar, delimiter='，', fmt='%.2f')
print(np.loadtxt('arraydate.txt', delimiter='，'))
# >>输出：[[0.63 0.46 0.64 0.27 0.34]
# [0.49 0.03 0.67 0.69 0.47]
# [0.07 0.57 0.87 0.77 0.49]
# [0.42 0.9 0.47 0.58 0.99]
# [0.62 0.63 0.74 0.95 0.56]] 类型是float64
练习：
import numpy as np
"""创建一个10*10的整数随机数组，取值范围为0-100，并存为txt文件，用逗号分开"""
ar = np.random.randint(101, size=(10, 10))
print(ar)
np.savetxt('10*10随机整数.txt', ar, delimiter='，', fmt='%d')
print(np.loadtxt('10*10随机整数.txt', delimiter='，',dtype=int))