<jupyter_start><jupyter_text>Variáveis---Na aula anterior, imprimimos textos com a função `print()` [[doc](https://docs.python.org/pt-br/3.8/library/functions.htmlprint)]. Para recapitular:<jupyter_code>print("Estamos na segunda aula!")<jupyter_output>Estamos na segunda aula!<jupyter_text>Mas e se a informação que queremos imprimir for muito extensa? Teremos de digitar tudo de novo sempre que quisermos imprimir?Nesses casos, usamos uma **variável**.Uma variável é **um nome que se refere a um valor** e fica temporariamente salvo na memória do computador. Sempre que chamarmos a variável, o valor será evocado.A atribuição é simples:```pythonvariavel = valor```Vamos pegar como exemplo o primeiro parágrafo de "Alice no País das Maravilhas":> Alice estava começando a ficar muito cansada de estar sentada ao lado de sua irmã e não ter nada para fazer: uma vez ou duas ela dava uma olhadinha no livro que a irmã lia, mas não havia figuras ou diálogos nele e "para que serve um livro", pensou Alice, "sem figuras nem diálogos?"<jupyter_code>alice = 'Alice estava começando a ficar muito cansada de estar sentada ao lado de sua irmã e não ter nada para fazer: uma vez ou duas ela dava uma olhadinha no livro que a irmã lia, mas não havia figuras ou diálogos nele e "para que serve um livro", pensou Alice, "sem figuras nem diálogos?"'<jupyter_output><empty_output><jupyter_text>Este texto imenso agora está salvo com o "apelido" de `alice`. Sempre que quisermos usar o texto podemos chamá-lo pela variável:<jupyter_code>print(alice)<jupyter_output>Alice estava começando a ficar muito cansada de estar sentada ao lado de sua irmã e não ter nada para fazer: uma vez ou duas ela dava uma olhadinha no livro que a irmã lia, mas não havia figuras ou diálogos nele e "para que serve um livro", pensou Alice, "sem figuras nem diálogos?"<jupyter_text>Quer dizer... *quase* sempre. A variável perde seu valor quando:1. o script é encerrado;2. o valor é alterado.Sim, eu posso mudar o valor de uma variável já existente. Basta atribuir novo valor:<jupyter_code>print("Valor anterior: ", alice)
alice = "Então ela pensava consigo mesma (tão bem quanto era possível naquele dia quente que a deixava sonolenta e estúpida) se o prazer de fazer um colar de margaridas era mais forte do que o esforço de ter de levantar e colher as margaridas, quando subitamente um Coelho Branco com olhos cor-de-rosa passou correndo perto dela."
print("Valor novo: ", alice)<jupyter_output>Valor anterior:  Alice estava começando a ficar muito cansada de estar sentada ao lado de sua irmã e não ter nada para fazer: uma vez ou duas ela dava uma olhadinha no livro que a irmã lia, mas não havia figuras ou diálogos nele e "para que serve um livro", pensou Alice, "sem figuras nem diálogos?"
Valor novo:  Então ela pensava consigo mesma (tão bem quanto era possível naquele dia quente que a deixava sonolenta e estúpida) se o prazer de fazer um colar de margaridas era mais forte do que o esforço de ter de levantar e colher as margaridas, quando subitamente um Coelho Branco com olhos cor-de-rosa passou correndo perto dela.<jupyter_text>Há algumas regras para criar variáveis:1. não pode começar com número ou símbolo, mas pode ter número e `underscore` (`_`) no meio ou no fim;2. não pode conter acentos ou pontos;3. maiúsculas e minúsculas são diferentes (a variável `nome` não é igual à variável `Nome`);4. não pode ser palavra-chave de Python: `and`, `as`, `assert`, `break`, `class`, `continue`, `def`, `del`, `elif`, `else`, `except`, `exec`, `finally`, `for`, `from`, `global`, `if`, `import`, `in`, `is`, `lambda`, `nonlocal`, `not`, `or`, `pass`, `raise`, `return`, `try`, `while`, `with`, `yield`, `True`, `False`, `None`.Agora vamos fazer um teste lógico:```pythonvariavel_1 = "Ana"variavel_2 = "Maria"variavel_1 = variavel_2print(variavel_1)```Qual será o resultado?  Tipos de dados---Nesta aula e na anterior, houve vezes em que usei valores com aspas, e outras vezes em que usei sem aspas. Exemplos:```pythonpi = 3.1416linguagem = "Python"```Isso porque os valores são de tipos diferentes: o primeiro pertence ao tipo numérico `float` (com decimal), enquanto o segundo pertence ao tipo não-numérico `string` (texto). Em Python, cada um tem suas particularidades. Nesta aula, vamos ver os tipos básicos e como trabalhar com eles: Numéricos- Integer (`int`)    - números inteiros    - não usa aspas- Float (`float`)    - números decimais; números com ponto flutuante; notação científica    - não usa aspas- Complex (`complex`)    - números complexos, com √-1 em parte da equação    - em Python, número imaginário representado pela letra `j`    - não usa aspas<jupyter_code>print(32)
print(type(32)) # a função type() mostra o tipo de dado
print(32.0)
print(type(32.0))
print(0.000000000000000000000000000001)
print(type(0.000000000000000000000000000001))
from cmath import sqrt  # veremos módulos nas próximas aulas
print(sqrt(-1))
print(type(sqrt(-1)))<jupyter_output>1j
<class 'complex'><jupyter_text>Não-numérico- String (`str`)    - texto; sequência de caracteres alfanuméricos; letra    - aparecem entre aspas duplas (`"`) ou simples (`'`)<jupyter_code>print("abcde")
print(type("abcde"))
print("a")
print(type("a"))
print(1234)
print(type(1234))

print('1234') # reparem que, ao usar aspas, converto int em str
print(type('1234'))<jupyter_output>1234
<class 'int'>
1234
<class 'str'><jupyter_text>Notem que, nas linhas acima, eu ora usei aspas duplas, ora usei aspas simples. Os dois tipos de aspas valem, mas cuidado:<jupyter_code>print("Estou usando 'aspas simples' dentro de aspas duplas")
print('Estou usando "aspas duplas" dentro de aspas simples')
print('O que acontece se, dentro de 'aspas simples', eu usar aspas simples?')
print("O mesmo acontece com "aspas duplas" dentro de aspas duplas?")<jupyter_output><empty_output><jupyter_text>Nos dois últimos exemplos, eu tive erro de sintaxe. Isso ocorre porque a máquina entende que os dados se encerram no fechamento de aspas e não sabe o que fazer com o restante da informação:- No primeiro exemplo, a máquina só computou `'O que acontece se, dentro de '`;- No segundo exemplo, a máquina computou `"O mesmo acontece com "`.Uma opção é usar `escape` (`\`) nas aspas internas. `Escape` funciona para eu avisar a máquina: "interprete de maneira literal, como aspas; não considere como fim de um texto".<jupyter_code>print('E agora? Consigo usar \'aspas simples\' dentro de aspas simples?')
print("E \"aspas duplas\" dentro de aspas duplas?")<jupyter_output>E "aspas duplas" dentro de aspas duplas?<jupyter_text>Lógico- Boolean (`bool`)    - comporta apenas dois valores: `True` (verdadeiro) e `False` (falso)    - nos "bastidores", funciona como número, sendo `0` para `False` e `1` para `True`    - assim como números, não usa aspas<jupyter_code>print(True)
print(type(True))
print(False)
print(type(False))
print(2 > 3)
print(2 < 3)<jupyter_output>True<jupyter_text>Operações aritméticasAgora que sabemos o que são **variáveis** e conhecemos os **tipos básicos**, podemos juntar as duas coisas para resolver **operações matemáticas**. Por exemplo, descobrir o salário mínimo por dia:<jupyter_code>sal_minimo = 1100
dias_uteis = 22
print(sal_minimo / dias_uteis)<jupyter_output>50.0<jupyter_text>Ou, como no exercício da aula anterior, calcular a área de um círculo de 12,7 metros de raio:<jupyter_code>raio = 12.7
pi = 3.14159
area = pi * (raio**2)
print(area)<jupyter_output>506.70705109999994<jupyter_text>No primeiro exemplo, eu dividi o salário mínimo (`sal_minimo`) pela quantidade de dias úteis (`dias_uteis`) em um mês. Para isso, usei o símbolo de divisão (`/`).No segundo exemplo, elevei o raio (`raio`) ao quadrado usando o símbolo de exponenciação (`**`) e, a ele, multipliquei o valor de pi (`pi`) com o símbolo de multiplicação (`*`).Os operadores são:- adição: `+`- subtração: `-`- multiplicação: `*`- divisão: `/`- exponenciação: `**`- parte inteira (descarta decimais): `//`- módulo (o resto de uma divisão): `%`Cabe ressaltar: a ordem de execução de operações segue a ordem convencional na matemática:1. exponenciação2. multiplicação e divisão3. soma e subtraçãoPodemos sobrescrever essa ordem usando parênteses.<jupyter_code>print(2 + 3 * 4) # multiplica 3 e 4, e depois adiciona 2
print((2 + 3) * 4) # soma 2 e 3, e depois multiplica por 4<jupyter_output>20
{'fraction_non_alphanumeric': 0.09903846153846153, 'fraction_numerical': 0.021634615384615384, 'mean_word_length': 5.313353566009105, 'pattern_counts': {'":': 1, '<': 43, '<?xml version=': 0, '>': 44, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 2, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '12', 'dir': 'jupyter-structured-clean-dedup', 'id': '383831', 'license': 'MIT', 'n_tokens_mistral': 3165, 'n_tokens_neox': 2963, 'n_words': 1116, 'path': '2021_idp_mba_pythonbasico/python_basico/02/02_notebook.ipynb', 'repo_name': 'rodolfo-viana/eventos', 'size': '8320'}