Python内存问题

我开始用python编程，但我有一个内存问题（很抱歉我的英语不好）。 我在我的算法上做了一个while循环，但在每个循环中，程序都会消耗大量内存。我有3Gb的RAM、AMD64X2处理器和Windows7 64位

对于每一个cicle，它消耗大约800MB的RAM，我认为这太多了。 我的部分代码在这里

from sympy import Symbol, diff, flatten 
import numpy as np
from numpy import linalg
from math import log, sqrt, cos, pi
import matplotlib.pyplot as plt

L = 7  #numero de variables
X = [Symbol('x%d' % i) for i in range(L*(L+1))]  #Las variables simbolicas
XX = [X[i] for i in xrange(L)]

LAM = []    

# Parametros
Pr = 10
Eps = 0
Ome = 5
LL = 0.5
b = 2
Gam = 0.2*2*(pi**2)


ran1 = xrange(L)
ran2 = xrange(L*L) 
ran3 = xrange(0,L*(L-1)+1,L)
ran4 = xrange(L,2*L,1)

dt = 0.01
TMAX = 60

def f(x,R,Tau):
    return [Pr*((1 + Eps*cos(Ome*Tau))*x[2] - LL*x[0] - (1 -LL*x[5])) , \
        Pr*((1 + Eps*cos(Ome*Tau))*x[3] - LL*x[1] - (1 - LL)*x[6]),\
        R*x[0] - x[2] - x[0]*x[4],R*x[1] - x[3] - x[1]*x[4],(x[0]*x[2] + x[1]*x[3])/2 - b*x[4],\
        (1/Gam)*(x[0] - x[5]),(1/Gam)*(x[1] - x[6])]

def Jacobian(f,x):          #num son los numeros en el que se evalua la matriz jacobiana, x las variables y f la funcion
    return [[diff(f[i],x[n]) for i in ran1] for n in ran1]

def Y(x):
    return[[x[i+j] for j in ran3] for i in ran4]
    #Ahora la multiplicacion de Y traspuesto por Jacobian traspuesto
def JY(r,Tau):
    J = flatten((np.dot(np.array(Jacobian(f(XX,r,Tau),XX)),np.array(Y(X)))).T)
    return [J[i] for i in ran2]
def Func(x,r,Tau):            #Expandemos las funciones en un solo arreglo
    FFF = []
    map(lambda g: FFF.append(g),f(XX,r,Tau))
    map(lambda g: FFF.append(g),JY(r,Tau))
    return map(lambda f: f.evalf(subs={X[j]:x[j] for j in xrange(L*(L+1))}),FFF)

def RKutta(xi,r):
    i = 1
    while i <= int(TMAX/dt):
        Tau = 0
        YY = xi
        k1 = np.array(Func(YY,r,Tau))*dt
        k2 = (np.array(Func(YY + k1/2,r,Tau/2)))*dt
        k3 = (np.array(Func(YY + k2/2,r,Tau/2)))*dt
        k4 = (np.array(Func(YY + k3,r,Tau)))*dt
        xi = YY + (k1/6) + (k2/3) + (k3/3) + (k4/6)
        Tau = Tau + dt
        i = i + 1
    return [xi[j] for j in xrange(len(xi))]


def lyap(xxi):
    u = [i for i in flatten(np.random.rand(1,L))]
    PhiT = (np.array([[float(xxi[i+j]) for j in ran3] for i in ran4])).T
    PU = np.dot(PhiT,u)
    summ = 0
    jj = 0
    while jj < len(PU):
        summ += (float(PU[jj]))**2
        jj = jj + 1
    lam = log(sqrt(summ))/TMAX
    return lam

R = 46.5
Rmax = 48.5
Rstep = 0.5

while R <= Rmax:
    xi = [5,5,5,5,5,5,5]   #Condiciones Iniciales
    for i in ran2:
        xi.append(None)

    for i in ran4:                    
        for j in ran3:          
            if (i+j+1)%(L+1) == 0:
                xi[i+j] = 1
            else:
                xi[i+j] = 0

    #Ahora el Runge Kutta para integrar todo el sistema


        #Y.append([r for r in xx])
    # savetxt('butterfly.txt', Y, fmt="%12.6G")
    #print Y
    XI = RKutta(xi,R)
    lamb = lyap(XI)
    LAM.append([R,lamb])
    print [R,lamb]
    R = R + Rstep
#print LAM
#x = [LAM[i][0] for i in xrange(len(LAM))]
#y = [LAM[i][1] for i in xrange(len(LAM))]
np.savetxt('lyap3.txt', LAM, fmt="%12.6G")
#plt.axis([10,30,-3,3]);
#plt.scatter(x,y)
#plt.show()

来自sympy导入符号、差异、展平
将numpy作为np导入
来自numpy import linalg
从数学导入日志、sqrt、cos、pi
将matplotlib.pyplot作为plt导入
L=7#变量数
X=[Symbol（'X%d'%i）表示范围（L*（L+1））内的i]#Las variables simbolicas
XX=[X[i]表示X范围内的i（L）]
LAM=[]
#参数
Pr=10
每股收益=0
Ome=5
LL=0.5
b=2
Gam=0.2*2*（π**2）
ran1=xrange（L）
ran2=X量程（L*L）
ran3=xrange（0，L*（L-1）+1，L）
ran4=X范围（长，2*L，1）
dt=0.01
TMAX=60
def f（x，R，Tau）：
返回[Pr*（（1+Eps*cos（Ome*Tau））*x[2]-LL*x[0]-（1-LL*x[5]）\
Pr*（（1+Eps*cos（Ome*Tau））*x[3]-LL*x[1]-（1-LL）*x[6]）\
R*x[0]-x[2]-x[0]*x[4]，R*x[1]-x[3]-x[1]*x[4]，（x[0]*x[2]+x[1]*x[3]）/2-b*x[4]\
（1/Gam）*（x[0]-x[5]），（1/Gam）*（x[1]-x[6]）]
定义雅可比矩阵（f，x）：#计算矩阵雅可比矩阵的数值，x变量y函数
返回[ran1中i的[diff（f[i]，x[n]），ran1中n的[diff（f[i]，x[n]）]
定义Y（x）：
返回[[x[i+j]表示ran3中的j]表示ran4中的i]
#雅可比数列的多样性
def JY（右，头）：
J=展平（（np.dot（np.array）（雅可比矩阵f（XX，r，Tau，XX）），np.array（Y（X）））.T）
返回[J[i]表示ran2中的i]
def Func（x，r，Tau）：#在单独的arreglo中扩展功能
FFF=[]
图（lambda g:FFF.append（g），f（XX，r，Tau））
映射（lambda g:FFF.append（g），JY（r，Tau））
返回映射（lambda f:f.evalf（subs={X[j]：X[j]表示X范围（L*（L+1））}），FFF）
def RKutta（xi，r）：
i=1
而我我是什么？您的大部分代码都使用O（L^2）存储，因此如果L很大，则就是它。
L是什么？您的大部分代码都使用O（L^2）存储，因此如果L很大，那么就是它。
似乎您正在实例化非常大的列表。看看你是否不能用迭代器代替一些列表理解。
看起来你在实例化非常大的列表。看看你是否能用迭代器替换一些列表理解。
在没有上下文的情况下遵循代码有点棘手，因为你显然在多个地方使用了numpy（作为np和不带前缀），evalf可能来自sympy。。但我们看不到你们的进口货

在一个非常模糊的猜测中，您的一些列表理解构建了比预期时间更长的临时列表。你也许可以把它们转换成发电机。另一种技术是尽可能多地使用map（）或类似的方法

我还注意到一些不需要的非音速索引迭代。Func首先构建一个名为FFF的列表，一次只生成一个项目（相当昂贵），然后毫无理由地按索引对其进行迭代。使用
[f（item）表示seq中的item]
而不是
[f（seq[i]）表示xrange中的i（len（seq））
，或者更好的是，
映射（f，seq）
，在这种情况下，尝试根本不构建临时列表。
在没有上下文的情况下遵循代码有点困难，因为您显然在多个地方使用了numpy（作为np和不带前缀）和evalf可能来自sympy..但我们没有看到您的导入

在一个非常模糊的猜测中，您的一些列表理解构建了比预期时间更长的临时列表。您也许可以将这些列表转换为生成器。另一种技术是尽可能多地使用map（）或类似方法

我还注意到一些不需要的非音速索引迭代。Func首先构建一个名为FFF的列表，一次一个项目（相当昂贵），然后无真正原因地按索引对其进行迭代。对于seq中的项目使用
[f（item）
而不是xrange（len（seq））中的I使用
[f（seq[I]）
，或者更好的是，
映射（f，seq）
，在这种情况下，尽量不要构建临时列表。
您的代码在语法上不正确，因为缩进被弄乱了。while循环中应该包含什么？还有，L，R，LL的值是什么？每个嵌套只缩进1个空间？您是一个邪恶的人。L只是变量的数量，在t中他的例子，7。我有另一个3个变量，但它仍然消耗大量内存。你在那里做了一些非常繁重的数学。你考虑过使用numpy之类的数字库吗？所有内容都在第一个版本中，这就是我复制到这个论坛的方式，程序运行良好。你的代码在语法上不正确，因为Ttation是一团糟。while循环里面应该是什么？还有，L，R，LL的值是什么？你每个嵌套只缩进1个空间？你是个邪恶的人。L只是变量的数量，在这个例子中是7。我有一个包含3个变量的循环，但它仍然消耗了很多内存。你在那里做了一些非常繁重的数学。你有吗考虑过使用numpy之类的数字库吗？一切都在第一个库中，而我就是这样将它复制到这个论坛的，程序运行得很好。这是怎么回事？我用“whiles”替换了一些“for”循环，如果这是你的意思：O@David温彻斯特：不，看看python itertools中迭代器的示例实现。看看你的计算是否可以不要让自己“忙碌”而不是“积累大量列表并在以后处理”.在while循环之前，我试着做了很多函数，所以我没有计算大的列表，内存使用量少了很多，但问题是计算太慢了，所以我把所有的东西都放在了大循环中。M…有一些解决方案吗？：//保罗：你的意思是他应该用NumPy来定义列表，而不是用itertools吗？可以吗你解释怎么说？怎么说？我用“whiles”替换了一些“for”cicles，如果这是你的意思：O@David温彻斯特：不，看看python itertool