programming python

Tổng các phần tử trong ma trận trong python

Trong bài viết này, chúng tôi đã giải thích cách tìm Tổng tuyệt đối của các phần tử trong ma trận Numpy với ví dụ mã Python hoàn chỉnh

Mục lục

Tổng tuyệt đối các phần tử trong ma trận Numpy
Tổng bình thường
Sự kết luận

Tổng tuyệt đối các phần tử trong ma trận Numpy

Để tìm Tổng tuyệt đối các phần tử trong ma trận Numpy, chúng ta cần làm theo các bước sau

Lấy giá trị tuyệt đối của các phần tử trong ma trận Numpy [dùng

import numpy as np
matrix = np.array[[[1.94353, -2.13254, 3.00845], [-4.3423, 5.5675, -6.01029]]]
print ["Original matrix = "]
print [matrix]

sum = np.nansum[matrix, dtype=np.float64]
print ["Sum = "]
print [sum]

Tìm tổng các phần tử của ma trận được cập nhật [sử dụng

import numpy as np
matrix = np.array[[[1.94353, -2.13254, 3.00845], [-4.3423, 5.5675, -6.01029]]]
print ["Original matrix = "]
print [matrix]

sum = np.nansum[matrix, dtype=np.float64]
print ["Sum = "]
print [sum]

Đoạn mã như sau

abs_matrix = np.abs[matrix]
abs_sum = np.nansum[abs_matrix, dtype=np.float64]

Ghi chú

dtype là kiểu dữ liệu của đầu ra tổng. Chúng tôi đã đặt nó thành float 64 bit để tránh tràn
abs_matrix có giá trị tuyệt đối của tất cả các phần tử trong ma trận ban đầu
nansum đưa ra tổng của tất cả các phần tử trong abs_matrix không có phần tử âm. nansum sẽ tránh các giá trị nan trong ma trận

Ví dụ mã Python hoàn chỉnh như sau

import numpy as np
matrix = np.array[[[1.94353, -2.13254, 3.00845], [-4.3423, 5.5675, -6.01029]]]
print ["Original matrix = "]
print [matrix]

abs_matrix = np.abs[matrix]
abs_sum = np.nansum[abs_matrix, dtype=np.float64]
print ["Absolute sum = "]
print [abs_sum]

đầu ra

Original matrix = 
[[ 1.94353 -2.13254  3.00845]
 [-4.3423   5.5675  -6.01029]]

Absolute sum = 
23.00461

Tổng bình thường

Bây giờ, sự khác biệt giữa tổng tuyệt đối và tổng bình thường là rất quan trọng đối với một số dữ liệu vì trong tổng bình thường, số âm và số dương có xu hướng triệt tiêu lẫn nhau

Khi bạn đang sử dụng tổng làm số liệu để so sánh dữ liệu/ma trận Numpy, điều quan trọng là sử dụng tổng tuyệt đối

Ví dụ mã Python hoàn chỉnh như sau

import numpy as np
matrix = np.array[[[1.94353, -2.13254, 3.00845], [-4.3423, 5.5675, -6.01029]]]
print ["Original matrix = "]
print [matrix]

sum = np.nansum[matrix, dtype=np.float64]
print ["Sum = "]
print [sum]

đầu ra

Original matrix = 
[[ 1.94353 -2.13254  3.00845]
 [-4.3423   5.5675  -6.01029]]

Sum = 
-1.965650000000001

Ghi chú

Tổng tuyệt đối là 23. 00461
Tổng bình thường là -1. 965650000000001
Sự khác biệt giữa hai giá trị là đáng kể

Sự kết luận

Với bài viết này tại OpenGenus, bạn phải có ý tưởng hoàn chỉnh về cách lấy tổng tuyệt đối của ma trận Numpy một cách dễ dàng chỉ với hai dòng mã

Hàm NumPy

import numpy as np
matrix = np.array[[[1.94353, -2.13254, 3.00845], [-4.3423, 5.5675, -6.01029]]]
print ["Original matrix = "]
print [matrix]

sum = np.nansum[matrix, dtype=np.float64]
print ["Sum = "]
print [sum]

4 trong python được sử dụng để trả về tổng/tổng của tất cả các phần tử trên một mảng đã cho. Hàm này nhận một số đối số, trong đó sử dụng đối số


# Syntax of sum[]
numpy.sum[array, axis=None, dtype=None, out=None, keepdims=, initial=]

0 để chỉ định kiểu dữ liệu được trả về và sử dụng đối số


# Syntax of sum[]
numpy.sum[array, axis=None, dtype=None, out=None, keepdims=, initial=]

1 để chỉ định giá trị ban đầu cần xem xét cho tổng

Sử dụng chức năng này, bạn có thể làm như sau

Lấy tổng của tất cả các phần tử mảng của mảng đã cho,
Lấy tổng của mỗi hàng trên một trục được chỉ định và
Lấy tổng của mỗi cột của một mảng nhất định

Trong bài viết này, tôi sẽ giải thích cú pháp của hàm numpy sum[], các đối số khác nhau mà hàm này sử dụng và cách sử dụng hàm này bằng các ví dụ như cách tính các giá trị tổng của mảng đã cho. Để biết thêm ví dụ về NumPy, hãy tham khảo Hướng dẫn NumPy

1. Ví dụ nhanh về Hàm NumPy Sum

Nếu bạn đang vội, dưới đây là một số ví dụ nhanh về cách sử dụng hàm sum[] của NumPy


# Below are the quick examples

# Example 1: # Create a numpy array
# Get the sum of an array 
arr = np.array[[14, 17, 19, 22]]
sum = np.sum[arr]

# Example 2: Create 2-D numpy array
# Get the Sum of all the elements in an array            
arr = np.array[[[12, 14], [17, 19],[13, 16],[24, 27]]]
sum = np.sum[arr]

# Example 3: Get the sum of each column element along axis = 0
sum = np.sum[arr, axis=0]

# Example 4: Get the sum of each row element along axis = 1
sum = np.sum[arr, axis=1]

# Example 5: Get the sum of an array to specify data type 
sum = np.sum[arr, axis=1, dtype=float]

# Example 6: Specify an initial value for the sum
sum = np.sum[arr, axis=1, initial=15]

# Example 7: Get the sum using nansum[]
arr = np.array[[[2, 3], [4, np.nan]]]
arr1 = np.nansum[arr]

2. Cú pháp tổng[]

Sau đây là cú pháp của hàm sum[]


# Syntax of sum[]
numpy.sum[array, axis=None, dtype=None, out=None, keepdims=, initial=]

2. 1 Các tham số của sum[]

Dưới đây là các tham số của hàm sum[]


# Syntax of sum[]
numpy.sum[array, axis=None, dtype=None, out=None, keepdims=, initial=]

2 – Mảng đầu vào, trong đó các phần tử được tính dưới dạng tổng

```
# Syntax of sum[]
numpy.sum[array, axis=None, dtype=None, out=None, keepdims=, initial=]
```
3 – Trục hoặc các trục dọc theo đó một tổng được thực hiện. Giá trị mặc định, axis=None, nó tính tổng tất cả các phần tử của mảng đầu vào. Nếu trục âm, số đếm bắt đầu từ trục cuối cùng đến trục đầu tiên. axis = 0 có nghĩa là dọc theo cột và axis = 1 có nghĩa là làm việc dọc theo hàng
```
# Syntax of sum[]
numpy.sum[array, axis=None, dtype=None, out=None, keepdims=, initial=]
```
0 – Bạn có thể sử dụng dtype để chỉ định loại dữ liệu đầu ra được trả về
```
# Syntax of sum[]
numpy.sum[array, axis=None, dtype=None, out=None, keepdims=, initial=]
```
5 – Mảng đầu ra thay thế để đặt kết quả. Mảng phải có cùng kích thước với đầu ra dự kiến. Mặc định là Không có
```
# Syntax of sum[]
numpy.sum[array, axis=None, dtype=None, out=None, keepdims=, initial=]
```
6 – keepdims là một tham số boolean. Nếu điều này được đặt thành True, các trục bị giảm sẽ được để lại trong kết quả dưới dạng kích thước với kích thước một


# Syntax of sum[]
numpy.sum[array, axis=None, dtype=None, out=None, keepdims=, initial=]

1 – Tham số ban đầu cung cấp giá trị Bắt đầu cho tổng

2. 2 Giá trị trả về của tổng[]

Nó trả về một mảng, nó chứa tổng các phần tử của mảng đầu vào cùng với trục đã chỉ định. Nếu trục = Không thì nó sẽ trả về một giá trị vô hướng

3. Cách sử dụng hàm NumPy sum[]

Hàm sum[] trong gói NumPy của Python dùng để tính tổng tất cả các phần tử, tổng từng hàng, tổng từng cột của một mảng cho trước

3. 1 Lấy Tổng của Mảng 1-D

Hãy xem cách tính tổng của tất cả các phần tử của mảng 1 chiều. Để làm như vậy trước tiên, hãy khởi tạo mảng 1-D NumPy bằng cách sử dụng


# Syntax of sum[]
numpy.sum[array, axis=None, dtype=None, out=None, keepdims=, initial=]

8 và chuyển mảng này làm đầu vào cho hàm sum[]

import numpy as np
matrix = np.array[[[1.94353, -2.13254, 3.00845], [-4.3423, 5.5675, -6.01029]]]
print ["Original matrix = "]
print [matrix]

abs_matrix = np.abs[matrix]
abs_sum = np.nansum[abs_matrix, dtype=np.float64]
print ["Absolute sum = "]
print [abs_sum]

3. 2 Lấy tổng của mảng 2 chiều

Hãy tính tổng tất cả các phần tử của mảng 2 chiều. Khi sử dụng mảng 2 chiều, nó xem xét tất cả các giá trị trong mảng để tính tổng và trả về một giá trị vô hướng. Nó coi


# Syntax of sum[]
numpy.sum[array, axis=None, dtype=None, out=None, keepdims=, initial=]

9 theo mặc định. Lưu ý rằng nó không tính tổng của từng hàng hoặc tổng của từng cột thay vào đó tính tổng của tất cả các giá trị

import numpy as np
matrix = np.array[[[1.94353, -2.13254, 3.00845], [-4.3423, 5.5675, -6.01029]]]
print ["Original matrix = "]
print [matrix]

abs_matrix = np.abs[matrix]
abs_sum = np.nansum[abs_matrix, dtype=np.float64]
print ["Absolute sum = "]
print [abs_sum]

4. Lấy tổng của mỗi cột của mảng 2 chiều

Để tính tổng cho từng cột của mảng NumPy, hãy chỉ định

import numpy as np
matrix = np.array[[[1.94353, -2.13254, 3.00845], [-4.3423, 5.5675, -6.01029]]]
print ["Original matrix = "]
print [matrix]

abs_matrix = np.abs[matrix]
abs_sum = np.nansum[abs_matrix, dtype=np.float64]
print ["Absolute sum = "]
print [abs_sum]

60. Điều này giúp bạn tính tổng dọc theo trục cột khi bạn có mảng 2 chiều. Điều này trả về ndarray có kích thước bằng với số lượng cột trong mảng của bạn

Original matrix = 
[[ 1.94353 -2.13254  3.00845]
 [-4.3423   5.5675  -6.01029]]

Absolute sum = 
23.00461

5 Lấy Tổng của Mỗi Hàng của Mảng 2-D

Tương tự, để tính tổng cho mỗi hàng, hãy chỉ định

import numpy as np
matrix = np.array[[[1.94353, -2.13254, 3.00845], [-4.3423, 5.5675, -6.01029]]]
print ["Original matrix = "]
print [matrix]

abs_matrix = np.abs[matrix]
abs_sum = np.nansum[abs_matrix, dtype=np.float64]
print ["Absolute sum = "]
print [abs_sum]

61. Điều này giúp bạn tính tổng dọc theo trục hàng. Điều này trả về ndarray có kích thước bằng với số hàng trong mảng của bạn

Original matrix = 
[[ 1.94353 -2.13254  3.00845]
 [-4.3423   5.5675  -6.01029]]

Absolute sum = 
23.00461

6. Chỉ định loại giá trị trả về

Theo mặc định, kiểu trả về của NumPy

import numpy as np
matrix = np.array[[[1.94353, -2.13254, 3.00845], [-4.3423, 5.5675, -6.01029]]]
print ["Original matrix = "]
print [matrix]

sum = np.nansum[matrix, dtype=np.float64]
print ["Sum = "]
print [sum]

4 sẽ bằng với kiểu phần tử mảng đầu vào của bạn. Trong các ví dụ trên của chúng tôi, chúng tôi có các mảng kiểu

import numpy as np
matrix = np.array[[[1.94353, -2.13254, 3.00845], [-4.3423, 5.5675, -6.01029]]]
print ["Original matrix = "]
print [matrix]

abs_matrix = np.abs[matrix]
abs_sum = np.nansum[abs_matrix, dtype=np.float64]
print ["Absolute sum = "]
print [abs_sum]

63 do đó, kết quả cũng ở kiểu int. Hãy thay đổi điều này bằng cách chỉ định đối số dtype. Sử dụng đối số này, bạn có thể chỉ định kiểu trả về của hàm sum[]

Ví dụ sau tính tổng cho mỗi hàng và trả về tổng ở kiểu float

Original matrix = 
[[ 1.94353 -2.13254  3.00845]
 [-4.3423   5.5675  -6.01029]]

Absolute sum = 
23.00461

7. Xem xét giá trị ban đầu cho NumPy sum[]

Bạn cũng có thể bắt đầu tính tổng với một giá trị ban đầu khác 0 bằng cách sử dụng đối số


# Syntax of sum[]
numpy.sum[array, axis=None, dtype=None, out=None, keepdims=, initial=]

1. Khi sử dụng đối số


# Syntax of sum[]
numpy.sum[array, axis=None, dtype=None, out=None, keepdims=, initial=]

1, hàm sum[] bắt đầu với giá trị ban đầu này và thêm tất cả các phần tử vào đó để nhận giá trị tổng/tổng cuối cùng

Original matrix = 
[[ 1.94353 -2.13254  3.00845]
 [-4.3423   5.5675  -6.01029]]

Absolute sum = 
23.00461

8. Nhận tổng bằng cách sử dụng np. NaN

Nếu bạn có các giá trị

import numpy as np
matrix = np.array[[[1.94353, -2.13254, 3.00845], [-4.3423, 5.5675, -6.01029]]]
print ["Original matrix = "]
print [matrix]

abs_matrix = np.abs[matrix]
abs_sum = np.nansum[abs_matrix, dtype=np.float64]
print ["Absolute sum = "]
print [abs_sum]

66 trong mảng của mình, việc áp dụng hàm sum[] sẽ dẫn đến kết quả đầu ra là

import numpy as np
matrix = np.array[[[1.94353, -2.13254, 3.00845], [-4.3423, 5.5675, -6.01029]]]
print ["Original matrix = "]
print [matrix]

abs_matrix = np.abs[matrix]
abs_sum = np.nansum[abs_matrix, dtype=np.float64]
print ["Absolute sum = "]
print [abs_sum]

67. Để khắc phục điều này, hãy sử dụng hàm

import numpy as np
matrix = np.array[[[1.94353, -2.13254, 3.00845], [-4.3423, 5.5675, -6.01029]]]
print ["Original matrix = "]
print [matrix]

abs_matrix = np.abs[matrix]
abs_sum = np.nansum[abs_matrix, dtype=np.float64]
print ["Absolute sum = "]
print [abs_sum]

68, nansum[] được sử dụng để tính tổng của mảng bỏ qua các giá trị nan. Hàm này cũng được sử dụng để tính tổng tất cả các phần tử, tổng từng hàng và tổng từng cột của một mảng nhất định bằng cách bỏ qua các giá trị NaN

import numpy as np
matrix = np.array[[[1.94353, -2.13254, 3.00845], [-4.3423, 5.5675, -6.01029]]]
print ["Original matrix = "]
print [matrix]

sum = np.nansum[matrix, dtype=np.float64]
print ["Sum = "]
print [sum]

7. Sự kết luận

Trong bài viết này, tôi đã giải thích cách sử dụng hàm tổng Python NumPy[]. Sử dụng hàm này để tính tổng của các phần tử mảng cùng với trục, kiểu dữ liệu và giá trị ban đầu đã chỉ định với các ví dụ. Và cũng tìm hiểu điều gì sẽ xảy ra nếu bạn có các giá trị NaN trong mảng và cách khắc phục điều này bằng cách sử dụng hàm nansum[]