Перша ітерація циклу “For”

Я хотів би запитати, чи існує елегантний пітонічний спосіб виконання якоїсь функції на першій ітерації циклу. Єдина можливість, яку я можу придумати, це:

first = True
for member in something.get():
    if first:
        root.copy(member)
        first = False
    else:
        somewhereElse.copy(member)
    foo(member)

У вас є кілька варіантів дизайну шаблону Head-Tail .

seq= something.get()
root.copy( seq[0] )
foo( seq[0] )
for member in seq[1:]:
    somewhereElse.copy(member)
    foo( member )

Або це

seq_iter= iter( something.get() )
head = seq_iter.next()
root.copy( head )
foo( head )
for member in seq_iter:
    somewhereElse.copy( member )
    foo( member )

Люди скигли, що це якось не "СУХО", оскільки код "зайвого foo (member)". Це смішне твердження. Якщо це було правдою, тоді всі функції можна було використовувати лише один раз. Який сенс визначати функцію, якщо ви можете мати лише одне посилання?

Щось подібне мало би спрацювати.

for i, member in enumerate(something.get()):
    if i == 0:
         # Do thing
    # Code for everything

Однак я настійно рекомендую подумати над своїм кодом, щоб перевірити, чи дійсно вам доведеться робити це таким чином, оскільки він начебто "брудний". Краще було б отримати елемент, який потребує спеціальної обробки спереду, а потім регулярно обробляти всі інші цикли.

Єдина причина, за якою я міг бачити, що не роблю цього таким чином, полягає у великому списку, який ви отримували б із виразу генератора (який ви не хотіли б отримувати заздалегідь, оскільки він не міститься в пам'яті), або подібних ситуацій .

як щодо:

my_array = something.get()
for member in my_array:
    if my_array.index(member) == 0:
        root.copy(member)
    else:
        somewhereElse.copy(member)
    foo(member)

або можливо:

for index, member in enumerate(something.get()):
    if index == 0:
        root.copy(member)
    else:
        somewhereElse.copy(member)
    foo(member)

Документація індекс-методу .

Це працює:

for number, member in enumerate(something.get()):
    if not number:
        root.copy(member)
    else:
        somewhereElse.copy(member)
    foo(member)

Однак у більшості випадків я б запропонував просто повторити whatever[1:]і виконати кореневі дії поза циклом; це, як правило, читабельніше. Звичайно, це залежить від вашого випадку використання.

Тут я міг би прийти з пітонічною ідіомою, яка може виглядати "недоречно". Хоча, швидше за все, я б використав форму, яку ви запропонували, задаючи питання, просто для того, щоб код залишався більш очевидним, хоча і менш елегантним.

def copy_iter():
    yield root.copy
    while True:
        yield somewhereElse.copy

for member, copy in zip(something.get(), copy_iter()):
    copy(member)
    foo(member)

(вибачте - перший, який я опублікував, перед редагуванням, форма не працювала, я забув насправді отримати ітератор для об'єкта 'copy')

Я думаю, це досить елегантно, але, можливо, занадто заплутано для того, що робить ...

from itertools import chain, repeat, izip
for place, member in izip(chain([root], repeat(somewhereElse)), something.get()):
    place.copy(member)
    foo(member)

Якщо something.get () повторює щось, ви можете зробити це також наступним чином:

root.copy(something.get())

for member in something.get():
  #  the rest of the loop

Я думаю, що перше рішення S.Lott є найкращим, але є інший вибір, якщо ви використовуєте досить недавній python (> = 2,6, я думаю, оскільки izip_longest здається недоступним до цієї версії), який дозволяє робити різні речі для перший елемент і наступний, і його можна легко змінити, щоб робити окремі операції для 1-го, 2-го, 3-го елемента ... також.

from itertools import izip_longest

seq = [1, 2, 3, 4, 5]

def headfunc(value):
    # do something
    print "1st value: %s" % value

def tailfunc(value):
    # do something else
    print "this is another value: %s" % value

def foo(value):
    print "perform this at ANY iteration."

for member, func in izip_longest(seq, [headfunc], fillvalue=tailfunc):
    func(member)
    foo(member)

Як щодо використання iterта споживання першого елемента?

Редагувати: Повертаючись до питання ОП, є загальна операція, яку ви хочете виконати з усіма елементами, а потім одна операція, яку ви хочете виконати з першим елементом, а інша - з рештою.

Якщо це лише один виклик функції, я б сказав, просто напишіть його двічі. Це не закінчить світ. Якщо це більше залучено, ви можете скористатися декоратором, щоб обгортати свою функцію "перша" та "відпочинок" загальною операцією.

def common(item):
    print "common (x**2):", item**2

def wrap_common(func):
    """Wraps `func` with a common operation"""
    def wrapped(item):
        func(item)
        common(item)
    return wrapped

@wrap_common
def first(item):
    """Performed on first item"""
    print "first:", item+2

@wrap_common
def rest(item):
    """Performed on rest of items"""
    print "rest:", item+5

items = iter(range(5))
first(items.next())

for item in items:
    rest(item)

Вихід:

first: 2
common (x**2): 0
rest: 6
common (x**2): 1
rest: 7
common (x**2): 4
rest: 8
common (x**2): 9
rest: 9
common (x**2): 16

або ви можете зробити фрагмент:

first(items[0])
for item in items[1:]:
    rest(item)

Ви не можете зробити це root.copy(something.get())раніше циклу?

РЕДАГУВАТИ: Вибачте, я пропустив другий біт. Але ви зрозуміли загальну ідею. В іншому випадку перелічити і перевірити 0?

EDIT2: Добре, позбувся дурної другої ідеї.

Я не знаю Python, але я використовую майже точну схему вашого прикладу.
Що я також роблю if, так це найчастіший стан, тому зазвичай перевіряю, if( first == false )
чому? для довгих циклів first один раз буде істинним, а весь інший раз буде помилковим, що означає, що у всіх циклах, крім першого, програма перевіряє стан і переходить до іншої частини.
Перевіривши, що спочатку це помилка, буде лише один перехід до іншої частини. Я насправді не знаю, чи це взагалі додає ефективності, але я все одно роблю це, просто щоб бути у спокої зі своїм внутрішнім ботаніком.

PS: Так, я знаю, що, вводячи частину if, вона також повинна перестрибнути іншу частину, щоб продовжити виконання, тому, ймовірно, мій спосіб робити це марно, але це приємно. : D

Ваше запитання суперечливе. Ви говорите "робіть щось лише на першій ітерації", а насправді ви говорите зробити щось інше на першій / наступній ітераціях. Ось як би я спробував це зробити:

copyfn = root.copy
for member in something.get():
    copyfn(member)
    foo(member)
    copyfn = somewhereElse.copy

Ось, що мені підходить

    dup_count = 0
    for x in reversed(dup_list):
        dup_count += 1
        if dup_count == 1:
            print("First obj {}: {}".format(dup_count,x))
        else:
            print("Object # {}:  {}".format( dup_count,x  ))