come attivare una funzione da un altro script


Risposta 1:

Il tuo codice originale è:

def func1 (): a = 8 b = 9def func2 (x, y): z = x + y + a + b ritorno za = func2 (4,6)stampa (a)

Ci sono diversi modi per farlo:

# Usa i valori di ritorno # Sii esplicito che la chiamata a func2 si basa sul risultato # della chiamata a func1def func1 (): a = 8 b = 9 restituire a, bdef func2 (x, y, args): a, b = * args # Decomprime dagli argomenti z = x + y + a + b ritorno za = func2 (4,6, args = func1 ())stampa (a)# ma potresti fare: a = func2 (4,6, args = (9,11)) # Non hai bisogno di una funzione per creare i tuoi dati

o

# Funzioni di passaggio: # In questa soluzione sei esplicito quando chiami # func2 che deve chiamare func1: func1 è una funzione di supportodef func1 (): a = 8 b = 9 restituire a, bdef func2 (x, y, func): a, b = func () z = x + y + a + b ritorno za = func2 (4,6, func1)stampa (a)# Se hai un'altra funzione che genera una coppia di valori # potresti passare anche quello

Direi di non usare affatto Globals: sembrano una soluzione rapida ma sono una pessima abitudine in cui entrare.

I globali per definizione rappresentano informazioni su come funziona la tua funzione che è al di fuori degli argomenti della tua funzione, il che può rendere la tua funzione molto più difficile da testare - poiché ora devi passare argomenti alla tua funzione e impostare separatamente i valori globali rilevanti in ordine per testare la tua funzione (tu provi le tue funzioni, vero). A volte è impossibile allontanarsi dai dati globali (ad esempio database, siti Web esterni) e devi fare i salti mortali a volte per testare il tuo codice quando hai dati esterni, ma non renditi la vita ancora più difficile .


Risposta 2:

Dipende dal codice in ogni file, ma la risposta è essenzialmente la stessa:

Sia che la funzione sia un metodo di un oggetto, o semplicemente nuda in un modulo, puoi importarla da ovunque sia stata dichiarata, ovunque tu voglia usarla.

Potresti avere buone ragioni per non incorporare la tua funzione in un oggetto, ma potresti voler convalidare quella ragione. Ci sono argomenti ragionevoli a favore e contro.

Chiamiamo un file di codice Python un "modulo". Convenientemente, i moduli Python ci forniscono uno spazio dei nomi "libero" per mantenere le nostre dichiarazioni fuori dallo spazio dei nomi globale, dove potrebbero entrare in conflitto con dichiarazioni attuali o future in altre parti del codice.

Una struttura di directory di moduli strettamente correlati è chiamata pacchetto.

Una struttura di directory di moduli non correlati è chiamata ... un pasticcio.

In ogni caso, se un modulo, memorizzato in un file chiamato foo.py, contiene una funzione chiamata bar:

def bar (cosa1, cosa2): restituisce "{0}, {1}". format (cosa1, cosa2)// ignora questo per il momento def yoda_speak (cosa1, cosa2): restituisce "{0}, {1}". format (cosa2, cosa1)

... poi, in un altro file, puoi importare la barra delle funzioni dal modulo pippo:

dalla barra di importazione foocosa = barra ("importato", "questo")

... oppure, puoi importare l'intero modulo foo, tutti hanno accesso a tutte le sue funzioni contemporaneamente, se sei sicuro di volerle tutte ... purché ti riferisca a loro tramite il loro spazio dei nomi (ad esempio foo.function_name () ) ...

import fooBoth_things = foo.bar ("Attento a questo", "ma puoi importare tutte le funzioni in questo modulo") yoda_speak = foo.anti_bar ("questo è", "Al contrario")

Risposta 3:

C'è un caso che fa esattamente quello che descrivi nella tua domanda, anche se potrebbe non essere il tuo caso d'uso. È una * chiusura *.

def myfunction (a): b = 2 * a def myotherfunzione (c): ritorno b * c ripristinare la mia altra funzione

myotherfunction è effettivamente mantenere una copia di a, che utilizzerà ogni volta che viene invocato

myother = myfunction (5)risultato = mio altro (5)stampa (risultato)

che stamperà: 50

La variabile locale b è il risultato di a * 2, che nel nostro caso era 5. Questo è tenuto come riferimento per la mia altra funzione che è il valore di ritorno

Ogni volta che la funzione restituita viene invocata, moltiplicherà l'argomento c per il valore della variabile locale b che è stata tenuta come riferimento.


Risposta 4:

Offro altri modi, sebbene l'uso di una classe e metodi e attributi sia la strada da percorrere.

'' ' soluzione esplicita, passando le informazioni attraverso un mutabile. Uso qualcosa di simile per programmi ricorsivi con informazioni sullo stato.'' 'import pprintdef f (d: dict) -> Nessuno: print ('funzione f: popolamento argomento con variabili locali') a_local_variable = 'f mi ha creato' d ['a_local_variable_from_elsewhere'] = a_local_variabledef g (d: dict) -> Nessuno: print ('FUNZIONE g: UTILIZZO DI ARGOMENTO CON VARIABILI LOCALI CREATE ALTROVE') pprint.pprint (d)def main (): pass_variables_around = {} f (pass_variables_around) g (pass_variables_around)principale()

Risposta 5:
variabile = 0def modify_global (): variabile globale variabile + = 1variabile di stampa>>>> 1

La parola chiave globale consente la modifica delle variabili globali localmente in una funzione.

La definizione di una funzione all'interno di un'altra non passa il valore delle variabili con lo stesso nome. Check-out

9. Classi - Documentazione di Python 3.7.0

le sezioni 9.1 e 9.2 per una breve spiegazione di come funzionano i nomi in Python.


Risposta 6:
def func1 (): globale a, b a = 8 b = 9def func2 (x, y): func1 () z = x + y + a + b ritorno za = func2 (4, 6)stampa (a)# Sono nuovo in Python quindi non sono sicuro che questa sia la soluzione migliore. Ma questa è una delle soluzioni.Devi essenzialmente rendere globali le variabili a e b mentre le dichiari se vuoi usarle in un'altra funzione.

Risposta 7:

Non sono sicuro di aver capito cosa intendi. Ma se importi una funzione da un file a un altro, l'importatore può passare valori alla funzione e la funzione può aggiornare qualsiasi cosa nel proprio file.

Tuttavia, se ho capito bene (ed è molto probabile che non lo sappia), quello che stai cercando di fare è, in molti casi, una pessima pratica di programmazione, affidandoti a moduli globali.


Risposta 8:

Anche se ci sono certamente dei modi, non farlo. Se desideri modificare alcuni valori all'interno di una funzione e utilizzare quei valori modificati in un'altra funzione, passa i valori da modificare alla prima funzione tramite i parametri di invocazione e accetta i valori modificati come valore di ritorno della funzione. Passa i valori modificati alla seconda funzione e accetta i suoi valori di ritorno.

Questa è una best practice generalmente accettata dal paradigma di programmazione funzionale che tenta di ridurre al minimo (inaspettato e non ovvio) gli effetti collaterali della chiamata di una funzione.


Risposta 9:

Il codice che hai fornito genererà errori.

Perché? A causa di come funzionano gli ambiti variabili in Python. aeb, dichiarati in func (), influenzano solo quella funzione, che è il loro ambito.

Se vuoi modificare i valori di una variabile globale all'interno di una funzione, devi usare la parola chiave globale:

globale xx = 123stampa xfunc ()stampa xdef func (): x = 124

tl; dr Il tuo codice, così com'è, non funzionerà.


Risposta 10:

Sì, questo è quello che stai cercando. Spero che sia d'aiuto.

def c (): r = raw_input ("Chiedi qualcosa?") ... ritorno rdef p (x): ... fare qualcosa ....r = c ()p (r)