2. 求方程ax2+bx+c=0的根,用3个函数分别求当: b2-4ac大于0、等于0和小于0时的根并输出结果。从主函数输人a,b,c的值。

以下是根据引用[1]提供的方法，用Python实现求解一元二次方程的根的代码：

def root1(a, b):
    return (-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)

def root2(a, b):
    return (-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)

def root3(a, b):
    return -b / (2 * a)

a = float(input("请输入a的值："))
b = float(input("请输入b的值："))
c = float(input("请输入c的值："))

delta = b ** 2 - 4 * a * c

if delta > 0:
    print("方程有两个不相等的实根：")
    print("x1 =", root1(a, b))
    print("x2 =", root2(a, b))
elif delta == 0:
    print("方程有两个相等的实根：")
    print("x1 = x2 =", root3(a, b))
else:
    print("方程没有实根。")

运行代码后，程序会提示用户输入a、b、c的值，然后根据输入的值计算方程的根，并输出结果。

--相关问题--:
1. 如何用Python求解高次方程的根？
2. 如何判断一个方程是否有实根？
3.

相关问题

求方程ax2+bx+c=0的根,用3个函数分别求当b2-4ac>0、b2-4ac=0、b2-4ac<0时的根,并

当$b^2-4ac>0$时，方程$ax^2+bx+c=0$有两个不相等的实数根。
我们可以使用判别式$D=b^2-4ac$来判断方程的根的情况。
当$D>0$时，方程有两个不相等的实数根。

我们可以定义一个函数来求解方程的根：

def find_roots(a, b, c):
    D = b**2 - 4*a*c
    if D > 0:
        root1 = (-b + D**0.5) / (2*a)
        root2 = (-b - D**0.5) / (2*a)
        return root1, root2

当$b^2-4ac=0$时，方程$ax^2+bx+c=0$有两个相等的实数根。
我们可以使用判别式$D=b^2-4ac$来判断方程的根的情况。
当$D=0$时，方程有两个相等的实数根。

我们可以继续完善上面的函数来求解方程的根：

def find_roots(a, b, c):
    D = b**2 - 4*a*c
    if D > 0:
        root1 = (-b + D**0.5) / (2*a)
        root2 = (-b - D**0.5) / (2*a)
        return root1, root2
    elif D == 0:
        root = -b / (2*a)
        return root, root

当$b^2-4ac<0$时，方程$ax^2+bx+c=0$没有实数根，而是有两个共轭的复数根。
我们可以使用判别式$D=b^2-4ac$来判断方程的根的情况。
当$D<0$时，方程没有实数根，而是有两个共轭的复数根。

我们可以继续完善上面的函数来求解方程的根：

def find_roots(a, b, c):
    D = b**2 - 4*a*c
    if D > 0:
        root1 = (-b + D**0.5) / (2*a)
        root2 = (-b - D**0.5) / (2*a)
        return root1, root2
    elif D == 0:
        root = -b / (2*a)
        return root, root
    else:
        real_part = -b / (2*a)
        img_part = abs(D)**0.5 / (2*a)
        root1 = complex(real_part, img_part)
        root2 = complex(real_part, -img_part)
        return root1, root2

这样，我们就实现了根据给定方程系数$a$、$b$、$c$来求解方程根的函数。对于不同的判别式情况，函数会返回不同的根。

C语言 求方程ax*2+bx+c=0的根，用三个函数分别求当：b*2-4ac大于零，等于零和小于零时的根并输出结果，从主函数输入a，b，c的值

下面是实现此功能的代码：

#include <stdio.h>
#include <math.h>

// 函数声明
void solve(double a, double b, double c);
void printRoot(double x1, double x2);
double getDiscriminant(double a, double b, double c);

int main()
{
    double a, b, c;
    printf("请输入方程的系数：\n");
    scanf("%lf %lf %lf", &a, &b, &c);
    solve(a, b, c);
    return 0;
}

// 计算并输出根
void printRoot(double x1, double x2)
{
    printf("方程的根为：\n");
    printf("x1 = %.2f\n", x1);
    printf("x2 = %.2f\n", x2);
}

// 计算判别式
double getDiscriminant(double a, double b, double c)
{
    return b * b - 4 * a * c;
}

// 求方程的根
void solve(double a, double b, double c)
{
    double discriminant = getDiscriminant(a, b, c);
    if (discriminant > 0) {
        double x1 = (-b + sqrt(discriminant)) / (2 * a);
        double x2 = (-b - sqrt(discriminant)) / (2 * a);
        printRoot(x1, x2);
    } else if (discriminant == 0) {
        double x = -b / (2 * a);
        printf("方程有唯一实根：\n");
        printf("x = %.2f\n", x);
    } else {
        printf("方程无实根\n");
    }
}

该程序定义了三个函数：

- `solve()`：根据输入的系数求出方程的根，并调用 `printRoot()` 函数输出结果。
- `printRoot()`：输出方程的根。
- `getDiscriminant()`：计算方程的判别式。

在主函数中，用户需要输入方程的系数，然后调用 `solve()` 函数来计算方程的根。程序会根据判别式的大小分别输出有实根、有唯一实根和无实根的情况。