python科学计算库之Numpy库的使用的简单习题_创建一个从1到80,步长为4的一维数组a,并将其变成一个4*5的二维数组,输出a的转

Numpy库

Numpy（Numerical Python的缩写）是一个开源的Python库，用于进行科学计算。它提供了一个高性能的多维数组对象（ndarray）及用于处理这些数组的各种工具和函数。由于其高效和灵活的数据结构以及丰富的功能，Numpy已成为Python科学计算的基础库，广泛应用于数据分析、机器学习、工程仿真等领域。

Numpy的主要特点包括：

高性能的多维数组支持：Numpy的核心是多维数组对象（ndarray），它提供了统一的接口来进行快速的数组计算。与Python原生的列表相比，Numpy的数组在性能上有显著的优势，尤其是在处理大数据时。

广泛的数学函数库：Numpy提供了大量的数学函数，包括线性代数运算、傅里叶变换、随机数生成等，这使得进行科学计算变得非常便捷。

数组广播功能：Numpy可以让不同大小的数组在一起进行数学计算时非常方便，通过其广播机制，小数组会在算术运算中自动扩展到与大数组相同的大小，这使得数组间的运算表达更加直观。

高效的内存使用：Numpy的数组使用连续内存块，这不仅有利于减少内存使用，还能提升计算性能。此外，Numpy还提供了内存映射功能，允许处理超过内存大小的数据集。

与其他语言的接口：Numpy可以很容易地与C、C++等语言集成，这允许在性能关键的应用中使用这些语言编写核心算法，同时保持Python的易用性。

Numpy是许多高级科学计算库的基础，包括Pandas（数据分析库）、Matplotlib（绘图库）、Scikit-learn（机器学习库）等，几乎成为了进行科学计算和数据分析的Python开发的必备库。

快速入门题

1. 创建一个从1到80，步长为4的一维数组A，并将其变成一个4*5的二维数组，输出A的转置

import numpy as np
A=np.arange(1,80,4) #A=np.arange(1,80)[::4] 
A=A.reshape(4,5)
print(A.T)

1
2
3
4
5

2. 随机生成a,b两个数组，其中a.shape: (4, 1) b.shape: (3,) 计算a+b,a*b,a/b

import numpy as np
a=np.random.randint(1,11,(4,1))
b=np.random.randint(1,11,(3,))
print(a+b)
print(a*b)
print(a/b)

1
2
3
4
5
6
7

3. 创建一个shape为5*3的随机矩阵A,打印出A中最大元素和最小元素,平均值，并计算每一行的和

import numpy as np
A=np.random.randint(0,40,(5,3))
print(A)
print(A.max())
print(A.min())
print(A.mean())
for i in A:
    print(i.sum())

1
2
3
4
5
6
7
8
9

4. 创建两个3*3的(0,5)之间的随机数组a和b,对a,b进行水平合并后得到数组c,对c使用Min-Max 标准化算法对数据进行标准化处理并输出结果

import numpy as np
a=np.random.randint(0,5,(3,3))
b=np.random.randint(0,5,(3,3))
c=np.hstack((a,b)) 

def minmax(a, axis=None):
    a_min = np.min(a, axis=axis, keepdims=True)
    a_max = np.max(a, axis=axis, keepdims=True)
    return (a - a_min)/(a_max - a_min)

print(minmax(c))

1
2
3
4
5
6
7
8
9
10
11
12
13

5. 打印出以下数组（要求使用np.ones创建形状为8*8的矩阵）：
[[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]]

import numpy as np
a=np.ones((8,8),dtype=np.int8)
a[::2,1::2]=0 
a[1::2,::2]=0 
print(a)


#[1::2, ::2]: 是对数组a的切片操作，用于选择数组中的特定元素。
#1::2 表示从第1个索引开始（注意，在Python中索引是从0开始的），每隔一个元素选择一次，直到数组的最后一个元素。这是对数组的第一个维度（通常是行）的操作。
#::2 表示从第0个索引开始，每隔一个元素选择一次，直到该维度的最后一个元素。这是对数组的第二个维度（通常是列）的操作
1
2
3
4
5
6
7
8
9
10

6. 使用numpy创建下列数组[1,1,2,3,4,5,6,1,1,6],找出数组中1元素的位置索引并输出索引（使用两种方法）。

import numpy as np
a=np.array([1,1,2,3,4,5,6,1,1,6])
#way1
b=[]
for i in range(len(a)):
    if a[i]==1:
        b.append(i)
print(b)        
#way2
print(list(np.where(a==1)[0]))


1
2
3
4
5
6
7
8
9
10
11
12

7. 使用numpy创建一维数组A,对A里面的数据进行去重得到B,使用numpy创建形状与B相同的随机数组C,自定义ufunc函数计算B和C的和（使用numpy.frompyfunc）
A为[4,4,1,2,3,4,5,7,9,1,1],数组C的数据范围在(0,5)之间

import numpy as np
A=np.array([4,4,1,2,3,4,5,7,9,1,1])
B=np.unique(A) #进行去重
print(B.shape) #(7,)
C=np.random.randint(0,5,(7,))
print(B)
print(C)
def add_elements(x, y):
    return x + y
add_them = np.frompyfunc(add_elements, 2, 1)
print(add_them(B,C))

1
2
3
4
5
6
7
8
9
10
11
12

8．用numpy编程创建国际象棋盘，填充8*8矩阵，棋盘是正方形，由横纵各八格，颜色一深一浅交错排列的64个小正方格组成，深色为黑格（为0），浅色为白格（为1），如下图所示。

并输出国际象棋盘对应的矩阵

import numpy as np
matr1=np.ones((8,8))
for i in range(8):
    for j in range(8):
        if(i+j)%2==0:
            matr1[i,j]=0
print('国际棋盘对应的矩阵为：\n',matr1)
for i in range(0,8):
    for j in range(0,8):
        if matr1[i,j]==0:
            print("□",end=' ')
        else:
            print("■", end=' ')
    print('\n')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

9. 创建一个大小3*3,(-1,1)值之间随机数组A, 对A的后两行进行交换,输出A中非0元素的值,将A中非0元素替换成0。

import numpy as np
A=np.random.uniform(-1,1,(3,3))
print(A)
A[[1,2]]=A[[2,1]]
print(A)
B=np.where(A<0)
print(A[B])
for i in range(A.shape[0]):
    for j in range(A.shape[1]):
        if A[i][j]<0:
            A[i][j]=0
print(A)

1
2
3
4
5
6
7
8
9
10
11
12
13

10.使用Numpy数组实现生命游戏
生命游戏，简称为生命，是英国数学家约翰·何顿·康威在1970年发明的细胞自动机。
给定一个包含 m × n 个格子的面板，每一个格子都可以看成是一个细胞。每个细胞具有一个初始状态 live（1）即为活细胞， 或 dead（0）即为死细胞。每个细胞与其八个相邻位置（水平，垂直，对角线）的细胞都遵循以下四条生存定律：

1. 如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡；
2. 如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活；
3. 如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡；
4. 如果死细胞周围正好有三个活细胞，则该位置死细胞复活

import numpy as np
def iterate(Z):
    #邻居
    N = (Z[0:-2,0:-2] + Z[0:-2,1:-1] + Z[0:-2,2:] +
         Z[1:-1,0:-2]                + Z[1:-1,2:] +
         Z[2:  ,0:-2] + Z[2:  ,1:-1] + Z[2:  ,2:])
    #规则
    birth = (N==3) & (Z[1:-1,1:-1]==0)
    survive = ((N==2) | (N==3)) & (Z[1:-1,1:-1]==1)
    Z[...] = 0
    Z[1:-1,1:-1][birth | survive] = 1
    return Z
Z = np.random.randint(0,2,(50,50))
for i in range(100): 
    Z = iterate(Z)
print(Z)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17