Вы очень, очень конкретны в том, что вы пытаетесь сделать. Если это упражнение, которое вы пытаетесь выполнить, в котором инструкции таковы: «Учитывая строку из 5 символов, создайте новую строку, в которой первые два символа чередуются с последними 3 в новой строке», тогда приведенный выше код будет работать для вас в этом ограниченном случае.

Однако, если вы пытаетесь решить проблему, было бы полезно иметь более подробную информацию о проблеме, которую вы пытаетесь решить, и о том, почему вы хотите ее решить.

Как указывает en_Knight, эта функция не работает с различными входными данными. И смысл вычислений, как правило, заключается в создании кода, который упрощает задачи, будучи достаточно общим, чтобы решать одни и те же задачи много раз с разными входными данными.

Несколько замечаний по стилю: при получении разделов списков вам нужно указать только начальный номер, если он не равен 0, или конечный номер, если он не находится в конце списка. Итак, вместо

second_part = formula[3:len(formula_chosen)]    

вы можете просто написать:

second_part = formula[3:]    

где пустая часть после : сигнализирует "Получить все содержимое до конца строки".

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

def alternate_half(input):
    output = ""
    input_a = input[:len(input)/2]
    input_b = input[len(input)/2:]
    for pos, char in enumerate(input_b):
        output += char 
        if len(input_a) > pos:
            output += input_a[pos]
    return output

Объяснение:

• def просто устанавливает функцию с именем alter_half здесь с параметром или входным значением, называемым «input», которое представляет собой строку, которую вы пометили как формулу выше.
• input[:len(input)/2]``input[len(input)/2:] - это просто фрагменты основного списка. Он использует описанный выше прием — этот python автоматически заполняет 0 или конец списка. Он также использует трюк, заключающийся в том, что при делении на целые числа в Python вы получаете взамен целое число. Так, например, в случае строки длиной 5 len(input)/2 равно 2, поэтому input_a — это первые 2 символа, а input_b — это символы от 2 до конца строки, поэтому «123».
• enumerate возвращает счетчик для каждого элемента в итерируемом объекте (например, в строке). Итак, enumerate("*+123") функционально эквивалентно [(0, '*'), (1, '+'), (2, '1'), (3, '2'), (4, '3')]. Таким образом, мы можем использовать позиционный аргумент в input_a и добавить к соответствующему символу в input_b.
• Наконец, мы просто проверяем, что если input_a короче, мы не пытаемся получить символ, превышающий длину строки. Поскольку мы делим строки пополам, input_a никогда не будет короче, чем input_b, более чем на один символ.

что-то вроде этого, используя itertools.cycle(). Это будет работать для строки любой длины и любой длины part1, которую вы можете решить.. (просто замените эти 2 переменной)

In [35]: from itertools import cycle

In [36]: s='*+123'

In [37]: part1=cycle(s[:2])

In [38]: part2=s[2:]

In [39]: processed_string=''.join([digit+part1.next() for digit in part2])[:-1]

In [40]: processed_string
Out[40]: '1*2+3'

Разберите первую часть, сделайте из нее цикл. Cycle поддерживает циклическую итерацию на next().
Понимание списка создает список каждой цифры в part2, объединенной с next() в itertools.cycle, называемом part1 (это делает его чередующимся между * и +).
''.join() этот список для создания строки. Избавьтесь от лишнего в конце, так как он не нужен для последней итерации.

Объяснение

In [50]: part1=cycle(s[:2])

In [51]: part1.next()
Out[51]: '*'

In [52]: part1.next()
Out[52]: '+'

In [53]: part1.next()
Out[53]: '*'

In [54]: part1.next()
Out[54]: '+'

In [55]: #alternates

In [56]: # list comp

In [57]: [digit for digit in part2]
Out[57]: ['1', '2', '3']

In [58]: [digit+part1.next() for digit in part2]
Out[58]: ['1*', '2+', '3*']

In [59]: # this is a list of strings and can be joined using join.

In [60]: ''.join([digit+part1.next() for digit in part2])
Out[60]: '1+2*3+'

In [61]: # this has a trailing extra character. get rid of it using slices

In [62]: ''.join([digit+part1.next() for digit in part2])[:-1]
Out[62]: '1*2+3'

In [63]: #solution

Чтобы избежать удаления последнего символа в конце, вы можете создать список для всех символов части2, кроме последнего (часть2[:-1]), а затем добавить последний символ части2(часть2[-1]) следующим образом:

In [64]: part1=cycle(s[:2])

In [65]: ''.join([digit+part1.next() for digit in part2[:-1]])
Out[65]: '1*2+'

In [66]: ''.join([digit+part1.next() for digit in part2[:-1]])+part2[-1]
Out[66]: '1*2+3'

Вы можете заключить его в такую ​​​​функцию:

In [67]: # enclose in a function

In [68]: def process_text(text,no_of_symbols):
   ....:     part1=cycle(text[:no_of_symbols])
   ....:     part2=text[no_of_symbols:]
   ....:     return ''.join([digit+part1.next() for digit in part2])[:-1]
   ....: 

In [69]: process_text('+*-123456',3)
Out[69]: '1+2*3-4+5*6'

Вы близко!

Вот версия вашего кода, которая работает — продолжайте на один символ, а затем обрежьте окончание

formula = '*+*123'    
first_part = formula[0:3]    
second_part = formula[3:len(formula)]    
print first_part    
print second_part    
expanded = ''

for i in range(len(second_part)):#changed here
    expanded = expanded + second_part[i] + first_part[i]

expanded = expanded[:-1] #changed here
print expanded

Вам, вероятно, не нравится эта дополнительная отбивная (вы не должны). Проблема с вашим алгоритмом в том, что он плохо работает, когда вещи даже не по длине, потому что вы делите список пополам. Лучший способ справиться с четностью/нечетностью — использовать оператор «по модулю».

оператор по модулю в Python

Вот интересный способ решить проблему, используя некоторые приемы Python, если вы хотите пройти через это, это может быть познавательно :)

formula = '*+123'   
out = ''

for c1,c2 in zip(formula,formula[::-1]):
    out += c2 + c1
out = out[:len(out)/2][::-1]     

print(out)

Попробуйте использовать itertools, которые стоит проверить при работе с итерируемыми объектами в Python.

import itertools

def alternate_characters(formula):
    try:
        if type(formula) is str:
            operators = formula[:2]
            operands = formula[2:]
            iterable = itertools.izip_longest(operands, operators)
            alt = ''
            for tup in iterable:
                for k in tup:
                    if k is not None:
                        alt += k

            return alt
    except TypeError:
        print "Formula must be a string"

С входной строкой:

print alternate_characters('*+123')
'1*2+3'

С нестроковым вводом:

print alternate_characters(*+123)
'TypeError: alternate_characters() argument after * must be a sequence, not int'