Escopo das variáveis em Python

Se você estiver familiarizado com Python ou qualquer outra linguagem de programação, sem dúvida saberá que as variáveis precisam ser definidas antes de serem usadas no programa. Neste tutorial, você começará com a inicialização de variáveis. Em seguida, você se familiarizará com o limite das variáveis em um programa - seu "escopo". Você aprenderá sobre os quatro escopos diferentes com a ajuda de exemplos: local, envolvente, global e incorporado. Esses escopos juntos formam a base para a regra LEGB usada pelo interpretador Python ao trabalhar com variáveis. Em seguida, você revisitará alguns exemplos com complexidade adicional para abrir caminho para a palavra-chave global seguida da palavra-chave não local.

Variável

Uma variável é um rótulo ou um nome dado a um determinado local na memória. Esse local contém o valor que você deseja que o programa memorize, para uso posterior. O que é ótimo em Python é que você não precisa declarar explicitamente qual é o tipo de variável que deseja definir - ela pode ser de qualquer tipo (string, inteiro, float etc.). Para criar uma nova variável em Python, basta usar o operador de atribuição (=, um único sinal de igual) e atribuir o valor desejado a ela.

first_string_var = "First String"  
first_int_var = 1
total = 1 + 2 * 3

A atribuição de um valor inicial a uma variável é chamada de inicialização da variável. Você acabou de inicializar a variável: first_string_var com um valor de cadeia de caracteres de First String e a variável first_int_var com um valor inteiro ou numérico de 1.
A parte à esquerda do operador de atribuição é o nome da variável, e o lado direito é o seu valor. O lado direito também pode ser uma operação aritmética - nesse caso, ela será avaliada antes que a atribuição ocorra.

O Python tem algumas regras que você deve seguir ao criar uma variável...

• Ele só pode conter letras (maiúsculas ou minúsculas), números ou o caractere de sublinhado _.
• Ele pode não começar com um número.
• Pode não ser uma palavra-chave (você aprenderá sobre elas mais adiante).

Se você não seguir essas regras, receberá um erro. Experimente você mesmo:

# No spaces are allowed in the variable
first string value = "First string"

  File "<ipython-input-1-2a2f77c0b400>", line 2
    first string value = "First string"
               ^
SyntaxError: invalid syntax

# Cannot start with a number
1st_string_value = "First String"

  File "<ipython-input-2-79b210888e10>", line 2
    1st_string_value = "First String"
                   ^
SyntaxError: invalid syntax

# Cannot be a keyword

True = "True"

  File "<ipython-input-3-5d4d2170e79c>", line 3
    True = "True"
                 ^
SyntaxError: can't assign to keyword

Escopo variável

Agora que você sabe como inicializar uma variável. Vamos falar sobre o escopo dessas variáveis. Nem todas as variáveis podem ser acessadas de qualquer lugar em um programa. A parte de um programa em que uma variável é acessível é chamada de escopo. Há quatro tipos principais de escopo variável e é a base para a regra LEGB. LEGB significa Local -> Enclosing -> Global -> Built-in.

Vamos aprender mais sobre os escopos...

Escopo local

Sempre que você definir uma variável em uma função, seu escopo estará SOMENTE dentro da função. Ele pode ser acessado do ponto em que é definido até o final da função e existe enquanto a função estiver sendo executada(Fonte). Isso significa que seu valor não pode ser alterado ou mesmo acessado de fora da função. Vamos dar um exemplo simples:

def print_number():
    first_num = 1
    # Print statement 1
    print("The first number defined is: ", first_num)

print_number()
# Print statement 2
print("The first number defined is: ", first_num)

The first number defined is:  1



---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-10-17d580e01222> in <module>
      6 print_number()
      7 # Print statement 2
----> 8 print("The first number defined is: ", first_num)


NameError: name 'first_num' is not defined

Conseguimos imprimir a variável first_num chamando a função print_number() (# Declaração de impressão 1). Porém, ao tentar acessar e imprimir a mesma variável de fora da função (# Declaração de impressão 2), foi gerado um NameError. Isso ocorre porque o site first_num é "local" para a função - portanto, não pode ser acessado de fora do corpo da função.

Escopo de fechamento

E se tivermos uma função aninhada (função definida dentro de outra função)? Como o escopo é alterado? Vamos ver com a ajuda de um exemplo.

def outer():
    first_num = 1
    def inner():
        second_num = 2
        # Print statement 1 - Scope: Inner
        print("first_num from outer: ", first_num)
        # Print statement 2 - Scope: Inner
        print("second_num from inner: ", second_num)
    inner()
    # Print statement 3 - Scope: Outer
    print("second_num from inner: ", second_num)

outer()

first_num from outer:  1
second_num from inner:  2



---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-4-13943a1eb01e> in <module>
     11     print("second_num from inner: ", second_num)
     12
---> 13 outer()


<ipython-input-4-13943a1eb01e> in outer()
      9     inner()
     10     # Print statement 3 - Scope: Outer
---> 11     print("second_num from inner: ", second_num)
     12
     13 outer()


NameError: name 'second_num' is not defined

Ocorreu um erro? Isso ocorre porque não é possível acessar second_num em outer() (# Declaração de impressão 3). Ele não é definido nessa função. No entanto, você pode acessar first_num em inner() (# Print statement 1), porque o escopo de first_num é maior, pois está em outer().
As variáveis de Outer têm um escopo maior e podem ser acessadas a partir da função anexa inner().

Escopo global

Esse talvez seja o escopo mais fácil de entender. Sempre que uma variável é definida fora de qualquer função, ela se torna uma variável global, e seu escopo é qualquer lugar dentro do programa. Isso significa que ele pode ser usado por qualquer função.

greeting = "Hello"

def greeting_world():
    world = "World"
    print(greeting, world)

def greeting_name(name):
    print(greeting, name)

greeting_world()
greeting_name("Samuel")

Hello World
Hello Samuel

Escopo embutido

Esse é o escopo mais amplo que existe! Todas as palavras-chave reservadas especiais se enquadram nesse escopo. Podemos chamar as palavras-chave em qualquer lugar do nosso programa sem precisar defini-las antes do uso.

As palavras-chave são simplesmente palavras especiais reservadas. Elas são mantidas para fins específicos e não podem ser usadas para nenhum outro fim no programa.
Essas são as palavras-chave do Python:

Regra LEGB

LEGB (Local -> Enclosing -> Global -> Built-in) é a lógica seguida por um interpretador Python quando ele está executando o seu programa.

Digamos que você esteja chamando print(x) dentro de inner(), que é uma função aninhada em outer(). Em seguida, o Python procurará primeiro se "x" foi definido localmente em inner(). Caso contrário, será usada a variável definida em outer(). Essa é a função de fechamento. Se também não tiver sido definido lá, o interpretador Python subirá outro nível - para o escopo global. Acima disso, você encontrará apenas o escopo interno, que contém variáveis especiais reservadas para o próprio Python.

Até agora, tudo bem!

A seguir, vamos revisitar alguns exemplos anteriores para ver se eles podem criar problemas quando o caso de uso se torna um pouco mais complexo.

Cenário 1: Escopo global

Você se lembra da função greeting_world() que vimos anteriormente? Digamos que você queira alterar a variável global greeting("Hello") para definir um novo valor ("Hi") para a saudação, de modo que greeting_world() imprima "Hi World"

greeting = "Hello"

def change_greeting(new_greeting):
    greeting = new_greeting

def greeting_world():
    world = "World"
    print(greeting, world)

change_greeting("Hi")
greeting_world()

Hello World

Bem... não foi o que eu queria! Por quê?

Isso ocorre porque, quando definimos o valor de greeting como "Hi", foi criada uma nova variável local greeting no escopo de change_greeting(). Isso não mudou nada para a greeting global. É nesse ponto que a palavra-chave global é útil.

Global Keyword

Com global, você está dizendo ao Python para usar a variável definida globalmente em vez de criar uma localmente. Para usar a palavra-chave, basta digitar 'global', seguido do nome da variável. Vamos ver isso em ação no Cenário 1.

greeting = "Hello"

def change_greeting(new_greeting):
    global greeting
    greeting = new_greeting

def greeting_world():
    world = "World"
    print(greeting, world)

change_greeting("Hi")
greeting_world()

Hi World

Funcionou! Vamos passar para o próximo cenário...

Cenário 2: Escopo de fechamento

Aqui, vamos dar uma olhada nas funções aninhadas outer() e inner() do exemplo Enclosing Scope. Vamos tentar alterar o valor de first_num de 1 para 0 em inner().

def outer():
    first_num = 1
    def inner():
        first_num = 0
        second_num = 1
        print("inner - second_num is: ", second_num)
    inner()
    print("outer - first_num is: ", first_num)

outer()

inner - second_num is:  1
outer - first_num is:  1

Nem sempre é tão simples, não é mesmo? Para esses fins, usamos a palavra-chave não local no Python.

Palavra-chave não local

Essa é outra palavra-chave útil que nos permite trabalhar de forma mais flexível e organizada com escopos variáveis. A palavra-chave nonlocal é útil em funções aninhadas. Isso faz com que a variável se refira à variável vinculada anteriormente no escopo mais próximo. Em outras palavras, isso impedirá que a variável tente se vincular localmente primeiro e a forçará a ir para um nível "superior". A sintaxe é semelhante à da palavra-chave global.

def outer():
    first_num = 1
    def inner():
        nonlocal first_num
        first_num = 0
        second_num = 1
        print("inner - second_num is: ", second_num)
    inner()
    print("outer - first_num is: ", first_num)

outer()

inner - second_num is:  1
outer - first_num is:  0

E aí está!

Conclusão

Agora você sabe qual é o escopo das variáveis do Python, a regra LEGB e como você deve usar as palavras-chave global e não local. Você poderá manipular facilmente variáveis em funções aninhadas, sem nenhum problema. Para saber mais sobre programação em Python, você deve dar uma olhada no curso Intro to Python for Data Science do DataCamp. É um curso interativo que abrange todos os conceitos básicos: de variáveis e cálculos a listas, funções e pacotes.