numpy 数组对象的创建生成
概要
本文对numpy数组对象进行简要介绍，同时对其各种创建与生成方式进行梳理。
数组对象
N 维数组类型，即 ndarray，描述了相同类型「元素」集合。ndarray是python中list的扩展。
对象签名如下：
numpy.ndarray(shape, dtype=float, buffer=None, offset=0, strides=None, order=None)
• shape：整数元组，表示形状
• dtype：数据类型对象
• buffer：使用 buffer 中的数据填充 ndarray
• offset：buffer 中的偏移量
• stride：内存中数据跨度
• order：行为主（C-Style）或列为主（Fortran-Style）
np.ndarray(shape=(2,), dtype=int, offset=8,buffer=np.array([1,2,3,4]),strides=(8, ),order="C")
array([2, 3])
在ndarray中所有元素必须是同一类型，否则会自动向下转换，int->float->str。
a = np.array([1, 2, 3, 4, 5])
print(a) # [1 2 3 4 5]
b = np.array([1, 2, 3, 4, '5'])
print(b) # ['1' '2' '3' '4' '5']
c = np.array([1, 2, 3, 4, 5.0])
print(c) # [1. 2. 3. 4. 5.]
array （数组）的创建和生成
从python列表或元组创建
重点掌握传入 list 创建一个 array 即可：np.array(list)
⚠️ 需要注意的是：「数据类型」第 2 个数字是「小数」（注：Python 中 1. == 1.0），而 array 是要保证每个元素类型相同的，所以会把 array 转为一个 float 的类型。
array()
#二维（多维类似）
np.array([[1, 2.,3],[4, 5, 6]])
输出 array([[1., 2., 3.],
[4., 5., 6.]])
#可以指定数据类型
np.array([1, 2, 3], dtype=np.float16)
输出array([1., 2., 3.], dtype=float16)
#tuple，一般用 list 就好，不需要使用 tuple
np.array([(1.1, 2.2, 3.3), (4.4, 5.5, 6.6)])
输出array([[1.1, 2.2, 3.3],
[4.4, 5.5, 6.6]])
array() & asarray()
(array()和asarray()主要区别:当数据源是ndarray 时，array()仍然会 copy 出一个副本，占用新的内存，但**不改变 dtype **时 asarray()不会。)
x = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]]) //数据源是array
y = np.array(x)
z = np.asarray(x)
w = np.asarray(x, dtype=np.int)
x[1][2] = 2
print(x,type(x),x.dtype)
# [[1 1 1]
# [1 1 2]
# [1 1 1]] <class 'numpy.ndarray'> int32
print(y,type(y),y.dtype)
# [[1 1 1]
# [1 1 1]
# [1 1 1]] <class 'numpy.ndarray'> int32
print(z,type(z),z.dtype)
# [[1 1 1]
# [1 1 2]
# [1 1 1]] <class 'numpy.ndarray'> int32
print(w,type(w),w.dtype)
# [[1 1 1]
# [1 1 2]
# [1 1 1]] <class 'numpy.ndarray'> int32
fromfunction()
tips:匿名函数lambda：是指一类无需定义标识符（函数名）的函数或子程序。
lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。
fromfunction(function, shape, dtype)
def f(x, y):
return 10 * x + y
x = np.fromfunction(f, (5, 4), dtype=int)
print(x)
# [[ 0 1 2 3]
# [10 11 12 13]
# [20 21 22 23]
# [30 31 32 33]
# [40 41 42 43]]
x = np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)
print(x)
# [[0 1 2]
# [1 2 3]
# [2 3 4]]
使用ones/zeros等填充方式创建
创建全 1/0 array 。
zeros()/ones()函数：返回给定形状和类型的零/1数组。
zeros/ones(shape, dtype=None, order=‘C’)
zeros_like()/ones_like()函数：返回与给定数组形状和类型相同的零/1数组。
zeros_like/ones_like(a, dtype=None, order=‘K’, subok=True, shape=None)
np.zeros((2,3,4))
array([[[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]],
[[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]]])
#像给定向量那样的 0 向量（ones_like 是 1 向量）
np.zeros_like(np.ones((2,3,3)))
创建空数组。
empty()函数：返回一个空数组，数组元素为随机数。
empty_like()函数：返回与给定数组具有相同形状和类型的新数组。
x = np.empty((3, 2))
print(x)
# [[1.60220393e-306 9.34587382e-307]
# [8.45599367e-307 7.56598449e-307]
# [1.33509389e-306 3.59412896e-317]]
创建单位数组。
eye()函数：返回一个对角线上为1，其它地方为零的单位数组。
eye(N, M=None, k=0, dtype=float, order=‘C’)
identity()函数：返回一个方的单位数组。
identity(n, dtype=None)
x = np.eye(2, 3)
print(x)
# [[1. 0. 0.]
# [0. 1. 0.]]
创建对角数组。
diag()函数：提取对角线或构造对角数组。
diag(v, k=0)
x = np.arange(9).reshape((3, 3))
print(x)
# [[0 1 2]
# [3 4 5]
# [6 7 8]]
print(np.diag(x)) # [0 4 8]
print(np.diag(x, k=1)) # [1 5]
print(np.diag(x, k=-1)) # [3 7]
v = [1, 3, 5, 7]
x = np.diag(v)
print(x)
# [[1 0 0 0]
# [0 3 0 0]
# [0 0 5 0]
# [0 0 0 7]]
创建常数数组。
full()函数：返回一个常数数组。full(shape, fill_value, dtype=None, order=‘C’)
full_like()函数：返回与给定数组具有相同形状和类型的常数数组。
full_like(a, fill_value, dtype=None, order=‘K’, subok=True, shape=None)
arr = np.full([3, 3], True, dtype=np.bool)
print(arr)
# [[ True True True]
# [ True True True]
# [ True True True]]
⚠️ 需要注意的是：创建出来的 array 默认是 float 类型。
利用数值范围创建ndarray
使用arange生成
arange()函数：返回给定间隔内的均匀间隔的值。arange([start,] stop[, step,], dtype=None)
⚠️ 需要注意：在 reshape 时，目标的 shape 需要的元素数量一定要和原始的元素数量相等
#注意，是小数哦
np.arange(12.0).reshape(4, 3)
array([[ 0., 1., 2.],
[ 3., 4., 5.],
[ 6., 7., 8.],
[ 9., 10., 11.]])
np.arange(100, 124, 2).reshape(3, 2, 2)
array([[[100, 102],
[104, 106]],
[[108, 110],
[112, 114]],
[[116, 118],
[120, 122]]])
使用linspace/logspace 生成
linspace()函数：返回指定间隔内的等间隔数字。
linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
logspace()函数：返回数以对数刻度均匀分布。
logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)
前者一般输入3 个参数：开头，结尾，数量；后者需额外传入一个 base，它默认是 10
⚠️ 需要注意的是：第三个参数并不是步长。
np.linspace(0, 9, 6).reshape(2, 3)
array([[0. , 1.8, 3.6],
[5.4, 7.2, 9. ]])
x = np.logspace(0, 1, 5)
print(np.around(x, 2))
# [ 1. 1.78 3.16 5.62 10. ]
#np.around 返回四舍五入后的值，可指定精度。
# around(a, decimals=0, out=None)
# a 输入数组
# decimals 要舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置
np.logspace(0, 9, 6, base=np.e).reshape(2, 3)
array([[1.00000000e+00, 6.04964746e+00, 3.65982344e+01],
[2.21406416e+02, 1.33943076e+03, 8.10308393e+03]])
#logspace 结果 log 后就是上面 linspace 的结果
np.log(_)
array([[0. , 1.8, 3.6],
[5.4, 7.2, 9. ]])
使用random.rand()生成
numpy.random.rand() 返回一个由[0,1)内的随机数组成的数组。rand(d0, d1, …, dn)
新的 API 方式创建，通过 np.random.default_rng() 先生成 Generator，然后再在此基础上生成各种分布的数据（记忆更加简便清晰）。依然介绍旧的 API 用法，因为很多代码中使用的还是旧的。
从文件读取
将本地图像导入并将其转换为numpy数组。
import numpy as np
from PIL import Image
img1 = Image.open('test.jpg')
a = np.array(img1)
print(a.shape, a.dtype)
# (959, 959, 3) uint8
存储时不需要写文件名后缀，会自动添加。
结构数组的创建
结构数组：先定义结构，再利用np.array()来创建数组，其参数dtype为定义的结构
1.利用字典来定义结构
personType = np.dtype({
'names': ['name', 'age', 'weight'],
'formats': ['U30', 'i8', 'f8']})
a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],dtype=personType)
print(a, type(a))
# [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]
# <class 'numpy.ndarray'>
2.利用包含多个元组的列表来定义结构
personType = np.dtype([('name', 'U30'), ('age', 'i8'), ('weight', 'f8')])
a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],dtype=personType)
print(a, type(a))
# [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]
# <class 'numpy.ndarray'>
结构数组的取值方式和一般数组差不多，可以通过下标取得元素
print(a[0])
# ('Liming', 24, 63.9)
print(a[-2:])
# [('Mike', 15, 67. ) ('Jan', 34, 45.8)]
# 我们可以使用字段名作为下标获取对应的值
print(a['name'])
# ['Liming' 'Mike' 'Jan']
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
