一、Numpy是什么

  1. Numerical Python，数值的Python，补充了Python语言所欠缺的数值计算能力。
  2. Numpy是其它数据分析及机器学习库的底层库。
  3. Numpy完全标准C语言实现，运行效率充分优化。
  4. Numpy开源免费。

二、Numpy的历史

  1. 1995年，Numeric，Python语言数值计算扩充。
  2. 2001年，Scipy->Numarray，多维数组运算。
  3. 2005年，Numeric+Numarray->Numpy。
  4. 2006年，Numpy脱离Scipy成为独立的项目。

三、Numpy的核心：多维数组

  1. 代码简洁：减少Python代码中的循环。
  2. 底层实现：厚内核(C)+薄接口(Python)，保证性能。
  1. # vector.py
  2. import datetime as dt
  3. import numpy as np
  4. n = 100000
  5. start = dt.datetime.now()
  6. A, B = [], []
  7. for i in range(n):
  8.     A.append(i ** 2)
  9.     B.append(i ** 3)
  10. C = []
  11. for a, b in zip(A, B):
  12.     C.append(a + b)
  13. print("原始方法：", (dt.datetime.now() - start).microseconds)
  15. start = dt.datetime.now()
  16. A, B = np.arange(n) ** 2, np.arange(n) ** 3
  17. C = A + B
  18. print("Numpy方法：", (dt.datetime.now() - start).microseconds)
  1. 原始方法： 106456
  2. numpy方法： 5676

四、Numpy基础

数组对象

1. 用np.ndarray类的对象表示n维数组

  1. - 实际数据：数组中元素
  2. - 元数据：描述数组中的元素
  3. - 将实际数据与元数据分开存放，一方面提高了内存空间的使用效率，另一方面减少对实际数据的访问频率，提高性能

2. Numpy数组是同质数组，即所有元素的数据类型必须相同

3. Numpy数组的下标从0开始，最后一个元素的下标为数组长度减1

4. np.ndarray.dtype/shape/size：类型/维度/大小

5. np.arange(起始值(0),终止值,步长(1))->等差序列

  • np.array(任何可被解释为Numpy数组的逻辑结构)
  • 任意维度和类型的数组对象
  1. # shape.py
  2. import numpy as np
  3. a = np.arange(1, 3)
  4. print(a, a.shape)
  6. b = np.array([[1, 2, 3],
  7.               [4, 5, 6]])
  8. print(b, b.shape)
  10. c = np.array([np.arange(1, 4), np.arange(4, 7), np.arange(7, 10)]) # 二维
  11. print(c, c.shape)
  1. [1 2] (2,)
  2. [[1 2 3]
  3.  [4 5 6]] (2, 3)
  4. [[1 2 3]
  5.  [4 5 6]
  6.  [7 8 9]] (3, 3)
  1. # type.py
  2. import numpy as np
  3. a = np.arange(1, 10)
  4. print(a, type(a[0]), a.dtype)
  5. # 转换float类型
  6. b = a.astype(float)
  7. print(b, type(b[0]), b.dtype)
  8. # 转换字符类型
  9. c = a.astype(str)
  10. print(c, type(c[0]), c.dtype)
  1. [1 2 3 4 5 6 7 8 9] <class 'numpy.int64'> int64
  2. [1. 2. 3. 4. 5. 6. 7. 8. 9.] <class 'numpy.float64'> float64
  3. ['1' '2' '3' '4' '5' '6' '7' '8' '9'] <class 'numpy.str_'> <U21
  1. # size.py
  2. import numpy as np
  3. a = np.array([[10, 20, 30],
  4.               [40, 50, 60]])
  5. print(a, a.shape, a.size, len(a))  # 一维的话len都可以，二维以上需要用size
  7. b = a.reshape((6,))
  8. print(b, b.shape, b.size, len(b))
  1. [[10 20 30]
  2.  [40 50 60]] (2, 3) 6 2
  3. [10 20 30 40 50 60] (6,) 6 6

6. 元素索引(下标)

  • 数组对象[..., 页号, 行号, 列号]
  • 数组对象.shape->(..., 页数, 行数, 列数)
  • X号：[0, X数-1]
  1. # index.py
  2. import numpy as np
  3. a = np.array([[[1, 2],
  4.                [3, 4]],
  5.               [[5, 6],
  6.                [7, 8]]])
  7. print(a, a.shape)
  8. print(a[0])
  9. print(a[0][0])
  10. print(a[0][0][0])
  12. # 遍历每一个元素
  13. print("遍历每一个元素：")
  14. for i in range(a.shape[0]):  # 遍历每一页(2)
  15.     for j in range(a.shape[1]):  # 遍历每一页中的每一行(2)
  16.         for k in range(a.shape[2]): # 遍历每一行中的每一列(2)
  17.             print(a[i][j][k], end=' ')
  1. [[[1 2]
  2.   [3 4]]
  4.  [[5 6]
  5.   [7 8]]] (2, 2, 2)
  6. [[1 2]
  7.  [3 4]]
  8. [1 2]
  9. 1
  10. 遍历每一个元素：
  11. 1 2 3 4 5 6 7 8

7. Numpy的内部基本数据类型

  • 布尔型：bool_
  • 整数型：int8/int16/int32/int64
  • 有符号：int8(-128~127)/int16/int32/int64
  • 无符号：uint8(0~255)/uint16/uint32/uint64
  • 浮点型：float16/float32/float64
  • 复数型：complex64/complex128
  • 字串型：str_，每个字符用32位Unicode编码表示

8. 自定义复合类型

  1. # dtype.py
  2. import numpy as np
  3. a = np.array([('123', [4, 5, 6])], dtype='U3, 3i4') # 3个Unicode组成的串，3个4字节整型组成的元素
  4. print(a, a[0]['f0'], a[0]['f1'])
  6. b = np.array([('123', [4, 5, 6])], dtype=[('fa', np.str_, 3), ('fb', np.int32, 3)])
  7. # 两个元组内分别代表两个元素的名称、类别、长度
  8. print(b, b[0]['fa'], b[0]['fb'])
  10. # 把dtype放入字典中
  11. c = np.array([('123', [4, 5, 6])],
  12.              dtype={'names': ['fa', 'fb'],
  13.                     'formats': ['U3', '3i4']})
  14. print(c, c[0]['fa'], c[0]['fb'], d.itemsize)
  16. # 指定内存占用空间
  17. d = np.array([('123', [4, 5, 6])],
  18.              dtype={'fa':('U3', 0),
  19.                     'fb':('3i4', 20)})
  20. print(d, d[0]['fa'], d[0]['fb'], d.itemsize) # 显示占用内存大小，有时候内存布局会影响效率
  22. #
  23. e = np.array([0x1234], dtype=('>u2', {'lo':('u1', 0),  # 用大于小于号规定大端小端字节序
  24.                                      'hi':('u1', 1)}))
  25. print('{:x} {:x}'.format(e['lo'][0], e['hi'][0]))
  1. [('123', [4, 5, 6])] 123 [4 5 6]
  2. [('123', [4, 5, 6])] 123 [4 5 6]
  3. [('123', [4, 5, 6])] 123 [4 5 6] 32
  4. [('123', [4, 5, 6])] 123 [4 5 6] 32
  5. 12 34

9. 类型字符码

  1. np.bool_: ?
  2. np.int8: b
  3. np.uint8: B
  4. np.int8/16/32/64: i1/2/4/8
  5. np.uint8/16/32/64: u1/2/4/8
  6. np.float/16/32/64: f2/4/8
  7. np.complex64/128: c8/16
  8. np.str_: U<字符数>
  9. np.datetime64: M8
  • 字节序前缀，用于多字节整数和字符串：

    • </>/[=]分别表示小端/大端/硬件字节序。
  • <字节序前缀><维度><类型><字节数或字符数>
    • >3i4：大端字节序，3个元素的一维数组，每个元素都是整型，每个整型元素占4个字节。
    • <(2,3)u8：小端字节序，6个元素2行3列的二维数组，每个元素都是无符号整型，每个无符号整型元素占8个字节。
    • >U7: 包含7个字符的Unicode字符串，每个字符占4个字节，采用大端字节序。

10. 切片

  • 数组对象[起始位置:终止位置:位置步长, ...]
  • 缺省起始位置：(位置步长+)首/(位置步长-)尾
  • 缺省终止位置：(位置步长+)尾后/(位置步长-)首前
  • 缺省位置步长：1
  1. # slice.py
  2. import numpy as np
  3. a = np.arange(1, 10)
  4. print(a)
  5. print(a[:3])  # 切到第四个元素之前
  6. print(a[3:6])
  7. print(a[6:])  # 从第七个元素取到最后
  8. print(a[::-1])
  9. print(a[:-4:-1])
  10. print(a[-4:-7:-1])
  11. print(a[-7::-1])
  12. print(a[::])
  13. print(a[:])
  14. print(a[::3])
  16. print("========三维========")
  17. b = np.arange(1, 25).reshape(2, 3, 4)
  18. print(b)
  19. print("========切片========")
  20. print(b[:, 0, 0])
  21. print(b[0, :, :])
  22. print(b[0, 1])
  23. print(b[0, 1, ::2])
  24. print(b[..., 1])
  25. print(b[:, 1])
  26. print(b[0, 1, 1::2])
  27. print(b[0, :, -1])
  28. print(b[0, ::-1, -1])
  29. print(b[0, ::2, -1])
  30. print(b[::-1, ::-1])
  31. print(b[..., ::-1])
  32. print(b[-1, 1:, 2:])
  1. [1 2 3 4 5 6 7 8 9]
  2. [1 2 3]
  3. [4 5 6]
  4. [7 8 9]
  5. [9 8 7 6 5 4 3 2 1]
  6. [9 8 7]
  7. [6 5 4]
  8. [3 2 1]
  9. [1 2 3 4 5 6 7 8 9]
  10. [1 2 3 4 5 6 7 8 9]
  11. [1 4 7]
  12. ========三维========
  13. [[[ 1  2  3  4]
  14.   [ 5  6  7  8]
  15.   [ 9 10 11 12]]
  17.  [[13 14 15 16]
  18.   [17 18 19 20]
  19.   [21 22 23 24]]]
  20. ========切片========
  21. [ 1 13]
  22. [[ 1  2  3  4]
  23.  [ 5  6  7  8]
  24.  [ 9 10 11 12]]
  25. [5 6 7 8]
  26. [5 7]
  27. [[ 2  6 10]
  28.  [14 18 22]]
  29. [[ 5  6  7  8]
  30.  [17 18 19 20]]
  31. [6 8]
  32. [ 4  8 12]
  33. [12  8  4]
  34. [ 4 12]
  35. [[[21 22 23 24]
  36.   [17 18 19 20]
  37.   [13 14 15 16]]
  39.  [[ 9 10 11 12]
  40.   [ 5  6  7  8]
  41.   [ 1  2  3  4]]]
  42. [[[ 4  3  2  1]
  43.   [ 8  7  6  5]
  44.   [12 11 10  9]]
  46.  [[16 15 14 13]
  47.   [20 19 18 17]
  48.   [24 23 22 21]]]
  49. [[19 20]
  50.  [23 24]]

11. 改变维度

  • 返回一个具有新维度的新数组对象

    • 视图变维reshape/ravel

      • 数据共享
    • 复制变维flatten
      • 数据独立
  • 就地变维，在原数组对象之上，改变其维度，不返回新数组
    • xxx.shape = ...
    • xxx.resize(...)
  1. # reshape.py
  2. a = np.arange(1, 9)
  3. print(a)
  4. b = a.reshape(2, 4)
  5. print(b)
  6. c = b.reshape(2, 2, 2)
  7. print(c)
  8. d = c.ravel()
  9. print(d)
  10. e = c.flatten()
  11. print(e)
  13. a += 10
  14. print(a)
  15. print("================")
  16. print(b, c, d, e) # a中的数据做出改变，abcd都会改变，由于数据共享，e使用的是flatten，数据独立
  18. a.shape = (2, 4)
  19. print(a)
  20. f = b.transpose() # 转置，同样也是视图变维
  21. print(f)
  1. [1 2 3 4 5 6 7 8]
  2. [[1 2 3 4]
  3.  [5 6 7 8]]
  4. [[[1 2]
  5.   [3 4]]
  7.  [[5 6]
  8.   [7 8]]]
  9. [1 2 3 4 5 6 7 8]
  10. [1 2 3 4 5 6 7 8]
  11. [11 12 13 14 15 16 17 18]
  12. ================
  13. [[11 12 13 14]
  14.  [15 16 17 18]] [[[11 12]
  15.   [13 14]]
  17.  [[15 16]
  18.   [17 18]]] [11 12 13 14 15 16 17 18] [1 2 3 4 5 6 7 8]
  19. [[11 12 13 14]
  20.  [15 16 17 18]]
  21. [[11 15]
  22.  [12 16]
  23.  [13 17]
  24.  [14 18]]

12. 组合与拆分

  • 垂直：

    • np.vstack((上, 下))->组合数组
    • np.vsplit(数组, 份数)->拆分：上, ..., 下
    • np.concatenate((上, 下), axis=0)->组合数组
    • np.split(数组, 份数, axis=0)->拆分
  • 水平：
    • np.hstack((左, 右))->组合数组
    • np.hsplit(数组, 份数)->拆分：左, ..., 右
    • np.concatenate((左, 右), axis=1)->组合数组
    • np.split(数组, 份数, axis=1)->拆分
  • axis表示轴向

  • 二维：0-行，垂直，1-列，水平

  • 三维：0-页，深度，1-行，垂直，2-列，水平

  • 深度：

    • np.dstack((前, 后))->组合数组
    • np.dsplit(数组, 份数)->前, ..., 后

  • 行列(可以用一维数组做参数)

    • np.row_stack((上, 下))->组合数组
    • np.column_stack((左, 右))->组合数组
  1. # stack.py
  2. import numpy as np
  3. a = np.arange(11, 20).reshape(3, 3)
  4. print(a)
  5. b = a + 10
  6. print(b)
  8. c = np.vstack((a,b))
  9. print(c)
  11. d = np.concatenate((a, b), axis=0)
  12. print(d)
  14. e, f = np.vsplit(c, 2)
  15. print("e, f:", e, f, sep='\n')
  17. g, h = np.split(d, 2, axis=0)
  18. print("g, h:", e, f, sep='\n')
  20. i = np.hstack((a, b))
  21. print(i)
  22. j = np.concatenate((a, b), axis=1)
  23. print(j)
  24. k, l = np.hsplit(i, 2)
  25. print("k, l:", k, l, sep='\n')
  26. m, n = np.split(j, 2, axis=1)
  27. print("m, n:", m, n, sep='\n')
  29. o = np.dstack((a, b))
  30. print(o)
  31. p, q = np.dsplit(o, 2)
  32. print("p, q:", p.T[0].T, q.T[0].T, sep='\n')
  34. a, b = a.ravel(), b.ravel()
  35. print(a, b)
  36. r = np.row_stack((a, b))
  37. print(r)
  1. [[11 12 13]
  2.  [14 15 16]
  3.  [17 18 19]]
  4. [[21 22 23]
  5.  [24 25 26]
  6.  [27 28 29]]
  7. [[11 12 13]
  8.  [14 15 16]
  9.  [17 18 19]
  10.  [21 22 23]
  11.  [24 25 26]
  12.  [27 28 29]]
  13. [[11 12 13]
  14.  [14 15 16]
  15.  [17 18 19]
  16.  [21 22 23]
  17.  [24 25 26]
  18.  [27 28 29]]
  19. e, f:
  20. [[11 12 13]
  21.  [14 15 16]
  22.  [17 18 19]]
  23. [[21 22 23]
  24.  [24 25 26]
  25.  [27 28 29]]
  26. g, h:
  27. [[11 12 13]
  28.  [14 15 16]
  29.  [17 18 19]]
  30. [[21 22 23]
  31.  [24 25 26]
  32.  [27 28 29]]
  33. [[11 12 13 21 22 23]
  34.  [14 15 16 24 25 26]
  35.  [17 18 19 27 28 29]]
  36. [[11 12 13 21 22 23]
  37.  [14 15 16 24 25 26]
  38.  [17 18 19 27 28 29]]
  39. k, l:
  40. [[11 12 13]
  41.  [14 15 16]
  42.  [17 18 19]]
  43. [[21 22 23]
  44.  [24 25 26]
  45.  [27 28 29]]
  46. m, n:
  47. [[11 12 13]
  48.  [14 15 16]
  49.  [17 18 19]]
  50. [[21 22 23]
  51.  [24 25 26]
  52.  [27 28 29]]
  53. [[[11 21]
  54.   [12 22]
  55.   [13 23]]
  57.  [[14 24]
  58.   [15 25]
  59.   [16 26]]
  61.  [[17 27]
  62.   [18 28]
  63.   [19 29]]]
  64. p, q:
  65. [[11 12 13]
  66.  [14 15 16]
  67.  [17 18 19]]
  68. [[21 22 23]
  69.  [24 25 26]
  70.  [27 28 29]]
  71. [11 12 13 14 15 16 17 18 19] [21 22 23 24 25 26 27 28 29]
  72. [[11 12 13 14 15 16 17 18 19]
  73.  [21 22 23 24 25 26 27 28 29]]

13. ndarray类的属性

  • shape - 维度
  • dtype - 元素类型
  • size - 元素数量
  • ndim - 维数，len(shape)
  • itemsize - 元素字节数
  • nbytes - 总字节数 = size x itemsize
  • real - 复数数组的实部数组
  • imag - 复数数组的虚部数组
  • T - 数组对象的转置视图
  • flat - 扁平迭代器
  • 数组对象.tolist()->列表
  1. # attr.py
  2. a = np.array([[1 + 1j, 2 + 4j, 3 + 7j],
  3.               [4 + 2j, 5 + 5j, 6 + 8j],
  4.               [7 + 3j, 8 + 6j, 9 + 9j]])
  5. print(a.shape)
  6. print(a.dtype)
  7. print(a.size)
  8. print(a.ndim)
  9. print(a.size)
  10. print(a.itemsize)
  11. print(a.nbytes)
  12. print(a.real, a.imag, sep='\n')
  13. print(a.T)
  14. print([elem for elem in a.flat])
  15. b = a.tolist()
  16. print(b)
  1. (3, 3)
  2. complex128
  3. 9
  4. 2
  5. 9
  6. 16
  7. 144
  8. [[1. 2. 3.]
  9.  [4. 5. 6.]
  10.  [7. 8. 9.]]
  11. [[1. 4. 7.]
  12.  [2. 5. 8.]
  13.  [3. 6. 9.]]
  14. [[1.+1.j 4.+2.j 7.+3.j]
  15.  [2.+4.j 5.+5.j 8.+6.j]
  16.  [3.+7.j 6.+8.j 9.+9.j]]
  17. [(1+1j), (2+4j), (3+7j), (4+2j), (5+5j), (6+8j), (7+3j), (8+6j), (9+9j)]
  18. [[(1+1j), (2+4j), (3+7j)], [(4+2j), (5+5j), (6+8j)], [(7+3j), (8+6j), (9+9j)]]

numpy_basic的更多相关文章

随机推荐

  1. webpack03

    index.html <!DOCTYPE html> <html lang="en"> <head> <meta charset=&quo ...

  2. PIO Core

    PIO核概述 具有Avalon接口的并行输入/输出(parallel input/output - PIO)核,在Avalon存储器映射(Avalon Memory-Mapped Avalon-MM) ...

  3. thinkphp跨模块调用

    thinkphp跨模块调用 跨模块调用模板 return $view->fetch('admin@user/add'); 全路径模板调用: return $view->fetch(APP_ ...

  4. 分享一下js正则中惰性与贪婪

    首先引入一个介绍比较详细的网站 http://www.cnblogs.com/yuaima/p/5258513.html http://www.jb51.net/article/31491.htm 接 ...

  5. OpenSUSE下支持托盘的邮件客户端Sylpheed

    在网上搜索了很多客户端想支持系统托盘,发现一个很不错的邮件客户端Sylpheed.设置方式和foxmail很像,最为重要的是支持系统托盘,很方便,默认没有开启,简单设置下:配置->通用首选项-& ...

  6. 如何利用Python词云和wordart可视化工具对朋友圈数据进行可视化展示

    大前天我们通过Python网络爬虫对朋友圈的数据进行了抓取,感兴趣的朋友可以点击进行查看,如何利用Python网络爬虫抓取微信朋友圈的动态(上)和如何利用Python网络爬虫爬取微信朋友圈动态——附代 ...

  7. 昼猫笔记 JavaScript -- 作用域技巧!!

    简单理解 var zm = function (x) { var code = 'bb' return code }; 学过js的老哥们都知道,当这样简单的一个函数进入浏览器,浏览器开始解释代码,会将 ...

  8. 学习《TensorFlow实战Google深度学习框架 (第2版) 》中文PDF和代码

    TensorFlow是谷歌2015年开源的主流深度学习框架,目前已得到广泛应用.<TensorFlow:实战Google深度学习框架(第2版)>为TensorFlow入门参考书,帮助快速. ...

  9. 【Codeforces Round #460 (Div. 2) A】 Supermarket

    [链接] 我是链接,点我呀:) [题意] 在这里输入题意 [题解] 就是让你求m*(ai/bb)的最小值 [代码] #include <bits/stdc++.h> #define dou ...

  10. 【Henu ACM Round#14 B】Duff in Love

    [链接] 我是链接,点我呀:) [题意] 在这里输入题意 [题解] 让你在n的因子里面找一个最大的数字x 且x的因子全都不是完全平方数(y^2,y>1) O(sqrt(n))找出n的所有因子. ...