Python Language
Tuple
Recherche…
Introduction
Un tuple est une liste de valeurs immuable. Les tuples sont l'un des types de collection les plus simples et les plus communs de Python et peuvent être créés avec l'opérateur virgule ( value = 1, 2, 3
).
Syntaxe
(1, a, "hello") # a doit être une variable
() # un tuple vide
(1) # un tuple à 1 élément.
(1)
n'est pas un tuple.1, 2, 3 # le tuple à 3 éléments (1, 2, 3)
Remarques
Les parenthèses ne sont nécessaires que pour les tuples vides ou lorsqu'ils sont utilisés dans un appel de fonction.
Un tuple est une séquence de valeurs. Les valeurs peuvent être de n'importe quel type, et elles sont indexées par des nombres entiers, de sorte que les n-uplets ressemblent beaucoup aux listes. La différence importante est que les tuples sont immuables et sont lavables, ils peuvent donc être utilisés dans des ensembles et des cartes.
Tuples d'indexation
x = (1, 2, 3)
x[0] # 1
x[1] # 2
x[2] # 3
x[3] # IndexError: tuple index out of range
L'indexation avec des nombres négatifs commencera à partir du dernier élément comme -1:
x[-1] # 3
x[-2] # 2
x[-3] # 1
x[-4] # IndexError: tuple index out of range
Indexer une gamme d'éléments
print(x[:-1]) # (1, 2)
print(x[-1:]) # (3,)
print(x[1:3]) # (2, 3)
Les tuples sont immuables
L'une des principales différences entre les list
s et les tuple
dans Python est que les tuples sont immuables, c'est-à-dire que l'on ne peut pas ajouter ou modifier des éléments une fois le tuple initialisé. Par exemple:
>>> t = (1, 4, 9)
>>> t[0] = 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
De même, les tuples n'ont pas de méthodes .append
et .extend
comme le fait la list
. Utiliser +=
est possible, mais cela change la liaison de la variable, et non le tuple lui-même:
>>> t = (1, 2)
>>> q = t
>>> t += (3, 4)
>>> t
(1, 2, 3, 4)
>>> q
(1, 2)
Soyez prudent lorsque vous placez des objets mutables, tels que des lists
, à l'intérieur de tuples. Cela peut conduire à des résultats très déroutants lors de leur modification. Par exemple:
>>> t = (1, 2, 3, [1, 2, 3])
(1, 2, 3, [1, 2, 3])
>>> t[3] += [4, 5]
Est-ce que les deux déclencheront une erreur et changeront le contenu de la liste dans le tuple:
TypeError: 'tuple' object does not support item assignment
>>> t
(1, 2, 3, [1, 2, 3, 4, 5])
Vous pouvez utiliser l'opérateur +=
pour "ajouter" à un tuple - cela fonctionne en créant un nouveau tuple avec le nouvel élément "ajouté" et l'assignez à sa variable actuelle; le vieux tuple n'est pas changé, mais remplacé!
Cela évite la conversion vers et depuis une liste, mais c'est lent et c'est une mauvaise pratique, surtout si vous allez ajouter plusieurs fois.
Le tuple est élémentaire et lavable
hash( (1, 2) ) # ok
hash( ([], {"hello"}) # not ok, since lists and sets are not hashabe
Ainsi, un tuple ne peut être placé dans un set
ou comme clé dans un dict
que si chacun de ses éléments le peut.
{ (1, 2) } # ok
{ ([], {"hello"}) ) # not ok
Tuple
Syntactiquement, un tuple est une liste de valeurs séparées par des virgules:
t = 'a', 'b', 'c', 'd', 'e'
Bien que cela ne soit pas nécessaire, il est courant de joindre des tuples entre parenthèses:
t = ('a', 'b', 'c', 'd', 'e')
Créez un nuplet vide avec des parenthèses:
t0 = ()
type(t0) # <type 'tuple'>
Pour créer un tuple avec un seul élément, vous devez inclure une virgule finale:
t1 = 'a',
type(t1) # <type 'tuple'>
Notez qu'une valeur unique entre parenthèses n'est pas un tuple:
t2 = ('a')
type(t2) # <type 'str'>
Pour créer un tuple singleton, il est nécessaire d'avoir une virgule de fin.
t2 = ('a',)
type(t2) # <type 'tuple'>
Notez que pour les tuples singleton, il est recommandé d'utiliser les parenthèses (voir PEP8 sur les virgules finales ). Aussi, pas d'espace blanc après la virgule de fin (voir PEP8 sur les espaces blancs )
t2 = ('a',) # PEP8-compliant
t2 = 'a', # this notation is not recommended by PEP8
t2 = ('a', ) # this notation is not recommended by PEP8
Une autre façon de créer un tuple est le tuple
fonction intégré.
t = tuple('lupins')
print(t) # ('l', 'u', 'p', 'i', 'n', 's')
t = tuple(range(3))
print(t) # (0, 1, 2)
Ces exemples sont basés sur le matériel du livre Think Python d'Allen B. Downey .
Emballage et déballage des tuples
Les tuples en Python sont des valeurs séparées par des virgules. La mise entre parenthèses pour la saisie de n-uplets est facultative, donc les deux affectations
a = 1, 2, 3 # a is the tuple (1, 2, 3)
et
a = (1, 2, 3) # a is the tuple (1, 2, 3)
sont équivalents. L'affectation a = 1, 2, 3
est également appelée " emballage" car elle regroupe les valeurs dans un tuple.
Notez qu'un tuple à une valeur est également un tuple. Pour dire à Python qu'une variable est un tuple et non une valeur unique, vous pouvez utiliser une virgule
a = 1 # a is the value 1
a = 1, # a is the tuple (1,)
Une virgule est également nécessaire si vous utilisez des parenthèses
a = (1,) # a is the tuple (1,)
a = (1) # a is the value 1 and not a tuple
Pour décompresser les valeurs d'un tuple et faire plusieurs affectations, utilisez
# unpacking AKA multiple assignment
x, y, z = (1, 2, 3)
# x == 1
# y == 2
# z == 3
Le symbole _
peut être utilisé comme un nom de variable jetable si l'on a seulement besoin de quelques éléments d'un tuple, agissant comme un espace réservé:
a = 1, 2, 3, 4
_, x, y, _ = a
# x == 2
# y == 3
Tuples à élément unique:
x, = 1, # x is the value 1
x = 1, # x is the tuple (1,)
Dans Python 3, une variable cible avec un préfixe *
peut être utilisée comme variable fourre-tout (voir Déballage d’itérables ):
first, *more, last = (1, 2, 3, 4, 5)
# first == 1
# more == [2, 3, 4]
# last == 5
Éléments d'inversion
Inverser les éléments dans un tuple
colors = "red", "green", "blue"
rev = colors[::-1]
# rev: ("blue", "green", "red")
colors = rev
# colors: ("blue", "green", "red")
Ou en utilisant inversé (inversé donne un itérable qui est converti en un tuple):
rev = tuple(reversed(colors))
# rev: ("blue", "green", "red")
colors = rev
# colors: ("blue", "green", "red")
Fonctions Tuple intégrées
Les tuples supportent les fonctions intégrées suivantes
Comparaison
Si les éléments sont du même type, python effectue la comparaison et renvoie le résultat. Si les éléments sont de types différents, il vérifie s'ils sont des nombres.
- Si les nombres, effectuez une comparaison.
- Si l'un des éléments est un nombre, l'autre élément est renvoyé.
- Sinon, les types sont triés par ordre alphabétique.
Si nous avons atteint la fin de l'une des listes, la liste la plus longue est "plus grande". Si les deux listes sont identiques, il renvoie 0.
tuple1 = ('a', 'b', 'c', 'd', 'e')
tuple2 = ('1','2','3')
tuple3 = ('a', 'b', 'c', 'd', 'e')
cmp(tuple1, tuple2)
Out: 1
cmp(tuple2, tuple1)
Out: -1
cmp(tuple1, tuple3)
Out: 0
Longueur de tuple
La fonction len
renvoie la longueur totale du tuple
len(tuple1)
Out: 5
Max d'un tuple
La fonction max
renvoie un élément du tuple avec la valeur maximale
max(tuple1)
Out: 'e'
max(tuple2)
Out: '3'
Min d'un tuple
La fonction min renvoie l'élément du tuple avec la valeur min
min(tuple1)
Out: 'a'
min(tuple2)
Out: '1'
Convertir une liste en tuple
Le tuple
fonction intégré convertit une liste en un tuple.
list = [1,2,3,4,5]
tuple(list)
Out: (1, 2, 3, 4, 5)
Concaténation tuple
Utilisez +
pour concaténer deux tuples
tuple1 + tuple2
Out: ('a', 'b', 'c', 'd', 'e', '1', '2', '3')