Python多线程计算二次方程根的常见错误与最佳实践

import math
import threading

A = input("What is your a? ")
B = input("What is your B? ")
C = input("What is your C? ")
a = int(A) # 问题1：应使用浮点数
b = int(B)
c = int(C)

def Quad_pt1():
    Pt1 = b*-1
    return Pt1 # 问题2：线程无法直接返回结果

def Quad_pt2():
    # 问题3：pow(2, b) 错误，应为 b**2
    # 问题4：未处理判别式为负数的情况
    Pt2 = math.sqrt(pow(2, b)-(4*a*c))
    return Pt2

def Quad_pt3():
    Pt3 = 2*a
    return Pt3

# 问题5：target=Quad_pt1() 立即执行函数，传递的是返回值
t1 = threading.Thread(target=Quad_pt1())
t2 = threading.Thread(target=Quad_pt2())
t3 = threading.Thread(target=Quad_pt3())

t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()

print(t1, t2, t3) # 问题6：打印的是线程对象，不是计算结果
# exit() # 阻止后续代码执行，但实际计算需要这些结果
# print((Pt1+Pt2)/Pt3) # 问题7：Pt1, Pt2, Pt3 未定义在当前作用域

# 错误示范：
# t1 = threading.Thread(target=Quad_pt1())
# 正确示范：
t1 = threading.Thread(target=Quad_pt1)

import threading

results = {} # 共享字典
# results_lock = threading.Lock() # 如果多个线程可能写入同一键，则需要锁

def Quad_pt1():
    # with results_lock:
    results["Pt1"] = -b

# ... 其他线程函数类似

import math
import cmath # 引入 cmath 模块处理复数

def Quad_pt2_with_complex():
    discriminant = b**2 - 4*a*c # 正确的判别式计算
    results["discriminant"] = discriminant # 存储判别式以便后续判断

    if discriminant >= 0:
        results["Pt2"] = math.sqrt(discriminant)
        results["is_complex"] = False
    else:
        results["Pt2"] = cmath.sqrt(discriminant) # 使用 cmath 处理负数平方根
        results["is_complex"] = True

try:
    a = float(input("请输入系数 A: "))
    b = float(input("请输入系数 B: "))
    c = float(input("请输入系数 C: "))
except ValueError:
    print("输入无效，请确保 A, B, C 为有效数字。")
    exit()

import math
import cmath # 导入 cmath 模块处理复数
import threading

# 1. 获取用户输入并转换为浮点数
A_str = input("请输入系数 A: ")
B_str = input("请输入系数 B: ")
C_str = input("请输入系数 C: ")

try:
    a = float(A_str)
    b = float(B_str)
    c = float(C_str)
except ValueError:
    print("输入无效，请确保 A, B, C 为有效数字。")
    exit()

# 2. 共享结果字典
results = {}

# 3. 定义线程执行函数
def calculate_pt1():
    """计算 -b 部分"""
    results["Pt1"] = -b

def calculate_pt2_and_discriminant():
    """计算判别式和其平方根 (Pt2)"""
    discriminant = b**2 - 4*a*c # 正确计算 b 的平方
    results["discriminant"] = discriminant

    if discriminant >= 0:
        results["Pt2"] = math.sqrt(discriminant)
        results["is_complex"] = False
    else:
        results["Pt2"] = cmath.sqrt(discriminant) # 使用 cmath 处理负数判别式
        results["is_complex"] = True

def calculate_pt3():
    """计算 2a 部分"""
    results["Pt3"] = 2 * a

# 4. 创建并启动线程
thread_pt1 = threading.Thread(target=calculate_pt1)
thread_pt2 = threading.Thread(target=calculate_pt2_and_discriminant)
thread_pt3 = threading.Thread(target=calculate_pt3)

threads = [thread_pt1, thread_pt2, thread_pt3]

for t in threads:
    t.start()

# 5. 等待所有线程完成
for t in threads:
    t.join()

# 6. 从共享字典中获取结果并计算根
pt1 = results["Pt1"]
pt2 = results["Pt2"]
pt3 = results["Pt3"]
is_complex = results["is_complex"]

if pt3 == 0: # 如果 2a 为 0，则不是二次方程
    print("系数 A 不能为 0，这不是一个二次方程。")
elif results["discriminant"] < 0 and a == 0 and b == 0:
    # 避免当a=0, b=0, c!=0时，判别式为负，但实际无解的误报
    print("系数 A 和 B 不能同时为 0，这不是一个二次方程。")
else:
    x1 = (pt1 + pt2) / pt3
    x2 = (pt1 - pt2) / pt3

    if is_complex:
        print(f"方程的复数根为：")
    else:
        print(f"方程的实数根为：")
    print(f"x1 = {x1}")
    print(f"x2 = {x2}")