Utilisation de variables dans le gestionnaire de signal - besoin global?

J'ai un gestionnaire de signal pour traiter ctrl-c interrompre. Si dans le gestionnaire de signal je veux lire une variable définie dans mon script principal, est-il une alternative à l'utilisation d'un "global" instruction lors de la définition de la variable?

Je ne me dérange pas de le faire, mais lire ce post (Utilisez-vous le "global" instruction en Python?) dans laquelle quelqu'un a fait remarquer qu'il devrait y avoir aucune raison de jamais utiliser mondiale.

Quelle est l'alternative dans ce cas?

Mon code ressemble à ceci:


def signal_handler(signal, frame):
    print "in sig handler - g_var=%s" % g_var

def main():
    global g_var
    g_var = "test"

    time.sleep(120)


if __name__ == '__main__':
    signal.signal(signal.SIGINT, signal_handler)
    main()

OriginalL'auteur Joe Watkins | 2012-09-11

python

22

Vous pouvez utiliser une fermeture comme le gestionnaire de signal qui acquiert l'état dans le script principal:
```
import signal
import sys
import time

def main_function():

    data_for_signal_handler = 10

    def signal_handler(*args):
        print data_for_signal_handler
        sys.exit()

    signal.signal(signal.SIGINT, signal_handler) # Or whatever signal

    while True:
        data_for_signal_handler += 1
        time.sleep(0.5)

if __name__ == '__main__':
    main_function()
```
OK, je pense que mon problème est que le gestionnaire de signal est définie en dehors de la fonction principale. Je n'ai pas de bonne raison de le faire, donc pense que j'ai juste besoin de le déplacer
Je ne crois pas avoir une bonne raison est généralement pourquoi les variables globales peuvent être déplacés vers un cadre plus restreint! 🙂
La modification d'une variable à partir de l'extérieur de la portée ne fonctionne pas comme on pourrait s'y attendre. Une solution de contournement consiste à passer une référence, comme un dictionnaire qui contient une référence à la variable à modifier.
ou en python3 utilisation nonlocal.

OriginalL'auteur Henry Gomersall

Vous pouvez utiliser partial pour créer une "fermeture".

import signal
from functools import partial

def signal_handler(g_var, signal, frame):
    print "in sig handler - g_var=%s" % g_var

def main():
    g_var = "test"
    signal.signal(signal.SIGINT, partial(signal_handler, g_var))

    time.sleep(120)


if __name__ == '__main__':
    main()

OriginalL'auteur Ale

Dans le paradigme orienté objet (POO) c'est très pratique pour utiliser les lambdas. À l'aide de lambda vous pourriez passer un certain contexte supplémentaire (comme un auto de référence) et/ou de se débarrasser de la fraction inutilisée des arguments (signal, cadre).

import time
import signal

class Application:

    def __init__( self ):
        signal.signal( signal.SIGINT, lambda signal, frame: self._signal_handler() )
        self.terminated = False

    def _signal_handler( self ):
        self.terminated = True

    def MainLoop( self ):        
        while not self.terminated:
            print( "I'm just doing my job like everyone else" )
            time.sleep( 3 )

app = Application()
app.MainLoop()

print( "The app is terminated, exiting ..." )

OriginalL'auteur Maxim Ky

1

Vous pouvez accéder à l'extérieur de la portée des variables à partir de l'intérieur d'une ligne définie par la fonction, comme suit:
```
my_values = {'foo':'bar'}
def handler(signum, frame):
    for key,val in my_values.items():
        print key,val
    my_values['bat']='baz'
    #remember to use mutable types, like dicts or lists

signal.signal(signal.SIGINT, handler)
```
comme juste commenté une réponse similaire: je pense que mon problème est que le gestionnaire de signal est définie en dehors de la fonction principale. Je n'ai pas de bonne raison de le faire, donc pense que j'ai juste besoin de le déplacer

OriginalL'auteur John Fink
0

Si vous êtes simplement à la lecture de la variable, il devrait y avoir aucun besoin de faire de la variable "globale"
```
def foo():
    print a
a = 3
foo()  #3
```
global est nécessaire pour vous permettre de modifier la variable et que ce changement se propager dans le module de l'espace de noms.

Si vous souhaitez passer de l'état de votre rappel sans l'aide de global, la méthode classique pour ce faire, nous utilisons une méthode d'instance comme le rappel:
```
class foo(object):
     def __init__(self,arg):
         self.arg = arg
     def callback_print_arg(self):
         print self.arg

def call_callback(callback):
    callback()

a = foo(42)
call_callback(a.callback_print_arg) #42
```
Il est clair pour moi qu'il n'était pas de parler de la "global" Python mot-clé, mais l'obligation d'avoir la variable dans la portée globale (définie dans le module de la portée). Cette réponse n'est pas utile.

OriginalL'auteur mgilson

Vous devez vous connecter pour publier un commentaire.