Moduler
I rpncalc2 gjorde vi koden ryddigere ved å definere funksjoner, men etterhvert som programmer blir større, er det en fordel å kunne dele opp koden i flere filer, som ofte kalles moduler. En av filene inneholder hovedprogrammet (f.eks. med main-funksjonen) som startes av brukeren, og denne vil bruke funksjoner (og variabler) definert i de andre modulene. Med en fornuftig oppdeling, kan selv store program bli oversiktlige og greie å håndtere. Moduler har på en måte samme rolle som funksjoner, men i større skala.
En vanlig måte å dele opp et program på er i en eller flere moduler som håndterer interaksjon med brukeren, og en eller flere støtte-moduler som inneholder kjernelogikken, f.eks. håndtering av komplekse datastrukturer. Fordelen er 1) at det er forutsigbart hvor ulike funksjoner er, og 2) at det gir økt gjenbruk. Siden vårt program er såpass lite, så holder det med to moduler:
- rpncalc4core: inneholder kjernelogikken som håndterer operand-stacken
- rpncalc4ui: inneholder koden som håndterer interaksjon med brukeren (ui-endelsen står for user interface, som vi på norsk kaller brukergrensesnitt)
rpncalc4core-modulen
Denne modulen inneholder alle variabler og funksjoner knyttet til håndtering av operand-stacken, først og fremst operands-variablen og i tillegg funksjonene som direkte leser og endrer den. I praksis er dette første del av koden fra rpncalc3.py:
operands = [] def isOperand(token): ... def printOperands(): ... def popOperands(n): ... def pushOperand(operand): ... def plus(): ... def minus(): ...
Det "eneste" denne modulen gjør er å deklarere og initialisere operands-variablen og tilhørende funksjoner. Når modulen kjøres/aktiveres så opprettes som vanlig et notatark kalt rpncalc4core hvor alle variablene og funksjonene noteres ned. Imidlertid blir ingen av funksjonene kjørt av modulen selv, de må kalles utenfra, av kode i andre moduler.
rpncalc4ui-modulen
Denne modulen håndterer interaksjon med brukeren og inneholder bare main-metoden (fra rpncalc3.py) og et enkelt kall til denne, altså hovedprogrammet som kjøres av brukeren.
Det viktigste nye er koblingen til rpncalc4core-modulen:
- import-setningen brukes for å angi at rpncalc4core-modulen skal brukes/aktiveres.
- rpncalc4core. (merk punktumet) som prefix foran funksjonsnavnene printOperands, isOperand, pushOperand, plus og minus, for å angi at disse ligger i den andre modulen.
import rpncalc4core
def main():
while (True):
rpncalc4core.printOperands()
...
if rpncalc4core.isOperand(token):
...
rpncalc4core.pushOperand(operand)
...
rpncalc4core.plus()
...
rpncalc4core.minus()
...
main()
En kan tenke på import-setningen som et slags kall til eller aktivering av den andre modulen, bortsett fra at dette bare skjer én gang. Så selv om flere moduler i samme program importerer rpncalc4core, så vil vi bare ha ett rpncalc4core-ark med én operands-variabel.
Ved kjøring skjer omtrent det samme som tidligere, bortsett fra at vi nå har to modul-ark, rpncalc4core og rpncalc4ui. Slik ser det omtrent når main-funksjonen i rpncalc4ui har kalt plus i rpncalc4, som igjen har kalt popOperands:
For å referere til navn (variabler og funksjoner) i en annen og importert modul, så brukes altså modul-navnet og punktum som prefiks, f.eks. rpncalc4core.isOperand i if-betingelsen. Dette er i grunnen samme notasjon som brukes når en kaller operands-lista sin pop-metode. En kan tenke på lista som et eget ark med funksjoner inni, men da er en inne på objektorientering...
Importerbar kode
# rpncalc4core.py
operands = []
def isOperand(token):
try:
float(token)
return True
except ValueError:
return False
def printOperands():
print(operands)
def popOperands(n):
global operands
size = len(operands)
if size >= n:
result = operands[size - n : size]
operands = operands[0 : size - n]
return result
else:
return None
def pushOperand(operand):
operands.append(operand)
def plus():
ops = popOperands(2)
if not (ops is None):
pushOperand(ops[0] + ops[1])
def minus():
ops = popOperands(2)
if not (ops is None):
pushOperand(ops[0] - ops[1])
| # rpncalc4ui.py
import rpncalc4core
def main():
while (True):
rpncalc4core.printOperands()
token = raw_input(" > ")
if rpncalc4core.isOperand(token):
operand = float(token)
rpncalc4core.pushOperand(operand)
elif token == "exit":
break
elif token == "+":
rpncalc4core.plus()
elif token == "-":
rpncalc4core.minus()
else:
print("Unsupported operator: " + token)
print("program exited")
main()
|