题目考点

这道题主要考这几个点：

1. 输入处理
   第一行读入一组多项式系数，第二行读入 x 的值。
2. 列表与数字类型转换
   因为系数里可能有小数，比如样例里的 1.1，所以要用 float。
3. NumPy 中的多项式计算
   这道题的核心通常是 numpy.polyval()。
4. 审题能力
   你要先看明白：题目不是让你“求导”“展开”“输出表达式”，而是让你“代入 x，求多项式的值”。

---

审题

输入是什么

第一行：多项式 P 的系数，空格分隔。
第二行：一个数 x。

比如样例输入：

1.1 2 3
0

输出是什么

输出多项式 P 在 x 这个点上的值。

这道题到底在求什么

如果系数是：

1.1 2 3

那它表示的多项式是：

1.1x^2 + 2x + 3

然后第二行给了：

x = 0

所以要算：

1.1 * 0^2 + 2 * 0 + 3 = 3.0

容易忽略的点

这里最容易忽略的一点是：

系数的顺序是从高次到低次。

也就是说：

[1.1, 2, 3]

表示的是：

1.1x^2 + 2x + 3

不是：

1.1 + 2x + 3x^2

这个顺序一定不能搞反。

---

思路提示

先不要急着写代码，先把题目翻译成步骤：

第一步，读入第一行，把它变成一个“系数列表”。
第二步，读入第二行，把它变成一个数字 x。
第三步，用 NumPy 的 polyval() 把系数和 x 代进去，直接得到结果。
第四步，打印结果。

你可以先把这道题理解成：

我已经知道多项式长什么样了，现在只需要把 x 填进去算值。

---

完整设计思路

这道题最直接的做法就是用 numpy.polyval()。

第一步：读取系数

第一行输入是一串数字，例如：

1.1 2 3

我们要把它变成列表：

[1.1, 2.0, 3.0]

因为有小数，所以这里应该用：

list(map(float, input().split()))

第二步：读取 x

第二行只有一个值，比如：

0

把它读成浮点数：

x = float(input())

之所以也可以用 float，是因为 x 不一定总是整数。

第三步：调用 numpy.polyval(P, x)

这是这道题的核心。

numpy.polyval(P, x)

它的意思是：

已知多项式系数列表 P，求这个多项式在 x 处的值。

例如：

P = [1.1, 2, 3]
x = 0

它等价于计算：

1.1 * 0^2 + 2 * 0 + 3

第四步：输出结果

直接 print() 即可。

---

代码实现

下面是这道题最基础、最适合初学者记忆的写法：

import numpy

P = list(map(float, input().split()))
x = float(input())

print(numpy.polyval(P, x))

---

运行演示

我们用样例来手动走一遍。

输入：

1.1 2 3
0

第一步：读取系数

P = [1.1, 2.0, 3.0]

这表示多项式：

1.1x^2 + 2x + 3

第二步：读取 x

x = 0.0

第三步：代入计算

1.1 * (0^2) + 2 * 0 + 3
= 1.1 * 0 + 0 + 3
= 3.0

第四步：输出

3.0

和题目样例一致。

---

补充理解：为什么这题要用 float，而不是 int

因为样例里系数出现了：

1.1

这已经不是整数了。

如果你写成：

list(map(int, input().split()))

程序会报错，因为 int('1.1') 是不合法的。

所以这道题里更稳妥的写法是：

list(map(float, input().split()))

---

补充理解：numpy.polyval() 到底怎么理解

你可以先把它记成一句话：

polyval = polynomial value
也就是“多项式求值”

它的格式是：

numpy.polyval(系数列表, x)

例如：

numpy.polyval([2, 3, 4], 5)

表示求：

2x^2 + 3x + 4

在 x = 5 时的值，也就是：

2 * 25 + 3 * 5 + 4 = 69

---

方法总结

以后看到这类题，你可以这样识别：

识别信号

题目出现这些关键词时，通常就是这类题：

• polynomial
• coefficients
• value at x

下手模板

你可以直接套这个思路：

1. 先读入系数列表
2. 再读入 x
3. 用 numpy.polyval() 求值
4. 输出结果

也就是：

import numpy

P = list(map(float, input().split()))
x = float(input())

print(numpy.polyval(P, x))

---

易错点回顾

这道题最常见的错误有三个：

1. 把系数顺序理解反了

[1.1, 2, 3]

表示的是：

1.1x^2 + 2x + 3

不是反过来。

2. 用了 int 而不是 float

因为系数可能带小数，所以要用：

float

3. 不会拆输入

这一句一定要熟：

P = list(map(float, input().split()))

它的意思是：

• input() 读入整行
• split() 按空格切开
• map(float, ...) 把每一项转成浮点数
• list(...) 把结果变成列表

---

练习

你可以先自己做这题，不要急着看答案。

练习题

输入：

2 0 1
3

请输出多项式在 x = 3 时的值。

提示

系数 [2, 0, 1] 表示的多项式是什么？
先写成标准形式，再把 x = 3 代进去。
也可以直接用 numpy.polyval()。

numpy.polyval() 为什么 [a, b, c] 表示的是 ax^2 + bx + c

这个问题非常关键。很多初学者第一次看到 numpy.polyval([a, b, c], x) 的时候，都会有同一个疑问：

为什么是 ax^2 + bx + c？
为什么不是 a + bx + cx^2？
这个次数到底是谁规定的？

答案是：这不是程序“猜出来”的，而是 polyval() 早就约定好的规则。

---

polyval() 的固定规则

numpy.polyval(p, x) 里，参数 p 表示的是：

按照“从高次到低次”的顺序排列的系数列表

也就是说：

• 第 1 个数，对应最高次项
• 第 2 个数，对应次高次项
• 第 3 个数，对应再低一项
• …
• 最后 1 个数，对应常数项

所以：

[a, b, c]

并不是随便对应的，而是因为这个列表里一共有 3 个系数。

3 个系数，就说明这个多项式最多是 2 次式。

于是它会自动按下面的顺序解释：

a * x^2 + b * x^1 + c * x^0

也就是：

ax^2 + bx + c

---

为什么最高次是 2 次

这里的关键规律是：

如果有 n 个系数，那么最高次就是 n – 1 次

因为多项式是按“从高到低”一项一项排下来的。

比如：

系数个数	对应最高次
1 个	0 次
2 个	1 次
3 个	2 次
4 个	3 次

所以：

1 个系数

[5]

表示：

5

也就是常数多项式。

2 个系数

[2, 3]

表示：

2x + 3

3 个系数

[2, 3, 4]

表示：

2x^2 + 3x + 4

4 个系数

[1, 2, 3, 4]

表示：

1x^3 + 2x^2 + 3x + 4

---

它是怎么“自动对应”的

这里的“自动”其实不是智能判断，而是按位置套公式。

假设系数列表是：

[c0, c1, c2, ..., cn]

那么 polyval() 默认理解成：

c0 * x^n + c1 * x^(n-1) + c2 * x^(n-2) + ... + cn

你可以把它理解成：

• 列表最左边：次数最高
• 列表最右边：次数最低

所以 [a, b, c] 长度是 3，也就是最高次是 2，于是：

a * x^2 + b * x^1 + c * x^0

---

直接看一个具体例子

例如：

numpy.polyval([1.1, 2, 3], 0)

因为系数有 3 个，所以它表示：

1.1x^2 + 2x + 3

把 x = 0 代进去：

1.1 * 0^2 + 2 * 0 + 3 = 3.0

所以输出就是：

3.0

---

再看一个例子，你会更清楚

numpy.polyval([2, 0, 1], 3)

先解释系数：

[2, 0, 1]

共有 3 个系数，所以是 2 次多项式：

2x^2 + 0x + 1

注意中间那个 0 很重要，它表示这一项“没有”，但位置不能丢。

把 x = 3 代进去：

2 * 3^2 + 0 * 3 + 1
= 2 * 9 + 0 + 1
= 19

---

为什么中间没有某一项时，也必须写 0

这是初学者特别容易错的地方。

比如你想表示：

2x^2 + 1

你不能写成：

[2, 1]

因为 [2, 1] 只有 2 个系数，polyval() 会把它理解成：

2x + 1

这就完全变了。

正确写法必须是：

[2, 0, 1]

因为它表示：

2x^2 + 0x + 1

所以你可以记一句很实用的话：

多项式哪一项没有，系数也要补 0，不能直接省掉位置。

---

为什么不是从低次到高次

因为 numpy.polyval() 这个函数的设计约定就是：

系数按降幂排列，也就是从高次到低次

这是一种常见数学/程序约定，不是 NumPy 临时发明的。

所以：

[a, b, c]

默认就是：

ax^2 + bx + c

而不是：

a + bx + cx^2

你在做题时，不要自己重新定义它的顺序，而要按函数规则来理解。

---

一眼判断的小技巧

以后你看到一个系数列表，可以这样快速判断：

第一步：先数有几个数

比如：

[4, 5, 6, 7]

有 4 个数。

第二步：最高次就是 4 – 1 = 3 次

所以它表示：

4x^3 + 5x^2 + 6x + 7

---

更容易记忆的理解方式

你可以把次数写在系数上方来理解。

比如 [a, b, c]：

a   b   c
2   1   0

也就是：

a*x^2 + b*x^1 + c*x^0

再比如 [p, q, r, s]：

p   q   r   s
3   2   1   0

也就是：

p*x^3 + q*x^2 + r*x + s

这个方法非常适合做题时手动分析。

---

本节小结

这部分你只要牢牢记住三句话就够了：

第一句，numpy.polyval() 的系数顺序是从高次到低次。

第二句，如果有 n 个系数，那么最高次就是 n - 1。

第三句，如果某一项不存在，也必须用 0 占住位置。

所以：

[a, b, c]

之所以表示：

ax^2 + bx + c

不是因为程序“猜”出来了，而是因为：

• 一共 3 个系数
• 最高次就是 2
• 顺序按高次到低次排
• 所以自然就是 a*x^2 + b*x + c

---

小练习

请你自己先判断下面这些系数列表分别表示什么多项式，不要急着运行代码。

练习 1

[3, 4]

提示：一共有几个系数？最高次是几次？

练习 2

[5, 0, 2]

提示：中间的 0 表示哪一项没有？

练习 3

[1, 2, 0, 7]

提示：这是几次多项式？最后一个数对应什么项？

补充一节：numpy.polyval() 和手动写 a*x**2 + b*x + c 到底有什么区别

这个问题也非常重要。因为很多初学者看到这道题时，第一反应会是：

“我直接写 a*x**2 + b*x + c 不就行了吗？”

从“结果能不能算出来”这个角度说，可以。
但从“这道题为什么更推荐 numpy.polyval()”这个角度说，两者还是有明显区别的。

---

先说结论

你可以先记住这一句：

手动写公式，适合“已知固定表达式”的情况。
numpy.polyval()，适合“已知系数列表，让程序自动处理”的情况。

也就是说：

• 如果题目明确告诉你就是 ax^2 + bx + c
• 而且 a、b、c 都已经单独给出来了

那你手写公式完全没问题。

但是这道题不是这样。
这道题给你的不是单独的 a、b、c，而是：

1.1 2 3

也就是“一串系数”。

这时候用 polyval() 就更自然。

---

两种写法分别是什么

写法 1：手动写公式

如果你已经知道多项式是二次的，可以写成：

a, b, c = map(float, input().split())
x = float(input())

print(a * x**2 + b * x + c)

这没有错。

---

写法 2：使用 numpy.polyval()

import numpy

P = list(map(float, input().split()))
x = float(input())

print(numpy.polyval(P, x))

这也是对的。

---

它们最本质的区别是什么

最本质的区别不在“算得对不对”，而在于：

手动写公式：你自己负责展开

polyval()：函数帮你按系数自动展开并计算

也就是说：

手动写：

a * x**2 + b * x + c

你是在明确告诉程序：

• 第一个数乘 x**2
• 第二个数乘 x
• 第三个数直接加上去

而 numpy.polyval(P, x) 是在告诉程序：

• 这里有一组系数
• 你按多项式规则自己去算吧

所以两者的区别，本质上是：

一个是“我自己写死公式”
一个是“我把规则交给函数处理”

---

为什么这道题更推荐 polyval()

原因 1：题目给的是“系数列表”，不是固定变量名

这道题输入的是一整行：

1.1 2 3

这种输入形式本身就很适合先变成一个列表：

P = [1.1, 2.0, 3.0]

而 numpy.polyval(P, x) 恰好就是接收“系数列表”的。

也就是说，输入形式和函数形式是天然匹配的。

如果你手动写，就必须先拆成：

a, b, c = map(float, input().split())

这就隐含了一个前提：

你已经知道一定只有 3 个系数

但题目真正强调的是“多项式系数”，不是“只允许二次式”。

所以从表达题意的角度，polyval() 更贴切。

---

原因 2：polyval() 更通用

手动写：

a * x**2 + b * x + c

只能处理二次式。

如果题目下一次变成：

2 3 4 5

也就是三次多项式：

2x^3 + 3x^2 + 4x + 5

那你手写公式就得改成：

a * x**3 + b * x**2 + c * x + d

如果再变成四次、五次，你就要继续改。

但 polyval() 不需要改。

不管是：

[2, 3]

还是：

[2, 3, 4]

还是：

[1, 5, 2, 8, 9]

都可以直接：

numpy.polyval(P, x)

这就是它最大的优势：

它不是只会算一个固定公式，而是能算“任意次数”的多项式。

---

原因 3：更不容易写错

手动写公式时，初学者很容易出错，常见错误有：

错误 1：次数写错

本来应该写：

a * x**2 + b * x + c

结果写成：

a * x*2 + b * x + c

这里 x**2 和 x*2 完全不是一回事。

---

错误 2：漏写某一项

比如本来应该是：

a * x**2 + b * x + c

结果不小心写成：

a * x**2 + c

把中间项漏掉了。

---

错误 3：高次低次顺序写反

比如 [a, b, c] 本来是：

ax^2 + bx + c

但手写时有人会错写成：

a + bx + cx^2

---

用 polyval() 时，这些错误会少很多，因为你只需要保证：

• 系数顺序对
• 输入类型对

剩下的计算由函数完成。

---

原因 4：代码更简洁，也更像“在解这道题”

这句话很重要。

这道题本质上不是在考你会不会展开二次表达式，而是在考你：

• 会不会读入系数
• 会不会理解多项式系数的顺序
• 会不会使用 NumPy 的多项式求值函数

所以从“题目考点”的角度说，polyval() 更符合出题人的意图。

换句话说：

手动写公式，是你自己绕过了函数。
polyval()，才是在直接使用这道题想让你掌握的工具。

---

一个非常直观的对比

手动写法

a, b, c = map(float, input().split())
x = float(input())

print(a * x**2 + b * x + c)

这段代码的问题不是错，而是它只能应付“刚好三个系数”的情况。

---

polyval() 写法

import numpy

P = list(map(float, input().split()))
x = float(input())

print(numpy.polyval(P, x))

这段代码的好处是：

• 输入几个系数都能处理
• 不需要你自己展开公式
• 更适合“多项式系数列表”这种题型

---

那是不是以后都不要手动写公式了

也不是。

手动写公式在下面这些情况仍然很有用。

适合手动写公式的情况

1. 题目表达式已经固定

比如题目明确给你：

y = 3x^2 + 2x + 1

只让你输入 x，求 y。

这种时候直接写：

3 * x**2 + 2 * x + 1

很自然，也很清楚。

2. 你在练习基础运算

如果你正在学习：

• 幂运算 **
• 变量代入
• 表达式书写

那手动写公式反而更适合训练基础。

---

适合 polyval() 的情况

1. 系数是整体输入的一串数据

2. 多项式次数不固定

3. 题目明显是 NumPy 练习

4. 你想减少手写展开时的错误

这道题就属于这一类。

---

你可以这样理解两者关系

你可以把它们想成：

手动写公式

像是你自己拿笔算：

ax^2 + bx + c

polyval()

像是你把“系数表”和“x 的值”交给一个专门干这件事的工具，它自动帮你算。

所以两者不是“谁对谁错”的区别，而是：

一个更基础，适合练表达式
一个更通用，适合处理多项式数据

---

本节小结

这部分可以总结成四句话。

第一，手动写 a*x**2 + b*x + c 当然可以算出结果。

第二，但它默认你已经知道多项式就是二次式，而且系数数量固定。

第三，numpy.polyval() 更适合“输入是一串系数”的题，因为它会按规则自动完成多项式求值。

第四，所以这道题更推荐 polyval()，不是因为手写不行，而是因为 polyval() 更通用、更稳、更符合题目本意。

---

一个很实用的判断标准

以后做题时，你可以这样判断该用哪种写法：

如果题目给你的是固定公式

例如：

y = 2x^2 + 3x + 1

那就手动写公式。

如果题目给你的是系数列表

例如：

2 3 1

那就优先想到：

numpy.polyval()

---

小练习

你先不要写代码，先判断下面两道题更适合用哪种方式。

练习 1

题目直接告诉你：

y = 4x^2 + 5x + 6

只输入 x，求 y。

提示：这里表达式是不是固定的？

练习 2

题目输入第一行是一串多项式系数，第二行是 x。

提示：这时你是不是事先不知道有几个系数？