Variáveis
Definição
Em Python, uma variável é simplesmente um nome para um objeto. Não existe a necessidade de criar ou definir o tipo de dado de uma variável antes do seu uso. Isto significa que a definição de uma variável corresponde à nomeação de um objeto, ou seja, à associação de um nome a um objeto.
Por exemplo, considere o número inteiro 5. Este número pode ser associado à variável teste e à variável contador. Temos então dois nomes para um mesmo dado.
teste = 5 contador = 5
Se a variável teste passar a ser associada à string ‘python para todos’, o valor 5 passará a ter um único nome (contador).
É também possível associar mais de um nome a um único objeto em um mesmo comando.
teste = contador = 5
Nomes de Variáveis
- Pode começar com uma letra ou com _
- Não pode começar com número
- Pode conter caracteres alfanuméricos e _
- É case sensitive (TESTE ≠ teste)
- Não pode ser uma palavra-chave (keyword). Na versão Python 3.8, 35 palavras-chaves estão definidas.
| False | await | else |
| None | break | except |
| True | class | finally |
| and | continue | for |
| as | def | from |
| assert | del | global |
| async | elif | if |
| pass | raise | return |
| while | with | yield |
| import | in | is |
| lambda | nonlocal | not |
| or | try |
Local x Global
- Variáveis locais só podem ser usadas nas funções em que foram definidas
- Variáveis globais são definidas fora de funções
- É possível em uma função ler o conteúdo de uma variável global
- Para alterar uma variável global, ela precisa ser declarada no corpo da função usando o comando global
No exemplo abaixo, temos uma variável local x que existe apenas dentro da função teste() e uma variável global x definida no início do programa (fora da função). Embora a variável global x seja passada na chamada de teste(), ela não é usada na função.
x = 2
def teste(x):
x = 5
print('* 1 * x =', x)
teste(x)
print('* 2 * x =', x)
O resultado do programa é:
* 1 * x = 5 * 2 * x = 2
Agora vejamos o mesmo programa usando apenas a variável global x. Neste caso, a função teste() altera o valor associado à variável x.
x = 2
def teste():
global x
x = 5
print('* 1 * x =', x)
teste()
print('* 2 * x =', x)
Agora o resultado do programa é
* 1 * x = 5 * 2 * x = 5
Tipos de Dados
Uma variável pode ser associada a diferentes tipos de dados. A tabela abaixo mostra os tipos básicos (built-in) de dados do Python.
| Tipo de Dado | Exemplo |
| str | a = ‘Maria’ |
| int | b = 10 |
| float | c = 23.89 |
| complex | d = 3 +2j |
| list | e = [1, ‘ab’, 23.7] |
| tuple | f = (‘DPW’, ‘TP1’, ‘OC’) |
| range | g = range(0,10) |
| dict | h = {“nome”: “Maria”, “matrícula”: “20182210034”} |
| set | i = {‘DPW’, ‘TP1’, ‘OC’} |
| frozenset | j = frozenset(e) |
| bool | k = True |
| bytes | l = b’teste de bytes’ |
| bytearray | m = bytearray([1, 3, 5, 7]) |
| memoryview | n = memoryview(m) |
| none | o = None |
Pode-se usar a função type() para verificar o tipo de dado de uma variável. Para os exemplos mostrados na tabela acima, basta entrar com os seguintes comandos:
print(type(a)) print(type(b)) print(type(c)) print(type(d)) print(type(e)) print(type(f)) print(type(g)) print(type(h)) print(type(i)) print(type(j)) print(type(k)) print(type(l)) print(type(m)) print(type(n)) print(type(o))
A saída gerada pelo Python é mostrada abaixo.
<class 'str'> <class 'int'> <class 'float'> <class 'complex'> <class 'list'> <class 'tuple'> <class 'range'> <class 'dict'> <class 'set'> <class 'frozenset'> <class 'bool'> <class 'bytes'> <class 'bytearray'> <class 'memoryview'> <class 'NoneType'>
Objetos
Python é uma linguagem orientada a objetos. Ao nomear um objeto, se não for especificado o tipo de dado, a linguagem deduz a classe. Por exemplo,
a = 12.5 b ='12.5'
A variável a é associada a um objeto da classe float, enquanto a variável b é associada a um objeto da classe string.
Para definir explicitamente a classe da variável, pode-se usar a função construtora correspondente.
a = float(12.5)
b = str('12.5')
Identificador
Um objeto em Python possui uma identificação única e constante durante toda a execução do programa. Uma variável, ao ser associada a um determinado objeto, assume a identificação desse objeto. Para conhecer a identificação de uma variável, basta usar a função id().
teste = 10
nome = 'Maria'
print(id(teste))
print(id(nome))
Uma possível saída para o exemplo é mostrada abaixo. Portanto a variável teste é identificada por 10914784, enquanto a variável nome é identificada por 140327649540224.
10914784 140327649540224
Observe agora o seguinte exemplo:
a = 15
b = a
print('id(a) =',id(a), ', id(b) =', id(b), ', id(15) =', id(15))
Um possível resultado é
id(a) = 10914944 , id(b) = 10914944 , id(15) = 10914944
Por que as variáveis a e b possuem a mesma identificação do número 15? Porque a e b são dois nomes para o objeto inteiro com valor 15.
Vamos então modificar o exemplo e ver o que acontece.
a = 15
b = a
b = 3
print('id(a) =',id(a), ', id(b) =', id(b))
print('id(15) =', id(15), ', id(3) =', id(3))
Abaixo é mostrada uma possível saída para o programa. Note que agora as variáveis a e b possuem identificações diferentes. São dois nomes para dois objetos diferentes.
id(a) = 10914944 , id(b) = 10914560 id(15) = 10914944 , id(3) = 10914560
Portanto, ao fazer uma cópia de uma variável, é possível que você esteja apenas dando um outro nome para um mesmo objeto. Em especial, é preciso ter muito cuidado ao associar nomes a listas e dicionários.
lista1 = [34, 82]
lista2 = lista1
lista2[0] = 19
print(lista1)
print(lista2)
print(id(lista1))
print(id(lista2))
O resultado da execução é mostrado abaixo. Note que lista1 e lista2 são dois nomes para uma mesma lista. Isto significa que, ao modificar apenas um item de lista2, o Python não entendeu que precisava criar uma cópia em separado para lista2 (não houve ordem explícita para fazer isso)
[19, 82] [19, 82] 140483812747464 140483812747464
Variáveis especiais
O Python possui algumas variáveis especiais cujo nome é precedido e seguido por __. A seguir, são apresentados alguns exemplos. Para mais detalhes, veja https://docs.python.org/3/reference/datamodel.html#the-standard-type-hierarchy.
- Exemplo: a variável __name__ informa o nome do módulo em execução: se o módulo corresponde ao arquivo que foi chamado na linha de comandos, a variável tem o valor __main__; se o módulo corresponde a um arquivo importado pelo programa inicial, a variável possui o nome do módulo importado.
import teste
print("Arquivo principal")
print("__name__ = %s" %__name__)
if __name__ == "__main__":
print ("Arquivo está sendo executado diretamente\n")
else:
print ("Arquivo está sendo importado\n")
print("Fatorial de 5 =", teste.fatorial(5))
Considere que o módulo teste.py possui a definição abaixo.
def fatorial(n):
i = 1
fat = 1
while i < n + 1:
fat = fat * i
i = i + 1
print("Arquivo teste.py com fatorial")
print("__name__ = %s\n" %__name__)
return fat
O programa apresenta a resposta abaixo.
Arquivo principal __name__ = __main__ Arquivo está sendo executado diretamente Arquivo teste.py com fatorial __name__ = teste Fatorial de 5 = 120
- Exemplo: __file__ é uma variável que contém o caminho para o módulo em execução. Usando o mesmo exemplo acima, apenas substituindo __name__ por __file__, o programa apresenta a resposta abaixo.
Arquivo principal __file__ = /home/morganna/Área de Trabalho/testes/principal.py Arquivo está sendo importado Arquivo teste.py com fatorial __file__ = /home/morganna/Área de Trabalho/testes/teste.py Fatorial de 5 = 120
- Exemplo: __dict__ é uma variável que possui a tabela de símbolos do módulo.
class Valor(object):
def __init__(self, valor):
self.valor = valor
valor1 = Valor(4)
valor2 = Valor(7)
print("*** Tabela da classe Valor")
print(Valor.__dict__, "\n")
print("*** Tabela do objeto valor1")
print(valor1.__dict__, "\n")
print("*** Tabela do objeto valor2")
print(valor2.__dict__, "\n")
A resposta do programa é mostrada abaixo. Observe que a variável mostra a tabela da classe Valor e, em seguida, as tabelas dos objetos valor1 e valor2.
*** Tabela da classe Valor
{'__module__': '__main__', '__init__': <function Valor.__init__ at 0x7f5cd39ba200>, '__dict__': <attribute '__dict__' of 'Valor' objects>, '__weakref__': <attribute '__weakref__' of 'Valor' objects>, '__doc__': None}
*** Tabela do objeto valor1
{'valor': 4}
*** Tabela do objeto valor2
{'valor': 7}