Python 在numpy sagemath中内存已满

我编写了下一个代码。在1-2小时的执行时间内，我的笔记本电脑（8gb）的RAM被填满，系统崩溃：

from scipy.stats import uniform    
import numpy as np

cant_de_cadenas =[700,800,900]

cantidad_de_cadenas=np.array([])

for kkkkk in cant_de_cadenas:
    cantidad_de_cadenas=np.append(cantidad_de_cadenas,kkkkk)    

cantidad_de_cadenas=np.transpose(cantidad_de_cadenas)

b=10
h=b
Longitud=1
numero_experimentos=100

densidad_de_cadenas =cantidad_de_cadenas/(b**2)

prob_perc=np.array([])

tiempos=np.array([])

S_int=np.array([])

S_medio=np.array([])

desviacion_standard=np.array([])

desviacion_standard_nuevo=np.array([])

anisotropia_macroscopica_porcentual=np.array([])

componente_y=np.array([])

componente_x=np.array([])

import time

for N in cant_de_cadenas:

    empieza=time.clock()

    PERCOLACION=np.array([])

    size_medio_intuitivo = np.array([])
    size_medio_nuevo = np.array([]) 
    std_dev_size_medio_intuitivo = np.array([])     
    std_dev_size_medio_nuevo = np.array([]) 
    comp_y = np.array([])   
    comp_x = np.array([])


    for u in xrange(numero_experimentos):


        perco = False

        array_x1=uniform.rvs(loc=-b/2, scale=b, size=N)  
        array_y1=uniform.rvs(loc=-h/2, scale=h, size=N)  
        array_angle=uniform.rvs(loc=-0.5*(np.pi), scale=np.pi, size=N)  


        array_pendiente_x=1./np.tan(array_angle)

        random=uniform.rvs(loc=-1, scale=2, size=N)
        lambda_sign=np.zeros([N])
        for t in xrange(N):
            if random[t]<0:
                lambda_sign[t]=-1
            else:
                lambda_sign[t]=1
        array_lambdas=(lambda_sign*Longitud)/np.sqrt(1+array_pendiente_x**2) 


        array_x2= array_x1 + array_lambdas*array_pendiente_x
        array_y2= array_y1 + array_lambdas*1

        array_x1 = np.append(array_x1, [-b/2, b/2, -b/2, -b/2])
        array_y1 = np.append(array_y1, [-h/2, -h/2, -h/2, h/2])
        array_x2 = np.append(array_x2, [-b/2, b/2, b/2, b/2])
        array_y2 = np.append(array_y2, [h/2, h/2, -h/2, h/2])

        M = np.zeros([N+4,N+4])  

        for j in xrange(N+4):
            if j>0:
                x_A1B1 = array_x2[j]-array_x1[j]
                y_A1B1 = array_y2[j]-array_y1[j]
                x_A1A2 = array_x1[0:j]-array_x1[j]
                y_A1A2 = array_y1[0:j]-array_y1[j]      
                x_A2A1 = -1*x_A1A2
                y_A2A1 = -1*y_A1A2
                x_A2B2 = array_x2[0:j]-array_x1[0:j]
                y_A2B2 = array_y2[0:j]-array_y1[0:j]
                x_A1B2 = array_x2[0:j]-array_x1[j]
                y_A1B2 = array_y2[0:j]-array_y1[j]
                x_A2B1 = array_x2[j]-array_x1[0:j]
                y_A2B1 = array_y2[j]-array_y1[0:j]

                p1 = x_A1B1*y_A1A2 - y_A1B1*x_A1A2
                p2 = x_A1B1*y_A1B2 - y_A1B1*x_A1B2
                p3 = x_A2B2*y_A2B1 - y_A2B2*x_A2B1
                p4 = x_A2B2*y_A2A1 - y_A2B2*x_A2A1

                condicion_1=p1*p2
                condicion_2=p3*p4                         

                for k in xrange (j):
                    if condicion_1[k]<=0 and condicion_2[k]<=0:
                        M[j,k]=1
                del condicion_1
                del condicion_2


            if j+1<N+4:
                x_A1B1 = array_x2[j]-array_x1[j]
                y_A1B1 = array_y2[j]-array_y1[j]
                x_A1A2 = array_x1[j+1:]-array_x1[j]
                y_A1A2 = array_y1[j+1:]-array_y1[j]     
                x_A2A1 = -1*x_A1A2
                y_A2A1 = -1*y_A1A2
                x_A2B2 = array_x2[j+1:]-array_x1[j+1:]
                y_A2B2 = array_y2[j+1:]-array_y1[j+1:]
                x_A1B2 = array_x2[j+1:]-array_x1[j]
                y_A1B2 = array_y2[j+1:]-array_y1[j]
                x_A2B1 = array_x2[j]-array_x1[j+1:]
                y_A2B1 = array_y2[j]-array_y1[j+1:]

                p1 = x_A1B1*y_A1A2 - y_A1B1*x_A1A2
                p2 = x_A1B1*y_A1B2 - y_A1B1*x_A1B2
                p3 = x_A2B2*y_A2B1 - y_A2B2*x_A2B1
                p4 = x_A2B2*y_A2A1 - y_A2B2*x_A2A1

                condicion_1=p1*p2
                condicion_2=p3*p4                         

                for k in xrange ((N+4)-j-1):
                    if condicion_1[k]<=0 and condicion_2[k]<=0:
                        M[j,k+j+1]=1   
                del condicion_1
                del condicion_2

        M[N,N+2]=0
        M[N,N+3]=0
        M[N+1,N+2]=0
        M[N+1,N+3]=0
        M[N+2,N]=0
        M[N+2,N+1]=0
        M[N+3,N]=0
        M[N+3,N+1]=0


        CD=np.array([])

        POPOPO=[] 
        for g in xrange(N):

            lala=0
            r=False
            while lala<=len(POPOPO)-1:       
                esta= g in POPOPO[lala]  

                if esta is True:
                    lala=len(POPOPO) 
                    r=True
                else:
                    lala=lala+1
            if r is False:       



                L=np.array([g])        
                for s in xrange(N):
                    if M[g,s] != 0:
                        L=np.append(L,s)

                x=0
                while x<= N:        
                    for l in xrange(N):
                        z= l in L              
                        d=L[x]
                        if z is False and M[d,l] != 0:   
                            L=np.append(L,l)
                    if x+1<len(L):
                        x+=1
                    else:
                        x=N+1.

                q= len (L)
                CD=np.append(CD, q)
                POPOPO.append(L)


        M_horizontal=M.copy()   
        M_horizontal[:,N+2] = np.zeros(N+4)    
        M_horizontal[:,N+3] = np.zeros(N+4)    
        M_horizontal[N+2] = np.zeros(N+4)    
        M_horizontal[N+3] = np.zeros(N+4)    



        L=np.array([N])        
        for s in xrange(N+4):
            if M_horizontal[N,s] != 0:
                L=np.append(L,s)

        x=0
        while x<= N+4:      
            for l in xrange(N+4):
                z= l in L               
                d=L[x]
                if z is False and M_horizontal[d,l] != 0:   
                    L=np.append(L,l)
            if x+1<len(L):
                x+=1
            else:
                x=(N+4)+1.      

        LV1_in_L = N in L 
        LV2_in_L= (N+1) in L

        if LV1_in_L is True and LV2_in_L is True:
            perc_horiz=True
        else:
            perc_horiz=False


        M_vertical=M.copy()    

        M_vertical[:,N] = np.zeros(N+4)    
        M_vertical[:,N+1] = np.zeros(N+4)    
        M_vertical[N] = np.zeros(N+4)    
        M_vertical[N+1] = np.zeros(N+4)    



        L=np.array([N+2])        
        for s in xrange(N+4):
            if M_vertical[N+2,s] != 0:
                L=np.append(L,s)

        x=0
        while x<= N+4:      
            for l in xrange(N+4):
                z= l in L               
                d=L[x]
                if z is False and M_vertical[d,l] != 0:   
                    L=np.append(L,l)
            if x+1<len(L):
                x+=1
            else:
                x=(N+4)+1.      

        LH1_in_L = (N+2) in L  
        LH2_in_L= (N+3) in L

        if LH1_in_L is True and LH2_in_L is True:
            perc_ver = True
        else:
            perc_ver = False



        if perc_ver is True or perc_horiz is True:
            PERCOLACION=np.append(PERCOLACION,1)
            perco=True


        D = np.array([]) 
        W = np.array([])   

        for c in xrange (int(min(CD)), int(max(CD)+1),1):   
            D=np.append(D,c)
            frec = sum (CD == c)   
            W = np.append(W,frec)

        if perco is True:
            posicion=np.argmax(D)
            D=np.delete(D,posicion)
            W=np.delete(W,posicion)

        if len(D) == 0 and len(W)==0:
            S_medio_intuitivo_exp_u=0
            S_medio_nuevo_exp_u = 0
            std_dev_exp_u = 0
            std_dev_nuevo_exp_u = 0
        else:

            S_medio_intuitivo_exp_u = np.average (D,weights=W)   

            peso_nuevo=D*W

            S_medio_nuevo_exp_u = np.average (D,weights=peso_nuevo)


            tipos=sum(W)   
            X=W*((D-S_medio_intuitivo_exp_u)**2)
            S=sum(X)

            std_dev_exp_u = np.sqrt(S/(tipos-1.)) 

            tipos_nuevo=sum(peso_nuevo)    
            X_nuevo=peso_nuevo*((D-S_medio_nuevo_exp_u)**2)
            S_nuevo=sum(X_nuevo)

            std_dev_nuevo_exp_u = np.sqrt(S_nuevo/(tipos_nuevo-1.))  


        componente_longitudinal=Longitud*np.abs(np.cos(array_angle))
        comp_y=np.append(comp_y, sum(componente_longitudinal)/N)

        componente_transversal=Longitud*np.abs(np.sin(array_angle))
        comp_x=np.append(comp_x, sum(componente_transversal)/N) 

        std_dev_size_medio_intuitivo=np.append(std_dev_size_medio_intuitivo, std_dev_exp_u)

        std_dev_size_medio_nuevo=np.append(std_dev_size_medio_nuevo, std_dev_nuevo_exp_u)

        size_medio_intuitivo=np.append(size_medio_intuitivo, S_medio_intuitivo_exp_u)

        size_medio_nuevo=np.append(size_medio_nuevo, S_medio_nuevo_exp_u)


    percolation_probability=sum(PERCOLACION)/numero_experimentos

    prob_perc=np.append(prob_perc, percolation_probability)

    S_int = np.append (S_int, sum(size_medio_intuitivo)/numero_experimentos)

    S_medio=np.append (S_medio, sum(size_medio_nuevo)/numero_experimentos)

    desviacion_standard = np.append (desviacion_standard, sum(std_dev_size_medio_intuitivo)/numero_experimentos)

    desviacion_standard_nuevo=np.append (desviacion_standard_nuevo, sum(std_dev_size_medio_nuevo)/numero_experimentos)

    tiempos=np.append(tiempos, time.clock()-empieza)

    componente_y=np.append(componente_y, sum(comp_y)/numero_experimentos)
    componente_x=np.append(componente_x, sum(comp_x)/numero_experimentos)

    anisotropia_macroscopica_porcentual=100*(1-(componente_y/componente_x))

从scipy.stats导入制服
将numpy作为np导入
卡德纳斯斜道=[700800900]
cantidad_de_cadenas=np.array（[]）
对于卡德纳斯的KKK：
cantidad_de_cadenas=np.append（cantidad_de_cadenas，kkkk）
cantidad_de_cadenas=np.转置（cantidad_de_cadenas）
b=10
h=b
Longitud=1
实验次数=100
densidad_de_cadenas=cantidad_de_cadenas/（b**2）
prob_perc=np.array（[]）
tiempos=np.array（[]）
S_int=np.array（[]）
S_medio=np.array（[]）
desviacion_standard=np.array（[]）
desviacion\u standard\u nuevo=np.array（[]）
宏观各向异性=np.数组（[]）
component_y=np.array（[]）
component_x=np.array（[]）
导入时间
对于卡德纳斯斜道中的N：
empieza=time.clock（）
PERCOLACION=np.array（[]）
size\u medio\u invo=np.array（[]）
size\u medio\u nuevo=np.数组（[]）
std\U dev\U size\U medio\U直观VO=np.array（[]）
std_dev_size_medio_nuevo=np.数组（[]）
comp_y=np.数组（[]）
comp_x=np.数组（[]）
对于X范围内的u（数值）：
perco=False
数组_x1=uniform.rvs（loc=-b/2，scale=b，size=N）
阵列_y1=均匀。rvs（loc=-h/2，比例=h，尺寸=N）
阵列角度=均匀.rvs（loc=-0.5*（np.pi），比例=np.pi，大小=N）
数组_pendiente_x=1./np.tan（数组_角度）
随机=均匀。rvs（loc=-1，比例=2，尺寸=N）
lambda_符号=np.零（[N]）
对于X范围内的t（N）：
如果随机[t]0：
x_A1B1=阵列_x2[j]-阵列_x1[j]
y_A1B1=阵列_y2[j]-阵列_y1[j]
x_A1A2=阵列_x1[0:j]-阵列_x1[j]
y_A1A2=阵列_y1[0:j]-阵列_y1[j]
x_A2A1=-1*x_A1A2
y_A2A1=-1*y_A1A2
x_A2B2=阵列_x2[0:j]-阵列_x1[0:j]
y_A2B2=阵列_y2[0:j]-阵列_y1[0:j]
x_A1B2=阵列_x2[0:j]-阵列_x1[j]
y_A1B2=阵列_y2[0:j]-阵列_y1[j]
x_A2B1=数组_x2[j]-数组_x1[0:j]
y_A2B1=阵列_y2[j]-阵列_y1[0:j]
p1=x_A1B1*y_A1A2-y_A1B1*x_A1A2
p2=x_A1B1*y_A1B2-y_A1B1*x_A1B2
p3=x_A2B2*y_A2B1-y_A2B2*x_A2B1
p4=x_A2B2*y_A2A1-y_A2B2*x_A2A1
条件1=p1*p2
条件2=p3*p4
对于x范围内的k（j）：
如果条件1[k]你能发布更多的代码吗？如果看不到你的实际算法，就不可能知道问题出在哪里。sage使用sympy，sympy似乎对做事情有好处，但不适合做需要快速/数值/优化的事情。。。如果可以，请在不涉及sympy的情况下使用numpy和python。另一个想法是分析您的代码，以查看在RAM消耗方面有问题的代码行在哪里。第三种选择是发布更多的代码，告诉我们问题可能出在哪里。我还想补充一点，这对于解决此类问题非常有用。我用扩展版本的代码编辑了我的文章。请帮忙！当您剥离代码来发布它时，将它剥离为实际运行的代码，并在运行时实际演示问题。我们不知道问题是否出在你撕下来的东西上。