Compreender Identificadores em Python

Introdução

Neste laboratório, você obterá uma compreensão abrangente dos identificadores em Python. Você aprenderá as regras fundamentais que regem como nomear variáveis, funções, classes e outros objetos em seu código Python.

Através da prática, você identificará nomes de identificadores válidos e inválidos, reforçando as convenções de nomenclatura. O laboratório também abordará convenções especiais de identificadores usadas em Python, equipando você com o conhecimento para escrever código claro, legível e de fácil manutenção.

Aprender Regras de Nomenclatura de Identificadores

Nesta etapa, aprenderemos sobre as regras para nomear identificadores em Python. Identificadores são nomes usados para identificar variáveis, funções, classes, módulos e outros objetos em um programa. Compreender as regras de nomenclatura é crucial para escrever código legível e de fácil manutenção.

Conforme mencionado na introdução, os identificadores Python devem seguir estas regras:

• Identificadores podem ser compostos por letras (a-z, A-Z), dígitos (0-9) e underscores (_).
• O primeiro caractere de um identificador não pode ser um dígito.
• Identificadores não podem conter espaços ou caracteres especiais como @, %, $, *, etc.
• Identificadores diferenciam maiúsculas de minúsculas (case-sensitive). myVariable e myvariable são considerados identificadores diferentes.
• Você não pode usar palavras-chave do Python ou nomes de funções built-in como identificadores.

Vamos criar um arquivo Python simples para praticar a definição de alguns identificadores.

Abra o terminal integrado no WebIDE clicando em Terminal -> New Terminal. Certifique-se de que você está no diretório ~/project.

Agora, vamos criar um novo arquivo Python chamado identifier_rules.py no diretório ~/project usando o editor VS Code. Você pode fazer isso clicando com o botão direito no painel do explorador de arquivos à esquerda e selecionando New File, ou usando a paleta de comandos (Ctrl+Shift+P ou Cmd+Shift+P) e digitando File: New File. Nomeie o arquivo como identifier_rules.py.

No arquivo identifier_rules.py, digite o seguinte código:

## This is a valid identifier
my_variable = 10

## This is also a valid identifier
anotherVariable = "Hello"

## This is a valid identifier starting with an underscore
_private_variable = True

## This is an invalid identifier (starts with a digit)
## 1st_variable = 5

## This is an invalid identifier (contains a space)
## my variable = "invalid"

## This is an invalid identifier (contains a special character)
## my-variable = 20

## This is an invalid identifier (using a keyword)
## if = 30

print(my_variable)
print(anotherVariable)
print(_private_variable)

Salve o arquivo pressionando Ctrl+S (ou Cmd+S).

Agora, vamos executar este script Python a partir do terminal para ver a saída. No terminal, certifique-se de que você está no diretório ~/project e execute o seguinte comando:

python identifier_rules.py

Você deverá ver a saída das instruções print, confirmando que os identificadores válidos foram processados corretamente. As linhas com identificadores inválidos estão comentadas, portanto, elas não causarão erros ao executar o script.

10
Hello
True

Este exercício demonstra as regras básicas para criar identificadores válidos em Python. Nas próximas etapas, exploraremos mais sobre identificadores válidos e inválidos e convenções de nomenclatura comuns.

Praticar Nomes de Identificadores Válidos

Nesta etapa, praticaremos a criação de nomes de identificadores válidos em Python com base nas regras que aprendemos na etapa anterior. Escolher nomes significativos e válidos para suas variáveis, funções e outros elementos de código é uma parte fundamental da escrita de bom código.

Vamos criar um novo arquivo Python chamado valid_identifiers.py no diretório ~/project usando o editor VS Code.

No arquivo valid_identifiers.py, digite o seguinte código. Este código define várias variáveis usando nomes de identificadores válidos e imprime seus valores.

## Valid variable names
user_age = 30
total_count = 100
item_price_usd = 25.50
is_active = True
_internal_value = "secret"
MAX_RETRIES = 5

## Valid function name (we will learn about functions later)
def calculate_total():
    return user_age * total_count

## Valid class name (we will learn about classes later)
class UserProfile:
    def __init__(self, name):
        self.name = name

## Print the values of the variables
print("User Age:", user_age)
print("Total Count:", total_count)
print("Item Price (USD):", item_price_usd)
print("Is Active:", is_active)
print("Internal Value:", _internal_value)
print("Maximum Retries:", MAX_RETRIES)

## Call the function and print the result
## print("Calculated Total:", calculate_total())

## Create an instance of the class and print a property
## user = UserProfile("Alice")
## print("User Name:", user.name)

Salve o arquivo pressionando Ctrl+S (ou Cmd+S).

Agora, vamos executar este script Python a partir do terminal. Certifique-se de que você está no diretório ~/project e execute o seguinte comando:

python valid_identifiers.py

Você deverá ver os valores das variáveis impressos no console.

User Age: 30
Total Count: 100
Item Price (USD): 25.5
Is Active: True
Internal Value: secret
Maximum Retries: 5

Observe como os nomes das variáveis usam underscores (_) para separar palavras, o que é uma convenção comum em Python para nomes de variáveis e funções (snake_case). Nomes de classes, como UserProfile, geralmente usam letras maiúsculas na primeira letra de cada palavra (PascalCase). Constantes, como MAX_RETRIES, são frequentemente escritas em letras maiúsculas com underscores.

Ao praticar com estes exemplos, você se familiariza mais com a criação de nomes de identificadores válidos e legíveis em Python.

Identificar Nomes de Identificadores Inválidos

Nesta etapa, focaremos em identificar nomes de identificadores inválidos em Python. Compreender o que torna um identificador inválido é tão importante quanto conhecer as regras para nomes válidos. Tentar usar um identificador inválido resultará em um SyntaxError quando você tentar executar seu código Python.

Vamos criar um novo arquivo Python chamado invalid_identifiers.py no diretório ~/project usando o editor VS Code.

No arquivo invalid_identifiers.py, digite o seguinte código. Este código contém exemplos de nomes de identificadores inválidos. Incluiremos intencionalmente estes para ver os erros que eles produzem.

## Invalid identifier: starts with a digit
## 1variable = 10

## Invalid identifier: contains a space
## my variable = "hello"

## Invalid identifier: contains a special character (@)
## user@name = "Alice"

## Invalid identifier: contains a special character (-)
## product-id = "XYZ123"

## Invalid identifier: using a Python keyword
## class = "Math"

## Invalid identifier: using another Python keyword
## for = 100

## Invalid identifier: contains a special character ($)
## total$amount = 50.75

## Invalid identifier: contains a special character (%)
## discount%rate = 0.15

print("Attempting to define invalid identifiers will cause a SyntaxError.")

Salve o arquivo pressionando Ctrl+S (ou Cmd+S).

Agora, vamos tentar executar este script Python a partir do terminal. Certifique-se de que você está no diretório ~/project e execute o seguinte comando:

python invalid_identifiers.py

Como todos os identificadores inválidos estão comentados, o script será executado sem erros e imprimirá a mensagem.

Attempting to define invalid identifiers will cause a SyntaxError.

Agora, vamos descomentar um dos identificadores inválidos para ver o erro. Remova o # do início da linha ## 1variable = 10. A linha agora deve ser 1variable = 10.

Salve o arquivo novamente.

Agora, execute o script novamente:

python invalid_identifiers.py

Desta vez, você deverá ver um SyntaxError indicando que o identificador é inválido porque começa com um dígito.

  File "/home/labex/project/invalid_identifiers.py", line 4
    1variable = 10
    ^
SyntaxError: invalid decimal literal

Você pode tentar descomentar outros identificadores inválidos um por um e executar o script para ver os diferentes tipos de mensagens SyntaxError que eles produzem. Lembre-se de comentar o identificador inválido anterior antes de descomentar o próximo para isolar o erro.

Esta etapa ajuda você a reconhecer erros comuns ao nomear identificadores e a entender a importância de seguir as regras de nomenclatura para evitar erros de sintaxe.

Compreender Convenções de Identificadores Especiais

Nesta etapa, exploraremos algumas convenções especiais para o uso de underscores em identificadores Python. Essas convenções não afetam necessariamente se um identificador é válido ou inválido de acordo com as regras básicas, mas transmitem significados específicos sobre o uso pretendido ou a visibilidade do identificador.

Aqui estão as convenções comuns de underscore:

• Underscore único inicial (_nome): Esta convenção indica que o identificador se destina ao uso interno dentro de um módulo ou classe. É uma dica para outros programadores de que eles não devem acessar diretamente este identificador de fora do módulo ou classe. No entanto, Python não impõe isso estritamente; você ainda pode acessá-lo se desejar.
• Underscore duplo inicial (__nome): Esta convenção é usada para "name mangling" (ofuscação de nome) em classes. Quando um identificador dentro de uma classe começa com dois underscores (e não termina com dois underscores), Python altera internamente o nome para dificultar o acesso direto de fora da classe. Isso ajuda a evitar conflitos de nomes na herança.
• Underscores duplos inicial e final (__nome__): Esses identificadores são reservados para uso especial pelo interpretador Python. Exemplos incluem __init__ (construtor), __str__ (representação em string), etc. Você deve evitar criar seus próprios identificadores com este padrão, a menos que esteja implementando um dos métodos especiais do Python.
• Underscore único final (nome_): Esta convenção é usada para evitar conflitos de nomes com palavras-chave do Python. Se você quiser usar um nome que seja uma palavra-chave do Python (como class ou for), você pode adicionar um underscore para torná-lo um identificador válido (por exemplo, class_, for_).

Vamos criar um novo arquivo Python chamado underscore_conventions.py no diretório ~/project usando o editor VS Code para ver essas convenções em ação.

No arquivo underscore_conventions.py, digite o seguinte código:

## Single leading underscore: intended for internal use
_internal_data = "This is internal data"

## Double leading underscore: name mangling in classes
class MyClass:
    def __init__(self):
        self.__private_attribute = "This is a private attribute"

    def get_private_attribute(self):
        return self.__private_attribute

## Double leading and trailing underscores: special method
class MyString:
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return f"MyString object with value: {self.value}"

## Single trailing underscore: to avoid keyword conflict
import builtins
class_ = "This variable name avoids conflict with the 'class' keyword"

print("Internal data:", _internal_data)

## Accessing the private attribute (demonstrating name mangling)
obj = MyClass()
## print(obj.__private_attribute) ## This will cause an AttributeError
print("Accessing private attribute via method:", obj.get_private_attribute())
## You can technically access it using the mangled name, but it's not recommended
## print("Accessing mangled name:", obj._MyClass__private_attribute)

## Using the special __str__ method
my_str_obj = MyString("Hello World")
print(my_str_obj) ## This calls the __str__ method

print("Variable name avoiding keyword conflict:", class_)

Salve o arquivo pressionando Ctrl+S (ou Cmd+S).

Agora, execute o script a partir do terminal:

python underscore_conventions.py

Você deverá ver a saída demonstrando o uso dessas convenções.

Internal data: This is internal data
Accessing private attribute via method: This is a private attribute
MyString object with value: Hello World
Variable name avoiding keyword conflict: This variable name avoids conflict with the 'class' keyword

Observe que tentar acessar diretamente obj.__private_attribute resultaria em um AttributeError devido à ofuscação de nome. Acessá-lo através do método get_private_attribute ou do nome ofuscado _MyClass__private_attribute funciona, mas a convenção é usar o método. A chamada print(my_str_obj) usa automaticamente o método __str__ porque é um método especial para representação em string.

Compreender essas convenções ajuda você a interpretar a intenção por trás dos nomes de identificadores no código Python e a escrever código que segue práticas comuns.

Resumo

Neste laboratório, aprendemos as regras fundamentais para nomear identificadores em Python. Praticamos a criação de nomes de identificadores válidos usando letras, dígitos e underscores, ao mesmo tempo em que aderimos à regra de que identificadores não podem começar com um dígito. Também identificamos nomes de identificadores inválidos que continham espaços, caracteres especiais ou eram palavras-chave do Python. Além disso, exploramos convenções especiais de identificadores, como o uso de um underscore inicial para variáveis "privadas".