Hướng dẫn how do you create a complex class in python? - làm thế nào để bạn tạo một lớp phức tạp trong python?

Nhận cuốn sách này -> Vấn đề về Array: Đối với các cuộc phỏng vấn và lập trình cạnh tranh

Trong một bài viết trước, chúng tôi đã nói về các số phức tạp trong Python bằng cách sử dụng các lớp và thuộc tính tích hợp để thực hiện các hoạt động trên chúng. Nhưng, hãy tưởng tượng nếu Python không được trang bị các tiện ích này. Làm thế nào chúng ta sẽ thực hiện các hoạt động phức tạp? Chúng ta có thể khám phá khái niệm đó bằng cách sử dụng các hoạt động toán học tích hợp để tạo ra lớp học phức tạp của riêng chúng ta trong Python.complex numbers in Python using built-in classes and attributes to perform operations on them. But, imagine if Python didn't come equipped with these conveniences. How would we go about implementing complex operations? We can explore that concept by utilizing built-in mathematical operations to create our own complex class in Python.

Để bắt đầu, chúng tôi cần khởi tạo số phức của mình:

def __init__ (self, real, imag=0.0):
    '''Form complex number'''
    self.real = real
    self.imag = imag

Như chúng tôi đã nêu trước đây, các số phức được tạo ra từ một số thực và một số tưởng tượng. Toán tử

def __add__(self, other):
    return Complex(self.real + other.real, self.imag + other.imag)

i = complex(2, 10j)
k = complex(3, 5j)
add = i + k
print(add)
# Output: (5+15j)

def __add__(self, other):
    return Complex(self.real + other.real, self.imag + other.imag)

i = complex(2, 10j)
k = complex(3, 5j)
add = i + k
print(add)
# Output: (5+15j)

Bạn có thể nhận thấy rằng

def __add__(self, other):
    return Complex(self.real + other.real, self.imag + other.imag)

i = complex(2, 10j)
k = complex(3, 5j)
add = i + k
print(add)
# Output: (5+15j)

def __add__(self, other):
    return Complex(self.real + other.real, self.imag + other.imag)

i = complex(2, 10j)
k = complex(3, 5j)
add = i + k
print(add)
# Output: (5+15j)

Chúng tôi có một lớp xác định các số phức tạp bởi các phần thực và tưởng tượng của chúng, bây giờ chúng tôi đã sẵn sàng để bắt đầu tạo các hoạt động để thực hiện trên các số phức tạp.

Phép cộng

Khi bạn thêm các số phức tạp lại với nhau, bạn chỉ có thể kết hợp như các thuật ngữ. Nói cách khác, chúng ta phải thêm các thành phần thực và tưởng tượng của cả hai số dưới dạng các phần riêng biệt. Nhìn vào lớp bổ sung bên dưới, chúng ta có thể thấy rằng chúng ta đã xác định số đầu tiên là

def __add__(self, other):
    return Complex(self.real + other.real, self.imag + other.imag)

i = complex(2, 10j)
k = complex(3, 5j)
add = i + k
print(add)
# Output: (5+15j)

def __add__(self, other):
    return Complex(self.real + other.real, self.imag + other.imag)

i = complex(2, 10j)
k = complex(3, 5j)
add = i + k
print(add)
# Output: (5+15j)

Sau khi khởi tạo hai số phức tạp của chúng tôi, sau đó chúng tôi có thể thêm chúng với nhau như được thấy bên dưới lớp bổ sung.

def __add__(self, other):
    return Complex(self.real + other.real, self.imag + other.imag)

i = complex(2, 10j)
k = complex(3, 5j)
add = i + k
print(add)
# Output: (5+15j)

Phép trừ

Phép trừ hoạt động rất giống với việc bổ sung với các số phức. Một lần nữa, chúng ta chỉ có thể kết hợp như các thuật ngữ, do đó, điều quan trọng là chúng ta phải giữ riêng này khi thực hiện thao tác trừ.

Sử dụng các biến tương tự từ ví dụ trước,

def __add__(self, other):
    return Complex(self.real + other.real, self.imag + other.imag)

i = complex(2, 10j)
k = complex(3, 5j)
add = i + k
print(add)
# Output: (5+15j)

def __add__(self, other):
    return Complex(self.real + other.real, self.imag + other.imag)

i = complex(2, 10j)
k = complex(3, 5j)
add = i + k
print(add)
# Output: (5+15j)

def __sub__(self, other):
    return Complex(self.real - other.real, self.imag - other.image)

subtract = i - k
# Output: (-1+5j)

Đúng như dự đoán, khi bạn trừ 3 từ 2, kết quả là -1 và 10J - 5J dẫn đến 5J.

Phép nhân

Nhân là một chút khó khăn hơn. Không giống như bổ sung và trừ, giờ đây chúng ta sẽ phải kết hợp các hệ số của các số tưởng tượng với các số thực. Tuy nhiên, kết quả phải được trả về dưới dạng số phức.

Trước khi chúng tôi nhảy vào mã, chúng ta hãy xem cách toán học hoạt động dưới mui xe. Như bạn có thể thấy dưới đây, chúng tôi chia vấn đề thành hai phần riêng biệt: một phần giải quyết cho số thực và một phần giải quyết cho sự tưởng tượng. Điều này trông quen thuộc với bất cứ ai biết đại số.

    # The problem written out
    (2 + 10j) * (3 + 5j)
    
    # Solving for the real number
    (2 * 3) - (10j * 5j)
    6 + 50
    --------------------
    56
    # Once we multiply 10j by 5j, j becomes j^2.
    # Which is also equal to -1, causing - to change to +
    
    # Solving for the imaginary number
    (10j * 3) + (2 * 5j)
    30j + 10j
    --------------------
    40j
    /* We are combining the coefficients from the reals
    with the imaginary numbers */
    
    # Final result:
    56 + 40j

Ghi chú

Phần thực của số phức được giải quyết bằng cách trừ

def __add__(self, other):
    return Complex(self.real + other.real, self.imag + other.imag)

i = complex(2, 10j)
k = complex(3, 5j)
add = i + k
print(add)
# Output: (5+15j)

def __add__(self, other):
    return Complex(self.real + other.real, self.imag + other.imag)

i = complex(2, 10j)
k = complex(3, 5j)
add = i + k
print(add)
# Output: (5+15j)

def __add__(self, other):
    return Complex(self.real + other.real, self.imag + other.imag)

i = complex(2, 10j)
k = complex(3, 5j)
add = i + k
print(add)
# Output: (5+15j)

Hiểu toán học liên quan đến việc giải quyết cho phép nhân hai số phức là bước đầu tiên quan trọng. Chúng tôi đã sẵn sàng để tiến về phía trước với lớp học. Khi chúng ta nhìn vào bên dưới, bạn sẽ nhận thấy rằng toán học chúng ta đã thực hiện ở trên được đặt rất giống với chính mã.

def __mul__(self, other):
    return Complex(self.real * other.real - self.imag * other.imag, self.imag         * other.real + self.real * other.real)

multiply = i * k
# Output: 

Phân công

Giống như phép nhân, chia các số phức có thể trở nên lộn xộn khá nhanh. Đặc biệt nếu bạn không quen thuộc với các khái niệm cơ bản về cách giải quyết cho thương số của hai số phức.

Tiếp tục với cùng một số phức được sử dụng trong suốt bài viết này, chúng tôi bắt đầu với vấn đề giải quyết cho số thực. Tương tự như phép nhân, sự phân chia các số phức có thể được chia thành hai phương trình riêng cho từng phần của số phức.

Sau đó, chúng tôi chuyển sang nửa sau của vấn đề mà chúng tôi giải quyết cho phần tưởng tượng. Điều này khá thẳng thắn vì chúng tôi chỉ tuân theo cùng một nguyên tắc phân chia cơ bản mà chúng tôi sử dụng với các số thực.

Khi chúng ta có hai mảnh cho mỗi phần - phần thực và tưởng tượng của số phức - thì chúng ta cần kết hợp chúng để có được kết quả cuối cùng.

    # Divisor
    (3**2 + 5j**2)
    (9 - 25)
    
    # Solving real number
    (2*3 - 10j*5j) / (9 - 25)
    (6 + 50) / (-16)
    (-44 / -16)
    --------------------------
    -3.5
    
    # Solving imaginary number
    (10j*3 + 2*5j) / (9 - 25)
    (30j + 10j) / (-16)
    40j / (-16)
    --------------------------
    -2.5j

    # Final result:
    (-3.5-2.5j)

Các ước số trong vấn đề trên được tìm thấy bằng cách nâng các phần thực và tưởng tượng của giá trị

def __add__(self, other):
    return Complex(self.real + other.real, self.imag + other.imag)

i = complex(2, 10j)
k = complex(3, 5j)
add = i + k
print(add)
# Output: (5+15j)

def __add__(self, other):
    return Complex(self.real + other.real, self.imag + other.imag)

i = complex(2, 10j)
k = complex(3, 5j)
add = i + k
print(add)
# Output: (5+15j)

J của 5J được loại bỏ một khi số được nâng lên công suất thứ hai, biến nó thành một số thực và cho phép nó được kết hợp với

def __sub__(self, other):
    return Complex(self.real - other.real, self.imag - other.image)

subtract = i - k
# Output: (-1+5j)

Hãy xem bản viết này bằng Python:

def __truediv__(self, other):
    divisor = (other.real**2 + other.imag**2)
    return Complex((self.real * other.real) -
        (self.imag * other.imag)/divisor,
        (self.imag * other.real) + (self.real * other.imag)/divisor)

divide = i / k
# Output: (-3.5-2.5j)

Note:

Bạn có thể nhận thấy rằng nhà điều hành bộ phận được đặt tên là

def __sub__(self, other):
    return Complex(self.real - other.real, self.imag - other.image)

subtract = i - k
# Output: (-1+5j)

def __sub__(self, other):
    return Complex(self.real - other.real, self.imag - other.image)

subtract = i - k
# Output: (-1+5j)

def __sub__(self, other):
    return Complex(self.real - other.real, self.imag - other.image)

subtract = i - k
# Output: (-1+5j)

def __sub__(self, other):
    return Complex(self.real - other.real, self.imag - other.image)

subtract = i - k
# Output: (-1+5j)

def __sub__(self, other):
    return Complex(self.real - other.real, self.imag - other.image)

subtract = i - k
# Output: (-1+5j)

Giá trị tuyệt đối

Trên một lưu ý ít toán học hơn, chúng ta hãy cố gắng tìm giá trị tuyệt đối của một số phức. Để làm như vậy, chúng ta phải trích xuất hệ số từ phần tưởng tượng và kết hợp nó với số thực. Chúng tôi đã thực hiện điều này với ước số trong ví dụ cuối cùng.

    # We are solving for the absolute value of i = (2+10j)
    (2**2 + (10j**2)*(-1))
    4 + (-100)*(-1)
    4 + 100
    ----------------------
    104
    sqrt(104)
    
    # Final result: 10.198039027185569

Như chúng ta có thể thấy với tôi

def __sub__(self, other):
    return Complex(self.real - other.real, self.imag - other.image)

subtract = i - k
# Output: (-1+5j)

def __sub__(self, other):
    return Complex(self.real - other.real, self.imag - other.image)

subtract = i - k
# Output: (-1+5j)

import math
from math import sqrt

def __abs__(self):
    new = (self.real**2 + (self.imag**2)*-1)
    return Complex(sqrt(new.real))


abs(i)
# Output: 10.198039027185569
abs(k)
# Output: 5.830951894845301

Bạn có thể tự hỏi tại sao thậm chí cần phải nâng các con số lên sức mạnh thứ hai nếu chúng ta sẽ giải quyết cho căn bậc hai.

Như đã lưu ý trước đó, nâng các số thực và tưởng tượng lên công suất thứ hai kéo chúng ra khỏi số phức bằng cách loại bỏ tất cả các phần tưởng tượng (J bình phương là -1). Điều này cho phép chúng tôi kết hợp hai số để tìm giá trị tuyệt đối của chúng.

Tất cả cùng nhau

Cho đến nay, chúng tôi đã thảo luận về việc bổ sung, trừ, nhân, chia và giá trị tuyệt đối với các số phức. Bạn có thể tự mình đóng góp nhiều hoạt động hơn cho lớp phức tạp của bạn. Nhưng, trước tiên, hãy dọn dẹp mã và xem cách nó hoạt động cùng nhau.

import math
from math import sqrt

class Complex(object):

    def __init__(self, real, imag=0.0):
        self.real = real
        self.imag = imag
        # Formats our results
        print(self.real + self.imag)

    def __add__(self, other):
        print('\nSum:')
        return Complex(self.real + other.real, self.imag + other.imag)

    def __sub__(self, other):
        print('\nDifference:')
        return Complex(self.real - other.real, self.imag - other.imag)
    
    def __mul__(self, other):
        print('\nProduct:')
        return Complex((self.real * other.real) - (self.imag * other.imag),
            (self.imag * other.real) + (self.real * other.imag))

    def __truediv__(self, other):
        print('\nQuotient:')
        r = (other.real**2 + other.imag**2)
        return Complex((self.real*other.real - self.imag*other.imag)/r,
            (self.imag*other.real + self.real*other.imag)/r)

    def __abs__(self):
        print('\nAbsolute Value:')
        new = (self.real**2 + (self.imag**2)*-1)
        return Complex(sqrt(new.real))


i = Complex(2, 10j)
k = Complex(3, 5j)

# Add
i + k
# Subtract
i - k
# Multiply
i * k
# Divide
i / k
# Absolute value
abs(i)
abs(k)

# Output:
(2+10j)
(3+5j)

Sum:
(5+15j)

Difference:
(-1+5j)

Product:
(56+40j)

Quotient:
(-3.5-2.5j)

Absolute Value:
10.198039027185569

Absolute Value:
5.830951894845301

Như bạn thấy từ đầu ra kết quả của chúng tôi, chúng tôi có thể thêm một dòng mới (

    # The problem written out
    (2 + 10j) * (3 + 5j)
    
    # Solving for the real number
    (2 * 3) - (10j * 5j)
    6 + 50
    --------------------
    56
    # Once we multiply 10j by 5j, j becomes j^2.
    # Which is also equal to -1, causing - to change to +
    
    # Solving for the imaginary number
    (10j * 3) + (2 * 5j)
    30j + 10j
    --------------------
    40j
    /* We are combining the coefficients from the reals
    with the imaginary numbers */
    
    # Final result:
    56 + 40j

Với bài viết này tại OpenGenus, bạn phải có ý tưởng hoàn chỉnh về việc thực hiện và thiết kế các số phức tạp bằng các lớp trong Python. Vui thích.