Meglio usare Global Variable o Coroutine in generale?

Question

Meglio usare Global Variable o Coroutine in generale?

#1 da (1 voti)
#2 da (1 voti)
#3 da (0 voti)

1

È meglio memorizzare lo stato in una variabile globale o in una coroutine, in particolare in Python? Non capisco le migliori pratiche qui.

Ad esempio, considera un semplice script Flask:

from flask import Flask
...

app = Flask(__name__)

### GLOBAL MEMORY ############ OPTION 1

exmple_variable = 'contents of some file or something.'

### COROUTINE ############### OPTION 2

def get_example_variable():
    a = yield
    while True:
        yield a

exmple_variable_coroutine = get_example_variable()
next(exmple_variable_coroutine)
exmple_variable_coroutine.send('contents of some file or something.')

### PAGES ####################

@app.route('/')        # uses option 1
def page_home():
    return render_template('index.html', example=example_variable)

@app.route('/index')   # uses option 2
def page_index():
    return render_template('index.html', example=next(exmple_variable_coroutine))

if __name__ == '__main__':
    app.run()

Quindi hai una piccola app Flask con le due opzioni delineate. In un caso come questo, sarebbe meglio usare la coroutine o usare la variabile globale?

La variabile che rappresenta l'hook della coroutine exmple_variable_coroutine è essenzialmente una variabile globale stessa. Quindi non sono sicuro che tutta questa complessità aggiunta aiuti molto. Con la crescita di questo progetto, forse c'è qualche valore aggiunto, ma non so cosa sarebbe.

state python

posta Legit Stack 29.06.2018 - 02:01

fonte

3 risposte

1

Direi che il problema più grande con la variabile globale è lo stato globale mutevole stesso. Se una dipendenza di una funzione legge o scrive lo stato globale, diventa effettivamente un'interfaccia nascosta della funzione, che deve essere considerata quando la si utilizza. Quindi non importa molto come li si nasconde e si nasconde. Può essere una variabile globale, o una variabile locale del modulo con getter e setter, o anche una variabile locale del modulo che viene usata internamente.

In realtà, nell'esempio "courotine", lo stato non è globale, è legato alla variabile exmple_variable_coroutine , se non lo rendi globale ma crei solo la funzione interna, il tuo stato non è globale

risposta data 29.06.2018 - 04:50

fonte

0

Dalla mia esperienza, i valori globali devono sempre essere evitati, specialmente nei programmi di grandi dimensioni. Sono convenienti a breve termine, ma lungo la strada possono causare conflitti, problemi di manutenzione, possibilmente errori.

risposta data 29.06.2018 - 03:35

fonte

Leggi altre domande sui tag state python

Installazione dell'applicazione desktop con tecnologia mista Dovresti consentire all'utente di sovrascrivere il normale comportamento

score 1 · Accepted Answer

La tua coroutine implementa una variabile globale di sola lettura ma con passaggi aggiuntivi. Non vedo come abbia un valore rispetto al semplice utilizzo diretto di una variabile globale (specialmente considerando che la variabile che contiene la coroutine è anche una variabile globale). L'approccio di coroutine è discutibilmente peggiore perché lo stato di coroutine potrebbe cambiare, mentre una costante globale ... beh, rimane costante.

Non si tratta di dati globali condivisi, ma di uno stato condiviso. Qui, "stato" sono tutti i dati che cambiano nel tempo. Per un'applicazione Web, qualsiasi stato condiviso appartiene a un database oa un meccanismo di persistenza simile. Ma è perfetto caricare dati di sola lettura all'avvio e archiviare tali dati in una variabile globale.

Le guide di stile Python incoraggiano che tutte le variabili di livello superiore debbano essere costanti e devono usare ALL_UPPERCASE per indicare ciò. Python non può in realtà imporre che non si riassegna una variabile globale, ma è improbabile che accada per caso.

Quindi, in sintesi, se hai bisogno di mantenere i dati in giro per tutta la vita della tua app, allora una costante globale è decisamente preferibile rispetto a questa insolita costruzione di coroutine.