À quoi sert un tuple?

Tuples faire bon dictionnaire touches lorsque vous avez besoin de combiner plus d'un élément de données dans votre clé et ne pas envie de faire une classe pour elle.

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

j'ai utilisé cette option pour créer un dictionnaire avec les clés que sont les coordonnées des sommets d'un maillage. Toutefois, dans mon cas particulier, la comparaison exacte des flotteurs en cause a bien fonctionné, ce qui n'est peut-être pas toujours vrai pour vos besoins [dans ce cas, je convertirais probablement vos flotteurs entrants en sorte de point fixe integer]

j'aime cette explication.

fondamentalement, vous devriez utiliser des tuples quand il y a une structure constante (la première position contient toujours un type de valeur et la seconde un autre, et ainsi de suite), et les listes devraient être utilisées pour les listes de valeurs homogènes.

bien sûr il y a toujours des exceptions, mais c'est une bonne ligne de conduite.

je les trouve utile lorsque vous traitez toujours avec deux ou plusieurs objets comme un ensemble.

les Tuples et les listes ont les mêmes usages en général. Les types de données immuables présentent en général de nombreux avantages, surtout en ce qui concerne les questions 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.

les exemples typiques sont des données fixes dans une application comme les divisions d'entreprise, les catégories, etc. Si ces données changent, un seul producteur reconstruit le tuple.

une liste peut toujours remplacer un tuple, en ce qui concerne la fonctionnalité (sauf, apparemment, comme des clés dans un dict). Cependant, un tuple peut accélérer les choses. Il en va de même pour, par exemple, les chaînes immuables en Java -- quand devrez-vous jamais être incapable de modifier vos chaînes? Jamais!!!!

je viens de lire un décent discussion sur les moyens de limiter ce que vous pouvez faire afin de faire de meilleurs programmes; Pourquoi Pourquoi De La Programmation Fonctionnelle En Matières

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

un avantage d'Être immuable est que parce que le tuple est de taille fixe, il permet à la durée d'exécution d'effectuer certaines optimisations. Ceci est particulièrement avantageux lorsqu'un tupple est utilisé dans le cadre d'une déclaration de valeur ou un paramètre à une fonction.

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

Un n-uplet est une liste séparée par des virgules de valeurs:

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

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

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

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

j'essaie d'être judicieuse à propos de cette usage particulier, cependant. Si les cookies sont utilisés librement dans le code, il est préférable de créer une classe car cela aide à documenter leur utilisation. S'ils sont utilisés uniquement dans un seul endroit (par exemple, une paire de méthodes), alors je pourrais utiliser un tuple. Dans tous les cas, parce que C'est Python, vous pouvez commencer par un tuple et ensuite le changer en une instance d'une classe personnalisée sans avoir à changer de code dans l'appelant.

La meilleure façon de penser est:

• Un n-uplet est un record dont les champs n'ont pas de noms.
• vous utilisez un tuple à la place d'un enregistrement quand vous ne pouvez pas vous donner la peine de spécifier les noms des champs.

Donc au lieu d'écrire des choses comme:

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

Ou encore plus détaillé:

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

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

il Vous suffit d'écrire:

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

C'est utile lorsque vous souhaitez passer autour d'un dossier qui n'a qu'un couple de champs, ou un enregistrement qui n'est utilisé que dans quelques endroits. Dans ce cas, spécifier un nouveau type d'enregistrement avec des noms de champ (en Python, vous utiliserez un objet ou un dictionnaire, comme ci-dessus) pourrait être trop verbeux.

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

type Person = (String, Int)

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

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

Le dessus est en contraste frappant avec les listes, qui sont censés être de longueur variable (le nombre d'éléments est normalement différente dans chaque liste, et vous écrire des fonctions pour ajouter et supprimer des éléments) et chaque élément de la liste est normalement le 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 le mélange de différents types de données à l'intérieur d'un même tuple est le point de l'ensemble de tuples. Les champs d'un tuple sont généralement de types différents (mais pas toujours - par exemple, vous pourriez avoir un (Float, Float, Float) tuple pour représenter les coordonnées x,y,z).

les Tuples et les listes sont souvent imbriquées. Il est courant d'avoir une liste de tuples. Vous pourriez avoir une liste de Personne tuples qu'une liste des objets de la Personne. Vous pouvez aussi avoir un champ tuple dont la valeur est une liste. Par exemple, si vous avez un carnet d'adresses où une personne peut avoir plusieurs adresses, vous pourriez avoir un tuple de type (Person, [String]). [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 ça exactement de la même manière, en mettant un Person objet dans le premier champ d'un n-uplet et une liste de chaînes dans sa deuxième champ.

En Python, la confusion se pose parce que le langage n'est pas appliquer l'une de ces caractéristiques pratiques qui sont appliquées par le compilateur dans des langages fonctionnels statiquement typés. Dans ces langues, vous ne pouvez pas mélanger différents types de tuples. Par exemple, vous ne pouvez pas retourner un (String, String) tuple d'une fonction dont le type dit qu'elle renvoie un (String, Integer) tuple. Vous ne pouvez pas non plus retourner une liste lorsque le type dit que vous prévoyez de retourner un tuple, et vice versa. Les listes sont utilisées strictement pour les collections croissantes d'articles, et les tuples strictement pour les dossiers de taille fixe. Python ne t'empêche pas de casser 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, parce que les clés de dictionnaire Python doivent être des valeurs immuables (c'est-à-dire constantes), alors que les listes Python sont mutables (vous pouvez ajouter et supprimer des éléments à tout moment). C'est une solution de contournement pour une limitation particulière en Python, pas une propriété de tuples en tant que concept informatique.

Donc en Python, les listes sont mutables et les tuples sont immuables. Mais c'est juste un choix de conception, pas une propriété intrinsèque de listes et les tuples en informatique. Autant avoir des listes immuables et des tuples mutables.

en Python (en utilisant L'implémentation par défaut de CPython), les tuples sont aussi plus rapides que les objets ou les dictionnaires pour la plupart des buts, donc ils sont parfois utilisés pour cette raison, même si nommer les champs en utilisant un objet ou un dictionnaire serait plus clair.

enfin, pour rendre encore plus évident que les tuples sont destiné à être un autre type d'enregistrement (pas un autre type de liste), Python dispose également d' nommé tuples:

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 lorsqu'on utilise des tuples normaux dont les champs n'ont pas de noms.

Immuable listes sont très utiles pour de nombreux usages, mais le sujet est bien trop complexe pour répondre ici. Le point principal est que les choses qui ne peuvent pas les changements sont plus faciles à raisonner que les choses qui peuvent changer. La plupart des bogues logiciels proviennent de choses qui changent de façon inattendue, donc restreindre les façons dont ils peuvent changer est un bon moyen d'éliminer les bogues. Si vous êtes intéressé, je vous recommande la lecture d'un tutoriel pour un langage de programmation fonctionnel tel que Elm, Haskell ou Clojure (Elm est le plus convivial). Les concepteurs de ces langues considérées immutabilité si utile que listes sont immuables. (Plutôt modification d'une liste pour ajouter ou supprimer un élément, vous faire une nouvelle liste avec l'élément ajouté ou supprimé. Immutabilité garantit que l'ancienne copie de la liste ne peut jamais changer, de sorte que le compilateur et l'exécution peuvent faire le code bien en réutilisant des parties de l'ancienne liste dans la nouvelle et les déchets-ramassant les parties gauches quand ils sont plus nécessaires.)