Numpy创建数组

创建 ndarray 数组的基本方法，除了使用 array() 方法外，NumPy 还提供了其他创建 ndarray 数组的方法。

numpy.empty()

numpy.empty() 创建未初始化的数组，可以指定创建数组的形状（shape）和数据类型（dtype）

语法格式：

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

它接受以下参数：
shape：指定数组的形状；
dtype：数组元素的数据类型，默认值是值 float；
order：指数组元素在计算机内存中的储存顺序，默认顺序是“C”(行优先顺序)。

1
2
3
import numpy as np 
arr = np.empty((3,2), dtype = int) 
print(arr)

切记 empty 并非创建空数组。

numpy.zeros()

该函数用来创建元素均为 0 的数组，同时还可以指定被数组的形状
语法格式：
numpy. zeros(shape,dtype=float,order=”C”)

shape指定数组的形状大小。
dtype可选项，数组的数据类型
order“C”代表以行顺序存储，“F”则表示以列顺序存储

1
2
3
4
5
6
import numpy as np
#默认数据类型为浮点数
a=np.zeros(6)
print(a)
b=np.zeros(6,dtype="complex64" )
print(b)

也可以使用自定义的数据类型创建数组

1
2
3
c = np.zeros((3,3), dtype = [('x', 'i4'), ('y', 'i4')]) 
print(c)
#输出x,y，并指定的数据类型
numpy.ones()

返回指定形状大小与数据类型的新数组，并且新数组中每项元素均用 1 填充
numpy.ones(shape, dtype = None, order = ‘C’)

1
2
3
import numpy as np 
arr1 = np.ones((3,2), dtype = int) 
print(arr1)
numpy.asarray()

asarray() 与 array() 类似，但是它比 array() 更为简单。asarray() 能够将一个 Python 序列转化为 ndarray 对象

语法格式：
numpy.asarray（sequence，dtype = None ，order = None ）

sequence：接受一个 Python 序列，可以是列表或者元组；
dtype：可选参数，数组的数据类型；
order：数组内存布局样式，可以设置为 C 或者 F，默认是 C。

1
2
3
4
5
import numpy as np 
l=[1,2,3,4,5,6,7] 
a = np.asarray(l); 
print(type(a)) 
print(a)

使用嵌套列表创建多维数组：

1
2
3
4
5
import numpy as np 
l=[[1,2,3,4,5,6,7],[8,9]] 
a = np.asarray(l); 
print(type(a)) 
print(a)
numpy.frombuffer()

表示使用指定的缓冲区创建数组

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

buffer：将任意对象转换为流的形式读入缓冲区；
dtype：返回数组的数据类型，默认是
float32；count：要读取的数据数量，默认为 -1 表示读取所有数据；
offset：读取数据的起始位置，默认为 0。

1
2
3
4
5
6
7
import numpy as np 
#字节串类型
l = b'hello world' 
print(type(l)) 
a = np.frombuffer(l, dtype = "S1") 
print(a) 
print(type(a))
numpy.fromiter()

该方法可以把迭代对象转换为 ndarray 数组，其返回值是一个一维数组。

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

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

1
2
3
4
5
6
7
8
9

import numpy as np
# 使用 range 函数创建列表对象 
list=range(6)
#生成可迭代对象i
i=iter(list)
#使用i迭代器，通过fromiter方法创建ndarray
array=np.fromiter(i, dtype=float)
print(array)

NumPy创建区间数组

所谓区间数组，是指数组元素的取值位于某个范围内，并且数组元素之间可能会呈现某种规律，比如等比数列、递增、递减等。

  1. numpy.arange()

可以使用 arange() 来创建给定数值范围的数组

语法格式：numpy.arange(start, stop, step, dtype)

start起始值，默认是 0。
stop终止值，注意生成的数组元素值不包含终止值。

step步长，默认为 1。
dtype可选参数，指定 ndarray 数组的数据类型。

1
2
3
import numpy as np
x = np.arange(8) 
print (x)

设置 start 、stop 值以及步长，最终输出 0-10 中的奇数：

1
2
3
import numpy as np
x = np.arange(1,10,2) 
print (x)
  1. numpy.linspace()

表示在指定的数值区间内，返回均匀间隔的一维等差数组，默认均分 50 份

语法格式：
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

start：代表数值区间的起始值；
stop：代表数值区间的终止值；
num：表示数值区间内要生成多少个均匀的样本。默认值为 50；
endpoint：默认为 True，表示数列包含 stop 终止值，反之不包含；
retstep：默认为 True，表示生成的数组中会显示公差项，反之不显示；
dtype：代表数组元素值的数据类型。

1
2
3
4
import numpy as np
#生成10个样本
a = np.linspace(1,10,10)
print(a)
  1. numpy.logspace

该函数同样返回一个 ndarray 数组，它用于创建等比数组

语法格式：

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

其中 base 代表对数函数的底数，默认为 10。
start 序列的起始值：basestart。
stop 序列的终止值：basestop。
num 数值范围区间内样本数量，默认为 50。
endpoint 默认为 True 包含终止值，反之不包含。
base 对数函数的 log 底数，默认为10。
dtype 可选参数，指定 ndarray 数组的数据类型

1
2
3
import numpy as np
a = np.logspace(1.0,2.0, num = 10)
print (a)

Numpy索引和切片

在 NumPy 中，如果想要访问，或修改数组中的元素，您可以采用索引或切片的方式，比如使用从 0 开始的索引依次访问数组中的元素，这与 Python 的 list 列表是相同的。

NumPy 提供了多种类型的索引方式，常用方式有两种：基本切片与高级索引

基本切片

NumPy 内置函数 slice() 可以用来构造切片对象，该函数需要传递三个参数值分别是 start（起始索引）、stop（终止索引） 和 step（步长） ，通过它可以实现从原数组的上切割出一个新数组。

1
2
3
4
5
import numpy as np
a = np.arange(5,100)
#生成切片对象
s = slice(2,9,3)#从索引2开始到索引9停止，间隔时间为2
print(a[s])

也可以通过冒号来分割切片参数，最终也能获得相同结果

1
2
3
4
import numpy as np
a = np.arange(10)
b = a[2:9:2]
print(b)

NumPy高级索引

在 NumPy 中还可以使用高级索引方式，比如整数数组索引、布尔索引以及花式索引

整数数组索引

整数数组索引，它可以选择数组中的任意一个元素，比如，选择第几行第几列的某个元素

1
2
3
4
5
6
import numpy as np
#创建二维数组
x = np.array([[1,  2],  [3,  4],  [5,  6]])
#[0,1,2]代表行索引;[0,1,0]代表列索引
y = x[[0,1,2],[0,1,0]] 
print (y)

对上述示例做简单分析：将行、列索引组合会得到 (0,0)、(1,1) 和 (2,0)
它们分别对应着输出结果在原数组中的索引位置

下面再看一组示例：获取了 4*3 数组中的四个角上元素，它们对应的行索引是 [0,0] 和 [3,3]，列索引是 [0,2] 和 [0,2]。

1
2
3
4
5
6
7
8
9
10
import numpy as np
b = np.array([[ 0, 1, 2],
              [ 3, 4, 5],
              [ 6, 7, 8],
              [ 9,10,11]])
r = np.array([[0,0],[3,3]])
c = np.array([[0,2],[0,2]])
#获取四个角的元素
c = b[r,c]
print(c)

也可以将切片所使用的:或省略号…与整数数组索引结合使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import numpy as np
d = np.array([[ 0,  1,  2],
              [ 3,  4,  5],
              [ 6,  7,  8],
              [ 9, 10, 11]])
#对行列分别进行切片
e = d[1:4,1:3]
print(e)
#行使用基础索引，对列使用高级索引
f = d[1:4,[1,2]]
#显示切片后结果
print (f)
#对行使用省略号
h=d[...,1:]
print(h)
布尔数组索引

当输出的结果需要经过布尔运算（如比较运算）时，此时会使用到另一种高级索引方式，即布尔数组索引。

下面示例返回数组中大于 6 的的所有元素：

1
2
3
4
#返回所有大于6的数字组成的数组
import numpy as np
x = np.array([[ 0,  1,  2],[ 3,  4,  5],[ 6,  7,  8],[ 9, 10, 11]])
print (x[x > 6])

我们可以使用补码运算符来去除 NaN（即非数字元素）

1
2
3
import numpy as np
a = np.array([np.nan, 1,2,np.nan,3,4,5])
print(a[~np.isnan(a))

下面示例，删除数组中整数元素，如下所示：

1
2
3
import numpy as np
a = np.array([1, 2+6j, 5, 3.5+5j])
print( a[np.iscomplex(a)])