## Python Matrix: Simple Creation and Operations

Python is a powerful and versatile language that is widely used in data science, machine learning, and artificial intelligence. One of the fundamental structures that are used in these fields is a matrix.

A matrix is a collection of numbers arranged in a grid or table, which is used to perform mathematical operations such as addition, subtraction, multiplication, and division. This article will provide you with a comprehensive guide on how to create and perform operations on a Python matrix.

### 1. Creation of Python Matrix

To create a Python matrix, there are several approaches that you can use.

The two most common are the use of lists and the `arange()`

function.

The first method involves creating a list of lists, where each list represents a row in the matrix.

For example, to create a 3-by-3 matrix with values 1, 2, 3, 4, 5, 6, 7, 8, and 9, you can use the following code:

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

Alternatively, you can use the `arange()`

function from the NumPy library to create a matrix. This function generates a sequence of evenly spaced numbers over a specified interval.

For example, to create the same matrix as above, you can use the following code:

## import numpy as np

`matrix_arange = np.array(np.arange(1,10)).reshape(3,3)`

The `reshape()`

function is used to convert the 1-dimensional array returned by `arange()`

into a 2-dimensional array of the desired shape. Another method of creating a Python matrix is by using the `matrix()`

function from the NumPy library.

This function takes a list-like object as input and returns a matrix. For example:

## import numpy as np

`matrix_np = np.matrix(matrix_lists)`

### 2. Operations on Python Matrix

Once you have created a Python matrix, you can perform a wide range of operations on it, including addition, subtraction, division, and exponentiation.

Addition and subtraction of two matrices can only be done when the matrices have the same shape. Addition and subtraction of matrices are done by adding or subtracting corresponding elements in the matrices.

For example, suppose you have two 2-by-2 matrices, A and B, and you want to add them. The resulting matrix, C, will have the same shape as A and B, and each element in C will be the sum of the corresponding elements in A and B.

## The code to perform this operation is as follows:

```
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
C = A + B
```

## The resulting matrix C will have the following values:

```
[[ 6 8]
[10 12]]
```

Similarly, subtraction of two matrices can be done by using the `-`

operator in place of `+`

:

`C = A - B`

Matrix division is not as straightforward as addition and subtraction, due to matrix algebra. Matrix division is equivalent to multiplying the first matrix by the inverse of the second matrix.

However, not all matrices have an inverse, so not all matrices can be divided. Generally, matrix division is not used as frequently as other operations.

Matrix exponentiation is another common operation that you can perform on a Python matrix. This operation involves raising each element in the matrix to a power.

For example, suppose you have a 2-by-2 matrix A and you want to square it. The resulting matrix, B, will have the same shape as A, and each element in B will be the square of the corresponding element in A.

## The code to perform this operation is as follows:

```
A = np.array([[1, 2], [3, 4]])
B = np.power(A, 2)
```

## The resulting matrix B will have the following values:

```
[[ 1 4]
[ 9 16]]
```

### 3. Addition of Python Matrix

Addition of two matrices using the traditional method involves using nested loops to add corresponding elements in the matrices.

## For example:

```
matrix1 = [[1,2,3], [4,5,6], [7,8,9]]
matrix2 = [[9,8,7], [6,5,4], [3,2,1]]
result = [[0,0,0], [0,0,0], [0,0,0]]
for i in range(len(matrix1)):
for j in range(len(matrix1[0])):
result[i][j] = matrix1[i][j] + matrix2[i][j]
```

## The resulting result matrix will be:

```
[[10, 10, 10],
[10, 10, 10],
[10, 10, 10]]
```

Using the `+`

operator, addition of two matrices can be done in a single line of code. For example:

```
matrix1 = np.array([[1,2,3], [4,5,6], [7,8,9]])
matrix2 = np.array([[9,8,7], [6,5,4], [3,2,1]])
result = matrix1 + matrix2
```

The resulting matrix will be the same as with the traditional method.

Using the `+`

operator is more efficient than using nested for-loops, especially for large matrices. Additionally, it is more readable and saves time.

### 3. Matrix Multiplication in Python

Matrix multiplication is an essential operation in linear algebra and is widely used in various applications such as image processing, signal processing, and machine learning.

In Python, you can perform matrix multiplication using the scalar product and the matrix product. 3.1 Scalar Product

The scalar product is a multiplication between a single scalar value and every element of a matrix.

To implement scalar product, you can use simple arithmetic operations in Python. For example:

```
matrix = np.array([[1, 2], [3, 4]])
scalar_value = 2
result = scalar_value * matrix
```

## The resulting matrix will be:

```
[[2, 4],
[6, 8]]
```

The scalar product can be useful in scaling an image, contrast, brightness, or any numerical values that require uniform transformation.

#### 3.2 Matrix Product

Matrix product, on the other hand, is a more complicated method that involves multiplying two matrices, resulting in a new matrix. Matrix product can only be performed if the number of columns in the first matrix is equal to the number of rows in the second matrix.

In Python, you can perform the matrix product using the `numpy.dot()`

function. For example:

```
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
result = np.dot(matrix1, matrix2)
```

## The resulting matrix will be:

```
[[19, 22],
[43, 50]]
```

In the above example, the number of columns in `matrix1`

(2 columns) is equal to the number of rows in `matrix2`

(2 rows), which allows us to perform the matrix product using the `dot()`

function.

Aside from using `numpy.dot()`

, matrix product can also be performed using matrix multiplication operators (`@`

or `*`

) in Python 3.5+. The code below achieves the same result as the previous example:

```
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
result = matrix1 @ matrix2
```

### 4. Subtraction of Python Matrix

Subtraction is another commonly used operation in matrix arithmetic. You can subtract two matrices of the same shape by subtracting the corresponding elements in each matrix.

In Python, you can do this easily using the `-`

operator. For example:

```
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
result = matrix1 - matrix2
```

## The resulting matrix will be:

```
[[-4, -4],
[-4, -4]]
```

In the above example, the corresponding elements in `matrix1`

and `matrix2`

are subtracted, leading to the resulting matrix.

Subtraction of matrices can be useful in finding the difference between two images, signals, or any numerical values.

### 5. Transpose of a Python Matrix

The transpose of a matrix is an operation that switches the rows and columns of a matrix, resulting in a new matrix with the dimensions switched.

Specifically, if you have an m by n matrix A, its transpose will be an n by m matrix A^T. In Python, you can perform the transpose operation using the `numpy.transpose()`

function.

For example, suppose you have a 2-by-3 matrix A:

`A = np.array([[1, 2, 3], [4, 5, 6]])`

You can obtain its transpose, denoted as A^T, using the `transpose()`

function as follows:

`AT = np.transpose(A)`

## print(AT)

## The output will be:

```
[[1, 4],
[2, 5],
[3, 6]]
```

As you can see, the transpose operation has switched the rows and columns of the original matrix. It’s essential to note that the transpose operation works for matrices of any size.

Therefore, if you have matrices with different sizes, it will result in different transposed matrices. 6.

### 6. Matrix Multiplication Operation using NumPy Methods

Matrix multiplication is a crucial operation in linear algebra. In Python, you can perform the matrix multiplication using the `numpy.multiply()`

and `numpy.matmul()`

methods.

#### 6.1 Using the `multiply()`

method

The `numpy.multiply()`

method multiplies two matrices element-wise, resulting in a new matrix. For example:

```
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
result = np.multiply(matrix1, matrix2)
```

## print(result)

## The output will be:

```
[[ 5, 12],
[21, 32]]
```

The method multiplies each element in the first matrix with the corresponding element in the second matrix. It should be noted that the two matrices must have the same dimensions to perform this operation.

#### 6.2 Using the `matmul()`

method

The `numpy.matmul()`

method multiplies two matrices in a traditional matrix multiplication sense. Specifically, it takes the dot product of each row of the first matrix with each column of the second matrix, resulting in a new matrix.

The matrices’ dimensions must satisfy the matrix multiplication rule, which is the number of columns in the first matrix must be equal to the number of rows in the second matrix. For example:

```
matrix1 = np.array([[1, 2], [3, 4], [5, 6]])
matrix2 = np.array([[5, 6, 7], [7, 8, 9]])
result = np.matmul(matrix1, matrix2)
```

## print(result)

## The output will be:

```
[[19, 22, 25],
[43, 50, 57],
[67, 78, 89]]
```

The new matrix’s row and column dimensions are equal to the dimensions of the first and second matrix’s row and column dimensions, respectively. It’s essential to note that the `numpy.matmul()`

method is generally faster and more efficient than using nested for loops or other methods to perform matrix multiplication.

### 7. NumPy Matrix Transpose

NumPy is a widely used Python library for numerical computing.

It provides numerous functions for working with arrays, matrices, and other mathematical operations. In this section, we will discuss how to transpose a matrix using the NumPy `transpose()`

function.

The transpose of a matrix is an operation that switches the rows and columns of a matrix, resulting in a new matrix with the dimensions switched. Specifically, if you have an m by n matrix A, its transpose will be an n by m matrix AT, where each element in the new matrix AT is located in the position where the corresponding element from the original matrix A would be.

To perform a matrix transpose using NumPy, you can use the `transpose()`

function provided by the NumPy library. The function takes a matrix as an argument and returns a new matrix that is the transpose of the original matrix.

Note that the `transpose()`

function is mainly used with 2-D arrays and matrices. Consider the following code that demonstrates how to transpose a matrix using the NumPy `transpose()`

function:

## import numpy as np

```
# create a matrix
matrix = np.array([[1, 2], [3, 4], [5, 6]])
# transpose the matrix using the transpose() function
transposed_matrix = np.transpose(matrix)
print(transposed_matrix)
```

## The output of the code will be:

```
[[1, 3, 5],
[2, 4, 6]]
```

Here, we create a 3 by 2 matrix using NumPy’s `array()`

function. We then use the `transpose()`

function to create a new matrix that is the transpose of the original matrix.

The resulting matrix has dimensions of 2 by 3. Notice how the rows and columns have been interchanged to obtain the transpose.

## You can also use the shorthand `T`

to achieve the same result:

`transposed_matrix = matrix.T`

This is a simple and convenient way to transpose a matrix using NumPy.

It is also essential to note that transpose operation works for matrices of any size. Therefore, if you have matrices with different sizes, it will result in different transposed matrices.

## Conclusion

In conclusion, NumPy provides a straightforward and efficient way to transpose matrices. The transpose operation switches the rows and columns of a matrix, resulting in a new matrix with dimensions opposite of the original matrix.

The NumPy `transpose()`

function can be used to perform this operation easily in Python. By understanding this concept and method, you can perform various tasks involving matrix operations, signal processing, and machine learning.

In conclusion, this article has covered several essential concepts in matrix operations, including matrix multiplication, subtraction, addition, and transpose. These operations are fundamental in linear algebra and are widely used in various scientific fields, including machine learning and data science.

Python’s pervasive library, NumPy, provides different methods to perform matrix operations, making it easier to work with matrices and arrays. By understanding these concepts and their implementation using NumPy, readers can apply them to real-world problems.

Therefore, it’s crucial to develop a good foundation in linear algebra and NumPy to become proficient in data science.