Python: évolution de la valeur dans un tuple

En fonction de votre problème de découpage peut être une solution élégante:

>>> b = (1, 2, 3, 4, 5)
>>> b[:2] + (8,9) + b[3:]
(1, 2, 8, 9, 4, 5)
>>> b[:2] + (8,) + b[3:]
(1, 2, 8, 4, 5)

Cela vous permet d'ajouter de multiples éléments ou de remplacer aussi quelques éléments (surtout si elles sont "voisins". Dans le cas ci-dessus de la coulée à une liste est probablement plus approprié et plus lisible (même si le découpage de la notation est beaucoup plus courte).

Comme Chasseur McMillen a écrit dans les commentaires, les tuples sont immuables, vous devez créer un nouveau tuple dans le but d'atteindre cet objectif. Par exemple:

>>> tpl = ('275', '54000', '0.0', '5000.0', '0.0')
>>> change_value = 200
>>> tpl = (change_value,) + tpl[1:]
>>> tpl
(200, '54000', '0.0', '5000.0', '0.0')

Je crois que cette technique répond à la question, mais ne pas le faire à la maison. À l'heure actuelle, toutes les réponses impliquent la création d'un nouveau tuple, mais vous pouvez utiliser ctypes de modifier un tuple dans la mémoire. En s'appuyant sur divers détails de mise en œuvre de Disponible sur un système 64 bits, une façon de le faire est comme suit:

def modify_tuple(t, idx, new_value):
    # `id` happens to give the memory address in CPython; you may
    # want to use `ctypes.addressof` instead.
    element_ptr = (ctypes.c_longlong).from_address(id(t) + (3 + idx)*8)
    element_ptr.value = id(new_value)
    # Manually increment the reference count to `new_value` to pretend that
    # this is not a terrible idea.
    ref_count = (ctypes.c_longlong).from_address(id(new_value))
    ref_count.value += 1

t = (10, 20, 30)
modify_tuple(t, 1, 50)   # t is now (10, 50, 30)
modify_tuple(t, -1, 50)  # Will probably crash your Python runtime

EDIT: Cela ne fonctionne pas sur les tuples avec les entrées en double encore!!

Basé sur Pooya l'idée de:

Si vous envisagez de le faire souvent (que vous ne devriez pas depuis des n-uplets sont inmutable pour une raison quelconque), vous devriez faire quelque chose comme ceci:

def modTupByIndex(tup, index, ins):
    return tuple(tup[0:index]) + (ins,) + tuple(tup[index+1:])

print modTupByIndex((1,2,3),2,"a")

Ou basé sur Jon idée:

def modTupByIndex(tup, index, ins):
    lst = list(tup)
    lst[index] = ins
    return tuple(lst)

print modTupByIndex((1,2,3),1,"a")

En premier lieu, demandez-vous pourquoi vous souhaitez muter votre tuple. Il ya une raison pourquoi chaînes et de tuple sont immuables dans Ptyhon, si vous souhaitez muter votre tuple il devrait probablement être un list à la place.

Deuxième, si vous souhaitez muter votre tuple ensuite, vous pouvez convertir votre tuple à un list puis de le convertir en arrière, et de réaffecter le nouveau tuple à la même variable. C'est une grande si vous allez seulement à muter votre tuple une fois. Sinon, personnellement, je pense que c'est contre-intuitif. Parce que C'est essentiellement la création d'un nouveau tuple et à chaque fois si vous souhaitez muter le tuple vous auriez à effectuer la conversion. Aussi, Si vous lisez le code, il serait trompeur de penser, pourquoi ne pas simplement créer un list? Mais c'est agréable parce qu'il ne nécessite pas de n'importe quelle bibliothèque.

Je suggère d'utiliser mutabletuple(typename, field_names, default=MtNoDefault) de mutabletuple 0.2. Personnellement, je pense que de cette façon est un plus intuitive et lisible. La lecture personnelle le code serait de savoir que l'auteur a l'intention de muter ce n-uplet dans l'avenir. L'inconvénient compare à la list méthode de conversion ci-dessus, c'est que cela vous oblige à importer d'autres py fichier.

from mutabletuple import mutabletuple

myTuple = mutabletuple('myTuple', 'v w x y z')
p = myTuple('275', '54000', '0.0', '5000.0', '0.0')
print(p.v) #print 275
p.v = '200' #mutate myTuple
print(p.v) #print 200

TL;DR: N'essayez pas de le muter tuple. si vous le faites et c'est une opération ponctuelle de convertir tuple de liste, de muter, tourner list dans une nouvelle tuple, et de réaffecter retour à la variable contenant vieux tuple. Si les désirs tuple et en quelque sorte vouloir éviter listet souhaitez muter plus d'une fois alors créer mutabletuple.

J'ai trouvé la meilleure façon de modifier les tuples est de recréer le tuple à l'aide de la version précédente de la base.

Voici un exemple que j'ai utilisé pour faire une version plus légère de couleur (je l'avais déjà ouvert à l'époque):

colour = tuple([c+50 for c in colour])

Ce qu'il fait, est-il passe par le tuple 'couleur' et lit chaque élément, fait quelque chose pour elle, et, enfin, ajoute le nouveau tuple.

Donc ce que vous voulez serait quelque chose comme:

values = ('275', '54000', '0.0', '5000.0', '0.0')

values  = (tuple(for i in values: if i = 0: i = 200 else i = values[i])

Spécifiques de l'un ne fonctionne pas, mais le concept est ce qu'il vous faut.

tuple = (0, 1, 2)

tuple = itérer n-uplet, de modifier chaque élément si nécessaire

c'est le concept.

Vous pouvez modifier la valeur du tuple à l'aide de la copie par référence

>>> tuple1=[20,30,40]

>>> tuple2=tuple1

>>> tuple2
    [20, 30, 40]

>>> tuple2[1]=10

>>> print(tuple2)
    [20, 10, 40]

>>> print(tuple1)
    [20, 10, 40]