Andrey Dugin

Помимо прочего, Python является основным языком в Data Science.

Вопрос элементарный. Изучайте list comprehensions:

[[item] for item in d]  # => [['hello'], ['world'], ['!']]

Или, если устроит список туплов:

list(zip(d))  # => [('hello',), ('world',), ('!',)]

Последовательность - это фактически массив. Или в виде чего она дана?

sequence = [2, 3, 7, 8, 0]

# reversed возвращает итератор (не массив)
for item in reversed(sequence):
    print(item)

# слайс возвращает новый список (массив)
for item in sequence[::-1]:
    print(item)

P.S. Не рекурсия, а реверсия. Рекурсия - это совершенно другое.
P.P.S. Почему Вы упорно не хотите прочитать учебник/документацию по Python?

Поляризационный фильтр в полной мере задачу не решит, потому (1) предназначен для другой задачи и (2) лучше всего работает в направлении 90 градусов от солнца, а вовсе не одинаково во все стороны, за счёт чего даёт на небе радиальный градиент. Для Вашей задачи используйте нейтральный градиентный серый фильтр, который затенит именно небо. Можно совместить с поляриком.

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

Вариант #1 (для возрастающих субпоследовательностей):

from itertools import count

def subsequences(sequence):
    start = 0
    expected = count(sequence[start])
    last_index = len(sequence) - 1
    for end, val in enumerate(sequence):
        flag_val = val == next(expected)
        flag_end = end == last_index
        if flag_val:
            if flag_end:
                yield sequence[start:]
            continue
        yield sequence[start:end]        
        if flag_end:
            yield sequence[end:]
            continue
        expected = count(sequence[end+1])
        start = end
        
def solve(sequence):
    return max(subsequences(sequence), key=len) 

if __name__ == '__main__':
    sequence = [0, 2, 3, 6, 7, 8, 9, 10, 13, 14, 15, 16, 20]
    print(solve(sequence))  # => [6, 7, 8, 9, 10]

Вариант #2 (универсальный, т.к. считает модуль разности):

from operator import sub
from itertools import groupby

def solve(sequence, step=1):
    pairs = zip(sequence[:-1], sequence[1:])
    criteria = lambda pair: abs(sub(*pair)) == step
    grouped = groupby(pairs, key=criteria)
    subsequences = (tuple(group) for flag, group in grouped if flag)
    result, extra = zip(*max(subsequences, key=len))
    return result + extra[-1:]

if __name__ == '__main__':
    sequence = [0, 2, 3, 6, 7, 6, 7, 8, 9, 10, 13, 14, 15, 16, 20]
    print(solve(sequence))  # => (6, 7, 6, 7, 8, 9, 10)

Первый способ в 1.5 раза быстрее второго.

В этой книге раздел "Рекомендация 52. Знайте, как устранить циклические зависимости" (стр. 231).

Самый простой и буквальный способ:
result = '0' in input().split()
Можно усложнить:

result = not all(
    map(int, input().split())
)

UPD Тю, а что так скромно? Нужно наворотить больше функциональности!

from itertools import repeat

def ask(question, expected=int):
    return expected(input(question))

def ask_quantity():
    return ask('Введите количество чисел: ')

def ask_number():
    return ask('Введите число: ')

def call(func):
    return func()

def solve():
    return not(all(map(call, repeat(ask_number, ask_quantity()))))

if __name__ == '__main__':
    print(f'Результат: {solve()}')

Бонус - программа даёт ответ сразу после после ввода первого же нуля.

timestamp // 86400
timestamp % 86400

Или используйте объекты datetime, в частности, datetime.day.

Можно обойтись без filter():

print(min(map(int, input().split()), key=lambda x: (not x % 2, x)))

Скажите, а вот если бы Вы, скажем, начинали заниматься каратэ - Вы бы тоже искали обязательно единственного в мире шаолиньского мастера с 20-м даном? Читайте любую книгу и не парьте мозг. Вам ещё много книг предстоит прочитать, в каждой что-то будете открывать для себя.

P.S. Основная "книга" - это Python 3.6.3 documentation.

Можно любым способом, лишь бы код был простой, читабельный и избегал заведомо лишних вычислений.

1) Если поле статическое - напрямую.
2) Если поле вычисляемое в момент запроса - через @property.
3) Можно через функцию, если зависит от параметров.

Надо ли начинать с подчёркивания - определяется программистом. Должно ли это поле быть"видно" вовне?

Пример решения с использованием стандартной библиотеки difflib:

from difflib import get_close_matches as gcm

model = 'A 170 Classic - 7/2004 - 85Kw'.upper()
model_list = map(str.upper, [
    'A 170 CDI CAT ELEGANCE',
    'A 170 CDI CAT CLASSIC',
    'A 170 CDI CAT AVANTGARDE',
])

result = gcm(model, model_list, n=1, cutoff=0.5)[0]

print(result)  # => 'A 170 CDI CAT CLASSIC'

Также посмотрите в сторону difflib.SequenceMatcher().ratio(), это имеет прямое отношение к cutoff в примере выше:

from difflib import SequenceMatcher as SM

s1 = 'A 170 Classic - 7/2004 - 85Kw'.upper()
s2 = 'A 170 CDI CAT CLASSIC'.upper()

SM(isjunk=None, a=s1, b=s2, autojunk=True).ratio()  # => 0.52

Теория: Расстояние Левенштейна

Вариант без re:

[phrase.strip() for phrase in text.split('  ') if phrase]

Format String Syntax

name = 'toster'
option1 = f"CREATE TABLE '{name}' ..."
option2 = "CREATE TABLE '{0}' ...".format(name)
option3 = "CREATE TABLE '{name}' ...".format(name='toster')
option4 = "CREATE TABLE '{name}' ...".format(**{'name': 'toster'})

Строка не содержит присваивания

1) Банальная отправка: https://translate.yandex.ru/?lang=en-ru&text=Just%... (нужно будет обработать все редиректы). Либо checkText, но тогда надо всякие хитрые id сессии отправлять.
2) Из полученного заберите перевод.

Я бы переписал вариант от aRegius для данного случая так:

def flatten(sequence):
    for item in sequence:
        try:
            yield from item  # Или yield from flatten(item) для более общего случая
        except TypeError:
            yield item

Первый подход предпочтителен, но можно ещё и так (код хуже читается):

from itertools import chain

def flatten(sequence):
    list_of_lists = ([item] if type(item) is int else item for item in sequence)
    return list(chain.from_iterable(list_of_lists))

flatten([1, 2, 3, [4, 5, 6], 7, 8])

И ещё вариант, ради фана:
[int(e) for e in re.findall('\d+', str(a))]