Python vérifier le premier et le dernier index d'une liste

En supposant que j'ai object_list liste qui contient les objets.

Je veux vérifier si mon itération courante est est à la première ou à la dernière.

for object in object_list:
    do_something
    if first_indexed_element:
        do_something_else
    if last_indexed_element:
        do_another_thing

Comment cela peut-il être atteint? Je sais que je peux utiliser la gamme et le comte d'index, mais s'il se sent maladroit.

Ce qui concerne

OriginalL'auteur Hellnar | 2010-08-03

list python

13
```
li = iter(object_list)

obj = next(li)

do_first_thing_with(obj)

while True:
    try:
        do_something_with(obj)
        obj = next(li)
    except StopIteration:
        do_final_thing_with(obj)
        break
```
+1 pour l'utilisation des itérateurs à la place des numéros d'index. Dans le cas des OP question, tous les objets sont traités avec faire_quelque_chose, et un traitement spécial est effectué avec la première et la dernière. Dans votre code, vous ne le traitement spécial pour le premier élément, mais pas le tout-traitement de l'élément. Je pense que vous avez juste besoin d'inverser les 2 déclarations dans votre essai: la clause d'obtenir le comportement souhaité.
Assez compliqué. Pas exactement ce que l'auteur veut (do_first_thing_with doit être appelée après la première do_something_with).
probablement la solution la plus efficace (+1), mais malheureusement pas très concis, facile à analyser.

OriginalL'auteur
15

Vous pouvez utiliser enumerate():
```
for i, obj in enumerate(object_list):
    do_something
    if i == 0:
        do_something_else
    if i == len(object_list) - 1:
        do_another_thing
```
Mais au lieu de vérifier à chaque itération de l'objet en question, peut-être quelque chose comme ce qui est mieux:
```
def do_with_list(object_list):
    for obj in object_list:
        do_something(obj)
    do_something_else(object_list[0])
    do_another_thing(object_list[-1])
```
Imaginez que vous avez une liste de 100 objets, puis de vous rendre 198 inutile comparaisons, parce que l'élément en cours ne peut pas être le premier ou le dernier élément de la liste.

Mais cela dépend si les déclarations doivent être exécutées dans un certain ordre et ce qu'ils font.

Btw. ne pas l'ombre object, c'est déjà un identifiant en Python 😉

i ne pourra jamais égaler len(object_list).
Vrai, merci

OriginalL'auteur
3
```
for index, obj in enumerate(object_list):
    do_something
    if index == 0:
        do_something_else
    if index == len(object_list)-1:
        do_another_thing
```
Cassera si object_list est itérateur. Il est préférable d'écrire du code qui fonctionnera avec tous les iterables, non seulement les listes.
Pas quand elle rend le code beaucoup plus complexe à lire, et vous savez que vous allez travailler avec des listes.

OriginalL'auteur

first = True
for o in object_list:
    do_something(o)
    if first:
        first = False
        do_something_with_first(o)
if 'o' in locals():
    do_something_with_last(o)

OriginalL'auteur

0

Vous avez juste à utiliser un compteur, pas besoin de la gamme :

Disons que votre compteur est cpt.
```
if cpt == 0:
  print "first"

if cpt == len(object_list) - 1:
  print "last"
```
modifier : le énumérer solution peut-être plus élégant.

OriginalL'auteur
0
1. Vous pouvez faire i = 0 et i++ en itérations. Donc, si i==0, c'est la première itération, si i == liste.size()-1 que c'est la dernière itération.
2. Il doit y avoir qch comme indexOf(object), qui retourne la position de l'élément dans la liste. si 0 - que la première itération, si size()-1 que l'an dernier. Mais c'est cher.
3. utilisation d'énumérer. Voir Ambre ou Felix postes.
4. comparer élément courant de la liste[0] et[-1]. dans le premier cas - la première itération, dans ce dernier cas - la dernière itération. C'est cher aussi.
Donc je préfère le 1 ou 3.

PS: la liste.size() len(liste) de cours.

Pourquoi devrait-4. être cher? Liste d'accès doit être O(1).
Ne sais pas ce qui est O(1), mais la comparaison d'objets personnalisés, à mon humble avis, est toujours plus lent que la comparaison de nombres (même si elles sont aussi des objets). En outre, dans ce cas, vous devez fournir l'égalité règles, ce qui peut être assez compliqué. En outre, la liste peut contenir des doublons, donc il peut provoquer des erreurs (c'est différent point de vue, néanmoins, vous devez le prendre en compte).
En outre! : lorsque vous essayez d'obtenir de l'élément de la liste, python première liste, puis de trouver l'élément à l'index. si vous utilisez un nombre, il faut seulement trouver numéro 1 de l'opération moins. à mon humble avis - je ne t sais python internes.
Vous avez raison, objets de comparaison être cher s'ils mettent en œuvre une fonction de comparaison personnalisée. Mais l'accès à un élément d'une liste est rapide.

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.