Supérieure de la limite de mémoire?

(C'est ma troisième réponse parce que j'ai mal compris ce que votre code a été fait dans mon original, et puis en fait, mais une petite erreur cruciale dans ma deuxième espérons que trois est un charme.

Modifications: Depuis ce qui semble être une réponse, j'ai fait quelques modifications pour améliorer sa mise en œuvre au fil des ans, la plupart des pas trop grands. C'est donc, si des gens l'utiliser en tant que modèle, il fournira une base encore meilleure.

Comme d'autres l'ont souligné, votre MemoryError problème est probablement parce que vous tentez de lire le contenu entier de gros fichiers dans la mémoire et, en plus, ce qui permet de doubler la quantité de mémoire nécessaire à la création d'une liste de listes de la chaîne de valeurs de chaque ligne.

Python mémoire limites sont déterminées par la quantité de ram physique et mémoire virtuelle de l'espace disque de votre ordinateur et système d'exploitation sont disponibles. Même si vous ne l'utilisez pas tout votre programme de "travaux", en utilisant, il peut être difficile car il prend trop de temps.

De toute façon, le moyen le plus évident d'éviter cette situation est de traiter chaque fichier une seule ligne à la fois, ce qui signifie que vous avez à faire le traitement de manière incrémentale.

Pour ce faire, une liste de fonctionnement totaux pour chacun des champs est conservé. Lorsque cela est terminé, la valeur moyenne de chaque champ peut être calculé en divisant le correspondant de la valeur totale par le nombre total de lignes à lire. Une fois que c'est fait, ces moyennes peuvent être imprimées et certains écrits de l'un des fichiers de sortie. J'ai aussi fait un effort conscient pour une utilisation très descriptif, les noms de variables pour essayer de le rendre compréhensible.

try:
    from itertools import izip_longest
except ImportError:    # Python 3
    from itertools import zip_longest as izip_longest

GROUP_SIZE = 4
input_file_names = ["A1_B1_100000.txt", "A2_B2_100000.txt", "A1_B2_100000.txt",
                    "A2_B1_100000.txt"]
file_write = open("average_generations.txt", 'w')
mutation_average = open("mutation_average", 'w')  # left in, but nothing written

for file_name in input_file_names:
    with open(file_name, 'r') as input_file:
        print('processing file: {}'.format(file_name))

        totals = []
        for count, fields in enumerate((line.split('\t') for line in input_file), 1):
            totals = [sum(values) for values in
                        izip_longest(totals, map(float, fields), fillvalue=0)]
        averages = [total/count for total in totals]

        for print_counter, average in enumerate(averages):
            print('  {:9.4f}'.format(average))
            if print_counter % GROUP_SIZE == 0:
                file_write.write(str(average)+'\n')

file_write.write('\n')
file_write.close()
mutation_average.close()

Python, il est possible d'utiliser toute la mémoire disponible à son environnement. Mon simple "test de la mémoire" se bloque sur ActiveState Python 2.6 après l'utilisation sur

1959167 [MiB]

Sur python 2.5, il se bloque de plus en plus tôt:

 239000 [MiB]

sans doute, je peux configurer Jython à utiliser plus de mémoire (il utilise les limites de la JVM)

Application de Test:

import sys

sl = []
i = 0
# some magic 1024 - overhead of string object
fill_size = 1024
if sys.version.startswith('2.7'):
    fill_size = 1003
if sys.version.startswith('3'):
    fill_size = 497
print(fill_size)
MiB = 0
while True:
    s = str(i).zfill(fill_size)
    sl.append(s)
    if i == 0:
        try:
            sys.stderr.write('size of one string %d\n' % (sys.getsizeof(s)))
        except AttributeError:
            pass
    i += 1
    if i % 1024 == 0:
        MiB += 1
        if MiB % 25 == 0:
            sys.stderr.write('%d [MiB]\n' % (MiB))

Dans votre application vous lire tout le fichier à la fois. Pour ces gros fichiers, vous devriez lire le ligne par ligne.

Non seulement vous êtes la lecture de l'ensemble de chaque fichier dans la mémoire, mais aussi vous laborieusement répliquer les informations dans une table appelée list_of_lines.

Vous avez un problème secondaire: votre choix de noms de variables gravement dissimuler ce que vous faites.

Voici votre script réécrit avec le readlines() caper retiré et avec des noms significatifs:

file_A1_B1 = open("A1_B1_100000.txt", "r")
file_A2_B2 = open("A2_B2_100000.txt", "r")
file_A1_B2 = open("A1_B2_100000.txt", "r")
file_A2_B1 = open("A2_B1_100000.txt", "r")
file_write = open ("average_generations.txt", "w")
mutation_average = open("mutation_average", "w") # not used
files = [file_A2_B2,file_A2_B2,file_A1_B2,file_A2_B1]
for afile in files:
    table = []
    for aline in afile:
        values = aline.split('\t')
        values.remove('\n') # why?
        table.append(values)
    row_count = len(table)
    row0length = len(table[0])
    print_counter = 4
    for column_index in range(row0length):
        column_total = 0
        for row_index in range(row_count):
            number = float(table[row_index][column_index])
            column_total = column_total + number
        column_average = column_total/row_count
        print column_average
        if print_counter == 4:
            file_write.write(str(column_average)+'\n')
            print_counter = 0
        print_counter +=1
file_write.write('\n')

Il devient rapidement évident que (1) vous êtes à la colonne de calcul des moyennes (2) l'obscurcissement conduit certains autres pensent que vous étiez le calcul de la ligne moyenne.

Que vous êtes à la colonne de calcul des moyennes, aucune sortie n'est requis jusqu'à la fin de chaque fichier, et la quantité de mémoire nécessaire est proportionnelle au nombre de colonnes.

Ici est une version révisée de la boucle externe code:

for afile in files:
    for row_count, aline in enumerate(afile, start=1):
        values = aline.split('\t')
        values.remove('\n') # why?
        fvalues = map(float, values)
        if row_count == 1:
            row0length = len(fvalues)
            column_index_range = range(row0length)
            column_totals = fvalues
        else:
            assert len(fvalues) == row0length
            for column_index in column_index_range:
                column_totals[column_index] += fvalues[column_index]
    print_counter = 4
    for column_index in column_index_range:
        column_average = column_totals[column_index] / row_count
        print column_average
        if print_counter == 4:
            file_write.write(str(column_average)+'\n')
            print_counter = 0
        print_counter +=1