Il modo più semplice per ordinare è tramite la funzione ordinati(elenco), che prende un elenco e restituisce un nuovo elenco con quegli elementi in ordine. L'elenco originale rimane invariato.
a = [5, 1, 4, 3] print(sorted(a)) ## [1, 3, 4, 5] print(a) ## [5, 1, 4, 3]
È più comune passare un elenco alla funzione managed(), ma in realtà può utilizzare come input qualsiasi tipo di raccolta iterabile. Il vecchio metodo list.sort() è un'alternativa descritta di seguito. La funzione Sort() sembra più facile da usare rispetto a sort(), quindi consiglio di usare Sort().
La funzione ordinati() può essere personalizzata mediante argomenti facoltativi. L'argomento facoltativo Sort() inversa=True, ad es. ordinati(list, reverse=True), consente di eseguire l'ordinamento all'indietro.
strs = ['aa', 'BB', 'zz', 'CC'] print(sorted(strs)) ## ['BB', 'CC', 'aa', 'zz'] (case sensitive) print(sorted(strs, reverse=True)) ## ['zz', 'aa', 'CC', 'BB']
Ordinamento personalizzato con chiave=
Per un ordinamento personalizzato più complesso, ordinati() accetta una chiave facoltativa "key=" che specifica una "chiave" che trasforma ogni elemento prima del confronto. La funzione chiave accetta 1 valore, restituisce 1 valore e "proxy" restituito viene utilizzato per i confronti all'interno dell'ordinamento.
Ad esempio, con un elenco di stringhe, specificando key=len (la funzione len() integrata) ordina le stringhe in base alla lunghezza, dalla più corta alla più lunga. L'ordinamento chiama len() per ogni stringa per ottenere l'elenco dei valori della lunghezza del proxy, quindi esegue l'ordinamento in base a questi valori.
strs = ['ccc', 'aaaa', 'd', 'bb'] print(sorted(strs, key=len)) ## ['d', 'bb', 'ccc', 'aaaa']
Come ulteriore esempio, specificando "str.lower" poiché la funzione chiave è un modo per forzare l'ordinamento a trattare allo stesso modo lettere maiuscole e minuscole:
## "key" argument specifying str.lower function to use for sorting print(sorted(strs, key=str.lower)) ## ['aa', 'BB', 'CC', 'zz']
Puoi anche trasferire il tuo MyFn come funzione chiave, in questo modo:
## Say we have a list of strings we want to sort by the last letter of the string. strs = ['xc', 'zb', 'yd' ,'wa'] ## Write a little function that takes a string, and returns its last letter. ## This will be the key function (takes in 1 value, returns 1 value). def MyFn(s): return s[-1] ## Now pass key=MyFn to sorted() to sort by the last letter: print(sorted(strs, key=MyFn)) ## ['wa', 'zb', 'xc', 'yd']
Per un ordinamento più complesso, ad esempio per cognome e poi per nome, puoi utilizzare le funzioni itemgetter o attrgetter come:
from operator import itemgetter # (first name, last name, score) tuples grade = [('Freddy', 'Frank', 3), ('Anil', 'Frank', 100), ('Anil', 'Wang', 24)] sorted(grade, key=itemgetter(1,0)) # [('Anil', 'Frank', 100), ('Freddy', 'Frank', 3), ('Anil', 'Wang', 24)] sorted(grade, key=itemgetter(0,-1)) #[('Anil', 'Wang', 24), ('Anil', 'Frank', 100), ('Freddy', 'Frank', 3)]
metodo sort()
In alternativa a Sort(), il metodo sort() su un elenco ordina l'elenco in ordine crescente, ad esempio list.sort(). Il metodo sort() modifica l'elenco sottostante e restituisce None. Utilizzalo in questo modo:
alist.sort() ## correct alist = blist.sort() ## Incorrect. sort() returns None
Quanto sopra è un malinteso molto comune con sort(). *Non restituisce* l'elenco ordinato. Il metodo sort() deve essere chiamato in un elenco; non funziona su nessuna raccolta enumerabile (ma la funzione orders() sopra funziona su qualsiasi cosa). Il metodo sort() è antecedente alla funzione managed(), quindi probabilmente lo vedrai nel codice precedente. Il metodo sort() non ha bisogno di creare un nuovo elenco, quindi può essere un po' più veloce nel caso in cui gli elementi da ordinare siano già presenti in un elenco.
Tuple
Una tupla è un raggruppamento di elementi a dimensione fissa, ad esempio una coordinata (x, y). Le tuple sono come elenchi, ad eccezione del fatto che sono immutabili e non cambiano dimensione (le tuple non sono strettamente immutabili poiché uno degli elementi contenuti potrebbe essere mutabile). Le tuple suonano una sorta di "struct" in Python, un modo conveniente per passare un piccolo pacchetto di valori logici e di dimensioni fisse. Una funzione che deve restituire più valori può restituire una sola tupla di valori. Ad esempio, se volessi avere un elenco di coordinate 3D, la rappresentazione naturale di Python sarebbe un elenco di tuple, in cui ogni tupla ha una dimensione 3 e contiene un gruppo (x, y, z).
Per creare una tupla, elenca semplicemente i valori tra parentesi separati da virgole. Il campo "vuoto" la tupla è solo una coppia vuota di parentesi. L'accesso agli elementi in una tupla è come un elenco: len(), [ ], for, in e così via, funzionano tutti allo stesso modo.
tuple = (1, 2, 'hi') print(len(tuple)) ## 3 print(tuple[2]) ## hi tuple[2] = 'bye' ## NO, tuples cannot be changed tuple = (1, 2, 'bye') ## this works
Per creare una tupla di dimensione 1, l'elemento solitario deve essere seguito da una virgola.
tuple = ('hi',) ## size-1 tuple
La sintassi è molto divertente, ma la virgola è necessaria per distinguere la tupla dal normale caso di mettere un'espressione tra parentesi. In alcuni casi puoi omettere le parentesi e Python vedrà dalle virgole che intendi una tupla.
L'assegnazione di una tupla a una tupla di dimensioni identiche di nomi di variabili assegna tutti i valori corrispondenti. Se le tuple non sono della stessa dimensione, viene generato un errore. Questa funzionalità è valida anche per gli elenchi.
(x, y, z) = (42, 13, "hike") print(z) ## hike (err_string, err_code) = Foo() ## Foo() returns a length-2 tuple
Elenco Comprensione (facoltativo)
La comprensione dell'elenco è una funzione più avanzata che è utile in alcuni casi, ma non è necessaria per gli esercizi e non è necessaria per imparare all'inizio (ad esempio, puoi saltare questa sezione). La comprensione di un elenco è un modo compatto per scrivere un'espressione che si espande in un intero elenco. Supponiamo di avere un elenco di numeri [1, 2, 3, 4], ecco la comprensione della lista per calcolare una lista dei loro quadrati [1, 4, 9, 16]:
nums = [1, 2, 3, 4] squares = [ n * n for n in nums ] ## [1, 4, 9, 16]
La sintassi è [ expr for var in list ]. Il valore for var in list è simile a un normale ciclo for, ma senza i due punti (:). L'espressione expr a sinistra viene valutata una volta per ogni elemento al fine di fornire i valori per il nuovo elenco. Ecco un esempio con le stringhe, in cui ogni stringa viene modificata in lettere maiuscole con "!!!" aggiunta:
strs = ['hello', 'and', 'goodbye'] shouting = [ s.upper() + '!!!' for s in strs ] ## ['HELLO!!!', 'AND!!!', 'GOODBYE!!!']
Puoi aggiungere un test if a destra del ciclo for per restringere i risultati. Se il test viene valutato per ogni elemento, inclusi solo gli elementi in cui il test è vero.
## Select values <= 2 nums = [2, 8, 1, 6] small = [ n for n in nums if n <= 2 ] ## [2, 1] ## Select fruits containing 'a', change to upper case fruits = ['apple', 'cherry', 'banana', 'lemon'] afruits = [ s.upper() for s in fruits if 'a' in s ] ## ['APPLE', 'BANANA']
Esercizio: list1.py
Per esercitarti con il materiale di questa sezione, prova i problemi successivi in list1.py che utilizzano l'ordinamento e le tuple (negli Esercizi di base).