A quoi sert un tuple ?

Question

J'apprends Python pour un cours maintenant, et nous venons de couvrir les tuples comme l'un des types de données.J'ai lu la page Wikipédia à ce sujet, mais je n'arrivais pas à comprendre où un tel type de données serait utile dans la pratique.Puis-je avoir quelques exemples, peut-être en Python, où un ensemble de nombres immuables serait nécessaire ?En quoi est-ce différent d’une liste ?

Answer 1

• Les tuples sont utilisés chaque fois que vous souhaitez renvoyer plusieurs résultats d'une fonction.
• Comme ils sont immuables, ils peuvent être utilisés comme clés pour un dictionnaire (les listes ne le peuvent pas).

Answer 2

Les tuples constituent de bonnes clés de dictionnaire lorsque vous devez combiner plusieurs éléments de données dans votre clé et que vous n'avez pas envie de créer une classe pour celle-ci.

a = {}
a[(1,2,"bob")] = "hello!"
a[("Hello","en-US")] = "Hi There!"

J'ai utilisé cette fonctionnalité principalement pour créer un dictionnaire avec des clés qui sont les coordonnées des sommets d'un maillage.Cependant, dans mon cas particulier, la comparaison exacte des flottants impliqués a bien fonctionné, ce qui n'est peut-être pas toujours vrai pour vos besoins [auquel cas je convertirais probablement vos flottants entrants en une sorte d'entier à virgule fixe]

Answer 3

J'aime cette explication.

Fondamentalement, vous devez utiliser des tuples lorsqu'il existe une structure constante (la 1ère position contient toujours un type de valeur et la seconde un autre, et ainsi de suite), et les listes doivent être utilisées pour les listes de valeurs homogènes.

Bien sûr, il y a toujours des exceptions, mais ceci constitue une bonne ligne directrice générale.

Answer 4

Les tuples et les listes ont les mêmes utilisations en général.Les types de données immuables présentent en général de nombreux avantages, principalement en matière de problèmes de concurrence.

Ainsi, lorsque vous avez des listes qui ne sont pas volatiles par nature et que vous devez garantir qu'aucun consommateur ne les modifie, vous pouvez utiliser un tuple.

Des exemples typiques sont les données fixes dans une application comme les divisions de l'entreprise, les catégories, etc.Si ces données changent, généralement un seul producteur reconstruit le tuple.

Answer 5

La meilleure façon d’y penser est :

• Un tuple est un enregistrer dont les champs n'ont pas de noms.
• Vous utilisez un tuple au lieu d'un enregistrement lorsque vous ne pouvez pas prendre la peine de spécifier les noms de champs.

Donc au lieu d'écrire des choses comme :

person = {"name": "Sam", "age": 42}
name, age = person["name"], person["age"]

Ou le plus verbeux encore :

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Sam", 42)
name, age = person.name, person.age

Vous pouvez simplement écrire :

person = ("Sam", 42)
name, age = person

Ceci est utile lorsque vous souhaitez transmettre un enregistrement contenant seulement quelques champs ou un enregistrement qui n'est utilisé qu'à quelques endroits.Dans ce cas, spécifier un tout nouveau type d'enregistrement avec des noms de champs (en Python, vous utiliseriez un objet ou un dictionnaire, comme ci-dessus) pourrait être trop verbeux.

Les tuples proviennent du monde de la programmation fonctionnelle (Haskell, OCaml, Elm, F#, etc.), où ils sont couramment utilisés à cette fin.Contrairement à Python, la plupart des langages de programmation fonctionnels sont typés de manière statique (une variable ne peut contenir qu'un seul type de valeur, et ce type est déterminé au moment de la compilation).Le typage statique rend le rôle des tuples plus évident.Par exemple, dans le langage Elm :

type alias Person = (String, Int)

person : Person
person = ("Sam", 42)

Cela met en évidence le fait qu’un type particulier de tuple est toujours censé avoir un nombre fixe de champs dans un ordre fixe, et que chacun de ces champs est toujours censé être du même type.Dans cet exemple, une personne est toujours un tuple de deux champs, l'un est une chaîne et l'autre est un entier.

Ce qui précède contraste fortement avec les listes, qui sont censés être de longueur variable (le nombre d'éléments est normalement différent dans chaque liste et vous écrivez des fonctions pour ajouter et supprimer des éléments) et chaque élément de la liste est normalement du même type.Par exemple, vous auriez une liste de personnes et une autre liste d’adresses – vous ne mélangeriez pas les personnes et les adresses dans la même liste.Alors que mélanger différents types de données dans un même tuple est tout l’intérêt des tuples.Les champs d'un tuple sont généralement de types différents (mais pas toujours - par ex.tu pourrais avoir un (Float, Float, Float) tuple pour représenter les coordonnées x, y, z).

Les tuples et les listes sont souvent imbriqués. Il est courant d'avoir une liste de tuples.Vous pouvez avoir une liste de tuples Personne ainsi qu'une liste d'objets Personne.Vous pouvez également avoir un champ tuple dont la valeur est une liste.Par exemple, si vous disposez d'un carnet d'adresses dans lequel une personne peut avoir plusieurs adresses, vous pourriez avoir un tuple du type (Person, [String]).Le [String] le type est couramment utilisé dans les langages de programmation fonctionnels pour désigner une liste de chaînes.En Python, vous n'écririez pas le type, mais vous pourriez utiliser des tuples comme celui-ci exactement de la même manière, en mettant un Person objet dans le premier champ d'un tuple et une liste de chaînes dans son deuxième champ.

En Python, la confusion surgit parce que la langue ne imposer l'une de ces pratiques appliquées par le compilateur dans les langages fonctionnels typés statiquement.Dans ces langues, vous ne pouvez pas mélanger différents types de tuples.Par exemple, vous ne pouvez pas renvoyer un (String, String) tuple d'une fonction dont le type indique qu'elle renvoie un (String, Integer) tuple.Vous ne pouvez pas non plus renvoyer une liste lorsque le type indique que vous envisagez de renvoyer un tuple, et vice versa.Les listes sont utilisées uniquement pour les collections croissantes d'éléments, et les tuples uniquement pour les enregistrements de taille fixe.Python ne vous empêche pas d'enfreindre l'une de ces règles si vous le souhaitez.

En Python, une liste est parfois convertie en tuple pour être utilisée comme clé de dictionnaire, car les clés du dictionnaire Python doivent être immuables (c'est-à-direconstante), alors que les listes Python sont mutables (vous pouvez ajouter et supprimer des éléments à tout moment).Il s'agit d'une solution de contournement pour une limitation particulière de Python, et non d'une propriété des tuples en tant que concept informatique.

Ainsi, en Python, les listes sont mutables et les tuples sont immuables.Mais il ne s’agit que d’un choix de conception, et non d’une propriété intrinsèque des listes et des tuples en informatique.Vous pourriez tout aussi bien avoir des listes immuables et des tuples mutables.

En Python (en utilisant l'implémentation CPython par défaut), les tuples sont également plus rapides que les objets ou les dictionnaires dans la plupart des cas, ils sont donc parfois utilisés pour cette raison, même lorsque nommer les champs à l'aide d'un objet ou d'un dictionnaire serait plus clair.

Enfin, pour rendre encore plus évident le fait que les tuples sont destinés à être un autre type d'enregistrement (et non un autre type de liste), Python a également tuples nommés:

from collections import namedtuple

Person = namedtuple("Person", "name age")

person = Person("Sam", 42)
name, age = person.name, person.age

C'est souvent le meilleur choix - plus court que la définition d'une nouvelle classe, mais la signification des champs est plus évidente que lors de l'utilisation de tuples normaux dont les champs n'ont pas de nom.

Les listes immuables sont très utiles à de nombreuses fins, mais le sujet est beaucoup trop complexe pour y répondre ici.Le point principal est que les choses qui ne peuvent pas changer sont plus faciles à raisonner que les choses qui peuvent changer.La plupart des bogues logiciels proviennent de changements inattendus, donc restreindre la manière dont ils peuvent changer est un bon moyen d'éliminer les bogues.Si vous êtes intéressé, je vous recommande de lire un tutoriel pour un langage de programmation fonctionnel tel que Elm, Haskell ou Clojure (Elm est le plus convivial).Les concepteurs de ces langages considéraient l'immuabilité si utile que tous les listes y sont immuables.(Au lieu de modifier une liste pour ajouter et/ou supprimer un élément, vous créer une nouvelle liste avec l'élément ajouté ou supprimé.L'immuabilité garantit que l'ancienne copie de la liste ne pourra jamais changer, de sorte que le compilateur et le runtime peuvent rendre le code performant en réutilisant des parties de l'ancienne liste dans la nouvelle et en ramassant les parties restantes lorsqu'elles sont plus longues. nécessaire.)

Answer 6

Je les trouve utiles lorsque vous traitez toujours deux objets ou plus comme un ensemble.

Answer 7

Un tuple est une séquence de valeurs.Les valeurs peuvent être de n'importe quel type et elles sont indexées par nombre entier, les tuples ne sont donc pas comme des listes.La différence la plus importante est que les tuples sont immuables.

Un tuple est une liste de valeurs séparées par des virgules :

t = 'p', 'q', 'r', 's', 't'

c'est une bonne pratique de mettre les tuples entre parenthèses :

t = ('p', 'q', 'r', 's', 't') 

Answer 8

Une liste peut toujours remplacer un tuple, en termes de fonctionnalité (sauf, apparemment, en tant que clés dans un dict).Cependant, un tuple peut accélérer les choses.La même chose est vraie, par exemple, pour les chaînes immuables en Java : quand devrez-vous un jour être incapable de modifier vos chaînes ?Jamais!

Je viens de lire une discussion décente sur la limitation de ce que vous pouvez faire afin de créer de meilleurs programmes ; Pourquoi Pourquoi la programmation fonctionnelle est importante

Answer 9

Un tuple est utile pour stocker plusieurs valeurs.Comme vous le remarquez, un tuple est comme une liste immuable - par ex.une fois créé, vous ne pouvez pas ajouter/supprimer/échanger des éléments.

L'un des avantages d'être immuable est que, comme le tuple est de taille fixe, il permet au moteur d'exécution d'effectuer certaines optimisations.Ceci est particulièrement avantageux lorsqu'un tuple est utilisé dans le contexte d'une valeur de retour ou d'un paramètre d'une fonction.

Answer 10

En plus des endroits où ils sont syntaxiquement requis, comme l'opération string % et pour plusieurs valeurs de retour, j'utilise les tuples comme forme de classes légères.Par exemple, supposons que vous ayez un objet qui transmet un cookie opaque à un appelant à partir d'une méthode, qui est ensuite transmis à une autre méthode.Un tuple est un bon moyen de regrouper plusieurs valeurs dans ce cookie sans avoir à définir une classe distincte pour les contenir.

J'essaie cependant d'être judicieux quant à cette utilisation particulière.Si les cookies sont utilisés généreusement dans tout le code, il est préférable de créer une classe car cela permet de documenter leur utilisation.S'ils ne sont utilisés qu'à un seul endroit (par ex.une paire de méthodes), alors je pourrais utiliser un tuple.Dans tous les cas, comme il s'agit de Python, vous pouvez commencer avec un tuple, puis le modifier en une instance d'une classe personnalisée sans avoir à modifier le code de l'appelant.