Objets de référence de liste Python
>>> L1 = [1, 2]
>>> L2 = ['A', L1]
>>> L2
['A', [1, 2]]
>>> L1.append('three')
>>> L2
['A', [1, 2, 'three']]
#Pour élémentiser en tant qu'objet séparé au lieu d'une référence
>>> L1 = [1, 2]
>>> L2 = ['A', L1[:]]
>>> L2
['A', [1, 2]]
>>> L1.append('three')
>>> L2
['A', [1, 2]]
Inclusion de liste#1
#Traitement des listes comme celui-ci
src = ['SPAM', 'HAM', 'EGG']
dest = []
for val in src:
lowerer = val.lower()
dest.append(lowerer) #Faites le tout plus bas et plongez dans une autre liste
#Python peut être écrit comme ça. Facile.
src = ['SPAM', 'HAM', 'EGG']
dest = [val.lower() for val in src]
Il semble que la notation d'inclusion de liste soit plus rapide. Speed of Python list inclusion notation
Inclusion de liste#2
#Il est également possible de générer une liste en spécifiant une expression conditionnelle
>>> L = [1, 2, 3, 4, 5]
>>> [i for i in L if i % 2]
[1, 3, 5]
#Les éléments d'objets itérables peuvent également être décomposés et stockés
>>> L = [('a', 1), ('b', 2), ('c', 3)]
>>> [c * i for c, i in L]
['a', 'bb', 'ccc']
#Au début du nom de la variable*Si vous ajoutez, vous pouvez recevoir plusieurs éléments dans une liste
>>> L = [(1, 2), (3, 4, 5), (6, 7, 8, 9)]
>>> [first * sum(others) for first, *others in L]
[2, 27, 144]
#Plusieurs boucles sont également possibles
>>> years = [2019, 2020]
>>> months = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
>>> [(y, m) for y in years
... for m in months]
[(2019, 1), (2019, 2), (2019, 3), (2019, 4), (2019, 5), (2019, 6), (2019, 7), (2019, 8), (2019, 9), (2019, 10), (2019, 11), (2019, 12), (2020, 1), (2020, 2), (2020, 3), (2020, 4), (2020, 5), (2020, 6), (2020, 7), (2020, 8), (2020, 9), (2020, 10), (2020, 11), (2020, 12)]
Puisque la liste est un objet de type séquence, Les opérateurs tels que + (concaténation), * (répétition) et les opérateurs de comparaison sont pris en charge
Opérateur de liste
#Mise en relation
>>> [1, 2] + [3]
[1, 2, 3]
#répétition
#Si vous préparez une liste de longueur fixe à l'avance, cela ressemble à ceci
>>> L = [None] * 5
>>> L
[None, None, None, None, None]
De la séquence+Opérateurs et*L'opérateur copie simplement la référence
#Si vous souhaitez créer un objet liste avec plusieurs objets liste comme éléments
#J'ai l'impression de pouvoir écrire comme ça
>>> L = [[]] * 3
>>> L
[[], [], []]
#Mais non
>>> L[0].append(1)
>>> L
[[1], [1], [1]] #Tous les éléments sont des références au même objet
#Répertorier la notation d'inclusion à de tels moments
>>> L = [[] for i in range(3)]
>>> L[0].append('spam')
>>> L
[['spam'], [], []]
Énoncé d'affectation cumulative
#Pour les objets de liste, A= A +B et A+=B n'est pas équivalent!
>>> A = [0, 1, 2, 3]
>>> B = ['spam']
>>> id(A)
4429687688
>>> A = A + B
>>> A
[0, 1, 2, 3, 'spam']
>>> id(A)
4429687176 # A = A +En B, un nouvel objet de liste est affecté à A
>>> A = [0, 1, 2, 3]
>>> B = ['spam']
>>> id(A)
4429687688
>>> A += B
>>> A
[0, 1, 2, 3, 'spam']
>>> id(A)
4429687688 # A +=En B, tous les éléments de B sont ajoutés tels quels à l'objet liste indiqué par la variable A.
Vous n'êtes pas obligé de créer une méthode, mais écrivez-la dans le sens de l'essayer une fois.
Liste des méthodes ceci et cela
#Ajouter un élément
>>> A = [0, 1, 2, 3]
>>> A.append(4)
>>> A
[0, 1, 2, 3, 4]
#Cependant, si le nombre d'éléments est connu à l'avance, il est plus rapide d'utiliser la notation de substitution ou d'inclusion.
#référence:https://www.kumilog.net/entry/python-speed-comp
#Supprimer tous les éléments
>>> A = [0, 1, 2, 3]
>>> A.clear() # del A[:]Pareil que
>>> A
[]
#Créer un autre objet de liste avec les mêmes éléments
>>> A = [0, 1, 2, 3]
>>> id(A)
4429688712
>>> B = A.copy() # B = A[:]Pareil que
>>> B
[0, 1, 2, 3]
>>> id(B)
4430184776
#Renvoie le nombre d'éléments avec une valeur égale à l'argument
>>> A = [0, 1, 2, 1]
>>> A.count(1)
2
#Décomposer et ajouter tous les éléments d'un objet itérable
>>> A = [0, 1, 2]
>>> A.extend('spam')
>>> A
[0, 1, 2, 's', 'p', 'a', 'm']
>>> A[len(A):len(A)] = 'ham' #C'est pareil
>>> A
[0, 1, 2, 's', 'p', 'a', 'm', 'h', 'a', 'm']
#Recherche un élément avec une valeur égale à l'argument et renvoie l'index du premier élément correspondant
>>> A = [3, 4, 5, 3, 4, 5]
>>> A.index(4)
1
>>> A.index(4, 3) #La plage de recherche peut être spécifiée comme un argument à la manière de découper
4
>>> A.index(4, 3, 4) #Exception sinon
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 4 is not in list
#Ajouter un élément à la position spécifiée
>>> L = ['ham']
>>> L.insert(0, 'spam') # L[0:0] = ['spam']Pareil que
>>> L
['spam', 'ham']
>>> L.insert(-1, 'egg') #Ajouté à la position relative à partir de la fin
>>> L
['spam', 'egg', 'ham']
#Pop l'élément de fin (retourner sa valeur et supprimer l'élément)
>>> L = [0, 1, 2, 3]
>>> L.pop()
3
>>> L
[0, 1, 2]
>>> L.pop(1) #L'index peut être spécifié
1
>>> L
[0, 2]
#Rechercher des éléments avec la même valeur que l'argument et supprimer le premier élément correspondant
>>> L = [0, 1, 2, 3, 2]
>>> L.remove(2)
>>> L
[0, 1, 3, 2]
#Remplacez les éléments de la liste dans l'ordre inverse. Il ne crée pas de nouvel objet de liste.
>>> L = [0, 1, 2, 3]
>>> L.reverse()
>>> L
[3, 2, 1, 0]
#Triez les éléments de la liste. Ne créez pas un nouvel objet de liste. Les arguments ne concernent que les mots clés.
>>> L = ['9', '10', '100']
>>> L.sort()
>>> L
['10', '100', '9']
#Si une fonction est spécifiée pour la clé, la clé est appelée avec l'élément de liste comme argument et la valeur de retour est utilisée comme clé de tri.
>>> L.sort(key=int)
>>> L
['9', '10', '100']
#Tri décroissant
>>> L.sort(reverse=True)
>>> L
['9', '100', '10']
#Le tri en python est un "tri stable" (les éléments avec la même clé de tri ont le même contexte avant et après le tri)
>>> def func(v):return v % 3
...
>>> L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> L.sort(key=func)
>>> L
[3, 6, 9, 0, 1, 4, 7, 2, 5, 8] # 3,6,9 - 0,1,4,7 - 2,5,Le contexte de 8 n'a pas changé
Recommended Posts