Variable scoping and neater code

Question

I'm working on a Python module that is acting as an interpreter for an old in-game scripting language. There are a lot of variables I've found I need on the way, and the top of my module looks like this:

from mufdatatypes import *
debugline=0
code=[]
debugline=0 #Line where something interesting starts
currentline=0 #Line where we currently are
infunc=0 #Need to know if we're in a function or not.
iflevel=0 #Need to track how far into ifs we are
inelse=0 #If we're in an if, have we already done an else?
looplevel=0 #Also need to know how many loops deep we're in
instrnum=0
charnum=0
gvarlist=[ "me": mufvariable(dbref(2)) , "loc" : mufvariable(dbref(0)) , "trigger" : mufvariable(dbref(-1)) , "command": mufvariable("") ]
item=''
structstack=[]

This is getting really cluttered. At the beginning of the function that does most of their defining, it looks like this:

def mufcompile(rawcode, primstable):
    """Compiles a source string into a list of instructions"""
    global source
    global code
    global debugline
    global currentline
    global code #The actual instructions will be stored here.
    global infunc #Need to know if we're in a function or not.
    global iflevel #Need to track how far into ifs we are.
    global inelse #If we're in an if, have we already done an else?
    global looplevel #Also need to know how man loops deep we're in.
    global addresstable #This will hold a table of function addresses.
    global structstack #This list stack will be used to hold status info as we go further down complex statements
    global instrnum #Number of instruction. Important for moving the EIP.
    global vartable #Table of variables. Dictionary.
    global charnum #Character in the line we're at.
    global item

I have a feeling I'm doing this in a way that is incorrect, and, perhaps, amusing to someone who actually knows what they're doing with Python. I know that variables can be declared on the spot, but if any functions above the one I'm writing have a reference to these, they won't compile, right? I also am a bit worried about how global global is. Do the modules that import this module have access to those variables? I don't want them to.

I would suggest using a class in order to get rid of the `global` keyword, even only one instance of that class will be created. — Niklas R, Mar 06 '12 at 21:51

score 2 · Accepted Answer · edited May 23 '17 at 11:44

2

It's probably better to make a dictionary or a class to store the values of your different variables, at least if they are related. Then pass this object as a parameter to the function and you can get rid of the globals. Anyway, you can check this question to learn more about how the global keyword works.

edited May 23 '17 at 11:44

Community

1
1

answered Mar 06 '12 at 21:55

Dan Gerhardsson

1,869
13
12

score 2 · Answer 2 · answered Mar 06 '12 at 22:22

some of those look like they should be in an object, but others look like you need to restructure your code.

the ones that should be in an object are things like source, lineno, etc. once they are in an object then you have two choices: either pass that object to every function or, better, make your functions methods so that they can "see" the data as attributes.

so something like:

class Parser(object):

    def __init__(self, source):
        self._source = source
        self._lineno = 0
        ...

    def parse_next_line(self, ...):
        self._lineno += 1
        ...

get the idea? then you run you code by doing something like:

source = ....
parser = Parser(source)
parser.parse_next_line(...)

BUT then there are other things, like inelse and looplevel. those kinds of things should not need to exist "outside" a single function and you need to think more about how to organise you code. it's hard to say more because i can't see all the details, and i don't want to criticse too much because it's great that you are thinking about this...

score 0 · Answer 3 · answered Mar 06 '12 at 21:51

0

Remember, you only need to declare a variable as global if you need to change it's global value. Top level variables can be read/used from anywhere.

answered Mar 06 '12 at 21:51

bluepnume

16,460
8
38
48

Variable scoping and neater code

3 Answers3