NumPy 数组对象

1、将数值列表转换为一维NumPy数组

编写一个 NumPy 程序，将数值列表转换为一维 NumPy 数组。

预期输出：

原始列表：[12.23， 13.32， 100， 36.32]

一维NumPy数组：[ 12.23 13.32 100. 36.32]

import numpy as np
l = [12.23, 13.32, 100, 36.32]
print("Original List:",l)
a = np.array(l)
print("One-dimensional NumPy array: ",a)

numpy.array：创建一个数组。

【1】语法：

numpy.array（object， dtype=None， copy=True， order='K'， subok=False， ndmin=0）

【2】参数：

2、编写一个 NumPy 程序来反转数组

编写一个 NumPy 程序来反转数组（第一个元素变为最后一个）。

原始数组：

[12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37]

反向数组：

[37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12]

import numpy as np
import numpy as np
x = np.arange(12, 38)
print("Original array:")
print(x)
print("Reverse array:")
x = x[::-1]
print(x)
'''
Original array:                                                         
[12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
 36                                                                     
 37]                                                                    
Reverse array:                                                          
[37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14
 13                                                                     
 12] 
'''

3、转换为浮点型的数组

编写一个NumPy程序将数组转换为浮点类型。

方法一：使用asfarray函数

import numpy as np
import numpy as np
a = [1, 2, 3, 4]
print("Original array")
print(a)
x = np.asfarray(a)
print("Array converted to a float type:")
print(x)
'''
Original array                                                          
[1, 2, 3, 4]                                                            
Array converted to a float type:                                        
[ 1.  2.  3.  4.]
'' '

【1】asfarrary：相当于as float array，将数组转换为浮点类型。不仅可以对多维数组做数值处理，还可以对列表做去转移符处理。

方法二：使用astype函数

import numpy as np
x = np.array([[2, 4, 6], [6, 8, 10]], np.int32)
print(x)
print(x.dtype)
y = x.astype(float)
print(y)
print(y.dtype)
'''
[[ 2  4  6]
 [ 6  8 10]]
int32
[[ 2.  4.  6.]
 [ 6.  8. 10.]]
float64
'''

4、将列表和元组转换为数组

编写一个NumPy程序将列表和元组转换为数组。

注：这里可以使用np.array或者np.asarray

import numpy as np
my_list = [1, 2, 3, 4, 5, 6, 7, 8]
print("List to array: ")
print(np.array(my_list))
my_tuple = ([8, 4, 6], [1, 2, 3])
print("Tuple to array: ")
print(np.array(my_tuple))
'''
List to array: 
[1 2 3 4 5 6 7 8]
Tuple to array: 
[[8 4 6]
 [1 2 3]]
'''

5、将值追加到数组的末尾

编写一个 NumPy 程序以将值追加到数组的末尾。

import numpy as np
x = [10, 20, 30]
print("Original array:")
print(x)
x = np.append(x, [[40, 50, 60], [70, 80, 90]])
print("After append values to the end of the array:")
print(x)
'''
Original array:
[10, 20, 30]
After append values to the end of the array:
[10 20 30 40 50 60 70 80 90]
'''

【1】np.append(arr, values, axis=None) 用法：

作用：

为原始array添加一些values

参数：

arr:需要被添加values的数组

values:添加到数组arr中的值（array_like，类数组）

axis:可选参数，如果axis没有给出，那么arr，values都将先展平成一维数组。注：如果axis被指定了，那么arr和values需要有相同的shape，否则报错：ValueError: arrays must have same number of dimensions

补充对axis的理解

axis的最大值为数组arr的维数-1，如arr维数等于1，axis最大值为0；arr维数等于2，axis最大值为1，以此类推。

当arr的维数为2(理解为单通道图)，axis=0表示沿着行方向添加values；axis=1表示沿着列方向添加values

当arr的维数为3(理解为多通道图)，axis=0，axis=1时同上；axis=2表示沿着深度方向添加values

添加了values的新数组

【2】这里由于使用的append中参数axis=None，因此会将添加的二维数组展开成一维的。

6、在现有数组周围添加边框

编写一个NumPy程序，在现有数组周围添加一个边框（用0填充）。

import numpy as np
x = np.ones((3,3))
print("Original array:")
print(x)
print("0 on the border and 1 inside in the array")
x = np.pad(x, pad_width=1, mode='constant', constant_values=0)
print(x)
'''
Original array:
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
0 on the border and 1 inside in the array
[[0. 0. 0. 0. 0.]
 [0. 1. 1. 1. 0.]
 [0. 1. 1. 1. 0.]
 [0. 1. 1. 1. 0.]
 [0. 0. 0. 0. 0.]]
'''

【1】np.pad

np.pad()用来在numpy数组的边缘进行数值填充。

np.pad(array，pad_width，mode，**kwargs)　　# 返回填充后的numpy数组

【1】array：要填充的numpy数组【要对谁进行填充】

【2】pad_width：每个轴要填充的数据的数目【每个维度前、后各要填充多少个数据】

【3】mode：填充的方式【采用哪种方式填充】

【4】参数mode解析

str（10种取值）、function

str类型取值包括：

‘constant’——表示连续填充相同的值，每个轴可以分别指定填充值，constant_values=（x, y）时前面用x填充，后面用y填充，缺省值填充0

‘edge’——表示用边缘值填充

‘linear_ramp’——表示用边缘递减的方式填充

‘maximum’——表示最大值填充

‘mean’——表示均值填充

‘median’——表示中位数填充

‘minimum’——表示最小值填充

‘reflect’——表示对称填充

‘symmetric’——表示对称填充

‘wrap’——表示用原数组后面的值填充前面，前面的值填充后面

【5】参数pad_width解析

pad_width参数类型：sequence，array_like，int

pad_width参数格式：((before_1, after_1), (before_2, after_2), … , (before_N, after_N))

第一个元素(before_1, after_1)表示第一维【列】的填充方式：前面填充before_1个数值，后面填充after_1个数值

第2个元素(before_2, after_2)表示第二维【行】的填充方式：前面填充before_2个数值，后面填充after_2个数值

【6】参数kwargs解析

字典类型，key包括：

stat_length：sequence、int、optional，用在"maximum", “mean”, “median”, "minimum"中，默认值是 None

constant_values：sequence、int、optional，用在"constant"中，默认值是 0

end_values：sequence、int、optional，用在"linear_ramp"中，默认值是 0

reflect_type：{‘even’, ‘old’}，用在"reflect"，"symmetric"中

7、查找数组的元素数和长度

编写一个NumPy程序来查找数组的元素数，一个数组元素的长度（以字节为单位）以及元素消耗的总字节数。

在这里插入代码片

【1】itemsize：输出array元素的字节数

【2】size：输出元素个数

【3】nbytes：计算数组中的所有数据消耗掉的字节数

8、获取数组的唯一元素

编写一个NumPy程序来获取数组的唯一元素。

import numpy as np
x = np.array([10, 10, 20, 20, 30, 30])
print("Original array:")
print(x)
print("Unique elements of the above array:")
print(np.unique(x))
x = np.array([[1, 1], [2, 3]])
print("Original array:")
print(x)
print("Unique elements of the above array:")
print(np.unique(x))
'''
import numpy as np
x = np.array([10, 10, 20, 20, 30, 30])
print("Original array:")
print(x)
print("Unique elements of the above array:")
print(np.unique(x))
x = np.array([[1, 1], [2, 3]])
print("Original array:")
print(x)
print("Unique elements of the above array:")
print(np.unique(x))
'''

9、创建一个连续的扁平化数组

编写一个 NumPy 程序来创建一个连续的扁平化数组。

原始数组：

[[10 20 30]

[20 40 50]]

新的扁平化数组：

[10 20 30 20 40 50]

import numpy as np
x = np.array([[10, 20, 30], [20, 40, 50]])
print("Original array:")
print(x)
y = np.ravel(x)
print("New flattened array:")
print(y)
'''
Original array:
[[10 20 30]
 [20 40 50]]
New flattened array:
[10 20 30 20 40 50]
'''

10、更改数组的数据类型

import numpy as np
x = np.array([[2, 4, 6], [6, 8, 10]], np.int32)
print(x)
print("Data type of the array x is:",x.dtype)
# Change the data type of x
y = x.astype(float)
print("New Type: ",y.dtype)
print(y)
'''
[[ 2  4  6]
 [ 6  8 10]]
Data type of the array x is: int32
New Type:  float64
[[ 2.  4.  6.]
 [ 6.  8. 10.]]
'''

【1】dtype：查看元素类型

【2】astype：改变元素数据类型

11、合并三个相同形状的给定NumPy数组

编写一个NumPy程序来合并三个相同形状的给定NumPy数组。

import numpy as np
arr1 = np.arange(1,7).reshape(2,3)
arr2 = np.arange(7,13).reshape(2,3)
arr3 = np.arange(13,19).reshape(2,3)
print("arr1:")
print(arr1)
print("arr2:")
print(arr2)
print("arr3:")
print(arr3)
result = np.concatenate((arr1, arr2, arr3), axis=1)
print("After concatenate,axis=1或者-1:")
print(result) 
result = np.concatenate((arr1, arr2, arr3), axis=0)
print("After concatenate,axis=0:")
print(result) 
'''
arr1:
[[1 2 3]
 [4 5 6]]
arr2:
[[ 7  8  9]
 [10 11 12]]
arr3:
[[13 14 15]
 [16 17 18]]
After concatenate,axis=1或者-1:
[[ 1  2  3  7  8  9 13 14 15]
 [ 4  5  6 10 11 12 16 17 18]]
After concatenate,axis=0:
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]
 [13 14 15]
 [16 17 18]]
'''

【2】np.concatenate

np.concatenate：数组拼接

concatenate((a1, a2, …), axis=0)

参数：

传入的参数必须是一个多个数组的元组或者列表

另外需要指定拼接的方向，默认是 axis = 0，也就是说对0轴的数组对象进行纵向的拼接（纵向的拼接沿着axis= 1方向）；注：一般axis = 0，就是对该轴向的数组进行操作，操作方向是另外一个轴，即axis=1。

传入的数组必须具有相同的形状，这里的相同的形状可以传入的数组必须具有相同的形状，这里的相同的形状可以满足在拼接方向axis轴上数组间的形状一致即可

12、查找两个数组之间的公共值

编写一个NumPy程序来查找两个数组之间的公共值。

import numpy as np
array1 = np.array([0,60, 20, 40, 70])
print("Array1: ",array1)
array2 = [60, 30, 40]
print("Array2: ",array2)
print("Common values between two arrays:")
print(np.intersect1d(array1, array2))
'''
Array1:  [ 0 60 20 40 10]
Array2:  [60, 30, 40]
Common values between two arrays:
[40 60]
'''

【1】np.intersect1d函数：查找两个数组中相同的值，并且会按照从小到大的顺序返回新的数组，也可用于求两个数组的交集。数组可以是一维，也可以是多维（我试了二维可以）

13、查找两个数组的集合差值

编写一个NumPy程序来查找两个数组的集合差异。set 差异将返回 array1 中不在 array2 中的已排序的唯一值。

import numpy as np
array1 = np.array([0, 10, 20, 40, 60, 80])
print("Array1: ",array1)
array2 = [10, 30, 40, 50, 70]
print("Array2: ",array2)
print("Unique values in array1 that are not in array2:")
print(np.setdiff1d(array1, array2))
'''
Array1:  [ 0 10 20 40 60 80]
Array2:  [10, 30, 40, 50, 70]
Unique values in array1 that are not in array2:
[ 0 20 60 80]
'''

【3】np.setdiff1d

setdiff1d(ar1, ar2, assume_unique=False)

1.功能：找到2个数组中集合元素的差异。

2.返回值：在ar1中但不在ar2中的已排序的唯一值。

3.参数：

ar1：array_like 输入数组。

ar2：array_like 输入比较数组。

assume_unique：bool。如果为True，则假定输入数组是唯一的，即可以加快计算速度。默认值为False。

Python刷题系列(2)_NumPy数组（上）