diff --git a/PY01.1-Operadores-e-Variaveis.ipynb b/PY01.1-Operadores-e-Variaveis.ipynb
new file mode 100644
index 0000000..4664a79
--- /dev/null
+++ b/PY01.1-Operadores-e-Variaveis.ipynb
@@ -0,0 +1 @@
+{"metadata":{"kernelspec":{"name":"python3","display_name":"Python 3 (ipykernel)","language":"python"},"language_info":{"name":"python","version":"3.7.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"vscode":{"interpreter":{"hash":"81d56cede9ef4caf6a61e146de670b37a2edead0ccb6294f4b93deebf2edb1a9"}}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Operadores e variáveis\n\nVamos começar a programar em Python escrevendo a parte de um programa que faz o cálculo dos pontos de um jogador em um jogo com temática espacial, com naves e robôs, estilo *\"shoot them up!\"*, daquele tipo que a gente atira em tudo que se mexer.\n\nDepois vamos aprender a usar variáveis para melhorar essses trechos do programa. Variáveis são uma forma de guardarmos informações na memória do computador para usarmos depois. \n\nAlém disso, elas também permitem que a gente use elas ao invés de usarmos números ou outros dados que um programa manipula, com a vantagem de que as variáveis podem mudar de valor (podem *variar*) e números e outros dados costumam ser fixos. \n\nPor exemplo, o valor do placar de um jogo não pode ser um valor fixo, porque o placar vai mudando de valor ao longo do jogo. Para isso precisamos usar uma variável ao invés de um valor para programar um placar.\n\nNos cálculos vamos usar as operações aritméticas básicas de adição `+`, subtração `-`, divisão `÷` e multiplicação `x`.","metadata":{}},{"cell_type":"markdown","source":"## Fazendo cálculos\n\nEm Python fazemos cálculos quase do mesmo modo como fazemos fora do computador, com papel e caneta.\n\nVeja no primeiro exemplo abaixo:\n\n> Para rodar o código Python abaixo (Windows ou Linux), clique na célula que contém o código e tecle Ctrl+Enter (no Mac, Cmd+Return). Faça isso com todos os exemplos de código que vierem. Assim você acompanha e experimenta a matéria ao mesmo tempo. ","metadata":{}},{"cell_type":"code","source":"2 * 10","metadata":{"trusted":true},"execution_count":3,"outputs":[{"execution_count":3,"output_type":"execute_result","data":{"text/plain":"20"},"metadata":{}}]},{"cell_type":"markdown","source":"Essa linha de código calculou o *produto* de `2` e `10`. É uma multiplicação. Só repare que a operação de multiplicação é representada por um *asterisco* e não pelo `xis`, ou o `.` que estamos acostumados a ver.","metadata":{}},{"cell_type":"markdown","source":"## Operadores aritméticos do Python\n\nOs operadores aritméticos do Python são:\n\n- `+` - soma (adição)\n- `-` - subtração \n- `/` - divisão (razão)\n- `*` - multiplicação (produto)","metadata":{}},{"cell_type":"markdown","source":"## Calculando os pontos de uma jogada\n\nVamos imaginar que você é um mago caçador de robôs feiticeiros espaciais. Para cada robô que você captura você acumula 0.05 pontos de experiência e 0.5 pontos de magia. ","metadata":{}},{"cell_type":"markdown","source":"\n\n\n\n\n\n\n\n","metadata":{}},{"cell_type":"markdown","source":"Agora imagine que em uma jogada você capturou 4 robôs feiticeiros ao mesmo tempo. Quantos pontos de experiência e de magia você ganhou?","metadata":{}},{"cell_type":"markdown","source":"\nVamos ver no próximo exemplo como calcular isso com o Python.\n\n> As linhas que começam por um `#` não são executadas pelo Python. Elas são usadas para acrescentar comentários ao código.","metadata":{}},{"cell_type":"code","source":"# Você capturou 4 robôs feiticeiros\n# e cada um deles vale 0.05 pontos de experiência\n# então\n\n4 * 0.05\n\n# Rode o código para ver quantos pontos \n# de experiência você ganhou na jogada","metadata":{"trusted":true},"execution_count":4,"outputs":[{"execution_count":4,"output_type":"execute_result","data":{"text/plain":"0.2"},"metadata":{}}]},{"cell_type":"markdown","source":"Então, você ganhou `0.2` pontos de experiência na jogada.\n\nPara calcular quantos pontos de magia você ganhou, multiplique o número de robôs que você capturou pelo número de pontos de magia que você ganha por cada um deles (que é `0.5`)\n\nNa célula abaixo, escreva a operação que faz esse cálculo.","metadata":{}},{"cell_type":"code","source":"4 * 0.5","metadata":{"trusted":true},"execution_count":5,"outputs":[{"execution_count":5,"output_type":"execute_result","data":{"text/plain":"2.0"},"metadata":{}}]},{"cell_type":"markdown","source":"O resultado deve ser `2.0` pontos de magia. Confere com a resposta da sua operação?","metadata":{}},{"cell_type":"markdown","source":"## Um cálculo mais interessante\n\nAgora vamos calcular os seus pontos de experiência de um modo mais interessante. \n\nDigamos que os pontos de experiência que você ganha dependem do seu nível de experiência e que quanto maior o seu nível mais pontos de experiência você ganha por cada robô feiticeiro capturado.\n\nPara cada nível de experiência atingido você ganhará 1 ponto de experiência de bônus além dos pontos normalmente ganhos por cada robô capturado.","metadata":{}},{"cell_type":"markdown","source":"\n\n\n\n\n\n\n\n\n\n","metadata":{}},{"cell_type":"markdown","source":"\nDigamos que seu nível de experiência é `20`. Então, se ao capturar 4 robôs você ganha `4 * 0.05` pontos de experiência, agora você vai ganhar esse valor e mais `4 * 20`, que são 20 pontos de experiência por cada robô capturado.\n\nO cálculo fica assim:","metadata":{}},{"cell_type":"code","source":"# Cálculo dos pontos de magia ganhos.\n# Você capturou 4 robôs feiticeiros\n# e cada um deles vale 0.5 pontos\n# de magia.\n\n4 * 0.5","metadata":{"trusted":true},"execution_count":6,"outputs":[{"execution_count":6,"output_type":"execute_result","data":{"text/plain":"2.0"},"metadata":{}}]},{"cell_type":"code","source":"# Cálculo do bônus por nível de experiência.\n# Supondo que seu nível atual é 20.\n# Então, são 20 pontos por cada robô capturado.\n\n4 * 20","metadata":{"trusted":true},"execution_count":7,"outputs":[{"execution_count":7,"output_type":"execute_result","data":{"text/plain":"80"},"metadata":{}}]},{"cell_type":"markdown","source":"Finalizando a conta, agora segundo essa nova forma de calcular os pontos, os seus pontos por ter capturado os 4 robôs nessa jogada serão:","metadata":{}},{"cell_type":"code","source":"0.2 + 2.0 + 80","metadata":{"trusted":true},"execution_count":8,"outputs":[{"execution_count":8,"output_type":"execute_result","data":{"text/plain":"82.2"},"metadata":{}}]},{"cell_type":"markdown","source":"\n\n\n\n","metadata":{}},{"cell_type":"markdown","source":"O valor da soma dos pontos normais (`0.2`) mais os pontos de magia (`2.0`) mais o bônus por experiência (`80`) é o valor de pontos ganhos na jogada, que é igual a `82.2`. ","metadata":{}},{"cell_type":"markdown","source":"## Sequência de execução das operações matemáticas\n\nAs operações matemáticas não são feitas todas ao mesmo tempo. Assim como nós, quando fazemos uma conta, o computador também vai fazendo uma conta de cada vez. A ordem que o computador decide seguir para ir fazendo as contas depende dos operadores aritméticos usados no cálculo. Isso é o que se chama de **precedência de operadores**.\n\nAlguns operadores têm precedência sobre outros. Isso quer dizer que as operações efetuadas por eles vão acontecer primeiro que as operações efetuadas por outros operadores.\n\nPor exemplo, vamos fazer a soma dos pontos toda de uma vez, só, em apenas uma linha de código.","metadata":{}},{"cell_type":"code","source":"# Nesta linha de código temos \n# os 3 cálculos de pontuação\n# que fizemos antes, além\n# da soma de cada um dos resultados\n# que é o que nos dá os pontos na jogada\n\n# Pontos normais por robô capturado: 4 * 0.05\n# + Pontos de magia: 4 * 0.5\n# + Pontos de bônus por experiência: 4 * 20\n\n4 * 0.05 + 4 * 0.5 + 4 * 20","metadata":{"trusted":true},"execution_count":9,"outputs":[{"execution_count":9,"output_type":"execute_result","data":{"text/plain":"82.2"},"metadata":{}}]},{"cell_type":"code","source":"# E poderia ser feito em 3 linhas diferentes?\n\n# usando uma variável auxiliar para fazer a operação\nprimeira_multiplicacao = 4 * 0.05\nsegunda_multiplicacao = 4 * 0.5\nterceira_multiplicacao = 4 * 20\n\nx + y + z\n","metadata":{"trusted":true},"execution_count":24,"outputs":[{"execution_count":24,"output_type":"execute_result","data":{"text/plain":"82.2"},"metadata":{}}]},{"cell_type":"markdown","source":"Tivemos o mesmo resultado porque as operações foram executadas na mesma ordem que nós usamos antes, apesar de estarem todas em uma mesma linha. \n\nIsso aconteceu por causa da precedência que a operação de multiplicação tem sobre a operação de adição. O que isso quer dizer é que as operações de multiplicação são feitas antes das operações de adição. \n\nVamos escrever novamente essa linha mas agora colocando entre parênteses as operações que são executadas primeiro. Assim vai ficar mais clara qual é a ordem de execução delas.","metadata":{}},{"cell_type":"code","source":"(4 * 0.05) + (4 * 0.5) + (4 * 20)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"As operações que estão entre parênteses são executadas primeiro. Elas são executadas da esquerda para a direita.\n\nDepois que cada operação de multiplicação é executada, o resultado de cada uma é colocado no lugar de cada operação. Isso acontece na memória do computador, mas se fossemos escrever em código, ficaria assim:\n","metadata":{}},{"cell_type":"code","source":"0.2 + 2.0 + 80","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Essas somas agora são executadas, uma por vez, da esquerda para a direita. O resultado é o mesmo de antes: `82.2`.","metadata":{}},{"cell_type":"markdown","source":"## Alterando a precedência das operações\n\nPodemos usar os parênteses para alterar a sequência que as operações são executadas pelo Python. \n\nPor exemplo:","metadata":{}},{"cell_type":"code","source":"4 * (0.05 + 4) * 0.5 + 4 * 20","metadata":{"trusted":true},"execution_count":27,"outputs":[{"execution_count":27,"output_type":"execute_result","data":{"text/plain":"88.1"},"metadata":{}}]},{"cell_type":"markdown","source":"Essa conta já não tem nada a ver com o cálculo do score do mago, mas vamos observar o resultado para aprender sobre precedência de operadores.\n\nO operador `+` não tem precedência sobre o `*`, mas como colocamos a operação de adição entre parênteses, ela foi executa primeiro mesmo assim. Só depois é que a multiplicação por `4` foi feita. Isso alterou o resultado para `88.1`, porque o cálculo que fizemos agora foi de fato diferente do anterior. \n\nNesse caso, o que dissemos foi:\n\n> \"some 0.05 com 4, depois multiplique o resultado por 4 e depois multiplique esse novo resultado por 0.5 e depois multiplique 4 por 20 e agora some esses dois resultados\".\n\n","metadata":{}},{"cell_type":"markdown","source":"A sequência é esta:","metadata":{}},{"cell_type":"code","source":"0.05+4","metadata":{"trusted":true},"execution_count":28,"outputs":[{"execution_count":28,"output_type":"execute_result","data":{"text/plain":"4.05"},"metadata":{}}]},{"cell_type":"code","source":"4.05 * 4","metadata":{"trusted":true},"execution_count":29,"outputs":[{"execution_count":29,"output_type":"execute_result","data":{"text/plain":"16.2"},"metadata":{}}]},{"cell_type":"code","source":"16.2 * 0.5","metadata":{"trusted":true},"execution_count":30,"outputs":[{"execution_count":30,"output_type":"execute_result","data":{"text/plain":"8.1"},"metadata":{}}]},{"cell_type":"code","source":"4 * 20","metadata":{"trusted":true},"execution_count":31,"outputs":[{"execution_count":31,"output_type":"execute_result","data":{"text/plain":"80"},"metadata":{}}]},{"cell_type":"code","source":"8.1 + 80","metadata":{"trusted":true},"execution_count":32,"outputs":[{"execution_count":32,"output_type":"execute_result","data":{"text/plain":"88.1"},"metadata":{}}]},{"cell_type":"markdown","source":"Também podemos *aninhar* parênteses. Aninhar significa colocar um parêntesis por fora de outro (ou por dentro, dependendo de como você vê). Quando aninhamos parênteses as operações que estão nos parênteses mais internos são executadas primeiro. Assim:","metadata":{}},{"cell_type":"code","source":"(4 * (0.05 + 4) * 0.5 + 4) * 20","metadata":{"trusted":true},"execution_count":33,"outputs":[{"execution_count":33,"output_type":"execute_result","data":{"text/plain":"242.0"},"metadata":{}}]},{"cell_type":"markdown","source":"Note no exemplo acima como a nova ordem de execução das operações alterou novamente o resultado final.","metadata":{}},{"cell_type":"markdown","source":"## Usando Variáveis\n\nVariáveis são uma forma de darmos nomes a valores que usamos em nossos programas para guardá-los e usá-los depois em nosso código.\n\nPara criar uma variável, escrevemos um nome para a variável e atribuímos um valor a ela usando o operador de atribuição do Python, que é o sinal `=`.","metadata":{}},{"cell_type":"code","source":"velocidade = 500","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"O código acima cria a variável chamada `velocidade` e atribui a ela o valor `500`.","metadata":{}},{"cell_type":"markdown","source":"### Variáveis no lugar de valores\n\nQuando temos uma variável podemos usar a variável em substituição ao valor que foi atribuído a ela. \n\nNo caso do cálculo da pontuação do mago em uma jogada, podemos escrever uma variável para cada um dos valores usados para calcular os pontos e, depois, reescrever a fórmula que calcula a pontuação usando apenas as variáveis no lugar dos valores.\n\nVamos ver como fazer isso criando uma variável de cada vez.","metadata":{}},{"cell_type":"markdown","source":" \n\n \nComeçamos pelo nível de experiência do jogador, pode ser guardado em uma variável.","metadata":{}},{"cell_type":"code","source":"experiencia = 20","metadata":{"trusted":true},"execution_count":6,"outputs":[]},{"cell_type":"markdown","source":"Lemos essas linhas de código assim:\n\n- experiencia é igual a 20\n\nou\n\n- experiencia contém 20\n\nou, ainda\n\n- experiencia é 20\n\n\nA forma de falar o que está escrito no código vai variar conforme a situação. Algumas vezes vai fazer mais sentido dizer *é igual a* e outras vai fazer mais sentido dizer *contém* ou *é*...\n\n> Note que o nome da variável que usamos para escrever o código do programa não precisa ser igual ao nome que vamos mostrar para quem for usá-lo. Neste caso a variável chama `experiencia` mas no placar estamos chamando de `xp`. Quando chegarmos na programação de interfaces gráficas vamos ver melhor como a apresentação dos dados é independente do modo como os dados são armazenados na memória do computador.","metadata":{}},{"cell_type":"markdown","source":"\n\n\n\n","metadata":{}},{"cell_type":"markdown","source":"Guardamos os pontos de experiência ganhos por capturar um robô e também os pontos de magia. Criamos uma variável para cada um.","metadata":{}},{"cell_type":"code","source":"pts_experiencia = 0.05\npts_magia = 0.6","metadata":{"trusted":true},"execution_count":4,"outputs":[]},{"cell_type":"markdown","source":"Precisamos guardar o número de robôs que capturamos na jogada. Esse valor não só faz parte do cálculo da pontuação como também é um dos que mais vai variar durante um jogo, porque a cada jogada o número de robôs capturados pode mudar. Ele pode ser 4, 2, zero, 1.000...\n\n\n\n\n\n\n\n\n","metadata":{}},{"cell_type":"code","source":"robos = 5","metadata":{"trusted":true},"execution_count":2,"outputs":[]},{"cell_type":"markdown","source":"Agora, podemos reescrever o cálculo dos pontos ganhos por capturar um robô usando as variáveis no lugar onde escreveríamos esses valores.","metadata":{}},{"cell_type":"code","source":"(robos * pts_experiencia) + (robos * pts_magia) + (robos * experiencia)","metadata":{"trusted":true},"execution_count":7,"outputs":[{"execution_count":7,"output_type":"execute_result","data":{"text/plain":"103.25"},"metadata":{}}]},{"cell_type":"markdown","source":"### Variáveis como rótulos\n\nNo exemplo anterior pudemos ver como a a fórmula que calcula a pontuação ficou mais clara quando escrevemos ela usando variáveis, já que agora não vemos apenas números na linha de código. \n\n> O nome de uma variável pode ser usado para explicar (se for bem escolido) o que é que a variável contém.\n\nÉ como se o nome da variável fosse um rótulo que colocamos em uma caixa onde guardamos coisas. A caixa seria um espaço na memória do computador e a variável seria um rótulo que colocamos nessa caixa. Depois de colocar esse rótulo, podemos usar o rótulo para nos referirmos tanto à caixa quando ao conteúdo da caixa. \n\nPor exemplo, imagine uma caixa com robôs. Na caixa colamos um rótulo onde está escrito `Robôs Capturados`.\n\n\n\n\n\n","metadata":{}},{"cell_type":"markdown","source":"Em Python, podemos usar uma `lista` para representar essa caixa. Mais adiante vamos ver como trabalhar com listas. Por enquanto, vamos escrever essa linha de código apenas para ilustrar o que está sendo explicado.\n\nExecute o código abaixo para acompanhar os próximos exemplos.","metadata":{}},{"cell_type":"code","source":"Robos_capturados = ['robô 1', 'robô 2', 'robô 3', 'robô 4']","metadata":{"trusted":true},"execution_count":13,"outputs":[]},{"cell_type":"markdown","source":"\nAgora, se alguém nos disser \"pegue os robôs capturados\", podemos entender isso de duas formas: \n\n1. pegar a caixa 'Robôs Capturados'\n1. pegar o conteúdo da caixa 'Robôs Capturados'\n\nSe pegamos a caixa, levamos junto seu conteúdo. Se pegamos só o conteúdo, ora, então pegamos o conteúdo. Em qualquer caso, acabamos sempre pegando o conteúdo da caixa que, nesse caso, é o valor da variável. O que acontece é que às vezes podemos também pegar a caixa junto e acabamos com duas coisas em mãos: os robôs (conteúdo) e a caixa (a variável).\n\nPor exemplo, execute os dois trechos de código abaixo e veja como o efeito é o mesmo.","metadata":{}},{"cell_type":"code","source":"# Assim estamos pegando \"só o conteúdo da caixa\"\n\n['robô 1', 'robô 2', 'robô 3', 'robô 4']","metadata":{"trusted":true},"execution_count":9,"outputs":[{"execution_count":9,"output_type":"execute_result","data":{"text/plain":"['robô 1', 'robô 2', 'robô 3', 'robô 4']"},"metadata":{}}]},{"cell_type":"code","source":"# Assim estamos pegando \"a caixa e seu conteúdo\"\n\nrobos_capturados","metadata":{"trusted":true},"execution_count":10,"outputs":[{"execution_count":10,"output_type":"execute_result","data":{"text/plain":"['robô 1', 'robô 2', 'robô 3', 'robô 4']"},"metadata":{}}]},{"cell_type":"code","source":"robos_capturados[1]","metadata":{"trusted":true},"execution_count":15,"outputs":[{"execution_count":15,"output_type":"execute_result","data":{"text/plain":"'robô 2'"},"metadata":{}}]},{"cell_type":"code","source":"robos_capturados","metadata":{"trusted":true},"execution_count":16,"outputs":[{"execution_count":16,"output_type":"execute_result","data":{"text/plain":"['robô 1', 'robô 2', 'robô 3', 'robô 4']"},"metadata":{}}]},{"cell_type":"code","source":"botos_capturados = ['robô 1', 'robô 2', 'robô 3', 'robô 4']","metadata":{"trusted":true},"execution_count":17,"outputs":[]},{"cell_type":"code","source":"botos_capturados","metadata":{"trusted":true},"execution_count":18,"outputs":[{"execution_count":18,"output_type":"execute_result","data":{"text/plain":"['robô 1', 'robô 2', 'robô 3', 'robô 4']"},"metadata":{}}]},{"cell_type":"code","source":"robos_capturados = ['robô 1', 'robô 2', 'robô 3', 'robô 4']\nrobos_capturados = ['robô 1', 'robô 2']\nprint(robos_capturados)","metadata":{"trusted":true},"execution_count":1,"outputs":[{"name":"stdout","text":"['robô 1', 'robô 2']\n","output_type":"stream"}]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"\nNo caso da linha de código que escrevemos antes, quando escrevemos o nome de uma variável estamos pegando a caixa e também seu conteúdo. Quando o Python está fazendo os cálculos, ele está usando o nome que demos à caixa (o nome da variável) para pegar o conteúdo que está na caixa (na memória do computador) e fazer o cálculo usando só o conteúdo (o valor da variável).\n\nPor isso também dizemos que uma variável *guarda* ou *armazena* um valor. Na verdade, é o computador que guarda o valor em sua memória, mas como através da variável podemos executar essa operação de armazenamento e recuperação de dados, fica prático para nós, que programamos, pensar na própria variável como meio e local de armazenamento de dados.\n","metadata":{}},{"cell_type":"markdown","source":"### Variáveis para acessar e modificar um valor na memória\n\nA segunda (e grande) vantagem é que também podemos usar o nome da variável para alterar o valor que está guardado na memória do computador. \n\nPor exemplo, se agora alterarmos o valor da variável `robos` para `2` (porque nessa jogada capturamos dois robôs e não 4 como da outra vez), então a mesma fórmula vai dar um resultado diferente.","metadata":{}},{"cell_type":"markdown","source":"\n\n\n\n","metadata":{}},{"cell_type":"code","source":"robos = 2\n(robos * pts_experiencia) + (robos * pts_magia) + (robos * experiencia)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Mudamos o valor da variável `robos` para `2` e agora o resultado é `41.1`.\n\nSe mudamos o valor de `robos` para `5`, qual o resultado? Experimente alterando o valor da variável `robos` na célula acima e executando novamente o código.","metadata":{}},{"cell_type":"markdown","source":"## Fluxo de execução de um programa\n\nNote que no último exemplo temos duas linhas de código. Elas são executadas em sequência, de cima para baixo.\n\nA ordem da execução de cada linha de código é muito importante. Como queremos calcular a pontuação usando a mesma fórmula mas com um número de robôs diferente, precisamos *primeiro* mudar o número de robôs para *depois* calcular a pontuação. Se não fizermos assim, o cálculo da pontuação vai ser feito com um número de robôs desatualizado e vai sair errado.\n\nO código de um programa é executado sempre de cima para baixo. Chama-se isso de `fluxo de execução`. Porém, às vezes, podem haver desvios do fluxo de execução. Isso acontece quando redirecionamos o fluxo de execução para outro código, que é uma outra parte do programa. \n\nOs desvios de execução podem acontecer basicamente em três casos:\n\n- quando uma função é executada\n- quando uma linha de código que contém uma sentença condicional é encontrada\n- quando o programa executa um loop \n\nVamos ver os três casos mais adiante.","metadata":{}},{"cell_type":"markdown","source":"## Usando uma função para mostrar o valor de uma variável\n\nVamos falar agora em *impressão*, mas não se trata de impressão em papel. É um pouco estranho na primeira vez que ouvimos isso, mas em programação chamamos a operação que exibe um texto ou números na tela de `imprimir`.\n\nTambém falamos `exibir` ou `mostrar`, que parecem fazer mais sentido para nós hoje, mas é que o termo `imprimir` vem de muito tempo atrás, quando a principal forma de os computadores exibirem os resultados das suas operações era através de impressoras que imprimiam eles em papel!\n\nEm Python, para *imprimir* o valor de uma variável, usamos uma função chamada `print()`. \n\n> Uma função é uma operação pré-programada: um trecho de código que podemos executar a qualquer momento.\n\nPor exemplo, imprimimos o valor da variável `experiencia` assim:","metadata":{}},{"cell_type":"code","source":"experiencia = 20\nprint(experiencia)\nexperiencia = 30\nprint(experiencia)","metadata":{"trusted":true},"execution_count":2,"outputs":[{"name":"stdout","text":"20\n30\n","output_type":"stream"}]},{"cell_type":"markdown","source":"A função `print()` escreve na tela o valor da variável.\n\n> Note que a variável é escrita entre os parênteses após o nome da função.","metadata":{}},{"cell_type":"markdown","source":"E se quiséssemos imprimir o resultado da pontuação? Uma forma de fazer isso é guardando esse resultado em uma variável para depois usar a função `print()` para imprimir o valor dessa variável.","metadata":{}},{"cell_type":"code","source":"robos = 2\nresultado = (robos * pts_experiencia) + (robos * pts_magia) + (robos * experiencia)\n\nprint(resultado)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"A função print também pode imprimir qualquer texto. Por exemplo, alguma mensagem que você queira exibir.","metadata":{}},{"cell_type":"code","source":"print('Você ganhou pontos!')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Podemos \"misturar\" nessa mensagem o valor da variável `resultado` e exibir uma mensagem com o número de pontos que o mago ganhou na jogada.\n\nPara isso, precisamos aprender a trabalhar com `Strings`, que são um tipo de dado diferente dos números com os quais trabalhamos até agora. Vamos ver isso a seguir.\n\nPor agora, execute a linha de código abaixo para ver como fica a mensagem completa.","metadata":{}},{"cell_type":"code","source":"print(f'Você ganhou {resultado} pontos!')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Juntando tudo para nosso primeiro programa!\n\nO código abaixo é o resultado de todas as linhas de código que precisamos para calcular o resultado de uma jogada. Esse é nosso primeiro programa!","metadata":{}},{"cell_type":"code","source":"experiencia = 20\npts_experiencia = 0.05\npts_magia = 0.5\n\n\nrobos = int(input('Oh, honorável Mago! Quantos robôs capturaste? '))\n\nresultado = (robos * pts_experiencia) + (robos * pts_magia) + (robos * experiencia)\n\nprint(f'Você ganhou {resultado} pontos!')\n ","metadata":{"trusted":true},"execution_count":2,"outputs":[{"output_type":"stream","name":"stdin","text":"Oh, honorável Mago! Quantos robôs capturaste? 4\n"},{"name":"stdout","text":"Você ganhou 82.2 pontos!\n","output_type":"stream"}]},{"cell_type":"markdown","source":"Esse código pode ser salvo em um arquivo e executado em seu computador. Para isso você vai precisar de um editor de texto como o `Bloco de Notas` do Windows ou o `Notepad++` ou qualquer outro editor que trabalhe com \"texto simples\". \n\n\nUm arquivo de texto simples costuma ter a extensão .TXT e é diferente de um arquivo de texto como um .DOCX do Word ou um PDF. Qualquer programa de computador é escrito e salvo em um arquivo de texto simples. Esse é um texto sem formatações especiais (como fontes, cores, imagens, etc...) e contém apenas caracteres. Caracteres são qualquer símbolo que você pode digitar no teclado, inclusive números e outros caracteres especiais, como `$`, `*`, `@`, `%`, etc...\n\nSupondo que você esteja usando o Windows, abra o `Bloco de Notas` e copie o código da célula acima em um novo arquivo e salve ele como 'pontos_na_jogada.py'. Depois, abra o terminal do Windows, vá para o diretório onde você salvou o arquivo e execute ele com Python com a seguinte linha de comando:\n\n\n\npython pontos_na_jogada.py\n\n
\n\n---","metadata":{}},{"cell_type":"markdown","source":"\n\n\n\n\n\n","metadata":{}},{"cell_type":"code","source":"experiencia = 20\npts_experiencia = 0.05\npts_magia = 0.5\n\ncontinuar = 's'\n\nwhile continuar == 's':\n robos = int(input('Oh, honorável Mago! Quantos robôs capturaste? '))\n\n resultado = (robos * pts_experiencia) + (robos * pts_magia) + (robos * experiencia)\n\n print(f'Você ganhou {resultado} pontos!')\n continuar = input('Continuar (s/n)?' )\n\nprint('Fim do programa')","metadata":{"trusted":true},"execution_count":2,"outputs":[{"output_type":"stream","name":"stdin","text":"Oh, honorável Mago! Quantos robôs capturaste? 5\n"},{"name":"stdout","text":"Você ganhou 102.75 pontos!\n","output_type":"stream"},{"output_type":"stream","name":"stdin","text":"Continuar (s/n)? s\nOh, honorável Mago! Quantos robôs capturaste? 2\n"},{"name":"stdout","text":"Você ganhou 41.1 pontos!\n","output_type":"stream"},{"output_type":"stream","name":"stdin","text":"Continuar (s/n)? n\n"},{"name":"stdout","text":"Fim do programa\n","output_type":"stream"}]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}
\ No newline at end of file