¿Saltar la primera entrada para for loop en python?

En python, ¿cómo hago algo como:

for car in cars:
   # Skip first and last, do work for rest

Las otras respuestas solo funcionan para una secuencia.

Para cualquier iterable, para omitir el primer elemento:

itercars = iter(cars)
next(itercars)
for car in itercars:
    # do work

Si desea omitir el último, puede hacer:

itercars = iter(cars)
# add 'next(itercars)' here if you also want to skip the first
prev = next(itercars)
for car in itercars:
    # do work on 'prev' not 'car'
    # at end of loop:
    prev = car
# now you can do whatever you want to do to the last one on 'prev'

Para omitir el primer elemento en Python, simplemente puede escribir

for car in cars[1:]:
    # Do What Ever you want

o para saltear el último elemento

for car in cars[:-1]:
    # Do What Ever you want

Puede usar este concepto para cualquier secuencia.

La mejor manera de omitir los primeros elementos es:

from itertools import islice
for car in islice(cars, 1, None):
    # do something

islice en este caso se invoca con un punto de inicio de 1 y un punto final de Ninguno, lo que significa el final del iterador.

Para poder omitir elementos desde el final de un iterable, debe conocer su longitud (siempre posible para una lista, pero no necesariamente para todo lo que puede iterar). por ejemplo, islice (cars, 1, len (cars) -1) omitirá el primer y el último elemento de la lista de automóviles.

Aquí hay una función de generador más general que omite cualquier número de elementos desde el principio y el final de un iterable:

def skip(iterable, at_start=0, at_end=0):
    it = iter(iterable)
    for x in itertools.islice(it, at_start):
        pass
    queue = collections.deque(itertools.islice(it, at_end))
    for x in it:
        queue.append(x)
        yield queue.popleft()

Ejemplo de uso:

>>> list(skip(range(10), at_start=2, at_end=2))
[2, 3, 4, 5, 6, 7]

for item in do_not_use_list_as_a_name[1:-1]:
    #...do whatever

Basado en la respuesta de @SvenMarnach, pero un poco más simple y sin usar deque

>>> def skip(iterable, at_start=0, at_end=0):
    it = iter(iterable)
    it = itertools.islice(it, at_start, None)
    it, it1 = itertools.tee(it)
    it1 = itertools.islice(it1, at_end, None)
    return (next(it) for _ in it1)

>>> list(skip(range(10), at_start=2, at_end=2))
[2, 3, 4, 5, 6, 7]
>>> list(skip(range(10), at_start=2, at_end=5))
[2, 3, 4]

También timeittenga en cuenta que, según mi resultado, esto es marginalmente más rápido que la solución de deque

>>> iterable=xrange(1000)
>>> stmt1="""
def skip(iterable, at_start=0, at_end=0):
    it = iter(iterable)
    it = itertools.islice(it, at_start, None)
    it, it1 = itertools.tee(it)
    it1 = itertools.islice(it1, at_end, None)
    return (next(it) for _ in it1)
list(skip(iterable,2,2))
    """
>>> stmt2="""
def skip(iterable, at_start=0, at_end=0):
    it = iter(iterable)
    for x in itertools.islice(it, at_start):
        pass
    queue = collections.deque(itertools.islice(it, at_end))
    for x in it:
        queue.append(x)
        yield queue.popleft()
list(skip(iterable,2,2))
        """
>>> timeit.timeit(stmt = stmt1, setup='from __main__ import iterable, skip, itertools', number = 10000)
2.0313770640908047
>>> timeit.timeit(stmt = stmt2, setup='from __main__ import iterable, skip, itertools, collections', number = 10000)
2.9903135454296716

Ejemplo:

mylist=['one'.'two','three'.'four'.'five']
for i in mylist[1:]:
   print(i)

En Python index start from 0, podemos utilizar el operador de corte para realizar manipulaciones en iteración.

for i in range(1,-1):

Bueno, para empezar, tu sintaxis no es realmente Python.

Las iteraciones en Python están sobre el contenido de los contenedores (bueno, técnicamente está sobre iteradores), con una sintaxis for item in container. En este caso, el contenedor es la carslista, pero desea omitir el primer y el último elemento, por lo que eso significa cars[1:-1](las listas de Python son de base cero, los números negativos cuentan desde el final y :está cortando la sintaxis.

Entonces quieres

for c in cars[1:-1]:
    do something with c

Un método alternativo:

for idx, car in enumerate(cars):
    # Skip first line.
    if not idx:
        continue
    # Skip last line.
    if idx + 1 == len(cars):
        continue
    # Real code here.
    print car

Aquí está mi opción preferida. No requiere agregar mucho al ciclo, y no usa nada más que herramientas integradas.

Ir desde:

for item in my_items:
  do_something(item)

a:

for i, item in enumerate(my_items):
  if i == 0:
    continue
  do_something(item)

Si carses una secuencia que puedes hacer

for car in cars[1:-1]:
    pass

El more_itertoolsproyecto se extiende itertools.islicepara manejar índices negativos.

Ejemplo

import more_itertools as mit

iterable = 'ABCDEFGH'
list(mit.islice_extended(iterable, 1, -1))
# Out: ['B', 'C', 'D', 'E', 'F', 'G']

Por lo tanto, puede aplicarlo con elegancia elementos de corte entre el primer y el último elemento de un iterable:

for car in mit.islice_extended(cars, 1, -1):
    # do something

Lo hago así, aunque parece un truco, funciona siempre:

ls_of_things = ['apple', 'car', 'truck', 'bike', 'banana']
first = 0
last = len(ls_of_things)
for items in ls_of_things:
    if first == 0
        first = first + 1
        pass
    elif first == last - 1:
        break
    else:
        do_stuff
        first = first + 1
        pass