Hướng dẫn how do you get a row and column of a matrix without numpy in python? - làm thế nào để bạn có được một hàng và cột của ma trận mà không có numpy trong python?

Chuỗi các đối tượng dọc trong ma trận Python thường được gọi là các cột của người Viking, trong khi loạt thứ nằm ngang được gọi là các hàng trên mạng. Giống như một danh sách lồng nhau, các hàng và cột được đặt trên đầu nhau. Nếu một ma trận có các hàng của K K K K và các cột M M, và nếu là K K K và Mùi là các số nguyên dương, thì thứ tự của một đối tượng ma trận như vậy được xác định bởi K-by-m.

Một ma trận có thể giữ các chuỗi, số và các loại đối tượng dữ liệu khác. Trong một ma trận, dữ liệu được xếp chồng lên cả hai cột và hàng. Một cấu trúc dữ liệu chính hỗ trợ các tính toán trong khoa học và toán học là ma trận. Vì Python không cung cấp loại tích hợp cho đối tượng ma trận, chúng tôi coi danh sách giữa các danh sách hoặc thậm chí là danh sách lồng nhau dưới dạng ma trận.

Dữ liệu được viết trong một mảng hai chiều để tạo ma trận. Thủ tục như sau:

[[13579] & nbsp; [246810] & nbsp; & nbsp; [0874]][1 3 5 7 9 ]
  [2 4 6 8 10]  
  [0 8 7 4]]

Nó có ma trận 3 x 5 làm màn hình của nó. Do đó, kích thước của nó là 3 x 5. Dữ liệu bên trong ma trận này bao gồm các đối tượng của số nguyên kiểu dữ liệu. Hàng trên cùng, hàng1, có các giá trị 1, 3, 5, 7 và 9, trong khi hàng2, cùng với hàng3, có các giá trị (2, 4, 6, 8) và tương ứng (0, 8, 7, 4) . Cột1 chứa các giá trị của (1, 2, 0) cũng như cột2 có các giá trị là (3, 4, 8), v.v.

Python cho phép chúng tôi lưu trữ tất cả dữ liệu trong một ma trận với hai chiều. Chúng ta có thể thêm ma trận, nhân chúng, chuyển chúng và thực hiện các hoạt động khác trên ma trận. Sử dụng các mảng, chúng tôi có thể xây dựng một ma trận Python và sử dụng nó tương tự. Hãy để nói về các ví dụ khác nhau về ma trận Python.

Bổ sung ma trận Python

Chúng tôi sẽ lấy hai ma trận và thêm chúng vào lặp qua chúng bằng cách sử dụng một vòng lặp cho vòng lặp.

Matrix1 = [[2,4,1], & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; [4,1,5], & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; [3,6,7]]= [[2, 4, 1],    
           [4, 1, 5],    
           [3, 6, 7]]

& nbsp; & nbsp; Matrix2 = [[4,2, -1], & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; [5,6, -3], & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; [0, -4,3]]= [[4, 2, -1],    
           [5, 6, -3],    
           [0, -4, 3]]

& nbsp; & nbsp; Matrix3 & nbsp; = [[0,1,0], & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; [1,0,0], & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; [0,0,1]]= [[0,1,0],    
            [1,0,0],    
            [0,0,1]]

& nbsp; Matrix4 & nbsp; = [[0,0,1], & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; [0,1,0], & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; [1,0,0]]= [[0,0,1],    
            [0,1,0],    
            [1,0,0]]

Matrices_length = Len (Matrix1)= len(matrix1)

cho hàng Inrange (Len (Matrix1)): & nbsp; & nbsp; & nbsp; & nbsp; cho cột Inrange (LEN (Matrix2 [0])): & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; Matrix4 [hàng] [cột] = Matrix1 [hàng] [cột] + Matrix2 [Row] [Cột] + Matrix3 [Row] [Cột] row in range(len(matrix1)):    
    for column in range(len(matrix2[0])):    
        matrix4[row][column] = matrix1[row][column] + matrix2[row][column] + matrix3[row][column]

in ("tổng của ma trận là =", Matrix4)("The sum of the matrices is = ", matrix4)

Ban đầu, thay vì sử dụng Numpy, chúng tôi trực tiếp xây dựng ba ma trận có thứ tự 3 x 3. Chúng tôi đã chỉ định thứ tự hoặc độ dài của Ma trận 1 là hàm Len () và các loại khác, tương ứng. Sử dụng các vòng lặp lồng nhau, đầu tiên, ba ma trận đã được thêm vào. Tổng số ba ma trận sau đó được chỉ định là ma trận 4 và chúng tôi đã sử dụng hàm in () để hiển thị kết quả.

Chuyển một ma trận trong Python

Bằng cách hoán đổi các phần tử của các cột và hàng ma trận, chúng ta có thể chuyển chúng. Sử dụng các ví dụ khác nhau, chúng tôi sẽ chứng minh làm thế nào để có được sự chuyển đổi của ma trận bằng cách sử dụng Python mà không bị numpy.

Một chuyển vị ma trận được biểu thị bằng biểu tượng tại. Chẳng hạn, giả sử chúng ta có một ma trận là một thứ tự có thứ tự:

3-by-2

Sau đó, chuyển đổi của A là:

Ma trận 2 x 3

Tính toán chuyển đổi của một ma trận với sự trợ giúp của một vòng lặp lồng nhau

Vòng lặp lồng nhau có thể được sử dụng để lặp đi lặp lại qua các cột và các hàng của một danh sách lồng nhau. Chèn phần tử vào hàng của Ith Ith và cột JTH JTH của Ma trận F cùng với cột JTH JTH và cột Ith của Ma trận Ma trận F^tiêu để có được chuyển vị của ma trận. Cấm F^tiêu sẽ là một ma trận 2 x 3 giả định là F F Fiến là một ma trận 3 x 2.

F = [[2,3], [5,7], [8,1]]= [[2, 3],
[5, 7],
[8, 1]]

F_t = [[0,0,0], & nbsp; & nbsp; & nbsp; & nbsp; [0,0,0]]= [[0, 0, 0],
       [0, 0, 0]]

Đối với Q Inrange (Len (F)): & NBSP; & nbsp; cho w inrange (len (f [0])): & nbsp; & nbsp; & nbsp; & nbsp; F_t [w] [q] = f [q] [w] q in range(len(F)):
    for w in range(len(F[0])):
        F_T[w][q] = F[q][w]

cho q trong f_t: & nbsp; & nbsp; in (q) q in F_T:
    print(q)

Một ma trận chuyển vị của ma trận gốc và ma trận F F với thứ tự 3 x 2 được tạo lần đầu tiên. Chương trình trước đó sử dụng các vòng lặp cho các vòng lặp, liên tục lặp trên mỗi hàng và sau đó mỗi cột. Tại mỗi lần lặp, chúng tôi thêm một phần tử từ F [Q] [W], vào FT FT [W] [Q]. Cuối cùng, chúng tôi thực hiện phương thức in () để mô tả chuyển vị.

Sử dụng danh sách lồng nhau để tìm thấy sự chuyển đổi của ma trận

Một danh sách lồng nhau được tạo ra khi một danh sách hiểu được thực hiện bên trong sự hiểu biết danh sách khác. Sau đây là cú pháp để hiểu danh sách lồng nhau:

new_list = [[expr. cho một mục danh sách] cho một mục danh sách]= [[expr. for a list item] for a list item]

Tương tự như vậy, chúng ta có thể có được một ma trận chuyển vị bằng cách sử dụng danh sách lồng nhau để hiểu theo cách tiếp cận vòng lặp như vậy.

J = [[1,3], [4,6], [9,2]]= [[1, 3],
[4, 6],
[9, 2]]

J_t = [[j [v] [c] cho v inrange (len (j))] cho c inrange (len (j [0]))]]]= [[J[v][c] for v in range(len(J))] for c in range(len(J[0]))]

cho c trong j_t: & nbsp; & nbsp; in (c) c in J_T:
    print(c)

Chúng tôi bắt đầu bằng cách tạo ma trận, J J, có thứ tự 3 x-2. Danh sách lồng nhau được hiểu trong mã trước các vòng lặp trên các thành viên Ma trận Ma trận một lần tại một thời điểm và chèn các phần tử của J [V], một nơi nào đó tại vị trí của J_T [V]. Các cột ma trận được lặp lại trong suốt phần đầu tiên của sự hiểu biết danh sách lồng nhau như vậy, trong khi các hàng của nó được lặp lại trong cột thứ hai.

Nhân hai ma trận trong Python

Quá trình nhị phân của nhân ma trận tạo ra ma trận bằng hai ma trận. Sử dụng các vòng lặp lồng nhau và danh sách hiểu, chúng ta có thể nhân các ma trận trong Python.

Cột ma trận đầu tiên và số lượng hàng thứ hai phải khớp để hoàn thành phép nhân ma trận. Ma trận chúng tôi có ở cuối do phép nhân ma trận sẽ bao gồm cùng thứ tự với ma trận ban đầu. Một minh họa về phép nhân ma trận được hiển thị dưới đây.

Sử dụng danh sách lồng nhau để tìm phép nhân Ma trận

Một ma trận có thể được tạo bằng Python không chỉ là một danh sách lồng nhau, một loại danh sách trong danh sách. Một hàng ma trận tương ứng với mọi giá trị của danh sách lồng nhau. Hãy cùng xem một ví dụ của một vòng lặp lồng được sử dụng để nhân hai ma trận.

N = [[9,1,7], [3,5,6], [4,7,8]]]= [[9, 1, 7],
[3, 5, 6],
[4, 7, 8]]

M = [[2,3,5,6], [8,9,1,2], [4,5,9,3]]]]= [[2, 3, 5, 6],
[8, 9, 1, 2],
[4, 5, 9, 3]]

Kết quả = [[0,0,0,0], [0,0,0,0], [0,0,0,0]]]]= [[0, 0, 0, 0],
[0,0,0,0],
[0,0,0,0]]

cho u inrange (len (n)): & nbsp; & nbsp; cho o inrange (len (m [0])): & nbsp; & nbsp; & nbsp; & nbsp; cho p inrange (len (m)): & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; result [u] [o] += n [u] [p] * m [p] [o] cho d trong kết quả: & nbsp; & nbsp; in (d) u in range(len(N)):
    for o in range(len(M[0])):
        for p in range(len(M)):
            result[u][o] += N[u][p] * M[p][o]
for d in result:
    print(d)

Trong ví dụ này, chúng tôi sẽ sử dụng các vòng lặp lồng nhau để thực hiện một chương trình nhân lên hai ma trận, nhưng trước khi chúng tôi làm như vậy, chúng tôi sẽ tạo ra hai ma trận, N N N N N N N N N N N. By-4 theo thứ tự, tương ứng, cũng như ma trận thứ ba có thứ tự 3 x 4. Tiếp theo, chúng tôi trải qua một quá trình lặp lại, nơi chúng tôi sử dụng các phần tử của các hàng trong các n N N, các cột trong Mùi Miên và các hàng trong Mùi Miên. Chúng tôi đã áp dụng câu lệnh in để hiển thị phép nhân của các ma trận được xác định.

Sử dụng danh sách lồng nhau để tìm sự nhân của ma trận

Sự hiểu biết danh sách lồng nhau là quá trình thực hiện danh sách hiểu biết cùng nhau trong danh sách hiểu, dẫn đến một loại danh sách lồng nhau

Syntax:

# new_list = [[expr. cho một mục danh sách] cho một mục danh sách]

Tương tự như vậy, với cùng một phương pháp vòng lặp lồng nhau, chúng ta cũng có thể thực hiện phép nhân hai ma trận bằng cách sử dụng phương pháp hiểu danh sách lồng nhau một cách dễ dàng.

E = [[8,1,3], [8,7,3], [7,3,5]]]= [[8, 1, 3],
[8, 7, 3],
[7, 3, 5]]

R = [[2,3,6,8], [9,8,5,3], [1,3,8,9]]]]= [[2, 3, 6, 8],
[9, 8, 5, 3],
[1, 3, 8, 9]]

result = [[sum (f*g cho f, g inzip (e_row, r_col)) cho r_col inzip (*r)] cho e_row trong e]= [[sum(f*g for f,g in zip(E_row, R_col)) for R_col in zip(*R)] for E_row in E]

cho z trong kết quả: & nbsp; & nbsp; in (z) z in result:
    print(z)

Để có được tổng số sản phẩm của mỗi phép nhân từng hàng, chúng tôi lặp lại các cột bên trong Ma trận R R R R và các hàng bên trong ma trận E E trong chương trình. Để có được các cột của Ma trận, chúng tôi sử dụng phương thức zip (). Chúng tôi yêu cầu các phần tử của hàng trong ma trận E E là thành phần thứ hai của danh sách lồng nhau hiểu để tính tổng sản phẩm cho mỗi hàng trong danh sách lồng nhau này. Cuối cùng, tuyên bố in sẽ được sử dụng.

Sự kết luận

Trong hướng dẫn này, chúng tôi đã thấy một vài cách thay thế để tính toán thủ công, phép nhân và chuyển vị ma trận thay vì numpy. Những cách tiếp cận này bao gồm các danh sách lồng nhau cũng như sự hiểu biết của các danh sách lồng nhau. Ngoài ra, một số chương trình được trình bày để chứng minh làm thế nào các phương pháp này có thể được sử dụng và hoạt động khác nhau với việc bổ sung, nhân và chuyển vị của một ma trận.