Program does not accept argument Python

Question

I am creating a postfix calculator that accepts arithmetic expressions and first pushes the operators to the stacl.

./pythonfilename 3 4 1 + - was used as my input. However, since no output is displayed, I tried to debug my program to see why my program is not taking in my argument. does not result in printing any output. I hit Ctrl+C to display the Traceback Call and it points out x = sys.stdin.readlines.

#!/usr/bin/python

import sys
import fileinput

class Stack:
    def __init__(self):
        self.items = []

    def isEmpty(self):
        return self.items == []

    def push(self,item):
        self.items.append(item)

    def pop(self):
        return self.items(pop)

    def peek(self):
        return self.items[len(self.items)-1]

    def size(self):
        return len(self.items)

    def is_number(line):
        try:
            float(line)
        except ValueError:
            return False        

def infixtoPostfix():
    initStack=Stack()
    x = sys.stdin.readlines() #read user input 
    for lines in x:#for lines in fileinput.input():
        for line in lines.strip().split(" "):
            if is_number(line):
                initStack.push(line)
                line = float(line)
            elif line =='+':
                firstNum = initStack.pop()
                secNum = initStack.pop()
                result = firstNum + secNum
                initStack.push(result)
                print initStack.peek()              

            elif line == '-':
                firstNum = initStack.pop()
                secNum = initStack.pop()
                result = firstNum - secNum
                initStack.push(result)
                print initStack.peek()

            elif line == '*':
                firstNum = initStack.pop()
                secNum = initStack.pop()
                result = firstNum * secNum
                initStack.push(result)
                print initStack.peek()
            elif line == "/":
                firstNum = initStack.pop()
                secNum = initStack.pop()
                result = firstNum / secNum
                initStack.push(result)
                print initStack.peek()
            elif line == "%":
                firstNum = initStack.pop()
                secNum = initStack.pop()
                result = firstNum % secNum
                initStack.push(result)
                print initStack.peek()

infixtoPostfix()

Answer 1

The standard way to read from a pipe (cat ... | python myprog.py) is

import sys

for line in sys.stdin:
    print ">", line

line will here include the final '\n'

If instead you want to take arguments on the command line (python myprog.py 3 4 1 + -), you would use sys.argv[1:] (sys.argv[0] contains myprog.py).

To get a consistent lexing of the input you need to first check sys.argv and then split sys.stdin:

def lex_input():
    "Returns a list of tokens."
    tokens = []
    if len(sys.argv) > 1:
        tokens = sys.argv[1:]
    else:
        for line in sys.stdin:
            tokens += line.split()
    return tokens

then you just need to change your infixPostfix() function to use this token-array (instead of doing both the parsing and the evaluation in the same function).

ps: a more succinct way of writing the individual clauses would be:

elif token == '+':
    push(pop() + pop())

but it depends on what you're trying to accomplish..

Update: full'ish solution

Update2: with debug statements to visualize the stack (removed Stack class in favor of a regular list for brevity)

import sys

STACK = []
push = STACK.append
pop = STACK.pop

OPERATIONS = {
    '+': lambda b, a: a + b,
    '-': lambda b, a: a - b,
    '*': lambda b, a: b * a,
    '/': lambda b, a: b / a,
}

def infixtoPostfix(tokens):
    print '%-15s %5s %-15s' % ('STACK before', 'token', 'STACK after')
    print '-'*15, '-'*5, '-'*15

    for token in tokens:
        print '%15s %5r' % (STACK, token),

        if token not in OPERATIONS:
            push(int(token))
        else:
            push(OPERATIONS[token](pop(), pop()))

        print '%15s' % STACK

def lex_input():
    "Returns a list of tokens."
    tokens = []
    if len(sys.argv) > 1:
        tokens = sys.argv[1:]
    else:
        for line in sys.stdin:
            tokens += line.split()
    return tokens

if __name__ == "__main__":
    infixtoPostfix(lex_input())
    # well formed programs should leave a single value on the STACK
    print "\nResult is:", STACK[0]

testing:

(dev) go|c:\srv> python rpn.py 3 4 1 + -
STACK before    token STACK after
--------------- ----- ---------------
             []   '3'             [3]
            [3]   '4'          [3, 4]
         [3, 4]   '1'       [3, 4, 1]
      [3, 4, 1]   '+'          [3, 5]
         [3, 5]   '-'            [-2]

Result is: -2

(cat rpn.txt | python rpn.py will output the same thing if rpn.txt contains 3 4 1 + -).

If you try an rpn program with a syntax error, then the program will raise an exception, e.g.:

(dev) go|c:\srv> python rpn.py 3 4 + -
STACK before    token STACK after
--------------- ----- ---------------
             []   '3'             [3]
            [3]   '4'          [3, 4]
         [3, 4]   '+'             [7]
            [7]   '-'
Traceback (most recent call last):
  File "rpn.py", line 60, in <module>
    infixtoPostfix(lex_input())
  File "rpn.py", line 45, in infixtoPostfix
    push(OPERATIONS[token](pop(), pop()))
  File "rpn.py", line 26, in pop
    return STACK.pop()
IndexError: pop from empty list

In a real compiler that would be bad, since you don't want the end user to see details of your implementation. Instead you'd want to give them a diagnostic error message, with the exact place where your program found it.

In this case that isn't that difficult. I've omitted the debug statements to print the stack:

def infixtoPostfix(tokens):
    # make a copy of the input, for use in error handling
    input_tokens = tokens[:]  
    try:
        for i, token in enumerate(tokens):
            if token not in OPERATIONS:
                push(int(token))
            else:
                push(OPERATIONS[token](pop(), pop()))
    except IndexError:
        print 'Detected Syntax Error at token no.:', i + 1  # people count from 1..
        print ' '.join(input_tokens)
        print '%s%s' % ('-' * (1 + len(' '.join(input_tokens[:i]))), '^')
        push('SYNTAX ERROR')  # the top of the stack contains the result of the current operation..

a small change to the result printing is necessary, printing the last element in the list (STACK[-1]) which is the top of the stack instead of relying on the list/stack only having one element at the end:

if __name__ == "__main__":
    infixtoPostfix(lex_input())
    # well formed programs should leave a single value on the STACK
    print "\nResult is:", STACK[-1]

if we feed this version our program with a syntax error:

(dev) go|c:\srv> python rpn.py 34 4 + -
Detected Syntax Error at token no.: 4
34 4 + -
-------^

Result is: SYNTAX ERROR

we get a proper error message, with a little pointy 'graphic' indicating where the error was detected.

We could go further since we know that all of our operations take two elements on the stack, and give an even more detailed error message, e.g.:

Syntax Error at token "-":  Stack underflow
   The "-" operation requires two stack arguments and the stack 
   contained only one:

        Stack      token
        ---------- -----
        [37]        '-'

I'll leave the implementation of that as an exercise.

As you can see, even in this simple example there is more error handling code than evaluation code and that isn't too surprising when writing simple compilers.

Answer 2

./pythonfilename 3 4 1 + -

actually 3 4 1 + - are passed as argument not as input .

if you want to read from a file please use open('filename')

use ./pythonfilename '3 4 1 + -'

x = [sys.argv[1]]

in place of x = sys.stdin.readlines()

However then your code only process single input as argument