专栏首页Python爬虫与数据分析数据分析 ———— 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的文章。

如果文章中有什么错误,或者不足的地方,大家可以留言指出, 谢谢!

精彩推荐

knn分类器实现人脸识别

mnist手写数字识别------原理及源码

win10下安装GPU版本的TensorFlow(cuda + cudnn)

TensorFlow-GPU线性回归可视化代码,以及问题总结

简单的验证码识别(一)------------环境搭建

简单的验证码识别(二)----------------原理介绍

简单的验证码识别(三)----------------代码实现

本文分享自微信公众号 - Python爬虫scrapy(python_scrapy),作者:a1131825850疯子

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-06-28

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 数据分析 ——— pandas日期处理(五)

    通过之前的文章,大家对pandas都有了基础的了解,在接下来的文章中就是对pandas的一些补充,pandas对日期处理函数。

    andrew_a
  • 数据分析 ——— numpy基础(三)

    上两篇文章我们介绍了numpy函数一些基本用法,以及其扩展函数的用法。在这里介绍一下numpy库来进行文件的读写。

    andrew_a
  • 数据分析 ——— matplotlib基础(二)

    在上面的三个面板中分别画出了sin,cos图,前面两个参数分别为x轴, y轴数据。ax2的第三个参数“go--”是matlab风格的绘图,ax3上给出了点的标记...

    andrew_a
  • 技术角 | 深度学习之《深度学习入门》学习笔记(一)Python入门

    最近学习吴恩达《Machine Learning》课程以及《深度学习入门:基于Python的理论与实现》书,一些东西总结了下。现就后者学习进行笔记总结。本文是本...

    ZNing
  • 【玩转腾讯云】深度学习之《深度学习入门》学习笔记(一)Python入门

    最近学习吴恩达《Machine Learning》课程以及《深度学习入门:基于Python的理论与实现》书,一些东西总结了下。现就后者学习进行笔记总结。本文是本...

    ZNing
  • python中numpy和pandas介

    numpy和pandas是python中用于处理数据的两个库。 numpy介绍: numpy用于处理array,且array中数据类型必须一致。下面以代码备注的...

    py3study
  • Python之numpy的ndarray数组使用方法介绍

    NumPy的全名为Numeric Python,是一个开源的Python科学计算库,它包括:

    我是攻城师
  • Numpy核心语法和代码整理汇总!

    NumPy(Numeric Python)提供了许多高级的数值编程工具,如:矩阵数据类型、矢量处理,以及精密的运算库。专为进行严格的数字处理而产生。多为很多大型...

    公众号机器学习与生成对抗网络
  • Numpy实战全集

    0.导语1.Numpy基本操作1.1 列表转为矩阵1.2 维度1.3 行数和列数()1.4 元素个数2.Numpy创建array2.1 一维array创建2.1...

    公众号guangcity
  • [机器学习实战札记] NumPy基础

    <<机器学习实战>>一书非常注重实践,对每个算法的实现和使用示例都提供了python实现。在阅读代码的过程中,发现对NumPy有一定的了解有助于理解代码。特别是...

    云水木石

扫码关注云+社区

领取腾讯云代金券