Alex Kazantsev's questions

在编写使用高斯方法计算函数积分的脚本时，我需要达到所需的计算精度delta。这取决于参数j_els。如果精度不满足指定值（误差在变量中可见err_gauss），则必须将参数加倍，并且必须在内部函数内重新计算积分gauss()。如果再次不满足，则参数j_els再次加倍，依此类推，直到max_iter达到所需的精度或指标（最大迭代次数）。

而且，用户请求的积分顺序n不能超过6个。计算初始值时使用该顺序j_els。功能的实现gauss_integrated(a, b)是这样的，n需要请求。

为了实现这一点，我编写了第 9 点，在 while 循环中我尝试达到所需的精度。但是，我不知道如何将具有双倍值的gauss()变量传递j_els给函数，因为它不是函数的参数。如何修复代码？我没有完整地展示剧本，只是展示了它的支撑点。第九段代码，同时完整展示。

import numpy as np

def func_for_integrate(x):
    """
    Исходная функция для последующего интергрирования 
    """
    res = (1+np.sqrt(x))/(x**2)
    return res

def gauss_integrated(a, b):
    """
    Функция получения интеграла по методу Гаусса 
    """
    # 1. запросим порядок формулы и точность 
    n = int( input('Введите порядок формулы (количество узлов от 1 до 6): ') )
    delta = float( input('Введите точность расчета (десятичная дробь): ') )
    
    # 2. определим условие, при котором n не может быть меньше единицы и больше пяти
    assert n>=1 and n<=5, 'Определите n от 1 до 6'
    
    # 3. определим максимаьное количество итераций удвоения интервалов 
    max_iter = 100 
    
   # 4. определим словарь с коэффициентами t:
    ...
    
    # 6. определим функцию расчета интеграла
    def gauss(n):
        ...
        
        # 6.4. определим переменную для параметра j 
        # ДАННЫЙ ПАРАМЕТР НЕОБХОДИМО УДАИВАТЬ ДЛЯ ТОЧНОСТИ
        j_els = n-1
    
        # 6.5. Рассчитаем интеграл с параметром j
        ...

        # 6.5.2. получим значение интеграла по формуле    
        s_j = ( ((b-a)/(2*(j_els+1))) * sum_outside )
        
        return s_j
    
    # 7. создадим две переменных: одна с количеством интервалов n, другая - с (n+1)
    integ_1 = gauss(n)
    n += 1
    integ_2 = gauss(n)

    # 8. применим критерий точности вычисления 
    err_gauss = abs((integ_2 - integ_1)/integ_2)

    # 9. с помощью цикла добьемся требуемой точности расчета 
    while err_gauss > delta:
        if i <= max_iter:
            i += 1
            integ_1 = integ_2
            j_els *= 2
            integ_2 = gauss()
            err_gauss = abs((integ_2 - integ_1)/integ_2)
            # корректировка точности
            if err_gauss <= delta:
                break
        else:
            print('Достигнуто максимальное количество итераций')
            break
   
    # 10. Выведем результаты
    print('Интеграл по методу Гаусса: ', integ_2)
    print('Итоговое количество интервалов: ', j_els)

需要执行该文件jar，为此将文件bat与脚本一起运行来执行。在行中指定可执行文件的命令Test9：

f:\Program_training......\Test9>java.exe -jar Test9.jar

但出现错误：

“java.exe”不是内部或外部命令、可运行程序或批处理文件。

找到一个变量Path并添加已安装的Java的路径：

c:\Program Files\Java\jdk-13.0.2\bin\

但这没有帮助。当我尝试直接在命令行上输入符号时，我收到了相同的通知C:\Program Files\Java\jdk-13.0.2\bin\java -jar Test9.jar。

问题如何解决？

我使用二分法计算方程中求根的函数dichotomy()，然后使用装饰器显示值print_dichotomy()。我相信最后我会看到列根 - 函数在根 - 误差 - 收敛处的值。然而，实际上，我以这样的方式得到它：只有函数的根和值预期从 columns 中显示，而其他两列是不正确的。其中，误差仅由一个值（其余行NaN）表示，并且收敛- 它的所有值都在一行中。

我没有描述该函数的本质dichotomy()，而是在其中放置 Pandas 列的伪值列表。

错误在哪里？

我的代码：

import numpy as np
import pandas as pd

def print_dichotomy(funcs):
    def wrapper(a, b, eps_func, eps_arg):
        *res, func, eps_list, prev_roots = list(funcs(a, b, eps_func, eps_arg))
        func = list(map(lambda x: f'{f(x):.10f}', res))
        result_table = pd.DataFrame()
        result_table['Корни'] = pd.Series(res)
        result_table['Значения функции'] = pd.Series(func)
        result_table['Погрешность расчета'] = pd.Series(eps_list)
        result_table['Сходимость'] = pd.Series(prev_roots)
        print(result_table)
    return wrapper

def f(x):
    return 1.2 - np.log(x) - 4 * np.cos(2 * x)

@print_dichotomy
def dichotomy(a, b, eps_func, eps_arg):

    # 1. создаем переменную-список для хранения значений корня
    prev_roots = [0.01, 0.01, 0.01, 0.01, 0.01, 0.01]
    # 2. создадим список для хранения погрешностей расчета
    eps_list = [0.02, 0.02, 0.02, 0.02, 0.02, 0.02]
    # 3. создадим список для хранения корней
    roots = [0.03, 0.03, 0.03, 0.03, 0.03, 0.03]
    for i in roots:
        root = i 
        # 4. возвращаем корень
        if root:
            yield root
      
    # 5. возвращаем значение погрешности расчета корня, сходимости 
    yield eps_list, prev_roots

dichotomy(0.0001, 50, 0.000001, 0.000001)

在用二分法求解一个变量的方程时，根据问题的条件，我需要计算求根时的迭代次数。对于一次迭代，正如我所读，您可以将段的划分数减半。对于每个根至少一次，段被划分。即迭代次数显然不会少于根数。但是，我的计数器只显示一个分区，即一次迭代。怎么了？

代码：

import numpy as np
from decimal import *
import pandas as pd

def print_dichotomy(funcs):
    def wrapper(a,b, eps_func, eps_arg):     
        *res, func, eps_list = list(funcs(a,b, eps_func, eps_arg))
        result_table = pd.DataFrame()
        result_table['Корни'] = pd.Series(res)
        print('Количество итераций: ', iter_count)
        print(result_table)
    return wrapper 

def f(x):
    return 1.2-np.log(x)-4*np.cos(2*x)

@print_dichotomy
def dichotomy(a, b, eps_func, eps_arg):      
    # 1. определим глобальную переменную (расчет количества итераций)
    global iter_count
    
    # 2. определим ограничения на границы отрезка 
    assert a != 0, 'a равно 0'
    assert b != 0, 'b равно 0'

    # 3. запросим количество частей n, на которые будет дробиться отрезок 
    n = int( input('Введите параметр n (целое число): ') )
    
    # 5. отделим корни
    # для этого разделим заданный отрезок на n частей 
    grid = np.linspace(a, b, n)
    
    #  6. создадим счетчик для количества итераций 
    iter_count = 0
    
    # 7. уточним наличие корней на каждом отрезке
    for x, y in zip(grid, grid[1:]):
        # 7.1. если на отрезке нет корня, смотрим следующий отрезок
        if f(x) * f(y) > 0:  
            continue
        root = None
        # 7.2. уточним корни
        while abs(f((x+y)/2)) > eps_func and ((y - x)/2) > eps_arg:
            if y != x:
                # 7.2.1.1. получаем середину отрезка
                mid = (y + x) / 2
                # 7.2.1.2. пополним счетчик итераций на один (было одно деление пополам)
                iter_count =+ 1
                # 7.2.1.3. корень примем равным серединному значению:
                root = mid  
                break
                # 7.2.1.5. иначе если произведение функции в середине отрезка на функцию в т. а <= 0:
                if Decimal(f(mid) * f(x)) <= 0:
                    # 7.2.1.5.1. серединой отрезка признаем точку b:
                    y = mid  
                else:
                    # 7.2.1.5.3. в другом случае — точку а:
                    x = mid 
        # 8. возвращаем рассчитанный корень 
        if root:
            yield root

dichotomy(0.0001, 50, 0.000001, 0.000001)

根据问题的条件，我需要用高斯法得到逆矩阵。在这种情况下，需要将中间矩阵输出到控制台。

该方法的本质：我们用单位矩阵代替给定矩阵并变换行。脚本分为正向和反向。

我应用了以下逻辑：我们转换字符串，每次都将它们添加到一个空列表中bank_of_matrix。但是，循环生成六行，即两个矩阵。现在它们在我的变量中bank_of_matrix的一“串”行中。有必要将它们分开。通过柜台办理？但是，即使我计算了所需的行数，我如何进行截断以便将下一个“部分”行“写入”到另一个矩阵中？

代码：

import numpy as np
matrix_origin = np.array([[3.8, 6.7, -1.2], 
                        [6.4, 1.3, -2.7], 
                        [2.4, -4.5, 3.5]])

n = matrix_origin.shape[0]
matrix_ = np.hstack((matrix_origin, np.eye(n)))

bank_of_matrix = []
# nrow равен номеру строки
# row содержит саму строку матрицы
for nrow, row in enumerate(matrix_):
    divider = row[nrow]  # диагональный элемент
    # делим на диагональный элемент:
    row /= divider
    bank_of_matrix.append(row) 
    # теперь вычитаем приведённую строку из всех нижележащих строк:
    for lower_row in matrix_[nrow + 1:]:
        factor = lower_row[nrow]  # элемент строки в колонке nrow
        lower_row -= factor * row  # вычитаем, чтобы получить ноль в колонке nrow
        bank_of_matrix.append(lower_row)
for i in bank_of_matrix:
    print(i)

第二个问题：我试图在输出到控制台时用 0 和 1 切断左矩阵。但是，我收到一个错误。代码：

for i in bank_of_matrix[:, n:]:
    print(i)

实现了使用二分法求根的算法。一共有三个函数：f()它包含了我们要找根的方程，print_dichotomy一个将计算结果输出到控制台的装饰器，以及dichotomy()一个使用二分法的脚本。

但是，字符串print('Значения функции составляют:\n', func)输出零。为什么？

代码：

import numpy as np

def print_dichotomy(dichotomy):
    def wrapper(a,b,eps):
        res = list(dichotomy(a,b, eps))
        func = ', '.join(map(lambda x: f'{f(x):.4f}', res))
        print('Корни по методу дихотомии находятся в точках:')
        print(', '.join(map(lambda x: f'{x:.4f}', res)))
        print('Значения функции составляют:\n', func)
    return wrapper

def f(x):
    return 1.2-np.log(x)-4*np.cos(2*x) 

@print_dichotomy
def dichotomy(a, b, eps):  
    """
    Функция отделения и уточнения корня.
    Передаются параметры: отрезок от a до b делим на n частей (отдельный запрос), погрешность по функции eps
    """
      
    # 2. определим ограничения на границы отрезка 
    assert a != 0, 'a равно 0'
    assert b != 0, 'b равно 0'

    # 3. запросим количество частей n, на которые будет дробиться отрезок 
    n = int( input('Введите параметр n (целое число): ') )
    
    # 4. отделим корни
    # 4.1. разделим заданный отрезок на n частей 
    grid = np.linspace(a, b, n)
    # 4.2. уточним наличие корней на каждом отрезке 
    for x, y in zip(grid, grid[1:]):
        # если на отрезке нет корня, смотрим следующий отрезок
        if f(x) * f(y) > 0:  
            continue
        root = None
        # 5. уточним корни
        # пока отрезок больше заданной погрешности по функции, выполняем нижестоящие операции:
        while abs(f(y) - f(x)) > eps or ((y - x)/2) > eps:
            if y != x:
            # получаем середину отрезка
                mid = (y + x) / 2
            # если функция в середине отрезка равну нулю или меньше погрешности:
                if f(mid) == 0 or abs(f(mid)) < eps:
                # корень равень серединному значению:
                    root = mid  
                    break
            # иначе если произведение функции в середине отрезка на функцию в т. а <0:
                elif (f(mid) * f(x)) <= 0:
                    # серединой становится точка b:
                    y = mid  
                else:
                    # в другом случае — точка а:
                    x = mid  
        if root:
            yield root

dichotomy(0.0001, 50, 0.000001)

我循环遍历列表while loop ，每次x_j_list将索引递增1。point_elem_j同时，我向列表添加了一个parameters_list新值poly_n。

但是，我收到一个错误

IndexError：列表索引超出范围

它出现就行了poly_n = x_j_list[point_elem_j] - x_col_list[0]。

在我的完整示例中，我设法进行了 21 次迭代（按 list 中的元素数x_j_list），但我无法计算 list 的parameters_list最终值，即第 21 个值poly_n。

问题是什么？

代码：

import numpy as np

x_i_list = [(0.1*np.pi*i) for i in range(0, 11)]
x_j_list = [(0.05*np.pi*j) for j in range(0, 21)]
order = 4
x_col_list = [0.0, 0.3141592653589793, 0.6283185307179586, 0.9424777960769379]


point_elem_j = 0
# пока индекс в сетке x_j_list не достигл длины данного списка: 
while point_elem_j <= len(x_j_list):

    poly_n = x_j_list[point_elem_j] - x_col_list[0] # считаем первый элемент
    parameters_list = [poly_n]
    for args, elems in enumerate(x_col_list[1:]):
        poly_n = (x_j_list[point_elem_j] - elems) * poly_n # считаем второй и последующие элементы
        parameters_list.append(poly_n)
        
    point_elem_j += 1

我需要将parameters_list枚举的结果放入列表中，得到如下： 首先，(x-x_0)它是x从列表中获取的x_j_list，和x_0- 从列表中获取的x_col_list。

那么parameters_list另一个元素应该出现在：第一个差值和第二个差值的乘积。它是通过从x零后面的同一列表元素中减去而获得的x_col_list。依此类推，直到此列表中的元素用完（它们与变量一样多order）。

原理如公式所示：

编译了一个不按预期工作的脚本。我得到的答案在第二个之后并没有真正收敛（算法正确地考虑了前两个）。

我的输出Список parameters_list: [0.15707963267948966, -0.024674011002723394, -0.07402203300817019, -0.12337005501361697]：

同时-0.074，我的心理账户给出的不是元素，而是0,011；-0.123而不是我考虑另一个元素的元素： -0.008。

代码：

x_j_list = [(0.05*np.pi*j) for j in range(0, 21)]
point_elem_j = 1
order = 4
x_col_list = [0.0, 0.3141592653589793, 0.6283185307179586, 0.9424777960769379]

parameters_list = []
for args, elems in enumerate(x_col_list):

    poly_0 = x_j_list[point_elem_j] - x_col_list[0]
    print(x_col_list[0])
    print('poly_0: ', poly_0)
    print('elems: ', elems)
    if not args:
        parameters_list.append(poly_0)
    
    if args in range(1, order):  # args = 1,2
        poly_n =  (x_j_list[point_elem_j] - x_col_list[args])*poly_0
        print('elems: ', elems)
        print('poly_n: ', poly_n)
        if args:
            parameters_list.append(poly_n)
        poly_0 = poly_n
        
print('Длина parameters_list: ', len(parameters_list))
print('Список parameters_list: ', parameters_list)

为公告板实现教程 servlet。不明白为什么Посмотреть объявление点击文字不能进入另一个页面（文件）。相反，我发现了错误404。

窗口截图

编码：

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Доска объявлений</title>
</head>
<body>
<form action="GetAttrs" method="post"">
     Авторизуйтесь&nbsp;&nbsp;Автор объявления:&nbsp;&nbsp;<input name="author" type="text" size="31" /><br>
     Напишите яркий заголовок&nbsp;&nbsp; Текст:&nbsp;&nbsp;<input name="title" type="text" size="31" /><br>
     Напишите объявление&nbsp;&nbsp; Ваш текст:&nbsp;&nbsp;<textarea name="content" rows="7" cols="30"></textarea><br>
    <p>
    <input type="submit" value="Разместить">
    <input type="reset" value="Сброс формы">
    <a href="Display.jsp">Посмотреть объявление</a>
</body>
</html>

我有一张表，其中有 2 个余弦计算：第二个通过点的间隔是第一个的 2 倍。

因此，在某些点上，所有值都是相同的，而在其他点上则不同。

必需：分割线。值匹配的地方，我们把所有的值放在一行；不匹配的地方，我们把值放在新的一行。

输出应该是这样的：

i   x_i   cos(x_i)  x_j   cos(x_j)
0   0.000   0.000   0.000   0.000
1                   0.157   0.987
2   0.314   0.309   0.314   0.309
3                   0.471   0.891

编码：

import pandas as pd

dataframe = pd.DataFrame()
dataframe['i'] = pd.Series([0.00, 0.314, 0.628, 0.942])
dataframe['cos(x_i)'] = pd.Series([0.000, 0.309, 0.587, 0.809])
dataframe['j'] = pd.Series([0.00, 0.157, 0.314, 0.471])
dataframe['cos(x_j)'] = pd.Series([0.000, 0.987, 0.309, 0.891])

for col in dataframe:
    if dataframe.iloc['i'] == dataframe.iloc['j']:
        # в датафрейм вносим всю строку
    else:
        # спускаемся на строку ниже
        # в датафрейм вносим ячейки столбцов 'j' и 'cos(x_j)'

我有一个 Pandas 数据框，我需要在其中沿某个列添加一些行。此外，这不应随意进行，而是按顺序向下移动，测量order变量指定的行数。

所以，有多少行要计入总和，用户定义的指标顺序会告诉. 在我们的例子order=3中，这意味着我们添加了 3 行。到目前为止，我已经收到了原始表格。想总结一下。我会很感激的想法。到目前为止，我认为按行分组的方向，但我发现很难实现。

编码：

import pandas as pd

order = 3
y_0 = 0
koefs_list = [3,4,5]
parameters_list = [1,1,1,2,2,2,3,3,3]

df = pd.DataFrame({"params":parameters_list, "koefs":koefs_list*int(len(parameters_list)/len(koefs_list))})
df["res"] = df["params"]*df["koefs"]+y_0
print(df)

在输出中，我需要按列添加值res：

    params  koefs  res
0       1      3    3
1       1      4    4
2       1      5    5
3       2      3    6
4       2      4    8
5       2      5   10
6       3      3    9
7       3      4   12
8       3      5   15

有 2 个列表。B koefs_list- 系数。我们将它们与列表参数相乘parameters_list。

它需要是这样的：

1. 该算法测量order从parameters_list

2. 乘以系数：每个元素都有自己的系数，从koefs_list

3. 将结果因子相加，添加到它们y_0

4. 结果被放入一个新列表中polinom_list。

5. parameters_list使用 length 内的以下元素执行操作 1 到 4 order。如此 - 到列表的末尾parameters_list。

现在我有一个功能zip。然而，其余的困难。

编码：

y_0 = 0
summa_prod= y_0 + 0
order = 3

polinom_list = []
koefs_list = [3,4,5]
parameters_list = [1,1,1,2,2,2,3,3,3]

for koefs, params in zip(koefs_list, parameters_list):
    product = koefs*params
    summa_prod +=product

我正在解决一个我试图填写新列表的问题param_list。其元素的形成逻辑如下：

由于我的代码的实现，只有第一个元素被添加到 list poly_0 = x_j - x_col_list[0]。他是平等的0.157 - 0 = 0

代码有什么问题？

编码：

params_list = []
x_j = 0.157
x_col_list = [0.0, 0.3142, 0.6283]

for args in range(order):   # args = 0,1,2
    poly_0 = x_j - x_col_list[0]
    if not args:
        params_list.append(poly_0)
    poly_n =  (x_j - x_col_list[args])
    if not args:
        param_list.append(poly_n)
        poly_0 = poly_n

print(params_list)

我正在编写一个用于计算牛顿多项式的代码片段。在循环期间for，我需要得到 3 个术语（每个术语都必须在括号中）：

(x - 30) (x - 20) (x - 10) + (x - 20)*(x - 10) + (x - 10)

当我浏览代码时，我得到了这个：

x + (x - 30) (x - 20) (x - 10) + (x - 20)*(x - 10) - 10

拥有 3 个术语对我来说很重要，因为将来在另一个周期中，它们中的每一个都将乘以系数。

如何实现？

编码：

from sympy import symbols
x = symbols('x')
dig_list = [10, 20, 30]

poly_0 = x-dig_list[0]
summa = poly_0

for i in range(1, len(dig_list)):
    poly_n = poly_0 * (x-dig_list[i])
    summa += poly_n
    poly_0 = poly_n
print(summa)

我需要得到这个结果：

(x - 30) (x - 20) (x - 10) + (x - 20)*(x - 10) + (x - 10)

而且，看起来，书面代码应该导致这一点，但是这个术语(x - 10)已经丢失了。有什么问题？

编码：

from sympy import symbols
x = symbols('x')
dig_list = [10, 20, 30]

poly_0 = x-dig_list[0]
for i in range(1, len(dig_list)):   
    poly_n = poly_0 * (x-dig_list[i])
    # кажется, что при первом проходе poly_0 в summa должен давать искомое слагаемое:
    summa = poly_0 + poly_n
    poly_0 = poly_n
print(summa)

我生成了一个数组列表，它们是一组有限差分：我们在带有增量的列中看到它们。

现在的任务。用户指定未来多项式的阶数，这决定了对应的列。其中，差异的数量是不同的：我需要获取某个列中最后一个数字（最后一个差异）的索引。我写了一个错误的代码：

ValueError：具有多个元素的数组的真值不明确。使用 a.any() 或 a.all()

编码：

def func(x):
    return np.sin(x)

def poly(order):
    # строим колонки X и Y:
    x_i_list = [round( (0.1*np.pi*i), 4 ) for i in range(0, 11)]
    y_i_list = []
    for x in x_i_list:
        y_i = round( (func(x)), 4 ) 
        y_i_list.append(y_i)

    # получаем дельты:
    n=order
    if n < len(y_i_list):
        result = [ np.diff(y_i_list, n=d) for d in np.arange(1, len(y_i_list)) ]
        print(result)
    else:
        print(f'Определите порядок полинома меньше {len(y_i_list)}')
    index = result.index(result[order-1][-1])
    return index
    
func(3)  # задается порядок полинома 3, 
         # то есть нужна разность по колонке с 3-й дельтой. 
         # Там индекс последней разности 7

我有一个数组列表，array可以从中选择第一个数组：

[array([0.0016, 0.5859, 0.2212, 0.1422, 0.0491]),
 array([ 0.5843, -0.3647, -0.079 , -0.0931]),
 array([-0.949 ,  0.2857, -0.0141]),
 array([ 1.2347, -0.2998]),
 array([-1.5345])]

但是，如果我选择一个零元素的代码，那么我会在输出中看到每个数组的所有零元素array：

for elen in result:
    print(elen[0])

# ВЫВОД:
0.0016
0.5842999999999999
-0.949
1.2347000000000001
-1.5345000000000002 

我需要得到array([0.0016, 0.5859, 0.2212, 0.1422, 0.0491])

我建立了三角函数 y=sin(x) 的多项式。为它选择度数 n=5。因此 m=2n=10。在这个阶段，我需要得到一个值的中间结果（表格），如下图（根据公式条件排除第0和第10个值）：

实际上，任务是计算表格单元格的值。它们由以下公式计算： 。

这里 k 等于 n（即 k=n=5）。

现在我已经手动实现了对 k 的搜索，独立设置这些系数（1、2 等等，直到 5）。现在我正在尝试（到目前为止没有成功）获得以下算法：

1. 计算 k=1 的产品列∏；
2. 列出 list_product_of_elements；
3. 计算这些值的总和；
4. 列出 sum_of_list_product_of_elements；
5. 输出列表到控制台；
6. 为 Pandas 框架专栏投稿；
7. 清除列表；
8. 对于 k=2，转到下一列 ∏ 并重复操作；
9. 输出一个填充的 Pandas 框架。

由于列计算不正确，Pandas 对象的元素数量也不匹配。我的周期有什么问题？

编码：

# Рассчитаем коэффициенты b_j: 
# получаем столбцы перемноженных значений y_j на sin(k*x_j) для таблицы выше

# сначала объявим списки, переменные, фрейм Pandas
df_table = pd.DataFrame(columns=['j','y_j', 'П, k=1', 'П, k=2', 'П, k=3', 'П, k=4', 'П, k=5'])
n=5
m=10
list_product_of_elements = []
sum_of_list_product_of_elements = []
sin_list = []

# следом получим столбец y_j:
for elem in x_list:
    sin = round(math.sin(1*elem), 4)
#     print(sin)
    sin_list.append(sin)
summa = sum(sin_list)

# теперь займемся формированием таблицы:
# идем по индексам коэффициентов k (т.е. k=1, k=2 и т.д.):
for n_elems in range(1, n+1): 
    # идем по элементам графы sin(x) (то есть y_j):
    for y_j in sin_list[1:10]:  
        # идем по x_j, рассчитанным по формуле для получения коэффициента b_j
        for x_j in grid_x_j_for_b_k: 
            product_of_elements = round( (y_j*np.sin(n_elems*x_j)), 4)
        # заносим в список рассчитанные элементы для данного k
        list_product_of_elements.append(product_of_elements) 
        # получаем сумму элементов по итерации
        sum_of_list_product_of_elements.append(sum(list_product_of_elements)) 
        # заполняем колонки фрейма 
        df_table[f'П, k={n_elems}'] = list_product_of_elements      
        # вывод колонки в консоль
        print(f'Произведения для k={n_elems}: ', list_product_of_elements)   
        # вывод суммы колонки в консоль
        print(f'Сумма для k={n_elems}: ', sum_of_list_product_of_elements)  
        # очистка списка элементов
        list_product_of_elements.clear()      
        # очистка списка суммы
        sum_of_list_product_of_elements.clear()
    
df_table['j'] = sin_list[1:10]

我使用二分法实现了用一个变量找到方程的根。那里的本质是：段被分成两半几次。如果段中间的函数为零或小于指定的错误，则找到根。否则，我们继续划分，然后将其左、右“边界”作为段的边界。

我将结果的输出组织在一个包装函数中，这样这个输出功能就不会影响主任务执行时间的计算——寻找根。

除其他事项外，还需要指示迭代次数（段被分成两半的次数）。正如我现在所做的（我自己也明白出了什么问题），它不起作用。错误：

NameError：名称“计数器”未定义

怎样成为？编码：

import numpy as np

def print_dichotomy(dichotomy):
    def wrapper(a,b,n, eps):
        print('Корни по методу дихотомии находятся в точках:')
        print(', '.join(map(lambda x: f'{x:.4f}', res)))
        print('Количество итераций: ', counter)   # ЗДЕСЬ ОШИБКА
    return wrapper

def f(x):
    return 1.2-np.log(x)-4*np.cos(2*x)

@print_dichotomy
def dichotomy (a,b,n, eps): # отрезок от a до b делим на n частей, погрешность eps
    """
    Функция отделения и уточнения корня
    """
    assert a!=0,  'a равно 0'
    assert b!=0, 'b равно 0'
    
    # сначала отделим корни
    grid=np.linspace(a, b, n)
    
    # далее уточним корни
    counter=0
    for x,y in zip(grid, grid[1:]):
        if f(x) * f(y) > 0: # если на отрезке нет корня, смотрим следующий
            continue
        root = None
        while ( abs(f(y)-f(x)) )>eps:     # пока отрезок больше заданной погрешности, выполняем нижестоящие операции:
            mid = (y+x)/2                   # получаем середину отрезка
            if f(mid) == 0 or f(mid)<eps:    # если функция в середине отрезка равну нулю или меньше погрешности:
                root = mid                  # корень равен серединному значению
                counter+=1
                break
            elif (f(mid) * f(x)) < 0:       # иначе если произведение функции в середине отрезка на функцию в т. а <0
                y = mid                     # серединой становится точка b
            else:
                x = mid                     #в другом случае - точка а
        if root:
            yield root

我使用二分法实现了寻根功能。我不会在这里解释它的本质——代码被实现了，而且非常正确。但是，这里有问题。

该函数dichotomy()包含计算方程根的逻辑，我需要以人类可读的形式获取它们的输出。现在，当我输入 时print(root)，我会在一列中得到输出。我还需要一个字符串列表，并在小数点后包含所需的位数。

另外，这是实现的：

import numpy as np
import timeit

start_time = time.time()
res = list(dichotomy(0.0001,184,10000, 0.000001)) # написанная нами функция с заданными пользователем аргументами
print('Корни по методу дихотомии находятся в точках:')
print(', '.join(map(lambda x: f'{x:.4f}', res)))
print(f'Время счета по модулю timeit: ', timeit.timeit('dichotomy(0.0001,184,10000, 0.000001)', 'from __main__ import dichotomy'), 'seconds')

但是，不能将输出代码输入到函数体中。这是第一个困难。

第二：如果我在函数外部声明计数时间timeit.timeit()，那么该方法在内部 - 不再有效。一般来说，现在这段代码在最后几行中失败了：

import numpy as np
import timeit

def f(x):
    return 1.2-np.log(x)-4*np.cos(2*x)

def dichotomy (a,b,n, eps): # отрезок от a до b делим на n частей, погрешность eps
    """
    Функция отделения и уточнения корня
    """
    assert a!=0,  'a равно 0'
    assert b!=0, 'b равно 0'
    
    # сначала отделим корни
    grid=np.linspace(a, b, n)
    
    # далее уточним корни
    for x,y in zip(grid, grid[1:]):
        if f(x) * f(y) > 0: 
            continue
        root = None
        while ( abs(f(y)-f(x)) )>eps:    
            mid = (y+x)/2                   
            if f(mid) == 0 or f(mid)<eps:   
                root = mid                 
                break
            elif (f(mid) * f(x)) < 0:       
                y = mid                     
            else:
                x = mid                     
        if root:
            yield root
         #   print(root) # дает вывод столбиком - неудобно, потому пробуем ниже:
            res = list(root)   # ОШИБКА здесь!
            print(', '.join(map(lambda x: f'{x:.4f}', res)))

    print(f'Время счета по модулю timeit: ', timeit.timeit('dichotomy(0.0001,184,10000, 0.000001)', 'from __main__ import dichotomy'), 'seconds')

print(list(dichotomy(0.0001,184,10000, 0.000001))) # здесь юзер пытается подставить в функцию значения своих аргументов и получить распечатку корней

输出现在是一个错误，指示res = list(root)：

TypeError：“numpy.float64”对象不可迭代