Как я могу выполнить проверку только один раз?

Question

Итак, у меня есть этот вопрос, который я должен сделать для домашней работы.

Затем напишите ind (e, L). Вот его описание:

Записать ind (e, L), который принимает последовательность L и элемент e. L может быть строкой или, в более общем плане, списком. Ваша функция ind должна возвращать индекс, по которому e сначала находится в L. Подсчет начинается с 0, как обычно со списками. Если e не является элементом L, то ind (e, L) должен возвращать целое число, равное len (L). Вот несколько примеров:

ind(42, [ 55, 77, 42, 12, 42, 100 ]) returns 2 
ind(42, range(0,100)) returns 42 
ind('hi', [ 'hello', 42, True ]) returns 3 
ind('hi', [ 'well', 'hi', 'there' ]) returns 1 
ind('i', 'team') returns 4 
ind(' ', 'outer exploration') returns 5 

В этом последнем примере, первый вход отра является строка из одного символа пробела, не пустая строка.

Подсказка: Так же, как вы можете проверить, входит ли элемент в последовательности с

если е в L: вы также можете проверить, является ли элемент не в последовательности с

если е не L: Этот последний синтаксис полезен для функции ind! Как и точка, ind, вероятно, наиболее похож на mylen из примеров классов.

И вот это один раз из многих кодов, которые я написал для этой проблемы.

def ind(e, L): 
    num = 0 
    if e not in L and num == 0: 
    return len(L) 
    else: 
    if e == L[0]: 
     num += 1 + ind(e, L[1:]) 
     return num 
    else: 
     return ind(e, L[1:]) 

Таким образом, проблема в том, что каждый раз e больше не входит в список. Он занимает длину оставшейся части списка и добавляет к num. Как это исправить???

Answer 1

И вот он (!) Один раз (!) Из многих кодов, которые я написал для этой проблемы.

Вы должны уделять больше внимания тому, что вы пишете, и, вероятно, также к тому, что вы кодируете.

Если вам явно не предложено написать рекурсивную функцию для этой задачи, я бы посоветовал это сделать.

Попробуйте сломать задачу на меньшие подзадачи. Некоторые из них уже решены:

• Если элемент не содержится в списке, возвращает длину списка (сделано)
• цикл по списку, отслеживание текущего индекса
  • если текущий элемент списка, который вы ищете, возвращает текущий индекс
  • еще, посмотрите на следующий элемент
• , так как вы можете быть уверены, что Eleme nt находится в списке после входа в цикл (почему?), все готово.

---

Если вы должны сделать это рекурсивно, «намеки» скорее вводят в заблуждение. Синтаксис not in не полезен. Вы посмотрели на функцию mylen? Я предполагаю, что это выглядит как

def mylen(s): 
    if not s: 
    return 0 
    return 1 + mylen(s[1:]) 

Теперь, чтобы найти (первый) индекс заданного элемента:

def ind(e, l): 
    if not l:  # list is exhausted, element was not found 
    return 0 
    elif l[0] == e: # element found 
    return 0 
    else    # element not found yet 
    return 1 + ind(e, l[1:]) 

Answer 2

При работе с indicies в последовательности, Python имеет большой встроенный в имени enumerate, который помогает с отслеживанием индекса в узком и простом виде.

Верните объект перечисления. sequence должен быть последовательностью, итератором или другим объектом, поддерживающим итерацию. Метод итератора, возвращаемый enumerate()next() возвращает кортеж, содержащий отсчет (от начала который по умолчанию 0), и значение, полученные из итерации последовательности

Пример:

seq = ['hello', 42, True] 
for index, obj in enumerate(seq): 
    print index, obj 

Выхода:

0 hello 
1 42 
2 True 

Мы можем использовать его для облегчения обработки. Поскольку мы можем перебирать L и извлекать как индекс, так и значение текущего элемента, нам нужно сделать сравнение с запрошенным значением сейчас. Когда значение найдено, мы можем просто вернуть его и пропустить поиск через остальную часть последовательности

def ind(e, L): 
    for index, value in enumerate(L): 
     if value == e: 
      return index 

Что теперь хватает только случай, когда значение не найдено, но добавление поддержки для этого достаточно прост:

def ind(e, L): 
    for index, value in enumerate(L): 
     if value == e: 
      return index 
    return len(L) # this will be executed only if any value wasn't found earlier 

Он проходит все testcases:

assert ind(42, [ 55, 77, 42, 12, 42, 100 ]) == 2 
assert ind(42, range(0,100)) == 42 
assert ind('hi', [ 'hello', 42, True ]) == 3 
assert ind('hi', [ 'well', 'hi', 'there' ]) == 1 
assert ind('i', 'team') == 4 
assert ind(' ', 'outer exploration') == 5 

И бонус, с использованием всех трюков Python предоставляет:

def ind(e, L): 
    return next((idx for idx, obj in enumerate(L) if obj == e), len(L)) 

Веселитесь с выяснить, что происходит здесь :)