Como chamar uma variável de outra função em Python

TLDR: Retorna a variável. Existem outros métodos mas eles não são tão limpos.

É assim que eu entendo a sua pergunta: Como aceder a uma variável definida numa função em Python?

Presumo que tenha algo como isto:

1. def foo(): 
2. # Faz algumas coisas. 
3. a = 42 
4. return 10 

We define a function, say foo, doing some very important stuff and returning 10. Dentro de foo definimos uma variável a, a qual você quer acessar fora de foo.

Solução 1: Usando return.

A maneira limpa de acessar um exterior de foo é retorná-lo. Você pode retornar objetos arbitrários, assim você pode retornar sua resposta padrão (no nosso caso 10) e a variável a, ambas envolvidas em um tuple, lista, dicionário ou mesmo uma instância de uma classe feita sob medida.

1. # Solução usando tuples. 
2.  
3. def foo(): 
4. >li> # Faz algumas coisas. 
5. a = 42 
6. return (10,a) 
7.  
8. foo()[0] # 10 
9. foo()[1] # 42 

I regard this soultion as “clean”, because it doesn’t introduce hidden elements to your namespaces (neither the module namespace as with global, nor your functions namespace as with function attributes. The input-output system is the default interface for functions.

That being said, maybe one of these other solutions matches your use-case.

Solution 2: Using global.

Global variables are accesible everywhere. You can define global variables from within functions. You cannot edit them from within a function without declaring them as global first.

1. def foo(): 
2. ## Faz algumas coisas. 
3. global a 
4. a = 42 
5. return 10 
6.  
7. foo() # 10 
8. a # 42 

Inside foo we declare a as a global variable. a is now accesible everywhere.

Note that we still have to call foo. Apenas definindo uma função não executará seu código em tempo de execução. Uma desvantagem desta abordagem é que o estado global do seu módulo agora depende se foo foi ou não chamado pelo menos uma vez em tempo de execução.

Solução 3: Usando atributos de função.

Tudo é um objeto em Python, até mesmo funções. É por isso que você pode atribuir atributos a funções exatamente como faria a um objeto.

1. def foo(): 
2. # Do some things. 
3. foo.a = 42 
4. return 10 
5.  
6. foo() # 10 
7. foo.a # 42 

This solutuon is essentially the same as the previous one, with the exception that the namespace you’re modifying is the one of foo.

It has the same type of drawbacks. Você está essencialmente armazenando valores em namespaces dinamicamente e então esperando que o código que o usa saiba tanto onde procurar e se foi colocado lá ou não.