NUMPY学习

了解numpy

numpy定义：NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

numpy发展历程：NumPy 的前身 Numeric 最早是由 Jim Hugunin 与其它协作者共同开发，2005 年，Travis Oliphant 在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色，并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。

NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：

• 一个强大的N维数组对象 ndarray
• 广播功能函数
• 整合 C/C++/Fortran 代码的工具
• 线性代数、傅里叶变换、随机数生成等功能

numpy应用：

NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用， 这种组合广泛用于替代 MatLab，是一个强大的科学计算环境，有助于我们通过 Python 学习数据科学或者机器学习。

SciPy 是一个开源的 Python 算法库和数学工具包。

SciPy 包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。

Matplotlib 是 Python 编程语言及其数值数学扩展包 NumPy 的可视化操作界面。它为利用通用的图形用户界面工具包，如 Tkinter, wxPython, Qt 或 GTK+ 向应用程序嵌入式绘图提供了应用程序接口（API）。

---

numpy安装

使用pip安装：

安装 NumPy 最简单的方法就是使用 pip工具（以下代码适用于python3）

pip3 install --user numpy scipy matplotlib

--user 选项可以设置只安装在当前的用户下，而不是写入到系统目录。

清华镜像方式（下载速度快，以下代码同样只适用于python3）

pip3 install numpy scipy matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple

具体安装操作请看python pip篇

安装验证：

>>> from numpy import *
>>> eye(4)

#输出结果
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])

from numpy import * 为导入 numpy 库。

eye(4) 生成对角矩阵。

---

numpy ndarray对象(numpy.array)

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。

ndarray 对象是用于存放同类型元素的多维数组。

ndarray 中的每个元素在内存中都有相同存储大小的区域。

ndarray组成

• 一个指向数据（内存或内存映射文件中的一块数据）的指针。

• 数据类型或 dtype，描述在数组中的固定大小值的格子。

• 一个表示数组形状（shape）的元组，表示各维度大小的元组。

• 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。

跨度可以是负数，这样会使数组在内存中从后向前移动，切片中 obj[: : -1] 或 obj[: , : : -1] 就是如此。 

其中data指向数据的存储区域，dtype用来描述数据类型，dim count用来记录轴数量，dimensions用来刻画每个轴的维度，strides记录的是每个轴下标增量为1时，数据存储区域中的指针所增加的字节数。如图，如果按照0轴方向步进一个单位a[0,1]->a[1,0]，数据地址的增量为3*4=12（其中，3代表每一行中元素个数，4代表float32的存储字节数）也即a[1,0]的地址比a[0,0]高12个字节。
 

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

 实例展示

# 多于一个维度  
import numpy as np 
a = np.array([[1,  2],  [3,  4]])  
print (a)

#输出结果
[[1  2] 
 [3  4]]

# 最小维度为2
import numpy as np 
a = np.array([1, 2, 3, 4, 5], ndmin =  2)  
print (a)

#输出结果
[[1, 2, 3, 4, 5]]

# dtype 参数设置为复数
import numpy as np 
a = np.array([1,  2,  3], dtype = complex)  
print (a)

#输出结果
[1.+0.j 2.+0.j 3.+0.j]

---

numpy数据类型(numpy.dtype、numpy.astype)

 

 numpy 的数值类型实际上是 dtype 对象的实例，并对应唯一的字符，包括 np.bool_，np.int32，np.float32，等等。

数据类型对象

数据类型对象（numpy.dtype 类的实例）用来描述与数组对应的内存区域是如何使用，它描述了数据的以下几个方面：：

• 数据的类型（整数，浮点数或者 Python 对象）
• 数据的大小（例如， 整数使用多少个字节存储）
• 数据的字节顺序（小端法或大端法）
• 在结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的部分
• 如果数据类型是子数组，那么它的形状和数据类型是什么。

字节顺序是通过对数据类型预先设定 < 或 > 来决定的。 < 意味着小端法(最小值存储在最小的地址，即低位组放在最前面)。> 意味着大端法(最重要的字节存储在最小的地址，即高位组放在最前面)。

语法构造

numpy.dtype(object, align, copy)

• object - 要转换为的数据类型对象
• align - 如果为 true，填充字段使其类似 C 的结构体。
• copy - 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用

实例

用dtype定义数组数据类型

#默认是浮点数是float64
arr9 = np.array([1.,2.,3.],dtype=np.float32)
print(arr9.dtype)
#输出结果
float32

#通过类型代码指定
arr9 = np.array([1.,2.,3.],dtype="f4")
print(arr9.dtype)
#输出结果
float32

用astype修改数组数据类型

#指定数组的数据类型为字符串
arr9 = np.array(["1.1","2.3","3.1"],dtype="S")
arr9 = arr9.astype("f8")
print(arr9)
print(arr9.dtype)

#输出结果
[ 1.1  2.3  3.1]
float64

注意：在使用astype的时候，系统会创建一个新的数组(原始数组的一份拷贝)，即使指定的数据类型与原始数组相同。

---

数组属性ndarray(ndim、shape、size、dtype、itemsize、flages、real、imag、data)

NumPy 数组的维数称为秩（rank），秩就是轴的数量，即数组的维度，一维数组的秩为 1，二维数组的秩为 2，以此类推。

在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴（axis），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。

很多时候可以声明 axis，相当于声明按轴进行操作。axis=0，表示沿着第 0 轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。

 ndarray.ndim

ndarray.ndim 用于返回数组的维数，等于秩。

import numpy as np 
a = np.arange(24)  
print (a.ndim)             # a 现只有一个维度

# 现在调整其大小
b = a.reshape(2,4,3)  # b 现在拥有三个维度
print (b.ndim)

#输出结果
1
3

ndarray.shape

ndarray.shape 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目n*m，即 ndim 属性(秩)。比如，一个二维数组，其维度表示"行数"和"列数"。

import numpy as np  

#可以查看数组维度 n*m
a = np.array([[1,2,3],[4,5,6]])  
print (a.shape)

#可以调整数组大小
a.shape =  (3,2)  
print (a)

#输出结果
(2, 3)
[[1 2]
 [3 4]
 [5 6]]

也可以通过reshape调整数组大小

import numpy as np 
a = np.array([[1,2,3],[4,5,6]]) 
b = a.reshape(3,2)  
print (b)

#输出结果
[[1 2]
 [3 4]
 [5 6]]

补充：ndarray.reshape 通常返回的是非拷贝副本，即改变返回后数组的元素，原数组对应元素的值也会改变。

ndarray.itemsize

ndarray.itemsize 以字节的形式返回数组中每一个元素的大小。

import numpy as np 
 
# 数组的 dtype 为 int8（一个字节）  
x = np.array([1,2,3,4,5], dtype = np.int8)  
print (x.itemsize)
 
# 数组的 dtype 现在为 float64（八个字节） 
y = np.array([1,2,3,4,5], dtype = np.float64)  
print (y.itemsize)

#输出结果
1
8

ndarray.flags

ndarray.flags 返回 ndarray 对象的内存信息

import numpy as np 
x = np.array([1,2,3,4,5])  
print (x.flags)

#输出结果
  C_CONTIGUOUS : True
  F_CONTIGUOUS : True
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False

---

numpy创建数组(empty、zeros、ones、zeros_like、ones_like)

数组创建除了使用ndarray之外，还有以下方法创建

numpy.empty

numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：

numpy.empty(shape, dtype = float, order = 'C')

参数说明：

shape：数组形状

dtype：数组数据类型，可选

order：有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

实例

import numpy as np 
x = np.empty([3,2], dtype = int) 
print (x)

#输出结果，结果元素为随机值
[[ 6917529027641081856  5764616291768666155]
 [ 6917529027641081859 -5764598754299804209]
 [          4497473538      844429428932120]]

numpy.zeros

创建指定大小的数组，数组元素以 0 来填充：

numpy.zeros(shape, dtype = float, order = 'C')

实例

import numpy as np
 
# 默认为浮点数
x = np.zeros(5) 
print(x)
 
# 设置类型为整数
y = np.zeros((5,), dtype = int) 
print(y)
 
# 自定义类型
z = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])  
print(z)

#输出结果
[0. 0. 0. 0. 0.]
[0 0 0 0 0]
[[(0, 0) (0, 0)]
 [(0, 0) (0, 0)]]

numpy.ones

创建指定形状的数组，数组元素以 1 来填充：

numpy.ones(shape, dtype = None, order = 'C')

实例

import numpy as np
 
# 默认为浮点数
x = np.ones(5) 
print(x)
 
# 自定义类型
x = np.ones([2,2], dtype = int)
print(x)

#输出结果
[1. 1. 1. 1. 1.]
[[1 1]
 [1 1]]

numpy.zeros_like

numpy.zeros_like 用于创建一个与给定数组具有相同形状的数组，数组元素以 0 来填充。

区别：numpy.zeros 可以直接指定要创建的数组的形状，而 numpy.zeros_like 则是创建一个与给定数组具有相同形状的数组。

numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)

参数说明：

a：给定要创建相同形状的数组

dtype：数组数据类型，可选

order：数组在内存中的存储顺序

subok：是否允许返回子类，如果为 True，则返回一个子类对象，否则返回一个与 a 数组具有相同数据类型和存储顺序的数组

shape：创建的数组的形状，如果不指定，则默认为 a 数组的形状。

实例

import numpy as np
 
# 创建一个 3x3 的二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
 
# 创建一个与 arr 形状相同的，所有元素都为 0 的数组
zeros_arr = np.zeros_like(arr)
print(zeros_arr)

#输出结果
[[0 0 0]
 [0 0 0]
 [0 0 0]]

numpy.ones_like

numpy.ones_like 用于创建一个与给定数组具有相同形状的数组，数组元素以 1 来填充。

区别与numpy.zeros_like类似

numpy.ones_like(a, dtype=None, order='K', subok=True, shape=None)

实例

import numpy as np
 
# 创建一个 3x3 的二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
 
# 创建一个与 arr 形状相同的，所有元素都为 1 的数组
ones_arr = np.ones_like(arr)
print(ones_arr)

#输出结果
[[1 1 1]
 [1 1 1]
 [1 1 1]]

---

numpy从已有的数组创建数组(asarray、frombuffer、fromiter)

numpy.asarray

numpy.asarray 类似 numpy.array，具有将别的形式转换为ndarray的作用

numpy.asarray(a, dtype = None, order = None)

参数说明：

a：任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组

dtype：数组数据类型，可选

order：可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序

实例

1.将列表转化为ndarray

import numpy as np 
 
x =  [1,2,3] 
a = np.asarray(x)  
print (a)

#输出结果
[1  2  3]

2.将元组转化为ndarray

import numpy as np 
 
x =  (1,2,3) 
a = np.asarray(x)  
print (a)

#输出结果
[1  2  3]

3.将元组列表转化为ndarray

import numpy as np 
 
x =  [(1,2,3),(4,5)] 
a = np.asarray(x)  
print (a)

#输出结果
[(1, 2, 3) (4, 5)]

numpy.frombuffer

numpy.frombuffer 用于实现动态数组。

numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)

补充：buffer 是字符串的时候，Python3 默认 str 是 Unicode 类型，所以要转成 bytestring 在原 str 前加上 b。

参数说明

buffer	可以是任意对象，会以流的形式读入。
dtype	返回数组的数据类型，可选
count	读取的数据数量，默认为-1，读取所有数据。
offset	读取的起始位置，默认为0。

实例

import numpy as np 
 
s =  b'Hello World' 
a = np.frombuffer(s, dtype =  'S1')  
print (a)

#输出结果
[b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']

numpy.fromiter

numpy.fromiter 方法从可迭代对象中建立 ndarray 对象，返回一维数组。

numpy.fromiter(iterable, dtype, count=-1)

iterable	可迭代对象
dtype	返回数组的数据类型
count	读取的数据数量，默认为-1，读取所有数据

实例

import numpy as np 
 
# 使用 range 函数创建列表对象  
list=range(5)
it=iter(list)
 
# 使用迭代器创建 ndarray 
x=np.fromiter(it, dtype=float)
print(x)

#输出结果
[0. 1. 2. 3. 4.]

---

numpy从数值范围创建数组(arange、linspace等差、logspace等比)

numpy.arange

numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象

numpy.arange(start, stop, step, dtype)

补充：根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。

参数说明

start	起始值，默认为0
stop	终止值（不包含）
step	步长，默认为1
dtype	返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

实例

#生成 0 到 4 长度为 5 的数组
import numpy as np
 
x = np.arange(5)  
print (x)

#输出结果
[0  1  2  3  4]

#设置返回类型位 float
import numpy as np
 
# 设置了 dtype
x = np.arange(5, dtype =  float)  
print (x)

#输出结果
[0.  1.  2.  3.  4.]

#设置了起始值、终止值及步长
import numpy as np
x = np.arange(10,20,2)  
print (x)

#输出结果
[10  12  14  16  18]

numpy.linspace

numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

参数说明

start	序列的起始值
stop	序列的终止值，如果endpoint为true，该值包含于数列中
num	要生成的等步长的样本数量，默认为50
endpoint	该值为 true 时，数列中包含stop值，反之不包含，默认是True。
retstep	如果为 True 时，生成的数组中会显示间距，反之不显示。
dtype	ndarray 的数据类型

实例

#设置起始点为 1 ，终止点为 10，数列个数为 10
import numpy as np
a = np.linspace(1,10,10)
print(a)

#输出结果
[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]

#将 endpoint 设为 false，不包含终止值
import numpy as np
 
a = np.linspace(10, 20,  5, endpoint =  False)  
print(a)

#输出结果
[10. 12. 14. 16. 18.] #如果将 endpoint 设为 true，则会包含 20

下面例子不懂 

#设置间距
import numpy as np
a =np.linspace(1,10,10,retstep= True)
 
print(a)
# 拓展例子
b =np.linspace(1,10,10).reshape([10,1])
print(b)

#输出结果
(array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]), 1.0)
[[ 1.]
 [ 2.]
 [ 3.]
 [ 4.]
 [ 5.]
 [ 6.]
 [ 7.]
 [ 8.]
 [ 9.]
 [10.]]

numpy.logspace

numpy.logspace 函数用于创建一个于等比数列

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

参数说明

start	序列的起始值为：base ** start
stop	序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中
num	要生成的等步长的样本数量，默认为50
endpoint	该值为 true 时，数列中中包含stop值，反之不包含，默认是True。
base	对数 log 的底数。
dtype	ndarray 的数据类型

实例

import numpy as np 
# 默认底数是 10 
#这句话的意思是在10的1次方到10的二次方之间，等比例出现的十个数字
a = np.logspace(1.0, 2.0, num = 10) 
print (a)

#输出结果
[ 10.           12.91549665     16.68100537      21.5443469  27.82559402      
  35.93813664   46.41588834     59.94842503      77.42636827    100.    ]

import numpy as np
#意思是2的0次方到2的9次方之间等比例出现的10个数字
a = np.logspace(0,9,10,base=2)
print (a)

#输出结果
[  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]

---

numpy切片与索引

ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。

ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。

 # 从索引 2 开始到索引 7 停止，间隔为2
import numpy as np
 
a = np.arange(10)
s = slice(2,7,2)  #可以用.分隔
b = a[2:7:2]  #也可以用:分隔

print (a[s])
print (b)

#输出结果
[2  4  6]
[2  4  6]

冒号 : 的解释：如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。如果为 [2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。

#多维数组同样适用上述索引提取方法

import numpy as np
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a)
# 从某个索引处开始切割
print('从数组索引 a[1:] 处开始切割')
print(a[1:])

#输出结果
[[1 2 3]
 [3 4 5]
 [4 5 6]]
从数组索引 a[1:] 处开始切割
[[3 4 5]
 [4 5 6]]

#切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的 ndarray。

import numpy as np
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print (a[...,1])   # 第2列元素
print (a[1,...])   # 第2行元素
print (a[...,1:])  # 第2列及剩下的所有元素

#输出结果
[2 4 5]
[3 4 5]
[[2 3]
 [4 5]
 [5 6]]

---

numpy高级索引

NumPy 中的高级索引指的是使用整数数组、布尔数组或者其他序列来访问数组的元素。相比于基本索引，高级索引可以访问到数组中的任意元素，并且可以用来对数组进行复杂的操作和修改。

整数数组索引

整数数组索引是指使用一个数组来访问另一个数组的元素。这个数组中的每个元素都是目标数组中某个维度上的索引值。

#获取数组中 (0,0)，(1,1) 和 (2,0) 位置处的元素

import numpy as np 
 
x = np.array([[1,  2],  [3,  4],  [5,  6]]) 
y = x[[0,1,2],  [0,1,0]]  
print (y)

#输出结果
[1  4  5]

#获取了 4X3 数组中的四个角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]

import numpy as np 
 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print ('我们的数组是：' )
print (x)
print ('\n')
rows = np.array([[0,0],[3,3]]) 
cols = np.array([[0,2],[0,2]]) 
y = x[rows,cols]  
print  ('这个数组的四个角元素是：')
print (y)

#输出结果
我们的数组是：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]

这个数组的四个角元素是：
[[ 0  2]
 [ 9 11]]

#可以借助切片 : 或 … 与索引数组组合

import numpy as np
 
a = np.array([[1,2,3], [4,5,6],[7,8,9]])
b = a[1:3, 1:3]
c = a[1:3,[1,2]]
d = a[...,1:]
print(b)
print(c)
print(d)

#输出结果
[[5 6]
 [8 9]]
[[5 6]
 [8 9]]
[[2 3]
 [5 6]
 [8 9]]

布尔索引

我们可以通过一个布尔数组来索引目标数组。

布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。

#获取大于 5 的元素

import numpy as np 
 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print ('我们的数组是：')
print (x)
print ('\n')
# 现在我们会打印出大于 5 的元素  
print  ('大于 5 的元素是：')
print (x[x >  5])

#输出结果
我们的数组是：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]

大于 5 的元素是：
[ 6  7  8  9 10 11]

#使用了 ~（取补运算符）来过滤 NaN(nan的意思是not a number，无效的数值)
import numpy as np 
 
a = np.array([np.nan,  1,2,np.nan,3,4,5])  
print (a[~np.isnan(a)])

#输出结果
[ 1.   2.   3.   4.   5.]

#演示如何从数组中过滤掉非复数元素
import numpy as np 
 
a = np.array([1,  2+6j,  5,  3.5+5j])  
print (a[np.iscomplex(a)])

#输出结果
[2.0+6.j  3.5+5.j]

补充：关于多条件的布尔索引 

import numpy as np
x = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
print('原数组：\n', x)
print('大于5且小于10的元素：')

print('条件加小括号：')
print(x[(x > 5) & (x < 10)])

print('使用np.logical_and方法：')
print(x[np.logical_and(x > 5, x < 10)])

print('使用np.all方法：')
print(x[np.all([x > 5, x < 10],axis=0)])

#输出结果
原数组：
 [[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
大于5且小于10的元素：

条件加小括号：
[6 7 8 9]

使用np.logical_and方法：
[6 7 8 9]

使用np.all方法：
[6 7 8 9]

花式索引

花式索引指的是利用整数数组进行索引。

花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。

对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素，如果目标是二维数组，那么就是对应下标的行。

花式索引跟切片不一样，它总是将数据复制到新数组中。

一维数组

#一维数组只有一个轴 axis = 0，所以一维数组就在 axis = 0 这个轴上取值
import numpy as np

x = np.arange(9)
print(x)
# 一维数组读取指定下标对应的元素
print("-------读取下标对应的元素-------")
x2 = x[[0, 6]] # 使用花式索引
print(x2) 

print(x2[0])
print(x2[1])

#输出结果
[0 1 2 3 4 5 6 7 8]
-------读取下标对应的元素-------
[0 6]
0
6

二维数组

#传入顺序索引数组
import numpy as np 
 
x=np.arange(32).reshape((8,4))
print(x)
# 二维数组读取指定下标对应的行
print("-------读取下标对应的行-------")
print (x[[4,2,1,7]])

#输出结果
[[ 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 27]
 [28 29 30 31]]
-------读取下标对应的行-------
#print (x[[4,2,1,7]]) 输出下表为 4, 2, 1, 7 对应的行
[[16 17 18 19]
 [ 8  9 10 11]
 [ 4  5  6  7]
 [28 29 30 31]]

#传入倒序索引数组
import numpy as np 
 
x=np.arange(32).reshape((8,4))
print (x[[-4,-2,-1,-7]])

#输出结果
[[16 17 18 19]
 [24 25 26 27]
 [28 29 30 31]
 [ 4  5  6  7]]

#传入多个索引数组（要使用 np.ix_）
np.ix_ 函数就是输入两个数组，产生笛卡尔积的映射关系

import numpy as np 
 
x=np.arange(32).reshape((8,4))
print (x[np.ix_([1,5,7,2],[0,3,1,2])])

#输出结果
[[ 4  7  5  6]
 [20 23 21 22]
 [28 31 29 30]
 [ 8 11  9 10]]

---

numpy广播（计算）

广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。

#满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘
import numpy as np 
 
a = np.array([1,2,3,4]) 
b = np.array([10,20,30,40]) 
c = a * b 
print (c)

#输出结果
[ 10  40  90 160]

2 个数组的形状不同时，numpy 将自动触发广播机制

import numpy as np 
 
a = np.array([[ 0, 0, 0],
           [10,10,10],
           [20,20,20],
           [30,30,30]])
b = np.array([0,1,2])
print(a + b)

#输出结果
[[ 0  1  2]
 [10 11 12]
 [20 21 22]
 [30 31 32]]

 补充：tile函数

numpy.tile(A, reps)

根据reps通过重复A的次数来构造一个数组。

假设reps的长度位d，则结果的维度为max(d, A.ndim)

import numpy as np

b = np.array( [1,2] )   # 表示有 1 行，2 列
c = np.array( [ [1], [2] ] )
bb = np.tile( b, (3,1)) # 表示把 b 在行方向复制为 3 行
cc = np.tile( c, (1,3)) # 表示把 c 在列方向复制为 3 列
print(b)
print(c)
print(bb)
print(cc)

#输出结果
[1 2]

[[1]
 [2]]

[[1 2]
 [1 2]
 [1 2]]

[[1 1 1]
 [2 2 2]]

广播的规则:

• 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
• 输出数组的形状是输入数组形状的各个维度上的最大值。
• 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
• 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。

---

numpy迭代数组(nditer)

NumPy 迭代器对象 numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式。

迭代器最基本的任务的可以完成对数组元素的访问。

#使用 arange() 函数创建一个 2X3 数组，并使用 nditer 对它进行迭代

import numpy as np
 
a = np.arange(6).reshape(2,3)
print ('原始数组是：')
print (a)
print ('\n')
print ('迭代输出元素：')
for x in np.nditer(a):
    print (x, end=", " )
print ('\n')

#输出结果
原始数组是：
[[0 1 2]
 [3 4 5]]

迭代输出元素：
0, 1, 2, 3, 4, 5, 

控制遍历顺序

• for x in np.nditer(a, order='F'):Fortran order，即是列序优先；
• for x in np.nditer(a.T, order='C'):C order，即是行序优先；

import numpy as np
 
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print ('原始数组是：') 
print (a) 
print ('\n') 
print ('原始数组的转置是：') 
b = a.T 
print (b) 
print ('\n') 
print ('以 C 风格顺序排序：') 
c = b.copy(order='C')  
print (c)
for x in np.nditer(c):  
    print (x, end=", " )
print  ('\n') 
print  ('以 F 风格顺序排序：')
c = b.copy(order='F')  
print (c)
for x in np.nditer(c):  
    print (x, end=", " )

#输出结果
原始数组是：
[[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]


原始数组的转置是：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]


以 C 风格顺序排序：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]
0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55, 

以 F 风格顺序排序：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]
0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55,

修改数组中元素的值

nditer 对象有另一个可选参数 op_flags。 默认情况下，nditer 将视待迭代遍历的数组为只读对象（read-only），为了在遍历数组的同时，实现对数组元素值的修改，必须指定 readwrite 或者 writeonly 的模式。

import numpy as np
 
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print ('原始数组是：')
print (a)
print ('\n')
for x in np.nditer(a, op_flags=['readwrite']): 
    x[...]=2*x #x[...] 是修改原 numpy 元素，x 只是个拷贝。
print ('修改后的数组是：')
print (a)

#输出结果
原始数组是：
[[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]


修改后的数组是：
[[  0  10  20  30]
 [ 40  50  60  70]
 [ 80  90 100 110]]

使用外部循环

nditer 类的构造器拥有 flags 参数，它可以接受下列值：

c_index	可以跟踪 C 顺序的索引
f_index	可以跟踪 Fortran 顺序的索引
multi_index	每次迭代可以跟踪一种索引类型
external_loop	给出的值是具有多个值的一维数组，而不是零维数组

#迭代器遍历对应于每列，并组合为一维数组。
import numpy as np 
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print ('原始数组是：')
print (a)
print ('\n')
print ('修改后的数组是：')
for x in np.nditer(a, flags =  ['external_loop'], order =  'F'):  
   print (x, end=", " )

#输出结果
原始数组是：
[[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]


修改后的数组是：
[ 0 20 40], [ 5 25 45], [10 30 50], [15 35 55],

广播迭代

如果两个数组是可广播的，nditer 组合对象能够同时迭代它们。 假设数组 a 的维度为 3X4，数组 b 的维度为 1X4 ，则使用以下迭代器（数组 b 被广播到 a 的大小）。

import numpy as np 
 
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print  ('第一个数组为：')
print (a)
print  ('\n')
print ('第二个数组为：')
b = np.array([1,  2,  3,  4], dtype =  int)  
print (b)
print ('\n')
print ('修改后的数组为：')
for x,y in np.nditer([a,b]):  
    print ("%d:%d"  %  (x,y), end=", " )

#输出结果
第一个数组为：
[[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]


第二个数组为：
[1 2 3 4]


修改后的数组为：
0:1, 5:2, 10:3, 15:4, 20:1, 25:2, 30:3, 35:4, 40:1, 45:2, 50:3, 55:4,

---

修改数组形状(reshape、flat、flatten、ravel)

numpy.reshape

numpy.reshape 函数可以在不改变数据的条件下修改形状

numpy.reshape(arr, newshape, order='C')

• arr：要修改形状的数组
• newshape：整数或者整数数组，新的形状应当兼容原有形状
• order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序。

import numpy as np
 
a = np.arange(8)
print ('原始数组：')
print (a)
print ('\n')
 
b = a.reshape(4,2)
print ('修改后的数组：')
print (b)

#输出结果
原始数组：
[0 1 2 3 4 5 6 7]

修改后的数组：
[[0 1]
 [2 3]
 [4 5]
 [6 7]]

numpy.ndarray.flat

 numpy.ndarray.flat是一个数组元素迭代器

import numpy as np
 
a = np.arange(9).reshape(3,3) 
print ('原始数组：')
for row in a:
    print (row)
 
#对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
print ('迭代后的数组：')
for element in a.flat:
    print (element)

#输出结果
原始数组：
[0 1 2]
[3 4 5]
[6 7 8]
迭代后的数组：
0
1
2
3
4
5
6
7
8

numpy.ndarray.flatten

numpy.ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组

ndarray.flatten(order='C')

• order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。

import numpy as np
 
a = np.arange(8).reshape(2,4)
 
print ('原数组：')
print (a)
print ('\n')
# 默认按行
 
print ('展开的数组：')
print (a.flatten())
print ('\n')
 
print ('以 F 风格顺序展开的数组：')
print (a.flatten(order = 'F'))

#输出结果
原数组：
[[0 1 2 3]
 [4 5 6 7]]


展开的数组：
[0 1 2 3 4 5 6 7]


以 F 风格顺序展开的数组：
[0 4 1 5 2 6 3 7]

numpy.ravel

numpy.ravel() 展平的数组元素，顺序通常是"C风格"，返回的是数组视图，修改会影响原始数组。

numpy.ravel(a, order='C')

• order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。

import numpy as np
 
a = np.arange(8).reshape(2,4)
 
print ('原数组：')
print (a)
print ('\n')
 
print ('调用 ravel 函数之后：')
print (a.ravel())
print ('\n')
 
print ('以 F 风格顺序调用 ravel 函数之后：')
print (a.ravel(order = 'F'))

#输出结果
原数组：
[[0 1 2 3]
 [4 5 6 7]]


调用 ravel 函数之后：
[0 1 2 3 4 5 6 7]


以 F 风格顺序调用 ravel 函数之后：
[0 4 1 5 2 6 3 7]

---

翻转数组(transpose、ndarray.T、rollaxis、swapaxes)

numpy.transpose

numpy.transpose 函数用于对换数组的维度

numpy.transpose(arr, axes)

• arr：要操作的数组
• axes：整数列表，对应维度，通常所有维度都会对换。

import numpy as np
 
a = np.arange(12).reshape(3,4)
 
print ('原数组：')
print (a )
print ('\n')
 
print ('对换数组：')
print (np.transpose(a))

#输出结果
原数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]


对换数组：
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

numpy.ndarray.T类似transpose

import numpy as np
 
a = np.arange(12).reshape(3,4)
 
print ('原数组：')
print (a)
print ('\n')
 
print ('转置数组：')
print (a.T)

#输出结果
原数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]


转置数组：
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

numpy.rollaxis

numpy.rollaxis 函数向后滚动特定的轴到一个特定位(前后调轴位置)

numpy.rollaxis(arr, axis, start)

• arr：数组
• axis：要向后滚动的轴，其它轴的相对位置不会改变
• start：默认为零，表示完整的滚动。会滚动到特定位置。

import numpy as np
 
# 创建了三维的 ndarray
a = np.arange(8).reshape(2,2,2)
 
print ('原数组：')
print (a)
print ('获取数组中一个值：')
print(np.where(a==6))   
print(a[1,1,0])  # 为 6
print ('\n')
 
 
# 将轴 2 滚动到轴 0（宽度到深度）轴序0，1，2变成1,2,0 操作
 
print ('调用 rollaxis 函数：')
b = np.rollaxis(a,2,0)
print (b)
# 查看元素 a[1,1,0]，即 6 的坐标，变成 [0, 1, 1]
# 最后一个 0 移动到最前面
print(np.where(b==6))   
print ('\n')
 
# 将轴 2 滚动到轴 1：（宽度到高度）（相当于轴1和2位置交换）
 
print ('调用 rollaxis 函数：')
c = np.rollaxis(a,2,1)
print (c)
# 查看元素 a[1,1,0]，即 6 的坐标，变成 [1, 0, 1]
# 最后的 0 和 它前面的 1 对换位置
print(np.where(c==6))   
print ('\n')

#输出结果
原数组：
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
获取数组中一个值：
(array([1]), array([1]), array([0]))
6


调用 rollaxis 函数：
[[[0 2]
  [4 6]]

 [[1 3]
  [5 7]]]
(array([0]), array([1]), array([1]))


调用 rollaxis 函数：
[[[0 2]
  [1 3]]

 [[4 6]
  [5 7]]]
(array([1]), array([0]), array([1]))

numpy.swapaxes

numpy.swapaxes 函数用于交换数组的两个轴(交换轴位置)

numpy.swapaxes(arr, axis1, axis2)

• arr：输入的数组
• axis1：对应第一个轴的整数
• axis2：对应第二个轴的整数

import numpy as np
 
# 创建了三维的 ndarray
a = np.arange(8).reshape(2,2,2)
 
print ('原数组：')
print (a)
print ('\n')
# 现在交换轴 0（深度方向）到轴 2（宽度方向）
 
print ('调用 swapaxes 函数后的数组：')
print (np.swapaxes(a, 2, 0))

#输出结果
原数组：
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]


调用 swapaxes 函数后的数组：
[[[0 4]
  [2 6]]

 [[1 5]
  [3 7]]]

---

修改数组维度(broadcast、broadcast_to、expand_dims、squeeze)

numpy.broadcast

numpy.broadcast 用于模仿广播的对象，它返回一个对象，该对象封装了将一个数组广播到另一个数组的结果

import numpy as np
 
x = np.array([[1], [2], [3]])
y = np.array([4, 5, 6])  
 
# 对 y 广播 x
b = np.broadcast(x,y)  
# 它拥有 iterator 属性，基于自身组件的迭代器元组
 
print ('对 y 广播 x：')
r,c = b.iters
 
# Python3.x 为 next(context) ，Python2.x 为 context.next()
print (next(r), next(c))
print (next(r), next(c))
print ('\n')
# shape 属性返回广播对象的形状
 
print ('广播对象的形状：')
print (b.shape)
print ('\n')
# 手动使用 broadcast 将 x 与 y 相加
b = np.broadcast(x,y)
c = np.empty(b.shape)
 
print ('手动使用 broadcast 将 x 与 y 相加：')
print (c.shape)
print ('\n')
c.flat = [u + v for (u,v) in b]
 
print ('调用 flat 函数：')
print (c)
print ('\n')
# 获得了和 NumPy 内建的广播支持相同的结果
 
print ('x 与 y 的和：')
print (x + y)

#输出结果
对 y 广播 x：
1 4
1 5

广播对象的形状：
(3, 3)

手动使用 broadcast 将 x 与 y 相加：
(3, 3)

调用 flat 函数：
[[5. 6. 7.]
 [6. 7. 8.]
 [7. 8. 9.]]

x 与 y 的和：
[[5 6 7]
 [6 7 8]
 [7 8 9]]

numpy.broadcast_to

numpy.broadcast_to 函数将数组广播到新形状。它在原始数组上返回只读视图。 

numpy.broadcast_to(array, shape, subok)

import numpy as np
 
a = np.arange(4).reshape(1,4)
 
print ('原数组：')
print (a)
print ('\n')
 
print ('调用 broadcast_to 函数之后：')
print (np.broadcast_to(a,(4,4)))

#输出结果
原数组：
[[0 1 2 3]]


调用 broadcast_to 函数之后：
[[0 1 2 3]
 [0 1 2 3]
 [0 1 2 3]
 [0 1 2 3]]

numpy.expand_dims

numpy.expand_dims 函数通过在指定位置插入新的轴来扩展数组形状

 numpy.expand_dims(arr, axis)

• arr：输入数组
• axis：新轴插入的位置

import numpy as np
 
x = np.array(([1,2],[3,4]))
 
print ('数组 x：')
print (x)
print ('\n')
y = np.expand_dims(x, axis = 0)
 
print ('数组 y：')
print (y)
print ('\n')
 
print ('数组 x 和 y 的形状：')
print (x.shape, y.shape)
print ('\n')
# 在位置 1 插入轴
y = np.expand_dims(x, axis = 1)
 
print ('在位置 1 插入轴之后的数组 y：')
print (y)
print ('\n')
 
print ('x.ndim 和 y.ndim：')
print (x.ndim,y.ndim)
print ('\n')
 
print ('x.shape 和 y.shape：')
print (x.shape, y.shape)

#输出结果
数组 x：
[[1 2]
 [3 4]]

数组 y：
[[[1 2]
  [3 4]]]

数组 x 和 y 的形状：
(2, 2) (1, 2, 2)

在位置 1 插入轴之后的数组 y：
[[[1 2]]

 [[3 4]]]

x.ndim 和 y.ndim：
2 3

x.shape 和 y.shape：
(2, 2) (2, 1, 2)

numpy.squeeze

numpy.squeeze 函数从给定数组的形状中删除一维的条目

numpy.squeeze(arr, axis)

• arr：输入数组
• axis：整数或整数元组，用于选择形状中一维条目的子集

import numpy as np
 
x = np.arange(9).reshape(1,3,3)
 
print ('数组 x：')
print (x)
print ('\n')
y = np.squeeze(x)
 
print ('数组 y：')
print (y)
print ('\n')
 
print ('数组 x 和 y 的形状：')
print (x.shape, y.shape)

#输出结果
数组 x：
[[[0 1 2]
  [3 4 5]
  [6 7 8]]]


数组 y：
[[0 1 2]
 [3 4 5]
 [6 7 8]]


数组 x 和 y 的形状：
(1, 3, 3) (3, 3)

---

连接数组(concatenate、stack、hstack、vstack)

numpy.concatenate

numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组

numpy.concatenate((a1, a2, ...), axis)

• a1, a2, ...：相同类型的数组
• axis：沿着它连接数组的轴，默认为 0

import numpy as np
 
a = np.array([[1,2],[3,4]])
 
print ('第一个数组：')
print (a)
print ('\n')
b = np.array([[5,6],[7,8]])
 
print ('第二个数组：')
print (b)
print ('\n')
# 两个数组的维度相同
 
print ('沿轴 0 连接两个数组：')
print (np.concatenate((a,b)))
print ('\n')
 
print ('沿轴 1 连接两个数组：')
print (np.concatenate((a,b),axis = 1))

#输出结果
第一个数组：
[[1 2]
 [3 4]]


第二个数组：
[[5 6]
 [7 8]]


沿轴 0 连接两个数组：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]


沿轴 1 连接两个数组：
[[1 2 5 6]
 [3 4 7 8]]

numpy.stack

numpy.stack 函数用于沿新轴连接数组序列

numpy.stack(arrays, axis)

• arrays相同形状的数组序列
• axis：返回数组中的轴，输入数组沿着它来堆叠

import numpy as np
 
a = np.array([[1,2],[3,4]])
 
print ('第一个数组：')
print (a)
print ('\n')
b = np.array([[5,6],[7,8]])
 
print ('第二个数组：')
print (b)
print ('\n')
 
print ('沿轴 0 堆叠两个数组：')
print (np.stack((a,b),0))
print ('\n')
 
print ('沿轴 1 堆叠两个数组：')
print (np.stack((a,b),1))

#输出结果
第一个数组：
[[1 2]
 [3 4]]


第二个数组：
[[5 6]
 [7 8]]


沿轴 0 堆叠两个数组：
[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]


沿轴 1 堆叠两个数组：
[[[1 2]
  [5 6]]

 [[3 4]
  [7 8]]]

numpy.hstack

numpy.hstack 是 numpy.stack 函数的变体，它通过水平堆叠来生成数组。

import numpy as np
 
a = np.array([[1,2],[3,4]])
 
print ('第一个数组：')
print (a)
print ('\n')
b = np.array([[5,6],[7,8]])
 
print ('第二个数组：')
print (b)
print ('\n')
 
print ('水平堆叠：')
c = np.hstack((a,b))
print (c)
print ('\n')

#输出结果
第一个数组：
[[1 2]
 [3 4]]


第二个数组：
[[5 6]
 [7 8]]


水平堆叠：
[[1 2 5 6]
 [3 4 7 8]]

numpy.vstack

numpy.vstack 是 numpy.stack 函数的变体，它通过垂直堆叠来生成数组

import numpy as np
 
a = np.array([[1,2],[3,4]])
 
print ('第一个数组：')
print (a)
print ('\n')
b = np.array([[5,6],[7,8]])
 
print ('第二个数组：')
print (b)
print ('\n')
 
print ('竖直堆叠：')
c = np.vstack((a,b))
print (c)

#输出结果
第一个数组：
[[1 2]
 [3 4]]


第二个数组：
[[5 6]
 [7 8]]


竖直堆叠：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

---

分割数组(split、hsplit、vsplit)

numpy.split

numpy.split 函数沿特定的轴将数组分割为子数组

numpy.split(ary, indices_or_sections, axis)

• ary：被分割的数组
• indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
• axis：设置沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向。

import numpy as np
 
a = np.arange(9)
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('将数组分为三个大小相等的子数组：')
b = np.split(a,3)
print (b)
print ('\n')
 
print ('将数组在一维数组中表明的位置分割：')
b = np.split(a,[4,7])
print (b)

#输出结果
第一个数组：
[0 1 2 3 4 5 6 7 8]


将数组分为三个大小相等的子数组：
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]


将数组在一维数组中表明的位置分割：
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]

numpy.hsplit

numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组

import numpy as np
 
harr = np.floor(10 * np.random.random((2, 6)))
print ('原array：')
print(harr)
 
print ('拆分后：')
print(np.hsplit(harr, 3))

#输出结果
原array：
[[4. 7. 6. 3. 2. 6.]
 [6. 3. 6. 7. 9. 7.]]
拆分后：
[array([[4., 7.],
       [6., 3.]]), array([[6., 3.],
       [6., 7.]]), array([[2., 6.],
       [9., 7.]])]

numpy.vsplit

numpy.vsplit 沿着垂直轴分割

import numpy as np
 
a = np.arange(16).reshape(4,4)
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('竖直分割：')
b = np.vsplit(a,2)
print (b)

#输出结果
第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]


竖直分割：
[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]

---

数组元素的添加与删除(resize、append、insert、delete、unique)

numpy.resize

numpy.resize 函数返回指定大小的新数组。

numpy.resize(arr, shape)

• arr：要修改大小的数组
• shape：返回数组的新形状

import numpy as np
 
a = np.array([[1,2,3],[4,5,6]])
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('第一个数组的形状：')
print (a.shape)
print ('\n')
b = np.resize(a, (3,2))
 
print ('第二个数组：')
print (b)
print ('\n')
 
print ('第二个数组的形状：')
print (b.shape)
print ('\n')
# 要注意 a 的第一行在 b 中重复出现，因为尺寸变大了
 
print ('修改第二个数组的大小：')
b = np.resize(a,(3,3))
print (b)

#输出结果
第一个数组：
[[1 2 3]
 [4 5 6]]


第一个数组的形状：
(2, 3)


第二个数组：
[[1 2]
 [3 4]
 [5 6]]


第二个数组的形状：
(3, 2)


修改第二个数组的大小：
[[1 2 3]
 [4 5 6]
 [1 2 3]]

numpy.append

numpy.append 函数在数组的末尾添加值。 追加操作会分配整个数组，并把原来的数组复制到新数组中。

append 函数返回的始终是一个一维数组。

numpy.append(arr, values, axis=None)

• arr：输入数组
• values：要向arr添加的值，需要和arr形状相同（除了要添加的轴）
• axis：默认为 None。当axis无定义时，是横向加成，返回总是为一维数组！当axis有定义的时候，分别为0和1的时候。当axis有定义的时候，分别为0和1的时候（列数要相同）。当axis为1时，数组是加在右边（行数要相同）。

import numpy as np
 
a = np.array([[1,2,3],[4,5,6]])
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('向数组添加元素：')
print (np.append(a, [7,8,9]))
print ('\n')
 
print ('沿轴 0 添加元素：')
print (np.append(a, [[7,8,9]],axis = 0))
print ('\n')
 
print ('沿轴 1 添加元素：')
print (np.append(a, [[5,5,5],[7,8,9]],axis = 1))

#输出结果
第一个数组：
[[1 2 3]
 [4 5 6]]


向数组添加元素：
[1 2 3 4 5 6 7 8 9]


沿轴 0 添加元素：
[[1 2 3]
 [4 5 6]
 [7 8 9]]


沿轴 1 添加元素：
[[1 2 3 5 5 5]
 [4 5 6 7 8 9]]

numpy.insert

numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值。

numpy.insert(arr, obj, values, axis)

• arr：输入数组
• obj：在其之前插入值的索引
• values：要插入的值
• axis：沿着它插入的轴，如果未提供，则输入数组会被展开

import numpy as np
 
a = np.array([[1,2],[3,4],[5,6]])
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('未传递 Axis 参数。 在删除之前输入数组会被展开。')
print (np.insert(a,3,[11,12]))
print ('\n')
print ('传递了 Axis 参数。 会广播值数组来配输入数组。')
 
print ('沿轴 0 广播：')
print (np.insert(a,1,[11],axis = 0))
print ('\n')
 
print ('沿轴 1 广播：')
print (np.insert(a,1,11,axis = 1))

#输出结果
第一个数组：
[[1 2]
 [3 4]
 [5 6]]


未传递 Axis 参数。 在删除之前输入数组会被展开。
[ 1  2  3 11 12  4  5  6]


传递了 Axis 参数。 会广播值数组来配输入数组。
沿轴 0 广播：
[[ 1  2]
 [11 11]
 [ 3  4]
 [ 5  6]]


沿轴 1 广播：
[[ 1 11  2]
 [ 3 11  4]
 [ 5 11  6]]

numpy.delete

numpy.delete 函数返回从输入数组中删除指定子数组的新数组。

Numpy.delete(arr, obj, axis)

• arr：输入数组
• obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
• axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开

import numpy as np
 
a = np.arange(12).reshape(3,4)
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print (np.delete(a,5))
print ('\n')
 
print ('删除第二列：')
print (np.delete(a,1,axis = 1))
print ('\n')
 
print ('包含从数组中删除的替代值的切片：')
a = np.array([1,2,3,4,5,6,7,8,9,10])
print (np.delete(a, np.s_[::2]))

#输出结果
第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]


未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 0  1  2  3  4  6  7  8  9 10 11]


删除第二列：
[[ 0  2  3]
 [ 4  6  7]
 [ 8 10 11]]


包含从数组中删除的替代值的切片：
[ 2  4  6  8 10]

numpy.unique

numpy.unique 函数用于去除数组中的重复元素

numpy.unique(arr, return_index, return_inverse, return_counts)

• arr：输入数组，如果不是一维数组则会展开
• return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
• return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
• return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数

import numpy as np
 
a = np.array([5,2,6,2,7,5,6,8,2,9])
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('第一个数组的去重值：')
u = np.unique(a)
print (u)
print ('\n')
 
print ('去重数组的索引数组：')
u,indices = np.unique(a, return_index = True)
print (indices)
print ('\n')
 
print ('我们可以看到每个和原数组下标对应的数值：')
print (a)
print ('\n')
 
print ('去重数组的下标：')
u,indices = np.unique(a,return_inverse = True)
print (u)
print ('\n')
 
print ('下标为：')
print (indices)
print ('\n')
 
print ('使用下标重构原数组：')
print (u[indices])
print ('\n')
 
print ('返回去重元素的重复数量：')
u,indices = np.unique(a,return_counts = True)
print (u)
print (indices)

#输出结果
第一个数组：
[5 2 6 2 7 5 6 8 2 9]


第一个数组的去重值：
[2 5 6 7 8 9]


去重数组的索引数组：
[1 0 2 4 7 9]


我们可以看到每个和原数组下标对应的数值：
[5 2 6 2 7 5 6 8 2 9]


去重数组的下标：
[2 5 6 7 8 9]


下标为：
[1 0 2 0 3 1 2 4 0 5]


使用下标重构原数组：
[5 2 6 2 7 5 6 8 2 9]


返回去重元素的重复数量：
[2 5 6 7 8 9]
[3 2 2 1 1 1]

---

numpy位运算(bitwise_and、bitwise_or、invert、left_shift、right_shift)

numpy.bitwise_and

bitwise_and() 函数对数组中整数的二进制形式执行位与运算。

位与操作运算规律如下：

A	B	AND
1	1	1
1	0	0
0	1	0
0	0	0

import numpy as np 
 
print ('13 和 17 的二进制形式：')
a,b = 13,17
print (bin(a), bin(b))
print ('\n')
 
print ('13 和 17 的位与：')
print (np.bitwise_and(13, 17))

#输出结果
13 和 17 的二进制形式：
0b1101 0b10001

13 和 17 的位与：
1

numpy.bitwise_or

bitwise_or()函数对数组中整数的二进制形式执行位或运算。

A	B	OR
1	1	1
1	0	1
0	1	1
0	0	0

import numpy as np 
 
a,b = 13,17 
print ('13 和 17 的二进制形式：')
print (bin(a), bin(b))
 
print ('13 和 17 的位或：')
print (np.bitwise_or(13, 17))

#输出结果
13 和 17 的二进制形式：
0b1101 0b10001

13 和 17 的位或：
29

invert

invert() 函数对数组中整数进行位取反运算，即 0 变成 1，1 变成 0。

对于有符号整数，取该二进制数的补码，然后 +1。二进制数，最高位为0表示正数，最高位为 1 表示负数。

看看 ~1 的计算步骤：

• 将1(这里叫：原码)转二进制 ＝ 00000001
• 按位取反 ＝ 11111110
• 发现符号位(即最高位)为1(表示负数)，将除符号位之外的其他数字取反 ＝ 10000001
• 末位加1取其补码 ＝ 10000010
• 转换回十进制 ＝ -2

对于没有符号的整数

import numpy as np 
 
print ('13 的位反转，其中 ndarray 的 dtype 是 uint8：')
print (np.invert(np.array([13], dtype = np.uint8)))
print ('\n')
# 比较 13 和 242 的二进制表示，我们发现了位的反转
 
print ('13 的二进制表示：')
print (np.binary_repr(13, width = 8))
print ('\n')
 
print ('242 的二进制表示：')
print (np.binary_repr(242, width = 8))

#输出结果
13 的位反转，其中 ndarray 的 dtype 是 uint8：
[242]

13 的二进制表示：
00001101

242 的二进制表示：
11110010

left_shift（左移右加0）

left_shift() 函数将数组元素的二进制形式向左移动到指定位置，右侧附加相等数量的 0。

import numpy as np 
 
print ('将 10 左移两位：')
print (np.left_shift(10,2))
print ('\n')
 
print ('10 的二进制表示：')
print (np.binary_repr(10, width = 8))
print ('\n')
 
print ('40 的二进制表示：')
print (np.binary_repr(40, width = 8))
#  '00001010' 中的两位移动到了左边，并在右边添加了两个 0。

#输出结果
将 10 左移两位：
40

10 的二进制表示：
00001010

40 的二进制表示：
00101000

right_shift（右移左加0）

right_shift() 函数将数组元素的二进制形式向右移动到指定位置，左侧附加相等数量的 0。

import numpy as np 
 
print ('将 40 右移两位：')
print (np.right_shift(40,2))
print ('\n')
 
print ('40 的二进制表示：')
print (np.binary_repr(40, width = 8))
print ('\n')
 
print ('10 的二进制表示：')
print (np.binary_repr(10, width = 8))
#  '00001010' 中的两位移动到了右边，并在左边添加了两个 0。

#输出结果
将 40 右移两位：
10

40 的二进制表示：
00101000

10 的二进制表示：
00001010

---

numpy字符串函数(add、multiply、center、capitalize、title、lower、upper、split、splitlines、strip、join、replace、decode、encode)

numpy.char.add

numpy.char.add() 函数依次对两个数组的元素进行字符串连接。

import numpy as np 
 
print ('连接两个字符串：')
print (np.char.add(['hello'],[' xyz']))
print ('\n')
 
print ('连接示例：')
print (np.char.add(['hello', 'hi'],[' abc', ' xyz']))

#输出结果
连接两个字符串：
['hello xyz']

连接示例：
['hello abc' 'hi xyz']

numpy.char.multiply

numpy.char.multiply() 函数执行多重连接。

import numpy as np 
 
print (np.char.multiply('Runoob ',3))

#输出结果
Runoob Runoob Runoob 

numpy.char.cacenter

numpy.char.center() 函数用于将字符串居中，并使用指定字符在左侧和右侧进行填充。

import numpy as np 
 
# np.char.center(str , width,fillchar) ：
# str: 字符串，width: 长度，fillchar: 填充字符
print (np.char.center('Runoob', 20,fillchar = '*'))

#输出结果
*******Runoob*******

numpy.char.capitalize

numpy.char.capitalize() 函数将字符串的第一个字母转换为大写

import numpy as np 
 
print (np.char.capitalize('runoob'))

#输出结果
Runoob

numpy.char.title

numpy.char.title() 函数将字符串的每个单词的第一个字母转换为大写

import numpy as np
 
print (np.char.title('i like runoob'))

#输出结果
I Like Runoob

numpy.char.lower

numpy.char.lower() 函数对数组的每个元素转换为小写

import numpy as np 
 
#操作数组
print (np.char.lower(['RUNOOB','GOOGLE']))
 
# 操作字符串
print (np.char.lower('RUNOOB'))

#输出结果
['runoob' 'google']
runoob

numpy.char.upper

numpy.char.upper() 函数对数组的每个元素转换为大写

import numpy as np 
 
#操作数组
print (np.char.upper(['runoob','google']))
 
# 操作字符串
print (np.char.upper('runoob'))

#输出结果
['RUNOOB' 'GOOGLE']
RUNOOB

numpy.char.split

numpy.char.split() 通过指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格。

import numpy as np 
 
# 分隔符默认为空格
print (np.char.split ('i like runoob?'))
# 分隔符为 .
print (np.char.split ('www.runoob.com', sep = '.'))

#输出结果
['i', 'like', 'runoob?']
['www', 'runoob', 'com']

 numpy.char.splitlines

numpy.char.splitlines() 函数以换行符作为分隔符来分割字符串，并返回数组。

\n，\r，\r\n 都可用作换行符。

import numpy as np 
 
# 换行符 \n
print (np.char.splitlines('i\nlike runoob?')) 
print (np.char.splitlines('i\rlike runoob?'))

#输出结果
['i', 'like runoob?']
['i', 'like runoob?']

numpy.char.strip

numpy.char.strip() 函数用于移除开头或结尾处的特定字符。

import numpy as np 
 
# 移除字符串头尾的 a 字符
print (np.char.strip('ashok arunooba','a'))
 
# 移除数组元素头尾的 a 字符
print (np.char.strip(['arunooba','admin','java'],'a'))

#输出结果
shok arunoob
['runoob' 'dmin' 'jav']

numpy.char.join

numpy.char.join() 函数通过指定分隔符来连接数组中的元素或字符串

import numpy as np 
 
# 操作字符串
print (np.char.join(':','runoob'))
 
# 指定多个分隔符操作数组元素
print (np.char.join([':','-'],['runoob','google']))

#输出结果
r:u:n:o:o:b
['r:u:n:o:o:b' 'g-o-o-g-l-e']

numpy.char.replace

numpy.char.replace() 函数使用新字符串替换字符串中的所有子字符串。

import numpy as np 
 
print (np.char.replace ('i like runoob', 'oo', 'cc'))

#输出结果
i like runccb

numpy.char.encode

numpy.char.encode() 函数对数组中的每个元素调用 str.encode 函数。 默认编码是 utf-8

import numpy as np 
 
a = np.char.encode('runoob', 'cp500') 
print (a)

#输出结果
b'\x99\xa4\x95\x96\x96\x82'

numpy.char.decode

numpy.char.decode() 函数对编码的元素进行 str.decode() 解码。

import numpy as np 
 
a = np.char.encode('runoob', 'cp500') 
print (a)
print (np.char.decode(a,'cp500'))

#输出结果
b'\x99\xa4\x95\x96\x96\x82'
runoob

---