7

I was recently told that I should keep my code in separate files; like main.py, engine.py, settings.py and so on. Although this surely does have benefits, like easier management, scalability and others, to me it seems like it has too many drawbacks...

For example, if I have a script called settings.py, where some things like sizes of onscreen objects, speed of the simulation and color of various objects are defined, what do I do if those variables are needed both in my engine.py script and my main.py script? Do I import it two times, in both scripts? It seems rather messy. What if some of my classes, that are in the engine.py script, require code from main.py?

Let me show you the exact situation...

My main.py script imports Pygame in itself, initializes it, and so on. It used to have a class which represented an onscreen object, and that class had a method draw, which just called a Pygame draw function. Now, when I put the class inside my engine.py script, things no longer work, because Pygame doesn't exist there! I ended up importing both settings.py and Pygame in the engine.py, and then importing the engine into main.py, but then it's more like an initializer than an engine... Is there a way to deal with things like these, like general guide lines?

Improve this question
2
  • 1
    It seems like you are trying to get around importing modules into which you've split up your code. If this is the case, you should really just import wherever necessary. Commented May 8, 2012 at 13:22
  • 11
    Any hassle you feel splitting your code up into multiple files is going to pale in comparison when you have to go back and maintain a 5000 line file you haven't looked at in a couple of months! Commented May 8, 2012 at 13:23

6 Answers 6

Reset to default
3

Here are the official PEP guidelines for imports: http://www.python.org/dev/peps/pep-0008/#imports

Also please see this StackOverflow question: What are good rules of thumb for Python imports?

You can import a variable from more than one class without a problem but you should try and structure your code so that things aren't circularly imported. Circular import dependency in Python

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

Comments

2

You should have a look at this model, which might help you understand things. I think this is the one that would actually fit best with what you want to do

Model-View-Controller

Some more doc here : http://www.wkoorts.com/wkblog/2007/12/23/mvc-design-patterns-with-python-links/

In this case, the imports should seem rather logical and necessary. And I would add that is is roughly what you already do with your 3 files.

Improve this answer

3 Comments

What does MVC has to do with the question?
From the explanation, It sound logical to me that he is describing a MVC (data, core functionality and front end )
Even then the data, core and front end may be broken down to tens of different files/modules for each. So his question still applies. It's kind of irrelevant I think but I'm not gonna mod you down.
1

Its common practice in other languages (especially Java, where its practically forced by the compiler) to have one file per class.

As for the inter-file dependencies you mention, you should consider avoiding global variables.

Here's another related question that better answers your question.

How many Python classes should I put in one file?

Improve this answer

Comments

1

Importing a module into multiple other modules isn't messy. It's much cleaner than a module with many thousands of lines of code.

It's true that circular imports are problematic. But your situation doesn't sound like there's going to be a circular import problem. You say that "Now, when I put the class inside my engine.py script, things no longer work, because Pygame doesn't exist there! I ended up importing both settings.py and Pygame in the engine.py, and then importing the engine into main.py".

Why can't you just put the class in engine.py and then import it into main.py? One very simple way to do this would be to pass a callback to your class:

# engine.py
...
class ClassWithDraw(Subclass):
    def __init__(self, draw_callback):
        ...
        self._draw_func = draw_callback
        ...
    def draw(self):
        self._draw_func()

# main.py

from engine import ClassWithDraw
drawer = ClassWithDraw(drawfunc)

What's nice about this approach is that the object is really only responsible for one thing: its own state. Indeed, it might make more sense for this object to not have a draw method at all; or it could have a draw_hook that would be called to get drawable data from it whenever necessary, and another external draw function could call it.

Yet another approach would be to have a completely separate module for Pygame. I don't know much about Pygame, so it's possible this won't work, but say you have a module that handles Pygame initialization and state. You can initialize it once, in main, and import it wherever you want.

Improve this answer

Comments

0

Not an answer, but:

settings.py should really be settings.ini, and you should read it using ConfigParser. Read the config file once and share the resulting ConfigParser.RawConfigParser around between modules.

Improve this answer

3 Comments

But why? It just seems like more of a hassle. I can have a clean, .py file that looks like name = value, as opposed to those sections and all that... Also, I need a script that reads the config, and then I need to import it everywhere else? Isn't that practically what I'm doing right now, except I'm setting those values directly, not reading them from a separate file or something? Please answer, I'd like to know!
Not only that, if I, for example, want to save a tuple, it becomes a string!
If this isn't an answer then it doesn't belong here.
0

You can import symbols from settings.py in any module they are needed. That's the concept. An actual problem is when you have circular imports. e.g. What if you had some symbols inside engine.py that were needed in main.py and vice versa. In that situation a common pattern is to break these dependencies in a third module, where main.py and engine.py could import from, without any problem.

Improve this answer

Comments

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.