Ivan Shevanski wrote: > Thanks for your quick responce Roy, thats exactly what I needed. =)
No, it isn't! ;) It might seem like a good idea right now, but it's not a good choice in the long run. It's like peeing in bed: Initially it's both a relief and you get warm and cosy, but you'll end upp with a mess that you (or someone else) will need to clean up later. Sure, it's unproblematic in this tiny example, but it's a bad habit to rely on global variables in cases that are easily solved without them. The obvious solution in your case is to just pass on the variable you need. There are several problems with globals that will become appearent as your code grows bigger, and you can't see all details in the program in the same instant. Your global namespace will get cluttered by a lot of names that are used far away in the code, the code in your functions will become difficult to understand, and it will be more difficult to see how the functions interact to each other. Your programs will also be brittle, since a change in one place is more likely to break some other code in another place in your program. Besides, if your code relies on changing global variables, your functions get very restricted: You can't have two or more sets of data being modified by these functions at the same time. It's pretty common in Python, that people use global variables for objects that are really constants (although Python won't enforce that) and it's common that these varaible names are written with CAPS. There are also cases where we want to keep some kind of module global state, and globals can be used for that, but it should be used only when needed. I just scanned through 55 000 lines of Python code in 276 files here at work, and found about a dozen occurences of the global keyword. In other words, it's very uncommon here that we use global variables that aren't just constants. The normal way to share data between functions is to pass data in as arguments, and out as return values. If you want objects to keep state between function calls without passing them around, consider using object-oriented code, but lets wait a bit with that. Anyway, here are two examples of a small program using globals or passing parameters. # Global version def getYear(): global year year = None while year is None: try: year = int(raw_input(prompt)) except ValueError: pass def calcAge(): global age age = current_year - birth_year def printAge(): print "*"*age print "You are", age, "years." def main(): global prompt prompt = 'What year were you born? ' getYear() global birth_year birth_year = year prompt = 'What year is it now? ' getYear() global current_year current_year = year calcAge() printAge() main() # Parameter passing version def getYear(prompt): year = None while year is None: try: year = int(raw_input(prompt)) except ValueError: pass return year def calcAge(start, end): return end - start def printAge(age): print "*"*age print "You are", age, "years." def main(): birth_year = getYear('What year were you born? ') current_year = getYear('What year is it now? ') age = calcAge(birth_year, current_year) printAge(age) main() In this case, the fact that getYear() in the global version assigns to the global "year" when you need to work with two different year is an inconvenience. If you imagine that you'd do something like "when was X born, when was Y born, when was Z born, then Y is oldest", you'll see that it's really stupid to have your functions write to globals instead of returning values directly to the caller of the function. -- http://mail.python.org/mailman/listinfo/python-list