Question

我有一个看起来如下的输入文件：

4 * 2 ^ 3 + 4 ^ 1 2 * 1 ^ 2 + 2 ^ 3

可能会有更多行。我需要做的是提取*符号之前的值，因此对于第一行是4。然后，我需要制作一个元组g = [(2,3),(4,1)]，这样，元组对之间就被+分开，然后对对本身就被^分开。

my_input = open('input.txt').readlines()
lines = [str(line) for line in 
open('input.txt','r').read().split('\n')]
per_line = str(lines[0]).split('*')
x = int(per_line[0])
terms = str(per_line[1].split('+'))

现在，如果我print terms我得到['2 ^ 3 ', ' 4 ^ 1']，并且如果我print x我得到4，那似乎可行。但是现在我需要以描述的元组形式获取这些值。如果我在'^'上再次分裂，我将无法获得所需的结果，而是["['2 ", " 3 ', ' 4 ", " 1']"]，这是行不通的。我尝试过factors = str(terms.split('^'))。

此外，我需要对此进行迭代，以使其适用于所有行，但以后可以这样做。我首先要确保它仅适用于第一行。

有什么建议吗？

Answer 1

现在，如果我print terms我得到['2 ^ 3 ', ' 4 ^ 1']

然后对于terms中的每个值（字符串），您必须在'^'上分割，然后将每个结果转换为int并打包为元组：

g = [tuple(map(int, x.split('^'))) for x in terms]

是

获取每个字符串，例如'2 ^ 3 '
将其拆分为列表，例如['2 ', '3 ']
使用int将map函数应用于每个列表元素
使映射结果元组

Answer 2

我将首先收集字符串中的所有数字，将它们分配给各自的元组，然后将它们分配给列表。

my_input = open('input.txt').readlines()
lines = [str(line) for line in
open('input.txt','r').read().split('\n')]
per_line = str(lines[0]).split('*')
x = int(per_line[0])
terms = str(per_line[1].split('+'))

#Start Soln Here ->
to_parse = terms.replace('^', ',')
#Tuples to populate final list g
a = ()
b = ()
#To hold int-converted values from file stream
operands = []
for i in to_parse:
    if i.isdigit():
        operands.append(int(i))
    #to prevent the inclusion of operators.
    else:
        continue
#operands list is populated now... Last thing to do is assign them to your tuples!
a = operands[0], operands[1]
b = operands[2], operands[3]
g = [a,b]
#test output
print(g)

返回

[(2, 3), (4, 1)]

Process finished with exit code 0

这是一个chatterbox解决方案，但它应该可以完成工作

Answer 3

这是一种更好的方法：

import re

x = []
g = []
with open('input.txt') as infile:
    for line in infile:
        nums = re.split(r'[\*\^\+]', line)
        x.append(int(nums[0]))
        g.append((int(nums[1]), int(nums[2])))

print(x) # [4, 2]
print(g) # [(2, 3), (1, 2)]

Answer 4

如果要解析通用表达式，则可能要构造一个解析树：

from lark import Lark

parser = Lark('''
    ?sum: product
        | sum "+" product       -> add
        | sum "-" product       -> sub

    ?product:
        | product "*" exponent  -> mul
        | product "/" exponent  -> div
        | exponent

    ?exponent:
        | item "^" exponent     -> exp
        | item

    ?item: NUMBER               -> number
        | "-" item              -> neg
        | "(" sum ")"

    %import common.NUMBER
    %import common.WS
    %ignore WS''', start='sum')

s = '4 * 2 ^ 3 + 4 ^ 1'
tree = parser.parse(s)
print(tree.pretty())

这将导致：

add
  mul
    number      4
    exp
      number    2
      number    3
  exp
    number      4
    number      1

输入行必须转换为元组

4 个答案: