Cara menggunakan ungkapan biasa Python untuk penukaran ungkapan aritmetik

Ungkapan biasa ialah alat yang berkuasa dalam Python, yang boleh digunakan untuk memadankan, mencari, menggantikan teks dan operasi lain. Dalam sains komputer, ungkapan biasa digunakan untuk menghuraikan ungkapan aritmetik ke dalam format yang boleh dibaca komputer dengan mudah. Artikel ini akan memperkenalkan cara menggunakan ungkapan biasa Python untuk penukaran ungkapan aritmetik.

Pertama, kita perlu memahami peraturan tatabahasa bagi ungkapan aritmetik. Ungkapan aritmetik terdiri daripada operan dan operator, contohnya: 2 + 4 * 5. Dalam ungkapan ini, nombor 2, 4, dan 5 ialah operan, dan tanda tambah dan darab ialah operator. Urutan di mana ungkapan aritmetik dihuraikan ditentukan oleh keutamaan pengendali. Secara umumnya, pendaraban dan pembahagian mempunyai keutamaan yang lebih tinggi daripada penambahan dan penolakan.

Sekarang, mari kita lihat cara menggunakan ungkapan biasa untuk menghuraikan ungkapan aritmetik. Pertama, kita perlu mentakrifkan ungkapan biasa untuk memadankan ungkapan aritmetik. Ungkapan biasa yang ringkas boleh jadi:

pattern = r"(d+)([+-*/])(d+)"

Ungkapan biasa ini sepadan dengan gabungan dua nombor dan operator. Antaranya, "(d+)" bermaksud memadankan sebarang bilangan nombor, dan "([+-*/])" bermaksud memadankan operator tambah, tolak, darab dan bahagi.

Sekarang, mari tulis fungsi Python yang menggunakan ungkapan biasa untuk menghuraikan ungkapan aritmetik:

import re

def evaluate(expression):
    pattern = r"(d+)([+-*/])(d+)"
    match = re.match(pattern, expression)
    if match:
        operand1 = int(match.group(1))
        operator = match.group(2)
        operand2 = int(match.group(3))
        if operator == "+":
            return operand1 + operand2
        elif operator == "-":
            return operand1 - operand2
        elif operator == "*":
            return operand1 * operand2
        elif operator == "/":
            return operand1 / operand2
    else:
        return None

Fungsi ini menerima ungkapan aritmetik sebagai parameter dan mengembalikan hasil pengiraan. Ia mula-mula menggunakan ungkapan biasa untuk memadankan nombor dan operator dalam ungkapan dan menyimpannya ke dalam pembolehubah operand1, operator, operand2. Kemudian, pengiraan dilakukan berdasarkan jenis operator dan hasilnya dikembalikan.

Sekarang, mari kita uji fungsi fungsi penilaian:

print(evaluate("2 + 4 * 5")) # 22
print(evaluate("10 - 3 / 2")) # 8.5

Hasilnya semua betul Fungsi penilaian boleh menghuraikan ungkapan aritmetik dan mengira hasilnya.

Akhir sekali, mari kita perkenalkan cara menangani keutamaan pengendali. Kita boleh melakukan ini menggunakan ungkapan biasa dan fungsi rekursif. Mula-mula, kami mentakrifkan berbilang ungkapan biasa untuk memadankan pengendali dengan keutamaan yang berbeza:

pattern_high = r"(d+)([*/])(d+)"
pattern_low = r"(d+)([+-])(d+)"

Antaranya, padanan pattern_high operasi pendaraban dan bahagi, dan padanan pattern_low operasi tambah dan tolak. Seterusnya, kami menulis fungsi rekursif yang mengendalikan semua operator dalam ungkapan:

def evaluate(expression):
    match_high = re.search(pattern_high, expression)
    match_low = re.search(pattern_low, expression)
    if match_high:
        operand1 = int(match_high.group(1))
        operator = match_high.group(2)
        operand2 = int(match_high.group(3))
        if operator == "*":
            result = operand1 * operand2
        elif operator == "/":
            result = operand1 / operand2
        new_expression = re.sub(pattern_high, str(result), expression, count=1)
        return evaluate(new_expression)
    elif match_low:
        operand1 = int(match_low.group(1))
        operator = match_low.group(2)
        operand2 = int(match_low.group(3))
        if operator == "+":
            result = operand1 + operand2
        elif operator == "-":
            result = operand1 - operand2
        new_expression = re.sub(pattern_low, str(result), expression, count=1)
        return evaluate(new_expression)
    else:
        return int(expression)

Fungsi ini menggunakan dua ungkapan biasa untuk memadankan operasi darab dan bahagi serta operasi tambah dan tolak. Jika terdapat operasi darab dan bahagi dalam ungkapan, operasi darab dan bahagi dikira terlebih dahulu, dan fungsi re.sub() digunakan untuk menggantikan ungkapan asal dengan hasilnya. Jika hanya terdapat operasi tambah dan tolak dalam ungkapan, operasi tambah dan tolak dikira secara langsung.

Sekarang, mari kita uji fungsi fungsi penilaian yang dioptimumkan:

print(evaluate("2 + 4 * 5")) # 22
print(evaluate("10 - 3 / 2")) # 8.5
print(evaluate("2 + 4 * 5 / 2 - 3")) # 13

Keputusan semuanya betul, menunjukkan bahawa pengoptimuman kami telah berkuat kuasa.

Untuk meringkaskan, ungkapan aritmetik boleh dihuraikan dengan mudah dan hasilnya dikira menggunakan ungkapan biasa Python. Untuk ungkapan kompleks, kita boleh menggunakan fungsi rekursif dan ungkapan biasa untuk mengendalikan keutamaan pengendali dan mengautomasikan algoritma.

Atas ialah kandungan terperinci Cara menggunakan ungkapan biasa Python untuk penukaran ungkapan aritmetik. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!