pop/supprimer des éléments d'un tuple python

Je ne suis pas sûr si je peux me faire comprendre mais va essayer.

J'ai un tuple en python que j'ai passer à travers comme suit (voir code ci-dessous). Tout en passant à travers elle, je maintenir un compteur (appelons-le "n") et " pop " des objets qui répondent à certaines conditions.

Maintenant, bien sûr une fois que je pop le premier élément, la numérotation tout va mal, comment puis-je faire ce que je veux faire plus élégamment tout en éliminant certains éléments d'un tuple à la volée?

for x in tupleX:
  n=0
  if (condition):
     tupleX.pop(n)
  n=n+1
tuples sont immuables, et qui n'ont pas pop méthode. Êtes-vous vraiment parler d'un list?

OriginalL'auteur Steve Grafton | 2014-02-10

  1. 37

    Comme DSM mentionne, tuple's sont immuables, mais même pour les listes, une solution plus élégante consiste à utiliser filter:

    tupleX = filter(str.isdigit, tupleX)

    ou, si condition n'est pas une fonction, utilisez une compréhension:

    tupleX = [x for x in tupleX if x > 5]

    si vous avez vraiment besoin tupleX être un tuple, l'utilisation d'un générateur d'expression et le passer à tuple:

    tupleX = tuple(x for x in tupleX if condition)
    Pour d'autres, référence, le générateur d'expression est optimale en termes de vitesse.
    pouvez-vous fournir des références de cette demande? En fait, dans le cas où le condition est un (non) en fonction de C (comme dans l'exemple que j'ai fourni), filter est généralement plus rapide; générateur d'expressions doivent exécuter du bytecode python, mais ne sont pas obligés de créer un appel-cadre (aussi comme dans mon exemple pour la compréhension de liste).
    Selon le docs, le filtre et le générateur de solutions sont fonctionnellement identiques - les deux renvoie un objet iterable de l'original filtré par l'état, et par cette définition, les deux sont à temps constant. Cependant, en supposant que les OP nécessite un n-uplet de sortie, la différence vient de la conversion. Pour preuve: prendre la n-uplet() du générateur et ils reviennent tous les deux instantanément, mais tuple() le filtre et il prend plus de temps proportionnelle à la taille de tupleX.
    Intéressante note: je suis tombé sur ce post en cherchant le moyen le plus efficace pour "supprimer" un seul élément d'un tuple. Alors que ce sont tous de grands solutions, ironiquement, "x = list(x); x.supprimer(<item>); x = n-uplet(x)" est plus rapide que l'un d'eux 😛

    OriginalL'auteur SingleNegationElimination

  2. 3

    ok j'ai compris brut moyen de le faire.

    - Je conserver le "n" de la valeur dans la boucle si la condition est satisfaite dans une liste (appelons cela delList) puis effectuez les opérations suivantes:

        for ii in sorted(delList, reverse=True):
    tupleX.pop(ii)

    Toutes les autres suggestions sont aussi les bienvenues.

    OriginalL'auteur Steve Grafton

  3. 3

    Peut-être vous voulez dictionnaires?

    d = dict( (i,value) for i,value in enumerate(tple))
while d:
    bla bla bla
    del b[x]
    non, je n'ai à travailler avec un tuple comme son m'a été donné par une fonction externe que je ne peux pas éditer le-vieux code hiérarchique avec de nombreuses dépendances.
    ok, voir le modifier...
    merci, je vais essayer ce -plus élégante que ma méthode.

    OriginalL'auteur tk.

  4. 2

    Oui nous pouvons le faire.
    D'abord convertir le tuple dans une liste, puis de supprimer l'élément dans la liste après que le nouveau reconvertir en tuple.

    Démo:

    my_tuple = (10, 20, 30, 40, 50)

# converting the tuple to the list
my_list = list(my_tuple)
print my_list  # output: [10, 20, 30, 40, 50]

# Here i wanna delete second element "20"
my_list.pop(1) # output: [10, 30, 40, 50]
# As you aware that pop(1) indicates second position

# Here i wanna remove the element "50"
my_list.remove(50) # output: [10, 30, 40]

# again converting the my_list back to my_tuple
my_tuple = tuple(my_list)


print my_tuple # output: (10, 30, 40)

    Grâce

    OriginalL'auteur Abdulvakaf K

  5. 2

    Un tuple est déclarée comme unchangable.

    Et vous n'allez pas le pop élément à l'intérieur de lui-même itération, il provoque une erreur, car il modifie la longueur de la liste obj.
    Mais vous pouvez le faire dans les interprétations de la liste, sur le côté opposé.

    tupleX = tuple( [ e for e in list( tupleX ) if not condition( e ) ] )

    Cela permet de maintenir les éléments qui na pas correspondre à l'état plutôt que l'extirpant du tuple/liste.

    Mais si vous avez l'intention de le faire aussi semblables que votre propre chemin, vous avez pour faire de votre tuple d'une liste à l'avance par les géohelminthiases comme listX = list( tupleX ). youd mieux ajouter l'indice de matériaux indésirables à l'intérieur de l'itération dans une liste ( unwanted_list ), et de réitérer unwanted_list et de la pop ele dans la liste d'origine. puis le faire revenir pour un tuple comme tuple( listX )

    OriginalL'auteur Sphynx-HenryAY

  6. 1

    Il est simple, mais une solution pratique.

    Que le DSM a dit, les tuples sont immuables, mais nous savons que les Listes sont mutables.
    Donc, si vous changez un tuple à une liste, il sera mutable. Ensuite, vous pouvez supprimer les objets par la condition, puis après avoir changé le type à un n-uplet de nouveau. C'est tout.

    S'il vous plaît regardez les codes ci-dessous:

    tuplex = list(tuplex)
for x in tuplex:
  if (condition):
     tuplex.pop(tuplex.index(x))
tuplex = tuple(tuplex)
print(tuplex)

    Par exemple, la procédure suivante vous permettra de supprimer tous les numéros à partir d'un n-uplet.

    tuplex = (1, 2, 3, 4, 5, 6, 7, 8, 9)
tuplex = list(tuplex)
for x in tuplex:
  if (x % 2 == 0):
     tuplex.pop(tuplex.index(x))
tuplex = tuple(tuplex)
print(tuplex)

    si vous tester le type de la dernière tuplex, vous trouverez qu'il est un n-uplet.

    Enfin, si vous souhaitez définir un index de compteur comme vous l'avez fait (c, n), vous devez l'initialiser avant de la boucle, pas dans la boucle.

    OriginalL'auteur Reza K Ghazi