Simple four function calculator in python

Question

I just finished my first Python GUI project, a simple four function calculator. I think I've tested it pretty thoroughly. I'm learning python and OOP, so any critiques would be welcome.

In general, I was wondering if there is a more automated way to generate the number buttons and their actions - it was a lot of copy and paste, while only changing a single character and the name of the function.

import sys
from PyQt4 import QtGui, QtCore
class Calc(QtGui.QMainWindow):
 def __init__(self):
 super(Calc,self).__init__()
 self.setGeometry(50,50,220,300)
 self.setWindowTitle('PyCalc')
 self.setWindowIcon(QtGui.QIcon('favicon.png'))
 self.string = ''
 self.home()
 def home(self):
 self.lcd = QtGui.QLCDNumber(self)
 self.lcd.setDigitCount(8)
 self.lcd.move(20,20)
 self.lcd.resize(125,50)
 btn1 = QtGui.QPushButton('1', self) # first argument is the text
 btn1.clicked.connect(self.button1) # note the lack of parens on method
 btn1.resize(50,50) # sizeHint - automatic sizing
 btn1.move(10,180) # x and y location
 btn2 = QtGui.QPushButton('2', self) 
 btn2.clicked.connect(self.button2) 
 btn2.resize(50,50) 
 btn2.move(60,180)
 btn3 = QtGui.QPushButton('3', self) 
 btn3.clicked.connect(self.button3) 
 btn3.resize(50,50) 
 btn3.move(110,180)
 btn4 = QtGui.QPushButton('4', self) 
 btn4.clicked.connect(self.button4) 
 btn4.resize(50,50) 
 btn4.move(10,130)
 btn5 = QtGui.QPushButton('5', self) 
 btn5.clicked.connect(self.button5) 
 btn5.resize(50,50) 
 btn5.move(60,130)
 btn6 = QtGui.QPushButton('6', self) 
 btn6.clicked.connect(self.button6) 
 btn6.resize(50,50) 
 btn6.move(110,130)
 btn7 = QtGui.QPushButton('7', self) 
 btn7.clicked.connect(self.button7) 
 btn7.resize(50,50) 
 btn7.move(10,80)
 btn8 = QtGui.QPushButton('8', self) 
 btn8.clicked.connect(self.button8) 
 btn8.resize(50,50) 
 btn8.move(60,80)
 btn9 = QtGui.QPushButton('9', self) 
 btn9.clicked.connect(self.button9) 
 btn9.resize(50,50) 
 btn9.move(110,80)
 btn0 = QtGui.QPushButton('0', self) 
 btn0.clicked.connect(self.button0) 
 btn0.resize(50,50) 
 btn0.move(60,230)
 btnDec = QtGui.QPushButton('.', self) 
 btnDec.clicked.connect(self.decimal) 
 btnDec.resize(50,50) 
 btnDec.move(110,230)
 btnEquals = QtGui.QPushButton('=', self) 
 btnEquals.clicked.connect(self.equals)
 btnEquals.resize(50,50) 
 btnEquals.move(10,230)
 btnAdd = QtGui.QPushButton('+', self) 
 btnAdd.clicked.connect(self.plus) 
 btnAdd.resize(50,50) 
 btnAdd.move(160,230)
 btnSubtract = QtGui.QPushButton('-', self) 
 btnSubtract.clicked.connect(self.minus) 
 btnSubtract.resize(50,50) 
 btnSubtract.move(160,180)
 btnMult = QtGui.QPushButton('x', self) 
 btnMult.clicked.connect(self.mult) 
 btnMult.resize(50,50) 
 btnMult.move(160,130)
 btnDiv = QtGui.QPushButton('/', self) 
 btnDiv.clicked.connect(self.divide) 
 btnDiv.resize(50,50) 
 btnDiv.move(160,80)
 btnClear = QtGui.QPushButton('C', self) 
 btnClear.clicked.connect(self.clear) 
 btnClear.resize(50,50) 
 btnClear.move(160,30)
 # this should always be last
 self.show()
 def button0(self):
 self.string += '0'
 self.lcd.display(self.string)
 def button1(self):
 self.string += '1'
 self.lcd.display(self.string)
 def button2(self):
 self.string += '2'
 self.lcd.display(self.string)
 def button3(self):
 self.string += '3'
 self.lcd.display(self.string)
 def button4(self):
 self.string += '4'
 self.lcd.display(self.string)
 def button5(self):
 self.string += '5'
 self.lcd.display(self.string)
 def button6(self):
 self.string += '6'
 self.lcd.display(self.string)
 def button7(self):
 self.string += '7'
 self.lcd.display(self.string)
 def button8(self):
 self.string += '8'
 self.lcd.display(self.string)
 def button9(self):
 self.string += '9'
 self.lcd.display(self.string)
 def mult(self):
 self.val1 = float(self.string)
 self.string = ''
 self.op = '*'
 def plus(self):
 self.val1 = float(self.string)
 self.string = ''
 self.op = '+'
 def minus(self):
 if self.string == '':
 self.string = '-'
 self.lcd.display(self.string)
 else:
 self.val1 = float(self.string)
 self.string = ''
 self.op = '-'
 def divide(self):
 self.val1 = float(self.string)
 self.string = ''
 self.op = '/'
 def clear(self):
 self.val1 = ''
 self.string = ''
 self.lcd.display(0)
 def equals(self):
 if self.op == '*':
 self.ans = self.val1.__mul__(float(self.string))
 elif self.op == '+':
 self.ans = self.val1.__add__(float(self.string))
 elif self.op == '-':
 self.ans = self.val1.__sub__(float(self.string))
 elif self.op == '/':
 self.ans = self.val1.__truediv__(float(self.string))
 self.string = ''
 self.val1 = ''
 print self.ans
 self.lcd.display(self.ans)
 def decimal(self):
 self.string += '.'
 self.lcd.display(self.string)
 def close_application(self):
 # add functionality to see if we want to exit
 choice = QtGui.QMessageBox.question(self,'Exit','Are you sure you want to exit?',
 QtGui.QMessageBox.Yes | QtGui.QMessageBox.No)
 if choice == QtGui.QMessageBox.Yes:
 sys.exit()
 else:
 pass
def main(): 
 app = QtGui.QApplication(sys.argv)
 GUI = Calc()
 sys.exit(app.exec_())
if __name__ == '__main__':
 main()

Answer 1

def button0(self):
 self.string += '0'
 self.lcd.display(self.string)
def button1(self):
 self.string += '1'
 self.lcd.display(self.string)

All of these numbers to 9 seem to do the same thing (append to the string and then display the updated number on the LCD). I think you should be able to use a single function that takes an argument to update your numbers.

 btn1 = QtGui.QPushButton('1', self) # first argument is the text
 btn1.clicked.connect(self.button1) # note the lack of parens on method
 btn1.resize(50,50) # sizeHint - automatic sizing
 btn1.move(10,180) # x and y location
 btn2 = QtGui.QPushButton('2', self) 
 btn2.clicked.connect(self.button2) 
 btn2.resize(50,50) 
 btn2.move(60,180)

If you don't want to repeat all of this code, you should be able to put the different number button objects inside of a collection (i.e., a list).

number_buttons = []
for x in range(1, 10):
 # update your calculations for x and y for move here
 button = QtGui.QPushButton(str(x), self) 
 button.clicked.connect(number_button_action(x))
 button.resize(50, 50)
 button.move(x, y)
 number_buttons.append(button)

You can refer to the button objects after using number_buttons[num - 1].

For the repeating operation buttons you should similarly be able to put the values inside of a tuple.

operations = (('.', self.decimal), ('=', self.plus), ('-', self.minus), ...) 

In the tuple, we're pairing the symbol for the operation and the specific function for the operation together. You can iterate through the operations tuple and create a button for each of the 2-tuples.

All of your button sizes are the same, so again all of you should need to change around is how you're calculating the x and y for your move operation (seems to go in a predictable pattern).

Answer 2

Try something like this:

class Calc(QtGui.QMainWindow):
 def __init__(self):
 # code omitted
 self.button_dict = {}
 self.home()
 move_map = [(60, 230), (10, 180), (60, 180), (110, 180), (10, 130), (60, 130), (110, 130), (10, 80), (60, 80), (110, 80)]
 def home(self):
 # code omitted
 def button_maker(self, plus_equal):
 def return_me(self):
 self.string += str(plus_equal)
 self.lcd.display(self.string)
 return return_me
 for i in range(0,10):
 x = str(i)
 button_dict[x] = QtGui.QPushButton(x, self)
 button_dict[x].clicked.connect(button_maker(self, i))
 button_dict[x].resize(50, 50)
 button_dict[x].move(move_map[i][0], move_map[i][1])
 # code omitted

Also, see @abrarisme 's answer for the other operations. For the numbers, I opted for a dictionary instead of a list, but either should do.

The function button _maker will return a button function for you to use with the connect call.

I would also disclaim here that I wasn't able to get PyQt4 installed in my environment properly, so I wasn't actually able to test any code.