1

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

我所拥有的是......“* + 123”

我想要的是.....“1 * 2 + 3”

我确定答案很简单，但我已经为此绞尽脑汁了.....我是初学者

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

这是我的代码

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

但我最终得到的是：“1*2+”

4

4 回答 4

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'

拆开第一部分，从中制作一个循环。cycle 在 next() 上保持循环迭代。
列表推导构造了 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

为避免最后一个字符的丢失，您可以为除 last(part2[:-1]) 之外的 part2 的所有字符构造列表，然后添加 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'
于 2014-11-14T01:02:20.337 回答
0

你很近！

这是你的代码的一个版本 - 继续一个字符，然后砍掉结尾

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)
于 2014-11-14T00:25:43.773 回答
0

尝试使用在 Python 中使用可迭代对象时值得一试的itertools 。

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'
于 2014-11-14T00:46:08.737 回答
0

你对你想做的事情非常、非常具体。如果这是您尝试做的练习，其中的说明是“给定一个 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 只是设置函数，命名为alternate_half，这里带有一个参数或输入值，称为“输入”，它是您在上面标记为公式的字符串。
  • 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')]。所以我们可以使用位置参数 ininput_a并附加到input_b.
  • 最后，我们只是检查以确保如果 input_a 更短，我们不会尝试让字符超过字符串的长度。因为我们将字符串分成两半，所以input_a不会比 input_b 短一个以上的字符。
于 2014-11-14T00:55:11.223 回答