Python-NumPy学习（1）

文章首发于：My Blog 欢迎大佬们前来逛逛

1. ndarray数组对象

1.1 数组的属性

数组属性反应了数组本身具有的固定信息：

  1. ndim：返回int，表示数组的维数
  2. shape：返回tuple，表示数组的尺寸，对于n行m列的数组，返回值是（n，m）
  3. size：返回int，表示数组的元素个数，等于数组的 n*m 的值
  4. dtype：返回 data_type，表示数组的元素类型
  5. itemsize：返回int，表示数组的每个元素的大小

测试如下：

a1 = np.arange(24).reshape(4, 6)
print(a1)
print(a1.ndim)
print(a1.shape)
print(a1.size)
print(a1.dtype)
print(a1.itemsize)

-----
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
2
(4, 6)
24
int32
4

1.2 数组的创建

numpy数组创建的三种方法：

  1. 利用python的原生数据类型：数组和元组进行转换为numpy的数组
  2. numpy的库中的原生数组的创建：zeros ones arange等
  3. 特殊库函数创建：random

1.2.1 数组元组的转换

创建数组和元组，然后转化为ndarray

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

object：接受的array，表示想要创建的数组原对象

dtype：数组元素的数据类型

ndmin：表示生成数组的默认维数

a1 = np.array([1, 2, 3, 4, 5])  # 将列表转换为数组
a2 = np.array((1, 2, 3, 4, 5))  # 将元组转换为数组
a3 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) # 二维数组

修改数组的属性：

a3 = np.array([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]])# 创建了一个 3*4的二维数组
a3.shape = 4, 3 #把它转变为 4*3 形状的

1.2.2 Numpy的原生数组的创建

arange函数

arange([start,] stop[, step,], dtype=None, *, like=None)

start：起始值（可选值，默认为0）

stop：终止值（必选值）

step：步长（可选值，默认为1）

a1 = np.arange(2, 10, 1)  # [2,10) 步长为1
a2 = np.arange(20)  # [0,20)

linspace函数生成等差数列

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

start：起始值

stop：终止值

num：生成的元素数量

endpoint：stop处的元素是否显示

retstep：是否显示步长

dtype：数据类型

axis：轴向，0表示X轴

a1 = np.linspace(1, 10, 5)  # [1,10] 生成5个元素，形成等差数列
a2 = np.linspace(1, 20, 10, False, True) #[1,20]中的元素，元素为10个，不显示最后stop元素，显示步长

logspace函数

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

start：起始值

stop：终止值

num：生成的元素的数量

endpoint：是否包含终点元素

base：底数，默认为 10.0

dtype：数据类型

asix：轴向

a1 = np.logspace(1, 4, 5)  # [1,10^4]中以10为底的对数幂数组，生成5个
a2 = np.logspace(1, 5, 6, False, 2, int)  # [1,2^5]中以2为底的对数幂数组中，生成6个，并且数据是int，且不包含最后一个元素
print(a1)
print(a2)
-----------
[   10.            56.23413252   316.22776602  1778.27941004
 10000.        ]
[ 2  3  5  8 12 20]

1.2.3 特殊数组的创建

zeros：创建全0数组，ones创建全1数组

zeros(shape, dtype=float, order='C', *, like=None)

shape：是一个tuple元组，表示要生成的新数组的行与列

dtype：数据类型

order：创建多维数组时，行优先还是有列优先

a1 = np.zeros((2, 5))  # 2*5 的全零数组
a2 = np.zeros((3, 4), int, order='C')
print(a1)
print(a2)
------------
[[0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]]
[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]]

eye：创建单位数组

对角线的元素为1，其他元素都是0

eye(N, M=None, k=0, dtype=float, order='C', *, like=None)

N，M：表示新生成数组的行与列，不是元组，这点与zeros不同，zeros的第一个参数为一个元素 ()

k：对角线的位置，如果k=0，则操作对角线为主对角线；如果k<0，则是较低的对角线；如果k>0，则是较高的对角线

a1 = np.eye(5, 5)
a2 = np.eye(5, 5, 1)
print(a1)
print(a2)
---------
[[1. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]]
 
[[0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]
 [0. 0. 0. 0. 0.]]

diag：创建对角的数组

diag(v, k=0)

v：为一个一维数组时，一维数组的元素当作生成的这个二维数组的对角线元素值，其他元素都是零；为一个二维数组时，则生成这个二维数组的对角线元素

k：对角线的位置

a1 = np.diag((1, 2, 3, 4))
a2 = np.diag(([1, 2, 3, 4], [5, 6, 7, 8], [5, 6, 8, 9], [1, 5, 6, 9]))
print(a1)
print(a2)
----------
[[1 0 0 0]
 [0 2 0 0]
 [0 0 3 0]
 [0 0 0 4]]
 
[1 6 8 9]

1.2.4 random创建数组

random函数：生成随机浮点数

random(size=None)

size：表示尺寸，可以是一个随机数，或者一个随机元素列表

print(np.random.random())  # 随机数字
print(np.random.random([4, 6]))  # 4*6的随机数组
------
0.6034088031001689
[[0.60809724 0.38712832 0.35226359 0.7502394  0.52615225 0.7124569 ]
 [0.8469049  0.86939894 0.2347224  0.35412129 0.94113052 0.58163995]
 [0.78082739 0.58041912 0.63386666 0.88877713 0.97485679 0.59972369]
 [0.17787109 0.51326606 0.79225259 0.24202619 0.91109686 0.78733859]]

rand：生成均匀分布的随机数

rand(*dn)

*dn：表示从 d1 d2 d3 .... dn，表示数组的维数，生成 di 维的正态分布的随机数数组

print(np.random.rand(1, 2, 3, 4))  # 四维
print(np.random.rand(4, 6, 5))  # 三维的随机数组

注意与random 的区别，random接受的是一个n*m维的元组或者列表，rand接受的是n个参数，表示n维

randint：生成指定范围的随机数

randint(low, high=None, size=None, dtype=None)

low：表示最底范围

high：表示终止范围

size：表示数组的shape，注意不是元素个数

dtype：数据类型

print(np.random.randint(1, 100, (2, 5)))  # [1-100] 之间生成一个2*5的二维数组
print(np.random.randint(1, 50, [3, 3]))  # 同理
---------
[[39 82 52 12 83]
 [31  4 49 73 32]]
[[15 49 16]
 [ 3  2  5]
 [46  2 14]]

1.2 访问数组

一维数组的访问：

a1 = np.arange(1, 10, 2)
print("创建的一维数组:", a1)
print("[0]:", a1[0])
print("[-1]:", a1[-1]) # 最后一个元素
print("[-2]:", a1[-2]) # 倒数第二个元素
print("[:-1]:", a1[:-1]) # 一直到最后一个元素，不包括最后一个
print("[2:5]:", a1[2:5]) # [2,5)之间所有的元素
print("[1:]:", a1[1:]) # 包括1下标之后所有的元素
print("[1:5:2]:", a1[0:5:1])  # [0-5) 步长为1
-------------
创建的一维数组: [1 3 5 7 9]
[0]: 1
[-1]: 9
[-2]: 7
[:-1]: [1 3 5 7]
[2:5]: [5 7 9]
[1:]: [3 5 7 9]
[1:5:2]: [1 3 5 7 9]

二维数组的访问：

a2 = np.arange(0, 20, 1).reshape(4, 5)
print("原始二维数组: \n", a2)
print("[1] ", a2[1])  # 第二行(从0开始)
print("[1,2:4] ", a2[1, 2:4])  # 第二行的 第 [2,4) 个元素
print("a2[1:, :4] ", a2[1:, :4]) # 第二，三，四行的前四列元素（不包括第五列(4)）
---------------
原始二维数组: 
 [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
[1]  [5 6 7 8 9]
[1,2:4]  [7 8]
a2[1:, :4]  [[ 5  6  7  8]
 [10 11 12 13]
 [15 16 17 18]]

1.3 改变数组的形状

1.3.1 reshape

reshape改变数组的形状，就是改变数组的维度

reshape(self, shape, order='C')

shape：改变的数组的新的尺寸

print(np.arange(0, 20, 1).reshape((4, 5)))
print(np.arange(0, 20, 1).reshape(4, 5))
---------
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]

这两种方式是等价的，加不加 元组类型都是一样的。

注意：reshape不会改变原始数据的形状

a1 = np.array([[1, 2, 3, 4], [2, 3, 4, 5]])
a2 = a1.reshape((4, 2))
print(a1)
print(a2)
---------
[[1 2 3 4]
 [2 3 4 5]]
[[1 2]
 [3 4]
 [2 3]
 [4 5]]

1.3.2 resize

resize修改数组的形状：

resize(self, new_shape, refcheck=True)

new_shape表示一个新的形状，可以为n个ins或者一个表示形状的元组

a = np.arange(0, 20, 1)
print(a)
a.resize(4, 5)
print(a)
---------
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]

注意：resize 没有返回值，并且resize 的改变会改变原来的数组的尺寸形状

NumPy还提供有重名的函数：np.resize，这个版本可以返回一个改变后的数组

a = np.arange(0, 20, 1)
print(np.resize(a, (4, 5)))
-------
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]

1.3.3 flatten

数组的展平工作：将多维数组转变为一维数组

a = np.arange(0, 20, 1)
a = np.resize(a, (4, 5))
print(a)
# 数组的展平
print(a.flatten('C')) # 横向展平
print(a.flatten('F')) # 纵向展平
----------
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
[ 0  5 10 15  1  6 11 16  2  7 12 17  3  8 13 18  4  9 14 19]

1.3.4 合并

hstack可以横向合并数组

接受一个元组，元组中包含需要合并的数组：

a1 = np.arange(0, 20, 1).reshape(4, 5)
a2 = a1 * 2
# 数组的展平
print(np.hstack((a1, a2)))
-----------
[[ 0  1  2  3  4  0  2  4  6  8]
 [ 5  6  7  8  9 10 12 14 16 18]
 [10 11 12 13 14 20 22 24 26 28]
 [15 16 17 18 19 30 32 34 36 38]]

注意：需要合并的两个数组的尺寸必须是一样的

vstack可以纵向合并数组

a1 = np.arange(0, 20, 1).reshape(4, 5)
a2 = a1 * 2
a3 = a2 * 2
# 数组的展平
print(np.vstack((a1, a2, a3)))
------------
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [ 0  2  4  6  8]
 [10 12 14 16 18]
 [20 22 24 26 28]
 [30 32 34 36 38]
 [ 0  4  8 12 16]
 [20 24 28 32 36]
 [40 44 48 52 56]
 [60 64 68 72 76]]

concatenate此函数也可以实现合并数组：并且还可以自己指定是横向还是纵向：

print(np.concatenate((a1, a2, a3), axis=1))
print(np.concatenate((a1, a2, a3), axis=0))

1.3.5 分割

np.split 实现了横向或者纵向分割数组：

a3 = np.arange(16).reshape((4, 4))
print(np.split(a3, 2))
print(np.split(a3, 2, axis=1))
----------
[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]

注意：split是等量 分割，第二个参数指明了等量分割的数量

np.array_split 实现了不等量分割

print(np.array_split(a3, 3, axis=1))
---------
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2],
       [ 6],
       [10],
       [14]]), array([[ 3],
       [ 7],
       [11],
       [15]])]
posted @ 2023-03-15 21:51  hugeYlh  阅读(14)  评论(0)  编辑  收藏  举报