数据分析 ———— numpy基础（一）
数据分析 ———— numpy基础（一）
准备了好长时间，想要写点关于数据分析的文章，但一直忙于工作，忙里抽闲更新一篇关于numpy的文章。
本文主要介绍numy的应用，常用的一些函数的使用，对数组，矩阵的操作：
一、 什么是numpy?
NumPy是一个功能强大的Python库，主要用于对多维数组执行计算。NumPy提供了大量的库函数和操作，它帮助程序员轻松地进行数值计算。这类数值计算广泛用于以下任务：
- 机器学习模型：在编写机器学习算法时，需要对矩阵进行各种数值计算。例如矩阵乘法、换位、加法等。NumPy提供了一个非常好的库，用于简单(在编写代码方面)和快速(在速度方面)计算。NumPy数组用于存储训练数据和机器学习模型的参数。
- 图像处理和计算机图形学：计算机中的图像表示为多维数字数组。NumPy成为同样情况下最自然的选择。实际上，NumPy提供了一些优秀的库函数来快速处理图像。
- 数学任务：NumPy对于执行各种数学任务非常有用，如数值积分、微分、内插、外推等。因此，当涉及到数学任务时，它形成了一种基于Python的MATLAB的快速替代。
二、 numpy中的函数
1、np.array ()
array: python所自带的array模块只支持一维数组的创建，不支持多维数组。
np.array: numpy中的np.array弥补了array的不足。其dtype参数指定数组中元素的类型。
import numpy as np
# 常规数组创建方法
a1 = np.array([1, 2, 4])
a2 = np.array([[1.0,2.0],[3.0,4.0]])
a3 = np.array([[1,2],[3,4]],dtype=complex) # 指定数据类型,complex复数类型
print(a1,"\n.a2.\n",a2,"\n.a3.\n", a3)
"""
运行结果：
[1 2 4]
.a2.
[[1. 2.]
[3. 4.]]
.a3.
[[1.+0.j 2.+0.j]
[3.+0.j 4.+0.j]]
"""2、np.arange ()
arange函数： 用于创建等差数列数组
np.arange([start, ]stop, [step, ]dtype=None)
- start: 可忽略不写，默认从0开始;起始值
- stop: 结束值；生成的元素不包括结束值
- step: 可忽略不写，默认步长为1；步长
- dtype: 默认为None，设置显示元素的数据类型
nd1 = np.arange(5) #array([0, 1, 2, 3, 4]) 随机生成5个自然数
nd2 = np.arange(1,5) #array([1, 2, 3, 4])
# nd3:1为起点，间隔为2，5为终止点但取不到，（左开右闭取值）
nd3 = np.arange(1,5,2)
print(nd1)
print(nd2)
print(nd3)
# 利用字符编码创建数组
# 创建一个单精度浮点数组
m3 = np.arange(7, dtype='f')
print(m3)
# 创建复数数组
m4 = np.arange(7, dtype='D')
print(m4)
"""
运行结果：
nd1: [0 1 2 3 4]
nd2: [1 2 3 4]
nd3: [1 3]
m3: [0. 1. 2. 3. 4. 5. 6.]
m4: [0.+0.j 1.+0.j 2.+0.j 3.+0.j 4.+0.j 5.+0.j 6.+0.j]
"""3、np.reshape()
np.reshape(): 给数组一个新的形状，并且数组中的元素值不变
np.reshape(a, newshape, order='C)参数说明:
- a：被转换的数组
- newshape：整数值或整数元组。新的形状应该兼容于原始形状。如果是一个整数值，表示一个一维数组的长度；如果是元组，一个元素值可以为-1，此时该元素值表示为指定，此时会从数组的长度和剩余的维度中推断出
- order: 可选（忽略）
a = np.arange(15)
b = a.reshape(3, 5)
print(a)
print("转换后的数组：",b) #将一维数组转换成为3行5列
"""
运行结果：
[ 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]]
"""4、np.ndim（）
np.ndim(): ndim返回的是数组的维度，返回的只有一个数
# ndim返回的是数组的维度，返回的只有一个数，该数即表示数组的维度
print("a的维度：",a.ndim)
print("b的维度：",b.ndim)
"""
运行结果：
a的维度：1
b的维度：2
"""5、np.shape()
np.shape(): 表示各位维度大小的元组。返回的是一个元组
a = np.arange(15)
b = a.reshape(3, 5)
c = np.array([[[1, 4,6],[2, 5,7]],[[5,2,1],[4, 5,7]]])
print("a,b,c的维度：",a.ndim,b.ndim,c.ndim)
print("数组a:",a)
print("数组b：",b)
print("数组c:",c)
# shape：表示各位维度大小的元组。返回的是一个元组
print("a的维度的大小:",a.shape) # 查看各维度大小的元组
print("b的维度的大小:",b.shape)
print("c的维度的大小:",c.shape)
"""
运行结果：
a,b,c的维度：1 2 3
数组a: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
数组b：[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
数组c: [[[1 4 6]
[2 5 7]]
[[5 2 1]
[4 5 7]]]
a的维度的大小: (15,)
b的维度的大小: (3, 5)
c的维度的大小: (2, 2, 3)
"""对于一维数组：有疑问的是为什么不是（1，15），因为a.ndim维度为1，元组内只返回一个数。
对于二维数组：前面的是行，后面的是列，他的ndim为2，所以返回两个数。
对于三维数组：很难看出，对于上面打印的c, 看下它是什么结构。
数组c:
[[[1 4 6]
[2 5 7]]
[[5 2 1]
[4 5 7]]]先看最外面的中括号，包含 [[1,4,6],[2,5,7]] 和 [[5,2,1],[4,5,7]]，假设他们分别为数组A、B，就得到[A,B]，如果A、B仅仅是一个数字，他的ndim就是2，这就是第一个数。但是A、B是（2，3）的数组。所以结合起来，这就是c的shape，为（2，2，3）。
将这种方法类比，也就可以推出4维、5维数组的shape。
6、np.dtype()
np.dtype(): 一个用于说明数组数据类型的对象。返回的是该数组的数据类型。
print("数据类型:",a.dtype) # 查看数据类型
"""
运行结果：
数据类型: int64
"""由于图中的数据都为整形，所以返回的都是int64。如果数组中有数据带有小数点，那么就会返回float64。
有人可能会问：整形数据不应该是int吗？浮点型数据不应该是float吗？
解答：int32、float64是Numpy库自己的一套数据类型。
7、np.astype()
np.astype(): 转换数组的数据类型
vec_1 = np.array(['1','2','3'])
vec_2 = vec_1.astype('float')
print("转换前的类型：",vec_1.dtype)
print(vec_1)
print("转换后的类型：",vec_2.dtype)
print(vec_2)
"""
运行结果：
转换前的类型：<U1
['1' '2' '3']
转换后的类型：float64
[1. 2. 3.]
"""注意：其中的float，它是python内置的类型，但是Numpy可以使用。Numpy会将Python类型映射到等价的dtype上。
还有其他的类型转换（大家自行测试）：
int32 --> float64 完全ok
float64 --> int32 会将小数部分截断
string --> float64 如果字符串数组表示的全是数字，也可以用astype转化为数值类型
8、np.min(), np.max()
np.min(): 获取数组中最小的元素
np.max(): 获取数组中最小的元素
print("获取数组中最小的值:",b.min())
print("获取数组中最大的值:",b.max())
"""
运行结果：
获取数组中最小的值: 0
获取数组中最大的值: 14
"""9、np.zeros(), np.ones()
np.zeros(): 设置一个元素全为0的数组, 返回给定形状和类型的用0填充的数组
np.ones(): 设置一个元素全为1的数组, 返回给定形状和类型的用2填充的数组组
zeros(shape, dtype=float, order='C'):
ones(shape, dtype=float, order='C'):
- shape：设置数组形状
- dtype：数据类型， 可选参数，默认为np.float64
- order：可选参数（可忽略）
np.zeros((3,4)) # 设置一个3行4列的0矩阵
np.ones((2,3,4), dtype=np.int32) # 设置一个3行4列的3维的值均为1的矩阵
"""
运行结果：
array([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]])
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]]], dtype=int32)
"""10、np.random()
np.random(): 随机抽样， 生成随机数据
np.random.rand(d0,d1,....,dn)：返回随机样本位于[0,1)之间
np.random.rand() # 返回0~1中的一个随机值
np.random.rand(3, 2)# 返回3行4列的元素值在0~1随机矩阵
"""
运行结果：
np.random.rand() ：0.6759565926081442
np.random.rand(3, 2)：
array([[0.50718076, 0.55366315, 0.8955532 ],
[0.78137634, 0.67035372, 0.56846724]])
"""randn(d0, d1,...dn): 返回一个样本或多个样本值， 为标准的正态分布
np.random.randn()
np.random.randn(2,3)
"""
运行结果：
np.random.randn()：-1.723572225201004
np.random.randn(2,3)：
array([[ 0.5517019 , 0.94568245, -0.73698193],
[ 0.18349642, -1.63614097, 0.74157234]])
"""randint(low[, high,size]) : 返回low<=n<high范围的随机整数矩阵，位于半开区间[low, high)
- size：随机整数矩阵大小
np.random.randint(4, size=8)
np.random.randint(4, size=(2,3))
"""
运行结果：
array([1, 3, 0, 0, 2, 0, 0, 3])
array([[2, 3, 2],
[0, 0, 0]])
"""np.random.random(size)：
返回指定size的[0.0,1.0)随机数矩阵，random_sample、ranf、sample和它一样。
np.random.random()
np.random.random(size=[2,3])
np.random.random((2,3)) # 设置一个2行3列的值在0~1之间的矩阵
"""
运行结果：
0.7893031677602365
array([[0.78053854, 0.18131081, 0.82077647],
[0.43697461, 0.91715564, 0.05549399]])
array([[0.38284667, 0.94033216, 0.10049719],
[0.08550353, 0.83507381, 0.70694944]])
"""11、np.linspace()
np.linspace() : 返回在指定范围内的均匀间隔的数字（组成的数组），也即返回一个等差数列
numpy.linspace(start,stop[,num=50[,endpoint=True[,retstep=False[,
dtype=None]]]]]):
- start: 起始点
- stop: 结束点
- num: 元素个数，默认为50
- endpoint: 是否包含stop数值，默认为True，包含stop值；若为False，则不包含stop值
- retstep: 返回值形式，默认为False，返回等差数列组，若为True，则返回结果(array([`samples`, `step`])),
- dtype: 返回结果的数据类型，默认无，若无，则参考输入数据类型。
# linspace创建等差数列的函数，10个值从0到90的等差数列
np.linspace(0 , 90, 10)
np.linspace(0 , 90, 10, endpoint=False)
np.linspace(0 , 90, 10, retstep =True) # 返回步长
"""
运行结果：
array([ 0., 10., 20., 30., 40., 50., 60., 70., 80., 90.])
array([ 0., 9., 18., 27., 36., 45., 54., 63., 72., 81.])
(array([ 0., 10., 20., 30., 40., 50., 60., 70., 80., 90.]), 10.0)
"""12、np.ravel(), np.flatten()
两个函数都是将多维数组降为一维的，但是两者的区别是返回拷贝还是返回视图.
np.flatten()返回一份拷贝，对拷贝所做修改不会影响原始矩阵
np.ravel()返回的是视图，修改时会影响原始矩阵
# 改变数组维度
# print(b)
w1 = np.array([[1 , 2] , [3 , 4]])
w1_f = w1.flatten() # 将数组展平，flatten函数会请求分配内存来保存结果
w1_r = w1.ravel() # 将数组展平， 返回数组的一个视图
print("w1_f",w1_f)
print("w1_r",w1_r)
# 二者的区别
w1_f[0] = 10
print('w1:' , w1)
w1_r[0] = 10
print('w1:' , w1)
"""
运行结果：
w1_f [1 2 3 4]
w1_r [1 2 3 4]
w1: [[1 2]
[3 4]]
w1: [[10 2]
[ 3 4]]
"""13. np.resize()
np.resize(): 修改数组的维度
b = np.arange(24).reshape(2,3,4) # 三维坐标
b.shape = (6, 4) # 6X4的多维数组
print(b)
b.resize((2,12))
print(b)
"""
运行结果：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]
[[ 0 1 2 3 4 5 6 7 8 9 10 11]
[12 13 14 15 16 17 18 19 20 21 22 23]]
"""14、np.transpose()
np.transpose(): 转置矩阵
# transpose转置矩阵
b = np.arange(24).reshape(2,3,4) # 三维坐标
b.shape = (6, 4) # 6X4的多维数组
b.transpose()
"""
运行结果：
array([[ 0, 4, 8, 12, 16, 20],
[ 1, 5, 9, 13, 17, 21],
[ 2, 6, 10, 14, 18, 22],
[ 3, 7, 11, 15, 19, 23]])
"""15、组合数组
水平组合：
np.hstack() ,np.concatenate(): : 在水平方向上平铺
# 组合数组
a = np.arange(9).reshape(3,3)
b = 2 * a
print("a:",a)
print("b:",b)
# 水平组合
hs = np.hstack((a, b))
con_hs = np.concatenate((a,b), axis=1)
print("hs:",hs)
print("con_hs:",con_hs)
"""
运行结果：
a: [[0 1 2][3 4 5] [6 7 8]]
b: [[ 0 2 4][ 6 8 10] [12 14 16]]
hs: [[ 0 1 2 0 2 4]
[ 3 4 5 6 8 10]
[ 6 7 8 12 14 16]]
con_hs: [[ 0 1 2 0 2 4]
[ 3 4 5 6 8 10]
[ 6 7 8 12 14 16]]
"""垂直组合：
np.vstack()，np.concatenate() ：在竖直方向上堆叠
# 垂直组合
vs = np.vstack((a,b))
con_vs = np.concatenate((a,b), axis=0)
print("vs:", vs)
print("con_vs:", con_vs)
"""
运行结果：
a: [[0 1 2][3 4 5] [6 7 8]]
b: [[ 0 2 4][ 6 8 10] [12 14 16]]
vs: [[ 0 1 2][ 3 4 5][ 6 7 8]
[ 0 2 4][ 6 8 10][12 14 16]]
con_vs: [[ 0 1 2][ 3 4 5][ 6 7 8]
[ 0 2 4][ 6 8 10] [12 14 16]]
"""深度组合：
np.dstack()： 对应的元素组合
np.dstack((a, b))
"""
运行结果：
a: [[0 1 2][3 4 5] [6 7 8]]
b: [[ 0 2 4][ 6 8 10] [12 14 16]]
array([[[ 0, 0],
[ 1, 2],
[ 2, 4]],
[[ 3, 6],
[ 4, 8],
[ 5, 10]],
[[ 6, 12],
[ 7, 14],
[ 8, 16]]])
"""列组合：
np.column_stack()： 对应列相组合
# 列组合
oned = np.arange(4)
print(oned)
twice_oned = 2*oned
print(twice_oned)
np.column_stack((oned, twice_oned))
"""
运行结果：
[0 1 2 3]
[0 2 4 6]
array([[0, 0],
[1, 2],
[2, 4],
[3, 6]])
"""行组合：
np.row_stack(): 对应的行进行组合
# 行组合
np.row_stack((oned, twice_oned))
"""
运行结果：
array([[0, 1, 2, 3],
[0, 2, 4, 6]])
"""16、数组的分割
水平分割：np.hsplit（）
# 数组的分割
print(a)
np.hsplit(a, 3) # 水平分割
np.split(a, 3, axis=1) # 等价上式
"""
运行结果：
a: [[0 1 2][3 4 5][6 7 8]]
分割后的数组：
[array([[0],[3],[6]]),
array([[1],[4],[7]]),
array([[2],[5],[8]])]
"""垂直分割：np.vsplit()
# 垂直分割
np.vsplit(a, 3)
np.split(a, 3, axis=0) # 等价上式
"""
运行结果：
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
"""深度分割：np.dsplit（）
# 深度分割
c = np.arange().reshape(3, 3, 3)
print(c)
np.dsplit(c, 3)
"""
运行结果：
[[[ 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]]]
[array([[[ 0], [ 3], [ 6]],
[[ 9], [12], [15]],
[[18], [21], [24]]]),
array([[[ 1], [ 4], [ 7]],
[[10], [13], [16]],
[[19], [22], [25]]]),
array([[[ 2], [ 5], [ 8]],
[[11], [14], [17]],
[[20], [23], [26]]])]
"""17、对复数进行操作
# 对复数做操作
b1 = np.array([1.j+1,2.j+3])
print(b1)
re = b1.real # 给出复数数组的实部
ig = b1.imag # 给出复数数组的虚部
print("re:",re)
print("ig:",ig)
"""
运行结果：
[1.+1.j 3.+2.j]
re: [1. 3.]
ig: [1. 2.]
"""18、数组转换为列表
# 数组的转换
# 将数组转换为列表
b1.tolist()
"""
运行结果：
[(1+1j), (3+2j)]
"""好了以上就是我们常用的numpy函数，占时整理了这些，还有很多我没写到的，大家可以在numpy api手册上查看，在后期我还会更新一些numpy， pandas, matplotlib, 以及seaborn的文章。
如果文章中有什么错误，或者不足的地方，大家可以留言指出， 谢谢！
精彩推荐
win10下安装GPU版本的TensorFlow（cuda + cudnn）
TensorFlow-GPU线性回归可视化代码，以及问题总结
本文分享自 Python爬虫scrapy 微信公众号，前往查看
如有侵权，请联系 cloudcommunity@tencent.com 删除。
本文参与 腾讯云自媒体分享计划 ，欢迎热爱写作的你一起参与！