Python: accès à des objets à partir d'un autre module

Je suis quelqu'un de très inexpérimenté programmeur création d'un jeu (à l'aide de Python 3.3) comme un exercice d'apprentissage. J'ai actuellement un module principal et un module de combat.

Les gens dans le jeu sont représentées par des instances de la classe "Personne", et sont créés dans le module principal. Cependant, le module de combat a bien besoin de l'accès à ces objets. En outre, je vais probablement créer plus de modules plus tard que aurez également besoin d'accéder à ces objets.

Comment puis-je permettre à d'autres modules pour l'accès Personnes à partir de main.py?

Des choses, main.py a

import combat

en haut; l'ajout de

import main

à combat.py ne semble pas aider.

Dois-je instancier les objets dans un module séparé (common.py?) et de les importer à chaque module doit avoir accès?

InformationsquelleAutor henrebotha | 2013-03-01
  1. 6

    Oui, vous devriez certainement facteur de cela. Ce que vous avez essayé circulaire importations entre les modules, et qui peut être très problématique. Si combat importations main et main importations combat, alors vous pouvez obtenir une exception parce que main n'aura pas fini de s'exécuter lorsque combat commence à s'exécuter pour l'importation. En supposant que main est votre script de démarrage, il doit probablement faire rien de plus que d'instancier une classe ou d'appeler une méthode d'un autre module. Éviter les variables globales, trop. Même si il ne semble pas comme ils vont être un problème aujourd'hui, qui peut vous mordre dans le derrière plus tard.

    Cela dit, vous pouvez référencer membres d'un module comme suit:

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

    ou

    from common import SomeClass
y = SomeClass()

    Personnellement, je suis généralement d'éviter la référence d'une méthode à partir d'un autre module sans la qualifier avec le nom du module, mais c'est aussi juridique:

    from common import some_method_in_common
x = some_method_in_common()

    Je l'utilise généralement from ... import ... pour les classes, et je l'utilise généralement la première forme de méthodes. (Oui, parfois, cela signifie que j'ai de la classe spécifique importations en provenance d'un module en plus d'importer le module lui-même.) Mais ce n'est que mon personnel convention.

    Une syntaxe alternative de ce qui est fortement découragé est

    from common import *
y = SomeClass()

    Cela va importer tous les membres de la commune dans le champ d'application actuel qui ne commence pas par un caractère de soulignement (_). J'ai la raison pour laquelle il est déconseillé est parce que c'est la compréhension de la source de ce nom et il fait de la rupture des choses trop faciles. Considérer cette paire d'importation:

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

    Le module qui ne SomeClass viennent? Il n'y a aucun moyen de dire à d'autres que d'aller regarder les deux modules. Pire, si les deux modules de définir SomeClass ou SomeClass est ajouté plus tard à some_other_module?

    • Merci, c'est très utile.
    • Vous êtes les bienvenus. Si la réponse offerte par quelqu'un répond à votre question, vous pouvez la marquer comme réponse en cliquant sur la case à cocher ci-dessous les boutons de vote.
    InformationsquelleAutor jpmc26
  2. 1

    si vous avez importé module principal en combat module en utilisant import main, alors vous devriez utiliser.*(les choses qui sont mises en œuvre dans le module principal) pour accéder à des classes et des méthodes de là.

    exemple:

    import main

person = main.Person()

    vous pouvez également utiliser from main import * ou import Person pour éviter principal.* dans le précédent.

    Il y a quelques règles pour l'importation de modules, comme décrit dans http://effbot.org/zone/import-confusion.htm :

    1. import X importe le module de X, et crée une référence à cette
      module dans l'espace de noms courant. Ou, en d'autres termes, après que vous avez exécuté
      cette déclaration, vous pouvez utiliser X.name à se référer à des choses définies dans
      module X.
    2. from X import * importe le module de X, et crée des références dans
      l'espace de noms courant de tous les objets définis par ce module
      (qui est, tout ce qui n'a pas un nom qui commence par “_”). Ou
      en d'autres termes, après avoir exécuté cette déclaration, vous pouvez simplement utiliser
      un simple nom pour désigner les éléments définis dans le module X. Mais X lui-même est
      pas de définition, de sorte X.name ne fonctionne pas. Et si le nom a déjà été
      définis, il est remplacé par la nouvelle version. Et si le nom de X est
      modifié pour pointer vers un autre objet, votre module ne pas le remarquer.
    3. from X import a, b, c importe le module de X, et crée des références
      dans l'espace de noms courant pour les objets donnés. Ou en d'autres termes,
      vous pouvez maintenant utiliser a et b et c dans votre programme.

    4. Enfin, X = __import__(‘X’) fonctionne comme import X, avec l'
      différence que vous

      1) passer le nom du module comme une chaîne de caractères, et

      2) explicitement l'affecter à une variable dans votre espace de noms courant.

    • Oh pinaise! J'ai oublié à ce sujet. Stupide erreur.
    • S'il vous plaît ne pas suggérer from X import *
    InformationsquelleAutor user2121529