解释

Question

好的，我试图做的是在字符串的其余部分中替换字符串中的前两个值。

我拥有的是......＆＃34; * + 123＆＃34;

我想要的是.....＆＃34; 1 * 2 + 3＆＃34;

我确定答案很简单，但我已经对此感到头疼......我是初学者

我尝试将前两个位置分开并将它们放入单独的变量中并以这种方式交替：

这是我的代码

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

for i in range(len(second_part)-1):
    expanded = expanded + second_part[i] + first_part[i]
print expanded

但我最终得到的是：＆＃34; 1 * 2 +＆＃34;

Answer 1

类似的东西，使用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'

拆开第一部分，从中做出一个循环。循环在next（）上循环迭代迭代 list comprehension构造part2中每个数字的列表，这个数字与itertools.cycle上的next（）连接，名为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

为了避免最后一个字符丢弃，你可以为part2的所有字符构建列表，除了last（part2 [： - 1]），然后添加part2的最后一个字符（part2 [-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'

Answer 2

你很亲密！

这是你的代码的一个版本 - 保持一个字符，然后切断结束

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

你可能不喜欢那些额外的印章（你不应该）。算法的问题在于，当事情的长度不均匀时，它处理得不好，因为你将列表分成两半。处理偶数/奇数的更好方法是使用“模数”运算符

Modulo operator in Python

这是一种使用一些Python技巧解决问题的有趣方法，如果你想通过它来实现它可能具有教育意义：）

formula = '*+123'   
out = ''

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

print(out)

Answer 3

尝试使用itertools，这在Python中使用iterables时值得检查。

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'

Answer 4

您正在尝试做的事情非常非常具体。如果这是您正在尝试执行的练习，其中的说明是，＆＃34;给定5个字符的字符串，创建一个新字符串，其中前两个字符与新字符串中的最后3个字符交替＆＃34;那么上面的代码将在这个有限的情况下为你工作。

但是，如果您正在尝试解决问题，那么了解您要解决的问题以及解决问题的原因将会有所帮助。

正如en_Knight指出的那样，此功能不适用于各种输入。一般而言，计算的关键在于创建代码，通过足够通用以使用不同的输入多次解决相同的问题，使任务变得更容易。

一些样式注释：获取列表的部分时，只需要在不是0时提供起始编号，或者在不在列表末尾时提供结束编号。而不是

second_part = formula[3:len(formula_chosen)]

你可以简单地写一下：

second_part = formula[3:]

:之后的空白部分表示＆＃34;将所有内容发送到字符串的末尾＆＃34;。

通过编写代码让你了解我的意思，这是一个更通用的解决方案，这里有一个函数可以完成你在任何长度的字符串上描述的内容：将它们精确地分成两半，然后交替使用字符。< / p>

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只是设置名为alternate_half的函数，这里有一个参数或输入值，称为＆＃34;输入＆＃34;这是您在上面标记为公式的字符串。
input[:len(input)/2]``input[len(input)/2:] - 这些都只是主要列表的一部分。它使用上面的技巧 - python自动填充0或列表的末尾。它还使用了这样一种技巧：当用Python中的整数除法时，你得到一个整数作为回报。因此，例如在5长度字符串的情况下，len(input)/2是2，所以input_a是前2个字符，input_b是字符串2到字符串的结尾，所以＆＃34; 123＆＃34;
enumerate为可迭代（例如字符串）中的每个项返回一个计数器。因此enumerate("*+123")在功能上等同于[(0, '*'), (1, '+'), (2, '1'), (3, '2'), (4, '3')]。所以我们可以使用input_a中的位置参数并附加到input_b中的相应字符。
最后我们只是检查以确保如果input_a更短，我们不会尝试让字符超过字符串的长度。因为我们将字符串分成两半，input_a永远不会比input_b短一个字符。

我想在python中将前两个字符替换为字符串的其余部分

4 个答案:

解释