Aula 0 - Introdução ao Python.ipynb

{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[]},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"markdown","source":["---\n","---\n","# UNIVERSIDADE FEDERAL FLUMINENSE\n","---\n","---\n","## TEP00118 - PESQUISA OPERACIONAL II\n","## Prof.: Diogo Ferreira de Lima Silva\n","---\n","### Monitor: Rodrigo Celso de Lima Porto\n","### Matrícula: 319042042\n","---"],"metadata":{"id":"bIPFQNROQ_iA"}},{"cell_type":"markdown","source":["---\n","---\n","# INTRODUÇÃO AO PYTHON\n","---\n","---\n","\n","<p align=justify>\n","&emsp; A linguagem Python foi criada por Guido van Hossum, em 1989, quando estava tendo problemas ao implementar um programa em linguagem C em um de seus expedientes na CWI (<a href='https://www.cwi.nl/'>Centrum Voor Wiskunde en Informatica</a>). Uma das principais desvantagens dessa linguagem, segundo ele, era que os programas escritos em C eram extremamente grandes, difíceis de compreender e ás vezes apenas os programadores mais experientes conseguiam entender a funcionalidade de certos códigos.\n","<br>\n","&emsp; O principal intuito ao criar o Python era o de criar uma linguagem que tivesse comandos legíveis e de simples compreensão. O seu nome é uma homenagem do criador ao programa de televisão <i>Monty Python's Flying Circus</i>, também conhecido simplesmente por <i><b>Monty Python</b></i>, que passava na BBC na década de 1970. E como <i>python</i> é o nome em inglês para a cobra píton, o logo do Python acabou se tornando duas cobras entrelaçadas: uma azul e uma amarela.\n","<br>\n","&emsp; Dentre as suas principais características, é possível citar:\n","\n","<ul align=justify>\n","<li><b>Linguagem de propósito geral</b>: Python não é focada em um propósito exclusivo, sendo possível aplicá-la em várias áreas da computação, como Ciência de Dados, Big Data, Internet das Coisas, Desenvolvimento Web, <i>Machine Learning</i>, Inteligência Artificial etc.</li>\n","<li><b>Simples e intuitiva</b>: Comparado com as outras linguagens, como Scala, Java ou C++, a sua curva de aprendizado é baixa devido á sua sintaxe simples que permite escrever programas totalmente funcionais em poucas linhas de código.</li>\n","<li><b>Multiplataforma</b>: Por ser tratar de uma linguagem interpretada, os programas escritos em Python rodam em várias plataformas, seja ela Windows, Linux, Mac etc, tornando os programas altamente versáteis e facilmente exportáveis.</li>\n","<li><b><i>Batteries includded</i></b>: Sabe aqueles brinquedos eletrônicos que você ganha de Natal, mas que não vem com as baterias incluídas? É o que acontece com algumas linguagens de programação, cujas funcionalidades não foram totalmente incluídas em seus módulos, sendo necessários instalá-los posteriormente, o que não é o caso do Python, que já vem com todo o necessário, sendo necessário instalar mais módulos nos casos em que queremos ir além das funcionalidades essenciais.</li>\n","<li><b><i>Open Source</i></b>: É uma linguagem de código aberto, totalmente livre, sendo possível até fazer alterações e redistribuições.</li>\n","<li><b>Organizada</b>: Por ela obrigar o programador a realizar as devidas identações em certas estruturas no código, o Python permite que os códigos sejam organizados e padronizados.</li>\n","<li><b>Linguagem orientada a objetos</b>: Tudo dentro do Python é um objeto, isto é, possui atributos, estados e métodos (ou comportamentos, dependendo da literatura), até mesmo a mais simples variável é um objeto no Python. E nesta aula, vamos ver alguns métodos que podem ser acessado para certos tipos de variáveis. Para se aprofundar na teoria de POO (Programação Orientada a Objetos), recomendo <a href='https://www.youtube.com/playlist?list=PL6qsRzBhn4BlSiDHoGWLj6Op4Ika8zjIC'>esta <i>playlist</i></a> do canal <a href='https://www.youtube.com/@CursoemVideo'>Curso em Vídeo</a>, para os interessados.</li>\n","<li><b>Considerável acervo de bibliotecas</b>: Inúmeras bibliotecas dos mais variados propósitos já foram escritos em Python; para criação de aplicativo de celular, aplicativos web, para criação de jogos, para criação de AIs, para criação de sistemas de RPA etc. Porém, neste curso de PO2, o ensino será focado na aplicação das seguintes bibliotecas:\n","<ul>\n","<li><a href='https://pyomo.readthedocs.io/en/stable/'>Pyomo</a>: para modelagem de problemas de programação de otimização.</li>\n","<li><a href='https://networkx.org/documentation/stable/reference/index.html'>NetworkX</a>: para resolução de problemas utilizando grafos.</li>\n","<li><a href='https://docs.sympy.org/latest/index.html'>SymPy</a>: para resolução de problemas utilizando computação simbólica; esta última só será vista na segunda parte da disciplina, na aula sobre Programação Não Linear</li>\n","</ul></li>\n","</ul>\n","\n","&emsp; Só a título de curiosidade, a programação Python possui sua própria filosofia, <b>O Zen do Python</b>, criado por Tim Peters, um famoso programador desta linguagem. O Zen do Python se encontra embutida na própria linguagem e consiste num conjunto de 19 aforismos que visam guiar a forma como os códigos devam ser escritos, visando a sua simplicidade e inteligibilidade.\n","\n","<h2><i>O Zen do Python</i></h2>\n","<ol align=justify>\n","<li>Bonito é melhor que feio</li>\n","<li>Explícito é melhor que implícito</li>\n","<li>Simples é melhor que complexo</li>\n","<li>Complexo é melhor que complicado</li>\n","<li>Linear é melhor que aninhado</li>\n","<li>Esparso é melhor que denso</li>\n","<li>Legibilidade conta</li>\n","<li>Casos especiais não são especiais o bastante para quebrar as regras</li>\n","<li>Ainda que a praticidade vença a pureza</li>\n","<li>Erros nunca devem passar silenciosamente</li>\n","<li>A menos que sejam explicitamente silenciados</li>\n","<li>Diante da ambiguidade, recuse a tentação de adivinhar</li>\n","<li>Deveria haver um — e preferencialmente apenas um — modo óbvio para fazer algo</li>\n","<li>Embora esse modo possa não ser óbvio a princípio (a menos que você seja holandês)</li>\n","<li>\"Agora\" é melhor que \"nunca\"</li>\n","<li>Embora \"nunca\" frequentemente seja melhor que \"já\"</li>\n","<li>Se a implementação é difícil de explicar, é uma má idéia</li>\n","<li>Se a implementação é fácil de explicar, pode ser uma boa ideia</li>\n","<li><i>Namespaces</i> são uma ideia estupenda - vamos fazer mais desses!</li>\n","</ol>\n","\n","&emsp; Para acessar ao Zen do Python, basta executar a seguinte linha de código:\n","</p>"],"metadata":{"id":"Tqj6L8qzAbvt"}},{"cell_type":"code","source":["import this"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"KpJ6KwGUJBcu","executionInfo":{"status":"ok","timestamp":1671499637145,"user_tz":180,"elapsed":21,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"d9facce0-c24e-4eaf-9b76-b6491f01a1bc"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["The Zen of Python, by Tim Peters\n","\n","Beautiful is better than ugly.\n","Explicit is better than implicit.\n","Simple is better than complex.\n","Complex is better than complicated.\n","Flat is better than nested.\n","Sparse is better than dense.\n","Readability counts.\n","Special cases aren't special enough to break the rules.\n","Although practicality beats purity.\n","Errors should never pass silently.\n","Unless explicitly silenced.\n","In the face of ambiguity, refuse the temptation to guess.\n","There should be one-- and preferably only one --obvious way to do it.\n","Although that way may not be obvious at first unless you're Dutch.\n","Now is better than never.\n","Although never is often better than *right* now.\n","If the implementation is hard to explain, it's a bad idea.\n","If the implementation is easy to explain, it may be a good idea.\n","Namespaces are one honking great idea -- let's do more of those!\n"]}]},{"cell_type":"markdown","source":["---\n","---\n","# OLÁ, MUNDO!\n","---\n","---\n","\n","<p align=justify>\n","&emsp; Respeitando a tradição, nada melhor do que começar a aprender a programar em Python do que ensinando a como usar a função embutida <code><font colo='#DCDCAA'>print</font>()</code> para escrever \"Olá, mundo!\".\n","</p>"],"metadata":{"id":"wstlmA0f-HGm"}},{"cell_type":"code","source":["print('Olá, mundo!')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"6QsohUDI_Am2","executionInfo":{"status":"ok","timestamp":1671748681523,"user_tz":180,"elapsed":10,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"097ece37-491b-4f29-8873-ee37aa0dbe47"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Olá, mundo!\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; O texto impresso pela função <code><font color='#DCDCAA'>print</font>()</code> é o que é chamado em algumas linguagens de programação de <i>string</i>, (\"cadeia\", em inglês), pois se trata de uma cadeia de caracteres. E uma dica que recomendo na hora de construir <i>strings</i> no Python é de sempre usar <code><font color='#CE9178'>'aspas simples'</font></code> ao invés de <code><font color='#CE9178'>\"aspas duplas\"</font></code>, para o caso de ser necessário usar aspas dentro de alguma <i>string</i>.\n","</p>"],"metadata":{"id":"tdPh3AJpAEZL"}},{"cell_type":"code","source":["print('Carl Sagan disse: \"O primeiro pecado da humanidade foi a fé, a primeira virtude foi a dúvida\"')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"1HcQ1GJ7CfHu","executionInfo":{"status":"ok","timestamp":1671750587125,"user_tz":180,"elapsed":9,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"8f66cd93-c393-4308-f31c-2bc3bd246171"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Carl Sagan disse: \"O primeira pecado da humanidade foi a fé, a primeira virtude foi a dúvida\"\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Algo que não seria possível fazer como nesta linha:\n","</p>"],"metadata":{"id":"a8qRHxjKEJiv"}},{"cell_type":"code","source":["print(\"Carl Sagan disse: \"O primeiro pecado da humanidade foi a fé, a primeira virtude foi a dúvida\")"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":130},"id":"zunx1zOCEWOz","executionInfo":{"status":"error","timestamp":1671750663205,"user_tz":180,"elapsed":12,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"626f84be-ff43-472a-f9ed-4fc6efe40094"},"execution_count":null,"outputs":[{"output_type":"error","ename":"SyntaxError","evalue":"ignored","traceback":["\u001b[0;36m  File \u001b[0;32m\"<ipython-input-9-9846061e9715>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    print(\"Carl Sagan disse: \"O primeiro pecado da humanidade foi a fé, a primeira virtude foi a dúvida\")\u001b[0m\n\u001b[0m                              ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Na verdade, é possível sim... se fosse utilizado o caracter de escape <code><font color='#CE9178'>\"\\\"</font></code>, pois ao usá-lo, ele faz com que o caracter logo depois dele não seja entendido como texto, mas sim como um comando a ser executado dentro da <i>string</i>.\n","<br>\n","&emsp; Os principais caracteres de escape disponíveis no Python são:\n","\n","<ul align=justify>\n","<li><code><font color='#CE9178'>\\n</font></code> (<i>line feed</i>) Cria uma nova linha.</li>\n","<li><code><font color='#CE9178'>\\t</font></code> (<i>tab</i>) Tabulação horizontal. Move o cursor para a próxima parada de tabulação.</li>\n","<li><code><font color='#CE9178'>\\r</font></code> (<i>carriage return</i>) Move o cursor para o início da linha atual, sem avançar para a próxima linha.</li>\n","<li><code><font color='#CE9178'>\\b</font></code> (<i>backspace</i>) Retrocede o cursor um caractere.</li>\n","<li><code><font color='#CE9178'>\\\\</font></code> (<i>backslash</i>) Imprime o símbolo de barra invertida dentro da <i>string</i>.</li>\n","<li><code><font color='#CE9178'>\\\"</font></code> Imprime o caractere de aspas duplas.</li>\n","<li><code><font color='#CE9178'>\\'</font></code> Imprime o caractere de aspas simples.</li>\n","</ul>\n","</p>"],"metadata":{"id":"tnESfL4CEsN5"}},{"cell_type":"code","source":["print(\"Carl Sagan disse:\\n\\t\\\"O primeiro pecado da humanidade foi a fé,\\n\\ta primeira virtude foi a dúvida\\\"\")"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"BBPIe4G2JTgR","executionInfo":{"status":"ok","timestamp":1671751543887,"user_tz":180,"elapsed":269,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"881a47b1-4436-4c02-9a98-a7983655f165"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Carl Sagan disse:\n","\t\"O primeiro pecado da humanidade foi a fé,\n","\ta primeira virtude foi a dúvida\"\n"]}]},{"cell_type":"markdown","source":["---\n","---\n","# VARIÁVEIS E ESTRUTURAS DE DADOS\n","---\n","---\n","\n","<p align=justify>\n","&emsp; Uma variável, no contexto da programação, é um espaço que você reserva na memória temporária de sua máquina para poder guardar algum dado. Nada mais, nada menos do que isso. É como uma caixa ou uma gaveta na qual se armazena um tipo de informação de cada vez, e quando um novo dado é inserido dentro desta caixa, o dado anterior é substituído pela nova informação.\n","<br>\n","&emsp; Em algumas linguagens, como C++, Java, JavaScript etc., o programador é obrigado a definir o tipo da variável antes de usá-la, e uma vez definido o seu tipo, esta variável não poderá armazenar dados de mais nenhum outro tipo. Por exemplo, se eu defini no meu código que a variável <code>nome</code> é do tipo <code><font color='#4EC9B0'>str</font></code>, ela passará a armazenar apenas dados do tipo <i>string</i> e nada mais. Se eu tentar armazenar, por exemplo, <code><font color='#B2CBA5'>2.7182818</font></code> nela, o compilador ou interpretador exibirá um erro ao programador por estar tentando atribuir um dado com o tipo não correpondente ao tipo aceitado pela variável. Para estes tipos de linguagens, dizemos que elas são de <b>tipagem estática</b>.\n","<br>\n","&emsp; Diferentemente desses tipos de linguagem, a declaração de variáveis no Python é do tipo <b>tipagem dinâmica</b>, o que significa que o tipo da variável é automaticamente definido pelo tipo de dado que ele armazena, não necessitando definir o seu tipo no momento da sua criação. E o fato de não ser necessário definir o seu tipo nos permite atribuir dados de tipos diferentes ao longo da execução de um código.\n","</p>"],"metadata":{"id":"CARXSpWEH2EA"}},{"cell_type":"code","execution_count":null,"metadata":{"id":"28inrQvHAWn1","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1671755906803,"user_tz":180,"elapsed":230,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"6dc17a7f-b33e-4498-cb25-74be78c923f1"},"outputs":[{"output_type":"stream","name":"stdout","text":["<class 'int'>\n","<class 'str'>\n","<class 'float'>\n","<class 'complex'>\n","<class 'bool'>\n"]}],"source":["x = 10          # Atribuindo o número 10 à variável x\n","print(type(x))  # Imprime o tipo da variável x\n","\n","x = 'meu texto' # x agora recebe uma string. O valor 10 armazenado anteriormente é apagado.\n","print(type(x))\n","\n","x = 3.141592653 # x agora recebe um número de ponto flutuante\n","print(type(x))\n","\n","x = 4 + 3j      # x recebe um número imaginário\n","print(type(x))\n","\n","x = True       # x recebe um valor lógico\n","print(type(x))"]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Como demonstrado, a variável <code>x</code> recebeu 4 tipos de variáveis diferentes sem o interpretador exibir mensagem de erro, por justamente o Python não obrigar o programador a definir seu tipo.\n","<br>\n","&emsp; O símbolo do jogo da velha <code><font color='#6AA94F'>#</font></code> permite escrever <b>comentários</b> no código. Tudo que vem depois do <code><font color='#6AA94F'>#</font></code> é ignorado pelo interpretador e não será executado. Caso se deseje realizar comentários com mais de uma linha, ao invés de inserir um <code><font color='#6AA94F'>#</font></code> no início de cada linha do texto a ser comentado, basta escrever o texto entre <code><font color='#CE9178'>'''três aspas simples'''</font></code> ou entre <code><font color='#CE9178'>\"\"\"três aspas duplas\"\"\"</font></code>.\n","<br>\n","&emsp; Uma confusão que é bem frequente quando se trata de variáveis é o fato do símbolo de igualdade <code>=</code> ser utilizado para inserir valores dentro das variáveis. Vale esclarecer que, na esmagadora maioria das linguagens de programação, o caracter <code>=</code> não quer dizer igualdade, pois ela na verdade representa uma operação de <b>atribuição</b>. Portando, <code>x = <font color='#B2CBA5'>10</font></code> não significa <i>\"x é igual a 10\"</i>, mas sim <i>\"x <b>recebe</b> 10\"</i>.\n","<br>\n","&emsp; Para verificar se x é igual a 10, deve-se usar <code>==</code>, pois é esse o operador de igualdade no Python: o sinal de igualdade duplicado.\n","</p>"],"metadata":{"id":"eDb9yshRRp8k"}},{"cell_type":"code","source":["x = 20         # x recebe 20\n","print(x == 10) # o valor armazenado em x é igual a 10?"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"MLXaMTcMRpGk","executionInfo":{"status":"ok","timestamp":1671755181027,"user_tz":180,"elapsed":223,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"4432d4ec-8a5c-473e-9e12-730080e0518a"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["False\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Uma outra coisa que vale mencionar sobre declaração de variáveis são as suas regras de nomeação, pois as variáveis não podem ser declaradas com qualquer nome, sendo necessário estar ciente que:\n","\n","<ul align=justify>\n","<li>O nome de uma variável só pode começar com uma letra ou pelo símbolo de de sublinhado <code>_</code></li>\n","<li>O nome de uma variável não pode começar por um número</li>\n","<li>O nome de uma variável só pode conter símbolos alfa-númericos (a-z, A-z e 0-9) e o <code>_</code> (não vale letras acentuadas)</li>\n","<li>Python é <i>case sensitive</i>, portanto maiúsculas e minúsculas diferem</li>\n","</ul>\n","</p>"],"metadata":{"id":"Taw_R7TdVV4z"}},{"cell_type":"code","source":["num = 4\n","Num = 5\n","nUm = num + Num\n","print('num:', num)\n","print('Num:', Num)\n","print('nUm:', nUm)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Iq2wJUVnVVND","executionInfo":{"status":"ok","timestamp":1671798556036,"user_tz":180,"elapsed":12,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"ab837ee2-788d-4535-87b4-765163ad4070"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["num: 4\n","Num: 5\n","nUm: 9\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Também é possível realizar atribuições múltiplas, em que $n$ valores são atribuídos à variáveis em uma única linha de código.\n","</p>"],"metadata":{"id":"UrUE4vvXE1vY"}},{"cell_type":"code","source":["nome, idade, altura, genero, casado = 'João', 11, 1.51, 'M', False\n","print('Nome:', nome)\n","print('Idade:', idade)\n","print('Altura', altura, 'm')\n","print('Gênero:', genero)\n","print('Casado:', casado)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"1F75cyDdFijA","executionInfo":{"status":"ok","timestamp":1671800870497,"user_tz":180,"elapsed":5,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"de756dc6-12e0-4ef4-f4a2-a489ad515b23"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Nome: João\n","Idade: 11\n","Altura 1.51 m\n","Gênero: M\n","Casado: False\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Ao invés de passar várias <i>strings</i> para a função <code><font color='#DCDCAA'>print</font>()</code>, é possível concatenar várias <i>strings</i> em uma única <i>string</i> utilizando o sinal de <code>+</code>.\n","&emsp; Caso se esteja querendo concatenar uma <i>string</i> com um dado que não seja <i>string</i>, é necessário antes convertê-lo para <code><font color='#4EC9B0'>str</font></code> usando a função <code><font color='#4EC9B0'>str</font>()</code>.\n","</p>"],"metadata":{"id":"wUNEahQKfwdu"}},{"cell_type":"code","source":["nome, idade, altura, genero, casado = 'João', 11, 1.51, 'M', False\n","print('Nome: ' + nome)\n","print('Idade: ' + str(idade))\n","print('Altura: ' + str(altura) + ' m')\n","print('Gênero: ' + genero)\n","print('Casado: ' + str(casado))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"mJOzX9Z4gcli","executionInfo":{"status":"ok","timestamp":1671807828361,"user_tz":180,"elapsed":297,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"36cb7fe9-3460-4267-e7c3-57a53b8aeec0"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Nome: João\n","Idade: 11\n","Altura: 1.51 m\n","Gênero: M\n","Casado: False\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Dentre os principais tipos de variáveis e estruturas de dados que existem no Python, tem-se:\n","\n","<ul align=justify>\n","<li><code><font color='#4EC9B0'>str</font></code> (<i>String</i>) Cadeias de caracteres ou textos, já anteriormente apresentadas.</li>\n","<li><code><font color='#4EC9B0'>int</font></code> (<i>Integer</i>) Números inteiros. A base padrão é a decimal, mas é possível usar outras bases como binária (iniciada com <code><font color='#B2CBA5'>0b</font></code>), octal (iniciada com <code><font color='#B2CBA5'>0o</font></code>) ou hexadecimal (iniciada com <code><font color='#B2CBA5'>0x</font></code>).</li>\n","<li><code><font color='#4EC9B0'>float</font></code> (<i>floating-point value</i>) Números de ponto flutuante, isto é, números com casas decimais. A precisão máxima aceita pelo Python é <code>1e-14</code>, isto é, 14 casas decimais.</li>\n","<li><code><font color='#4EC9B0'>complex</font></code> (<i>Complex</i>) Número complexo, ou imaginário, cuja parte imaginpario é representado pela letra <code><font color='#B2CBA5'>j</font></code> no Python.</li>\n","<li><code><font color='#4EC9B0'>bool</font></code> (<i>Boolean</i>) Valor lógico, que pode ser <code><font color='#569CD6'>True</font></code> ou <code><font color='#569CD6'>False</font></code>. Possuem esse nome em homenagem ao matemático <a href='https://pt.wikipedia.org/wiki/George_Boole'>George Boole</a>.</li>\n","<li><code><font color='#4EC9B0'>tuple</font></code> (<i>Tuple</i>) Tupla de valores, um estrutura de dados compreendido por <code>()</code>, cujos valores são <b>ordenados</b>, <b>imutáveis</b>, <b>permitem duplicatas</b> e <b>indexados a partir do 0</b>.</li>\n","<li><code><font color='#4EC9B0'>list</font></code> (<i>List</i>) Lista de valores, uma estrutura de dados compreendido por <code>[]</code>, cujos valores são <b>ordenados</b>, <b>mutáveis</b>, <b>permitem duplicatas</b> e <b>indexados a partir do 0</b>.</li>\n","<li><code><font color='#4EC9B0'>set</font></code> (<i>Set</i>) Conjunto de valores, uma estrutura de dados compreendido por <code>{}</code>, cujos valores são <b>não ordenados</b>, <b>imutáveis</b>, <b>não permitem duplicatas</b> e <b>não são indexados</b>.</li>\n","<li><code><font color='#4EC9B0'>dict</font></code> (<i>Dictionary</i>) Dicionário de valores, uma estrutura de dados compreendido por <code>{}</code>, cujos valores são <b>não ordenados</b>, <b>mutáveis</b>, <b>não permitem duplicatas</b> e <b>são indexados por valores chaves</b>.</li>\n","</ul>\n","</p>"],"metadata":{"id":"15Xzw0OacVIs"}},{"cell_type":"markdown","source":["---\n","## *Strings*\n","---\n","\n","<p align=justify>\n","&emsp; Como apresentado anteriormente, <i>strings</i> são como são chamados os dados de caracteres em Python, por justamente representarem cadeias de caracteres.\n","<br>\n","&emsp; Lembra-se que praticamente tudo no Python é um objeto? Pois cada coisinha possuía atributos, estados e métodos? Esse é justamente o caso dos tipos de dados no Python. Uma vez que o interpretador reconhecer que um dado é de um determinado tipo, ele constrói uma instância do objeto daquele tipo, atribuindo-lhe todos os atributos e métodos pertinentes ao seu tipo.\n","<br>\n","&emsp; As principais funções embutidas e métodos aplicados para os dados do tipo <code><font color='#4EC9B0'>str</font></code> são:\n","\n","<ul>\n","<li><code><font color='#DCDCAA'>len</font>()</code> (<i>Length</i>) Função que retorna o comprimento da <i>string</i>, isto é, a quantidade de caracteres que o compõe.</li>\n","<li><code>.<font color='#DCDCAA'>upper</font>()</code> (<i>Uppercase</i>) Método que retorna o a <i>string</i> com todas as letras em maiúscula.</li>\n","<li><code>.<font color='#DCDCAA'>lower</font>()</code> (<i>Lowercase</i>) Método que retorna o a <i>string</i> com todas as letras em minúscula.</li>\n","<li><code>.<font color='#DCDCAA'>strip</font>()</code> Método que divide uma <i>string</i> em duas ou mais <i>strings</i> a partir de uma <i>string</i> separadora passada como parâmetro para o método.</li>\n","<li><code>.<font color='#DCDCAA'>replace</font>()</code> Método que remove os espaços vazios que estejam no início ou no fim de uma <i>string</i>.</li>\n","<li><code>.<font color='#DCDCAA'>format</font>()</code> Método que insere dados formatados para dentro de uma <i>string</i> por meio de caracteres de escape <code>{}</code>.</li>\n","</ul>\n","\n","&emsp; Vamos ver a utilização de cada uma delas.\n","</p>"],"metadata":{"id":"5QyugOfHlqFt"}},{"cell_type":"code","source":["print(len('Anticonstitucionalissimamente'))\n","print(len('Pneulmoultramicroscopicossilicovulcanoconiótico'))\n","print(len('homo hominis lupus')) # Espaços vazios também contam"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"p11rB45NcsOA","executionInfo":{"status":"ok","timestamp":1671803251096,"user_tz":180,"elapsed":222,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"6daf42b6-53a0-44e2-c68d-0bd43ab7eaee"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["29\n","47\n","18\n"]}]},{"cell_type":"code","source":["print('carpe diem'.upper())\n","print('MEMENTO MORI'.lower())"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Lz-AJmxGPT3B","executionInfo":{"status":"ok","timestamp":1671803336804,"user_tz":180,"elapsed":238,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"116b6d90-404c-4a51-a660-4192acc9ec8b"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["CARPE DIEM\n","memento mori\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Neste momento já é possível perceber a principal diferença prática entre uma <b>função</b> e um <b>método</b>. Uma função não precisa de um objeto para ser acessada, bastando chamá-la no código quando quiser, já um método necessita de um objeto para chamá-la, já que um método representa um comportamento ou uma ação a ser aplicada sobre o objeto.\n","<br>\n","&emsp; Por isso que <code><font color='#DCDCAA'>len</font>()</code> pôde ser chamada sem necessitar de um objeto antes dela para contabiliar o número de caracteres de um <i>string</i>, pois <code><font color='#DCDCAA'>len</font>()</code> não é um método nativo do objeto, mas sim uma função já existente na linguagem Python. Além disso, veremos mais adiante que <code><font color='#DCDCAA'>len</font>()</code> pode ser utilizada para outros tipos de dados, não só para <i>strings</i>.\n","<br>\n","&emsp; Já os métodos <code>.<font color='#DCDCAA'>upper</font>()</code> e <code>.<font color='#DCDCAA'>lower</font>()</code>, por existirem apenas dentro do objeto <code><font color='#4EC9B0'>str</font></code>, somente podem ser acessados por meio deles. Na maioria das linguagens, o operador de acesso aos atributos e métodos de um objeto é o ponto final <code>.</code>, como foi visto no bloco anterior.\n","<br>\n","&emsp;Vale ressaltar que só é possível acessar esses dois métodos das <i>strings</i> <code><font color='#CE9178'>'carpe diem'</font></code> e <code><font color='#CE9178'>'MEMENTO MORI'</font></code> pois o Pyhton considera todo tipo de dado como um objeto. Outras linguagens não fazem isso. Se fosse o caso do Python não considerá-los como sendo objetos, ou haveria funções nativas que já permitissem converter minúsculas em maiúsculas e vice-versa, ou teríamos que nós mesmos definir essas funções. Mais para frente, vamos ver como definir nossas próprias funções.\n","<br>\n","&emsp; Dando seguimento aos exemplos...\n","</p>"],"metadata":{"id":"48B2tbLWPwMY"}},{"cell_type":"code","source":["email = 'nome.sobrenomne@email.com'\n","usuario, servidor = email.split('@') # Atribuição múltipla\n","\n","\"\"\"\n","O método .split() separa o email em duas strings a partir do símbolo de @\n","e vai armazenar o usuario e o servidor em duas variáveis diferentes.\n","\"\"\"\n","\n","print(usuario)\n","print(servidor)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"ifgJ0wKzTPoo","executionInfo":{"status":"ok","timestamp":1671804395820,"user_tz":180,"elapsed":236,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"c857f5bd-7762-45f7-e2ef-4b7670b774ec"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["nome.sobrenomne\n","email.com\n"]}]},{"cell_type":"code","source":["print('hunter'.replace('t', 'g'))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"KZ03x9S9U3p1","executionInfo":{"status":"ok","timestamp":1671804785896,"user_tz":180,"elapsed":209,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"8a4bb452-d0fe-4021-f3fd-7a8f4871e91b"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["hunger\n"]}]},{"cell_type":"code","source":["pi = 3.1415926525897\n","raio = 2000\n","area = pi * raio ** 2\n","\n","print('A área de um círculo de raio {} m é de {} m²'.format(raio, area))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"dqmuSO_mVKnQ","executionInfo":{"status":"ok","timestamp":1671806871323,"user_tz":180,"elapsed":302,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"b2c60340-e692-46e1-9716-27894dcc0fe2"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["A área de um círculo de raio 2000 m é de 12566370.6103588 m²\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; O método <code>.<font color='#DCDCAA'>format</font>()</code>, como o próprio nome sugere, formata uma <i>string</i> inserindo os valores passados como parâmetros para dentro de espaços reservados (<i>placeholders</i>) representados por <code>{}</code> dentro da <i>string</i>.\n","<br>\n","&emsp; Nesses <code>{}</code>, é possível explicitar a formatação dos valores por meio de uma <b>sintaxe de formatação</b>, que podem ser:\n","\n","<ul align=justify>\n","<li><code>:></code> O valor será alinhado à direita (dentro do espaço disponibilizado). Por padrão, os valores serão alinhados à direita.</li>\n","<li><code>:<</code> O valor será alinhado à esquerda (dentro do espaço disponibilizado).</li>\n","<li><code>:^</code> O valor será centralizado (dentro do espaço disponibilizado).</li>\n","<li><code>: </code> Reserva um espaço para o sinal algébrico. Caso seja um número negativo, exibirá um <code>-</code>; do contrário, exibirá um espaço vazio.</li>\n","<li><code>:+</code> Reserva um espaço para o sinal algébrico. Caso seja um número negativo, exibirá um <code>-</code>; se for positivo, exibirá o sinal de <code>+</code>; se for nulo, exibirá um espaço vazio.</li>\n","<li><code>:.</code> Utiliza o ponto final como separador de milhar.</li>\n","<li><code>:,</code> Utiliza a vírgula como separador de milhar.</li>\n","<li><code>:_</code> Utiliza o sublinhado como separador de milhar.</li>\n","<li><code>:'número'</code> O número informado representa a quantidade de espaços reservados para o valor. Por exemplo, <code>{:9}</code> significa que o valor terá 9 espaços reservados para ocupar. Caso a quantidade de caracteres do valor seja menor que o espaço reservado, os espaços não ocupados ficarão vazias.</li>\n","<li><code>:.'número'</code> O número informado após o ponto representa a quantidade de casas decimais. Por exemplo, <code>{:.2}</code> significa que o valor terá dois número após o ponto decimal.</li>\n","<li><code>:g</code> Formato genérico.</li>\n","<li><code>:G</code> Formato genérico (Utiliza um <code>E</code> maiúsculo em notações científicas).</li>\n","<li><code>:f</code> Representa o valor como sendo um ponto flutuante.</li>\n","<li><code>:F</code> Representa o valor como sendo um ponto flutuante, em letras maiúsculas (isto é, <code>inf</code> e <code>nan</code> passam a ser <code>INF</code> e <code>NAN</code>).</li>\n","<li><code>:e</code> Formato científico com um <code>e</code> minúsculo.</li>\n","<li><code>:E</code> Formato científico com um <code>E</code> maiúsculo.</li>\n","<li><code>:c</code> Converte o valor ao correspondente caracter Unicode.</li>\n","<li><code>:b</code> Formato binário.</li>\n","<li><code>:o</code> Formato octal.</li>\n","<li><code>:x</code> Formato hexadecimal</li>\n","<li><code>:X</code> Formato hexadecimal, em letras maiúsculas.</li>\n","<li><code>:n</code> Formato de número.</li>\n","<li><code>:%</code> Formato percentual.</li>\n","</ul>\n","\n","&emsp; Também é possível combinar as sintaxes para obter uma formatação mais customizada. Por exemplo, podemos escrever <code>{:,.2f}</code> para que os números tenham a vírgula como separador de milhar, 2 casas decimais após o ponto e sejam representadas como números flutuantes.\n","</p>"],"metadata":{"id":"N9XRcYuBXCs8"}},{"cell_type":"code","source":["pi = 3.1415926525897\n","raio = 2000\n","area = pi * raio ** 2\n","\n","print('A área de um círculo de raio {:,.2f} m é de {:,.2f} m²'.format(raio, area))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"cOyGI-3uWiNd","executionInfo":{"status":"ok","timestamp":1671806979937,"user_tz":180,"elapsed":217,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"e7c912cb-866f-447f-a535-f0e6be66cbcd"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["A área de um círculo de raio 2,000.00 m é de 12,566,370.61 m²\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","\n","1.   Item de lista\n","2.   Item de lista\n","\n","\n","&emsp; Uma melhor forma de formatar <i>strings</i> no Python é colocando um <code><font color='#569CD6'>f</font></code> no início da <i>string</i> para informar ao Python que se trata de um texto formatável. Tais <i>strings</i> são conhecidas por <i>f-strings</i> entre os programadores.\n","</p>"],"metadata":{"id":"4tWS6F4KeVzv"}},{"cell_type":"code","source":["pi = 3.1415926525897\n","raio = 2000\n","area = pi * raio ** 2\n","\n","print(f'A área de um círculo de raio {raio:,.2f} m é de {area:,.2f} m²')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"NR-xBrVee3mG","executionInfo":{"status":"ok","timestamp":1671807405661,"user_tz":180,"elapsed":237,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"d45ba21d-ef99-4e4e-cc8d-22ed1085d430"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["A área de um círculo de raio 2,000.00 m é de 12,566,370.61 m²\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; É possível também acessar cada um dos caracteres de uma <i>string</i> informando o seu índice entre <code>[]</code>, sabendo que o primeiro caracter de uma <i>string</i> possui índice 0 e os índices informados sempre devem ser do tipo  <code><font color='#4EC9B0'>int</font></code>.\n","</p>"],"metadata":{"id":"_ELiPWMT5WIA"}},{"cell_type":"code","source":["nome = 'Jerônimo'\n","\n","print(f'1ª letra: {nome[0]}')\n","print(f'2ª letra: {nome[1]}')\n","print(f'3ª letra: {nome[2]}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"7zY7VHme5ve2","executionInfo":{"status":"ok","timestamp":1671815889035,"user_tz":180,"elapsed":204,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"8b6182f9-78a1-466a-e2bc-70c14a47b45f"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["1ª letra: J\n","2ª letra: e\n","3ª letra: r\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; É possível utilizar índices negativos. Nestes caso, o índice <code><font color='#B2CBA5'>-1</font></code> representa o último caracter da <i>string</i>, <code><font color='#B2CBA5'>-2</font></code> o penúltimo, <code><font color='#B2CBA5'>-3</font></code> o antepenúltimo, e assim em diante.\n","</p>"],"metadata":{"id":"d3fYaOK_81Jo"}},{"cell_type":"code","source":["forma = 'Hexágono'\n","\n","print(f'Última letra: {forma[-1]}')\n","print(f'Penúltima letra: {forma[-2]}')\n","print(f'Antepenúltima letra: {forma[-3]}')\n","print(f'Anteantepenúltima letra: {forma[-4]}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"ibz23Gsj9a24","executionInfo":{"status":"ok","timestamp":1671815470213,"user_tz":180,"elapsed":219,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"e0fa7465-adc6-4334-992a-7fac47d44f8c"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Última letra: o\n","Penúltima letra: n\n","Antepenúltima letra: o\n","Anteantepenúltima letra: g\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Também é possível fatiar uma <i>string</i> em <i>strings</i> menores usando <code>[<font color='#B2CBA5'>início</font>:]</code>, <code>[:<font color='#B2CBA5'>fim + 1</font>]</code>, ou <code>[<font color='#B2CBA5'>início</font>:<font color='#B2CBA5'>fim + 1</font>]</code>, ou ainda <code>[<font color='#B2CBA5'>início</font>:<font color='#B2CBA5'>fim + 1</font>:<font color='#B2CBA5'>passo</font>]</code>.\n","</p>"],"metadata":{"id":"PPTY3aic6lcg"}},{"cell_type":"code","source":["palavra = 'paralelepípedo'\n","\n","print(palavra[:7])     # 7 primeiras letras.\n","print(palavra[2:9])    # String entre os caracteres de índices 2 e 8.\n","print(palavra[4:9])    # As últimas letras começando do caracter de índice 4.\n","print(palavra[::2])    # pega as letras de índice par\n","print(palavra[1::2])   # pega as letras de índice ímpar\n","print(palavra[2:10:3]) # pega as letras, começando do índice 2 até 9, indo de 3 em 3."],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"-XSDKS2_7qzo","executionInfo":{"status":"ok","timestamp":1697560708856,"user_tz":180,"elapsed":11,"user":{"displayName":"Rodrigo Porto","userId":"09314262811226536393"}},"outputId":"59a45566-6f8f-4436-c57e-5a5d4e0032c0"},"execution_count":1,"outputs":[{"output_type":"stream","name":"stdout","text":["paralel\n","ralelep\n","lelep\n","prllppd\n","aaeeíeo\n","rep\n"]}]},{"cell_type":"markdown","source":["---\n","## *Ints* e *floats*\n","---\n","\n","<p align=justify>\n","&emsp; São assim como são conhecidos os inteiros e os números fracionários (ou de ponto flutuante) no Python.\n","<br>\n","&emsp; Dentre as principais operações e funções matemáticas que podemos executar com esses tipos de dado no Python podemos citar:\n","\n","<ul align=justify>\n","<li>As operações aritméticas básicas: soma <code>+</code>, subtração <code>-</code>, multiplicação <code>*</code> e divisão <code>/</code>.</li>\n","<li>A divisão inteira, isto é, o quociente inteiro da divisão, desconsiderando o resto, feito utilizando duas barras <code>//</code> (aplicável apenas para dados do tipo <code><font color='#4EC9B0'>int</font></code>).</li>\n","<li>O resto da divisão inteira, usando como operador o sinal de porcentagem <code>%</code> (aplicável apenas para dados do tipo <code><font color='#4EC9B0'>int</font></code>).</li>\n","<li>A grande maioria das linguagens de programação usam o <code>^</code> para realizar a potenciação, mas o Python tinha que ser o diferentão e usar o asterisco duplicado <code>**</code> para realizar essa operação.</li>\n","<li>A função nativa de soma <code><font color='#DCDCAA'>sum</font>()</code>, que usaremos bastante quando mexermos com Pyomo.</li>\n","<li>A função nativa <code><font color='#DCDCAA'>abs</font>()</code>, que retorna o valor absoluto de um valor, isto é, o seu módulo, desconsiderando o seu sinal algébrico.</li>\n","<li>Funções nativas <code><font color='#DCDCAA'>min</font>()</code> e <code><font color='#DCDCAA'>max</font>()</code> para obter os valores mínimos e máximos de uma coleção de dados.</li>\n","<li>Algumas funções matemáticas como as trigonométricas <code>sin()</code>, <code>cos()</code> e <code>tan()</code>, o logaritmo <code>log()</code>, a exponenciação <code>exp()</code>, raiz quadrada <code>sqrt()</code> etc. só podem ser realizadas importando bibliotecas próprias para isso. A biblioteca mais utilizada para realizar essas operações é o <code>math</code>.</li>\n","<li>Funções estatísticas, como média <code>mean()</code>, desvio padrão <code>stdev()</code> ou <code>sd()</code>, mediana <code>median()</code>, moda <code>mode()</code> etc. podem ser usadas importando bibliotecas como <code>statistics</code>, <code>scypy</code> e <code>pandas</code>.</li>\n","</ul>\n","\n","&emsp; Vale sempre lembrar que o Python respeita as regras de precedência para calcular as expressões matemáticas, sempre da esquerda para direita, das mais internas para as mais externas.\n","\n","<ol align=justify>\n","<li>As expressões que se encontram entre parênteses;</li>\n","<li>As funções matemáticas;</li>\n","<li>Potenciações e radiciações;</li>\n","<li>Multiplicações e divisões;</li>\n","<li>Somas e subtrações.</li>\n","</ol>\n","</p>"],"metadata":{"id":"THRIn2DxfZ6f"}},{"cell_type":"code","source":["x, y = 345, -5\n","\n","soma    = x + y\n","subt    = x - y\n","mult    = x * y\n","div     = x / y\n","div_int = x // y\n","resto   = x % y\n","pot     = x ** y\n","mod_x   = abs(x)\n","mod_y   = abs(y)\n","\n","print(f'Soma: {soma:18.2f}')\n","print(f'Subtração: {subt:13.2f}')\n","print(f'Multiplicação: {mult:10.2f}')\n","print(f'Divisão: {div:14.2f}')\n","print(f'Divisão inteira: {div_int:6.2f}')\n","print(f'Resto: {resto:15.2f}')\n","print(f'Potenciação: {pot:9.2f}')\n","print(f'Módulo de x: {mod_x:11.2f}')\n","print(f'Módulo de y: {mod_y:9.2f}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"kBIUPq61vTAY","executionInfo":{"status":"ok","timestamp":1671900949137,"user_tz":180,"elapsed":245,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"814ac099-7311-4963-ba4b-f30bfe98385c"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Soma:             340.00\n","Subtração:        350.00\n","Multiplicação:   -1725.00\n","Divisão:         -69.00\n","Divisão inteira: -69.00\n","Resto:            0.00\n","Potenciação:      0.00\n","Módulo de x:      345.00\n","Módulo de y:      5.00\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Vamos importar a biblioteca <code>math</code> para usar as funções matemáticas.\n","</p>"],"metadata":{"id":"KtMnfuwFzjQB"}},{"cell_type":"code","source":["import math\n","\n","seno = math.sin(x)\n","cosseno = math.cos(x)\n","tangente = math.tan(x)\n","logaritmo = math.log(x)\n","exponencial = math.exp(x)\n","raiz_quadrada = math.sqrt(x)\n","\n","print(f'sen(x) = {seno:+1.2f}')\n","print(f'cos(x) = {cosseno: 1.2f}')\n","print(f'tan(x) = {tangente: 1.2f}')\n","print(f'log(x) = {logaritmo: 1.2f}')\n","print(f'exp(x) = {exponencial: 1,.2f}')\n","print(f'sqrt(x) = {raiz_quadrada: .2f}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"7r-DBMBz1l65","executionInfo":{"status":"ok","timestamp":1671900952158,"user_tz":180,"elapsed":297,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"83b19979-7cb3-4970-98b3-1456431047d2"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["sen(x) = -0.54\n","cos(x) =  0.84\n","tan(x) = -0.65\n","log(x) =  5.84\n","exp(x) =  678,572,502,005,717,114,936,084,201,252,923,068,757,816,206,693,592,959,739,978,656,180,233,096,564,187,865,891,727,183,527,130,380,662,882,630,766,402,796,917,605,194,684,903,182,578,622,484,447,232.00\n","sqrt(x) =  18.57\n"]}]},{"cell_type":"markdown","source":["<p aling=justify>\n","&emsp; Existem basicamente 4 formas de importar bibliotecas no Python:\n","\n","<ul align=justify>\n","<li>\n","Usando <code><font color='#C586C0'>import</font> nome_biblioteca</code>, em que são importadas todas as funções da biblioteca para dentro do programa, o que pode acabar deixando o seu código um pouco lento, além de deixá-lo também muito verboso, já que toda vez que for utilizar uma função da biblioteca importada, será necessário escrever o nome completo da biblioteca antes da função para acessá-lo, ficando <code>nome_biblioteca.funcao()</code>.\n","</li>\n","\n","<li>\n","Usando <code><font color='#C586C0'>import</font> nome_biblioteca <font color='#C586C0'>as</font> bib</code>, em que é definido um apelido depois do <code><font color='#C586C0'>as</font></code> para encurtar o nome da biblioteca e deixar o código mais limpo, necessitando escrever apenas <code>bib.funcao()</code> para usar uma função. Essa é a mais forma mais recomendada de importar quando usar mais de uma biblioteca.\n","</li>\n","\n","<li>\n","Usando <code><font color='#C586C0'>from</font> nome_biblioteca <font color='#C586C0'>import</font> *</code>, desta forma todas as funções da biblioteca são importadas e não se faz necessário chamar o nome da biblioteca para usar as suas funções. Porém essa é a forma menos recomendada, pois além de deixar o código lento pode ocorrer conflitos com funções de outras bibliotecas que tenham o mesmo nome da função importada. Por exemplo, as bibliotecas <code>math</code>, <code>numpy</code> e <code>sympy</code> possuem as funções trigonométricas <code>sin()</code>, <code>cos()</code> e <code>tan()</code> e caso duas dessas bibliotecas tenham sido importadas dessa forma e seja chamada algumas dessas funções no código, o Python exibirá um erro uma vez que não saberá qual função de qual biblioteca usar, já que possuem o mesmo nome.\n","</li>\n","\n","<li>\n","Usando <code><font color='#C586C0'>from</font> nome_biblioteca <font color='#C586C0'>import</font> funcao1(), funcao2, ..., funcaoN()</code>, em que ao invés de importar todas as funções da biblioteca, o programador importa apenas as funções necessárias para a execução do código, além de não precisar chamar o nome da biblioteca para usar a função importada. Esta última forma é a mais recomendada de importar quando for usar apenas uma biblioteca.\n","</li>\n","</ul>\n","</p>"],"metadata":{"id":"Pdw5dY0X_pvR"}},{"cell_type":"markdown","source":["---\n","## *Booleans* ou valores lógicos\n","---\n","\n","<p align=justify>\n","&emsp; <i>Booleans</i> são variáveis que aceitam dois valores lógicos, <code><font color='#569CD6'>True</font></code> e <code><font color='#569CD6'>False</font></code>, que podem ser resultado de operadores de comparação, como maior que <code>></code>, menor que <code><</code>, maior ou igual <code>>=</code>, menor ou igual <code><=</code>, igual <code>==</code> ou diferente <code>!=</code>.\n","<br>\n","&emsp; E quando se trata de valores lógicos, é importante estar ciente de como funciona os <b>operadores lógicos</b>, que no Python só existem três:\n","\n","<ul>\n","<li><code><font color='#82C6FF'>and</font></code> Retorna <code><font color='#569CD6'>True</font></code> apenas se ambas expresões lógicas forem <code><font color='#569CD6'>True.</font></code></li>\n","<li><code><font color='#82C6FF'>or</font></code> Retorna <code><font color='#569CD6'>True</font></code> se pelo menos uma expressão lógica for <code><font color='#569CD6'>True</font></code>.</li>\n","<li><code><font color='#82C6FF'>not</font></code> Inverte o valor lógico da <i>boolean expression</i>. Retorna <code><font color='#569CD6'>True</font></code> se o resultado for <code><font color='#569CD6'>False</font></code> e vice-versa.</li>\n","</ul>\n","</p>"],"metadata":{"id":"SiAO_r5o414X"}},{"cell_type":"code","source":["x, y = 100, 50\n","\n","print(f'x > 10? {x > 10}')\n","print(f'y = 50? {y == 50}')\n","print(f'x > 90 e x < 120? {x > 90 and x < 120}')\n","print(f'y < 40 e y > 30? {y < 40 and y > 30}')\n","print(f'x = 100 ou y = 25? {x == 100 or y == 25}')\n","print(f'x < 75 ou y <> 50? {x < 75 or y != 50}')\n","print(f'não x = 80? {not x == 80}')\n","print(f'não x > 90 ou y < 60? {not x > 90 or y < 60}')\n","print(f'não (x > 90 ou y < 60)? {not (x > 90 or y < 60)}')\n","\n","# A última expressão deixa evidente que usar parêntesis faz diferença."],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"S1FZOxHJsxrJ","executionInfo":{"status":"ok","timestamp":1671845413586,"user_tz":180,"elapsed":6,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"c6d09deb-407f-4207-98ca-4b98e751c4dc"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["x > 10? True\n","y = 50? True\n","x > 90 e x < 120? True\n","y < 40 e y > 30? False\n","x = 100 ou y = 25? True\n","x < 75 ou y <> 50? False\n","não x = 80? True\n","não x > 90 ou y < 60? True\n","não (x > 90 ou y < 60)? False\n"]}]},{"cell_type":"markdown","source":["---\n","## Tuplas\n","---\n","\n","<p align=justify>\n","&emsp; Tuplas são uma coleção de dados que não podem ser modificadas uma vez que foram definidas. Por isso é a estrutura mais leve e simples do Python.<br>\n","&emsp; Elas são criadas quando os dados são englobados entre <code>()</code> ou quando estamos atribuindo mais de um valor para uma única variável (neste último caso, falamos que estamos <b>empacotando</b> os dados).\n","</p>"],"metadata":{"id":"Fu90DqsxxsOq"}},{"cell_type":"code","source":["pares = (2, 4, 6, 8, 10)\n","impares = 1, 3, 5, 7, 9\n","\n","print(f'Pares entre 1 e 10: {pares}')\n","print(f'Ímpares entre 1 e 10: {impares}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"odiHWHU1VN9b","executionInfo":{"status":"ok","timestamp":1671888836058,"user_tz":180,"elapsed":251,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"252fe0b0-042a-4b8d-a56b-8d9fef5e926a"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Pares entre 1 e 10: (2, 4, 6, 8)\n","Ímpares entre 1 e 10: (1, 3, 5, 7, 9)\n"]}]},{"cell_type":"code","source":["pares = (2, 4, 6, 8, 10)\n","pares[0] = 22 # Esta linha gerará um erro de atribuição"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":183},"id":"7uBUgz4k6cfy","executionInfo":{"status":"error","timestamp":1671898515079,"user_tz":180,"elapsed":367,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"b754d29e-4bff-423e-ba7b-0001908b043b"},"execution_count":null,"outputs":[{"output_type":"error","ename":"TypeError","evalue":"ignored","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)","\u001b[0;32m<ipython-input-44-685b8f0ae85a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mpares\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mpares\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m22\u001b[0m \u001b[0;31m# Esta linha gerará um erro de atribuição\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Podemos também pegar uma tupla e atribuir os seus valores para duas variáveis ou mais. Quando fazemos isso, dizemos que estamos <b>desempacotando</b> os dados da tupla para cada uma das variáveis.\n","<br>\n","&emsp; Quando estamos atribuindo uma tupla de $n$ elementos para $n$ variáveis, cada uma das variáveis vão receber os respectivos elementos da tupla na ordem em que estão.\n","<br>\n","&emsp; Porém, nos casos em queremos atribuir $n$ elementos de uma tupla para $m$ variáveis, onde $m < n$, devemos colocar um asterisco <code>*</code> imediatamente à esquerda do nome da variável para informar que a variável sinalizada receberá o restante dos elementos que não foram atribuídos às outras variáveis. Vale informar que nestes casos, apenas uma das variáveis deve ser sinalizada com o <code>*</code>. Não pode haver duas ou mais variáveis com o <code>*</code> para desempacotar uma tupla.\n","<br>\n","\n","</p>"],"metadata":{"id":"unahZS1nV5PK"}},{"cell_type":"code","source":["x, y, z = (12, 34, 65) # Desempacotando a tupla\n","\n","print(f'x = {x}')\n","print(f'y = {y}')\n","print(f'z = {z}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"ebJ6bp98WRHx","executionInfo":{"status":"ok","timestamp":1671889330036,"user_tz":180,"elapsed":216,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"81374b90-1a7c-4d8b-d6a1-1049a4ffa9b5"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["x = 12\n","y = 34\n","z = 65\n"]}]},{"cell_type":"code","source":["*x, y, z = (12, 34, 65, 9, 13, 57)\n","\n","print(f'x = {x}')\n","print(f'y = {y}')\n","print(f'z = {z}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"LYCev6P7XsBj","executionInfo":{"status":"ok","timestamp":1671889409825,"user_tz":180,"elapsed":331,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"92e58dfe-59e6-47dd-f2a8-cae607abc158"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["x = [12, 34, 65, 9]\n","y = 13\n","z = 57\n"]}]},{"cell_type":"code","source":["x, *y, z = (12, 34, 65, 9, 13, 57)\n","\n","print(f'x = {x}')\n","print(f'y = {y}')\n","print(f'z = {z}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"8vXgIM6tYAVi","executionInfo":{"status":"ok","timestamp":1671889430065,"user_tz":180,"elapsed":233,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"f4b5a4a0-5bf9-4c4b-9f0d-32703b46baf4"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["x = 12\n","y = [34, 65, 9, 13]\n","z = 57\n"]}]},{"cell_type":"code","source":["x, y, *z = (12, 34, 65, 9, 13, 57)\n","\n","print(f'x = {x}')\n","print(f'y = {y}')\n","print(f'z = {z}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"7VPF_FK9YDLK","executionInfo":{"status":"ok","timestamp":1671889439254,"user_tz":180,"elapsed":247,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"c77746fe-dbab-4c4d-9da1-e6a0ed3929e5"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["x = 12\n","y = 34\n","z = [65, 9, 13, 57]\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Também é possível atribuir uma tupla vazia em uma variável. Para isso, basta atribuir a função <code><font color='#4EC9B0'>tuple</font>()</code>, que além de converter uma coleção de dados para uma tupla, também serve para criar uma tupla vazia.\n","</p>"],"metadata":{"id":"fcXSV790m5Ro"}},{"cell_type":"code","source":["minha_tupla = tuple()\n","\n","print(f'Tupla vazia: {minha_tupla}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"lke83rvKnHJf","executionInfo":{"status":"ok","timestamp":1671893725865,"user_tz":180,"elapsed":233,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"2d36ab3b-d18a-4941-d7fa-3d0c552a4040"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Tupla vazia: ()\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Assim como as <i>strings</i>, é possível acessar os elementos de uma tupla informando o seu índice entre colchetes <code>[]</code>, logo depois do nome da tupla, assim como também é possível fatiar uma tupla em tuplas menores, da mesma forma como foi apresentado no tópico sobre <i>strings</i>. Vale lembrar que os índices sempre começam a partir do 0.\n","</p>"],"metadata":{"id":"pG79xkqnZNsR"}},{"cell_type":"code","source":["numeros = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n","\n","print(numeros[0])\n","print(numeros[1])\n","print(numeros[2])"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"JFB9McxnosCZ","executionInfo":{"status":"ok","timestamp":1671893918039,"user_tz":180,"elapsed":303,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"45466bdf-ed84-4c77-b412-d76cdd7fc32d"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["1\n","2\n","3\n"]}]},{"cell_type":"code","source":["numeros = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n","\n","print(numeros[-1])\n","print(numeros[-2])\n","print(numeros[-3])"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"6nHfcWDnpMj_","executionInfo":{"status":"ok","timestamp":1671893942141,"user_tz":180,"elapsed":240,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"6e2d34da-c618-42a2-98bb-a46ff5e41960"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["10\n","9\n","8\n"]}]},{"cell_type":"code","source":["numeros = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n","\n","print(f'Os primeiros 5 naturais: {numeros[:5]}')\n","print(f'Naturais entre 5 e 10: {numeros[4:10]}')\n","print(f'Pares entre 1 e 10: {numeros[1::2]}')\n","print(f'Ímpares entre 1 e 10: {numeros[0::2]}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"3L27pCbCpQnf","executionInfo":{"status":"ok","timestamp":1671894111583,"user_tz":180,"elapsed":426,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"727b53c5-6d0f-4e47-f92e-9700a4283d8a"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Os primeiros 5 naturais: (1, 2, 3, 4, 5)\n","Naturais entre 5 e 10: (5, 6, 7, 8, 9, 10)\n","Pares entre 1 e 10: (2, 4, 6, 8, 10)\n","Ímpares entre 1 e 10: (1, 3, 5, 7, 9)\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Os principais métodos e funções disponíveis nos objetos de tuplasa são:\n","\n","<ul align=justify>\n","<li>\n","<code><font color='#DCDCAA'>len</font>()</code> Assim como funciona para <i>strings</i>, essa função retorna a quantidade de elementos contidos numa tupla.\n","</li>\n","\n","<li>\n","<code>.count()</code> Retorna a quantidade de ocorrências de um determinado valor na tupla.\n","</li>\n","\n","<li>\n","<code>.index()</code> Retorna o índice da primeira ocorrência do valor informado como argumento.\n","</li>\n","</ul>\n","</p>"],"metadata":{"id":"HRyXe-Iep8p3"}},{"cell_type":"code","source":["valores = (12, 323, 8952, 4, 45, 23, 6564, 4, 44)\n","\n","print(f'Qtde de elementos: {len(valores)}')\n","print(f'Quantas vezes aparece o 4?: {valores.count(4)}')\n","print(f'Onde está o 45?: {valores.index(45)}') # Retorna o índice do número 45"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"DNLPX32_tFL5","executionInfo":{"status":"ok","timestamp":1671895135136,"user_tz":180,"elapsed":246,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"29b14b2f-0779-4837-a56a-29c94d2abb8c"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Qtde de elementos: 9\n","Quantas vezes aparece o 4?: 2\n","Onde está o 45?: 4\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Já as principais operações que podemos fazer com tuplas no Python são:\n","\n","<ul align=justify>\n","<li>\n","Concatenação: <code>x + y</code><br>\n","&emsp; Junta duas tuplas em uma única tupla.\n","</li>\n","\n","<li>\n","Replicação: <code>x * <font color='#B2CBA5'>n</font></code><br>\n","&emsp; Cria uma nova tupla, replicando $n$ vezes uma tupla.\n","</li>\n","\n","<li>\n","Comparação: <code>></code>, <code><</code>, <code>>=</code>, <code><=</code>, <code>==</code> ou <code>!=</code><br>\n","&emsp; Compara item a item as duas tuplas. Se <code>(x <= y) == <font color='#569CD6'>True.</font></code>, significa que <code>x</code> contém todos os elementos de <code>y</code>, mas não necessariamente <code>y</code> contém todos os elementos de <code>x</code>. Se <code>(x != y) == <font color='#569CD6'>True.</font></code>, significa que <code>x</code> não contém todos os elementos de <code>y</code> ou vice-versa.\n","</li>\n","\n","<li>\n","Associação: <code><font color='#82C6FF'>in</font></code> e <code><font color='#82C6FF'>not in</font></code><br>\n","&emsp; Verifica se um valor pertence a uma tupla ou não.\n","</li>\n","</ul>\n","</p>"],"metadata":{"id":"lalBME-Ct3fm"}},{"cell_type":"code","source":["x = (23, 4, 665)\n","y = (903, 5, 457, 78, 9456)\n","z = (23, 4, 665, 8, 56)\n","\n","print(f'x + y = {x + y}')\n","print(f'y + x = {y + x}')\n","print(f'x * 3 = {x * 3}')\n","print(f'(x < z) = {x < z}')\n","print(f'(x == y) = {x == y}')\n","print(f'(x != z) = {x != z}')\n","print(f'(x >= z) = {x >= z}')\n","print(f'4 está em x?: {4 in x}')\n","print(f'4 está em y?: {4 in y}')\n","print(f'4 está em z?: {4 in z}')\n","print(f'8 não está em x?: {8 not in x}')\n","print(f'8 não está em y?: {8 not in y}')\n","print(f'8 não está em z?: {8 not in z}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"nkamBmny2xoT","executionInfo":{"status":"ok","timestamp":1671897979620,"user_tz":180,"elapsed":377,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"faa643ea-d0d0-493c-9fee-d130b0a14420"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["x + y = (23, 4, 665, 903, 5, 457, 78, 9456)\n","y + x = (903, 5, 457, 78, 9456, 23, 4, 665)\n","x * 3 = (23, 4, 665, 23, 4, 665, 23, 4, 665)\n","(x < z) = True\n","(x == y) = False\n","(x != z) = True\n","(x >= z) = False\n","4 está em x?: True\n","4 está em y?: False\n","4 está em z?: True\n","8 não está em x?: True\n","8 não está em y?: True\n","8 não está em z?: False\n"]}]},{"cell_type":"markdown","source":["---\n","## Listas\n","---\n","\n","<p align=justify>\n","&emsp; Diferentemente das tuplas, as listas constitui de uma coleção de dados <b>mutáveis</b>, uma vez que é sempre possível mudar um dos seus valores acessando um dos seus índices (sempre começando a partir de 0). Eles são construídos englobando os dados por colchetes <code>[]</code> e é possível criar uma lista vazia usando a função conversora <code><font color='#4EC9B0'>list</font>()</code>.\n","</p>"],"metadata":{"id":"GHqKh-8vxzQZ"}},{"cell_type":"code","source":["pares = [0, 2, 4, 6, 8, 10]\n","pares[-1] = 12 # Essa linha geraria erro se pares fosse uma tupla.\n","print(pares)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"LawEI9SR5-EM","executionInfo":{"status":"ok","timestamp":1671898958982,"user_tz":180,"elapsed":301,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"1198566c-7962-4196-d501-84e27e841dc4"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["[0, 2, 4, 6, 8, 12]\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Assim como as <i>strings</i> e as tuplas, é possível fatiar listas e listas menores.\n","</p>"],"metadata":{"id":"4dAd21Z58FfF"}},{"cell_type":"code","source":["pares = [0, 2, 4, 6, 8, 10]\n","print(f'Pares entre 5 e 10: {pares[3:6]}')\n","print(f'Múltiplos de 4: {pares[2::2]}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Eg_kn8z88dBb","executionInfo":{"status":"ok","timestamp":1671899097110,"user_tz":180,"elapsed":307,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"4978363a-cdf8-4b50-94d6-17f1400391d1"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Pares entre 5 e 10: [6, 8, 10]\n","Múltiplos de 4: [4, 8]\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Dentre as principais funções e métodos empregados com listas, vale destacar:\n","\n","<ul align=justify>\n","<li>\n","<code><font color='#DCDCAA'>len</font>()</code> Assim como funciona para <i>strings</i> e tuplas, essa função retorna a quantidade de elementos na lista.\n","</li>\n","\n","<li>\n","<code>.count()</code> Retorna a quantidade de ocorrências de um determinado valor na lista.\n","</li>\n","\n","<li>\n","<code>.index()</code> Retorna o índice da primeira ocorrência do valor informado como argumento.\n","</li>\n","\n","<li>\n","<code>.sort()</code> Ordena o conteúdo da lista, se os elementos forem todos do mesmo tipo.\n","</li>\n","\n","<li>\n","<code>.append()</code> Incluir um novo elemento no final da lista.\n","</li>\n","\n","<li>\n","<code>.insert()</code> Insere um novo elemento na lista na posição passada como parâmetro. Caso o comprimento da lista seja menor do que o valor da posição informada, o elemento será inserido ao final da lista.\n","</li>\n","\n","<li>\n","<code>.pop()</code> Retorna e remove o elemento da lista na posição passada como parâmetro. Se nenhuma posição for informada, ou ela for maior que o comprimento da lista, retorna e remove o último elemento da lista.\n","</li>\n","\n","<li>\n","<code>.remove()</code> Remove a primeira ocorrência do item passado como parâmetro, da esquerda para a direita.\n","</li>\n","</ul>\n","\n","</p>"],"metadata":{"id":"bXiGZt8J89JJ"}},{"cell_type":"code","source":["valores = [23, 546, 89, 1, 48, 90, 1, 123, 567, 29902, 1]\n","\n","print(f'Qtde de elemento: {len(valores)}')\n","print(f'Quantas vezes aparece 1?: {valores.count(1)}')\n","\n","valores.sort() # Organiza a lista em ordem crescente\n","print(f'Lista ordenada: {valores}')\n","\n","valores.append(3.1415) # Insere o pi ao final da lista\n","print(f'Lista com pi no final: {valores}')\n","\n","valores.insert(2, 2.7182) # Insere o número \"e\" na posíção de índice 2.\n","print(f'Lista com o número e: {valores}')\n","\n","pi = valores.pop() # Armazena o valor removido em uma variável\n","print(f'Lista sem o {pi}: {valores}')\n","\n","e = valores.pop(2) # Armazena o valor removido em uma variável\n","print(f'Lista sem o {e}: {valores}')\n","\n","valores.remove(1) # Remove o primeiro 1 da lista\n","print(f'Lista com um 1 a menos: {valores}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"VlN1xDZG-ws7","executionInfo":{"status":"ok","timestamp":1671900684008,"user_tz":180,"elapsed":223,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"9436581d-03d4-4998-eb10-23b041c7fd96"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Qtde de elemento: 11\n","Quantas vezes aparece 1?: 3\n","Lista ordenada: [1, 1, 1, 23, 48, 89, 90, 123, 546, 567, 29902]\n","Lista com pi no final: [1, 1, 1, 23, 48, 89, 90, 123, 546, 567, 29902, 3.1415]\n","Lista com o número e: [1, 1, 2.7182, 1, 23, 48, 89, 90, 123, 546, 567, 29902, 3.1415]\n","Lista sem o 3.1415: [1, 1, 2.7182, 1, 23, 48, 89, 90, 123, 546, 567, 29902]\n","Lista sem o 2.7182: [1, 1, 1, 23, 48, 89, 90, 123, 546, 567, 29902]\n","Lista com um 1 a menos: [1, 1, 23, 48, 89, 90, 123, 546, 567, 29902]\n"]}]},{"cell_type":"markdown","source":["---\n","## Conjuntos\n","---\n","\n","<p align=justify>\n","&emsp; Diferentemente das tuplas e das listas, os conjuntos em Python representam uma coleção de dados <b>não ordenados</b>, pelo fato de seus elementos não serem indexados. Portanto, os seus elementos não podem ser acessados individualmente, porém eles são iteráveis, algo que veremos mais adiante no tópico sobre <b>ESTRUTURAS DE ITERAÇÃO</b>. Além disso, os elementos de um conjunto não se repetem, ou seja, <b>não aceita duplicatas</b>.\n","<br>\n","&emsp; Os conjuntos são criados englobando um conjunto de dados com chaves <code>{}</code> ou através da conversão de uma coleção de dados ou pela criação de um conjunto vazio utilizando a função <code><font color='#4EC9B0'>set</font>()</code>.\n","</p>"],"metadata":{"id":"_Uk3Wqzxx4pP"}},{"cell_type":"code","source":["platonicos = {'cubo', 'tetraedro', 'octaedro', 'dodecaedro', 'icosaedro'}\n","vazio = set()\n","\n","print(f'Sólidos platônicos: {platonicos}')\n","print(f'Conjunto vazio: {vazio}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"BQBdsTkhITsr","executionInfo":{"status":"ok","timestamp":1671902292799,"user_tz":180,"elapsed":341,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"20e10f57-b11c-4aaa-c18e-94738a8d3aa7"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Sólidos platônicos: {'cubo', 'dodecaedro', 'tetraedro', 'icosaedro', 'octaedro'}\n","Conjunto vazio: set()\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; As principais funções e métodos utilizados com conjuntos são:\n","\n","<ul>\n","<li>\n","<code><font color='#DCDCAA'>len</font>()</code> Assim como funciona para <i>strings</i>, tuplas e listas, essa função retorna a cardinalidade da lista, isto é, o a sua quantidade de elementos.\n","</li>\n","\n","<li>\n","<code>.add()</code> Adiciona um elemento ao conjunto, caso o elemento ainda não ocorra no conjunto.\n","</li>\n","\n","<li>\n","<code>.discard()</code> Retira um elemento do conjunto, caso ele esteja no conjunto.\n","</li>\n","</ul>\n","</p>"],"metadata":{"id":"jmQsoaoPJ05w"}},{"cell_type":"code","source":["quimicos = {'H', 'He', 'C', 'S', 'N', 'Au', 'O', 'Ag'}\n","print(f'Qtde de elementos químicos: {len(quimicos)}')\n","\n","quimicos.add('Fe') # Adiciona o elemento ferro\n","print(f'quimicos + ferro: {quimicos}')\n","\n","quimicos.discard('Ag') # Retira o elemento prata\n","print(f'quimicos - prata: {quimicos}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"p1K-mWksMDlj","executionInfo":{"status":"ok","timestamp":1671903370379,"user_tz":180,"elapsed":236,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"f5a92c10-c02c-47e7-e24e-a66a2852e555"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Qtde de elementos químicos: 8\n","quimicos + ferro: {'Ag', 'C', 'He', 'S', 'Au', 'H', 'N', 'O', 'Fe'}\n","quimicos - prata: {'C', 'He', 'S', 'Au', 'H', 'N', 'O', 'Fe'}\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; As principais operações utilizadas com conjuntos são:\n","\n","<ul align=justify>\n","<li>\n","<code>x.union(y)</code> ou <code>x | y</code><br> Retorna um novo conjunto resultante da união de dois conjuntos <code>x</code> e <code>y</code> e é formado por todo elemento que pertence a <code>x</code> ou que pertence a <code>y</code> ou a ambos.\n","</li>\n","\n","<li>\n","<code>x.intersection(y)</code> ou <code>x & y</code><br> Retorna um novo conjunto resultante da interseção de dois conjuntos <code>x</code> e <code>y</code> e é formado apenas por elementos que pertencem simultaneamente a <code>x</code> e a <code>y</code>.\n","</li>\n","\n","<li>\n","<code>x.difference(y)</code> ou <code>x - y</code><br> Retorna um novo conjunto resultante da subtração dos elementos de  <code>x</code> com <code>y</code> e é formado apenas por elementos que pertencem exclusivamente a <code>x</code>, mas não a <code>y</code>.\n","</li>\n","\n","<li>\n","<code>x == y</code><br>\n","Retorna <code><font color='#569CD6'>True</font></code> se, e somente se, todo elemento que pertença a <code>x</code> também pertença a <code>y</code> e vice-versa. Retorna <code><font color='#569CD6'>False</font></code> caso contrário.\n","</li>\n","\n","<li>\n","<code>x != y</code><br>\n","Retorna <code><font color='#569CD6'>True</font></code> se, e somente se, existir algum elemento que pertença a um dos conjuntos, mas não pertença ao outro.\n","</li>\n","\n","<li>\n","<code>x <= y</code><br>\n","Retorna <code><font color='#569CD6'>True</font></code> se, e somente se, todo elemento que pertença a <code>x</code> também pertença a <code>y</code>. Isto é, somente quando <code>x</code> estiver contido em <code>y</code>.\n","</li>\n","</ul>\n","</p>"],"metadata":{"id":"DQcaPRoyMEB4"}},{"cell_type":"code","source":["valores1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\n","valores2 = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20}\n","valores3 = valores1.union(valores2)\n","print(valores3)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"VSizSm_nP_i5","executionInfo":{"status":"ok","timestamp":1671904659474,"user_tz":180,"elapsed":264,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"51dbfbe9-6234-4310-b4ed-45baff189e1b"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}\n"]}]},{"cell_type":"code","source":["pares = valores3.difference({1, 3, 5, 7, 9, 11, 13, 15, 17, 19})\n","impares = valores3 - pares\n","print(f'Pares = {pares}')\n","print(f'Impares = {impares}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"MxGHFtcpSJTB","executionInfo":{"status":"ok","timestamp":1671905232152,"user_tz":180,"elapsed":239,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"b1a37c41-bebf-4a0d-ef68-ae176235863d"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Pares = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}\n","Impares = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19}\n"]}]},{"cell_type":"code","source":["primos = {2, 3, 5, 7, 11, 13, 17, 19}\n","primos_pares = primos.intersection(pares)\n","print(primos_pares)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"CH107ZQMTAN3","executionInfo":{"status":"ok","timestamp":1671905236100,"user_tz":180,"elapsed":3,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"64c11867-4c5b-4371-b411-e1b88b1c6a60"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["{2}\n"]}]},{"cell_type":"code","source":["print(f'(valores1 != valores2) = {valores1 != valores2}')\n","print(f'(primos <= impares) = {primos <= impares}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"VfmSFL3gTgnv","executionInfo":{"status":"ok","timestamp":1671905237157,"user_tz":180,"elapsed":2,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"a29f2da9-aece-419f-d20d-bb12795435c9"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["(valores1 != valores2) = True\n","(primos <= impares) = False\n"]}]},{"cell_type":"markdown","source":["---\n","## Dicionários\n","---\n","\n","<p align=justify>\n","&emsp; Dicionários, assim como os conjuntos, se tratam de uma coleção de dados <b>não ordenados</b>, porém diferentemente deles, seus elementos são formados por uma par de <code>chave:valor</code>, onde as chaves representam os indíces dos valores, da mesma forma como os dicionários do nosso uso cotidiando são formados por pares de palavras e conjuntos de significados associados àquela palavra. Neste caso, a palavra é a chave e os seus significados são os valores. E dam mesma forma como ocorre com dicionários da vida real, dicionários em Python <b>não aceitam duplicatas</b> de pares de <code>chave:valor</code>.\n","<br>\n","&emsp; Semelhantemente aos conjuntos, é possível criar dicionários englobando os pares de <code>chave:valor</code> com chaves <code>{}</code>, ou através da conversão de dados para dicionários ou por meio da criação de dicionários vazios com a função <code><font color='#4EC9B0'>dict</font>()</code>.\n","</p>"],"metadata":{"id":"nXwh1Wy-x7r_"}},{"cell_type":"code","source":["idades = {'Ana': 11, 'Octávio': 23, 'Beatriz': 20, 'Mateus': 13, 'Felipa': 15}\n","vazio = dict()\n","\n","print(f'Idades: {idades}')\n","print(f'Dicionário vazio: {vazio}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"VJQkDLnHXBjH","executionInfo":{"status":"ok","timestamp":1671906216819,"user_tz":180,"elapsed":235,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"3436a712-41bd-4dbb-85d3-6159e63b1903"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Idades: {'Ana': 11, 'Octávio': 23, 'Beatriz': 20, 'Mateus': 13, 'Felipa': 15}\n","Dicionário vazio: {}\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Para acessar um valor de um dicionário, é necessário passar a chave como índice, entre colchetes <code>[]</code>, logo depois do nome do dicionário.\n","</p>"],"metadata":{"id":"pi4YTAlxXe5I"}},{"cell_type":"code","source":["print(f'Idade de Ana: {idades[\"Ana\"]}')\n","print(f'Idade de Octávio: {idades[\"Octávio\"]}')\n","print(f'Idade de Mateus: {idades[\"Mateus\"]}')\n","print(f'Idade de Beatriz: {idades[\"Beatriz\"]}')\n","print(f'Idade de Felipa: {idades[\"Felipa\"]}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"X3sizN6HXzGJ","executionInfo":{"status":"ok","timestamp":1671906388567,"user_tz":180,"elapsed":219,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"56dde693-8bd1-499f-aae3-b1b9fa57b1bc"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Idade de Ana: 11\n","Idade de Octávio: 23\n","Idade de Mateus: 13\n","Idade de Beatriz: 20\n","Idade de Felipa: 15\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; As principais funções e métodos utilizados com dicionários são:\n","\n","<ul align=justify>\n","<li>\n","<code><font color='#DCDCAA'>len</font>()</code> Assim como funciona para <i>strings</i>, tuplas , listas e conjuntos, essa função retorna a quantidade de pares <code>chave:valor</code> existentes no dicionário.\n","</li>\n","\n","<li>\n","<code><font color='#C586C0'>del</font></code> Remove um par <code>chave:valor</code> informando o dicionário e a chave. Caso a chave não existe no dicionário informado, exibirá uma mensagem de erro.\n","</li>\n","\n","<li>\n","<code>.items()</code> Retorna uma visualização de todos os pares <code>chave:valor</code> de um dicionário.\n","</li>\n","\n","<li>\n","<code>.keys()</code> Retorna uma visualização de todos as chaves de um dicionário.\n","</li>\n","\n","<li>\n","<code>.values()</code> Retorna uma visualização de todos os valores de um dicionário.\n","</li>\n","\n","<li>\n","<code>.get(chave, default)</code> Passa uma chave como parâmetro e retorna <code><font color='#569CD6'>None</font></code> se a chave não existir no dicionário e retorna o valor se a chave existir. Caso o <code>default</code> tenha sido informado, retornará <code>default</code> se a chave não existir no dicionário e retornará o valor se a chave existir.\n","</li>\n","</ul>\n","</p>"],"metadata":{"id":"SRI3Yq_TZChY"}},{"cell_type":"code","source":["idades = {'Ana': 11, 'Octávio': 23, 'Beatriz': 20, 'Mateus': 13, 'Felipa': 15}\n","\n","print(f'Qtde de idades: {len(idades)}')\n","print(f'Nomes: {idades.keys()}')\n","print(f'Idades: {idades.values()}')\n","print(f'Nomes e idades: {idades.items()}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Uj33xK4UZVtG","executionInfo":{"status":"ok","timestamp":1671907577265,"user_tz":180,"elapsed":220,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"69cdc193-de9b-4095-9205-c5fd6bf6fc64"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Qtde de idades: 5\n","Nomes: dict_keys(['Ana', 'Octávio', 'Beatriz', 'Mateus', 'Felipa'])\n","Idades: dict_values([11, 23, 20, 13, 15])\n","Nomes e idades: dict_items([('Ana', 11), ('Octávio', 23), ('Beatriz', 20), ('Mateus', 13), ('Felipa', 15)])\n"]}]},{"cell_type":"code","source":["del idades['Ana']\n","print(f'Idades: {idades}')\n","print(f'Existe alguma Ana no dicionário?: {idades.get(\"Ana\", \"Não\")}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"WvhC1jrcc1M9","executionInfo":{"status":"ok","timestamp":1671907578324,"user_tz":180,"elapsed":4,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"2b6c1279-4faf-479b-8df9-0bd2b051e1fd"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Idades: {'Octávio': 23, 'Beatriz': 20, 'Mateus': 13, 'Felipa': 15}\n","Existe alguma Ana no dicionário?: Não\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Para adicionar um novo valor em um dicionário, basta atribuir o valor a uma nova chave no dicionário, como exemplificado a seguir:\n","</p>"],"metadata":{"id":"vsm9j6c9dU4e"}},{"cell_type":"code","source":["idades['Pedro'] = 30\n","print(idades)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"FkBJ6Dpfd18T","executionInfo":{"status":"ok","timestamp":1671907753023,"user_tz":180,"elapsed":225,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"cbce5d8a-0a5b-4214-c574-3f1d6324edc8"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["{'Octávio': 23, 'Beatriz': 20, 'Mateus': 13, 'Felipa': 15, 'Pedro': 30}\n"]}]},{"cell_type":"markdown","source":["---\n","---\n","# ESTRUTURA DE SELEÇÃO `if`-`else`\n","---\n","---\n","\n","<p align=justify>\n","&emsp; A estrutura <code><font color='#C586C0'>if-else</font></code> serve para determinar que um certo trecho do código seja executado caso a condição definida pelo <code><font color='#C586C0'>if</font></code> seja verdadeira. Neste caso, caso tenha sido definido, o trecho escrito no escopo do <code><font color='#C586C0'>else</font></code> é ignorado e prossegue a execução do código. Caso contrário, o trecho dentro do escopo do <code><font color='#C586C0'>if</font></code> é ignorado e o escopo do <code><font color='#C586C0'>else</font></code> é executado, caso ele tenha sido definido.\n","<br>\n","&emsp; Para o exemplo a seguir, vamos usar a função <code><font color='#DCDCAA'>input</font>()</code>, que permite ao usuário atribuir valores às variáveis manualmente, durante a execução do código. Nele, é possível passar como argumento a mensagem de texto que será exibida no momento em que o programa requisitar ao usuário a entrada de valores para dar prosseguimento à sua execução. Com, por padrão, o dado informado é armazenado como <code><font color='#4EC9B0'>str</font></code>, será necessário usar funções conversoras quando queremos que o usuário informe dados que não sejam textos (ou que não queiramos que seja entendido como texto), tais como <code><font color='#4EC9B0'>int</font>()</code>, <code><font color='#4EC9B0'>float</font>()</code>, <code><font color='#4EC9B0'>bool</font>()</code> ou vários outros que já vimos no tópico sobre VARIÁVEIS E ESTRUTURAS DE DADOS.\n","</p>"],"metadata":{"id":"mgziOv_3yHUe"}},{"cell_type":"code","source":["salario = float(input('Informe o seu salário: '))\n","\n","if salario < 0:\n","  salario = float(input('Valor inválido!\\nPor favor, digite novamente: '))\n","\n","print(f'Seu salário é de R$ {salario:.2f}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"d8rWRKPxsL9b","executionInfo":{"status":"ok","timestamp":1672012522980,"user_tz":180,"elapsed":7141,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"1d4e63da-a93f-4b30-a6ca-8f3248451ee9"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Informe o seu salário: -1000\n","Valor inválido!\n","Por favor, digite novamente: 1200\n","Seu salário é de R$ 1200.00\n"]}]},{"cell_type":"code","source":["idade = int(input('Informe a sua idade, por favor: '))\n","\n","if idade >= 18:\n","  print('É maior de idade')\n","else:\n","  print('É menor de idade')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"VXTY-XsUqKza","executionInfo":{"status":"ok","timestamp":1672012185358,"user_tz":180,"elapsed":4953,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"2d63c3e8-4312-4d72-85c1-1553257ec8f8"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Informe a sua idade, por favor: 45\n","É maior de idade\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; É possível criar estruturas de seleção <b>aninhadas</b>, em que temos estruturas  <code><font color='#C586C0'>if-else</font></code> dentro de estruturas <code><font color='#C586C0'>if-else</font></code>\n","</p>"],"metadata":{"id":"NXsxBZeWvWWw"}},{"cell_type":"code","source":["idade = int(input('Informe a sua idade, por favor: '))\n","\n","if idade >= 18:\n","  print('É maior de idade'.)\n","else:\n","  if idade >= 12:\n","    print('É um(a) adolescente.')\n","  else:\n","    print('Ainda é uma criança.')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"-CiiP-qEwU4J","executionInfo":{"status":"ok","timestamp":1672013360063,"user_tz":180,"elapsed":3161,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"7f680d30-c1e6-4d1c-8640-1d12ff4e0cf8"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Informe a sua idade, por favor: 15\n","É um adolescente\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Porém, uma maneira mais limpa e elegante é usando <code><font color='#C586C0'>elif</font></code> (abreviação de <i>else if</i>) para casos em que a condição anterior não tenha sido atendida.\n","</p>"],"metadata":{"id":"BTdwaIXMw26H"}},{"cell_type":"code","source":["idade = int(input('Informe a sua idade, por favor: '))\n","\n","if idade >= 50:\n","  print('Já é um(a) senhor(a) de idade.')\n","elif idade >= 30:\n","  print('Já atingiu a meia-idade.')\n","elif idade >= 18:\n","  print('É um(a) adulto.')\n","elif idade >= 12:\n","  print('É um(a) adolescente.')\n","else\n","  print('Ainda é uma criança.')"],"metadata":{"id":"UN03bUxpw2RY"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["---\n","---\n","# ESTRUTURA DE REPETIÇÃO `for`\n","---\n","---\n","\n","<p align=justify>\n","&emsp; A estrutura de repetição <code><font color='#C586C0'>for</font></code> é utilizada quando queremos que um determinado trecho do código seja repetida uma certa quantidade de vezes ou quando queremos iterar sobre uma certa coleção de dados. Ela sempre segue a estrutura <code><font color='#C586C0'>for</font> var <font color='#C586C0'>in</font> lista_de_valores:</code> e geralmente se usa a função <code><font color='#DCDCAA'>range</font>(<font color='#B2CBA5'>início</font>, <font color='#B2CBA5'>fim</font>, <font color='#B2CBA5'>passo</font>)</code> para gerar uma lista de números entre <code><font color='#B2CBA5'>início</font></code> e <code><font color='#B2CBA5'>fim - 1</font></code>, indo de <code><font color='#B2CBA5'>passo</font></code> em <code><font color='#B2CBA5'>passo</font></code>. Se <code><font color='#B2CBA5'>início</font></code> e <code><font color='#B2CBA5'>passo</font></code> forem omitidos, cria-se uma lista de valores desde <code><font color='#B2CBA5'>0</font></code> até <code><font color='#B2CBA5'>fim - 1</font></code>.\n","</p>"],"metadata":{"id":"0UsVwPJ0yUfn"}},{"cell_type":"code","source":["for valor in range(101): # range(100) gera a lista [0, 1, ..., 99, 100]\n","  if valor % 2 == 0: # Se valor for par.\n","    print(valor, end=', ') # Este 'end' serve para determinar a string final da impressão."],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"MJo01lfe2ZrX","executionInfo":{"status":"ok","timestamp":1672015404140,"user_tz":180,"elapsed":268,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"d484ae6b-9332-4383-b2fb-e504cb127e6c"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, "]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Lembra quando foi falado que conjuntos em Python não possuem índices e, por isso, não seria possível acessar seus elementos indivualmente? Na verdade, é possível acessá-los se usarmos a estrutura <code><font color='#C586C0'>for</font></code>.\n","</p>"],"metadata":{"id":"CkKTH_U3455V"}},{"cell_type":"code","source":["pares = set(range(0, 101, 2))\n","impares = set()\n","\n","for par in pares:\n","  impares.add(par + 1)\n","\n","print(impares)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"hMXe-fp35V4G","executionInfo":{"status":"ok","timestamp":1672015860812,"user_tz":180,"elapsed":10,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"0559791d-64d3-46d7-ae52-24f6134c06ec"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["{1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99, 101}\n"]}]},{"cell_type":"markdown","source":["---\n","---\n","# ESTRUTURA DE REPETIÇÃO `while`\n","---\n","---\n","\n","<p align=justify>\n","&emsp; A estrutura de repetição <code><font color='#C586C0'>while</font></code> serve para repetir um determinado trecho do código enquanto uma condição for verdadeira; caso contrário, o código sai do <i>loop</i> e prossegue o restante do código.\n","</p>"],"metadata":{"id":"dkhgPGthylUv"}},{"cell_type":"code","source":["valor = int(input('Digite um inteiro para calcular seu fatorial: '))\n","fatorial, i = valor, valor\n","\n","while i > 1:\n","  i = i - 1\n","  fatorial = fatorial * i\n","\n","print(f'O fatorial de {valor:n} é {fatorial:n}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"NW9Uqayn6_6N","executionInfo":{"status":"ok","timestamp":1672017271973,"user_tz":180,"elapsed":3479,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"8702c60a-07fc-4bba-fb7e-075aaf37e4b4"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Digite um inteiro para calcular seu fatorial: 7\n","O fatorial de 7 é 5040\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Uma forma de melhorar o código anterior é susbtituir as linhas <code>i = i - <font color='#B2CBA5'>1</font></code> e <code>fatorial = fatorial * i</code> por <code>i -= <font color='#B2CBA5'>1</font></code> e <code>fatorial *= i</code>, respectivamente.\n","<br>\n","&emsp; É sempre possível fazer isso quando uma variável recebe ela mesma e é aplicado uma operação aritmética sobre ela. Destarte, é possível escrever as seguintes linhas de código:\n","\n","<ul>\n","<li>\n","<code>var += expressão</code> é o mesmo que <code>var = var + expressão</code>\n","</li>\n","\n","<li>\n","<code>var -= expressão</code> é o mesmo que <code>var = var - expressão</code>\n","</li>\n","\n","<li>\n","<code>var *= expressão</code> é o mesmo que <code>var = var * expressão</code>\n","</li>\n","\n","<li>\n","<code>var /= expressão</code> é o mesmo que <code>var = var / expressão</code>\n","</li>\n","\n","<li>\n","<code>var //= expressão</code> é o mesmo que <code>var = var // expressão</code>\n","</li>\n","\n","<li>\n","<code>var %= expressão</code> é o mesmo que <code>var = var % expressão</code>\n","</li>\n","\n","<li>\n","<code>var **= expressão</code> é o mesmo que <code>var = var ** expressão</code>\n","</li>\n","\n","</ul>\n","</p>"],"metadata":{"id":"JiJlUEm--MoU"}},{"cell_type":"code","source":["valor = int(input('Digite um inteiro para calcular seu fatorial: '))\n","fatorial, i = valor, valor\n","\n","while i > 1:\n","  i -= 1\n","  fatorial *= i\n","\n","print(f'O fatorial de {valor:n} é {fatorial:n}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"S19FBrYB_Kuk","executionInfo":{"status":"ok","timestamp":1672017302506,"user_tz":180,"elapsed":4330,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"2d269b39-6c0f-4530-edf0-220d4ca42d5d"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Digite um inteiro para calcular seu fatorial: 7\n","O fatorial de 7 é 5040\n"]}]},{"cell_type":"markdown","source":["---\n","---\n","# DEFININDO FUNÇÕES\n","---\n","---\n","\n","<p align=justify>\n","&emsp; As funções em Python são definidas usando a sintaxe <code><font color='#569CD6'>def</font> nome_da_funcao(arg1, arg2, ..., argN):</code> e ao final da sua execução, usa-se o comando <code><font color='#C586C0'>return</font></code> para retorna a saída da função.\n","</p>"],"metadata":{"id":"x-ynprpaypq2"}},{"cell_type":"code","source":["def fatorial(num):\n","\n","  num = int(num)\n","\n","  if num < 0:\n","    return None\n","  elif num == 0:\n","    return 1\n","  else:\n","    i = num\n","    while i > 1:\n","      i -= 1\n","      num *= i\n","    return num\n","\n","print(fatorial(10))"],"metadata":{"id":"0WPRyxzsyTLR","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1672019078919,"user_tz":180,"elapsed":330,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"eab55e5e-6db4-48f7-d258-da1a66af83c7"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["3628800\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; Um aspecto a se ter ciência quando estamos lidando com funções são os conceitos de <b>escopo global</b> e <b>escopo local</b>. As variáveis que são declaradas no escopo global de um código podem ser acessadas e manipuladas em qualquer parte do código. No entanto, variáveis que são declaradas em um escopo local de uma função, por exemplo, só existem neste escopo, não podendo ser acessadas ou manipuladas no escopo global ou em um outro escopo local.\n","</p>"],"metadata":{"id":"yK5q-s-JG1oa"}},{"cell_type":"code","source":["z = 100 # declarando a variável global z\n","\n","def soma(x, y):\n","  z = x + y # Criando a variável local z\n","  return z\n","\n","a, b = 10, 20\n","c = soma(a, b)\n","\n","print(f'c = {c}')\n","print(f'z = {z}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"j3z1cRazF2FQ","executionInfo":{"status":"ok","timestamp":1672019582725,"user_tz":180,"elapsed":286,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"d776116c-4c87-40f0-a88f-6c32ba2e7a9c"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["c = 30\n","z = 100\n"]}]},{"cell_type":"markdown","source":["<p align=justify>\n","&emsp; No último exemplo, é possível perceber que o <code>z</code> que se encontra dentro da função <code><font color='#DCDCAA'>soma</font>()</code> não possui qualquer relação com o <code>z</code> declarado no escopo global do código, pois são considerados variáveis diferentes pelo interpretador.\n","<br>\n","&emsp; Além disso, as variáveis <code>a</code> e <code>b</code> ocuparam os lugares dos argumentos <code>x</code> e <code>y</code> definidos no escopo da função <code><font color='#DCDCAA'>soma</font>()</code>, enquanto o <code>c</code> recebeu o retorno de <code><font color='#DCDCAA'>soma</font>(a,b)</code>, que não possui o mesmo valor da variável <code>z</code> definida globalmente, o que mais uma vez mostra que a declaração em escopos distintos faz com que as variáveis <code>z</code> sejam consideradas variáveis diferentes.\n","<br>\n","&emsp; É possível ainda indicar quais serão os tipos das variáveis que devem passadas como argumentos e o tipo do dado da variável de retorno através das <i>annotations</i>, usando a sintaxe <code><font color='#569CD6'>def</font> nome_da_funcao(arg1:tipo1, arg2:tipo2, ..., argN:tipoN) -> tipo_retorno:</code>. Porém, elas não obrigam o usuário a usarem as variáveis dos tipos indicados (uma vez que o Python é uma linguagem de tipagem dinâmica), mas elas apenas <b>sugerem</b> ao usuário qual o tipo a ser usado.\n","</p>"],"metadata":{"id":"NHjAGrQMIkHg"}},{"cell_type":"code","source":["def soma(x:float, y:float) -> float:\n","  return x + y\n","\n","z = soma(1000, 2000)\n","print(f'z = {z}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"aVCcMNq6L3Fd","executionInfo":{"status":"ok","timestamp":1672020685554,"user_tz":180,"elapsed":281,"user":{"displayName":"Rodrigo Celso de Lima Porto","userId":"00317348114914252656"}},"outputId":"d2317c38-a575-4879-e85a-eeffa7d48084"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["z = 3000\n"]}]},{"cell_type":"markdown","source":["---\n","---\n","# REFERÊNCIAS\n","---\n","---\n","\n","<ol>\n","<li>\n","FILHO, Dante Corbucci; FERNANDES, Leandro A. F. Mateiriais e aula disponíveis no <a href='http://www.ic.uff.br/~fabio/python_arquivos'>site do Instituto de Computação da UFF</a>.\n","</li>\n","\n","<li>\n","SOUSA, Álan Crístoffer e. Curso Básico de Python 3. CEFET/MG. 2017. Disponível em: <a href='https://acristoffers.me/Python3.pdf'>https://acristoffers.me/Python3.pdf</a>.\n","</li>\n","\n","<li>\n","SUNDNES, Joakim. Introduction to Scientific Programming with Python. Simula SpringerBriefs on Computing, vol. 6. 2020. Disponível em: <a href='https://link.springer.com/book/10.1007/978-3-030-50356-7'>https://link.springer.com/book/10.1007/978-3-030-50356-7</a>.\n","</li>\n","</ol>\n"],"metadata":{"id":"9tyUgNrtMx6n"}}]}