Hướng dẫn scalar multiplication python without numpy - python nhân vô hướng không có numpy

Cách tiếp cận Numpythonic: (sử dụng numpy.dot để có được sản phẩm chấm của hai ma trận)

In [1]: import numpy as np

In [3]: np.dot([1,0,0,1,0,0], [[0,1],[1,1],[1,0],[1,0],[1,1],[0,1]])
Out[3]: array([1, 1])

Cách tiếp cận Pythonic:

Độ dài của vòng lặp for thứ hai của bạn là len(v) và bạn cố gắng lập chỉ mục

In [13]: first,second=[1,0,0,1,0,0], [[0,1],[1,1],[1,0],[1,0],[1,1],[0,1]]

In [14]: from itertools import starmap

In [15]: from operator import mul

In [16]: [sum(starmap(mul, zip(first, col))) for col in zip(*second)]
Out[16]: [1, 1]

In [13]: first,second=[1,0,0,1,0,0], [[0,1],[1,1],[1,0],[1,0],[1,1],[0,1]]

In [14]: from itertools import starmap

In [15]: from operator import mul

In [16]: [sum(starmap(mul, zip(first, col))) for col in zip(*second)]
Out[16]: [1, 1]

In [13]: first,second=[1,0,0,1,0,0], [[0,1],[1,1],[1,0],[1,0],[1,1],[0,1]]

In [14]: from itertools import starmap

In [15]: from operator import mul

In [16]: [sum(starmap(mul, zip(first, col))) for col in zip(*second)]
Out[16]: [1, 1]

In [13]: first,second=[1,0,0,1,0,0], [[0,1],[1,1],[1,0],[1,0],[1,1],[0,1]]

In [14]: from itertools import starmap

In [15]: from operator import mul

In [16]: [sum(starmap(mul, zip(first, col))) for col in zip(*second)]
Out[16]: [1, 1]

In [13]: first,second=[1,0,0,1,0,0], [[0,1],[1,1],[1,0],[1,0],[1,1],[0,1]]

In [14]: from itertools import starmap

In [15]: from operator import mul

In [16]: [sum(starmap(mul, zip(first, col))) for col in zip(*second)]
Out[16]: [1, 1]

Phép nhân ma trận python mà không cần numpy | Ở đây, chúng ta sẽ thảo luận về cách nhân hai ma trận trong Python mà không bị numpy. Sự nhân ma trận là một hoạt động nhị phân nhân với hai ma trận, vì ngoài ra và trừ cả hai ma trận phải có cùng kích thước, nhưng ở đây trong ma trận nhân không cần phải có cùng kích thước, mà là nhân hai ma trận có giá trị hàng đầu tiên Ma trận phải bằng giá trị cột của ma trận thứ hai. Nhân phức tạp hơn một chút so với các hoạt động nhân khác. | Here, we will discuss how to multiply two matrices in Python without NumPy. Matrix multiplication is a binary operation that multiplies two matrices, as in addition and subtraction both the matrices should be of the same size, but here in multiplication matrices need not be of the same size, but to multiply two matrices the row value of the first matrix should be equal to the column value of the second matrix. Multiplying is a bit more complex than other multiplicative operations.

Ở đây, chúng tôi đưa đầu vào của người dùng để nhân hai ma trận mà không cần numpy; Chúng tôi nạp các giá trị hàng và giá trị cột từ người dùng và sau đó tiến hành các phần tử.row values and column values from the user and then proceed with the elements.

# Python program to multiply two matrices without numpy

# take first matrix inputs
print("Enter the order of matrix 1:")
m, n = list(map(int, input().split()))
print("Enter row values")
m1 = []
for i in range(m):
   print("Enter row",  i, "values:")
   row = list(map(int, input().split()))
   m1.append(row)

# take second matrix inputs
print("Enter the order of matrix2:")
p, q = list(map(int, input().split()))
print("Enter row values")
m2 = []
for j in range(p):
   print("Enter row", j, "value:")
   row = list(map(int, input().split()))
   m2.append(row)

# print both matrices
print("Matrix 1:", m1)
print("Matrix 2:", m2)

# multiply matrix
result = []
for i in range(m):
   row = []
   for j in range(q):
      row.append(0)
   result.append(row)
print("Matrix Multiplication:")
for i in range(m):
   for j in range(q):
      for k in range(n):
         result[i][j] += m1[i][k] * m2[k][j]
for row in result:
   print(row)

Output:-

Nhập thứ tự của Ma trận 1: 2 2 Trung tâm giá trị hàng Hàng 0 Giá trị: 14 21 Trung tâm 1 Giá trị: 20 25NENT 21], [20, 25]] Ma trận 2: [[19, 17], [21, 23]] Nhân số ma trận: [707, 721] [905, 915]
2 2
Enter row values
Enter row 0 values:
14 21
Enter row 1 values:
20 25
Enter the order of matrix2:
2 2
Enter row values
Enter row 0 value:
19 17
Enter row 1 value:
21 23
Matrix 1: [[14, 21], [20, 25]]
Matrix 2: [[19, 17], [21, 23]]
Matrix Multiplication:
[707, 721]
[905, 915]

Trong mã trên, chúng tôi đang lấy hai đầu vào cùng nhau là m, n = list (mAm Điều tương tự cũng được thực hiện cho ma trận thứ hai P, Q lần lượt là các hàng và cột. & nbsp; sau đó được lồng cho các vòng lặp, chúng tôi nhân ma trận và lưu trữ nó trong kết quả.m, n = list(map(int, input().split())) here, we have taken two inputs together as row and column for the first matrix similarly, the same thing is done for second matrix p, q are rows and columns respectively. Then in nested for loops we multiply the matrix and store it in the result.

Chương trình Python để nhân hai ma trận mà không bị Numpy

Trong Python, chúng ta có thể xác định các chức năng của riêng mình. Mục đích chính cho điều này là sử dụng lại mã do đó nó làm giảm số lượng dòng. Để xác định một hàm, chúng tôi sử dụng từ khóa def.we can define our own functions. The main aim for this is to reuse the code hence it reduces the number of lines. To define a function we use the def keyword.

# Python program to multiply two matrices without using numpy

MAX = 100
def matrixPrint(M, row, col):
   for i in range(row):
      for j in range(col):
         print(M[i][j], end=" ")
      print()

def matrixMultiply(row1, col1, m1, row2, col2, m2):
   res = [[0 for i in range(MAX)] for j in range(MAX)]
   if(row2 != col1):
      print("Matrix multiplication not possible")
      return
   for i in range(row1):
      for j in range(col2):
         res[i][j] = 0
         for k in range(row2):
            res[i][j] += m1[i][k] * m2[k][j]
   print("Result:")
   matrixPrint(res, row1, col2)

# main
if __name__ == "__main__":
   m1 = [[0 for i in range(MAX)] for j in range(MAX)]
   m2 = [[0 for i in range(MAX)] for j in range(MAX)]
   row1 = int(input("Enter the number of rows in matrix 1: "))
   col1 = int(input("Enter the number of columns in matrix 1: "))
   print("Enter the elements of matrix 1:")
   for i in range(row1):
      for j in range(col1):
         m1[i][j] = int(input("m1[" + str(i) + "][" + str(j) + "]: "))

   row2 = int(input("Enter the number of rows in matrix 2: "))
   col2 = int(input("Enter the number of columns in matrix 2: "))

   print("Enter the elements of matrix 2: ")
   for i in range(row2):
      for j in range(col2):
         m2[i][j] = int(input("m2[" + str(i) + "][" + str(j) + "]: "))
   print("Matrix 1: ")
   matrixPrint(m1, row1, col1)
   print("Matrix 2: ")
   matrixPrint(m2, row2, col2)
   matrixMultiply(row1, col1, m1, row2, col2, m2)

Output:-

Nhập số lượng hàng trong Ma trận 1: 3enter Số lượng cột trong Ma trận 1: 2enter Các phần tử của Ma trận 1: M1 [0] [0]: 12M1 [0] [1]: 20M1 [1] [0]: 15M1 . 0] [0]: 23m2 [0] [1]: 21m2 [0] [2]: 10m2 [1] [0]: 18m2 [1] [1]: 16m2 [1] [2]: 22Matrix 1:12 2015 2514 12Matrix 2:23 21 1018 16 22Result: 636 572 560795 715 700538 486 404
Enter the number of columns in matrix 1: 2
Enter the elements of matrix 1:
m1[0][0]: 12
m1[0][1]: 20
m1[1][0]: 15
m1[1][1]: 25
m1[2][0]: 14
m1[2][1]: 12
Enter the number of rows in matrix 2: 2
Enter the number of columns in matrix 2: 3
Enter the elements of matrix 2:
m2[0][0]: 23
m2[0][1]: 21
m2[0][2]: 10
m2[1][0]: 18
m2[1][1]: 16
m2[1][2]: 22
Matrix 1:
12 20
15 25
14 12
Matrix 2:
23 21 10
18 16 22
Result:
636 572 560
795 715 700
538 486 404

Trong ví dụ trên, chúng tôi đã sử dụng hai hàm Matrixprint () và MatrixMultiply (). Hàm đầu tiên Matrixprint () mất 3 tham số:- Ma trận được in, hàng và cột, hàm này được sử dụng để in ma trận. Sau đó, trong hàm thứ hai MatrixMultiply (), chúng tôi đã lấy 6 tham số; Đó là các hàng và cột của Matrix1 và Matrix2 và Matrix1 và Matrix2. & NBSP;matrixPrint() and matrixMultiply(). The first function matrixPrint() takes 3 parameters:- matrix to be printed, rows and columns, this function is used to print the matrix. Then in the second function matrixMultiply(), we have taken 6 parameters; those are rows and columns of matrix1 and matrix2 and matrix1 and matrix2 as well. 

Phép nhân ma trận python mà không bị numpy

Để nhân một ma trận, chúng tôi sử dụng một vòng lặp cho vòng lặp. Lồng nhau cho vòng lặp là một vòng lặp bên trong một vòng khác cho vòng lặp.for loop is a for loop inside another for loop.

# Python program to multiply two matrices without numpy

m1 = [[10, 11, 12],
      [13, 14, 15],
      [16, 17, 18]]
m2 = [[9, 8, 7],
      [6, 5, 4],
      [3, 2, 1]]
res = [[0, 0, 0],
       [0, 0, 0],
       [0, 0, 0]]

# multiply matrix
for i in range(len(m1)):
   for j in range(len(m2[0])):
      for k in range(len(m2)):
         res[i][j] += m1[i][k] * m2[k][j]
for r in res:
   print(r)

Output:-

[192, 159, 126] [246, 204, 162] [300, 249, 198]
[246, 204, 162]
[300, 249, 198]

Đối với mã trên, chúng tôi đã cung cấp bộ giá trị của riêng mình, sau đó chúng tôi đã khởi tạo ma trận kết quả Res thành 0 và lặp lại trong một tập hợp các vòng lặp.

Chương trình nhân ma trận trong Python mà không có Numpy

Chúng tôi cũng nhân ma trận bằng danh sách, danh sách là một nhóm các yếu tố được đặt hàng, lưu trữ nhiều mục. multiply matrices using a list, a list is an ordered group of elements, which stores many items.

# Python program to multiply two matrices without numpy

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

B = [[25, 24, 23, 22],
     [21, 20, 19, 18],
     [17, 16, 15, 14]]

# multiply matrix
res = [[sum(a * b for a, b in zip(A_row, B_col))
        for B_col in zip(*B)] for A_row in A]
for r in res:
   print(r)

Output:-

[118, 112, 106, 100] [307, 292, 277, 262] [496, 472, 448, 424]
[307, 292, 277, 262]
[496, 472, 448, 424]

Trong mã, chúng tôi đã sử dụng hàm zip. Chức năng này giúp kết hợp các loại lặp tương tự, các mục dữ liệu ở vị trí đó, nó cũng sử dụng độ dài ngắn nhất của các trình lặp đầu vào này.zip function. This function helps to combine similar types of iterators, data items at that position, it also uses the shortest length of these input iterators.

Phép nhân ma trận động trong python

Nhân chuỗi chuỗi ma trận (hoặc vấn đề đặt hàng chuỗi ma trận) là một vấn đề tối ưu hóa liên quan đến cách hiệu quả nhất để nhân một chuỗi ma trận nhất định. Vấn đề không thực sự là thực hiện các phép nhân, mà chỉ để quyết định chuỗi các phép nhân ma trận liên quan. Vấn đề có thể được giải quyết bằng cách sử dụng lập trình động.(or the matrix chain ordering problem) is an optimization problem concerning the most efficient way to multiply a given sequence of matrices. The problem is not actually to perform the multiplications, but merely to decide the sequence of the matrix multiplications involved. The problem may be solved using dynamic programming.

# Python program to multiply matrices using dynamic programming

import sys
def matrixMultiply(d):
   n = len(d)
   # create the table to store solutions
   c = [[0 for x in range(n)] for x in range(n)]
 
   # length of the chain
   for length in range(2,n):
      for i in range(1,n-length+1):
         j = i+length-1
         # store a maximum integer
         c[i][j] = sys.maxsize
         
         for k in range(i,j):
            # p holds the value of multiplication cost
            p = c[i][k] + c[k+1][j] + d[i-1] * d[k] * d[j]
            #compare previous cost with p
            if p < c[i][j]:
               c[i][j] = p
   # last element of first row contains
   return c[1][n-1]

# take inputs
d = [10, 11, 12, 13, 14, 15]

# calling function and print result
print('The minimum cost is', matrixMultiply(d))

Output:-

Chi phí tối thiểu là 6800

Nếu bạn thích bài đăng này, hãy chia sẻ nó với bạn bè của bạn. Bạn có muốn chia sẻ thêm thông tin về chủ đề được thảo luận ở trên hay bạn tìm thấy điều gì không chính xác? Hãy cho chúng tôi biết trong các ý kiến. Cảm ơn bạn!

Làm thế nào để bạn nhân một vô hướng trong Python?

Làm thế nào để bạn nhân ma trận mà không cần numpy?

Làm thế nào để bạn nhân với một vô hướng?

Matmul có giống như sản phẩm dot không?