Python刷题系列(2)_NumPy数组

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】参数：

名字	描述	必需/可选
对象	数组，公开数组接口的任何对象。	必填
d类型：数据类型，可选	数组的所需数据类型。	自选
复制（布尔）	如果为 true（默认值），则复制对象。	自选
顺序 ： ‘K’， ‘A’， ‘C’， ‘F’	指定阵列的内存布局。如果 object 不是数组，则新创建的数组将按 C 顺序（行主）排列，除非指定了“F”，在这种情况下，它将按 Fortran 顺序排列。	自选
subok （bool）	如果为 True，则子类将被传递，否则返回的数组将被强制为基类数组。	自选
ndmin （int）	指定生成的数组应具有的最小维度数。	自选

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。

14、查找两个数组的并集

编写一个 NumPy 程序来查找两个数组的并集。Union 将返回两个输入数组中任一输入数组中唯一的、经过排序的值数组。

import numpy as np
array1 = np.array([0, 1, 2, 3, 4, 5])
print("Array1: ",array1)
array2 = [5, 4, 3, 9, 7]
print("Array2: ",array2)
print("Unique sorted array of values that are in either of the two input arrays:")
print(np.union1d(array1, array2))


'''
Array1:  [0 1 2 3 4 5]
Array2:  [5, 4, 3, 9, 7]
Unique sorted array of values that are in either of the two input arrays:
[0 1 2 3 4 5 7 9]
'''

np.union1d(array1, array2)：筛选出两个数组当中的唯一元素，顺序排列放入新数组当中。

15、测试数组中的所有元素是否都计算为 True

编写一个 NumPy 程序来测试数组中的所有元素是否都计算为 True。
注意：在 python 中，0 的计算结果为 False。

import numpy as np
array1 = np.array([[0,60, 20, 40, 70],
                  [1,2,3,4,5]])
print("Array1: ",np.all(array1))
print("Array2: ",np.all([10, 20, -50]))

'''
Array1:  False
Array2:  True
'''

这个和list的用法一样，全部使用all，单个使用any。
上面的代码将all改成any，则Array也会显示True，表示只要有一个不是0，结果就为True。

16、通过重复构造数组

import numpy as np
a = [1, 2, 3, 4]
print("Original array")
print(a)
print("Repeating 2 times")
x = np.tile(a, 2)
print(x)
print("Repeating 3 times")
x = np.tile(a, 3)
print(x)

'''
Original array
[1, 2, 3, 4]
Repeating 2 times
[1 2 3 4 1 2 3 4]
Repeating 3 times
[1 2 3 4 1 2 3 4 1 2 3 4]
'''

【4】np.tile

np.tile(A,res)：A 是个数组，reps 是个元组。tile这个函数把数组 A 当成一个元素来构造 shape 为 res 的数组

17、比较两个给定的数组

import numpy as np
a = np.array([1, 2])
b = np.array([4, 5])
print("a > b：")
print(np.greater(a, b))
print("a >= b：")
print(np.greater_equal(a, b))
print("a < b：")
print(np.less(a, b))
print("a <= b：")
print(np.less_equal(a, b))

'''
a > b：
[False False]
a >= b：
[False False]
a < b：
[ True  True]
a <= b：
[ True  True]
'''

18、沿数组的第一个和最后一个轴对排序

import numpy as np
a = np.array([[4, 6],[2, 1]])
print("Original array: ")
print(a)
print("Sort along the first axis=0: ")
x = np.sort(a, axis=0)
print(x)
print("Sort along the last axis=1: ")
y = np.sort(a, axis=1)
print(y)

'''
Original array: 
[[4 6]
 [2 1]]
Sort along the first axis=0: 
[[2 1]
 [4 6]]
Sort along the last axis=1: 
[[4 6]
 [1 2]]
'''

19、获取给定数组中大于 10 的元素的值和索引

import numpy as np
x = np.array([[0, 10, 20], [20, 30, 40]])
print("Original array: ")
print(x)
print("Values bigger than 10 =", x[x>10])
print(np.nonzero(x > 10))

'''
Original array: 
[[ 0 10 20]
 [20 30 40]]
Values bigger than 10 = [20 20 30 40]
(array([0, 1, 1, 1], dtype=int64), array([2, 0, 1, 2], dtype=int64))
'''

【5】np.nonzero

np.nonzero函数是numpy中用于得到数组array中非零元素的位置（数组索引）的函数。

解释
nonzero(a)：返回数组a中非零元素的索引值数组。
（1）只有a中非零元素才会有索引值，那些零值元素没有索引值。
（2）返回的索引值数组是一个2维tuple数组，该tuple数组中包含一维的array数组。其中，一维array向量的个数与a的维数是一致的。
（3）索引值数组的每一个array均是从一个维度上来描述其索引值。比如，如果a是一个二维数组，则索引值数组有两个array，第一个array从行维度来描述索引值；第二个array从列维度来描述索引值。
（4）np.transpose(np.nonzero(x)) 函数能够描述出每一个非零元素在不同维度的索引值。
（5）通过a[nonzero(a)] 得到所有a中的非零值。

20、测试数组中是否存在指定的值

编写一个 NumPy 程序来测试数组中是否存在指定的值。

import numpy as np
x = np.array([[1.12, 2.0, 3.45], [2.33, 5.12, 6.0]], float) 
print("Original array:")
print(x)
print(2 in x)
print(0 in x)
print(6 in x)
print(2.3 in x)
print(5.12 in x)

'''
Original array:
[[1.12 2.   3.45]
 [2.33 5.12 6.  ]]
True
False
True
False
True
'''

21、向NumPy数组添加额外的列

import numpy as np
x = np.array([[10,20,30], [40,50,60]])
y = np.array([[100], [200]])
print(np.append(x, y, axis=1))

'''
[[ 10  20  30 100]
 [ 40  50  60 200]]
'''

22、按行列访问数组

就是使用切片…

import numpy as np
x= np.arange(9).reshape(3,3)
print("Original array elements:")
print(x)
print("Access an array by column:")
print("第一行:")
print(x[0,:])
print("第一列:")
print(x[:,0])

'''
Original array elements:
[[0 1 2]
 [3 4 5]
 [6 7 8]]
Access an array by column:
第一行:
[0 1 2]
第一列:
[0 3 6]
'''

23、替换数组中大于指定数组的元素

import numpy as np
x = np.array([[ 0.409, 0.480, 0.320], [ 0.740,0.508,0.308], [ 0.509,0.345,0.156]])
print("Original array:")
print(x)
print("替换后：")
x[x > .5] = .5
print(x)

'''
Original array:
[[0.409 0.48  0.32 ]
 [0.74  0.508 0.308]
 [0.509 0.345 0.156]]
替换后：
[[0.409 0.48  0.32 ]
 [0.5   0.5   0.308]
 [0.5   0.345 0.156]]
'''

24、删除数组中的特定元素

import numpy as np
x = np.array([10, 20, 30, 40, 50, 60, 70])
index = [0, 3, 4]
print("Original array:")
print(x)
print("Delete first, fourth and fifth elements:")
new_x = np.delete(x, index)
print(new_x)

'''
Original array:
[10 20 30 40 50 60 70]
Delete first, fourth and fifth elements:
[20 30 60 70]
'''

25、计算一组数据的直方图

import numpy as np    
import matplotlib.pyplot as plt
plt.hist([1, 2, 1], bins=[0, 1, 2, 3, 5])
plt.show()