1、Numpy的优势
1.1 定义
Numpy是一个开源的python科学计算库，用于快速处理任意维度的数组
Numpy中存储对象是ndarray
1.2 创建ndarray
np.array([ ])
代码示例：
import numpy as np
# 1、创建数组
score = np.array([[80,82,90,85,86],
[86,84,95,96,82],
[75,76,79,90,82],
[82,85,84,88,91],
[92,96,93,88,89]])
print(score)1.3 numpy的优势
内存块风格——一体化存储
支持并行化运算
效率高于纯python代码——底层使用了C语言，内部释放了GIL
2、N维数组——ndarray
2.1 ndarray的属性
import numpy as np
# 数据准备
score = np.array([[80,82,90,85,86],
[86,84,95,96,82],
[75,76,79,90,82],
[82,85,84,88,91],
[92,96,93,88,89]])
# ndarray属性
# 1、数组维度的元组
tuple = score.shape
print(tuple) # (5, 5)
# 2、数组维数
a = score.ndim
print(a) # 2
# 3、数组中元素数量
print(score.size) # 25
# 4、一个数组元素的长度
print(score.itemsize) # 4
# 5、数组元素类型
print(score.dtype) #int322.2 ndarray的形状
# 1、一维数组
a = np.array([1,2,3])
print(a) # [1 2 3]
# 2、二维数组
b = np.array([[1,2,3],[4,5,6]])
print(b)
"""
[[1 2 3]
[4 5 6]]
"""
# 3、三维数组
c = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
print(c)
"""
[[[ 1 2 3]
[ 4 5 6]]
[[ 7 8 9]
[10 11 12]]]
"""2.3 指定ndarray数组元素类型
dtype = np.*
*为各种数据类型
d = np.array([1,2,3],dtype=np.float32)
print(d.dtype) # float32
e = np.array(["I","Love","Python"],dtype=np.string_)
print(e) # [b'I' b'Love' b'Python']2.4 生成0、1数组
#1、 生成0和1的数组
ones = np.ones([5,4]) # 5行4列的数组
print(ones)
"""
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
"""
zeros = np.zeros([3,3])
print(zeros)
"""
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
"""
# 生成类似于ones数组的0数组
zeros_like = np.zeros_like(ones)
print(zeros_like)
"""
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
"""
# 生成类似于zeros数组的1数组
ones_like = np.ones_like(zeros)
print(ones_like)
"""
[[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]
"""2.5 从现有数组生成新数组
# 2、从现有数组生成
a = np.array([[1,2,3],[4,5,6]])
# 通过np.array生成数组
a1 = np.array(a)
# 通过np.asarray生成数组
a2 = np.asarray(a)
# print(a1)
# print(a2)
"""
a1 =
[[1 2 3]
[4 5 6]]
a2 =
[[1 2 3]
[4 5 6]]
"""
# 改变a中第一个元素的值
a[0,0] = 100
print(a1)
print(a2)
"""
a1 =
[[1 2 3]
[4 5 6]]
a2 =
[[100 2 3]
[ 4 5 6]]
"""
# 在修改已有的数组的值时，使用np.array生成的新数组不改变值，使用np.asarray生成的新数组随着原数组的改变而改变2.6 在指定范围内生成数组
2.6.1 np.linspace()
np.linspace(start,end,num,et)
"""
start : 开始值
end : 结束值
num : 等间隔生成个数
t ：是否包含结束值，默认包含
"""# 3、生成指定范围内的数组
array = np.linspace(0,100,11) # 从0到100等间隔生成11个数字
print(array) #[ 0. 10. 20. 30. 40. 50. 60. 70. 80. 90. 100.]2.6.2 np.arange()
np.arange(start,stop,step,dtype)
"""
start : 开始值
stop : 结束值
step : 每间隔step生成一个值
dtype ： 生成数据类型，可不写
"""array1 = np.arange(10,30,5)
print(array1) # [10 15 20 25]2.6.3 np.logspace()——从10的start次方到10的stop次方等间隔生成num个值
np.logspace(start,stop,num)
"""
start：开始值
stop：结束值
num: 生成个数
"""array2 = np.logspace(0,2,3)
print(array2) # [ 1. 10. 100.]python学习笔记day04(2020-10-17)
2.7 生成随机数组
使用np.random模块
2.7.1 均匀分布
- 生成从0到1的数据——np.random.rand()
a1 = np.random.rand(2,3)
print(a1)
"""
[[0.17230452 0.23478503 0.54017338]
[0.65589368 0.03895236 0.91973592]]
"""
- 随机生成指定范围内的数组——np.random.uniform(low,high,size)
a2 = np.random.uniform(low=1,high=10,size=[2,3])
print(a2)
"""
[[1.3842155 1.18276627 4.83022089]
[8.32765243 6.50418712 8.40070829]]
"""- 随机生成指定范围内的整数数组——np.random.randint(low,high,size)
a3 = np.random.randint(1,10,[2,3])
print(a3)
"""
[1 1 7]
[4 8 2]]
"""- 均匀分布小案例
# 均匀分布小案例
# 1、数据准备
x = np.random.uniform(0,1,100000000)
# 2、创建画布
plt.figure(figsize=(20,8),dpi=100)
# 3、绘制图像
plt.hist(x,bins=1000)
# 4、展示图像
plt.show() 结果：
2.7.2 正态分布
np.random.normal(low,high,size)
正态分布小案例：
# 生成正态分布小案例——身高均值1.75，方差1，生成100000000个数据
# 数据准备
x = np.random.normal(1.75,1,100000000)
# 创建画布
plt.figure(figsize=(20,8),dpi=100)
# 绘制图像
plt.hist(x,1000)
# 展示图象
plt.show() 结果：
2.8 数组索引切片
直接索引
先对行进行索引，在对列进行索引
import numpy as np
#生成数据
stock_change = np.random.normal(0,1,(5,5))
print(stock_change)
# 获取前两行前三列的元素
print(stock_change[0:2,0:3])2.9 数组形状修改
- array.reshape([行数，列数])——将生成的数据重新组合成新的要求的数组
# 将stock_change转换成4行5列的数组
print(stock_change.reshape([4,5]))
# 将stock_change转换成n行2列的数组
print(stock_change.reshape([-1,2]))
- array.resize([行数，列数])——修改原数组不生成新数组
stock_change.resize([4,5])
print(stock_change)- array.T——行列互换
stock_change.T
print(stock_change)2.10 类型转换
- array.astype(数据类型)
a = stock_change.astype(np.int32)
print(a)
"""
[[ 0 2 0 0]
[ 2 0 0 0]
[ 0 0 0 0]
[-2 1 0 2]
[ 0 0 0 0]]
"""- array.tostring()
2.11 数组去重
np.unique()
arr = np.array([[1,2,3,4],[3,4,5,6]])
arr1 = np.unique(arr)
print(arr1) # [1 2 3 4 5 6]2.12 ndarray运算
2.12.1 逻辑运算
大于、小于直接进行判断
赋值：满足要求，直接赋值
import numpy as np
import random
# 逻辑运算
stock_change = np.random.normal(0,1,(8,10))
# print(stock_change)
stock_c = stock_change[0:5,0:5]
# print(stock_c)
print(stock_c > 1)
"""
[[False True False False False]
[False False True False False]
[False False False False False]
[False True False False False]
[False False False True False]]
"""
# 将stock_c中大于1的值改为2
stock_c[stock_c > 1] = 2
print(stock_c)2.12.2 通用判断函数
- np.all()——数组中元素全部满足条件才返回True，否则返回False
- np.any()——数组中只要有元素满足条件就返回True
stock_d = stock_change[0:2,0:5]
print(stock_d)
print(np.all(stock_d > 0))
print(np.any(stock_d > 0))
"""
[[ 0.16697365 -0.2080857 0.33042748 1.47538504 0.10321387]
[-0.40174553 0.56802209 -0.17421236 0.55153511 0.64556469]]
False
True
"""2.12.3 np.where(条件,x,y)——三目运算符
判断条件，满足条件的赋值为x,否则赋值为y
np.where(np.logical_and(条件1，条件2), x, y)——同时满足条件1和条件2，赋值x,否则赋值y
np.where(np.logical_or(条件1，条件2), x, y)——满足条件1或条件2，赋值x,否则赋值y
stock_e = np.where(stock_d>0,1,0)
print(stock_e)
"""
[[0 1 0 0 0]
[1 0 0 0 1]]
"""
print(np.where(np.logical_and(stock_d>-0.5,stock_d<0.5),1,0))
"""
[[0 0 1 1 1]
[0 0 1 0 0]]
"""
print(np.where(np.logical_or(stock_d>0,stock_d<-0.5),2,0))
"""
[[2 2 0 2 0]
[2 2 0 2 2]]
"""2.12.4 统计函数
- min——最小值
- max——最大值
- midian——中位数
- mean
- std——标准差
- var——方差
- argmax——最大值下标
- argmin——最小值下标
# 统计运算 axis=0按列 axis=1按行
print(stock_d)
print(stock_d.min(axis=0))
print(stock_d.min(axis=1))
print(stock_d.max(axis=0))
print(stock_d.max(axis=1))
"""
[[ 1.15795698 0.53414763 -0.51772646 0.51335568 -0.36422497]
[ 0.77516663 0.01804359 1.11578044 -1.1685942 -0.24747188]]
[ 0.77516663 0.01804359 -0.51772646 -1.1685942 -0.36422497]
[-0.51772646 -1.1685942 ]
[ 1.15795698 0.53414763 1.11578044 0.51335568 -0.24747188]
[1.15795698 1.11578044]
"""2.13 数组间运算
- 数组和数可以直接进行运算
- 数组和数组运算需要满足广播机制
- 维度相同 或
- shape对应位置为1
- 矩阵乘法API
- np.dot()——点乘
- np.matmul()——矩阵相乘
- 注意：两者在进行矩阵相乘时没有区别，但是dot支持矩阵与数字相乘
import numpy as np
# 1、数组与数的运算
# arr = np.array([1,2,3,4])
# print(arr)
# print(arr + 1)
# print(arr / 2)
# print(arr * 10)
"""
[1 2 3 4]
[2 3 4 5]
[0.5 1. 1.5 2. ]
[10 20 30 40]
"""
# 2、矩阵运算
a = np.array([[80,86],
[82,80],
[85,78],
[90,90],
[86,82],
[82,90],
[78,80],
[92,94]])
b = np.array([[0.7],[0.3]])
# 2.1 a * b
print(np.matmul(a,b))
"""
[[81.8]
[81.4]
[82.9]
[90. ]
[84.8]
[84.4]
[78.6]
[92.6]]
"""
# 2.2 点乘
print(np.dot(a,b))
"""
[[81.8]
[81.4]
[82.9]
[90. ]
[84.8]
[84.4]
[78.6]
[92.6]]
"""
