跳转至

8.1.创建数组

import numpy as np
import pprint

Linux 5.4.0-74-generic
Python 3.9.5 @ GCC 7.3.0
Latest build date 2021.06.16
numpy version:  1.20.3

共同的参数

这里有几个共同的参数：

  • a / object：一个 array-like 类型的对象，它不一定是数组，可以为list、tuple、list of tuple、list of list、tuple of list、tuple of tuple等等。

  • dtype：数组的值类型，默认为float。可以指定为 Python 的内置的值类型，也可以使用 numpy 的数值类型，如numpy.int32、numpy.float64等等。

  • order：指定数组的内存布局，如果 object 是一个数组，则'C'、'F'参数可用，如果 object 不是数组，则以下四个参数都可用，默认值为'C'。

    1. 'C'：按行存储，C 风格。
    2. 'F'：按列存储，Fortran 风格。
    3. 'A'：保留 F order 或 C order，否则使用相似的顺序。
    4. 'K'：如果 object 是 F order，则保留 F order，否则使用 C order。

  • subok：bool. 当subok=True，如果a为ndarray的子类（如matrix类），则新创建的数组与a类型相同。当subok=False，新创建的数组的类型始终为ndarray。默认为False。

从现有的数据对象创建

np.array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0)

从 object 创建 array。

  • object：可以是数组对象、嵌套序列、一个有__array__方法的对象，该方法返回 array 或者 array-like 对象。
  • copy：默认为True，表示拷贝对象，若为False，则仅当传入非 array 对象、__array__方法返回副本、需要满足dtype、order参数时才会拷贝。
  • ndmin：指定结果ndarray最少有多少个维度。
np.asarray(a, dtype=None, order=None) - 将 a 转换为 ndarray 
return array(a, dtype, copy=False, order=order)
np.asanyarray(a, dtype=None, order=None) - 将 a 转换为 ndarray 
return array(a, dtype, copy=False, order=order, subok=True)

np.asanyarray与np.asarray的区别在于 subok 参数。

np.ascontiguousarray(a, dtype=None) - 返回 C 风格的连续 ndarray 
return array(a, dtype, copy=False, order='C', ndmin=1)

返回的数组的 ndim 至少是1维的，即对于标量，不保留 0-d 数组。

np.asfortranarray(a, dtype=None) - 返回 Fortran 风格的连续 ndarray 
return array(a, dtype, copy=False, order='F', ndmin=1)

返回的数组的 ndim 至少是1维的，即对于标量，不保留 0-d 数组。

np.copy(a, order='K', subok=False) - 返回 a 的深拷贝 
return array(a, order=order, copy=True)
np.asmatrix(data, dtype=None) - 返回 matrix

等价于以下代码 

matrix(data, copy=False)

np.asarray_chkfinite(a, dtype=None, order=None) - 创建数组时检查是否存在nan或Infs 
try:
    np.asarray_chkfinite([np.nan, 1, 2])
except ValueError as e:
    print("ValueError", e)

ValueError array must not contain infs or NaNs
np.asscalar(a) - 将大小为1的数组转为标量

NumPy v1.16 之后建议使用a.item()代替该函数。

print(np.asscalar(np.array([1])))

1
<ipython-input-1-3f4c1e63f66b>:2: DeprecationWarning: np.asscalar(a)
is deprecated since NumPy v1.16, use a.item() instead
  print(np.asscalar(np.array([1])))
np.frombuffer(buffer, dtype=float, count=-1, offset=0)

从 buffer 中返回一维的 ndarray，创建的数组与 buffer 对象共享内存。

  • buffer：一个有 buffer 接口的对象。内置的 bytes/bytearray/array.array 类型提供了该接口。
  • count：指定读取的数量，-1表示读取 buffer 的全部数据。
  • offset：指定从哪里开始读取，以 bytes 为单位，默认为 0。
# array.array 提供了类似list对象的内存机制
from array import array

# 创建一个array数组
a = array("d", [1, 2, 3, 4])
# 通过 np.frombuffer 创建一个和 a 共享内存的 NumPy 数组
b = np.frombuffer(a, dtype=np.float64)
print("a:", a)
print("b:", b)
b[1] = 20       # 修改NumPy数组中的第一个元素
print("a:", a)  # array数组中的第一个元素也同时改变

a: array('d', [1.0, 2.0, 3.0, 4.0])
b: [1. 2. 3. 4.]
a: array('d', [1.0, 20.0, 3.0, 4.0])
np.fromfunction(function, shape, *, dtype=float, **kwargs)

function 会获取每一个坐标点的数据，作为输入参数。假设 shape 的维度为 N，那么 function 将有 N 个参数，function(x1,x2,...x_N)作为该坐标点的值。

def fun(x, y):
    return x + y

np.fromfunction(fun, shape=(3, 3))

array([[0., 1., 2.],
       [1., 2., 3.],
       [2., 3., 4.]])
np.fromiter(iterable, dtype, count=-1) - 从可迭代对象创建 1-d 的数组 
np.fromiter("123", dtype="int64")

array([1, 2, 3])
np.fromstring(string, dtype=float, count=-1, sep='') - 从字符串或raw binary创建 1-d 数组
  • sep：如果sep=""，则 string 将按照二进制数据解释（即每个字符作为ASCII码值对待）， 不建议 触发二进制模式。创建的数组有自己的数据存储区。
a = "abcdefg"
# 触发二进制模式, 每个字符的ASCII编码被解释为整数
a = np.fromstring(a, dtype=np.int8)
print(a)

a = "1;2;3;4;5"
a = np.fromstring(a, dtype=np.int8, sep=";")
print(a)

[ 97  98  99 100 101 102 103]
[1 2 3 4 5]
<ipython-input-1-ad8737ef7b85>:4: DeprecationWarning: The binary mode of fromstring is deprecated, as it behaves surprisingly on unicode inputs. Use frombuffer instead
  a = np.fromstring(a, dtype=np.int8)
np.require(a, dtype=None, requirements=None) - 返回满足指定条件的数组
  • requirements: str or list of str. 可取值如下：
    1. 'F' / 'F_CONTIGUOUS' - ensure a Fortran-contiguous array
    2. 'C' / 'C_CONTIGUOUS' - ensure a C-contiguous array
    3. 'A' / 'ALIGNED' - ensure a data-type aligned array
    4. 'W' / 'WRITEABLE' - ensure a writable array
    5. 'O' / 'OWNDATA' - ensure an array that owns its own data
    6. 'E' / 'ENSUREARRAY' - ensure a base array, instead of a subclass

创建元素重复的数组

np.tile(A, reps) - 重复A数组以构建新数组
  • reps：如果是整数，代表每个元素的重复次数。如果是整数数组，则代表对应轴的重复次数。
a = np.array([0, 1, 2])
print(np.tile(a, 2), "\n-----")
print(np.tile(a, (2, 2)), "\n-----")
print(np.tile(a, (2, 1, 2)))

[0 1 2 0 1 2]
-----
[[0 1 2 0 1 2]
 [0 1 2 0 1 2]]
-----
[[[0 1 2 0 1 2]]

 [[0 1 2 0 1 2]]]

b = np.array([[1, 2], [3, 4]])
print(np.tile(b, 2), "\n-----")
print(np.tile(b, (2, 1)))

[[1 2 1 2]
 [3 4 3 4]]
-----
[[1 2]
 [3 4]
 [1 2]
 [3 4]]
np.repeat(a, repeats, axis=None) - 重复A数组以构建新数组
  • repeats：如果是整数，则每个元素都重复repeats次。如果是整数数组，则分别指定各元素的重复次数。
a = np.array([0, 1, 2])
print(np.repeat(a, 2), "\n-----")
print(np.repeat(a, [1, 2, 3]))

[0 0 1 1 2 2]
-----
[0 1 1 2 2 2]

从文件加载

np.fromfile(file, dtype=float, count=-1, sep='', offset=0)

从二进制文件或者文本文件中的数据构造 ndarray。

  • sep：当从文本文件中读取时，数值之间的分隔符。 如果sep是空字符串则表示文件应该作为二进制文件读取；如果sep为" "表示可以匹配0个或者多个空白字符。
np.loadtxt - 从文本文件中加载数组 
np.loadtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None,
           converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0,
           encoding='bytes', max_rows=None)

要求文本文件每一行都有相同数量的数值

  • comments：指示注释行的起始字符，可以为单个字符或者字符列表（默认为#）。
  • delimiter：指定数值之间的分隔字符串，默认为空白符。
  • converters：将指定列号 (0,1,2...) 的列数据执行转换，是一个map，如{0:func1}表示对第一列数据执行func1(val_0)。
  • skiprows：指定跳过开头的多少行。
  • usecols：指定读取那些列（0表示第一列。

从数值区间创建

np.arange([start,] stop[, step,], dtype=None) - 返回均匀间隔的值组成的 1-d 数组

区间是半闭半开的 [start,stop)，其行为类似 range 函数。start为开始点，stop为终止点，step为步长，默认为1。这三个参数可以是整数或浮点数。如果step为浮点数，结果可能有误差，因为浮点数相等比较不准确（计算机精度有限）。

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

返回num个均匀采样的数值组成的 1-d 数组，区间是闭区间[start,stop]。

  • endpoint：是否包含stop。
  • retstep：如果为True，则返回的结果包含采样步长 step。
  • axis：用于储存采样点的 axis，默认为 0，仅当 start 和 stop 是 array-like 时生效。于 1.16.0 版本加入。

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

返回num个均匀采样的对数数值组成的 1-d 数组，采样点开始于base^start，结束于base^stop。辑上相当于先执行arange获取数组array，然后再执行base^array[i]获取采样点。

  • base：对数的底数。
  • axis：用于储存采样点的 axis，默认为 0，仅当 start 和 stop 是 array-like 时生效。

以填充的方式创建

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

根据指定的 shape 和 dtype 创建 array，但不初始化，其元素的值是随机的。

np.empty_like(a, dtype=None, order='K', subok=True, shape=None)

根据 a 的 shape 和 dtype 创建 array，但不初始化，其元素的值是随机的。

np.zeros(shape, ...) - 类似 np.empty，但元素的初始值为 0

np.ones(shape, ...) - 类似 np.empty，但元素的初始值为 1

np.full(shape, fill_value, ...) - 类似 np.empty，但元素的初始值为 fill_value

np.zeros_like(a, ...) - 类似 np.empty_like，但元素的初始值为 0

np.ones_like(a, ...) - 类似 np.empty_like，但元素的初始值为 1

np.full_like(a, fill_value, ...) - 类似 np.empty_like，但元素的初始值为 fill_value 
# 内存未初始化
a = np.empty((3, 2), order="C")

# 内存未初始化
np.empty_like(a)

array([[0.e+000, 5.e-324],
       [5.e-324, 1.e-323],
       [1.e-323, 1.e-323]])
np.eye(N, M=None, k=0, dtype=float, order='C') - 返回一个 2-D 数组，对角线元素1，其余元素为0
  • N：行数
  • M：列数，若不传入M，则N=M
  • k：k=0，主对角线元素为1；k为正整数，对应的上对角线元素为1；k为负整数，对应的下对角线元素为1
pprint.pprint(np.eye(N=2, M=3))
print()
# 参数 k 是可以超出范围的
pprint.pprint(np.eye(N=2, M=3, k=1))

array([[1., 0., 0.],
       [0., 1., 0.]])

array([[0., 1., 0.],
       [0., 0., 1.]])

np.identity(n, dtype=None) - 返回一个单位矩阵