Tutorial: Escopo de variáveis em Python e LEGB!

Aprenda quais são os escopo de variáveis ​​em Python e se familiarize com a regra ‘LEGB’. Você também lidará com cenários em que poderá ver as palavras-chave globais e não-locais em ação.

Se você estiver familiarizado com o Python ou qualquer outra linguagem de programação, sem dúvida saberá que as variáveis ​​precisam ser definidas antes que possam ser usadas no seu programa.

Escopo de variáveis em Python

Neste tutorial, você começará com a inicialização variável . Em seguida, você se familiarizará com o limite de variáveis ​​em um programa – seu “escopo”. Você aprenderá sobre os quatro escopos diferentes com a ajuda de exemplos: local , anexo , global e interno.

Esses escopos juntos formam a base para a regra LEGB usada pelo interpretador Python ao trabalhar com variáveis. Depois, você revisitará alguns exemplos com complexidade adicional para abrir o caminho para a palavra-chave global seguida pela 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 seu programa lembre, para uso posterior. O que é ótimo no Python é que você não precisa declarar explicitamente qual é o tipo de variável que deseja definir – ela pode ser de qualquer tipo (string, número inteiro, float etc.).

Para criar uma nova variável no 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

Atribuir um valor inicial a uma variável é chamado inicializar a variável. Você acabou de inicializar a variável: first_string_var com um valor de sequência de Primeira sequência e 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 da atribuição.

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

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

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

# Nenhum espaço é permitido na variável
first string value = "First string"
File "<ipython-input-1-2a2f77c0b400>", line 2
    first string value = "First string"
               ^
SyntaxError: invalid syntax
# Não é possível iniciar com um número
1st_string_value = "First String"
File "<ipython-input-2-79b210888e10>", line 2
    1st_string_value = "First String"
                   ^
SyntaxError: invalid syntax
# Não pode ser uma palavra-chave

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 do programa. A parte de um programa em que uma variável está acessível é chamada de escopo. Existem quatro tipos principais de Escopo de variáveis em Python e é a base para a regra LEGB.

LEGB significa Local -> Enclosing -> Global -> Built-in.

Vamos aprender mais sobre escopos …

Escopo local

Sempre que você define uma variável dentro de uma função, seu escopo fica APENAS dentro da função. É acessível a partir do ponto em que é definida até o final da função e existe enquanto a função estiver em execução ( Origem ). O que 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)
O primeiro número definido é: 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()(# Print statement 1). Mas, ao tentar acessar e imprimir a mesma variável de fora da função (# Print statement 2), ele levantou a NameError. Isso ocorre porque first_num é “local” para a função – portanto, não pode ser acessado de fora do corpo da função.

Âmbito de fechamento

E se tivermos uma função aninhada (função definida dentro de outra função)? Como o escopo muda? 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 você não pode acessar  second_num a partir de outer()(# Print statement 3). Não está definido nessa função. No entanto, você pode acessar first_num a partir de inner()(# Print statement 1), porque o escopo de first_numé maior, está dentro outer().
Este é um escopo anexo.  Outer são variáveis ​​de um escopo maior e podem ser acessadas a partir da função incluída inner().

Âmbito global

Esse talvez seja o escopo mais fácil de entender. Sempre que uma variável é definida fora de qualquer função, ela se tornará uma variável de âmbito global e seu escopo está localizado em qualquer lugar do programa. Isso que dizer que pode ser utilizado por qualquer uma das funções.

greeting = "Olá"

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

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

greeting_world()
greeting_name("Carlos Eduardo")
Olá Mundo
Olá Carlos Eduardo

Âmbito incorporado

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.

Palavras-chave são simplesmente palavras reservadas especiais. Eles são mantidos para finalidades específicas e não podem ser usados ​​para nenhuma outra finalidade no programa. Estas são as palavras-chave em Python:

Regra do LEGB

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

Digamos que você esteja chamando print(x)dentro de inner(), que é uma função aninhada outer(). Então, o Python primeiro procurará se “x” foi definido localmente dentro de inner(). Caso contrário, a variável definida em outer()será usada. Esta é a função anexa. Se também não foi definido lá, o intérprete 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.

Escopo de variáveis em Python

Por enquanto, tudo bem!

Em seguida, revisitemos alguns exemplos anteriores para ver se eles podem criar problemas quando o caso de uso se tornar um pouco mais complexo.

Cenário 1: escopo global

Lembra da greeting_world() da função anterior? Digamos que você queira alterar a variável global greeting(“Olá”) para definir um novo valor (“Oi”) para a saudação, para que greeting_world() imprima “Oi Mundo”.

greeting = "Olá"

def change_greeting(new_greeting):
    greeting = new_greeting

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

change_greeting("Oi")
greeting_world()
Oi mundo

Bem … isso não foi exatamente como queríamos! Por quê?

Isso ocorre porque quando configuramos o valor greeting como “Oi”, ele criou uma nova variável local greeting no escopo de change_greeting(). Não mudou nada para o greeting global. É aqui que a palavra-chave global é útil.

Palavra-chave global

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

greeting = "Olá"

def change_greeting(new_greeting):
    global greeting
    greeting = new_greeting

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

change_greeting("Oi")
greeting_world()
Oi mundo

Ah, agora isso funcionou! Vamos para o próximo cenário …

Cenário 2: Enclosing Scope

Aqui, temos as funções outer()inner() aninhados a partir do exemplo Enclosing Scope (fechando escope). Vamos tentar alterar o valor de first_num 1 para 0 de dentro de 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 é assim tão simples, é! Para esses fins, usamos palavras-chave não-locais 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 não-local é útil em funções aninhadas. Faz com que a variável se refira à variável anteriormente vinculada no escopo mais próximo. Em outras palavras, impedirá que a variável tente ligar localmente primeiro e forçará a subir um nível ‘mais alto’. A sintaxe é semelhante à 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 ​​em Python, a regra LEGB e como deve usar as palavras-chave globais e não-locais. Você poderá manipular facilmente variáveis ​​em funções aninhadas, sem nenhum problema.

Para aprender mais sobre programação em Python, você definitivamente deve dar uma olhada nos nossos outros conteúdos relacionados a Python para Ciência de Dados . É um conteúdo dinâmico, fácil entendimento que abrange todos os conceitos básicos: de variáveis ​​e cálculos a listas, funções e pacotes.

Até a próxima!

Compartilhe

Share on facebook
Facebook
Share on twitter
Twitter
Share on linkedin
LinkedIn
Share on whatsapp
WhatsApp
Share on print
imprimir
Share on facebook
Share on twitter
Share on linkedin
Share on whatsapp
Share on print

O que achou deste artigo?

Leia também