Code Review

00_original.py

# Это оригинальный код, всё веселье ниже и по пунктам

limit = 5

def intify(array):
    latest = []
    for i in array:
        row = []
        for j in i:
            row.append(int(j))
        latest.append(row)
    return latest

def find_index(item, array):
    last_index = 0
    indexes = []
    while last_index + 1 < len(array):
        try:
            # slice array from current index and find item occuriencies
            last_index = array[last_index:].index(item) + last_index
            # if found - append index to list
            indexes.append(last_index)
            # increase to find item in rest of array
            last_index += 1
        except ValueError:
            return indexes
    return indexes

def reduce_array(what, where):
    '''
    what - what array do we look for,
    where - what array do we look in
    '''
    map = []
    result_index = len(where)
    if len(what) == 0:
        return where
    for item in what:
        indexes = find_index(item, where)
        if len(indexes) > 0:
            map.append(indexes)
    # start examine from last element in map, if 'what' is present in 'where' and map's isn't max,
    # then points should begin from last index of 'where' consequitively
    if len(map) < limit:
        try:
            # index of last element
            index = len(where) - 1
            for i in range(-1, -len(map), -1):
                map[i].index(index)
                index -= 1
            result_index = index
            print result_index
        except ValueError:
            pass
    else:
        # for every occuriency we should find full consequitive path 
        for m in map[0]:
            try:
                a = m
                for point in map[1:]:
                    a += 1
                    point.index(a)
                result_index = m
                break
            except ValueError:
                continue
    
    return where[:result_index]

01_intify.py

# Название функции неплохое, но никак не намекает на то, что мы будем работать с матрицами
# Название параметра array вводит в заблуждение, что пойдет любой массив, тогда как на самом деле
# подойдет только двухмерный.
# Правильно:
#     def intify(matrix):
def intify(array):
    # Почему эта переменная называется latest? Она будет содержать последнюю строку/элемент чего-то?
    # Но это не так! Это просто наглая попытка наебать читающего твой код.
    latest = []
    # Имя переменной i всем цивилизованным сообществом зарезервировано для целочисленных индексов.
    # В данном случае это строка в матрице и называться она должна соответствуще
    for i in array:
        row = []
        # Аналогично j - целочисленный индекс, элемент должен называться по-другому
        for j in i: 
            row.append(int(j)) # Зачем приводить целое число к целому? ;D
        latest.append(row)
    return latest

# R1
def intify(matrix):
    result = []
    for line in matrix:
        # Это стандартный шаблон для использования map() - мы поэлементно обрабатываем массив
        # Наличие some_list.append(...) в цикле и some_list = [] перед ним просто пахнет
        row = []
        for item in line:
            row.append(int(item))
        result.append(row)
    return result

# R2
def intify(matrix):
    # Опять обрабатываем поэлементно и собираем результаты -> map
    result = []
    for line in matrix:
        result.append(map(int, line))
    return result

# R3
def intify(matrix):
    # map(lambda ...) - дурной паттерн, лучше переписать, используя списковое выражение
    return map(lambda line: map(int, line), matrix)

# R4
def intify(matrix):
    return [map(int, line) for line in matrix]
# Вообще-то, эта функция не используется и должна быть безжалостно вырезана

# R5

02_find_index.py

# Название функции активно вводит в заблуждение, 
# функция-то возвращает список найденных индексов
def find_index(item, array):
    last_index = 0
    indexes = []
    # Долго, дорого, непонятно
    # Проще просто пробежать по массиву и запомнить индексы где элемент совпадает
    while last_index + 1 < len(array):
        try:
            # slice array from current index and find item occuriencies
            last_index = array[last_index:].index(item) + last_index
            # if found - append index to list
            indexes.append(last_index)
            # increase to find item in rest of array
            last_index += 1
        except ValueError:
            return indexes
    return indexes

# R1
def find_indexes(item, array):
    indexes = []
    # Это традиционная парадигма для итерации с индексами
    for i, value in enumerate(array):
        # Мы генерируем элементы и засовываем их в список
        # Более гибко и, на мой вкус, более стильно будет сначала генерировать,
        # а потом всё собрать, для этого можно использовать генератор
        if value == item:
            indexes.append(i)  
    return indexes

# R2
def find_indexes(item, array):
    # Это генератор, при его вызове мы получим ленивую последовательность индексов элемента item
    # Такой простой генератор лучше переписать с помощью генераторного выражения
    def _find_indexes():
        for i, value in enumerate(array):
            if value == item:
                yield i  
    return list(_find_indexes())

# R3
def find_indexes(item, array):
    # Можно подставить в list() напрямую, даже лучше 
    # - когда генераторное выражение единственный аргумент, то скобки вокруг него можно опустить
    indexes = (i for i, value in enumerate(array) if value == item)
    return list(indexes)

# R4
def find_indexes(item, array):
    # Для превращения генераторного выражения в список есть специальный синтаксис
    return list(i for i, value in enumerate(array) if value == item)

# R5
def find_indexes(item, array):
    return [i for i, value in enumerate(array) if value == item]

03_reduce_array.py

# Название функции слабо намекает на то, что мы как-то будем уменьшать массив, как - хз
# Кроме того, в ФП, reduce - устоявшееся название для определённой функции обработки списка/массива
# Таким образом, reduce_array как бы намекает на то, что мы займёмся чем-то подобным, но нет
# мы занимаемся чем-то другим.
# 
# docstring говорит нам, что мы что-то будем искать. Мы же вроде собирались уменьшить массив?
# 
# Название аргументов соответствует docstring'у, но не соответствует тому, что мы тут делаем
# 
# Порядок аргументов обратен логичному. where - это то с чем мы работаем, what - то, что вырезаем,
# т.е. модификатор, что-то менее важное, кроме того, нам нужно вырезвать what из конца where, так 
# почему он в начале?
# 
# Алгоритм избыточный, странный и нелогичный.
# Какого хуя творится внутри функции совершенно непонятно, несмотря на комментарии.
# Далее см. префиксы #--
def reduce_array(what, where):
    '''
    what - what array do we look for,
    where - what array do we look in
    '''
    #-- map() - стандартная функция, некошерно её перебивать,
    #--         к тому же, это имя никак не поясняет, что мы туда сейчас засунем,
    #--         а также то, что мы затем будем вытворять с этой переменной
    map = []
    result_index = len(where)
    if len(what) == 0:
        return where
    #-- сборка результатов в цикле вместо спискового выражения
    for item in what:
        indexes = find_index(item, where)
        if len(indexes) > 0:
            map.append(indexes)
    #-- Комментируем сразу всё, хотя магия, нуждающаяся в пояснениях, распределена по веткам
    # start examine from last element in map, if 'what' is present in 'where' and map's isn't max,
    # then points should begin from last index of 'where' consequitively
    #-- Глобальная переменная! Да ещё маленькими буквами и с неспецифическим названием
    #-- В питоне константы принято называть всеми заглавными
    if len(map) < limit:
        #-- слишком большое тело try, простор для непреднамеренного проглатывания исключений
        try:
            #-- Ёбаная магия и сраное колдовство
            # index of last element
            index = len(where) - 1
            for i in range(-1, -len(map), -1):
                map[i].index(index)
                index -= 1
            result_index = index
            print result_index
        except ValueError:
            pass
    else:
        # for every occuriency we should find full consequitive path 
        #-- Ёбаная магия и сраное колдовство, дубль 2
        for m in map[0]:
            #-- слишком большое тело try, простор для непреднамеренного проглатывания исключений
            try:
                a = m
                for point in map[1:]:
                    a += 1
                    point.index(a)
                result_index = m
                break
            except ValueError:
                continue
    
    return where[:result_index]
# Если ты веришь, что это работает, то тебе пора основать свою религию. 
# Резюме - подвергнуть немедленному испепеляющему рефакторингу

# R1
# Первая тупая реализация алгоритма:
#   - найти максимальный совпадающий участок
#   - вырезать его
def cut_tail(src, tail):
    max_overlap = min(len(src), len(tail))
    for i in range(max_overlap, 0, -1):
        if src[-i:] == tail[:i]:
            return src[:-i]
    else:
        return src

# R1A
# Те же яйца, только с циклом свёрнутым в генераторное выражение
def cut_tail(src, tail):
    max_overlap = min(len(src), len(tail))
    variants = (src[:-i] for i in range(max_overlap, 0, -1) if src[-i:] == tail[:i])
    return next(variants, src)