实验3 矩阵与运算 1、使用mat函数创建一个2*3矩阵: 2、使用 shape 可以获取矩阵的大小 3、使用mat函数创建一个3*2矩阵，并与1创建的矩阵相乘，然后求该3*3矩阵对角元素之和 4、再创建一个2*3矩阵，并与1创建的矩阵点乘

1、可以使用以下代码创建一个 2*3 的矩阵：

matrix1 = np.mat([[1, 2, 3], [4, 5, 6]])

2、可以使用以下代码获取矩阵的大小：

matrix1.shape

该代码将返回一个元组，其中第一个值表示矩阵的行数，第二个值表示矩阵的列数。

3、可以使用以下代码创建一个 3*2 的矩阵，并与 1 创建的矩阵相乘，然后求该 3*3 矩阵对角元素之和：

matrix2 = np.mat([[7, 8], [9, 10], [11, 12]])

matrix3 = matrix1 * matrix2

sum = 0

for i in range(3):

sum += matrix3[i, i]

print(sum)

该代码将输出矩阵 matrix3 对角元素之和。

4、可以使用以下代码创建一个 2*3 的矩阵，并与 1 创建的矩阵进行点乘：

matrix4 = np.mat([[13, 14, 15], [16, 17, 18]])

matrix5 = np.multiply(matrix1, matrix4)

该代码将生成一个新的矩阵 matrix5，其中每个元素都是对应位置上两个矩阵元素的积。

相关问题

3、使用mat函数创建一个3*2矩阵，并与1创建的矩阵相乘，然后求该3*3矩阵对角元素之和 4、再创建一个2*3矩阵，并与1创建的矩阵点乘

抱歉，我可以回答您的问题。

针对您的第一个问题：

首先使用mat函数创建一个3*2矩阵：

import numpy as np

mat1 = np.mat([[1,2],[3,4],[5,6]])

然后与1创建的矩阵相乘：

mat2 = mat1 * np.mat([[1],[1]])

最后求该3*3矩阵对角元素之和：

sum_diag = np.trace(np.mat(np.eye(3)) * mat2)

所以，对角元素之和为：

11

针对您的第二个问题：

创建一个2*3矩阵：

mat3 = np.mat([[2,3,4],[5,6,7]])

然后与1创建的矩阵点乘：

mat4 = np.multiply(mat1,mat3)

请注意，第一个矩阵的列数必须等于第二个矩阵的行数才能进行点乘。所以这里需要将mat3转置（变成3*2矩阵）才可以进行点乘。

最后输出矩阵mat4的结果：

[[ 2  6]
 [15 24]
 [30 42]]

编写并测试3*3矩阵转置函数，使用数组保存3*3矩阵

### 回答1：
以下是一个简单的3*3矩阵转置函数的示例代码，使用数组保存矩阵：

def transpose(matrix):
    # 创建一个新的3*3矩阵
    result = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
    # 遍历原矩阵，将每个元素转置到新矩阵中对应位置
    for i in range(3):
        for j in range(3):
            result[j][i] = matrix[i][j]
    return result

# 测试代码
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(transpose(matrix))

输出结果为：

[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

这个函数接受一个3*3的矩阵作为参数，返回一个新的3*3矩阵，其中每个元素都是原矩阵对应位置的转置。我们可以使用这个函数来测试不同的3*3矩阵。

### 回答2：
矩阵转置是一种常见的矩阵操作，其目的是将一个矩阵的行与列对调。例如，一个3×3的矩阵：

1 2 3

4 5 6

7 8 9

其转置矩阵为：

1 4 7

2 5 8

3 6 9

在编写这个3×3矩阵转置函数之前，我们需要先定义一个数组来保存矩阵。我们可以使用二维数组来表示一个矩阵，该数组可以定义为：

int matrix[3][3];

该数组表示一个3×3的矩阵。接下来，我们需要编写这个矩阵转置函数。该函数的输入参数应该是一个3×3的矩阵的地址，函数的返回值应该是转置后的新矩阵的地址。

int* transpose(int* matrix) {
int i, j;
static int newMatrix[3][3];

for(i=0; i<3; i++) {
for(j=0; j<3; j++) {
newMatrix[j][i] = *(matrix+i*3+j);
}
}

return (int*)newMatrix;
}

在该函数中，我们定义了一个新的3×3矩阵newMatrix来保存转置后的矩阵，该矩阵是静态的，因此其存储地址是一直不变的。在函数的主循环中，我们对输入的矩阵进行遍历，并将其转置后的元素保存到新矩阵中。由于这个新矩阵newMatrix是静态变量，因此可以直接返回该矩阵的地址。

最后，我们需要对这个函数进行测试。我们首先定义一个3×3的矩阵，将其填充为：

1 2 3

4 5 6

7 8 9

然后我们调用这个函数，将输出一个转置后的新矩阵：

1 4 7

2 5 8

3 6 9

完整的测试代码如下：

#include <stdio.h>

int* transpose(int*);

int main() {
int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int* newMatrix = transpose((int*)matrix);

int i, j;
for(i=0; i<3; i++) {
for(j=0; j<3; j++) {
printf("%d ", *(newMatrix+i*3+j));
}
printf("\n");
}

return 0;
}

在该测试代码中，我们首先定义了一个3×3的矩阵matrix，然后将其地址作为参数调用transpose函数。该函数返回一个转置后的新矩阵的地址，我们将其赋给一个指向int的指针newMatrix。最后我们遍历这个新矩阵，并将其元素打印输出。

通过这个测试代码，我们可以验证这个3×3矩阵转置函数是否正确。

### 回答3：
矩阵转置是线性代数中的基本操作之一，在计算机科学领域中经常会涉及到矩阵转置。编写一个3*3矩阵转置函数的主要任务是将矩阵的行与列互换，以得到转置后的矩阵。在本文中，我们将简要介绍如何编写并测试这个功能。

第一步是定义一个3*3矩阵的数组，并为该数组中的所有元素分配内存。我们可以使用静态数组或动态数组来实现这一点。静态数组可以使用以下代码来声明：

int matrix[3][3];

动态数组则需要使用 `malloc` 函数来分配内存。例如：

int **matrix = (int **) malloc(sizeof(int*) * 3);
for (int i = 0; i < 3; i++) {
    matrix[i] = (int *) malloc(sizeof(int) * 3);
}

接着，我们需要编写一个函数来将矩阵转置。该函数会接收一个3x3的矩阵数组，并按以下步骤进行处理：

1. 按照行遍历矩阵。
2. 对于每一行中的每个元素，将其与位于相同位置的列元素进行交换。
3. 重复步骤1和2，直到遍历完所有的行和列。

以下是示例代码，用于展示如何实现矩阵转置函数：

void transpose(int matrix[3][3]) {
    for (int i = 0; i < 3; i++) {
        for (int j = i; j < 3; j++) {
            int temp = matrix[i][j];
            matrix[i][j] = matrix[j][i];
            matrix[j][i] = temp;
        }
    }
}

在这个例子中，我们可以使用双重循环来遍历矩阵。第一个循环变量 `i` 控制当前行的索引，而第二个循环变量 `j` 控制当前列的索引。我们使用 `temp` 临时变量来完成行与列的交换操作。

最后，我们需要编写一些测试用例来验证矩阵转置函数是否正确。我们可以使用下面的代码来创建一个3x3的矩阵，并将其填充为递增的自然数序列。例如：

int matrix[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

我们可以将该矩阵传递给矩阵转置函数，然后比较转置后的矩阵与期望结果是否一致。例如：

transpose(matrix);
assert(matrix[0][0] == 1);
assert(matrix[0][1] == 4);
assert(matrix[0][2] == 7);
assert(matrix[1][0] == 2);
assert(matrix[1][1] == 5);
assert(matrix[1][2] == 8);
assert(matrix[2][0] == 3);
assert(matrix[2][1] == 6);
assert(matrix[2][2] == 9);

在这个例子中，我们使用 `assert` 函数来检查转置矩阵是否与我们期望的结果一致。

总之，编写并测试3x3矩阵转置函数需要以下步骤：

1. 定义一个3x3的矩阵数组，并为其分配内存。
2. 编写一个函数来实现矩阵转置。
3. 编写测试用例来验证函数的正确性。