Variáveis

Podemos usar uma linguagem de programação, como Python, para fazer cálculos ou trabalhar com valores constantes como inteiros ou strings, mas isso é o suficiente? Ao escrever programas reais, geralmente precisamos armazenar valores ou resultados de operações/cálculos na memória do computador para serem utilizados posteriormente.

O que é uma variável?

Variável é um local nomeado onde podemos armazenar algum valor e acessar o valor posteriormente. Imagine uma caixa onde guardamos algo. Essa é uma variável. Por exemplo, você calcula algo e gostaria de reutilizar a fórmula para alguns outros números. Neste caso, você opera apenas essas "caixas". Para armazenar algo nessas "caixas", usaremos o símbolo de igualdade (=) entre o nome do compartimento e o valor que queremos armazenar. Essa operação é chamada de atribuição, onde um valor é atribuído a uma variável.

Dica

Em geral, é uma boa prática dar um nome que descreva o conteúdo de uma variável.

Toda variável deve ser declarada antes de ser usada. Isso pode ser feito em praticamente qualquer parte do código, desde que antes da primeira utilização. As variáveis, de maneira geral, possuem um grupo de características que as definem e as tornam uma entidade única. Há quatro características elementares referentes a todas as variáveis: nome, tipo, tamanho e valor.

Nome

O nome da variável ou então, a referência, é como se refere a um determinado espaço de memória. Toda vez que é utilizado o nome de uma variável, pode-se ler o valor contido nela, ou então, atribuir qualquer outro valor. O nome de uma variável é dado por um identificador, que é qualquer sequência de letras do alfabeto, dígitos e subscrito (_), desde que não comece com dígito.

Exemplos:

As palavras class e as são duas das palavras reservadas (palavras-chave) de Python. As palavras reservadas definem as regras de sintaxe e estrutura da linguagem e elas não podem ser usadas como nomes de variáveis. Python tem aproximadamente 30 palavras reservadas (esse número pode variar, à medida que a linguagem evolui):

Você não precisa memorizar essa lista. Na maioria dos ambientes de desenvolvimento, as palavras-chave são exibidas em uma cor diferente; se você tentar usar uma como um nome de variável, você saberá.

Em Python, os identificadores são case-sensitive, ou seja, letras maiúsculas e minúsculas são consideradas diferentes (nome não é o mesmo que Nome).
Tipo

O tipo da variável funciona como uma espécie de classificação das informações, ou seja, o tipo informa com antecedência qual informação podemos esperar de determinada variável. Toda variável declarada será, obrigatoriamente, de algum tipo. O tipo da variável será armazenado junto com o valor que esta estará armazenando.

Em Python, já é pré-definida algumas operações para alguns tipos de dados, por exemplo, quando utilizamos o operador + (adição) entre 2 variáveis que contenham números inteiros, o interpretador, somará os valores. Porém, se utilizarmos o sinal de adição com 2 variáveis do tipo string, o interpretador fará uma concatenação.

Alguns tipos comuns de Python:
- int: Números inteiros. Exemplos: 1, -2, 0, 2000
- float: Números reais (ponto-flutuante). Exemplos: -5.0, 2.5, 10e-3, 3.2e5
- str: Cadeia de caracteres (string). Exemplos: "Python", "Olá, mundo!"
- bool: Valores booleanos - True (Verdadeiro) e False (Falso)
- list: Lista de valores. Exemplos: [2, 3, 5, 7], ["uva", "maçã", "kiwi"], ["Paulo", 1.82, True, 9.3]
A função type() pode ser utilizada para mostrar o tipo de um dado. Essa função recebe um argumento que terá o tipo identificado. Como resposta, a função informa o tipo do dado fornecido como argumento. Veja alguns exemplos de utilização da função type():
CódigoTestar
>>> type(2) <class 'int'> >>> type(42.0) <class 'float'> >>> type("Ufes") <class 'str'> >>> type(True) <class 'bool'> >>> type([2, 3, 5]) <class 'list'>
Fique ligado

Diferentemente de outras linguagens de programação como C, C++ e Java, Python possui tipagem dinâmica. Uma linguagem de programação que possui tipagem dinâmica não exige que o programador declare, explicitamente, o tipo de dado que será armazenado por cada variável. Essa característica permite que, ao longo da execução de um programa, uma mesma variável armazene valores de tipos distintos. Observe o exemplo abaixo:
```
>>> x = 10
>>> x
10
>>> x = 15.6
>>> x
15.6
>>> x = "Ufes"
>>> x
Ufes
>>> x = True
>>> x
True
```
Tamanho

As informações precisam ser armazenadas em alguma mídia, e as variáveis, são armazenadas na memória RAM do nosso computador. Assim, de acordo com o tipo da variável, o tamanho de uma variável representa o espaço usado na memória.
Valor

Representa a informação contida na variável, isto é, o dado propriamente dito, é a parte principal de qualquer variável. Como já dito, para atribuir um valor a uma variável, utilizamos o operador de atribuição que, em Python, é representado pelo símbolo de =.
CódigoTestar
>>> a = 1 >>> a 1 >>> b = a + 2 >>> b 3 >>> c = 2**3 >>> c 8 >>> nome = "Ana" >>> nome 'Ana' >>> Nome = "Bia" # (1) >>> Nome 'Bia' >>> nome 'Ana'
1. Lembre-se que Python é case-sensitive, ou seja, letras maiúsculas e minúsculas são consideradas diferentes.
Como estamos no Python Shell, não precisamos usar a função print() para exibirmos o valor armazenado em uma variável, mas no modo script (quando temos um arquivo .py) qualquer coisa que queira ser exibida na tela deve ser feita usando a função print().

Como visto na imagem anterior, após uma variável ser declarada, podemos usar o seu valor armazenado para fazermos operações. Veja mais um exemplo:
```
>>> x = 4
>>> print(x**2 + 2*x + 1)
25
>>> print(x**0.5)
2
```
Note que agora foi usado a função print() para exibir os resultados.

O que representa x**0.5?
Analise o código abaixo. Por que um programador optaria (qual a vantagem) por usar variáveis ao invés de simplesmente fazer print(1500 + (1500*5)/100)?
```
>>> salario = 1500
>>> aumento = 5
>>> print(salario + (salario*aumento)/100)
1575.0
```
Vejamos mais um exemplo:
```
>>> x = 4
>>> y = 5
>>> x = x + y
>>> print(x)
9
>>> x = x - y
>>> print(x)
4
>>> x = x * y
>>> print(x)
20
>>> x = x / y
>>> print(x)
4.0
```
Você consegue entender o que representa a expressão x = x + y? Ela pode ser lida/entendida da seguinte maneira: "pegue o valor que está armazenado em x, some com o valor de y e atribua o resultado a x"

Por que a variável x terminou com valor 4.0 ao invés de 4?

Para os operadores matemáticos, é possível utilizar uma forma compacta para atualizar o valor de uma variável:

Forma compacta Equivalente a

x += y x = x + y

x -= y x = x - y

x *= y x = x * y

x /= y x = x / y

x %= y x = x % y

x //= y x = x // y

x **= y x = x ** y

Exemplo:
```
>>> n = 10
>>> n += 50
>>> print(n)
60
>>> n -= 20
>>> print(n)
40
>>> n *= 2
>>> print(n)
80
>>> n /= 4
>>> print(n)
20.0
>>> n %= 3
>>> print(n)
2.0
```
Python também permite atribuição encadeada, o que torna possível atribuir o mesmo valor a várias variáveis simultaneamente:
```
>>> a = b = c = 300
>>> a
300
>>> b
300
>>> c
300
```
A atribuição encadeada acima atribui 300 às variáveis a, b e c simultaneamente. Além disso,também é possível atribuir múltiplos valores a múltiplas variáveis:
```
>>> a, b, c = 5, 3.2, "Hello"
>>> a
5
>>> b
3.2
>>> c
'Hello'
```

Variáveis Numéricas

Uma variável é dita numérica quando armazena números inteiros (int) ou de ponto flutuante (float). Os números inteiros são aqueles sem parte decimal, como 1, 0, -5, 550, etc. Números de ponto flutuante ou decimais são aqueles com parte decimal, como 1.0, 3.1415, 0.05, etc. Observe que 1.0, mesmo tendo zero na parte decimal, é um número de ponto flutuante.

Esteja ciente que é possível encontrar problemas de representação de valores em função de como os números decimais são convertidos em números de ponto flutuante. Este não é um problema do Python, mas o hardware de ponto flutuante subjacente na CPU. Veja dois exemplos:

>>> a = 2.1 + 4.2
>>> a
6.300000000000001
>>> 3*0.1
0.30000000000000004

Variáveis do tipo Lógico

Em muitos casos, é preciso armazenar um conteúdo simples: verdadeiro ou falso em uma variável. Nesse caso, é utilizado um tipo de variável chamado de tipo lógico ou booleano (ou simplesmente bool), que possui apenas dois valores possíveis: True para verdadeiro e False para falso.

Em linguagens de programação, o tipo booleano, ou lógico, é uma maneira comum de representar algo que tem apenas dois estados opostos, como ligado ou desligado, sim ou não, etc.

>>> venceu = True
>>> print(venceu)
True
>>> aprovado = False
>>> print(aprovado)
False

Operadores de Comparação

As operações de comparação ou relação permitem comparar dois valores e determinar a relação entre eles. Os principais operadores de comparação em Python são:

Operador	Operação	Símbolo matemático	Exemplo de aplicação
`==`	igualdade	\(=\)	`3 == 2 #resulta em False`
`>`	maior que	\(>\)	`3 > 2 #resulta em True`
`<`	menor que	\(<\)	`3 < 2 #resulta em False`
`!=`	diferente	\(\neq\)	`3 != 2 #resulta em True`
`>=`	maior ou igual	\(\geq\)	`3 >= 2 #resulta em True`
`<=`	menor ou igual	\(\leq\)	`3 <= 2 #resulta em False`

O resultado da aplicação desses operadores é sempre True ou False.

Veja alguns exemplos:

>>> a = 1
>>> b = 5
>>> a == b # a é igual a b?
False
>>> b > a # b é maior que a?
True
>>> a < b
True
>>> a != b
True
>>> c = 1
>>> a == c
True
>>> c > a
False
>>> c >= a
True
>>> c < a
False
>>> c <= a
True

Também podemos utilizar variáveis do tipo lógico para armazenar o resultado de expressões e comparações:

>>> notaProva1 = 8
>>> notaProva2 = 6
>>> media = (notaProva1 + notaProva2) / 2
>>> aprovado = media >= 7.0
>>> print(aprovado)
True

Operadores Lógicos

Para agrupar operações com lógica booleano, utilizamos operadores lógicos. Python, assim como outras linguagens, possui três operadores lógicos para realização de testes compostos: not (não), and (e), or (ou). Este operadores são usados para unir duas ou mais condições.

Operador and: operador binário (precisa de dois argumentos) e retorna True se ambas as declarações forem verdadeiras, caso contrário, retorna False. Exemplos:

>>> True and True
True
>>> True and False
False
>>> False and True
False
>>> False and False
False
>>> x = 2
>>> y = -2
>>> print(x > 0 and y < 0)
True
>>> print(x > 0 and y > 0)
False
>>> print(x < 0 and y < 0)
False
>>> print(x < 0 and y > 0)
False

Operador or: operador binário e retorna True se uma das declarações for verdadeira, caso contrário, retorna False.

>>> True or True
True
>>> True or False
True
>>> False or True
True
>>> False or False
False
>>> x = 2
>>> y = -2
>>> print(x > 0 or y < 0)
True
>>> print(x > 0 or y > 0)
True
>>> print(x < 0 or y < 0)
True
>>> print(x < 0 or y > 0)
False

Operador not: operador unário, que inverte o valor booleano do resulado, ou seja, retorna False se o resultado for verdadeiro, caro contrário, retorna True.

>>> not True
False
>>> not False
True
>>> x = 2
>>> y = -2
>>> print(not (x > 0 and y > 0))
True
>>> print(not (x > 0 or y > 0))
False

Expressões Lógicas

Os operadores lógicos podem ser combinados em expressões lógicas mais complexas. Quando uma expressão tiver mais de um operador lógico, avalia-se o operador not primeiro, seguido do operador and e, finalmente, o operador or. Podemos controlar a ordem com que as expressões são avaliadas com o uso de parênteses. Veja um exemplo:

Os operadores relacionais também podem ser utilizados em expressões com operadores lógicos. Nesses casos, os operadores relacionais são avaliados primeiramente. Exemplo:

>>> a = 7
>>> print(a > 5 or a < 0 and a != 7) 
True
>>> print((a > 5 or a < 0) and a != 7)
False

Atenção

Os seguintes valores são avaliados como False em Python:

constantes definidas como falsas: None e False
zero de qualquer tipo numérico: 0, 0.0
sequências vazias: "", [], {}

Qualquer outra coisa geralmente é avaliada como True. Por exemplo:

>>> print(0.0 or False)
False
>>> print("True" and True)
True
>>> print("" or False)
False

A última coisa a ser mencionada é que os operadores lógicos em Python estão em curto-circuito. É por isso que eles também são classificados como preguiçosos (lazy). Os operadores recebem essa classificação pois eventualmente somente alguns valores da expressão serão verificados para determinar o seu resultado final (True ou False).

Os operadores lógicos preguiçosos podem trazer um melhor desempenho computacional, uma vez que:

O operador lógico and necessita apenas que um dos valores da expressão seja falso para que ela seja considerada falsa;
O operador lógico or necessita apenas que um dos valores da expressão seja verdadeiro para que ela seja considerada verdadeira.

Exemplo:

>>> x = 3
>>> y = 0
>>> print(x / y)
ZeroDivisionError: division by zero
>>> print((y != 0) and (x / y)) # (1)
False
>>> print(teste)
NameError: name 'teste' is not defined
>>> print((x > y) or teste) # (2)
True

Como y != 0 é falso, a expressão (x / y) não é analisada/executada.
Como x > y é verdadeiro, a expressão teste (que tentaria acessar o valor da variável teste) não é executado.

Variáveis do tipo String

Variáveis do tipo string armazenam cadeias de caracteres como nomes e textos em geral. Uma cadeia de caracteres é uma sequência de símbolos como letras, números, sinais de pontuação, etc. Uma string python é zero ou mais caracteres escritos entre aspas simples (') ou aspas duplas ("). Não há diferença entre usar aspas simples ou duplas. No entanto, o mesmo tipo de aspas usado para iniciar uma string deve ser usado para finalizá-la.

Para padronizar, na disciplina iremos sempre usar aspas duplas (").

Por exemplo:

>>> S = "Olá, mundo!"
>>> print(S)
Olá, mundo!

Uma string tem um tamanho associado que pode ser obtido utilizando a função integrada len(). Esta função retorna o número de caracteres na string.

>>> S = "Olá, mundo!"
>>> len(S)
11
>>> len("UFES")
4
>>> len("")
0

Concatenação de Strings

Podemos juntar/concatenar strings usando o operador de concatenação + ou o operador de atribuição +=.

>>> S = "Olá" + "Mundo"
>>> print(S)
OláMundo
>>> nome = "Alan"
>>> sobrenome = "Turing"
>>> nomeCompleto = nome + sobrenome
>>> print(nomeCompleto)
AlanTuring
>>> nomeCompleto = nome + " " + sobrenome # Inclui um espaço entre o nome e o sobrenome
>>> print(nomeCompleto)
Alan Turing
>>> S = "Olá,"
>>> S += " Mundo!"
>>> print(S)
Olá, Mundo!

Quando precisamos replicar uma string \(n\) vezes, podemos usar o operador *.

>>> S = 'x' * 20
>>> print(S)
xxxxxxxxxxxxxxxxxxxx
>>> S = "abc" * 3
>>> print(S)
abcabcabc
>>> print("*" * 10)
**********

Métodos em Strings

As strings têm deversos métodos que executam operações com os dados da string. O principais e que serão bastante úteis na disciplina são:

split(): divide uma string em uma lista de substrings de acordo com um delimitador especificado. Veja mais detalhes e exemplos aqui

>>> nomeCompleto = "Alan Turing"
>>> nome, sobrenome = nomeCompleto.split()  # Equivalente à nomeCompleto.split(" ")
>>> print(nome)
Alan
>>> print(sobrenome)
Turing
>>> S = "Alan Turing;1912"
>>> nome, ano = S.split(";") #Agora o separador será o ';'
>>> print(nome)
Alan Turing
>>> print(ano)
1912

strip(): remove qualquer espaço em branco no início ou fim da string. Veja mais detalhes e exemplos aqui

>>> S = "     UFES   "
>>> print(S)
    UFES   
>>> print(S.strip())
UFES

lower() e upper(): converte todos os caracteres para minúsculo e maiúsculo, respectivamente:

>>> S = "Ufes"
>>> print(S.lower())
ufes
>>> print(S.upper())
UFES

Lembre-se que strings são imutáveis. Assim, ao aplicar um dos métodos anteriores retornará uma nova string modificada, mas a string original não será alterada. Por exemplo:

>>> S = "ufes"
>>> print(S.upper())
UFES
>>> print(S)
ufes
>>> S = S.upper() # Salvamos a modificação na mesma variável
>>> print(S)
UFES

Posteriormente, veremos outros métodos e mais detalhes de strings.

Conversão de tipo

O Python permite que determinados valores de um tipo sejam convertidos em outro tipo (cast). Para isso, temos algumas funções:

int(): converte o valor para o tipo int (número inteiro)
float(): converte o valor para o tipo float (número real)
str(): converte o valor para o tipo str (string)

A função int recebe qualquer valor e o converte em um número inteiro, se for possível, ou declara que há um erro:

>>> int("32")
32
>>> int(3.99999) # (1)
3
>>> int(-2.3)
-2
>>> int("Ufes")
ValueError: invalid literal for int() with base 10: 'Ufes'
>>> int("1.5")
ValueError: invalid literal for int() with base 10: '1.5'

A função int pode converter valores de ponto flutuante em números inteiros, mas não faz arredondamentos, ela apenas "corta" a parte da fração.

A função float converte números inteiros e string em números de ponto flutuante:

>>> float(32)
32.0
>>> float("3.1415")
3.1415

Finalmente, a função str converte o números em uma string:

>>> str(32)
'32'
>>> str(3.1415)
'3.1415'

Material complementar

Complemente sua leitura e seu conhecimento:

Forma compacta	Equivalente a
`x += y`	`x = x + y`
`x -= y`	`x = x - y`
`x *= y`	`x = x * y`
`x /= y`	`x = x / y`
`x %= y`	`x = x % y`
`x //= y`	`x = x // y`
`x **= y`	`x = x ** y`