Python 如何转换类'；sympy.core'；至'；编号'；或'；浮动'；为了优化？

我是Python的发起人，我想解决以下问题，但我不知道原因是什么。我使用“fsolve”优化工具解决了这个问题

首先，我试图解一个非线性方程，但我在两种情况下接近它。有一个案例很成功。但我找不到另一个案子了

第一个案例（完整案例）

第二个案例（失败案例）

失败的消息如下所示

runfile('C:/Users/user/Desktop/******/untitled0.py', wdir='C:/Users/user/Desktop/******')
Traceback (most recent call last):

  File "C:\Users\user\AppData\Roaming\Python\Python37\site-packages\sympy\core\expr.py", line 327, in __float__
    raise TypeError("can't convert expression to float")

TypeError: can't convert expression to float

Traceback (most recent call last):

  File "C:\Users\user\Desktop\*******\untitled0.py", line 29, in <module>
    solutions = fsolve(function,x0)

  File "C:\Users\user\anaconda3\lib\site-packages\scipy\optimize\minpack.py", line 147, in fsolve
    res = _root_hybr(func, x0, args, jac=fprime, **options)

  File "C:\Users\user\anaconda3\lib\site-packages\scipy\optimize\minpack.py", line 225, in _root_hybr
    ml, mu, epsfcn, factor, diag)

error: Result from function call is not a proper array of floats.

runfile（'C:/Users/user/Desktop/*****/untitled0.py'，wdir='C:/Users/user/Desktop/*****'））
回溯（最近一次呼叫最后一次）：
文件“C:\Users\user\AppData\Roaming\Python37\site packages\sympy\core\expr.py”，第327行，在\uuuu float中__
raise TypeError（“无法将表达式转换为浮点”）
TypeError:无法将表达式转换为浮点
回溯（最近一次呼叫最后一次）：
文件“C:\Users\user\Desktop\******\untitled0.py”，第29行，在
解决方案=fsolve（函数，x0）
文件“C:\Users\user\anaconda3\lib\site packages\scipy\optimize\minpack.py”，第147行，在fsolve中
res=\u root\u hybr（func，x0，args，jac=fprime，**选项）
文件“C:\Users\user\anaconda3\lib\site packages\scipy\optimize\minpack.py”，第225行，在\u root\u hybr中
ml，mu，epsfcn，因子，diag）
错误：函数调用的结果不是正确的浮点数组。

只需将数学表达式eq1、eq2直接输入“返回”，但结果不同于手动输入表达式

我尝试了很多方法将“sympy函数”转换为“float数组”，但效果并不理想

我试过“lambdify”和“lambda”。。。这些措施也失败了

如何以浮点形式输入定义为“sympy”的函数，以便使用优化工具“fsolve”进行计算

实际上，上面的代码不是我的案例。因为这只是一种简化的情况。但在我的例子中，不可能手动输入所有上述函数，因为我要解一个非常复杂的非线性方程，它有数百个十阶或更高阶的项

---

有人能解决这个问题吗？

要在

fsolve

中工作，您的

函数必须使用类似
x0
的值运行

在第一种情况下：

In [1]: def function(v): 
   ...:         
   ...:     b_1 = v[0]      
   ...:     b_2 = v[1]     
   ...:      
   ...:     return (2*b_1 + 2*b_2/3,2*b_1/3 + 2*b_2/5) 
   ...:                                                                                              

In [3]: function([1,2])                                                                              
Out[3]: (3.333333333333333, 1.4666666666666668)

在第二种情况下：

In [4]: y= symbols('y') 
   ...: b_1, b_2 = symbols ('b_1,b_2') 
   ...:  
   ...: b = 1                      
   ...:    
   ...: f = b_1 + b_2*(y/b)**2 
   ...:  
   ...: K1 = integrate(f**2,(y,0,b)) 
   ...:  
   ...:  
   ...: eq1 = diff(K1,b_1) 
   ...: eq2 = diff(K1,b_2) 
   ...:                                                                                              

In [5]: eq1                                                                                          
Out[5]: 
       2⋅b₂
2⋅b₁ + ────
        3  

In [6]: eq2                                                                                          
Out[6]: 
2⋅b₁   2⋅b₂
──── + ────
 3      5  

In [7]: def function(v): 
   ...:         
   ...:     b_1 = v[0]      
   ...:     b_2 = v[1]     
   ...:      
   ...:     return (eq1,eq2) 
   ...:                                                                                              

In [8]: function([1,2])                                                                              
Out[8]: 
⎛       2⋅b₂  2⋅b₁   2⋅b₂⎞
⎜2⋅b₁ + ────, ──── + ────⎟
⎝        3     3      5  ⎠

这将返回一个sympy表达式的元组
fsolve
与第一种情况一样需要数字。请注意，
v
值不会更改返回的表达式。函数内的
b_1
与
b不同₁在
eq
中

我们可以使用
lambdify
将sympy转换为numpy函数：

In [15]: f1 = lambdify([b_1, b_2], eq1)                                                              

In [17]: f1(1,2)                                                                                     
Out[17]: 3.333333333333333

In [18]: f2 = lambdify([b_1, b_2], eq2)                                                              

In [19]: def function(v): 
    ...:         
    ...:     b_1 = v[0]      
    ...:     b_2 = v[1]     
    ...:      
    ...:     return (f1(b_1,b_2), f2(b_1, b_2))                                                                                              

In [20]: function([1,2])                                                                             
Out[20]: (3.333333333333333, 1.4666666666666668)

这现在应该可以在
fsolve
中使用

注意
lambdify
产生了什么：

In [22]: print(f1.__doc__)                                                                           
Created with lambdify. Signature:
func(b_1, b_2)

Expression:

2*b_1 + 2*b_2/3

Source code:

def _lambdifygenerated(b_1, b_2):
    return (2*b_1 + (2/3)*b_2)

您的错误是在尝试执行以下操作时产生的：

In [23]: np.array(Out[8], dtype=float)                                                               
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-23-5f2b1be0015f> in <module>
----> 1 np.array(Out[8], dtype=float)

/usr/local/lib/python3.6/dist-packages/sympy/core/expr.py in __float__(self)
    325         if result.is_number and result.as_real_imag()[1]:
    326             raise TypeError("can't convert complex to float")
--> 327         raise TypeError("can't convert expression to float")
    328 
    329     def __complex__(self):

TypeError: can't convert expression to float

In[23]：np.array（Out[8]，dtype=float）
---------------------------------------------------------------------------
TypeError回溯（最近一次调用上次）
在里面
---->1 np.数组（Out[8]，dtype=float）
/usr/local/lib/python3.6/dist-packages/sympy/core/expr.py in\uuuuu float\uuuuu（self）
325如果result.is_number和result.as_real_imag（）[1]：
326 raise TypeError（“无法将复数转换为浮点”）
-->327 raise TypeError（“无法将表达式转换为浮点”）
328
329 def_________________（自）：
TypeError:无法将表达式转换为浮点

（看起来你没有给出完整的回溯。在任何情况下，
fsolve
都需要一个函数，在给定数组输入（形状类似于
x0
）时返回浮点数组（或等效数组）

lambdify
是将Symphy表达式转换为兼容函数的最佳方法，如果不是唯一方法的话。
a
Symphy
表达式不能在
numpy
或
scipy
中可靠使用，则解算器需要一个numpy/python函数，而不是一个使用Symphy符号的函数。如果您不能et
lambdify
要工作，请坚持使用Symphy解算器。非常感谢。我已经很久没有解决它了，但它终于解决了。你是最好的。你也可以使用
function=lambdify（[（b_1，b_2）]，[eq1，eq2]）
来创建一个获取列表并返回列表的函数。
In [22]: print(f1.__doc__)                                                                           
Created with lambdify. Signature:
func(b_1, b_2)

Expression:

2*b_1 + 2*b_2/3

Source code:

def _lambdifygenerated(b_1, b_2):
    return (2*b_1 + (2/3)*b_2)

In [23]: np.array(Out[8], dtype=float)                                                               
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-23-5f2b1be0015f> in <module>
----> 1 np.array(Out[8], dtype=float)

/usr/local/lib/python3.6/dist-packages/sympy/core/expr.py in __float__(self)
    325         if result.is_number and result.as_real_imag()[1]:
    326             raise TypeError("can't convert complex to float")
--> 327         raise TypeError("can't convert expression to float")
    328 
    329     def __complex__(self):

TypeError: can't convert expression to float