Andrey Dugin

В последней строке написано, чего не хватает - модуля codecs. Читайте внимательно.

Вы серьёзно? Цикл по массиву в numpy?! Зачем???

img_contrast = (img - min_br) * (255 / (max_br - min_br))

dmitrylogvinov, Вы в корне неправильно подходите к обучению. Вам нужно больше времени проводить с учебником и изучать стандартные библиотеки (и в первую очередь - встроенные функции, обращая особое внимание на их параметры), а не пытаться решать задачи "в лоб", раз за разом городя конструкции в стиле Delphi из базового синтаксиса, примерно одинакового для каждого языка. "Батарейки" в Python присутствуют как раз для того, чтобы не изобретать велосипеды.

Задача решается просто и элегантно:

from itertools import count

def lastmax(*sequence):
    return max(zip(sequence, count()))

assert lastmax(1, 2, 3) == (3, 2)
assert lastmax(1, 2, 1, 2, 1) == (2, 3)
assert lastmax(1, 2, 3, 4, 5) == (5, 4)
assert lastmax(1, 1, 1, 1, 1) == (1, 4)

Те же самое, но без itertools:

def lastmax(*sequence):
    return max(zip(sequence, range(len(sequence))))

Ещё вариант:

from operator import itemgetter

def lastmax(*sequence):
    return max(enumerate(sequence), key=itemgetter(1, 0))[::-1]

И ещё:

def lastmax(*sequence):
    return max({v: i for i, v in enumerate(sequence)}.items())

Есть и ещё несколько более эзотерических вариантов - например, через heapq.

d = {1: [1, 2, 3, 4], 3: [5, 7, 9], 9: [9, 0, 5, 4, 6]}

Вариант #1.1 (21.7 µs per loop) - кстати, v.pop() было бы быстрее, чем v.pop(0):

while d:
    for k, v in d.copy().items():
        print(f'{k}:{v.pop(0)}') if v else d.pop(k)

Вариант #1.2 (32.2 µs per loop):

while d:
    for key, vals in tuple(d.items()):
        try:
            print(f'{key}:{vals.pop(0)}')
        except IndexError:
            del d[key]

Вариант #2 (15.7 µs per loop) - самый быстрый, т.к. нет try/except и модификации:

from itertools import chain, cycle, zip_longest

def solve(mapping, placeholder=None):
    keys = cycle(mapping.keys())
    vals = chain(*zip_longest(*mapping.values(), fillvalue=placeholder))
    for key, val in zip(keys, vals):
        if val is not placeholder:
            print(f'{key}:{val}')

solve({1: [1, 2, 3, 4], 3: [5, 7, 9], 9: [9, 0, 5, 4, 6]})

Вариант #3 (27.2 µs per loop):

from itertools import repeat, starmap

def solve(mapping):
    iterf = lambda key, vals: (repeat(key), iter(vals))
    items = tuple(starmap(iterf, mapping.items()))
    for _ in max(mapping.values(), key=len):
        for ikeys, ivals in items:
            try:
                print(f'{next(ikeys)}:{next(ivals)}')
            except StopIteration:
                pass

solve({1: [1, 2, 3, 4], 3: [5, 7, 9], 9: [9, 0, 5, 4, 6]})

Вопрос элементарный. Изучайте 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 (для возрастающих субпоследовательностей):

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))]