J'essaie de créer un script qui définit une variable locale, la référente à partir d'une fonction et peut renvoyer la valeur manipulée à la portée principale (ou quoi que ce soit appelé; je suis nouveau à Python)
i J'ai simplifié mon code pour montrer les bases optimistes de ce que j'essaye d'accomplir, ce qui consiste à importer un local à partir du module dans un bloc de fonction, je pense. p>
J'ai eu ceci pour travailler en utilisant Globals Code>, mais ce n'est pas la meilleure solution. . . P>
chambersinreactor = 0;
cardsdiscarded = 0;
def find_chamber_discard():
"""Find chambers and discard in row (reads each player slot)"""
chambersinreactor = 0; # Resets the variable, not what I want
cardsdiscarded = 0; # Resets the variable, not what I want
chambersinreactor += 1
cardsdiscarded += 1
return # Don't know what to put here
find_chamber_discard()
print chambersinreactor # prints as 0, should be 1
print cardsdiscarded # prints as 0, should be 1
3 Réponses :
Les fonctions ne devraient pas avoir à savoir quelle portée ils s'appellent; Le point d'une fonction consiste à effectuer un bloc de code réutilisable qui peut être invoqué plusieurs fois à différents endroits.
Vous communiquez des informations à une fonction en passant à travers ses variables d'entrée. La fonction communique les informations à son appelant en le renvoyant. Gérer les variables d'une portée est le travail du code dans cette portée Mettre cela ensemble, ce que vous voulez faire est quelque chose comme ceci: Il existe des moyens de contourner cela avec des variables globales ou de manipuler des structures de données mutables, mais en fin de compte, ils rendent votre programme moins flexible et plus susceptibles de contenir des erreurs qui seront difficile à repérer. Il existe une place pour ces techniques, mais la première méthode que vous touchez pour communiquer des informations vers et depuis des fonctions devraient vraiment transmettre des arguments et recevoir des valeurs de retour.
Chambersinreactor, CartesDiscarded = Find_chamber_Discard (Chambersinreactor, cartesDiscarded) - C'est incroyable - qui savait que vous pouviez renvoyer plusieurs valeurs comme celle-ci ?!
#!/usr/bin/env python
chambersinreactor = 0; cardsdiscarded = 0;
def find_chamber_discard():
chambersinreactor = 0
cardsdiscarded = 0
chambersinreactor += 1
cardsdiscarded += 1
return(chambersinreactor, cardsdiscarded)
#Here the globals remain unchanged by the locals.
#In python, a scope is similar to a 'namespace'
find_chamber_discard()
print chambersinreactor #prints as 0
print cardsdiscarded
#I've modified the function to return a pair (tuple) of numbers.
#Above I ignored them. Now I'm going to assign the variables in the
#main name space to the result of the function call.
print("=====with assignment===")
(chambersinreactor, cardsdiscarded) = find_chamber_discard()
print chambersinreactor # now prints as 1
print cardsdiscarded
# Here is another way that doesn't depend on returning values.
#Pass a dictionary of all the main variables into your function
#and directly access them from within the function as needed
print("=======using locals===")
def find_chamber_discard2(_locals):
_locals['chambersinreactor'] += 1
_locals['cardsdiscarded'] += 1
return
find_chamber_discard2(locals())
print chambersinreactor #incremented the value, which was already 1
print cardsdiscarded
La recommandation de la DOCS est de jamais Modifier les sections locales (), car le comportement que vous noter est entièrement basé sur la mise en œuvre et n'est pas garanti: "Le contenu de ce dictionnaire ne doit pas être modifié; changements peut ne pas affecter les valeurs des variables locales et libres utilisées par l'interprète. "
Une approche consiste à utiliser des valeurs mutables, telles que les dictes ou les listes: Toutefois, si vous avez une fonction qui change de l'état, vous êtes probablement mieux en train de s'enraciner. En classe, comme c'est ce qu'elles sont: Si ce que vous faites est compte, vous pouvez peut-être utiliser le compteur: Personnellement, j'irais pour l'approche de la classe, peut-être même en emballage de comptoir, car elle maintient toutes les fonctionnalités associées ensemble.
Voulez-vous dire que vous voulez transmettre des arguments sur la fonction, puis les renvoyer?
Chambersinreactor et `cartesDiscarded` sont des variables globales. Ils sont définis en dehors de la portée locale.