当前位置:   article > 正文

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

创建一个从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
声明:本文内容由网友自发贡献,转载请注明出处:【wpsshop】
推荐阅读
相关标签
  

闽ICP备14008679号