Liste Python & pour chaque accès (Rechercher/Remplacer dans la liste)

J'ai d'abord pensé que Python était un pur passe-par-langue de référence.

À venir à partir de C/C++ je ne peux pas aider mais penser à propos de la gestion de la mémoire, et il est difficile de le mettre hors de ma tête. Donc, je suis en train de penser à partir d'une perspective Java et de penser à tout, mais primitives comme un passage par référence.

Problème: j'ai une liste, contenant un tas d'instances d'une classe définie par l'utilisateur.

Si j'utilise le pour-chaque syntaxe, c'est à dire.:

for member in my_list:
    print(member.str);

Est member l'équivalent d'une référence à l'objet?

Est-il l'équivalent de l'action:

i = 0
while i < len(my_list):
    print(my_list[i])
    i += 1

Je ne pense PAS, parce que quand je suis à la recherche de faire un remplacement, il ne fonctionne pas, c'est que cela ne fonctionne pas:

for member in my_list:
    if member == some_other_obj:
        member = some_other_obj

Un simple rechercher et remplacer dans une liste. Peut-être que le faire dans une boucle for-each, si oui, comment? D'autre, je n'ai qu'à utiliser le hasard de la syntaxe d'accès (entre crochets), ou ne travaillent pas et j'ai besoin de supprimer l'entrée, et insérez une nouvelle un seul? I. e.:

i = 0
for member in my_list:
   if member == some_other_obj:
      my_list.remove(i)
      my_list.insert(i, member)
   i += 1

Les valeurs ne sont pas copiées au cours d'une itération de la liste. Les raisons sont semblables à pourquoi les objets ne sont pas copiés passés en paramètres à une fonction.

InformationsquelleAutor Syndacate | 2011-09-14

47

De répondre à ce qui a été bon, les commentaires ont conduit à une amélioration de ma propre compréhension de Python variables.

Comme indiqué dans les commentaires, lorsque vous passez en boucle sur une liste avec quelque chose comme for member in my_list la member variable est liée à chaque élément de la liste. Cependant, la ré-affectation de la variable dans la boucle n'est pas influer directement sur la liste elle-même. Par exemple, ce code ne changera pas la liste:
```
my_list = [1,2,3]
for member in my_list:
    member = 42
print my_list
```
De sortie:

[1, 2, 3]

Si vous souhaitez modifier une liste contenant immuable types de, vous avez besoin de faire quelque chose comme:
```
my_list = [1,2,3]
for ndx, member in enumerate(my_list):
    my_list[ndx] += 42
print my_list
```
De sortie:

[43, 44, 45]

Si votre liste contient des objets mutables, vous pouvez modifier le member objet directement:
```
class C:
    def __init__(self, n):
        self.num = n
    def __repr__(self):
        return str(self.num)

my_list = [C(i) for i in xrange(3)]
for member in my_list:
    member.num += 42
print my_list
```
[42, 43, 44]

Noter que vous n'êtes toujours pas la modification de la liste, il suffit de modifier les objets de la liste.

Vous pouvez bénéficier de la lecture de Nommage et de Liaison.
- Quel dommage qu'il est ré-défini comme une copie de la liste des membres. Je crois qu'il serait beaucoup plus utile de se manifester comme une référence, comme si vous étiez le fixer, il serait probablement pour manipuler la structure d'une certaine façon ou d'une autre. J'ai testé la syntaxe: for idx in range(0, len(my_list)): my_list[idx] = new_obj Il travaille à mon goût. Je vous remercie.
- -1: member n'est pas une copie de la valeur. ideone.com/y7A9M
- Vous ne savez pas comment C++ gère des choses comme cela, mais en Java la version de la boucle for each (ou amélioré pour la boucle dans leur jargon) fonctionne de manière similaire, du moins en effet.
- Sebastian: je ne peut pas avoir la terminologie parfait, mais je crois que je vous ai fourni une bonne façon de penser à ce sujet. La réponse a été modifié & élargi.
- Je ne peux révoquer mon vote, sauf si vous modifiez la réponse (c'est une caractéristique de la SORTE).
- Je me souviens de l'ensemble du "Noms se réfèrent à des objets. Les noms sont présentés par le nom des opérations de liaison" terminologie juste cliqué quand j'ai vu python.net/~goodger/projets/pycon/2007/idiomatiques/... de Sorte que vous ne modifiez pas les modifier member vous venez de le lier à un autre objet. Et si member n'est pas l'un des objets de la liste à tout moment, il se réfère à chacun d'eux.
- Sebastian: je pense que j'avais modifié l'entrée après votre downvote. Cependant, j'ai édité de nouveau (je l'espère l'améliorer).
- +2: pour l'effort.
- btw, il n'y a pas de primitives en Python contrairement à Java. Les entiers sont (immuable) des objets.
- Sébastien: Merci!
InformationsquelleAutor GreenMatt
16

Python, Java n'est pas, ni en C/C++ -- vous besoin d'arrêter de penser de cette façon d'utiliser la puissance de Python.

Python n'a pas passé par valeur, ni par référence, mais utilise à la place de passer par nom (ou passe-par-objet) -- en d'autres termes, presque tout est lié à un nom que vous pouvez ensuite utiliser (les deux exceptions évidentes étant tuple - et la liste d'indexation).

Lorsque vous ne spam = "green", vous avez lié le nom de spam à l'objet de type string "green"; si vous ne eggs = spam vous n'avez pas copié quoi que ce soit, vous n'avez pas fait référence pointeurs; vous avez simplement lié à un autre nom, eggs, pour le même objet ("green" dans ce cas). Si vous liez ensuite spam à autre chose (spam = 3.14159) eggs sera toujours lié à "green".

Lors d'une boucle for s'exécute, il prend le nom que vous lui donnez, et se lie à tour de rôle, chaque objet dans l'objet iterable lors de l'exécution de la boucle; lorsque vous appelez une fonction, il prend les noms en-tête de la fonction et les lie à la arguments passés; attribution d'un nom est en fait la reliaison un nom (il peut prendre un certain temps pour absorber cette -- il l'a fait pour moi, de toute façon).

Avec des boucles en utilisant des listes, il y a deux façons de base pour attribuer retour à la liste:
```
for i, item in enumerate(some_list):
    some_list[i] = process(item)
```
ou
```
new_list = []
for item in some_list:
    new_list.append(process(item))
some_list[:] = new_list
```
Avis de la [:] sur ce dernier some_list -- il est à l'origine d'une mutation de some_lists'éléments (réglage de la chose entière pour new_list's éléments) au lieu de reconsolidation du nom some_list à new_list. Est-ce important? Ça dépend! Si vous avez d'autres noms d'ailleurs some_list lié à la même liste d'objets, et vous voulez pour voir les mises à jour, alors vous devez utiliser la méthode de l'effeuillage; si vous n'en avez pas, ou si vous ne pas voulez voir les mises à jour, puis relier -- some_list = new_list.
- Le nom de la liaison fonctionne de la même manière que dans Java. Je ne pouvais pas voir la différence.
- En java primitives comme les entiers et les booléens sont passés par valeur et tout n'est pas une primitive est passé par référence. La liaison à un nom est similaire pour le passage par référence, moins le type de sécurité et probablement quelques autres détails. En java, une référence maintient, au moins dans la compilation, le type de données à propos de ce qu'il peut se référer à python noms n'ont pas une telle restriction.
InformationsquelleAutor Ethan Furman
6

Vous pouvez remplacer quelque chose là-bas par l'obtention de l'index le long de l'élément.
```
>>> foo = ['a', 'b', 'c', 'A', 'B', 'C']
>>> for index, item in enumerate(foo):
...     print(index, item)
...
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'A')
(4, 'B')
(5, 'C')
>>> for index, item in enumerate(foo):
...     if item in ('a', 'A'):
...         foo[index] = 'replaced!'
...
>>> foo
['replaced!', 'b', 'c', 'replaced!', 'B', 'C']
```
Noter que si vous souhaitez supprimer un élément de la liste que vous avez à effectuer une itération sur une copie de la liste, sinon vous obtiendrez des erreurs puisque vous essayez de modifier la taille de quelque chose que vous êtes à parcourir. Cela peut se faire assez facilement avec des tranches.

Mal:
```
>>> foo = ['a', 'b', 'c', 1, 2, 3]
>>> for item in foo:
...     if isinstance(item, int):
...         foo.remove(item)
...
>>> foo 
['a', 'b', 'c', 2]
```
Le 2 est encore là parce que nous avons modifié la taille de la liste que nous avons itéré il. La manière correcte serait:
```
>>> foo = ['a', 'b', 'c', 1, 2, 3]
>>> for item in foo[:]:
...     if isinstance(item, int):
...         foo.remove(item)
...
>>> foo 
['a', 'b', 'c']
```
- +1 pour être pythonic
- pythonic approche serait: foo = [c for c in foo if condition(c)]
- Sebastian: honnêtement, je ne pense pas que tout ce qui peut tenir dans un one-liner est plus pythonic de 3 lignes de code, j'ai voulu souligner que Gilder a l'aide de enumerate tout GreenMat était coincé (il a édité sa réponse) pour for x in xrange(len()). Cheers
- Accordé je suis une "vieille école" programmeur tente de mettre à jour mes compétences en moi-même; j'ai donc tendance à penser for x in xrange(len(l)) premier. En tant que tel, j'attends for x in xrange(len(l)) sera plus familier que for x in enumerate(l) pour quelqu'un venant de C/C++ (qui l'OP professé à l'être). Est-il préférable d'être plus Pythonic ou de se concentrer sur le coeur de l'émission et l'utilisation de plus en plus familiers de la syntaxe sur des choses qui sont nécessaires pour l'exemple, mais pas le nœud du problème? (Je ne pense pas qu'il y a une seule bonne réponse à cette question.)
- J'ai utilisé de la compréhension de liste pour remplacer O(N**2) boucle sur foo[:] avec foo.remove() en elle (3ème exemple). Je n'ai rien contre le premier exemple avec enumerate(). Il devrait être évident en raison de 1ère et de 3ème des exemples de faire des choses différentes et la compréhension de liste produit un résultat similaire à la 3ème exemple.
- Je suis d'accord d'être pythonic n'est pas obligatoire, toutefois, si je n'ai jamais entendu parler en cours de javanic ou *C*inic est parce que python offre une légère façon différente de penser au sujet de la programmation et de l'écriture de code, au début, vous obtenez le mieux à mon humble avis. De toute façon il y a des situations où vous avez besoin et l'index et rien d'autre, dans ce cas, je aller avec xrange(len(l)) et ne se sentent pas moins pythonic... 🙂
- Sebastian: honnêtement, dans la même situation (3ème exemple), j'irais avec la compréhension de liste (si condition ne semble pas être encombrant et maladroit) Cheers
- J'ai peu d'intérêt en étant pythonic, le code est pour moi, pour une classe, si c'était à moi qu'il serait en C++, mais il n'est pas à moi. Il a besoin afin de fonctionner correctement, c'est tout. Chaque langue a leurs "cartes réseau" - C gourous essayez d'être très délicat avec une certaine utilité de la syntaxe et de la magie noire, Java gourous de la création d'un programme "hello world" pour être modulaire, haskell gourous de la fierté d'eux-mêmes dans 1 ligne de manière récursive fonctionnelle des appels de fonction, etc. Je ne pense pas qu'il soit vraiment de "bonne" réponse, soit, tout ce que l'on préfère. Cela étant dit, je ne comprends maintenant le nom de liaison concept python utilise.
- vous devriez avoir écrit vous avez peu d'intérêt dans python tout le contraire faut-il se préoccuper de la langue spécifications et zen. Cheers
InformationsquelleAutor Glider

Vous devez vous connecter pour publier un commentaire.