![[Home page]](../PythonPowered.gif "Home page"){kind=small}
| Books | Code | Blog | Python | Author | Train | Find | ©M.Lutz |
File: pygadgets-products/unzipped/_PyCalc/Calculator/calculator.py
#!/usr/local/bin/python
"""
################################################################################
PyCalc 4.0: a Python/tkinter calculator program and GUI component.
[SA] 4.0, Sep-2017: Standalone release of PyCalc, PyClock, PyPhoto, PyToe.
Copyright 2017 M.Lutz, from book "Programming Python, 4th Edition".
License: provided freely, but with no warranties of any kind.
Evaluates expressions as they are entered per operator precedence,
catches button clicks and keyboard keys for expression entry.
4.0 (2017, standalone rlease [SA])
-automatic comma separators in main display
-enhanced help display
-Mac OS port
-new configs model: file or args, more options
-extra operators via new 'more' button frame
-x! factorial, -x, int(x), and 'e' extra ops
-x^y power operator with same precedence as * and /
-statistics module functions import
3.0+ (2010, PP4E, version number retained):
-port to run under Python 3.X (only)
-drop 'L' keypress (the long type is now dead in earnest)
3.0 changes (2005, PP3E):
-use 'readonly' entry state, not 'disabled', else field is greyed
out (fix for 2.3 Tkinter change);
-avoid extended display precision for floats by using str(), instead
of `x`/repr() (fix for Python change);
-apply font to input field to make it larger;
-use justify=right for input field so it displays on right, not left;
-add 'E+' and 'E-' buttons (and 'E' keypress) for float exponents;
'E' keypress must generally be followed digits, not + or - optr key;
-remove 'L' button (but still allow 'L' keypress): superfluous now,
because Python auto converts up if too big ('L' forced this in past);
-use smaller font size overall;
-auto scroll to the end in the history window
2.0 (1999, PP2E) evaluated expression parts as entered, added integrated
command-line popups, a recent calculations history display popup, fonts
and colors configuration, help and about popups, preimported math/random
constants, and more;
1.0 (1996, PP1E) was a very simplistic calculator GUI that just built up
Pyton expressions and passed them to eval() as a whole;
done 4.0: add a commas-insertion mode (see StringVarCommas);
done 4.0: allow '**' as an operator key (added as "^" key)
todo: allow '+' and 'J' inputs for complex Numbers
todo: use new decimal type for fixed precision floats; as is, can
use 'cmd' popup windows to input and evaluate things like complex, but
can't be input via main window;
caveat: PyCalc's precision, accuracy, and some of its behaviour, is
currently bound by result of the built-in str() call;
################################################################################
"""
import sys
from tkinter import * # widgets, consts
from PP4E.Gui.Tools.guimixin import GuiMixin # quit method
from PP4E.Gui.Tools.widgets import label, entry, button, frame # widget builders
debugme = True
def trace(*args):
if debugme: print(args)
# [SA] port to Mac OS
RunningOnMac = sys.platform.startswith('darwin') # all Mac OS (X)
# [SA]: set window icons on Windows and Linux
from windowicons import trySetWindowIcon
################################################################################
# The main class - handles user interface.
# An extended Frame, on new Toplevel, or embedded in another container widget.
################################################################################
class CalcGui(GuiMixin, Frame):
Operators = "+-*/^=" # button lists, [SA] +^
Operands = ["abcd", "0123", "4567", "89()"] # customizable here
# [SA] additions, from book's subclasses
Extras = [(' x! ', 'factorial(%s)'),
('-x ', '-(%s)'),
('x^2', '(%s)**2'),
('1/x', '1.0/(%s)'),
('sqrt', 'sqrt(%s)'),
('int', 'int(%s)')]
def __init__(self, parent=None, configs=object()):
Frame.__init__(self, parent) # None=default Tk root
self.pack(expand=YES, fill=BOTH) # all parts expandable
self.eval = Evaluator() # embed a stack handler
self.text = StringVarCommas() # extended linked variable
self.text.set("0")
self.erase = 1 # clear "0" text next
self.makeWidgets(configs) # build the GUI itself
if not parent or not isinstance(parent, Frame):
self.master.title('PyCalc 4.0') # title iff owns window
self.master.iconname("PyCalc") # ditto for key bindings
self.master.bind('<KeyPress>', self.onKeyboard)
self.entry.config(state='readonly') # 3.0: not 'disabled'=grey
else:
self.entry.config(state='normal')
self.entry.focus()
self.root = parent
def makeWidgets(self, configs):
"""
build the GUI (N frames plus text-entry), register events:
"""
font = configs.Font # font, color configurable
bg, fg = configs.BgColor, configs.FgColor
self.entry = entry(self, TOP, self.text)
self.entry.config(font=font) # 3.0: make display larger
self.entry.config(justify=RIGHT) # 3.0: on right, not left
#self.entry.pack(expand=NO, fill=X) # [SA] grow vertically too
for row in self.Operands:
frm = frame(self, TOP)
for char in row:
if RunningOnMac:
# [SA] emulate colored buttons
l = label(frm, LEFT, char,
fg=fg, bg=bg, font=font)
l.bind('<Button-1>', lambda e, op=char: self.onOperand(op))
else:
button(frm, LEFT, char, lambda op=char: self.onOperand(op),
fg=fg, bg=bg, font=font)
frm = frame(self, TOP)
for char in self.Operators:
if RunningOnMac:
# [SA] emulate colored buttons
l = label(frm, LEFT, char,
fg=bg, bg=fg, font=font)
l.bind('<Button-1>', lambda e, op=char: self.onOperator(op))
else:
button(frm, LEFT, char, lambda op=char: self.onOperator(op),
fg=bg, bg=fg, font=font)
frm = frame(self, TOP)
button(frm, LEFT, 'dot ', lambda: self.onOperand('.'))
button(frm, LEFT, ' E+ ', lambda: self.text.set(self.text.get()+'E+'))
button(frm, LEFT, ' E- ', lambda: self.text.set(self.text.get()+'E-'))
button(frm, LEFT, 'cmd ', lambda: self.onMakeCmdline(configs))
button(frm, LEFT, 'help', self.help)
button(frm, LEFT, 'quit', self.quit) # from guimixin
frm = frame(self, BOTTOM)
button(frm, LEFT, 'eval ', self.onEval)
button(frm, LEFT, 'hist ', lambda: self.onHist(configs))
button(frm, LEFT, 'more ', self.onMore)
button(frm, LEFT, 'clear', self.onClear)
# [SA] make+hide additions
morefrm = frame(self, TOP)
for (lab, expr) in self.Extras:
button(morefrm, LEFT, lab, (lambda expr=expr: self.onExtra(expr)))
button(morefrm, LEFT, 'pi', lambda: self.onLiteral('pi'))
button(morefrm, LEFT, 'e', lambda: self.onLiteral('e'))
morefrm.pack_forget()
self.morefrm, self.moretgl = morefrm, 0
# [SA] bind Delete for erase on Macs (\b isn't auto)
if RunningOnMac:
class Dummy: char = '\b'
self.master.bind('<BackSpace>', lambda e: self.onKeyboard(Dummy))
def onMore(self):
"""
[SA] show/hide extra-row additions
"""
self.moretgl += 1
if self.moretgl % 2:
self.morefrm.pack(expand=YES, fill=BOTH)
else:
self.morefrm.pack_forget()
def onClear(self):
"""
clear calculator state
"""
self.eval.clear()
self.text.set('0')
self.erase = 1
def onEval(self):
"""
run eval operation: eval all still-open exprs
"""
self.eval.shiftOpnd(self.text.get()) # last or only opnd
self.eval.closeall() # apply all optrs left
self.text.set(self.eval.popOpnd()) # need to pop: optr next?
self.erase = 1
def onOperand(self, char):
"""
handle an operand button or keypress
"""
if char == '(':
self.eval.open()
self.text.set('(') # clear text next
self.erase = 1
elif char == ')':
self.eval.shiftOpnd(self.text.get()) # last or only nested opnd
self.eval.close() # pop here too: optr next?
self.text.set(self.eval.popOpnd())
self.erase = 1
else:
if self.erase:
self.text.set(char) # clears last value
else:
self.text.set(self.text.get() + char) # else append to opnd
self.erase = 0
def onOperator(self, char):
"""
handle an operator button or keypress
"""
self.eval.shiftOpnd(self.text.get()) # push opnd on left
self.eval.shiftOptr(char) # eval exprs to left?
self.text.set(self.eval.topOpnd()) # push optr, show opnd|result
self.erase = 1 # erased on next opnd|'('
def onExtra(self, expr):
"""
[SA] addition: run extra-row expr with value substitution
"""
try:
self.text.set(self.eval.runstring(expr % self.text.get()))
except:
self.text.set('ERROR')
def onLiteral(self, literal):
"""
[SA] addition: run extra-row literal expr
"""
self.text.set(self.eval.runstring(literal)) # e.g., 'pi', 'e'
def onMakeCmdline(self, configs):
"""
new non-modal top-level window for arbitrary Python code
"""
new = Toplevel() # new top-level window
new.title('PyCalc Command Line')
trySetWindowIcon(new, 'icons', 'pygadgets') # [SA] for win+lin
frm = frame(new, TOP) # only the Entry expands
label(frm, LEFT, '>>>').pack(expand=NO)
var = StringVar() # [SA] no commas here
ent = entry(frm, LEFT, var, width=40)
ent.config(font=configs.Font) # [SA] now configurable
onButton = (lambda: self.onCmdline(var, ent))
onReturn = (lambda event: self.onCmdline(var, ent))
button(frm, RIGHT, 'Run', onButton).pack(expand=NO)
ent.bind('<Return>', onReturn)
var.set(self.text.get())
ent.focus() # [SA] on this entry and window
def onCmdline(self, var, ent):
"""
evaluate cmdline pop-up input
"""
try:
value = self.eval.runstring(var.get())
var.set('OKAY')
if value != None: # run in eval namespace dict
self.text.set(value) # expression or statement
self.erase = 1
var.set('OKAY => '+ value)
except: # result in calc field
var.set('ERROR') # status in pop-up field
ent.icursor(END) # insert point after text
ent.select_range(0, END) # select msg so next key deletes
def onKeyboard(self, event):
"""
on keyboard press event, pretend button was pressed,
or handle extras - backspace (not delete), ?=help;
"""
pressed = event.char
if pressed != '':
if pressed in self.Operators:
self.onOperator(pressed)
else:
for row in self.Operands:
if pressed in row:
self.onOperand(pressed)
break
else: # 4E: drop 'Ll'
if pressed == '.':
self.onOperand(pressed) # can start opnd
if pressed in 'Ee': # 2e10, no +/-
self.text.set(self.text.get()+pressed) # can't: no erase
elif pressed == '\r':
self.onEval() # enter key=eval
elif pressed == ' ':
self.onClear() # spacebar=clear
elif pressed == '\b':
self.text.set(self.text.get()[:-1]) # backspace
elif pressed == '?': # [SA] +Mac delete
self.help()
def onHist(self, configs):
"""
show recent calcs log popup
"""
from tkinter.scrolledtext import ScrolledText # or PP4E.Gui.Tour
new = Toplevel() # make new window
new.title('PyCalc History')
trySetWindowIcon(new, 'icons', 'pygadgets') # [SA] for win+lin
# new window goes away on ok press or enter key
ok = Button(new, text=' OK ', command=new.destroy)
ok.pack(pady=1, side=BOTTOM) # pack first=clip last
new.bind("<Return>", (lambda event: new.destroy()))
text = ScrolledText(new, bg='beige') # add Text + scrollbar
bg, font = configs.HistBgColor, configs.HistFont # [SA] now configurable
text.config(bg=bg, font=font)
text.insert('0.0', self.eval.getHist()) # get Evaluator text
text.see(END) # 3.0: scroll to end
text.pack(expand=YES, fill=BOTH)
# go modal until window destroyed
ok.focus_set() # make new window modal:
new.grab_set() # get keyboard focus, grab app
new.wait_window() # don't return till new.destroy
def help(self):
"""
[SA] fully redesigned, and helpmessage replaces self.infobox();
called for 'help' button click, '?' keyboard press, Mac menus;
"""
from helpmessage import showhelp
showhelp(self.root, 'PyCalc', self.HelpText, forcetext=False,
setwinicon=lambda win:
trySetWindowIcon(win, 'icons', 'pygadgets'))
#if self.root: self.root.focus_force() # now done in helpmessage
HelpText = ('PyCalc 4.0\n'
'\n'
'A Python/tkinter calculator GUI.\n'
'For Mac OS, Windows, and Linux.\n'
'From the book Programming Python.\n'
'Author and © M. Lutz 1996-2017.\n'
'\n'
'Use button clicks or keyboard presses to '
'input numbers and operators, or type '
'Python expression code in a "cmd" popup.\n'
'\n'
'Keyboard usage: spacebar="clear", enter="eval", '
'.="dot", ?="help", backspace or delete=erase 1 character. '
'Comma separators are inserted automatically for '
'display as numbers are entered and shown.\n'
'\n'
'Tips:\n'
'▶ "=" assigns variables '
'(e.g., ab=99, ab+1)\n'
'▶ "eval" evaluates pending expressions\n'
'▶ "more" shows/hides extra keys\n'
'▶ "hist" displays recent calculations\n'
'▶ "^" is x^y power (Python\'s "**")\n'
'▶ "int" and "* 1." convert to int and float\n'
'\n'
'The "cmd" dialog supports entry of additional '
'ops, including all functions in Python\'s math, '
'random, statistics, and builtins modules. E.g., '
'sin(x), log(x, b), random(), mean([]), max(x, y), set().\n'
'\n'
'Version history (see source for changes):\n'
'● 4.0: Sep 2017, standalone release\n'
'● 3.1: May 2010, Programming Python 4E\n'
'● 3.0 2005 3E, 2.0 1999 2E, 1.0 1996 1E\n'
'\n'
'For downloads and more apps, visit:\n'
'http://learning-python.com/programs.html'
)
################################################################################
# The expression evaluator class.
# Embedded in and used by a CalcGui instance, to perform calculations.
################################################################################
class Evaluator:
def __init__(self):
self.names = {} # a names-space for my vars
self.opnd, self.optr = [], [] # two empty stacks
self.hist = [] # my prev calcs history log
# preimport math modules into calc's namespace for "cmd"
# namespaces are disjoint: set(dir(math)) & set(dir(other))
self.runstring("from math import *") # sin(x), log(x, b), pi, e
self.runstring("from random import *") # plus builtins: max(), abs()
try:
# [SA] new in py 3.4, ignore is absent
self.runstring("from statistics import *") # mean(), median(), etc
except:
print('Note: PyCalc cannot load statistics module in your Python;')
print('upgrade to Python 3.4 or later to use its tools in PyCalc.')
def clear(self):
self.opnd, self.optr = [], [] # leave names intact
if len(self.hist) > 64: # don't let hist get too big
self.hist = ['clear']
else:
self.hist.append('--clear--')
def popOpnd(self):
value = self.opnd[-1] # pop/return top|last opnd
self.opnd[-1:] = [] # to display and shift next
return value # or x.pop(), or del x[-1]
def topOpnd(self):
return self.opnd[-1] # top operand (end of list)
def open(self):
self.optr.append('(') # treat '(' like an operator
def close(self): # on ')' pop downto highest '('
self.shiftOptr(')') # ok if empty: stays empty
self.optr[-2:] = [] # pop, or added again by optr
def closeall(self):
while self.optr: # force rest on 'eval'
self.reduce() # last may be a var name
try:
self.opnd[0] = self.runstring(self.opnd[0])
except:
self.opnd[0] = '*ERROR*' # pop else added again next:
afterMe = {'^': ['+', '-', '(', '='], # [SA] add power operator
'*': ['+', '-', '(', '='], # class member
'/': ['+', '-', '(', '='], # optrs to not pop for key
'+': ['(', '='], # if prior optr is this: push
'-': ['(', '='], # else: pop/eval prior optr
')': ['(', '='], # all left-associative as is
'=': ['('] }
def shiftOpnd(self, newopnd): # push opnd at optr, ')', eval
self.opnd.append(newopnd)
def shiftOptr(self, newoptr): # apply ops with <= priority
while (self.optr and
self.optr[-1] not in self.afterMe[newoptr]):
self.reduce()
self.optr.append(newoptr) # push this op above result
# optrs assume next opnd erases
def reduce(self):
trace(self.optr, self.opnd)
try: # collapse the top expr
operator = self.optr[-1] # pop top optr (at end)
[left, right] = self.opnd[-2:] # pop top 2 opnds (at end)
self.optr[-1:] = [] # delete slice in-place
self.opnd[-2:] = []
result = self.runstring(left + operator + right)
if result == None:
result = left # assignment? key var name
self.opnd.append(result) # push result string back
except:
self.opnd.append('*ERROR*') # stack/number/name error
def runstring(self, rawcode):
code = rawcode.replace('^', '**') # [SA] xlate power
try: # 3.0: not `x`/repr
result = str(eval(code, self.names, self.names)) # try expr: string
self.hist.append(rawcode + ' => ' + result) # add to hist log
except:
exec(code, self.names, self.names) # try stmt: None
self.hist.append(rawcode)
result = None
return result
def getHist(self):
return '\n'.join(self.hist)
################################################################################
# [SA] StringVar wrapper class.
# Used to manage thousands-separator commas display with minimal changes.
################################################################################
class StringVarCommas(StringVar):
"""
in the main number-display area (only: not cmd): auto insert commas as
numbers are entered, and remove them when fetched for the evaluator;
this also removes commas on backspace erases by a get+set combination;
literal comma presses are simply ignored (TBD: use them as a toggle?);
some lex errors are caught here (e.g., '1E2.'), but others pass here
and fail later in the evaluator (e.g., '1..2', '..1', '1EE2', '.'),
due in part to split(x, 1): removing the 1 would make more fail here;
"""
# extend StringVar interface
def get(self):
text = StringVar.get(self) # get display text
return self.decommify(text) # strip commas
def set(self, text):
text = self.commify(text) # add commas
StringVar.set(self, text) # set display text
# add text processing methods
def decommify(self, text):
return text.replace(',', '')
def commify(self, text):
text = self.decommify(text)
#text = '{:,}'.format(num) # requires an eval()
# strip sign if added by -X key
if text.startswith('-'):
sign, text = '-' , text[1:]
else:
sign = ''
# add commas to whole-number part
try:
if text.isdigit(): # all digits: 'xxx'
return sign + '{:,}'.format(int(text)) # add ',' and sign
elif '.' in text: # also for '.' or '..'
whole, rest = text.split('.', 1) # 'x.y' 'x.' '.y' 'x.yEz'
if whole: # nov17: '.any' => '.any'
whole = '{:,}'.format(int(whole)) # (whole or '0') adds '0'
return sign + whole + '.' + rest # covers '0.1e2', '.1e-2'
elif 'E' in text.upper() and 'ERROR' not in text:
whole, exp = text.upper().split('E', 1) # no '.' but whole base
whole = '{:,}'.format(int(whole)) # 'xe+z', 'xe-z', 'xez'
return sign + whole + 'E' + exp
else:
return text # other: allow 'abcd'
except:
return 'ERROR' # anything not recognized: avoid uncaught exception in GUI
################################################################################
# Main logic - when run standalone.
# Get optional configs via command-line args, make and start a CalcGui object.
################################################################################
if __name__ == '__main__':
from getConfigs import getConfigs # [SA] new common gadgets utility
defaults = dict(InitialSize=None,
BgColor='wheat',
FgColor='black',
Font=('courier', 14, 'bold'), # or 'family...' str arg
HistBgColor='beige',
HistFont=None)
configs = getConfigs('PyCalc', defaults) # load from file or args
root = Tk() # non-default top-level window
if configs.InitialSize:
root.geometry(configs.InitialSize) # 'Wxh' size string
trySetWindowIcon(root, 'icons', 'pygadgets') # [SA] for win+lin
calc = CalcGui(root, configs) # build gui on root
if RunningOnMac:
# Mac requires menus, deiconifies, focus
# [SA] on Mac, customize app-wide automatic top-of-display menu
from guimaker_pp4e import fixAppleMenuBar
fixAppleMenuBar(window=root,
appname='PyCalc',
helpaction=calc.help, # bound method (has self)
aboutaction=None,
quitaction=calc.quit) # app-wide quit: ask
# [SA] reopen auto on dock/app click and fix tk focus loss on deiconify
def onReopen():
root.lift()
root.update()
temp = Toplevel()
temp.lower()
temp.destroy()
root.createcommand('::tk::mac::ReopenApplication', onReopen)
root.mainloop()