[Python] Dove sbaglio?

Gio 30 Apr 2020 21:45:18 CEST

Il 30/04/2020 19:53, Marco Beri ha scritto:
> On Thu, Apr 30, 2020 at 7:45 PM Carpediem <i.carpediem a tiscali.it 
> <mailto:i.carpediem a tiscali.it>> wrote:
>
>     Il 30/04/2020 18:54, Marco Beri ha scritto:
>>     On Thu, Apr 30, 2020 at 6:18 PM Carpediem <i.carpediem a tiscali.it
>>     <mailto:i.carpediem a tiscali.it>> wrote:
>>
>>         Grazie Alessandro. Mi hai fatto notare l'assenza
>>         dell'istruzione break e
>>         ora che l'ho inserita, il programma termina la sua esecuzione.
>>
>>         Purtroppo, non mi restituisce ciò che mi aspetto e continuo a
>>         non capire
>>         perchè. L'ordinamento che cerco, è in
>>
>>         relazione con l'indice dei numeri della lista di riferimento e
>>         utilizzare il metodo sorted() per quel che ho visto, o
>>         compreso, non mi
>>         è di aiuto.
>>
>>         Partendo da questo:
>>
>>         [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
>>         17, 18, 19,
>>         20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
>>         35, 36]
>>
>>         [22, 0, 18, 34, 20, 7, 2, 1, 30, 22, 55, 47, 53, 49, 52, 38,
>>         12, 41, 29,
>>         5, 11, 44, 26, 33, 40, 13, 50, 39, 4, 21, 45, 3, 53, 32, 6,
>>         25, 55]
>>
>>         volevo ottenere questo:
>>
>>         [10, 36, 12, 32, .............]
>>
>>         [55, 55, 53, 53, 52, ......]
>>
>>
>>     Se guardi la documentazione di cosa fanno zip e sorted (che ha un
>>     parametro reversed) vedrai che quello che vuoi fare è ottenibile
>>     con poche istruzioni:
>>
>>         >>> riepilogo_numeri_singoli = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
>>         10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
>>         ...                             25, 26, 27, 28, 29, 30, 31,
>>         32, 33, 34, 35, 36]
>>         >>>
>>         >>> ritardo_numeri_singoli = [22, 0, 18, 34, 20, 7, 2, 1, 30,
>>         22, 55, 47, 53, 49, 52, 38, 12, 41, 29, 5, 11, 44, 26, 33,
>>         40, 13, 50, 39, 4, 21,
>>         ...                           45, 3, 53, 32, 6, 25, 55]
>>         >>>
>>         >>> ritardo_numeri_singoli_ordine_decrescente ,
>>         numeri_singoli_in_ordine =
>>         zip(*sorted(zip(ritardo_numeri_singoli,
>>         riepilogo_numeri_singoli), reverse=True))
>>         >>>
>>         >>> ritardo_numeri_singoli_ordine_decrescente
>>         (55, 55, 53, 53, 52, 50, 49, 47, 45, 44, 41, 40, 39, 38, 34,
>>         33, 32, 30, 29, 26, 25, 22, 22, 21, 20, 18, 13, 12, 11, 7, 6,
>>         5, 4, 3, 2, 1, 0)
>>         >>>
>>         >>> numeri_singoli_in_ordine
>>         (36, 10, 32, 12, 14, 26, 13, 11, 30, 21, 17, 24, 27, 15, 3,
>>         23, 33, 8, 18, 22, 35, 9, 0, 29, 4, 2, 25, 16, 20, 5, 34, 19,
>>         28, 31, 6, 7, 1)
>>         >>>
>>
>>
>>     Ciao.
>>     Marco.
>
>
>     Grazie per il tuo tempo Marco. Scoprire che tutto il casino che ho
>     scritto si può riassumere in una sola istruzione quasi mi
>     demoralizza. Tuttavia, il risultato che ottengo con ciò che mi
>
>     hai suggerito, non è ciò che voglio. il primo numero della lista
>     ritardo_numeri_singoli_in_ordine_decrescente è il numero 55 che
>     nella lista ritardo_numeri_singoli aveva indice 10 e in corrispondenza
>
>     dell'indice 10 della lista riepilogo_numeri_singoli c'è il numero
>     10 che dovrebbe essere il primo numero presente nella lista
>     numeri_singoli_in ordine. Il secondo 55 aveva indice 36 e quindi
>     il numero
>
>     corrispondente con tale indice nella lista
>     riepilogo_numeri_singoli (il 36) dovrebbe essere il secondo numero
>     presente nella nuova lista e così via. Quindi [10, 36, 12, 32 ....]
>
>     La tua soluzione mi rende invece un risultato diverso. Molto
>     probabilmente l'intenzione di ciò che voglio ottenere è stata da
>     me espressa poco chiaramente.
>
>     L'istruzione sort con reverse = True l'avevo usata anche io per
>     l'ordine decrescente ma l'Istruzione zip è invece a me totalmente
>     sconosciuta. Cercherò di capirci qualcosa.
>
>     E' comunque utilizzabile per ciò che mi serve? In caso affermativo
>     vedere l'istruzione che rende il risultato corretto mi
>     faciliterebbe molto a comprendere il suo funzionamento.
>
>     Se ti fosse possibile, sono certo ne troverei giovamento.
>
>
> La funzione zip fa questo:
>
>     >>> list(zip([1,2,3], ['a', 'b', 'c']))
>     [(1, 'a'), (2, 'b'), (3, 'c')]
>
>
> Passandogli un parametro con l'* in pratica gli facciamo fare il 
> contrario:
>
>     >>> list(zip(*[(1, 'a'), (2, 'b'), (3, 'c')]))
>     [(1, 2, 3), ('a', 'b', 'c')]
>
>
> Ma nel tuo caso lei fa il suo dovere, dobbiamo invece modificare il 
> comportamento della funzione sorted:
>
>     >>> ritardo_numeri_singoli_ordine_decrescente ,
>     numeri_singoli_in_ordine = zip(*sorted(zip(ritardo_numeri_singoli,
>     riepilogo_numeri_singoli), key=lambda x:(x[0],-x[1]), reverse=True))
>     >>> ritardo_numeri_singoli_ordine_decrescente
>     (55, 55, 53, 53, 52, 50, 49, 47, 45, 44, 41, 40, 39, 38, 34, 33,
>     32, 30, 29, 26, 25, 22, 22, 21, 20, 18, 13, 12, 11, 7, 6, 5, 4, 3,
>     2, 1, 0)
>     >>> numeri_singoli_in_ordine
>     (10, 36, 12, 32, 14, 26, 13, 11, 30, 21, 17, 24, 27, 15, 3, 23,
>     33, 8, 18, 22, 35, 0, 9, 29, 4, 2, 25, 16, 20, 5, 34, 19, 28, 31,
>     6, 7, 1)
>
>
> In pratica diciamo alla funzione sorted di usare per l'ordinamento 
> inverso il primo numero così com'è (il ritardo) e il secondo numero al 
> contrario.
> In alternativa potevamo dirgli di non fare l'ordine inverso e 
> invertire il primo, il risultato non cambia:
>
>     >>> ritardo_numeri_singoli_ordine_decrescente ,
>     numeri_singoli_in_ordine = zip(*sorted(zip(ritardo_numeri_singoli,
>     riepilogo_numeri_singoli), key=lambda x:(-x[0],x[1])))
>     >>> ritardo_numeri_singoli_ordine_decrescente
>     (55, 55, 53, 53, 52, 50, 49, 47, 45, 44, 41, 40, 39, 38, 34, 33,
>     32, 30, 29, 26, 25, 22, 22, 21, 20, 18, 13, 12, 11, 7, 6, 5, 4, 3,
>     2, 1, 0)
>     >>> numeri_singoli_in_ordine
>     (10, 36, 12, 32, 14, 26, 13, 11, 30, 21, 17, 24, 27, 15, 3, 23,
>     33, 8, 18, 22, 35, 0, 9, 29, 4, 2, 25, 16, 20, 5, 34, 19, 28, 31,
>     6, 7, 1)
>
>
> Ok, confesso che è un po' complicato (le funzioni lambda sono un 
> pochino avanzate), però anche quello che vuoi fare tu lo è.
>
> Ciao.
> Marco.

Punto 1) Non avrei mai risolto il problema da solo

Punto 2)  La soluzione è bellissima e ha un fascino di mistero come 
certe belle donne

Punto 3) Come certe belle donne è tanto complicata che a volte dici: non 
so cosa le passa per la testa

Punto 4) In questo caso dico: è talmente complicata che non so come farà 
ad entrarmi in testa

Punto 5) ho cercato in rete info sulla funzione zip ma al momento non ho 
trovato nulla di spiegato in modo semplice ma comunque approfondito: hai 
riferimenti?

Punto 6) Addirittura due soluzioni diverse: geniale ed invidiabile. Una 
riga di codice contro le circa 30 da me utilizzate!!!!

Punto 7) nel guardare la tua prima soluzione (quella che non combaciava 
con ciò che volevo ottenere) forse ho compreso come in quel caso ha 
lavorato la funzione zip!!! farò delle prove con altri dati tentando di 
anticiparne su carta il risultato

Punto 8) Ma dove hai imparato? Avevo immaginato che mi ero infilato in 
qualcosa di complicato e la tua conferma un poco mi consola

Punto 9) La soluzione che stavo sperimentando mi resta un mistero sul 
suo non fuzionamento anche perchè all'inizio parte bene e poi si perde. 
Sempre per imparare, ma dov'era l'errore?

Punto 10) Cento volte Grazie.

Isidoro

>
>
> _______________________________________________
> Python mailing list
> Python a lists.python.it
> https://lists.python.it/mailman/listinfo/python
-------------- parte successiva --------------
Un allegato HTML è stato rimosso...
URL: <http://lists.python.it/pipermail/python/attachments/20200430/4c1d7726/attachment-0001.html>