Indexeur Python 3 et décompression de séquence (substitution de déballage)

Dans Python 3, les indexeurs et déballage de séquence (substitution de décompression) sont utilisés pour diviser «tuple» et «list». ) Peut être utilisé. Ce dernier est le trait de soulignement habituel _ pour ignorer les variables (réutilisation de _) et astérisque * pour les affecter à la liste des éléments itérables restants. /ja/3/reference/simple_stmts.html#assignment-statements) est possible.

En plus de la décompression en tapples dans la documentation Python 3, la conversion en listes est également considérée comme une décompression si certains des éléments sur le côté gauche peuvent être utilisés comme variables dans le code.

[a, b] = 0, 1
#La formule ci-dessus est une conversion taple-to-list, mais l'élément de liste b peut être utilisé comme variable.
print(b)  # 1
b = 2
print(b)  # 2
print((a, b))  # (0, 2)

Conditions préalables

Types qui peuvent et ne peuvent pas utiliser les indexeurs

Les types qui peuvent être utilisés par l'indexeur sont les classes qui ont la méthode abstraite «index», et les types qui ne peuvent pas être utilisés sont les types qui n'ont pas le «index». Le premier a des types où les index sont significatifs, tels que "tuple" et "list", et le second sont des types où les index n'ont pas de sens, tels que "set" et "frozenset". L'utilisation d'un indexeur pour ce dernier entraînera une erreur TypeError.

tuple1 = (0, 1, 2)
t0 = tuple1[0]
print(0)  # 0
t0, t1, t2 = tuple1
print((t0, t1, t2))  # (0, 1, 2)

set1 = {0, 1, 2}
# s0 = set1[0]  # TypeError 'set' object is not subscriptable
# print(s0)
s0, s1, s2 = set1
print((s0, s1, s2))  # (0, 1, 2)

Les types avec «index» sont définis comme typing.SupportsIndex.

Types qui peuvent et ne peuvent pas utiliser le déballage de séquence (substitution de déballage)

Le type qui peut être utilisé pour décompresser la séquence est le type qui correspond à «sequence». C'est un type qui a des méthodes spéciales __getitem__ et des méthodes spéciales __len__, et de nombreux types tels que tuple, list et set sont applicables.

Types qui peuvent et ne peuvent pas utiliser les indexeurs et les décompresseurs de séquences

Les types qui peuvent être utilisés à la fois pour les indexeurs et les décompresseurs de séquences sont ceux avec «index», «getitem» et «len». «tuple» et «list» appartiennent à cette catégorie, mais pas «set» et «gelé».

Fractionnement de tuple

Puisque le précédent et le suivant (, ) peuvent être omis, dans le cas du côté gauche (destination de déballage) du nombre égal, il peut être écrit pour être divisé et remplacé.

Indexeur

t = ("a", "b", "c")
a = t[0]
b = t[1]
c = t[2]
print((a, b, c))  # ('a', 'b', 'c')

tuple → décompression de tuple

# tuple→tuple
a, b, c = "a", "b", "c"
print((a, b, c))  # ('a', 'b', 'c')

# tuple→tuple
a, b, c = ("a", "b", "c")
print((a, b, c))  # ('a', 'b', 'c')

# tuple→tuple
(a, b, c) = ("a", "b", "c")
print((a, b, c))  # ('a', 'b', 'c')

#Omission de variables inutiles
(_, b, _) = ("a", "b", "c")
print((_, b, _))  # ('c', 'b', 'c')

#Mettez le reste dans une liste
(a, *bc, _, e) = ("a", "b", "c", "d", "e")
print((a, bc, _, e))  # ('a', ['b', 'c'], 'd', 'e')

tuple → list unpack

# tuple→list
[a, b, c] = ("a", "b", "c")
print((a, b, c))  # ('a', 'b', 'c')

#Omission de variables inutiles
[_, b, _] = ("a", "b", "c")
print((_, b, _))  # ('c', 'b', 'c')

#Mettez le reste dans une liste
[a, *bc, _, e] = ("a", "b", "c", "d", "e")
print((a, bc, _, e))  # ('a', ['b', 'c'], 'd', 'e')

Division de la liste

Il peut être géré fondamentalement de la même manière que tuple. Cependant, les "[", "]" précédents et suivants ne peuvent pas être omis.

Indexeur

t = ["a", "b", "c"]
a = t[0]
b = t[1]
c = t[2]
print((a, b, c))  # ('a', 'b', 'c')

list → décompression de tuple

# list→tuple
a, b, c = ["a", "b", "c"]
print((a, b, c))  # ('a', 'b', 'c')

# list→tuple
(a, b, c) = ["a", "b", "c"]
print((a, b, c))  # ('a', 'b', 'c')

#Omission de variables inutiles
(_, b, _) = ["a", "b", "c"]
print((_, b, _))  # ('c', 'b', 'c')

#Mettez le reste dans une liste
(a, *bc, _, e) = ["a", "b", "c", "d", "e"]
print((a, bc, _, e))  # ('a', ['b', 'c'], 'd', 'e')

liste → liste décompresser

# list→list
[a, b, c] = ["a", "b", "c"]
print((a, b, c))  # ('a', 'b', 'c')

#Omission de variables inutiles
[_, b, _] = ["a", "b", "c"]
print((_, b, _))  # ('c', 'b', 'c')

#Mettez le reste dans une liste
[a, *bc, _, e] = ["a", "b", "c", "d", "e"]
print((a, bc, _, e))  # ('a', ['b', 'c'], 'd', 'e')

Division de set

L'indexeur n'est pas pris en charge. Lors du déballage dans un robinet ou une liste, la commande n'est pas garantie.

déballage de l'ensemble

# set→tuple
#La commande n'est pas garantie.
a, b, c = {"a", "b", "c"}
print((a, b, c))  # ('a', 'b', 'c')L'une des sortes de

# set→list
#La commande n'est pas garantie.
[a, b, c] = {"a", "b", "c"}
print((a, b, c))  # ('a', 'b', 'c')L'une des sortes de

#set → set (impossible)
# {a, b, c} = {"a", "b", "c"}
# print((a, b, c))  # ('a', 'c', 'b')

Exemple

• Application de Python 3 vars