资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/数据科学（1）：numpy基础

数据科学（1）：numpy基础

ISherry / 570人阅读

摘要：现在到数据分析部分，先从开始环境基础是高性能科学计算和数据分析的基础包。花式索引花式索引指的是利用整型数组进行索引，它是将索引数组的元素的值作为目标数组的下标，来获取目标数组下标对应的值。

</>复制代码 
  1. 最近的爬虫学习告一段落，后续补上爬虫的笔记。现在到数据分析部分，先从NumPy开始(环境python-3.6.5) 2019/1/23
NumPy基础

NumPy是高性能科学计算和数据分析的基础包。包括以下几个功能:

ndarray,一个具有矢量算术运算和复杂广播能力的快速且节省空间的多维数组；

用于对整组数据进行快速运算的标准数学函数(无需编写循环);

用于读写磁盘的工具以及用于操作内存映射文件的工具；

线性代数，随机数生成以及傅里叶变换功能；

用于集成由C,C++，Fortran等语言编写的代码的工具。

例子引入

用python原生代码对两个向量相加

</>复制代码 
  1. def pythonsum(n):
  2.     a = list(range(n))
  3.     b = list(range(n))
  4.     c = []
  5.     for i in range(len(a)):
  6.         a[i] = i ** 2
  7.         b[i] = i ** 3
  8.         c.append(a[i] + b[i])
  9.     return c
  10. arr = pythonsum(2)
  11. print(arr)

利用NumPy对向量相加。

</>复制代码 
  1. import numpy as np
  2. def numpysum(n):
  3.     a = np.arange(n) ** 2
  4.     b = np.arange(n) ** 3
  5.     c = a + b
  6.     return c
  7. arr = numpysum(2)
  8. print(arr)

两种方法都可以对向量进行相加，相比而言利用NumPy库的代码会更简洁一点。可以对两种方法计算出执行时间，结果也是NumPy的效率高些。

ndarray，多维数组对象

NumPy中的ndarray是一个多维数组对象，这个对象是一个快速而且灵活的大数据集容器,该对象由两个部分组成:

实际的数据

描述这些数据的元数据

ndarray是一个通用的同构数据多维容器，指的是其中的元素必须是相同的数据类型，每一个数组都有一个shape(表示各维度大小的元组)和一个dtype(用于说明数据类型的对象)。

</>复制代码 
  1. In [12]: import numpy as np
  2. In [13]: a = np.arange(5)
  3. In [14]: a.dtype
  4. Out[14]: dtype("int32")
  5. In [15]: a.shape
  6. Out[15]: (5,)
  7. In [16]: a
  8. Out[16]: array([0, 1, 2, 3, 4])

NumPy中创建数组的函数

函数 说明
array 将输入数据(元组，列表或其他序列类型)转换为ndarray。要么推断出dtype,要么显示指定dtype。默认直接复制输入数据
asarray 将输入转换为ndarray,如果输入就是一个ndarray就不进行复制
arange 类似内置的range,但返回的是一个ndarray而不是一个列表
ones,ones_like 根据指定的形状和dtype创建一个全是1的数组。ones_like以另一个数组为参数，并根据其形状和dtype创建一个全为1的数组
zeros,zeros_like 类似于ones,ones_like，只不过创建的是全为0的数组

示例1:创建一维数组

</>复制代码 
  1. In [12]: import numpy as np
  2. In [29]: data = [1,2,3,4]
  3. In [30]: arr = np.array(data)
  4. In [31]: arr
  5. Out[31]: array([1, 2, 3, 4])

示例2:创建多维数组

</>复制代码 
  1. In [32]: data2 = [[1,2,3,4],[5,6,7,8]]
  2. In [33]: arr2 = np.array(data2)
  3. In [34]: arr2
  4. Out[34]:
  5. array([[1, 2, 3, 4],
  6.        [5, 6, 7, 8]])
  7. In [35]: arr2.dtype
  8. Out[35]: dtype("int32")
  9. In [36]: arr2.shape
  10. Out[36]: (2, 4)

示例3:使用zeros()函数创建元素全为0的数组

</>复制代码 
  1. In [37]: np.zeros(5)
  2. Out[37]: array([0., 0., 0., 0., 0.])
  3. In [38]: np.zeros((2,4))
  4. Out[38]:
  5. array([[0., 0., 0., 0.],
  6.        [0., 0., 0., 0.]])
  7. In [39]: np.zeros((4,2))
  8. Out[39]:
  9. array([[0., 0.],
  10.        [0., 0.],
  11.        [0., 0.],
  12.        [0., 0.]])

示例4:使用empty()函数

</>复制代码 
  1. In [44]: np.empty((2,4))
  2. Out[44]:
  3. array([[0., 0., 0., 0.],
  4.        [0., 0., 0., 0.]])
  5. #empty函数大多数情况是返回一些未初始化的垃圾值

示例5:arange()函数

</>复制代码 
  1. In [51]: np.arange(10)
  2. Out[51]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
NumPy数据类型

示例

</>复制代码 
  1. In [4]: print(np.float64(42))
  2. 42.0
  3. In [5]: print(np.int8(42.0))
  4. 42
  5. In [6]: print(np.bool(42))
  6. True
  7. In [7]: print(np.bool(0))
  8. False

定义数组的数据类型
创建数组的时候如果没有指定dtype的话，那么它会自动推断出数组元素的数据类型。如果指定了dtype，那么定义的数据类型是什么，数组元素的数据类型就是什么。

</>复制代码 
  1. In [10]: print(np.arange(7,dtype=np.float64))
  2. [0. 1. 2. 3. 4. 5. 6.]
  3. In [11]: print(np.arange(7,dtype=np.complex64))
  4. [0.+0.j 1.+0.j 2.+0.j 3.+0.j 4.+0.j 5.+0.j 6.+0.j]

数据类型的转换
数组的数据类型转换可以使用ndarray的astype方法显示地转换dtype。

</>复制代码 
  1. In [12]: arr = np.array([1,2,3])#整型
  2. In [13]: arr.dtype
  3. Out[13]: dtype("int32")
  4. In [14]: float_arr = arr.astype(np.float64)#整型转换为浮点型
  5. In [15]: float_arr
  6. Out[15]: array([1., 2., 3.])
  7. In [16]: float_arr.dtype
  8. Out[16]: dtype("float64")

用简洁的类型代码定义dtype

</>复制代码 
  1. In [27]: print(np.arange(7,dtype="f"))
  2. [0. 1. 2. 3. 4. 5. 6.]
  3. In [28]: print(np.arange(7,dtype="D"))
  4. [0.+0.j 1.+0.j 2.+0.j 3.+0.j 4.+0.j 5.+0.j 6.+0.j]
  5. #查看代码表示的数据类型
  6. In [29]: print(np.dtype("f"))
  7. float32
  8. In [30]: print(np.dtype("F"))
  9. complex64
  10. In [31]: print(np.dtype("d"))
  11. float64
  12. In [36]: print(np.dtype("U"))
  14. 自定义数据类型
    需求：假如需要有一个存储商店库存信息的数据类型，格式是有一个长度为40字节的字符串来记录商品的名称，32位的整数来记录商品的库存数量，32位的单精度浮点数来记录商品的价格。
    可以这样定义数据类型
  15. </>复制代码 
    1. In [39]: t = np.dtype([("name",np.str_,40),("num",np.int32),("price",np.float32)])
    2. In [40]: t
    3. Out[40]: dtype([("name", "
    4. 数组与标量之间的运算
    5. 数组不用编写循环就可以对数据进行批量运算。
    6. </>复制代码 
      1. In [45]: arr = np.array([[1., 2., 3.], [4., 5., 6.]])
      2. In [46]: arr
      3. Out[46]:
      4. array([[1., 2., 3.],
      5.        [4., 5., 6.]])
      6. In [47]: arr * arr
      7. Out[47]:
      8. array([[ 1.,  4.,  9.],
      9.        [16., 25., 36.]])
      10. In [48]: arr - arr
      11. Out[48]:
      12. array([[0., 0., 0.],
      13.        [0., 0., 0.]])
      14. In [49]: arr + arr
      15. Out[49]:
      16. array([[ 2.,  4.,  6.],
      17.        [ 8., 10., 12.]])
    7. 大小相同的数组之间进行算术运算都会作用到每个元素上
    8. </>复制代码 
      1. In [50]: arr = np.array([[1,2],[3,4]])
      2. In [51]: arr
      3. Out[51]:
      4. array([[1, 2],
      5.        [3, 4]])
      6. In [52]: arr * 2
      7. Out[52]:
      8. array([[2, 4],
      9.        [6, 8]])
      10. In [53]: arr + 2
      11. Out[53]:
      12. array([[3, 4],
      13.        [5, 6]])
      14. In [54]: arr - 1
      15. Out[54]:
      16. array([[0, 1],
      17.        [2, 3]])
    9. 注：除了数组和标量之间的运算以及相同大小数组之间的运算之外，不同大小的数组之间也可以进行运算，叫做广播。(关于广播后续再谈...)
    10. 数组的索引和切片
    11. 一维数组的索引和切片(与python的列表非常相似)
    12. </>复制代码 
      1. In [57]: a = np.arange(9)
      2. In [58]: a
      3. Out[58]: array([0, 1, 2, 3, 4, 5, 6, 7, 8])
      4. In [59]: a[3]
      5. Out[59]: 3
      6. In [60]: a[3:5]
      7. Out[60]: array([3, 4])
      8. In [61]: a[:7:2]
      9. Out[61]: array([0, 2, 4, 6])
      10. In [62]: a[::-1]
      11. Out[62]: array([8, 7, 6, 5, 4, 3, 2, 1, 0])
      12. In [63]: a[3:7] = 666
      13. In [64]: a
      14. Out[64]: array([  0,   1,   2, 666, 666, 666, 666,   7,   8])
    13. 多维数组的索引和切片
    14. </>复制代码 
      1. In [14]: arr = np.arange(24).reshape(2,3,4)
      2. In [15]: arr
      3. Out[15]:
      4. array([[[ 0,  1,  2,  3],
      5.         [ 4,  5,  6,  7],
      6.         [ 8,  9, 10, 11]],
      7.        [[12, 13, 14, 15],
      8.         [16, 17, 18, 19],
      9.         [20, 21, 22, 23]]])
      10. #选取第一个元素
      11. In [16]: arr[0,0,0]
      12. Out[16]: 0
      13. #第一个维度不要，选取第一行第一列的元素
      14. In [17]: arr[:,0,0]
      15. Out[17]: array([ 0, 12])
      16. #第一个维度的下标0代表的元素，后面的维度都不选取的话可以加省略号，也可以写arr[0,:,:]效果是一样的。
      17. In [18]: arr[0, ...]
      18. Out[18]:
      19. array([[ 0,  1,  2,  3],
      20.        [ 4,  5,  6,  7],
      21.        [ 8,  9, 10, 11]])
      22. #第一个维度的下标0代表的元素
      23. In [19]: arr[0]
      24. Out[19]:
      25. array([[ 0,  1,  2,  3],
      26.        [ 4,  5,  6,  7],
      27.        [ 8,  9, 10, 11]])
      28. In [20]: arr[0,1]
      29. Out[20]: array([4, 5, 6, 7])
      30. In [21]: arr[0,1,::2]
      31. Out[21]: array([4, 6])
      32. In [22]: arr[...,1]
      33. Out[22]:
      34. array([[ 1,  5,  9],
      35.        [13, 17, 21]])
      36. In [23]: arr[:,1]
      37. Out[23]:
      38. array([[ 4,  5,  6,  7],
      39.        [16, 17, 18, 19]])
      40. In [24]: arr[0,:,-1]
      41. Out[24]: array([ 3,  7, 11])
      42. In [25]: arr[0,::-1,-1]
      43. Out[25]: array([11,  7,  3])
    15. 布尔型索引
      布尔型索引指可以利用一个布尔型数组来对目标数组进行索引，找到布尔数组中值为True对应的目标数组的值。而需要注意的一点是布尔数组的长度必须和目标数组的轴长度一致。下面举例说明
    16. 一维数组的布尔型索引
      创建一个布尔型数组和一个目标数组。
    17. </>复制代码 
      1. In [27]: bool_arr = np.array([True,False,False,True,False])
      2. In [29]: dest_arr = np.arange(5)
      3. In [30]: dest_arr
      4. Out[30]: array([0, 1, 2, 3, 4])
      5. In [31]: bool_arr
      6. Out[31]: array([ True, False, False,  True, False])
      7. #布尔型数组会匹配True中对应的目标数组的值
      8. In [32]: dest_arr[bool_arr]
      9. Out[32]: array([0, 3])
      10. #可以对这些值进行算术操作，比如将匹配的数据都赋值为-5
      11. In [35]: dest_arr[bool_arr] = -5
      12. In [36]: dest_arr
      13. Out[36]: array([-5,  1,  2, -5,  4])
    18. 多维数组的布尔型索引
      数组的比较运是矢量化的，将names数组和字符串"Bob"比较会产生一个布尔型数组
    19. </>复制代码 
      1. In [2]: names = np.array(["Bob","Joe","will","Bob","Joe","Joe"])
      2. In [3]: arr = np.arange(24).reshape((6,4))
      3. In [4]: arr
      4. Out[4]:
      5. array([[ 0,  1,  2,  3],
      6.        [ 4,  5,  6,  7],
      7.        [ 8,  9, 10, 11],
      8.        [12, 13, 14, 15],
      9.        [16, 17, 18, 19],
      10.        [20, 21, 22, 23]])
      11. In [5]: names
      12. Out[5]: array(["Bob", "Joe", "will", "Bob", "Joe", "Joe"], dtype="
      13. 布尔索引实现的是通过列向量中的每个元素的布尔量数值对一个与列向量有着同样行数的矩阵进行符合匹配。而这样的作用，其实是把列向量中布尔量为True的相应行向量给抽取了出来。如果进行变量或者标定量的大数据处理，这种筛选功能的使用肯定会给程序的设计带来极大的便捷。
      14. 花式索引
        花式索引指的是利用整型数组进行索引，它是将索引数组的元素的值作为目标数组的下标，来获取目标数组下标对应的值。它是将数据复制到新的数组当中。
      15. </>复制代码 
        1. In [17]: arr = np.empty((8,4))
        2. In [18]: for i in range(8):
        3.     ...:     arr[i] = i
        4.     ...:
        5. In [19]: arr
        6. Out[19]:
        7. array([[0., 0., 0., 0.],
        8.        [1., 1., 1., 1.],
        9.        [2., 2., 2., 2.],
        10.        [3., 3., 3., 3.],
        11.        [4., 4., 4., 4.],
        12.        [5., 5., 5., 5.],
        13.        [6., 6., 6., 6.],
        14.        [7., 7., 7., 7.]])
        15. #这里的[4,3,0,6]就是索引数组，同时4,3,0,6是arr数组的下标值，
        16. #取出的数据就是array[arr[4],arr[3],arr[0],arr[6]]
        17. In [20]: arr[[4,3,0,6]]
        18. Out[20]:
        19. array([[4., 4., 4., 4.],
        20.        [3., 3., 3., 3.],
        21.        [0., 0., 0., 0.],
        22.        [6., 6., 6., 6.]])
        23. In [21]: arr[[-1,-2,-3]]
        24. Out[21]:
        25. array([[7., 7., 7., 7.],
        26.        [6., 6., 6., 6.],
        27.        [5., 5., 5., 5.]])
      16. 参考链接:
      17. 布尔型索引和花式索引： https://www.jianshu.com/p/743...
      19. <<利用python进行数据分析>>：https://github.com/BrambleXu/...
      21.            
      22.                
      23.                                            
      24.                        
      25.
云服务器 GPU云服务器 数据科学基础 基础科学数据中心 numpy数据分析 numpy

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/43070.html

相关文章

  • 真假美猴王-Numpy数据与Python数组的区别与联系

    摘要：下文统一称为数组是存储单一数据类型的多维数组同语言数组直接保存数值而则是能够对数组进行处理的函数。动态数据类型与的数组和的这些不可变数据类型的适用场景等可变数据类型适用于需要不断对原始数据进行修改的场景。 showImg(https://segmentfault.com/img/remote/1460000018925396);Numpy,是python中的一个矩阵计算包,功能类似ma...

    邹强 评论0 收藏0

  • 【数据科学系统学习】Python # 数据分析基本操作[一] numpy

    摘要：提供了使我们能够快速便捷地处理结构化数据的大量数据结构和函数。结构化数据，例如多维数据矩阵表格行数据，其中各列可能是不同的类型字符串数值日期等。基础数组和矢量计算高性能科学计算和数据分析的基础包。 本篇内容为整理《利用Python进行数据分析》，博主使用代码为 Python3，部分内容和书本有出入。 利用 Python 进行科学计算的实用指南。本书重点介绍了用于高效解决各种数据分析问...

    wushuiyong 评论0 收藏0

  • Python数据分析

    摘要：从本博客开始，将系统的学习的数据分析的六大模块，有关的基础知识，可以看我的博客。专为进行严格的数字处理而产生。在实现一个程序之前，值得检查下所需的数据处理方式是否已经在中存在了。积分六官网为了解决数据分析而创建的库。 从本博客开始，将系统的学习Python的数据分析的六大模块numpy、scipy、matplotlib、pandas、scikit-learn、keras，有关Pytho...

    Shimmer 评论0 收藏0

  • Numpy 中文用户指南 1. 安装

    摘要：包的核心是对象。但有个例外，包括对象数组的元素大小是不同的。序列大小和速度在科学计算中尤为重要。例如考虑两个长度相同的列表中每个元素相乘的情况。此外，编码所需的工作量随数据维数的增加而增加。这些信息主要用于高级用户。 译者：飞龙 1.1 NumPy 是什么？ 原文：What is NumPy? NumPy是Python中用于科学计算的基础包。它是一个Python库，提供多维数组对象，各...

    mochixuan 评论0 收藏0

  • 学习Python：做数据科学还是网站开发？

    摘要：属于前一种，而且日益被用于数学计算机器学习和多种数据科学应用。近来，由于拥有多个针对机器学习自然语言处理数据视觉化数据探索数据分析和数据挖掘的插件，丰富的数据科学生态体系得到了较大的发展，甚至有将数据科学社区化的趋势。 译者注：本文的英文原文地址是：Python for Data Science vs Python for Web Development，发布时间是10月29日。译者一...

    neu 评论0 收藏0

发表评论

登陆后可评论

0条评论

ISherry

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<