task03:Numpy基础学习_数组操作、向量化和广播

最新推荐文章于 2022-10-24 17:12:34 发布

羊老羊

最新推荐文章于 2022-10-24 17:12:34 发布

阅读量128

点赞数

分类专栏：数据挖掘

本文链接：https://blog.csdn.net/wistonty11/article/details/109278758

版权

数据挖掘专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1.数组操作

1.1更改形状

在对数组进行操作时，为了满足格式和计算的要求通常会改变其形状。
numpy.ndarray.shape 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。

例如：通过修改 shap 属性来改变数组的形状

import numpy as np
x = np.array([1, 2, 9, 4, 5, 6, 7, 8])
print(x.shape) # (8,)
x.shape = [2, 4]
print(x)
# [[1 2 9 4]
# [5 6 7 8]]

numpy.ndarray.flat 将数组转换为一维的迭代器，可以用for访问数组每一个元素。

import numpy as np
x = np.array([[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25],
[26, 27, 28, 29, 30],
[31, 32, 33, 34, 35]])
y = x.flat
print(y)
# <numpy.flatiter object at 0x0000020F9BA10C60>
for i in y:
    print(i, end=' ')
# 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
y[3] = 0
print(end='\n')
print(x)
# [[11 12 13 0 15]
# [16 17 18 19 20]
# [21 22 23 24 25]
# [26 27 28 29 30]
# [31 32 33 34 35]]

numpy.ndarray.flatten([order=‘C’]) 将数组的副本转换为一维数组，并返回。
a. order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘k’ – 元素在内存中的出现顺序。(简记)
b. order：{'C / F，'A，K}，可选使用此索引顺序读取a的元素。'C’意味着以行大的C风格顺序对元素进行索引，最后一个轴索引会更改F
表示以列大的Fortran样式顺序索引元素，其中第一个索引变化最快，最后一个索引变化最快。请注意，'C’和’F’选项不考虑基础数组的
内存布局，仅引用轴索引的顺序.A’表示如果a为Fortran，则以类似Fortran的索引顺序读取元素在内存中连续，否则类似C的顺序。“ K”
表示按照步序在内存中的顺序读取元素，但步幅为负时反转数据除外。默认情况下，使用Cindex顺序。

import numpy as np
x = np.array([[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25],
[26, 27, 28, 29, 30],
[31, 32, 33, 34, 35]])
y = x.flatten(order='F')
print(y)
# [11 16 21 26 31 12 17 22 27 32 13 18 23 28 33 14 19 24 29 34 15 20 25 30 35]

numpy.ravel(a, order=‘C’) 返回的是视图

import numpy as np
x = np.array([[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25],
[26, 27, 28, 29, 30],
[31, 32, 33, 34, 35]])
y = np.ravel(x)
print(y)
#[11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35]
y[3] = 0
print(x)
# [[11 12 13 0 15]
# [16 17 18 19 20]
# [21 22 23 24 25]
# [26 27 28 29 30]
# [31 32 33 34 35]]

order=F 就是拷贝

numpy.reshape(a, newshape[, order=‘C’]) 在不更改数据的情况下为数组赋予新的形状。
当参数 newshape = [rows,-1] 时，将根据行数自动确定列数

import numpy as np
x = np.arange(12)
y = np.reshape(x, [3, 4])
print(y.dtype) # int32
print(y)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
y = np.reshape(x,[-1,3])
print(y)
# [[ 0 1 2]
# [ 3 4 5]
# [ 6 7 8]
# [ 9 10 11]]
y[0, 1] = 10
print(x)
# [ 0 10 2 3 4 5 6 7 8 9 10 11]

改变x去reshape后y中的值，x对应元素也改变
当参数 newshape = -1 时，表示将数组降为一维

1.2数组转置

numpy.transpose(a, axes=None) Permute the dimensions of an array.
numpy.ndarray.T Same as self.transpose() , except that self is returned if self.ndim < 2 .

import numpy as np
x = np.random.rand(5, 5) * 10
x = np.around(x, 2)
print(x)
# [[6.74 8.46 6.74 5.45 1.25]
# [3.54 3.49 8.62 1.94 9.92]
# [5.03 7.22 1.6 8.7 0.43]
# [7.5 7.31 5.69 9.67 7.65]
# [1.8 9.52 2.78 5.87 4.14]]
y = x.T
print(y)
# [[6.74 3.54 5.03 7.5 1.8 ]
# [8.46 3.49 7.22 7.31 9.52]
# [6.74 8.62 1.6 5.69 2.78]
# [5.45 1.94 8.7 9.67 5.87]
# [1.25 9.92 0.43 7.65 4.14]]
y = np.transpose(x)
print(y)
# [[6.74 3.54 5.03 7.5 1.8 ]
# [8.46 3.49 7.22 7.31 9.52]
# [6.74 8.62 1.6 5.69 2.78]
# [5.45 1.94 8.7 9.67 5.87]
# [1.25 9.92 0.43 7.65 4.14]]

1.3更改维度

当创建一个数组之后，还可以给它增加一个维度，这在矩阵计算中经常会用到。
很多工具包在进行计算时都会先判断输入数据的维度是否满足要求，如果输入数据达不到指定的维度时，可以使用 newaxis 参数来增加一个维度

import numpy as np
x = np.array([1, 2, 9, 4, 5, 6, 7, 8])
y = x[np.newaxis, :]
print(y.shape) # (1, 8)
print(y) # [[1 2 9 4 5 6 7 8]]
y = x[:, np.newaxis]
print(y.shape) # (8, 1)
print(y)
#[[1]
# [2]
# [9]
# [4]
# [5]
# [6]
# [7]
# [8]]

numpy.squeeze(a, axis=None) 从数组的形状中删除单维度条目，即把shape中为1的维度去掉
a 表示输入的数组
axis 用于指定需要删除的维度，但是指定的维度必须为单维度，否则将会报错；
在机器学习和深度学习中，通常算法的结果是可以表示向量的数组（即包含两对或以上的方括号形式[[]]），如果直接利用这个数组进行画图可能显示界面为空。我们可以利用 squeeze() 函数将表示向量的数组转换为秩为1的数组，这样利用matplotlib 库函数画图时，就可以正常的显示结果了

import numpy as np
x = np.array([[[0], [1], [2]]])
y = np.squeeze(x)
print(y.shape) # (3,)
print(y) # [0 1 2]
y = np.squeeze(x, axis=2)
print(y.shape) # (1, 3)
print(y) # [[0 1 2]]
y = np.squeeze(x, axis=1)
# ValueError: cannot select an axis to squeeze out which has size not equal to one

1.4 数组组合

numpy.concatenate((a1, a2, …), axis=0, out=None) Join a sequence of arrays along an existing axis.

import numpy as np
x = np.array([1, 2, 3])
y = np.array([7, 8, 9])
z = np.concatenate([x, y])
print(z)
# [1 2 3 7 8 9]

import numpy as np
x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.array([[7, 8, 9], [10, 11, 12]])
z = np.concatenate([x, y])
print(z)
# [[ 1 2 3]
# [ 4 5 6]
# [ 7 8 9]
# [10 11 12]]

numpy.stack(arrays, axis=0, out=None)沿着新的轴加入一系列数组（stack为增加维度的拼接）

import numpy as np
x = np.array([1, 2, 3])
y = np.array([7, 8, 9])
z = np.stack([x, y], axis=1)
print(z.shape) # (3, 2)
print(z)
# [[1 7]
# [2 8]
# [3 9]]

hstack(),vstack() 分别表示水平和竖直的拼接方式。在数据维度等于1时，比较特殊。而当维度大于或等于2时，它们的作用相当
于 concatenate ，用于在已有轴上进行操作。

1.5数组拆分

numpy.split(ary, indices_or_sections, axis=0)

import numpy as np
x = np.array([[11, 12, 13, 14],
[16, 17, 18, 19],
[21, 22, 23, 24]])
y = np.split(x, [1, 3])
print(y)
#[array([[11, 12, 13, 14]]), array([[16, 17, 18, 19],
       #[21, 22, 23, 24]]), array([], shape=(0, 4), #dtype=int32)]

numpy.vsplit(ary, indices_or_sections)垂直切分是把数组按照高度切分

import numpy as np
x = np.array([[11, 12, 13, 14],
[16, 17, 18, 19],
[21, 22, 23, 24]])
y = np.vsplit(x, 3)
print(y)
# [array([[11, 12, 13, 14]]), array([[16, 17, 18, 19]]), array([[21, 22, 23, 24]])]

numpy.hsplit(ary, indices_or_sections)水平切分是把数组按照宽度切分

1.6 数组平铺

numpy.tile(A, reps)这个函数就是把数组像瓷砖一样铺展开来

import numpy as np
x = np.array([[1, 2], [3, 4]])
y = np.tile(x, (1, 3))
print(y)
# [[1 2 1 2 1 2]
# [3 4 3 4 3 4]]

numpy.repeat(a, repeats, axis=None) Repeat elements of an array.
a. axis=0 ，沿着y轴复制，实际上增加了行数。
b. axis=1 ，沿着x轴复制，实际上增加了列数。
c. repeats ，可以为一个数，也可以为一个矩阵

1.7添加和删除元素

a=np.array([1,1,2,3,3,4,4])
b=np.unique(a,return_counts=True)
print(b[0][list(b[1]).index(1)])
#2

2.向量化和广播

向量化和广播这两个概念是 numpy 内部实现的基础.

向量化的应用使得代码更简洁，可读性更强，也可以说使用了向量化方法的代码看上去更“Pythonic”
广播（Broadcasting）机制描述了 numpy 如何在算术运算期间处理具有不同形状的数组，让较小的数组在较大的数组上“广播”，以便它们具有兼容的形状。并不是所有的维度都要彼此兼容才符合广播机制的要求，但它们必须满足一定的条件。
若两个数组的各维度兼容，也就是两个数组的每一维等长，或其中一个数组为一维，那么广播机制就适用。如果这两个条件不满足，numpy就会抛出异常，说两个数组不兼容。总结来说，广播的规则有三个：
1.如果两个数组的维度数dim不相同，那么小维度数组的形状将会在左边补1。
2.如果shape维度不匹配，但是有维度是1，那么可以扩展维度是1的维度匹配另一个数组；
3.如果shape维度不匹配，但是没有任何一个维度是1，则匹配引发错误；

import numpy as np
x = np.arange(4).reshape(4, 1)
y = np.ones(5)
print(x.shape) # (4, 1)
print(y.shape) # (5,)
print((x + y).shape) # (4, 5)
print(x + y)
# [[1. 1. 1. 1. 1.]
# [2. 2. 2. 2. 2.]
# [3. 3. 3. 3. 3.]
# [4. 4. 4. 4. 4.]]
1 2 3 4 5 6 7 8 9
10
11
12
13
14【例】不匹配报错的例子
x = np.array([0.0, 10.0, 20.0, 30.0])
y = np.array([1.0, 2.0, 3.0])
z = x[:, np.newaxis] + y
print(z)
# [[ 1. 2. 3.]
# [11. 12. 13.]
# [21. 22. 23.]
# [31. 32. 33.]]

不匹配报错

import numpy as np
x = np.arange(4)
y = np.ones(5)
print(x.shape) # (4,)
print(y.shape) # (5,)
print(x + y)
# ValueError: operands could not be broadcast together with shapes (4,) (5,)

羊老羊

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
task03:Numpy基础学习_数组操作、向量化和广播

1.数组操作1.1更改形状在对数组进行操作时，为了满足格式和计算的要求通常会改变其形状。numpy.ndarray.shape 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。例如：通过修改 shap 属性来改变数组的形状import numpy as npx = np.array([1, 2, 9, 4, 5, 6, 7, 8])print(x.shape) # (8,)x.shape = [2, 4]print(x)# [[1 2 9
复制链接

扫一扫