8

I'm a very inexperienced programmer creating a game (using Python 3.3) as a learning exercise. I currently have a main module and a combat module.

The people in the game are represented by instances of class "Person", and are created in the main module. However, the combat module obviously needs access to those objects. Furthermore, I'm probably going to create more modules later that will also need access to those objects.

How do I allow other modules to access the Persons from main.py?

As things stand, main.py has

import combat

at the top; adding

import main

to combat.py doesn't seem to help.

Should I instantiate my objects in a separate module (common.py?) and import them to every module that needs to access them?

Improve this question

2 Answers 2

Reset to default
10

Yes, you should factor this out. What you tried is circular imports between your modules, and that typically causes more problems than it solves. If combat imports main and main imports combat, then you may get an error because some object definitions will be missing from main when you try to import them. This is because main will not have finished executing when combat starts executing for the import. Assuming main is your start up script, it should do nothing more than start the program by calling a method from another module; it may instantiate an object if the desired method is an instance method on a class. Avoid global variables, too. Even if it doesn't seem like they'll be a problem now, that can bite you later on.

That said, you can reference members of a module like so:

import common
x = common.some_method_in_common()
y = common.SomeClass()

or

from common import SomeClass
y = SomeClass()

Personally, I generally avoid referencing a method from another module without qualifying it with the module name, but this is also legal:

from common import some_method_in_common
x = some_method_in_common()

I typically use from ... import ... for classes, and I typically use the first form for methods. (Yes, this sometimes means I have specific class imports from a module in addition to importing the module itself.) But this is only my personal convention.

An alternate syntax of which is strongly discouraged is

from common import *
y = SomeClass()

This will import every member of common into the current scope that does not start with an underscore (_). The reason it's discouraged is because it makes identifying the source of the name harder and it makes breaking things too easy. Consider this pair of imports:

from common import *
from some_other_module import *
y = SomeClass()

Which module does SomeClass come from? There's no way to tell other than to go look at the two modules. Worse, what if both modules define SomeClass or SomeClass is later added to some_other_module?

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

You're welcome. If an answer offered by someone answers you question, you can mark it as an answer by clicking the check mark below the up/down vote buttons.
2

if you have imported main module in combat module by using import main, then you should use main.*(stuff that are implemented in main module) to access classes and methods in there.

example:

import main

person = main.Person()

also you can use from main import * or import Person to avoid main.* in the previous.

There are some rules for importing modules as described in http://effbot.org/zone/import-confusion.htm :

  1. import X imports the module X, and creates a reference to that module in the current namespace. Or in other words, after you’ve run this statement, you can use X.name to refer to things defined in module X.
  2. from X import * imports the module X, and creates references in the current namespace to all public objects defined by that module (that is, everything that doesn’t have a name starting with “_”). Or in other words, after you’ve run this statement, you can simply use a plain name to refer to things defined in module X. But X itself is not defined, so X.name doesn’t work. And if name was already defined, it is replaced by the new version. And if name in X is changed to point to some other object, your module won’t notice.
  3. from X import a, b, c imports the module X, and creates references in the current namespace to the given objects. Or in other words, you can now use a and b and c in your program.

  4. Finally, X = __import__(‘X’) works like import X, with the difference that you

    1) pass the module name as a string, and

    2) explicitly assign it to a variable in your current namespace.

Improve this answer

2 Comments

D'oh! I forgot about this. Silly mistake.
Please do not suggest from X import *

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.