web-dev-qa-db-fra.com

Passer des variables, créer des instances, soi, La mécanique et l'utilisation des classes: besoin d'explication

Je suis restée assise là-dessus toute la journée et je suis déjà un peu fatiguée, alors veuillez m'excuser d'être bref.

Je suis nouveau sur Python.

Je viens de réécrire un programme de travail, en un tas de fonctions dans une classe et tout bousillé. Je ne sais pas si c'est moi, mais je suis très surpris de ne pas avoir trouvé de tutoriel pour débutant sur la gestion des cours sur le Web. J'ai donc quelques questions.

Premier de tous, dans le __init__ section de la classe, j'ai déclaré un groupe de variables avec self.variable=something.

Est-il exact de pouvoir accéder/modifier ces variables dans chaque fonction de la classe en utilisant self.variable dans cette fonction? En d'autres termes, en déclarant self.variable J'ai créé ces variables, des variables globales dans la portée de la classe, n'est-ce pas?

Si non, comment puis-je gérer moi-même?

Deuxièmement, comment puis-je transmettre correctement des arguments à la classe? Un exemple de code serait cool.

Troisièmement, comment appeler une fonction de la classe en dehors de la portée de la classe? Un exemple de code serait cool.

Fouthly, comment créer une instance du class INITIALCLASS en autre class OTHERCLASS _, passant des variables de OTHERCLASS à INITIALCLASS? Un exemple de code serait cool.

Je veux appeler une fonction de OTHERCLASS avec des arguments de INITIALCLASS. Ce que j'ai fait jusqu'à présent, c'est.

class OTHERCLASS():
    def __init__(self,variable1,variable2,variable3):
        self.variable1=variable1
        self.variable2=variable2
        self.variable3=variable3
    def someotherfunction(self):
        something=somecode(using self.variable3)
        self.variable2.append(something)
        print self.variable2
    def somemorefunctions(self):
        self.variable2.append(variable1)

class INITIALCLASS():
    def __init__(self):
        self.variable1=value1
        self.variable2=[]
        self.variable3=''
        self.DoIt=OTHERCLASS(variable1,variable2,variable3)

    def somefunction(self):
        variable3=Somecode
        #tried this
        self.DoIt.someotherfunctions()
        #and this
        DoIt.someotherfunctions()

Je n'ai clairement pas compris comment passer des variables à des classes ou comment gérer self, quand l'utiliser et quand ne pas en utiliser. Je n'ai probablement pas non plus compris comment créer correctement une instance d'une classe. En général, je ne comprenais pas la mécanique des cours, alors aidez-moi et expliquez-le-moi comme si je n'avais aucune idée (ce que je n'ai pas, semble-t-il). Ou dirigez-moi vers une vidéo complète, ou un tutoriel lisible.

Tout ce que je trouve sur le Web, ce sont des exemples très simples, qui ne m'ont pas beaucoup aidé. Ou simplement des définitions très courtes de classes et d'instances de méthodes de classes, etc.

Je peux vous envoyer mon code original si vous le souhaitez, mais c'est assez long.

pythonclasscallparameter-passinginstance-variables
39
Baf
class Foo          (object):
    # ^class name  #^ inherits from object

    bar = "Bar" #Class attribute.

    def __init__(self):
        #        #^ The first variable is the class instance in methods.  
        #        #  This is called "self" by convention, but could be any name you want.
        #^ double underscore (dunder) methods are usually special.  This one 
        #  gets called immediately after a new instance is created.

        self.variable = "Foo" #instance attribute.
        print self.variable, self.bar  #<---self.bar references class attribute
        self.bar = " Bar is now Baz"   #<---self.bar is now an instance attribute
        print self.variable, self.bar  

    def method(self, arg1, arg2):
        #This method has arguments.  You would call it like this:  instance.method(1, 2)
        print "in method (args):", arg1, arg2
        print "in method (attributes):", self.variable, self.bar


a = Foo() # this calls __init__ (indirectly), output:
                 # Foo bar
                 # Foo  Bar is now Baz
print a.variable # Foo
a.variable = "bar"
a.method(1, 2) # output:
               # in method (args): 1 2
               # in method (attributes): bar  Bar is now Baz
Foo.method(a, 1, 2) #<--- Same as a.method(1, 2).  This makes it a little more explicit what the argument "self" actually is.

class Bar(object):
    def __init__(self, arg):
        self.arg = arg
        self.Foo = Foo()

b = Bar(a)
b.arg.variable = "something"
print a.variable # something
print b.Foo.variable # Foo
76
mgilson

Voici donc un exemple simple d'utilisation des classes: Supposons que vous soyez un institut financier. Vous voulez que les comptes de vos clients soient gérés par un ordinateur. Vous devez donc modéliser ces comptes. C'est là que les classes entrent en jeu. Travailler avec des classes s'appelle la programmation orientée objet. Avec les classes, vous modélisez des objets du monde réel sur votre ordinateur. Alors, de quoi avons-nous besoin pour modéliser un compte bancaire simple? Nous avons besoin d'une variable qui enregistre le solde et d'une autre qui enregistre le nom du client. En outre, certaines méthodes pour augmenter et diminuer l’équilibre. Cela pourrait ressembler à:

class bankaccount():
    def __init__(self, name, money):
        self.name = name
        self.money = money

    def earn_money(self, amount):
        self.money += amount

    def withdraw_money(self, amount):
        self.money -= amount

    def show_balance(self):
        print self.money

Vous avez maintenant un modèle abstrait d'un compte simple et de son mécanisme. La def __init__(self, name, money) est le constructeur des classes. Il construit l'objet en mémoire. Si vous voulez maintenant ouvrir un nouveau compte, vous devez créer une instance de votre classe. Pour ce faire, vous devez appeler le constructeur et transmettre les paramètres nécessaires. Dans Python, un constructeur est appelé par le nom de la classe:

spidermans_account = bankaccount("SpiderMan", 1000)

Si Spiderman veut acheter une nouvelle bague à M.J., il doit retirer de l'argent. Il appellerait la méthode withdraw sur son compte:

spidermans_account.withdraw_money(100)

S'il veut voir l'équilibre, il appelle:

spidermans_account.show_balance()

Le problème des classes est de modéliser les objets, leurs attributs et leurs mécanismes. Pour créer un objet, instanciez-le comme dans l'exemple. Les valeurs sont transmises aux classes avec des méthodes getter et setter telles que `Earn_money () ´. Ces méthodes accèdent à vos objets variables. Si vous voulez que votre classe stocke un autre objet, vous devez définir une variable pour cet objet dans le constructeur.

27
MaxPowers

L'intérêt d'une classe est de créer une instance, qui encapsule un ensemble de données. Il est donc faux de dire que vos variables sont globales dans l'étendue de la classe: disons plutôt qu'une instance contient des attributs, et que cette instance peut faire référence à ses propres attributs dans n'importe lequel de ses codes (via self.whatever). De même, tout autre code donné à une instance peut utiliser cette instance pour accéder aux attributs de l'instance - c'est-à-dire instance.whatever.

3
Daniel Roseman