Python Language
Elenco

introduzione

Sintassi

• [valore, valore, ...]
• lista ([iterable])

Osservazioni

Accedere ai valori di lista

Gli elenchi Python sono indicizzati a zero e si comportano come matrici in altre lingue.

lst = [1, 2, 3, 4]
lst[0]  # 1
lst[1]  # 2

Il tentativo di accedere a un indice al di fuori dei limiti dell'elenco IndexError un IndexError .

lst[4]  # IndexError: list index out of range

Gli indici negativi sono interpretati come conteggi dalla fine della lista.

lst[-1]  # 4
lst[-2]  # 3
lst[-5]  # IndexError: list index out of range

Questo è funzionalmente equivalente a

lst[len(lst)-1]  # 4

Gli elenchi consentono di utilizzare la notazione delle lst[start:end:step] come lst[start:end:step] . L'output della notazione di sezione è un nuovo elenco contenente elementi dall'indice start a end-1 . Se le opzioni vengono omessi start default è all'inizio della lista, end alla fine della lista e step a 1:

lst[1:]      # [2, 3, 4]
lst[:3]      # [1, 2, 3]
lst[::2]     # [1, 3]
lst[::-1]    # [4, 3, 2, 1] 
lst[-1:0:-1] # [4, 3, 2]
lst[5:8]     # [] since starting index is greater than length of lst, returns empty list
lst[1:10]    # [2, 3, 4] same as omitting ending index

Con questo in mente, puoi stampare una versione invertita della lista chiamando

lst[::-1]    # [4, 3, 2, 1]

Quando si utilizzano lunghezze di passi di importi negativi, l'indice di partenza deve essere maggiore dell'indice finale altrimenti il ​​risultato sarà una lista vuota.

lst[3:1:-1] # [4, 3]

L'utilizzo degli indici step negativi è equivalente al seguente codice:

reversed(lst)[0:2] # 0 = 1 -1
                   # 2 = 3 -1

Gli indici utilizzati sono 1 in meno di quelli utilizzati nell'indicizzazione negativa e sono invertiti.

Affettatura avanzata

Quando gli elenchi vengono __getitem__() viene chiamato il metodo __getitem__() dell'oggetto elenco, con un oggetto slice . Python ha un metodo slice incorporato per generare oggetti slice. Possiamo usarlo per memorizzare una sezione e riutilizzarla in un secondo momento in questo modo,

data = 'chandan purohit    22 2000'  #assuming data fields of fixed length 
name_slice = slice(0,19)
age_slice = slice(19,21)
salary_slice = slice(22,None)

#now we can have more readable slices
print(data[name_slice]) #chandan purohit     
print(data[age_slice]) #'22'
print(data[salary_slice]) #'2000'

Questo può essere di grande utilità fornendo funzionalità di slicing ai nostri oggetti sovrascrivendo __getitem__ nella nostra classe.

Elenca metodi e operatori supportati

A partire da una lista data a :

a = [1, 2, 3, 4, 5]

1. append(value) - aggiunge un nuovo elemento alla fine dell'elenco.

   # Append values 6, 7, and 7 to the list
   a.append(6)
   a.append(7)
   a.append(7)
   # a: [1, 2, 3, 4, 5, 6, 7, 7]
   
   # Append another list
   b = [8, 9]
   a.append(b)
   # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]
   
   # Append an element of a different type, as list elements do not need to have the same type
   my_string = "hello world"
   a.append(my_string)
   # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9], "hello world"]
   

   Si noti che il metodo append() aggiunge solo un nuovo elemento alla fine dell'elenco. Se si aggiunge un elenco a un altro elenco, l'elenco che si aggiunge diventa un singolo elemento alla fine del primo elenco.

   # Appending a list to another list
   a = [1, 2, 3, 4, 5, 6, 7, 7]
   b = [8, 9]
   a.append(b)
   # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]
   a[8]
   # Returns: [8,9]
   

2. extend(enumerable) : estende l'elenco aggiungendo elementi da un'altra enumerabile.

   a = [1, 2, 3, 4, 5, 6, 7, 7]
   b = [8, 9, 10]
   
   # Extend list by appending all elements from b
   a.extend(b)
   # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
   
   # Extend list with elements from a non-list enumerable:
   a.extend(range(3))
   # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10, 0, 1, 2]
   

   Gli elenchi possono anche essere concatenati con l'operatore + . Nota che questo non modifica nessuno degli elenchi originali:

   a = [1, 2, 3, 4, 5, 6] + [7, 7] + b
   # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
   

3. index(value, [startIndex]) - ottiene l'indice della prima occorrenza del valore di input. Se il valore di input non è presente nell'elenco, viene sollevata un'eccezione ValueError . Se viene fornito un secondo argomento, la ricerca viene avviata a quell'indice specificato.

   a.index(7)
   # Returns: 6
   
   a.index(49) # ValueError, because 49 is not in a.
   
   a.index(7, 7)
   # Returns: 7
   
   a.index(7, 8) # ValueError, because there is no 7 starting at index 8
   

4. insert(index, value) - inserisce il value appena prima index specificato. Quindi, dopo l'inserimento, il nuovo elemento occupa l' index posizione.

   a.insert(0, 0)  # insert 0 at position 0
   a.insert(2, 5)  # insert 5 at position 2
   # a: [0, 1, 5, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
   

5. pop([index]) - rimuove e restituisce l'oggetto index . Senza argomenti rimuove e restituisce l'ultimo elemento della lista.

   a.pop(2)
   # Returns: 5
   # a: [0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
   a.pop(8)
   # Returns: 7
   # a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   
   # With no argument:
   a.pop()
   # Returns: 10
   # a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
   

6. remove(value) - rimuove la prima occorrenza del valore specificato. Se il valore fornito non può essere trovato, viene sollevata ValueError .

   a.remove(0)
   a.remove(9)
   # a: [1, 2, 3, 4, 5, 6, 7, 8]
   a.remove(10)
   # ValueError, because 10 is not in a
   

7. reverse() - inverte l'elenco sul posto e restituisce None .

   a.reverse()
   # a: [8, 7, 6, 5, 4, 3, 2, 1]
   

   Ci sono anche altri modi per invertire una lista .

8. count(value) : conta il numero di occorrenze di alcuni valori nell'elenco.

   a.count(7)
   # Returns: 2
   

9. sort() - ordina l'elenco in ordine numerico e lessicografico e restituisce None .

   a.sort()
   # a = [1, 2, 3, 4, 5, 6, 7, 8]
   # Sorts the list in numerical order
   

   Le liste possono anche essere invertite se ordinate usando il reverse=True flag nel metodo sort() .

   a.sort(reverse=True)
   # a = [8, 7, 6, 5, 4, 3, 2, 1]
   

   Se si desidera ordinare per attributi di elementi, è possibile utilizzare l'argomento della parola key :

   import datetime
   
   class Person(object):
       def __init__(self, name, birthday, height):
           self.name = name
           self.birthday = birthday
           self.height = height
   
       def __repr__(self):
           return self.name
   
   l = [Person("John Cena", datetime.date(1992, 9, 12), 175),
        Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
        Person("Jon Skeet", datetime.date(1991, 7, 6), 185)]
   
   l.sort(key=lambda item: item.name)
   # l: [Chuck Norris, John Cena, Jon Skeet]
   
   l.sort(key=lambda item: item.birthday)
   # l: [Chuck Norris, Jon Skeet, John Cena]
   
   l.sort(key=lambda item: item.height)
   # l: [John Cena, Chuck Norris, Jon Skeet]
   

   In caso di lista di dicts il concetto è lo stesso:

   import datetime
   
   l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'height': 175},
    {'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'height': 180},
    {'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'height': 185}]
   
   l.sort(key=lambda item: item['name'])
   # l: [Chuck Norris, John Cena, Jon Skeet]
   
   l.sort(key=lambda item: item['birthday'])
   # l: [Chuck Norris, Jon Skeet, John Cena]
   
   l.sort(key=lambda item: item['height'])
   # l: [John Cena, Chuck Norris, Jon Skeet]
   

   Ordina per sottotit:

   import datetime
   
   l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'size': {'height': 175, 'weight': 100}},
    {'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'size' : {'height': 180, 'weight': 90}},
    {'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'size': {'height': 185, 'weight': 110}}]
   
   l.sort(key=lambda item: item['size']['height'])
   # l: [John Cena, Chuck Norris, Jon Skeet]
   

Un modo migliore per ordinare usando attrgetter e itemgetter

Le liste possono anche essere ordinate usando le funzioni attrgetter e itemgetter dal modulo operatore. Questi possono aiutare a migliorare la leggibilità e la riusabilità. Ecco alcuni esempi,

from operator import itemgetter,attrgetter

people = [{'name':'chandan','age':20,'salary':2000},
          {'name':'chetan','age':18,'salary':5000},
          {'name':'guru','age':30,'salary':3000}]
by_age = itemgetter('age')
by_salary = itemgetter('salary')

people.sort(key=by_age) #in-place sorting by age
people.sort(key=by_salary) #in-place sorting by salary

itemgetter può anche avere un indice. Questo è utile se vuoi ordinare in base agli indici di una tupla.

list_of_tuples = [(1,2), (3,4), (5,0)]
list_of_tuples.sort(key=itemgetter(1))
print(list_of_tuples) #[(5, 0), (1, 2), (3, 4)]

Utilizzare l' attrgetter se si desidera ordinare per attributi di un oggetto,

persons = [Person("John Cena", datetime.date(1992, 9, 12), 175),
           Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
           Person("Jon Skeet", datetime.date(1991, 7, 6), 185)] #reusing Person class from above example

person.sort(key=attrgetter('name')) #sort by name
by_birthday = attrgetter('birthday')
person.sort(key=by_birthday) #sort by birthday

10. clear() - rimuove tutti gli elementi dall'elenco

    a.clear()
    # a = []
    

11. Replicazione : moltiplicando una lista esistente per un intero, si otterrà una lista più ampia consistente in tante copie dell'originale. Questo può essere utile ad esempio per l'inizializzazione della lista:

    b = ["blah"] * 3
    # b = ["blah", "blah", "blah"]
    b = [1, 3, 5] * 5
    # [1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5]
    

    Fai attenzione a questo se il tuo elenco contiene riferimenti ad oggetti (ad esempio un elenco di elenchi), vedi Errori comuni - Moltiplicazione elenco e riferimenti comuni .

12. Cancellazione elemento : è possibile eliminare più elementi nell'elenco utilizzando la parola chiave del e la notazione di sezione:

    a = list(range(10))
    del a[::2]
    # a = [1, 3, 5, 7, 9]
    del a[-1]
    # a = [1, 3, 5, 7]
    del a[:]
    # a = []
    

13. copiatura

    L'assegnazione di default "=" assegna un riferimento della lista originale al nuovo nome. Cioè, il nome originale e il nuovo nome puntano entrambi allo stesso oggetto elenco. Le modifiche apportate tramite una di esse si rifletteranno in un'altra. Questo spesso non è ciò che intendevi.

    b = a
    a.append(6)
    # b: [1, 2, 3, 4, 5, 6]
    

    Se vuoi creare una copia della lista hai sotto le opzioni.

    Puoi tagliarlo:

    new_list = old_list[:]
    

    Puoi usare la funzione built-in list ():

    new_list = list(old_list)
    

    Puoi usare generici copy.copy ():

    import copy
    new_list = copy.copy(old_list) #inserts references to the objects found in the original.
    

    Questo è un po 'più lento di list () perché deve prima trovare il datatype di old_list.

    Se la lista contiene oggetti e vuoi copiarli, usa generico copy.deepcopy ():

    import copy
    new_list = copy.deepcopy(old_list) #inserts copies of the objects found in the original.
    

    Ovviamente il metodo più lento e che richiede più memoria, ma a volte inevitabile.

    aa = a.copy()
    # aa = [1, 2, 3, 4, 5]

Lunghezza di una lista

Usa len() per ottenere la lunghezza unidimensionale di una lista.

len(['one', 'two'])  # returns 2

len(['one', [2, 3], 'four'])  # returns 3, not 4

len() funziona anche su stringhe, dizionari e altre strutture di dati simili alle liste.

Nota che len() è una funzione built-in, non un metodo di un oggetto lista.

Si noti inoltre che il costo di len() è O(1) , il che significa che richiederà la stessa quantità di tempo per ottenere la lunghezza di un elenco indipendentemente dalla sua lunghezza.

Iterare su una lista

Python supporta l'uso di un ciclo for direttamente su un elenco:

my_list = ['foo', 'bar', 'baz']
for item in my_list:
    print(item)

# Output: foo
# Output: bar
# Output: baz

Puoi anche ottenere la posizione di ogni oggetto allo stesso tempo:

for (index, item) in enumerate(my_list):
    print('The item in position {} is: {}'.format(index, item))
 
# Output: The item in position 0 is: foo
# Output: The item in position 1 is: bar
# Output: The item in position 2 is: baz

L'altro modo di iterare un elenco in base al valore dell'indice:

for i in range(0,len(my_list)):
    print(my_list[i])
#output:
>>>
foo
bar
baz

Tieni presente che la modifica di elementi in un elenco durante l'iterazione potrebbe avere risultati imprevisti:

for item in my_list:
    if item == 'foo':
        del my_list[0]
    print(item)

# Output: foo
# Output: baz

In questo ultimo esempio, abbiamo cancellato il primo elemento alla prima iterazione, ma quello ha causato l' bar della bar .

Verifica se un elemento è in una lista

Python rende molto semplice controllare se un elemento è in una lista. Basta usare l' in dell'operatore.

lst = ['test', 'twest', 'tweast', 'treast']

'test' in lst
# Out: True

'toast' in lst
# Out: False

Nota: l' in operatore insiemi è asintoticamente più veloce che su liste. Se è necessario utilizzarlo più volte su elenchi potenzialmente di grandi dimensioni, è possibile convertire l' list in un set e verificare la presenza di elementi sul set .

slst = set(lst)
'test' in slst
# Out: True

Invertire gli elementi dell'elenco

È possibile utilizzare la funzione reversed che restituisce un iteratore all'elenco invertito:

In [3]: rev = reversed(numbers)

In [4]: rev
Out[4]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

Si noti che l'elenco "numeri" rimane invariato per questa operazione e rimane nello stesso ordine in cui era originariamente.

Per invertire la posizione, puoi anche utilizzare il metodo reverse .

È anche possibile invertire una lista (ottenendo effettivamente una copia, l'elenco originale non viene modificato) utilizzando la sintassi slicing, impostando il terzo argomento (il passo) come -1:

In [1]: numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

In [2]: numbers[::-1]
Out[2]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

Verifica se l'elenco è vuoto

Il vuoto di una lista è associato al False booleano, quindi non è necessario controllare len(lst) == 0 , ma solo lst o not lst

lst = []
if not lst:
    print("list is empty")

# Output: list is empty

Concatena e Unisci elenchi

1. Il modo più semplice per concatenare list1 e list2 :

   merged = list1 + list2
   

2. zip restituisce un elenco di tuple , in cui l'i-esima tupla contiene l'elemento i-esimo da ciascuna delle sequenze di argomenti o iterabili:

   alist = ['a1', 'a2', 'a3']
   blist = ['b1', 'b2', 'b3']
   
   for a, b in zip(alist, blist):
       print(a, b)
    
   # Output:
   # a1 b1
   # a2 b2
   # a3 b3
   

   Se gli elenchi hanno lunghezze diverse, il risultato includerà solo tanti elementi come il più breve:

   alist = ['a1', 'a2', 'a3']
   blist = ['b1', 'b2', 'b3', 'b4']
   for a, b in zip(alist, blist):
       print(a, b)
   
   # Output:
   # a1 b1
   # a2 b2
   # a3 b3
   
   alist = []
   len(list(zip(alist, blist)))
   
   # Output:
   # 0
   

   Per gli elenchi di riempimento di lunghezza non uguale a quella più lunga con None s usa itertools.zip_longest ( itertools.izip_longest in Python 2)

   alist = ['a1', 'a2', 'a3']
   blist = ['b1']
   clist = ['c1', 'c2', 'c3', 'c4']
   
   for a,b,c in itertools.zip_longest(alist, blist, clist):
       print(a, b, c)
   
   # Output: 
   # a1 b1 c1
   # a2 None c2
   # a3 None c3
   # None None c4
   

3. Inserisci a valori di indice specifici:

    alist = [123, 'xyz', 'zara', 'abc']
    alist.insert(3, [2009])
    print("Final List :", alist)
   

   Produzione:

    Final List : [123, 'xyz', 'zara', 2009, 'abc']
   

Ogni e qualsiasi

Puoi usare all() per determinare se tutti i valori in un iterabile valgono su True

nums = [1, 1, 0, 1]
all(nums)
# False
chars = ['a', 'b', 'c', 'd']
all(chars)
# True

Allo stesso modo, any() determina se uno o più valori in un iterabile valutano True

nums = [1, 1, 0, 1]
any(nums)
# True
vals = [None, None, None, False]
any(vals)
# False

Mentre questo esempio utilizza un elenco, è importante notare che questi lavori integrati funzionano con qualsiasi iterabile, inclusi i generatori.

vals = [1, 2, 3, 4]
any(val > 12 for val in vals)
# False
any((val * 2) > 6 for val in vals)
# True

Rimuovi i valori duplicati nella lista

La rimozione di valori duplicati in un elenco può essere effettuata convertendo l'elenco in un set (ovvero una raccolta non ordinata di oggetti distinti). Se è necessaria una struttura di dati list , il set può essere riconvertito in un elenco utilizzando la funzione list() :

names = ["aixk", "duke", "edik", "tofp", "duke"]
list(set(names))
# Out: ['duke', 'tofp', 'aixk', 'edik']

Si noti che convertendo una lista in un set si perde l'ordinamento originale.

Per preservare l'ordine della lista si può usare OrderedDict

import collections
>>> collections.OrderedDict.fromkeys(names).keys()
# Out: ['aixk', 'duke', 'edik', 'tofp']

Accesso ai valori nell'elenco nidificato

A partire da un elenco tridimensionale:

alist = [[[1,2],[3,4]], [[5,6,7],[8,9,10], [12, 13, 14]]]

Accedere agli elementi nell'elenco:

print(alist[0][0][1])
#2
#Accesses second element in the first list in the first list

print(alist[1][1][2])
#10
#Accesses the third element in the second list in the second list

Esecuzione delle operazioni di supporto:

alist[0][0].append(11)
print(alist[0][0][2])
#11
#Appends 11 to the end of the first list in the first list

Usando i cicli annidati per stampare l'elenco:

for row in alist: #One way to loop through nested lists
    for col in row:
        print(col)
#[1, 2, 11]
#[3, 4]
#[5, 6, 7]
#[8, 9, 10]
#[12, 13, 14]

Si noti che questa operazione può essere utilizzata in una comprensione di lista o anche come generatore per produrre efficienze, ad esempio:

[col for row in alist for col in row]
#[[1, 2, 11], [3, 4], [5, 6, 7], [8, 9, 10], [12, 13, 14]]

Non tutti gli elementi negli elenchi esterni devono essere elenchi stessi:

alist[1].insert(2, 15)
#Inserts 15 into the third position in the second list

Un altro modo di usare nested for loops. L'altro modo è migliore, ma ho avuto bisogno di usarlo occasionalmente:

for row in range(len(alist)): #A less Pythonic way to loop through lists
    for col in range(len(alist[row])):
       print(alist[row][col])

#[1, 2, 11]
#[3, 4]
#[5, 6, 7]
#[8, 9, 10]
#15
#[12, 13, 14]

Utilizzo delle sezioni nell'elenco nidificato:

print(alist[1][1:])
#[[8, 9, 10], 15, [12, 13, 14]]
#Slices still work

L'elenco finale:

print(alist)
#[[[1, 2, 11], [3, 4]], [[5, 6, 7], [8, 9, 10], 15, [12, 13, 14]]]

Confronto di liste

È possibile confrontare le liste e le altre sequenze lessicograficamente utilizzando operatori di confronto. Entrambi gli operandi devono essere dello stesso tipo.

[1, 10, 100] < [2, 10, 100]
# True, because 1 < 2
[1, 10, 100] < [1, 10, 100]
# False, because the lists are equal
[1, 10, 100] <= [1, 10, 100]
# True, because the lists are equal
[1, 10, 100] < [1, 10, 101]
# True, because 100 < 101
[1, 10, 100] < [0, 10, 100]
# False, because 0 < 1

Se una delle liste è contenuta all'inizio dell'altra, vince la lista più corta.

[1, 10] < [1, 10, 100]
# True

Inizializzazione di un elenco su un numero fisso di elementi

Per elementi immutabili (ad es. None , stringhe letterali ecc.):

my_list = [None] * 10
my_list = ['test'] * 10

Per gli elementi mutabili , lo stesso costrutto genererà tutti gli elementi della lista che si riferiscono allo stesso oggetto, ad esempio, per un insieme:

>>> my_list=[{1}] * 10
>>> print(my_list)
[{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}]
>>> my_list[0].add(2)
>>> print(my_list)
[{1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}]

Invece, per inizializzare la lista con un numero fisso di diversi oggetti mutabili , usa:

my_list=[{1} for _ in range(10)]