Accès par indice
>>> L = [0, 1, 2, 3, 4, 5]
>>> L[2]
2
#Si vous spécifiez une valeur négative comme index, il sera référencé à partir de la fin.
>>> L[-1] #L'index du dernier élément est-1
5
>>> L[-2]
4
#Exception si vous spécifiez un index en dehors de la plage
>>> L[6]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
tranche
#Obtenez tout à la fois en spécifiant une plage de valeurs d'index
>>> L = [0, 1, 2, 3, 4]
>>> L[1:4]
[1, 2, 3] #Créez un nouvel objet séquence avec les éléments jusqu'à celui précédant l'élément spécifié à la position finale
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[-5:-1] #Si la position de départ et la position de fin sont des valeurs négatives, la position sera spécifiée à partir de la fin.
[5, 6, 7, 8]
>>> L[-5:0] #Quand tu veux aller jusqu'au bout, pas comme ça
[]
>>> L[-5:] #comme ça
[5, 6, 7, 8, 9]
>>> L = [1, 2, 3]
>>> L[10:20] #Renvoie une séquence vide si vous spécifiez un index qui n'existe pas
[]
>>> L[1:1] #Les tranches de longueur nulle renvoient également une séquence vide
[]
>>> L[3:1] #Les tranches de longueur négative renvoient également une chaîne vide (elle indique une chaîne vide, mais c'est la même chose que ci-dessus....？）
[]
>>> L[0:10] #Si spécifié au-delà de la fin de l'élément, renvoie jusqu'au dernier élément
[1, 2, 3]
>>> L[-10:10] #Si spécifié au-delà du début de l'élément, retourne à partir du premier élément
[1, 2, 3]
Obtenir l'élément en spécifiant la valeur d'incrément
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[1:10:3] #Obtenu en sautant l'index 3 entre la position de départ et la position finale
[1, 4, 7]
#Si vous spécifiez une valeur négative comme valeur d'incrémentation, les éléments sont récupérés dans l'ordre inverse de l'arrière.
>>> L[8:2:-1]
[8, 7, 6, 5, 4, 3]
>>> L[10:1:-3]
[9, 6, 3]
Omission de la spécification de tranche
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[:5] #Omettre la position de départ (la position de départ est 0)
[0, 1, 2, 3, 4]
>>> L[0::2] #Omettre la position finale (la position finale est 10)
[0, 2, 4, 6, 8]
#Si la valeur d'incrément est négative
>>> L[:5:-1] #Omettre la position de départ (la position de départ est 10)
[9, 8, 7, 6]
>>> L[10::-2] #Omettre la position finale (la position finale est 0)
[9, 7, 5, 3, 1]
#Si la valeur d'incrément est omise, la valeur d'incrément est 1.
>>> L[2:5:]
[2, 3, 4]
>>> L[2:5] #Dernier:L'interprétation comme une forme qui omet. Je vois.
[2, 3, 4]
#Astuces d'omission
>>> L[::2]
[0, 2, 4, 6, 8]
>>> L[::-1]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
Objet Slice
#Opération de tranche[]Le contenu peut être créé en tant qu'objet de tranche (utile pour faire référence à une plage spécifique plusieurs fois)
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[slice(1, 10, 3)] # L[1:10:3]Pareil que
[1, 4, 7]
>>> L[slice(10)] # L[:10]Pareil que
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Substitution avec tranche
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[1:9] = ['spam', 'ham'] #Remplace les éléments de la plage de tranches, les longueurs ne doivent pas nécessairement correspondre
>>> L
[0, 'spam', 'ham', 9]
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[1:1] = ['spam', 'ham'] #Pour les tranches de longueur 0, ne supprimez pas les éléments de la liste d'origine (insertion uniquement)
>>> L
[0, 'spam', 'ham', 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[3:-3] = [] #Si le côté droit a une longueur de 0, supprimez l'élément de la liste d'origine
>>> L
[0, 1, 2, 7, 8, 9]
#Si vous spécifiez une valeur d'incrément autre que 1 pour la tranche, seul l'élément correspondant est remplacé par la valeur sur le côté droit. C'est cool.
>>> L = [0, 1, 2, 3, 4, 5, 6]
>>> L[1::2] = ['one', 'three', 'five']
>>> L
[0, 'one', 2, 'three', 4, 'five', 6]
#Ce n'est pas parce que le côté gauche est une liste que vous ne pouvez pas l'attribuer à moins qu'il ne s'agisse d'une liste.
#Tout objet itérable peut être affecté.
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[5:] = 'spam'
>>> L
[0, 1, 2, 3, 4, 's', 'p', 'a', 'm']
Instruction d'affectation cumulative
>>> L = [1, 2, 3]
>>> L[2] += 4
>>> L
[1, 2, 7]
>>> L = [0, 1, 2, 3]
>>> L[1:3] += ['spam', 'ham'] #Vous pouvez également spécifier une tranche sur le côté gauche
>>> L
[0, 1, 2, 'spam', 'ham', 3]
>>> L[3:5] *= 2 # L[3:5]À L[3:5]*Réglez 2.
>>> L
[0, 1, 2, 'spam', 'ham', 'spam', 'ham', 3]
Supprimer l'élément
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del L[1], L[2]
>>> L
[0, 2, 4, 5, 6, 7, 8, 9]
#Bien sûr, vous pouvez spécifier des tranches et des valeurs incrémentielles
>>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del L[::2]
>>> L
[1, 3, 5, 7, 9]
#La suppression d'un élément ne libère pas l'objet. Supprimez-le simplement de la séquence.
>>> L1 = [1, 2, 3]
>>> L2 = [L1]
>>> L2
[[1, 2, 3]]
>>> del L2[0]
>>> L2
[]
>>> L1 #L1 n'est pas supprimé
[1, 2, 3]
Opérateur de séquence
>>> [1, 2] + [3, 4] #Mise en relation
[1, 2, 3, 4]
>>> [1, 2] * 3 #Répéter pour le nombre de fois spécifié
[1, 2, 1, 2, 1, 2]
>>> 3 * [1, 2] #Idem même si l'ordre de calcul est modifié
[1, 2, 1, 2, 1, 2]
#L'opérateur de comparaison compare les éléments de la séquence depuis le début.
>>> [1, 2] < [3, 4]
True # (1 < 3) & (2 < 4)
#dans (il semble être appelé un opérateur d'appartenance)
>>> 'B' in ['A', 'B', 'C']
True
Recommended Posts