PS：内容来源于《利用Python进行数据分析》

一、创建ndarray

　　1、array ：将一个序列（嵌套序列）转换为一个数组（多维数组）　

  1. In[2]: import numpy as np
  2. In[3]: arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
  3. In[4]: arr
  4. Out[4]: array([1, 2, 3, 4, 5, 6, 7, 8, 9])
  5.  
  6. In[5]: arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
  7. In[6]: arr
  8. Out[6]:
  9. array([[1, 2, 3],
  10.        [4, 5, 6],
  11.        [7, 8, 9]])

　　2、arange：类似于内置的range，返回的是一个ndarray对象。通过reshape指定数组维度

  1. In[8]: arr = np.arange(1, 10).reshape(3, 3)
  2. In[9]: arr
  3. Out[9]:
  4. array([[1, 2, 3],
  5.        [4, 5, 6],
  6.        [7, 8, 9]])

　　3、ones、ones_like、zeros、zeros_like：根据指定shape和dtype创建一个全1或全0数组；ones_like或zeros_like另一个数组为参数，根据参数数组的shape和dtype创建全1或全0数组

  1. arr = np.ones((2, 4), dtype = np.int32)
  2. arr
  3. Out[11]:
  4. array([[1, 1, 1, 1],
  5.        [1, 1, 1, 1]])
  6. arr2 = np.zeros_like(arr)
  7. arr2
  8. Out[13]:
  9. array([[0, 0, 0, 0],
  10.        [0, 0, 0, 0]])

　　4、empty、empy_like：类似ones、ones_like，只是分配的内存空间不填充任何值，即数组的元素是未初始化的。

  1. arr = np.empty((3, 3), dtype = np.float64)
  2. arr
  3. Out[15]:
  4. array([[ 0.,  0.,  0.],
  5.        [ 0.,  0.,  0.],
  6.        [ 0.,  0.,  0.]])
  7. arr1 = np.empty_like(arr)
  8. arr1
  9. Out[17]:
  10. array([[ 0.,  0.,  0.],
  11.        [ 0.,  0.,  0.],
  12.        [ 0.,  0.,  0.]])

　　5、eye、identity：创建一个N x N单位矩阵（对角线为1，其余为0）

  1. In[18]: arr = np.eye(4, dtype = np.float32)
  2. In[19]: arr
  3. Out[19]:
  4. array([[ 1., 0., 0., 0.],
  5. [ 0., 1., 0., 0.],
  6. [ 0., 0., 1., 0.],
  7. [ 0., 0., 0., 1.]], dtype=float32)
  8. In[20]: arr1 = np.identity(4, dtype = np.int32)
  9. In[21]: arr1
  10. Out[21]:
  11. array([[1, 0, 0, 0],
  12. [0, 1, 0, 0],
  13. [0, 0, 1, 0],
  14. [0, 0, 0, 1]])

二、ndarray的shape和dtype

　　ndarray是通用的同构数据多维容器，其中的所有元素必须是相同的数据类型。

　　ndarray.shape 获取一个表示数组各维度大小的元组。 ndarray.dtype获取数组元素的数据类型。

　　numpy的数据类型有：int8 int16 int32 int64 uint8 uint16 uint32 uint64 float16 float32 float64 float128 complex64 complex128 complex256 bool object(O) string_(S) unicode_(U)

  1. In[2]: import numpy as np
  2. In[3]: arr = np.arange(16).reshape((2, 2, 4))
  3. In[4]: arr.shape
  4. Out[4]: (2, 2, 4)
  5. In[5]: arr.dtype
  6. Out[5]: dtype('int32')

　　可以通过ndarray的astype方法显示地转换dtype。如果转换过程失败了（类型转换不能实现），会引发TypeError。调用astype会创建一个新的数组，即使新旧dtpye相同也会如此。

  1. In[16]: arr = np.array(10)
  2. In[17]: arr.dtype
  3. Out[17]: dtype('int32')
  4. In[18]: float_arr = arr.astype(np.float32)
  5. In[19]: float_arr.dtype
  6. Out[19]: dtype('float32')
  7. In[20]: str = np.array(['1.3', '-4.5', ''], dtype = np.string_)
  8. In[21]: str.dtype
  9. Out[21]: dtype('S4')
  10. In[22]: num = str.astype(np.float32)
  11. In[23]: num.dtype
  12. Out[23]: dtype('float32')

三、数组和标量之间的矢量化运算

　　大小相等的数组之间的任何算术运算都会将运算应用到元素级。

  1. In[26]: arr = np.arange(1, 10).reshape((3, 3))
  2. In[27]: arr
  3. Out[27]:
  4. array([[1, 2, 3],
  5.        [4, 5, 6],
  6.        [7, 8, 9]])
  7. In[28]: arr ** 2
  8. Out[28]:
  9. array([[ 1,  4,  9],
  10.        [16, 25, 36],
  11.        [49, 64, 81]])
  12. In[29]: arr - arr
  13. Out[29]:
  14. array([[0, 0, 0],
  15.        [0, 0, 0],
  16.        [0, 0, 0]])
  17. In[30]: arr * arr.T
  18. Out[30]:
  19. array([[ 1,  8, 21],
  20.        [ 8, 25, 48],
  21.        [21, 48, 81]])

四、基本的索引和切片

　　数组切片形式上和Python列表的截取功能相似，但是数组切片获取的是原始数组的视图，这意味着不会创建新的数组，数据也不会被复制，在视图上的任何修改都会直接作用源数组上。

  1. In[2]: import numpy as np
  2. In[3]: arr = np.arange(10)
  3. In[4]: arr
  4. Out[4]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
  5. In[5]: arr[1:6]
  6. Out[5]: array([1, 2, 3, 4, 5])
  7. In[6]: arr[1:6] = [5, 4, 3, 2, 1]
  8. In[7]: arr
  9. Out[7]: array([0, 5, 4, 3, 2, 1, 6, 7, 8, 9])

　　数组的索引用以获取数组的元素（与C的数组相同）。在多维数组中，如果忽略了后面维度的索引，则返回对象为维度低一点的ndarray对象。通过索引获取的数组子集，也是源数组的视图。

　　通过索引访问数组，arr[i][j][k] 与 arr[i, j, k] 是等价的。

  1. In[8]: arr = np.arange(1, 13).reshape((2, 2, 3))
  2. In[9]: arr
  3. Out[9]:
  4. array([[[ 1,  2,  3],
  5.         [ 4,  5,  6]],
  6.  
  7.        [[ 7,  8,  9],
  8.         [10, 11, 12]]])
  9. In[10]: arr[0]
  10. Out[10]:
  11. array([[1, 2, 3],
  12.        [4, 5, 6]])
  13. In[11]: arr[0][0][0]
  14. Out[11]: 1
  15. In[12]: arr[0, 0, 0]
  16. Out[12]: 1
  17. In[13]: arr[0][1]
  18. Out[13]: array([4, 5, 6])
  19. In[14]: arr[0, 1]
  20. Out[14]: array([4, 5, 6])

　　切片索引：

  1. In[15]: arr
  2. Out[15]:
  3. array([[[ 1,  2,  3],
  4.         [ 4,  5,  6]],
  5.  
  6.        [[ 7,  8,  9],
  7.         [10, 11, 12]]])
  8. In[16]: arr[:, 1, 0:2]
  9. Out[16]:
  10. array([[ 4,  5],
  11.        [10, 11]])

　　布尔型索引：布尔索引元素的个数必须与数组相应维度上元素个数相同，否则会引发IndexError异常。 数组索引位相对应的布尔值为True的元素会被选取。

　　与切片不同，通过布尔索引选取数组中的数据，将总是创建数据的副本，即使返回一模一样的数组也是如此。

  1. In[23]: arr
  2. Out[23]:
  3. array([[1, 1, 1, 1],
  4.        [2, 2, 2, 2],
  5.        [3, 3, 3, 3],
  6.        [4, 4, 4, 4],
  7.        [5, 5, 5, 5],
  8.        [6, 6, 6, 6],
  9.        [7, 7, 7, 7]])
  10. In[24]: num = np.arange(1, 8)
  11. In[25]: num
  12. Out[25]: array([1, 2, 3, 4, 5, 6, 7])
  13. In[26]: arr[num % 2 == 0]
  14. Out[26]:
  15. array([[2, 2, 2, 2],
  16.        [4, 4, 4, 4],
  17.        [6, 6, 6, 6]])
  18. In[27]: arr[(num % 2 != 0) | (num == 4)]
  19. Out[27]:
  20. array([[1, 1, 1, 1],
  21.        [3, 3, 3, 3],
  22.        [4, 4, 4, 4],
  23.        [5, 5, 5, 5],
  24.        [7, 7, 7, 7]])
  25. In[28]: arr[(num % 2 != 0) & (num < 4)]
  26. Out[28]:
  27. array([[1, 1, 1, 1],
  28.        [3, 3, 3, 3]])

　　花式索引：花式索引（Fancy indexing）是一个numpy术语，指的是利用整数数组进行索引。 与切片不同，花式索引也总是将数据复制到新数组中。

　　 传入一个用于指定顺序的整数列表或ndarray，以获取特定顺序选取的行子集。如果使用负数索引，将会从末尾开始选取行。

  1. In[33]: arr = np.empty((8, 3), dtype = np.int32)
  2. In[34]: for i in range(8):
  3.    ...:     arr[i] = i
  4.    ...: arr
  5. Out[34]:
  6. array([[0, 0, 0],
  7.        [1, 1, 1],
  8.        [2, 2, 2],
  9.        [3, 3, 3],
  10.        [4, 4, 4],
  11.        [5, 5, 5],
  12.        [6, 6, 6],
  13.        [7, 7, 7]])
  14. In[35]: arr[[4, 2, 0, 5]]
  15. Out[35]:
  16. array([[4, 4, 4],
  17.        [2, 2, 2],
  18.        [0, 0, 0],
  19.        [5, 5, 5]])
  20. In[36]: arr[[-1, -5, -7]]
  21. Out[36]:
  22. array([[7, 7, 7],
  23.        [3, 3, 3],
  24.        [1, 1, 1]])

　　一次传入多个索引有一点特别，返回的是一个一维数组（而不是所期望的其他维度也指定顺序），其中的元素对应各个索引元组。

　　下面代码实际选取了元素： arr[1, 0]、arr[5, 2]、 arr[6, 1]、 arr[2, 2]

  1. In[40]: arr = np.arange(24).reshape(8, 3)
  2. In[41]: arr
  3. Out[41]:
  4. array([[ 0,  1,  2],
  5.        [ 3,  4,  5],
  6.        [ 6,  7,  8],
  7.        [ 9, 10, 11],
  8.        [12, 13, 14],
  9.        [15, 16, 17],
  10.        [18, 19, 20],
  11.        [21, 22, 23]])
  12. In[42]: arr[[1, 5, 6, 2],[0, 2, 1, 2]]
  13. Out[42]: array([ 3, 17, 19,  8])

　　如果希望返回其他维度也按数组指定顺序，可采用下面的方法：

　　方法一实际是通过一个数组获取指定顺序的子集，然后在获取子集的基础上，利用切片索引再次获取子集（第一个维度通过：获取全部元素；第二个维度通过花式索引获取指定顺序）。方法二使用np.ix_()函数，将两个一维整数数组转换为一个用户选取子集的索引器。 有趣的是，指定顺序数组的元素个数可以超过源数组的元素个数（其索引不能溢出，可以重复）。

  1. In[43]: arr[[1, 5, 6, 2]][:, [0, 2, 1, 2]]
  2. Out[43]:
  3. array([[ 3,  5,  4,  5],
  4.        [15, 17, 16, 17],
  5.        [18, 20, 19, 20],
  6.        [ 6,  8,  7,  8]])
  7. In[44]: arr[np.ix_([1, 5, 6, 2], [0, 2, 1, 2])]
  8. Out[44]:
  9. array([[ 3,  5,  4,  5],
  10.        [15, 17, 16, 17],
  11.        [18, 20, 19, 20],
  12.        [ 6,  8,  7,  8]])

五、数组的转置和轴对换

　　转置（transpose）是重塑的一种特殊形式，它返回的是源数据的视图，不会进行任何复制操作。

　　1、ndarray的特殊属性T，返回数组的转置：（np.dot函数计算的是矩阵的内积）

  1. In[49]: arr = np.arange(1, 10).reshape((3, 3))
  2. In[50]: arr
  3. Out[50]:
  4. array([[1, 2, 3],
  5.        [4, 5, 6],
  6.        [7, 8, 9]])
  7. In[51]: arr.T
  8. Out[51]:
  9. array([[1, 4, 7],
  10.        [2, 5, 8],
  11.        [3, 6, 9]])
  12. In[52]: np.dot(arr, arr.T)
  13. Out[52]:
  14. array([[ 14,  32,  50],
  15.        [ 32,  77, 122],
  16.        [ 50, 122, 194]])

　2、通过transpose函数返回数组的转置：transpose需要得到一个由轴编号组成的元组作为参数。

　　　所谓的轴编号即shape获取的元组的下标，比如有数组arr = np.arange(16).reshape((2, 2, 4))，arr.shape的值为元组（2, 2, 4），其下标元组为（0, 1, 2）。则，arr 与 arr.transpose(0, 1, 2) 的值是相同的。

  1. In[62]: arr = np.arange(16).reshape((2, 2, 4))
  2. In[63]: arr
  3. Out[63]:
  4. array([[[ 0,  1,  2,  3],
  5.         [ 4,  5,  6,  7]],
  6.  
  7.        [[ 8,  9, 10, 11],
  8.         [12, 13, 14, 15]]])
  9. In[64]: arr.transpose(0, 1, 2)
  10. Out[64]:
  11. array([[[ 0,  1,  2,  3],
  12.         [ 4,  5,  6,  7]],
  13.  
  14.        [[ 8,  9, 10, 11],
  15.         [12, 13, 14, 15]]])

　变更下标元组的顺序作为参数传递给transpose函数，即可实现相应的轴对换。例如arr.transpose(1, 0, 2)，将第一轴和第二轴转置对换，第三轴元素不变。

  1. In[65]: arr.transpose(1, 0, 2)
  2. Out[65]:
  3. array([[[ 0,  1,  2,  3],
  4.         [ 8,  9, 10, 11]],
  5.  
  6.        [[ 4,  5,  6,  7],
  7.         [12, 13, 14, 15]]])
  8. In[66]: arr.transpose(0, 2, 1)
  9. Out[66]:
  10. array([[[ 0,  4],
  11.         [ 1,  5],
  12.         [ 2,  6],
  13.         [ 3,  7]],
  14.  
  15.        [[ 8, 12],
  16.         [ 9, 13],
  17.         [10, 14],
  18.         [11, 15]]])
  19. In[67]: arr.transpose(1, 2, 0)
  20. Out[67]:
  21. array([[[ 0,  8],
  22.         [ 1,  9],
  23.         [ 2, 10],
  24.         [ 3, 11]],
  25.  
  26.        [[ 4, 12],
  27.         [ 5, 13],
  28.         [ 6, 14],
  29.         [ 7, 15]]])
  30. In[68]: arr.transpose(2, 0, 1)
  31. Out[68]:
  32. array([[[ 0,  4],
  33.         [ 8, 12]],
  34.  
  35.        [[ 1,  5],
  36.         [ 9, 13]],
  37.  
  38.        [[ 2,  6],
  39.         [10, 14]],
  40.  
  41.        [[ 3,  7],
  42.         [11, 15]]])

　3、swapaxes方法：此方法需要接受一对轴编号（只能是两个轴编号做为参数，不能多也不能少，且变换参数顺序对结果无影响）。

　　PS：结果理解小技巧——swapaxes（0， 2） 第二轴不变，可以视为2 x 4的数组转置 [ [(0, 4), (1, 5), (2, 6), (3, 7)], [(8, 12), (9, 13), (10, 14), (11, 15)]]，结果是4 x 2 数组

  1. In[77]: arr
  2. Out[77]:
  3. array([[[ 0,  1,  2,  3],
  4.         [ 4,  5,  6,  7]],
  5.  
  6.        [[ 8,  9, 10, 11],
  7.         [12, 13, 14, 15]]])
  8. In[78]: arr.swapaxes(0, 1)
  9. Out[78]:
  10. array([[[ 0,  1,  2,  3],
  11.         [ 8,  9, 10, 11]],
  12.  
  13.        [[ 4,  5,  6,  7],
  14.         [12, 13, 14, 15]]])
  15. In[79]: arr.swapaxes(1, 0)
  16. Out[79]:
  17. array([[[ 0,  1,  2,  3],
  18.         [ 8,  9, 10, 11]],
  19.  
  20.        [[ 4,  5,  6,  7],
  21.         [12, 13, 14, 15]]])
  22. In[80]: arr.swapaxes(0, 2)
  23. Out[80]:
  24. array([[[ 0,  8],
  25.         [ 4, 12]],
  26.  
  27.        [[ 1,  9],
  28.         [ 5, 13]],
  29.  
  30.        [[ 2, 10],
  31.         [ 6, 14]],
  32.  
  33.        [[ 3, 11],
  34.         [ 7, 15]]])

　

　　

初识numpy的多维数组对象ndarray的更多相关文章

  1. Numpy的ndarry：一种多维数组对象

    Numpy的ndarry:一种多维数组对象 Numpy最重要的一个特点就是其N维数组对象(即ndarry),该对象是一个快速而灵活的大数据集容器.你可以利用这种数组对整块数据执行一些数学运算,其语法跟 ...

  2. jquery解析php通过ajax传过来的json二维数组对象

    ajax获得php传过来的json二维数组对象,jquery解析 php代码: <?php $news = array( '武汉'=>array(1,2,3), '广州'=>arra ...

  3. Numpy 笔记: 多维数组的切片(slicing)和索引(indexing)【转】

    目录 切片(slicing)操作 索引(indexing) 操作 最简单的情况 获取多个元素 切片和索引的同异 切片(slicing)操作 Numpy 中多维数组的切片操作与 Python 中 lis ...

  4. Python数据分析 | Numpy与1维数组操作

    作者:韩信子@ShowMeAI 教程地址:http://www.showmeai.tech/tutorials/33 本文地址:http://www.showmeai.tech/article-det ...

  5. ndarray：一种多维数组对象

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

  6. numpy中多维数组的绝对索引

    这涉及到吧多维数组映射为一维数组. 对于3维数组,有公式: def MAP(x,y,z): return y_s * z_s * x + z_s * y + z 此公式可以推广到N维 测试代码:(两个 ...

  7. 利用numpy实现多维数组操作图片

    1.上次介绍了一点点numpy的操作,今天我们来介绍它如何用多维数组操作图片,这之前我们要了解一下色彩是由blue ,green ,red 三种颜色混合而成,0:表示黑色 ,127:灰色 ,255:白 ...

  8. NumPy之:多维数组中的线性代数

    目录 简介 图形加载和说明 图形的灰度 灰度图像的压缩 原始图像的压缩 总结 简介 本文将会以图表的形式为大家讲解怎么在NumPy中进行多维数据的线性代数运算. 多维数据的线性代数通常被用在图像处理的 ...

  9. Numpy学习一：ndarray数组对象

    NumPy是Python的一个高性能科学计算和数据分析基础库,提供了功能强大的多维数组对象ndarray.jupyter notebook快速执行代码的快捷键:鼠标点击选中要指定的代码框,Shift ...

随机推荐

  1. Windows上安装zabbix客户端

    1.下载解压 https://www.zabbix.com/downloads/3.4.0/zabbix_agents_3.4.0.win.zip conf目录下放有agent配置文件 bin目录下有 ...

  2. HDFS基本操作的API

    一.从hdfs下载文件到windows本地: package com.css.hdfs01; import java.io.IOException; import java.net.URI; impo ...

  3. Spring整合JUnit4进行AOP单元测试的时候，报："C:\Program Files\Java\jdk1.8.0_191\bin\java.exe" -ea -Didea.test.cyclic.buffer.size=1048576 "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2018.3\lib\idea_rt.jar=64

    错误代码 "C:\Program Files\Java\jdk1.8.0_191\bin\java.exe" -ea -Didea.test.cyclic.buffer.size= ...

  4. python常见模块之os模块

    os模块是python系统与操作系统交互的一个接口 os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径 os.chdir("dirname") 改变当前 ...

  5. 在github上新建一个仓库并上传本地工程

    扫盲:在github上新建一个仓库并上传本地工程 http://1ke.co/course/194 我自己新建了个项目,一步一步流程如下. zhoudd@desay:~/桌面/mini_embed_d ...

  6. PHP 基础篇 - PHP 的 BC MATH 系列数学函数

    一.常见问题 用 PHP 做计算时经常会遇到精度带来的问题,下面来看两个常见的例子: 1. 运算比较 下面表达式输出的结果不是相等: <?php echo 2.01 - 0.01 == 2 ? ...

  7. 理解tomcat之搭建简易http服务器

    做过java web的同学都对tomcat非常熟悉.我们在使用tomcat带来的便利的同时,是否想过tomcat是如何工作的呢?tomcat本质是一个http服务器,本篇文章将搭建一个简单的http服 ...

  8. django的所有app放在一个文件夹下便于管理

    1.新建一个python Package,名字叫apps 2.拖拽以后的app到apps文件夹下,把Search for references勾选去掉,重要重要重要!!!! 3.右键点击apps文件夹 ...

  9. idea配置scala和spark

    1 下载idea  路径https://www.jetbrains.com/idea/download/#section=windows 2安装spark  spark-2.1.0-bin-hadoo ...

  10. hdu2328 Corporate Identity

    地址:http://acm.hdu.edu.cn/showproblem.php?pid=2328 题目: Corporate Identity Time Limit: 9000/3000 MS (J ...