Python Language
Tuple

Introduction

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

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')