[Python] media di diversi valori riportati in columns file

[drudox]

Salve !
ho una domanda (magari banale) ovvero necessito di effettuare la media di diverse quantita' ciascuna riscuna riportate in colonne all interno di diversi file .. quale e` il metodo piu` consigliato e veloce per eseguirla ?

[nuzzopippo]

ho una domanda (magari banale) ovvero necessito di effettuare la media di diverse quantita' ciascuna riscuna riportate in colonne all interno di diversi file .. quale e` il metodo piu` consigliato e veloce per eseguirla ?

Ciao @drudox, dovresti essere più "dettagliato" nella domanda, non metteresti in condizione chi Ti risponde a doversi inventare uno scenario che quasi certamente sarebbe inadeguato, le cose possono variare moltissimo per "sfumature", p.e. in presenza di grosse quantità di dati esistono librerie apposite per gestirli, tipo pandas, complessa e che personalmente non conosco perché fuori dalla mia sfera di interessi.

A livello generico, dipende nuovamente da cosa stai trattando, supponiamo sia da trattarsi un file tipo csv così articolato

Codice: Seleziona tutto

NzP:~$ cd /media/ngiuseppe/1FA6-C648/src/posts/drudox
NzP:~$ cat esempio.csv
A;B;C;D;E;F;G
1;2;3;4;5;6;7
8;9;10;11;12;13;14
15;16;17;18;19;20;21
NzP:~$

Volendolo trattare direttamente, senza librerie specializzate, naturalmente dovremo leggerlo

Codice: Seleziona tutto

>>> f_name = 'esempio.csv'
>>> with open(f_name) as f:
	data = [x.split(';') for x in f.read().splitlines()]

	
>>> for r in data:
	print(r)

	
['A', 'B', 'C', 'D', 'E', 'F', 'G']
['1', '2', '3', '4', '5', '6', '7']
['8', '9', '10', '11', '12', '13', '14']
['15', '16', '17', '18', '19', '20', '21']

come puoi vedere dall'output, con il blocco di istruzioni "with open ..." ho letto il file e da esso creato una lista di liste contenente le singole righe-dati del file.
Supponiamo di volere la media dei dati della colonna "C", osserviamo che essa ha indice "2" e che i dati sono rappresentati sotto forma di stringhe, noi "vogliamo" i valori numerici e NON vogliamo la riga di intestazione, potremmo selezionare i dati interessanti così:

Codice: Seleziona tutto

>>> c_data = [int(x[2]) for x in data[1:]]
>>> for r in c_data:
	print(r)

	
3
10
17

per poi sommarli e calcolarci la media

Codice: Seleziona tutto

>>> sum(c_data) / len(c_data)
10.0
>>> 

Questo a livello di singoli "passi" da effettuarsi per ogni singolo file ... ovviamente, se esistono delle condizioni "comuni" tra i file, può benissimo implementarsi una funzione specifica che provveda a leggersi i files e calcolarsi le medie delle colonne interessanti, passate quali parametri ma, mi ripeto, dipende dalle condizioni da affrontare.

[drudox]

mi sono spiegato male .... scusami !!

dunque considera una serie di file in cui le colonne sono cosi fatte :

Codice: Seleziona tutto

A  3  6  7
B  5  2  10 

il file sucessivo invece ha :

Codice: Seleziona tutto

A  5 8 9
B  7 4 20  

ecco tra questi file io voglio ottere la media dei valori di A, B, C
quindi nell esempio sarebbe (essendo 2 file):
A ((3+5)/2 = 4) , ((6+8)/2 = 7), ((7+9)/2=
b ((5+7)/2 = 6) , ((2+4)/2 = 3 ), ((10+20)/2 = 15)

quindi un output :

Codice: Seleziona tutto

A  4 7 8
B 6 3 15

l'esempio e` banale ... ma spero renda il concetto .. esiste in python una funzione che fa questo... considerando 50 file con 100 righe ciascuno ? ... il pseudocodice che direi sarebbe:
" somma ciascun valore relativo alla ennesima colonna di ogni riga per tutti i files, calcola la media dividendo la somma per il numero dei file"

[drudox]

risolto manualmente in "Fortran (o anche C++ :P) style" ho scritto questo :

Codice: Seleziona tutto

#!/usr/bin/env python3 
# -*- coding : utf-8 -*- :w


import sys
import numpy as np
import matplotlib.pyplot as plt
import argparse
from subprocess import call
from os.path import exists
from os import listdir
from os.path import isfile, join
import glob

#onlyfiles = [f for f in listdir(mypath) ] #if isfile(join(mypath, f))]
from qualityPlot.qualityplot import *

data = glob.glob("*.dat")

#print(data)

#print(data[1])

bins = np.genfromtxt(data[0], usecols=(0,))
one = [] 
two = [] 
three = [] 

for i in range(len(data)):
    one.append(np.genfromtxt(data[i], usecols=(1,)))
    two.append(np.genfromtxt(data[i], usecols=(2,)))
    three.append(np.genfromtxt(data[i], usecols=(3,)))
    #j +=1 
sum1, sum2,sum3 = [],[],[]
sum1,sum2,sum3 = 0., 0. ,0.

for i in range(len(one)): 
   sum1 = sum1 + one[i] 
   sum2 = sum2 + two[i]
   sum3 = sum3 + three[i]

sum1 = sum1/len(one) 
sum2 = sum2/len(two) 
sum3 = sum3/len(three) 

fig,axs = ThesisBlack(**{'lines.linewidth': 1} )(1,1,(9.0,8.0))
plt.rcParams.update({'font.size': 18})
axs.plot(bins,sum1,color='k',label='$\cos(\lambda_1, W)$',linewidth=3, linestyle='--')
axs.plot(bins,sum2,color='C1',label='$\cos(\lambda_2, W)$',linewidth=3,linestyle='-')
axs.plot(bins,sum3,color='C2',label='$\cos(\lambda_2, W)$',linewidth=4,linestyle=':')
axs.legend(loc='best')
axs.tick_params(axis='both',labelsize=22) 
axs.set_title(' (Re=90)', color='k' )
axs.set(xlabel='cos($\Theta$)')
axs.set(ylabel='PDFs')
#plt.ylim([-3,8])
plt.tight_layout()
plt.savefig( 'streigen_mean_90.pdf',bbox_inches='tight' )

molto brutto ... ma condivido ogni (seppur la trovo spesso brutta) soluzione usata...

ah P.S. qualityPlot e` una libreria che feci ai tempi della tesi di dottorato ... usare matplotlibrc non mi permetteva alcune cose ... ovviamente see site interessati produce diverse still ... quello ottenuto in questo caso e` questo ...

[nuzzopippo]

beh ... direi che non sei stato un esempio di chiarezza, non l'avevo mica immaginato che Tu volessi un grafico quando parlavi di medie di valori da vari files

Avevo preparato una funzione in grado di leggersi tutti i files di una directory ed esplicitarne le rispettive medie, ma non centra nulla con il Tuo risultato, Ok, mi ci son divertito.

Ciao

[drudox]

beh se la condividi puo` essere un insegnamento ... dato che in python son una schiappa .... non che in altro sia poi meglio eh www.github.com/drudox
PS mi chiamo Marco e` un piacere far la tua conoscenza

[nuzzopippo]

beh se la condividi puo` essere un insegnamento ... dato che in python son una schiappa .... non che in altro sia poi meglio eh www.github.com/drudox
PS mi chiamo Marco e` un piacere far la tua conoscenza

Piacere Marco, sono Giuseppe

Beh, non è che io sia un gran che, ho ben poco da insegnare, credo che, per come l'avevo capito, pandas debba avere strumenti utili, comunque :

Non avendo 50 files con centinaia colonne dati ho ridotto di un fattore 10, preparando questi files

Codice: Seleziona tutto

NzP:~$ cd /media/nuzzopippo/1FA6-C648/src/posts/drudox
NzP:~$ ls
data_01  data_02  data_03  data_04  data_05
NzP:~$ cat data_01
A 92 85 91 93 9 98 56 66 12 16
B 60 31 62 67 83 53 29 33 73 80
C 58 82 60 75 4 25 82 67 63 31
D 65 37 35 30 40 27 8 56 38 48
E 53 31 50 80 72 57 11 9 39 88
NzP:~$ cat data_02
A 41 15 97 17 88 85 65 88 84 63
B 31 50 71 39 18 70 83 37 78 8
C 68 90 42 10 43 6 74 45 36 88
D 98 53 45 79 71 11 49 93 5 32
E 61 21 9 73 3 17 6 18 87 77
F 83 60 63 76 94 43 32 95 70 45
NzP:~$ cat data_03
A 35 80 43 41 69 45 26 36 17 64 39 24
B 67 64 98 52 38 38 94 63 6 10 56 46
C 34 48 65 89 71 49 76 90 99 37 92 63
D 55 94 34 2 18 85 97 34 78 10 54 31
E 27 34 64 74 13 98 3 34 72 1 49 12
NzP:~$ cat data_04
A 85 81 91 64 92 30 91 97 1 95
B 81 86 19 49 31 80 78 99 60 48
C 46 82 91 82 75 47 49 7 58 40
D 83 66 80 59 32 56 22 67 40 30
E 97 5 42 81 77 7 56 31 41 62
F 6 28 41 42 27 60 51 79 8 94
G 28 54 60 82 48 14 98 42 31 71
NzP:~$ cat data_05
A 55 51 47 23 18 93 40 72 86 83 70
B 89 64 55 15 3 22 34 79 6 15 62
C 13 77 95 32 33 22 39 55 54 41 73
D 51 45 91 37 70 21 19 63 70 49 27
E 30 9 62 12 88 39 6 11 16 90 52
F 70 77 34 75 46 61 75 58 63 41 49
G 84 31 65 38 21 4 75 84 31 28 25
H 55 34 54 32 46 41 14 20 82 75 4
NzP:~$ 

poi, dando per scontato non vi siano errori e che i files siano "preparati", ho fatto "al volo" una funzione che ricevendo il path di una directory apre tutti i files della directory, li legge, scarta i valori non numerici e restituisce una lista di stringhe costituite dal nome-file + "means" e dai valori medi arrotondati al secondo decimale

Codice: Seleziona tutto

>>> import random
>>> def means_to_files(path):
	f_names = os.listdir(path)
	means = []
	for f_name in f_names:
		rows = []
		with open(os.path.join(path, f_name)) as f:
			data = [x.split() for x in f.read().splitlines()]
		for r in data:
			rows.append([int(x) for x in r if x.isnumeric()])
		tmp_means = []
		tmp_means.append(f_name + '_means')
		for i in range(len(rows[0])):
			val_col = [x[i] for x in rows]
			tmp_means.append('%.2f' % (sum(val_col) / len(val_col)))
		means.append(' '.join(tmp_means))
	return means

>>> means = means_to_files('/media/nuzzopippo/1FA6-C648/src/posts/drudox')
>>> for m in means:
	print(m)

	
data_01_means 65.60 53.20 59.60 69.00 41.60 52.00 37.20 46.20 45.00 52.60
data_02_means 63.67 48.17 54.50 49.00 52.83 38.67 51.50 62.67 60.00 52.17
data_03_means 43.60 64.00 60.80 51.60 41.80 63.00 59.20 51.40 54.40 24.40 58.00 35.20
data_04_means 60.86 57.43 60.57 65.57 54.57 42.00 63.57 60.29 34.14 62.86
data_05_means 55.88 48.50 62.88 33.00 40.62 37.88 37.75 55.25 51.00 52.75 45.25
>>> 

Noterai come la funzione è costruita sulla falsa-riga del precedente post, non è niente di che ed ho dato, inoltre, per scontato che i dati di un file siano a dimensione costante, mentre non ho dato per scontato che i files abbiano le stesse dimensione, non ho usato indicatori come avevi posto Tu (50 sono TROPPE lettere) ma il nome-file per distinguere.

Ciao

[drudox]

Te ne sono grato !

[vaeVictis]

Ciao, non so se ho capito bene, ma tu a partire dai due file

Codice: Seleziona tutto

A  3  6  7
B  5  2  10 

Codice: Seleziona tutto

A  5 8 9
B  7 4 20 

vuoi ottenere

Codice: Seleziona tutto

A ((3+5)/2 = 4) , ((6+8)/2 = 7), ((7+9)/2= 8 )
b ((5+7)/2 = 6) , ((2+4)/2 = 3 ), ((10+20)/2 = 15).

che vuol dire fare la media di tutti i valori che occupano lo stesso posto in file diversi.

Sempre se ho capito bene, la procedura indicata dal buon @nuzzopippo invece fa le medie sulle singole colonne di ogni singolo file.

Dal momento che (se ho capito bene) ho affrontato un problema analogo tempo fa e mi ero scritto una classe apposita per la lettura di più file in parallelo, l'ho un po' migliorata per gestire alcune problematiche e quindi la posto.

Il seguente messaggio contiene il file MultiFile.py, poi la spiegazione della classe MultiFile in esso contenuta e infine la spiegazione di come si utilizza il file per risolvere il tuo problema. Puoi andare direttamente alla fine se non ti interessano i dettagli.

MultiFile.py

Codice: Seleziona tutto

#! /usr/bin/env python3

import argparse
import logging
import numpy as np
import sys

from os.path import isfile

class MultiFile(object):
    _Log_Format = "%(levelname)s %(asctime)s - %(message)s"
    logging.basicConfig(stream = sys.stderr, format = _Log_Format, level = logging.INFO)
    _class_logger = logging.getLogger(__name__).getChild(__qualname__)
    def __init__(self, *files, logging = False, permissive = False):
        self._logging = logging
        self._permissive = permissive
        self._filenames = list(files)
        self._files = []
        self._filesToIterate = []
        self._IOErrStrings = []
        for filePath in self._filenames:
            try:
                tempFile = open(filePath)
                self._files.append(tempFile)
                self._filesToIterate.append(tempFile)
            except IOError as e:
                IOerror = "I/O error({0}): {1} : '{2}'"
                self._IOErrStrings.append(IOerror.format(e.errno, e.strerror, filePath))
        if self._IOErrStrings:
            self._class_logger.error('\n'.join(self._IOErrStrings))
            raise IOError

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
       for myFile in self._files:
           myFile.close()

              
    def __iter__(self):
        while True:
            if not self._filesToIterate:
                raise StopIteration
            lines = [ next(f,'') for f in self._filesToIterate ]
            if all(lines):
                yield lines
            else:
                overFilesNames = [ myFile.name for myFile, line in zip(self._filesToIterate, lines) if line == '' ]
                if self._logging:
                    self._class_logger.info("over:" + ', '.join(overFilesNames))
                if self._permissive:
                    lines = [ line for line in lines if line ]
                    if lines:
                        yield lines
                    self._filesToIterate = [ myFile for myFile in self._filesToIterate if myFile.name not in overFilesNames ]
                else:
                    self._filesToIterate = []

    def close(self):
        for myFile in self._files:
            myFile.close()



if __name__ == '__main__':

    def existing_file(path):
        if not isfile(path):
            raise argparse.ArgumentTypeError(f"{path} is not a valid path")
        else:
            return path

    parser = argparse.ArgumentParser()
    parser.add_argument("--files", type = existing_file, required = True, nargs='+')
    parser.add_argument("--precision", type = int, default=3)
    parser.add_argument("--logging", action = 'store_true')
    parser.add_argument("--permissive", action = 'store_true')
    
    args = parser.parse_args()
    with MultiFile(*args.files, logging = args.logging, permissive = args.permissive) as myMultiFile:
        for multiLine in myMultiFile:
            label = ''
            for singleLine in multiLine:
                try:
                    label = singleLine.split()[0]
                    break
                except:
                    pass
            if not label:
                continue
            means = ' '.join("{:.{}f}".format(x, args.precision) for x in np.array([singleLine.split()[1:] for singleLine in multiLine if singleLine.rstrip()]).astype('float').mean(axis = 0))
            print(label + ' ' + means)

Spiegazione della classe MultiFile contenuta in MultiFile.py
Allora, per la lettura di un numero arbitrario di file, riga per riga (quindi la prima di tutti, poi la seconda di tutti), tempo fa avevo buttato giù questa classe (in realtà una versione simile, che ho migliorato per questo post):
Nel seguito, faccio riferimento ai seguenti file (notare che hanno un numero di righe differente, rispettivamente 2, 3 e 4, e inoltre filec.txt ha una riga vuota):
filea.txt

Codice: Seleziona tutto

A  3  6  7
B  5  2  10 

fileb.txt

Codice: Seleziona tutto

A  5 8 9
B  7 4 20  
C 6 5 12

filec.txt

Codice: Seleziona tutto

A  3  6  7
B  5  2  10 

D 9 6 3

Come funziona la classe Multifile?
Supponiamo che hai messo il codice precedente in un file e lo hai chiamato "MultiFile.py" e supponiamo di stare nell'interprete di Python nella cartella che contiene MultiFile.py.
Lo importi usualmente come:

Codice: Seleziona tutto

>>> import MultiFile

Lo istanzi passandogli come argomenti tutti i file che vuoi analizzare. In più ha due parametri logging e permissive, entrambi False di default.
Lo puoi usare sia come oggetto:

Codice: Seleziona tutto

myMultiFile = MultiFile.MultiFile("filea.txt", "fileb.txt", "filec.txt")

sia in un costrutto with/as (che è meglio)

Codice: Seleziona tutto

with MultiFile.MultiFile("filea.txt", "fileb.txt", "filec.txt") as myMultiFile

In pratica, è un "MultiFile", come dice anche il nome. E lo usi analogamente ai file:

Codice: Seleziona tutto

>>> with MultiFile.MultiFile("filea.txt", "fileb.txt", "filec.txt") as myMultiFile:
...     for multiLine in myMultiFile:
...             multiLine
... 
['A  3  6  7\n', 'A  5 8 9\n', 'A  3  6  7\n']
['B  5  2  10 \n', 'B  7 4 20  \n', 'B  5  2  10 \n']

Come vedi, a ogni iterazione la variabile "multiLine" è una lista i cui elementi sono le righe dei vari file.
Inoltre, l'iterazione (in questo caso) si blocca quando il file più corto (filea.txt, di due righe) termina.

L'idea è quella di avere le righe disposte in questo modo per farci poi comodamente le elaborazioni che più ci interessano. Su cui mi soffermo più giù.

Ora, con il parametro permissive impostato a True, fai in modo che la lettura continui e ti mostri ovviamente solo le righe dei file restanti. Questo perché potresti avere la necessità di elaborare file con un numero di righe diverse e vuoi continuare a leggere quelle che restano e lavorare solo su quelle.
Faccio un esempio:

Codice: Seleziona tutto

>>> with MultiFile.MultiFile("filea.txt", "fileb.txt", "filec.txt", permissive = True) as myMultiFile:
...     for multiLine in myMultiFile:
...             multiLine
... 
['A  3  6  7\n', 'A  5 8 9\n', 'A  3  6  7\n']
['B  5  2  10 \n', 'B  7 4 20  \n', 'B  5  2  10 \n']
['C 6 5 12\n', '\n']
['D 9 6 3\n']

Come vedi, nelle prime due iterazioni legge tre file, poi due perché filea.txt è terminato e di queste due righe lette la seconda è vuota perché è la terza riga di filec.txt , e alla successiva iterazione ne legge una perché è terminato anche fileb.txt.

Il parametro logging serve per stampare nello standard error l'informazione dei file che sono terminati.
Ovviamente se lasci "permissive" a False, avrai la segnalazione solo del primo file che termina, perché il ciclo si blocca.

Codice: Seleziona tutto

>>> with MultiFile.MultiFile("filea.txt", "fileb.txt", "filec.txt", logging = True) as myMultiFile:
...     for multiLine in myMultiFile:
...             multiLine
... 
['A  3  6  7\n', 'A  5 8 9\n', 'A  3  6  7\n']
['B  5  2  10 \n', 'B  7 4 20  \n', 'B  5  2  10 \n']
INFO 2021-12-22 02:13:01,354 - over:filea.txt

Se invece imposti permissive a True, avrai le informazioni man mano che i file terminano e te le stampa prima di stampare il contenuto letto:

Codice: Seleziona tutto

>>> with MultiFile.MultiFile("filea.txt", "fileb.txt", "filec.txt", permissive = True, logging = True) as myMultiFile:
...     for multiLine in myMultiFile:
...             multiLine
... 
['A  3  6  7\n', 'A  5 8 9\n', 'A  3  6  7\n']
['B  5  2  10 \n', 'B  7 4 20  \n', 'B  5  2  10 \n']
INFO 2021-12-22 02:15:02,060 - over:filea.txt
['C 6 5 12\n', '\n']
INFO 2021-12-22 02:15:02,060 - over:fileb.txt
['D 9 6 3\n']
INFO 2021-12-22 02:15:02,060 - over:filec.txt

Dicevo che è meglio usarlo con il costrutto with/as perché (analogamente a come si usano in questo modo i file) non devi stare a pensare alla chiusura dei file che hai aperto.
Se invece lo usi con la sintassi

Codice: Seleziona tutto

myMultiFile = MultiFile.MultiFile("filea.txt", "fileb.txt", "filec.txt", permissive = True, logging = True)

quando hai finito devi accertarti di "chiuderlo":

Codice: Seleziona tutto

myMultiFile.close()

altrimenti alcuni file potrebbero rimanere aperti. (Ipotesi che si verifica )

Infine, se passi dei file non esistenti a MultiFile, questo se ne accorge, ti segnala la cosa, solleva un'eccezione IOError e se non la gestisci ti crasha il programma.



La parte del programma che fa le medie dei valori che occupano lo stesso posto

All'interno del programma, la parte vera e propria che fa le medie dei valori corrispondenti su tutti i file è la seguente:

Codice: Seleziona tutto

        for multiLine in myMultiFile:
            label = ''
            for singleLine in multiLine:
                try:
                    label = singleLine.split()[0]
                    break
                except:
                    pass
            if not label:
                continue
            means = ' '.join("{:.{}f}".format(x, args.precision) for x in np.array([singleLine.split()[1:] for singleLine in multiLine if singleLine.rstrip()]).astype('float').mean(axis = 0))
            print(label + ' ' + means)

La spiego:
c'è un primo ciclo for in cui ogni multiLine è del tipo di quelle che hai visto sopra, quindi una cosa del tipo:

Codice: Seleziona tutto

['B  5  2  10 \n', 'B  7 4 20  \n', 'B  5  2  10 \n']

Successivamente, imposto label a una stringa vuota, e poi c'è un ciclo su ogni elemento di multiLine, ovvero su ogni riga letta da ogni file.
Per ogni riga faccio una try/except in cui cerco di "prendere" la lettera iniziale. Faccio una try/except perché la singleLine su cui sto operando potrebbe essere una riga vuota (come accade per esempio in filec.txt che ha una riga mancante). Se la riga dovesse essere vuota o comunque mal formata, viene sollevata un'eccezione, che gestisco semplicemente con pass per andare alla singleLine successiva. Appena trovo una singleLine che inizia con una label valida, interrompo con una break.
Successivamente, controllo se ho trovato una label valida con "if not label". Potrebbe infatti darsi che tutte le righe sono vuote, caso in cui la label sarebbe "vuota", e semplicemente con continue passo all'iterazione successiva del ciclo for più esterno.

Ora la parte delle medie:

Codice: Seleziona tutto

means = ' '.join( "{:.{}f}".format(x, args.precision) for x in np.array([singleLine.split()[1:] for singleLine in multiLine if singleLine.rstrip()]).astype('float').mean(axis = 0) )

Supponiamo che sia

Codice: Seleziona tutto

>>> multiLine = ['B  5  2  10 \n', 'B  7 4 20  \n', 'B  5  2  10 \n']

Da questa, con:

Codice: Seleziona tutto

[ singleLine.split()[1:] for singleLine in multiLine if singleLine.rstrip() ]

creo una lista di liste contenenti i vari numeri (in formato stringa) contenuti nelle righe non vuote:

Codice: Seleziona tutto

>>> [ singleLine.split()[1:] for singleLine in multiLine if singleLine.rstrip() ]
[['5', '2', '10'], ['7', '4', '20'], ['5', '2', '10']]

Questa lista di liste la do in pasto a numpy, con il quale creo un np.array e poi gli dico di fare le medie per "colonne":

Codice: Seleziona tutto

>>> np.array( [ singleLine.split()[1:] for singleLine in multiLine if singleLine.rstrip() ] ).astype('float').mean(axis = 0)
array([ 5.66666667,  2.66666667, 13.33333333])

Una volta che ho questo array uso una ' '.join() su:

Codice: Seleziona tutto

>>> [ "{:.{}f}".format(x, args.precision) for x in np.array([singleLine.split()[1:] for singleLine in multiLine if singleLine.rstrip()]).astype('float').mean(axis = 0) ]
['5.667', '2.667', '13.333']

ottenendo quindi:

Codice: Seleziona tutto

' '.join("{:.{}f}".format(x, args.precision) for x in np.array([singleLine.split()[1:] for singleLine in multiLine if singleLine.rstrip()]).astype('float').mean(axis = 0))
'5.667 2.667 13.333'

Una volta che ho sia label che means, con print le stampo:

Codice: Seleziona tutto

print(label + ' ' + means)

Sì, ok, ma come si usa il file che ti ho postato all'inzio?
Ora, ciò premesso e facendo sempre riferimento ai file filea.txt, fileb.txt e filec.txt, il file si usa nel seguente modo.
Lo salvi dove ti pare, mettiamo con il nome MultiFile.py, gli dai i permessi di esecuzione e vedi la sintassi del comando nel seguente modo:

Codice: Seleziona tutto

$ ./MultiFile.py --help
usage: MultiFile.py [-h] --files FILES [FILES ...] [--precision PRECISION]
                    [--logging] [--permissive]

optional arguments:
  -h, --help            show this help message and exit
  --files FILES [FILES ...]
  --precision PRECISION
  --logging
  --permissive

Lo puoi quindi lanciare in uno dei seguenti modi:
1)

Codice: Seleziona tutto

$ ./MultiFile.py --files filea.txt fileb.txt filec.txt
A 3.667 6.667 7.667
B 5.667 2.667 13.333

in questo modo, se dovessi avere un file più corto degli altri, la procedura si interrompe quando quello finisce.
2)

Codice: Seleziona tutto

$ ./MultiFile.py --files filea.txt fileb.txt filec.txt --permissive
A 3.667 6.667 7.667
B 5.667 2.667 13.333
C 6.000 5.000 12.000
D 9.000 6.000 3.000

in questo modo, se hai file di diverse lunghezze, man mano che i file finiscono vengono messi da parte e la procedura continua sugli altri.
3)

Codice: Seleziona tutto

$ ./MultiFile.py --files filea.txt fileb.txt filec.txt --permissive --logging
A 3.667 6.667 7.667
B 5.667 2.667 13.333
INFO 2021-12-22 02:27:18,697 - over:filea.txt
C 6.000 5.000 12.000
INFO 2021-12-22 02:27:18,697 - over:fileb.txt
D 9.000 6.000 3.000
INFO 2021-12-22 02:27:18,698 - over:filec.txt

in questo modo, la lettura continua (perché c'è permissive) e hai il logging sullo standard error.
Sottolineo che il logging è sullo standard error perché se vuoi salvare su un file di output le medie che hai calcolato, ti basta dare il comando:

Codice: Seleziona tutto

$ ./MultiFile.py --files filea.txt fileb.txt filec.txt --permissive --logging > foo.txt 
INFO 2021-12-22 02:29:56,334 - over:filea.txt
INFO 2021-12-22 02:29:56,335 - over:fileb.txt
INFO 2021-12-22 02:29:56,335 - over:filec.txt

come vedi, ti stampa solo i vari logging, mentre nel file di output hai solo quello che ti interessa:

Codice: Seleziona tutto

$ cat foo.txt 
A 3.667 6.667 7.667
B 5.667 2.667 13.333
C 6.000 5.000 12.000
D 9.000 6.000 3.000

Infine, con il parametro precision, puoi impostare una precisione dopo la virgola per la stampa delle medie. Di default ho messo 3.
Per impostarne una differente:

Codice: Seleziona tutto

$ ./MultiFile.py --files filea.txt fileb.txt filec.txt --permissive --precision 5
A 3.66667 6.66667 7.66667
B 5.66667 2.66667 13.33333
C 6.00000 5.00000 12.00000
D 9.00000 6.00000 3.00000

Per concludere, se passi dei file inesistenti al programma, questo non ti crasha perché ho fatto in modo che argparse se ne accorga prima e ti segnali la cosa:

Codice: Seleziona tutto

$ ./MultiFile.py --files filea.txt fileb.txt filenonesistente.txt
usage: MultiFile.py [-h] --files FILES [FILES ...] [--precision PRECISION]
                    [--logging] [--permissive]
MultiFile.py: error: argument --files: filenonesistente.txt is not a valid path

edit:
Non sono andato avanti a migliorare la classe MultiFile, ma si potrebbe introdurre un'ulteriore funzione per controllare che le righe (o almeno quelle non vuote) abbiano tutte lo stesso numero di campi e così via.

[nuzzopippo]

...
vuoi ottenere

Codice: Seleziona tutto

A ((3+5)/2 = 4) , ((6+8)/2 = 7), ((7+9)/2= 8 )
b ((5+7)/2 = 6) , ((2+4)/2 = 3 ), ((10+20)/2 = 15).

che vuol dire fare la media di tutti i valori che occupano lo stesso posto in file diversi.

Sempre se ho capito bene, la procedura indicata dal buon @nuozzopippo invece fa le medie sulle singole colonne di ogni singolo file.

Beh, si, certo che fa ma media di tutte le singole colonne di un singolo file, poi restituisce la lista ottenuta per tutti i files, che sarebbe manipolabile a discrezione, rispondeva a quanto esposto dallo OP.

Molto interessante la Tua classe @vae, appena mi libero di alcune pendenze me la debbo guardare per bene

[vaeVictis]

@nuzzopippo
A quanto ho capito io, lui vuole fare la media dei valori che nei diversi file occupano la stessa posizione, escludendo la prima in cui ci sono le etichette.
Infatti, nell'esempio che fa, lui mostra due file

Codice: Seleziona tutto

A  3  6  7
B  5  2  10 

Codice: Seleziona tutto

A  5 8 9
B  7 4 20 

dai quali ne produce uno che ha le stesse etichette e nelle varie posizioni ha le medie dei valori che hanno la stessa posizione nei due file:

Codice: Seleziona tutto

A ((3+5)/2 = 4) , ((6+8)/2 = 7), ((7+9)/2= 8 )
b ((5+7)/2 = 6) , ((2+4)/2 = 3 ), ((10+20)/2 = 15).

Fammi sapere che ne pensi della classe. È una rielaborazione di una classe che avevo sviluppato insieme a crap0101 qui sul forum.

[nuzzopippo]

Fammi sapere che ne pensi della classe. È una rielaborazione di una classe che avevo sviluppato insieme a crap qui sul forum.

Contaci.
Se c'era anche @crap1010 di mezzo è certo ottima, non che ne dubitassi comunque, tarderò qualche giorno (il periodo è impegnativo) perché voglio guardarmela per bene, approcciando anche a numpy, che sin ora non ho guardato.

Riguardo alla "stessa posizione" dello quesito posto dallo OP è costruttiva nel codice da me postato, lo ho precisata l'ipotesi che i files "siano preparati", l'esclusione dei dati non numerici era pensata in tal senso, poi le liste mantengono l'indicizzazione, al più si potrebbe considerare il "non fermarsi" alla minima dimensione, cosa semplicissima da integrare, lo ho ritenuto più "congeniale" non capendo bene la destinazione d'uso delle elaborazioni (che in effetti non immaginavo mirassero ad un grafico)



[Edit] E si, riguardando l'intero post vedo che hai ragione ed ho veramente sbagliato la mia interpretazione, mi hanno fregato i primi due 5

[vaeVictis]

[...]

[Edit] E si, riguardando l'intero post vedo che hai ragione ed ho veramente sbagliato la mia interpretazione, mi hanno fregato i primi due 5

C'è poco da arrossire
Anche io ho dovuto rileggere più volte, perché l'op (senza offesa) non è stato il massimo della chiarezza. Cosa comunque comprensibile. E anche a me il 3+5 e il 5+7 inizialmente avevano mandato in confusione.
Diciamo che sono stato facilitato dal fatto che avevo già avuto un confronto con questo tipo di analisi poiché, dovendo analizzare alcune migliaia di file testuali, ognuno con una cinquantina di colonne e qualche decina di migliaia di righe, per un totale di svariati giga di peso complessivo, non ho potuto usare programmi già esistenti e ho dovuto inventarmi questa procedura per minimizzare l'allocazione di memoria, leggendo riga riga tutti i singoli file ad ogni iterazione (che è quello che fa la classe MultiFile)

[nuzzopippo]

beh, @vae, purtroppo "non capire" è una cosa che mi capita sempre più spesso, invecchio, spero di non aver indirizzato male @drudox, che ha pure ringraziado

Ovvio, appena tornato a casa mi son riscritto la funzione, adottando un metodo rigidamente procedurale ed appoggiandomi ad un dizionario con le coordinate quali chiavi, lanciato sui files del post precedente e verificato con gli elementi alle coordinate 0,0 e 3,3 sembra funzioni bene, lo posto anche per chiedere venia della mia cattiva interpretazione

Codice: Seleziona tutto

>>> def means_to_row_col_files(path, minsize=False):
	f_names = os.listdir(path)
	fmatrix = []
	for f_name in f_names:
		rows = []
		with open(os.path.join(path, f_name)) as f:
			data = [x.split() for x in f.read().splitlines()]
		for r in data:
			rows.append([int(x) for x in r if x.isnumeric()])
		fmatrix.append(rows)
	if minsize:
		hmin = len(fmatrix[0])
		wmin = len(fmatrix[0][0])
		for fm in fmatrix[1:]:
			if len(fm) < hmin:
				hmin = len(fm)
			if len(fm[0]) < wmin:
				wmin = len(fm[0])
	tmp = {}
	for fm in fmatrix:
		limr = len(fm) if not minsize else hmin
		limc = len(fm[0]) if not minsize else wmin
		for r in range(limr):
			for c in range(limc):
				if (r, c) not in tmp.keys():
					tmp[r, c] = []
					tmp[r, c].append([])
				tmp[r, c][0].append(fm[r][c])
	for key in tmp.keys():
		tmp[key].append(sum(tmp[key][0]) / len(tmp[key][0]))
	coords = tmp.keys()
	means = []
	for h in sorted(list(set([x[0] for x in coords]))):
		row_h = []
		for w in sorted(list(set([x[1] for x in coords if x[0] == h]))):
			row_h.append(tmp[h, w][1])
		means.append(row_h)
	return means

>>> means = means_to_row_col_files('/media/nuzzopippo/1FA6-C648/src/posts/drudox')
>>> for m in means:
	for v in m:
		print('%3.2f' % v, end=' ')
	print()

	
61.60 62.40 73.80 47.60 55.20 70.20 55.60 71.80 40.00 64.20 54.50 24.00 
65.60 59.00 61.00 44.40 34.60 52.60 63.60 62.20 44.60 32.20 59.00 46.00 
43.80 75.80 70.60 57.60 45.20 29.80 64.00 52.80 62.00 47.40 82.50 63.00 
70.40 59.00 57.00 41.40 46.20 40.00 39.00 62.60 46.20 33.80 40.50 31.00 
53.60 20.00 45.40 64.00 50.60 43.60 16.40 20.60 51.00 63.60 50.50 12.00 
53.00 55.00 46.00 64.33 55.67 54.67 52.67 77.33 47.00 60.00 49.00 
56.00 42.50 62.50 60.00 34.50 9.00 86.50 63.00 31.00 49.50 25.00 
55.00 34.00 54.00 32.00 46.00 41.00 14.00 20.00 82.00 75.00 4.00 
>>> means = means_to_row_col_files('/media/nuzzopippo/1FA6-C648/src/posts/drudox', True)
>>> for m in means:
	for v in m:
		print('%3.2f' % v, end=' ')
	print()

	
61.60 62.40 73.80 47.60 55.20 70.20 55.60 71.80 40.00 64.20 
65.60 59.00 61.00 44.40 34.60 52.60 63.60 62.20 44.60 32.20 
43.80 75.80 70.60 57.60 45.20 29.80 64.00 52.80 62.00 47.40 
70.40 59.00 57.00 41.40 46.20 40.00 39.00 62.60 46.20 33.80 
53.60 20.00 45.40 64.00 50.60 43.60 16.40 20.60 51.00 63.60 
>>> 

[Edit] ... e invece no, non va ancora, lo devo rivedere
[ri-edit], no va bene, mi ero sbagliato a contare manualmente le righe di un paio di files

[vaeVictis]

Secondo me ti sei complicato le cose oltre misura
Se lo vuoi fare usando le funzioni, puoi semplificare il tutto con una cosa del genere:

Codice: Seleziona tutto

>>> my_files = ['fileb.txt', 'filed.txt', 'filec.txt', 'filee.txt', 'filea.txt']    # lista dei nomi dei file
>>> my_open_files = [ open(file) for file in my_files   ]   # lista dei file aperti
>>> while True:
...     try:
...             my_lines = [ next(file) for file in my_open_files  ]     # lista delle righe lette da ogni file
...             means = np.array([ line.rstrip().split()[1:] for line in my_lines ]).astype('float').mean(axis = 0)   # medie 
...             print(' '.join((means.astype("str"))))     # stampa dei valori
...     except StopIteration:      # quando ho concluso la lettura mi fermo
...             break
... 
61.6 62.4 73.8 47.6 55.2 70.2 55.6 71.8 40.0 64.2
65.6 59.0 61.0 44.4 34.6 52.6 63.6 62.2 44.6 32.2
43.8 75.8 70.6 57.6 45.2 29.8 64.0 52.8 62.0 47.4
70.4 59.0 57.0 41.4 46.2 40.0 39.0 62.6 46.2 33.8
53.6 20.0 45.4 64.0 50.6 43.6 16.4 20.6 51.0 63.6
57.2 64.2 57.0 62.0 50.4 62.0 46.0 54.2 52.2 45.8
54.8 48.4 74.6 65.8 42.2 20.8 41.6 52.6 34.8 51.8
74.4 61.0 57.2 38.4 32.8 33.6 47.0 70.4 39.4 40.6

In python c'è numpy che fornisce praticamente qualsiasi utility matematica. Farsi le medie "a mano" è un po' un suicidio.

In numpy c'è la funzione mean che puoi usare in questo modo.
Supponendo che hai già dato i comandi:

Codice: Seleziona tutto

>>> import numpy as np
>>> my_files = ['fileb.txt', 'filed.txt', 'filec.txt', 'filee.txt', 'filea.txt']
>>> my_open_files = [ open(file) for file in my_files   ]
>>> my_lines = [ next(file) for file in my_open_files  ]

In my_lines hai tutte le righe lette:

Codice: Seleziona tutto

>>> my_lines
['A 41 15 97 17 88 85 65 88 84 63\n', 'A 85 81 91 64 92 30 91 97  1 95\n', 'A 35 80 43 41 69 45 26 36 17 64\n', 'A 55 51 47 23 18 93 40 72 86 83\n', 'A 92 85 91 93  9 98 56 66 12 16\n']

da queste ti costruisci l'array numpy:

Codice: Seleziona tutto

>>> my_values = np.array([ line.rstrip().split()[1:] for line in my_lines ])
>>> my_values
array([['41', '15', '97', '17', '88', '85', '65', '88', '84', '63'],
       ['85', '81', '91', '64', '92', '30', '91', '97', '1', '95'],
       ['35', '80', '43', '41', '69', '45', '26', '36', '17', '64'],
       ['55', '51', '47', '23', '18', '93', '40', '72', '86', '83'],
       ['92', '85', '91', '93', '9', '98', '56', '66', '12', '16']],
      dtype='<U2')

reinterpreti l'array come se fossero float

Codice: Seleziona tutto

>>> my_values.astype('float')
array([[41., 15., 97., 17., 88., 85., 65., 88., 84., 63.],
       [85., 81., 91., 64., 92., 30., 91., 97.,  1., 95.],
       [35., 80., 43., 41., 69., 45., 26., 36., 17., 64.],
       [55., 51., 47., 23., 18., 93., 40., 72., 86., 83.],
       [92., 85., 91., 93.,  9., 98., 56., 66., 12., 16.]])

e poi ti calcoli le medie direttamente con mean dandogli come axis il valore 0:

Codice: Seleziona tutto

>>> my_values.astype('float').mean(axis = 0)
array([61.6, 62.4, 73.8, 47.6, 55.2, 70.2, 55.6, 71.8, 40. , 64.2])

al che te li stampi comodamente reinterpretandoli come "stringa" e usando una join sull'array

Codice: Seleziona tutto

>>> ' '.join( my_values.astype('float').mean(axis = 0).astype("str") )
'61.6 62.4 73.8 47.6 55.2 70.2 55.6 71.8 40.0 64.2'

[nuzzopippo]

tarderò qualche giorno (il periodo è impegnativo) perché voglio guardarmela per bene, approcciando anche a numpy, che sin ora non ho guardato.

Come detto sopra, numpy non lo ho ancora guardato (come tantissime altre librerie), un po' perché il mio orizzonte non è così vasto da comprendere necessità di elaborazioni "pesanti", un po' perché sto tutt'ora cercando di approfondire la base (ignorare l'inglese è una palla al piede terribile).
So che la potenza di python è data dalle sue librerie, un giorno spero di arrivare a conoscere le principali ma non ho fretta

... poi, "farsi le medie a mano" mi è facile, per abitudini antiche, sono portato a ragionare a passetti, per contro "ricordo" poco, ce ne vuole prima che riesca a fissare i millemila metodi delle varie librerie

Grazie del Tuo codice, mi darà spunto su cose da guardare (p.s., la Tua classe prima : è decisamente "bel codice")

[vaeVictis]

Grazie del Tuo codice, mi darà spunto su cose da guardare (p.s., la Tua classe prima : è decisamente "bel codice")

Grazie! Apprezzo molto.
La sto sistemando (ho eliminato una variabile che era inutile e sto aggiungendo funzionalità) e poi la carico su github

Ho aggiunto alcuni codici al mio messaggio precedente, non so se li hai visti.
Ci sono i dettagli su come usare la funzione mean di numpy. Magari ti facilita l'approccio.


Edit:
Ho aggiunto il progetto su github

[nuzzopippo]

Ho aggiunto alcuni codici al mio messaggio precedente, non so se li hai visti.

Li sto guardando e provando adesso, non tanto per numpy, del quale mi tradurrò docs e tutorial prima di iniziarlo, quanto per le tecniche di lettura files che utilizzi : molto interessanti, avevo tutti i mezzi per derivarle, i comandi li conosco tutti, ma non mi ha mai sfiorato l'idea di combinazioni del genere, quei my_open_files/my_lines sono di una eleganza particolare.

Visto su gittub

[vaeVictis]

ma non mi ha mai sfiorato l'idea di combinazioni del genere, quei my_open_files/my_lines sono di una eleganza particolare.

Ti ringrazio davvero per le tue parole.
Sinceramente, io ci ho messo parecchio per iniziare a scrivere codice "pythonico". Mi sono letto una marea di risorse e ho visionato codici di altre persone ben più avanti di me. Ho dovuto però fare molta fatica perché provenendo dal C/C++ è stato particolarmente difficile scremare le sintassi acquisite.

Visto su gittub

In tutto ciò, l'op è sparito
@drudox batti un colpo.


Edit:
Rileggendo il mio messaggio, non vorrei che sembrasse che me la stessi tirando. Non era quello il mio intento. Era per dire che è una strada molto impervia e che spesso "rubare" da chi scrive bel codice aiuta a scrivere bene.