├── README.md
├── code-atividades
    ├── 041.py
    ├── __pycache__
    │   └── calcArea.cpython-311.pyc
    ├── calcArea.py
    ├── ex001.py
    ├── ex002.py
    ├── ex003.py
    ├── ex004.py
    ├── ex005.py
    ├── ex006.py
    ├── ex007.py
    ├── ex008.py
    ├── ex009.py
    ├── ex010.py
    ├── ex011.py
    ├── ex012.py
    ├── ex013.py
    ├── ex014.py
    ├── ex015.py
    ├── ex016.py
    ├── ex017.py
    ├── ex018.py
    ├── ex019.py
    ├── ex039.py
    ├── ex040.py
    ├── ex042.py
    ├── ex043.py
    ├── ex044.py
    ├── ex045.py
    ├── ex20.py
    ├── ex21.py
    ├── ex22.py
    ├── ex23.py
    ├── ex24.py
    ├── ex25.py
    ├── ex26.py
    ├── ex27.py
    ├── ex28.py
    ├── ex29.py
    ├── ex30.py
    ├── ex31.py
    ├── ex32.py
    ├── ex33.py
    ├── ex34.py
    ├── ex35.py
    ├── ex36.py
    ├── ex37.py
    ├── ex38.py
    ├── ex41.py
    ├── ex46.py
    ├── ex48.py
    └── main.py
└── novos-codigos
    └── ex01.py


/README.md:
--------------------------------------------------------------------------------
  1 | # Lógica de Programação 
  2 | 
  3 | Este repositório tem como objetivo compartilhar um pouco dos meus estudos de lógica de programação utilizando o Python. No momento, vou passar por algumas informações introdutórias sobre, mas, deixarei um link com a história e detalhes sobre a mesma. 
  4 | 
  5 | **Link:** [Ebook - Introdução ao Python - Editora IFRN](https://memoria.ifrn.edu.br/bitstream/handle/1044/2090/EBOOK%20-%20INTRODU%C3%87%C3%83O%20A%20PYTHON%20%28EDITORA%20IFRN%29.pdf?sequence=1&isAllowed=y)
  6 | 
  7 | Primeiro de tudo, **instalação**. Se em sua máquina já tiver o python instalado, então tudo certo xD
  8 | 
  9 | No entanto, o passo a passo a seguir é eficaz para ajudar aqueles que não possuem o Python instalado.
 10 | 
 11 | OBS: Também pode servir para quem não sabe (esqueceu) é só verificar se você tem o Python instalado na sua máquina.
 12 | 
 13 | **NO CMD:**
 14 | 
 15 | **Digite:** `python --version`
 16 | 
 17 | O retorno esperado para (caso) você tiver o python instalado, seria o nome a versão: `python3.11.2 `
 18 | 
 19 | Caso contrário, vamos ver agora um passo a passo da instalação (depois irei adicionar uma imagens e deixar mais claro no que for possível):
 20 | 
 21 | 1. Acesse o site oficial do Python (<https://www.python.org>) e procure a seção de downloads.
 22 | 2. Na página de downloads, escolha a versão mais recente estável (por exemplo, `Python 3.9.6`). Não esqueça que deve corresponder ao seu sistema operacional(x64, x86). Se você estiver em um ambiente Windows, é só baixar o instalador executável para ele.
 23 | 3. Clique no link de download para iniciar o download do instalador.
 24 | 4. Depois de concluído o download, execute o instalador.
 25 | 5. <span style="color:red">IMPORTANTE -</span> Na primeira tela do instalador, marque a opção "Add Python to PATH" (Adicionar Python ao PATH). Isso adicionará automaticamente o Python ao PATH do sistema, que é o que permite executar comandos Python em qualquer diretório no prompt de comando ou terminal.
 26 | 6. Selecione a opção "Customize installation" (Personalizar instalação) para ter mais controle sobre as opções de instalação. Aqui você pode escolher os recursos adicionais que deseja instalar (como pip, IDLE etc.) e selecionar o diretório de instalação.
 27 | 7. Depois de fazer as seleções desejadas, clique em "Next" (Avançar) e aguarde a instalação ser concluída.
 28 | 8. Após a instalação ser concluída, você pode abrir o prompt de comando (no Windows, pressione Win + R, digite "cmd" e pressione Enter) e digitar "python" para verificar se o Python foi instalado corretamente, como fizemos inicialmente.
 29 | 
 30 | 
 31 | ------
 32 | 
 33 | ### Linguagem Pyton
 34 | 
 35 | ##### Interpretador IDLE
 36 | 
 37 | Bem... há varias formas de utilizarmos na prática o python. Aqui, utilizei o IDLE para testes iniciais com a linguagem e o Pycharm. Para aprender um pouco sobre a IDE que vem junto a instalação padrão do Pyhton. Segue apenas um resuminho sobre:
 38 | 
 39 | *IDLE* oferece uma interface gráfica simples que facilita a interação com o interpretador Python. Ele inclui recursos como um editor de texto com realce de sintaxe, suporte para execução interativa de código, histórico de comandos, visualização de resultados, depuração passo a passo, a capacidade de abrir múltiplos editores de código, autocompletar, exibição da árvore de análise sintática e suporte a extensões de terceiros. Uma das principais características do IDLE é a capacidade de executar código Python interativamente, o que significa que você pode digitar instruções e ver os resultados imediatamente. 
 40 | 
 41 | ##### Pycharm 
 42 | 
 43 | O PyCharm é um ambiente de desenvolvimento integrado (IDE) altamente popular e amplamente utilizado para programação em Python. Ele é desenvolvido pela JetBrains e oferece uma série de recursos e 
 44 | ferramentas que visam facilitar o processo de desenvolvimento de software em Python.
 45 | 
 46 | 
 47 | 
 48 | ------
 49 | 
 50 | ### Resumão Sobre Variáveis e Atribuição de Valores
 51 | 
 52 | **Declaração de variáveis:**
 53 | 
 54 | 1. Em Python, você não precisa declarar explicitamente o tipo de dado de uma variável. Apenas atribua um valor a ela e Python cuidará do resto.
 55 | 2. **Atribuição de valores:**
 56 |    Para atribuir um valor a uma variável, utilize o operador de atribuição (=) seguido pelo valor que deseja armazenar.
 57 | 3. **Nomes de variáveis:**
 58 | 
 59 | - O nome de uma variável pode conter letras, números e o caractere de sublinhado (_).
 60 | - O primeiro caractere do nome da variável não pode ser um número.
 61 | - Python é sensível a maiúsculas e minúsculas, ou seja, diferencia maiúsculas de minúsculas. Por exemplo, "valor" e "Valor" são duas variáveis diferentes.
 62 | 
 63 | 4. **Reatribuição de valores:**
 64 |    Você pode alterar o valor de uma variável simplesmente atribuindo um novo valor a ela.
 65 | 5. **Tipos de dados**
 66 |    As variáveis em Python podem conter diferentes tipos de dados, como 
 67 |    inteiros (int), números de ponto flutuante (float), strings (str), 
 68 |    listas (list), dicionários (dict), entre outros. O tipo de dado é 
 69 |    inferido automaticamente quando você atribui um valor à variável.
 70 | 
 71 | <Exemplos em código - ex001>
 72 | 
 73 | ------
 74 | 
 75 | ### Expressões em Python
 76 | 
 77 | Expressões são combinações válidas de variáveis, constantes e operadores que retornam um resultado após a sua avaliação. Existem três tipos principais de expressões em Python: aritméticas, lógicas e relacionais.
 78 | 
 79 | #### **Expressões Aritméticas:**
 80 | 
 81 | - Operam sobre valores inteiros ou reais.
 82 | - Os operadores aritméticos são: + (adição), - (subtração), * (multiplicação), / (divisão), // (parte inteira da divisão), % (resto da divisão) e ** (exponenciação).
 83 | - A precedência dos operadores é: primeiro **, depois *, /, // e %, e por último + e -.
 84 | - Parênteses podem ser usados para forçar a avaliação de operadores com menor precedência.
 85 | 
 86 | Exemplos:
 87 | 
 88 | - 5 + 3 → Resultado: 8
 89 | - 10 * 2 / 5 → Resultado: 4.0
 90 | - 2 ** 3 + 4 → Resultado: 12
 91 | - (5 + 3) * 2 → Resultado: 16
 92 | 
 93 | <Exemplos em código - ex002>
 94 | 
 95 | <center>.....................................................................................................................................................................</center>
 96 | 
 97 | #### Expressões Lógicas:
 98 | 
 99 | - São formadas por operadores lógicos: 'or' (ou), 'and' (e) e 'not' (não).
100 | - O resultado da avaliação é sempre True (verdadeiro) ou False (falso).
101 | - A precedência é: primeiro 'not', depois 'and', e por último 'or'.
102 | 
103 | Exemplos:
104 | 
105 | - True and False → Resultado: False
106 | - not (5 == 3) → Resultado: True
107 | - (2 > 1) or (3 < 1) → Resultado: True
108 | 
109 | <Exemplos em código - ex003>
110 | 
111 | <center>.....................................................................................................................................................................</center>
112 | 
113 | #### Expressões Relacionais:
114 | 
115 | - São usadas para fazer comparações entre expressões.
116 | - Os operadores relacionais são: == (igual a), > (maior que), < (menor que), >= (maior ou igual a), <= (menor ou igual a) e != (diferente de).
117 | - O resultado da comparação é True se a condição for satisfeita, ou False caso contrário.
118 | 
119 | Exemplos:
120 | 
121 | - 5 == 5 → Resultado: True
122 | - 10 > 5 → Resultado: True
123 | - 7 <= 6 → Resultado: False
124 | 
125 | É importante entender a ordem de precedência dos operadores para avaliar corretamente as expressões. Se necessário, é possível usar parênteses para controlar a ordem de avaliação.
126 | 
127 | Lembre-se de que as expressões são fundamentais para realizar cálculos, comparações e testes em Python, tornando-se uma parte essencial na programação com essa linguagem.
128 | 
129 | <Exemplos em código - ex001, ex002, ex003>
130 | 
131 | _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
132 | 
133 | ### Controle de Fluxo
134 | 
135 | O controle de fluxo em Python é essencial para direcionar a execução do código, permitindo que certas partes do programa sejam executadas apenas sob determinadas condições ou repetidas várias vezes. As principais estruturas de controle de fluxo em Python são:
136 | 
137 | #### Estrutura Condicional (if, elif, else):
138 | 
139 | - Permite executar um bloco de código somente se uma condição for verdadeira.
140 | - A estrutura é composta por um "if" seguido por uma condição. Se a condição for verdadeira, o bloco de código dentro do "if" é executado. Caso contrário, o programa verifica se existem cláusulas "elif" (abreviação de "else if") com condições adicionais. Se alguma dessas condições for verdadeira, o bloco de código associado à primeira condição verdadeira "elif" é executado. Caso nenhuma das condições anteriores seja verdadeira, o bloco de código dentro de "else" (opcional) é executado.
141 | 
142 | #### Estrutura de Repetição (for):
143 | 
144 | - Permite executar um bloco de código repetidamente para cada elemento de uma sequência (por exemplo, uma lista, string, tupla, etc.).
145 | - O loop "for" itera sobre os elementos da sequência, e a cada iteração, o bloco de código associado é executado.
146 | 
147 | #### Estrutura de Repetição (while):
148 | 
149 | - Permite executar um bloco de código repetidamente enquanto uma condição for verdadeira.
150 | - O bloco de código é executado repetidamente até que a condição especificada seja falsa.
151 | 
152 | #### Controle de Loop (break e continue):
153 | 
154 | - O "break" é usado para interromper um loop prematuramente, quando uma condição é atendida.
155 | - O "continue" é usado para pular a iteração atual de um loop e passar para a próxima iteração.
156 | 
157 | #### Cores no Terminal
158 | 
159 | Os códigos ANSI são uma forma de adicionar formatação de texto ao imprimir no terminal, permitindo que você altere cores de fundo, cores do texto, estilo do texto e até mesmo a posição do cursor. No Python, você pode utilizar esses códigos ANSI para adicionar cores e outros efeitos visuais ao seu texto.
160 | 
161 | Códigos ANSI para cores no terminal:Os códigos ANSI são sequências de escape que começam com o caractere de escape `\033` (também representado como `\x1b` ou `\u001b`). Eles são seguidos por um conjunto de números separados por ponto e vírgula, que especificam as propriedades de formatação. Para adicionar cores, geralmente usamos códigos ANSI que começam com `\033[`, seguidos por um número para representar a cor desejada.
162 | 
163 | Exemplo:
164 | 
165 | - `\033[31m` para cor vermelha
166 | - `\033[32m` para cor verde
167 | - `\033[33m` para cor amarela
168 | 
169 | 1. Estilos de texto:Você pode usar códigos ANSI para adicionar estilos ao texto, como negrito, sublinhado e piscando. Alguns exemplos:
170 | 
171 | - `\033[1m` para negrito
172 | - `\033[4m` para sublinhado
173 | - `\033[5m` para piscando
174 | 
175 | 1. Resetar a formatação:Após usar códigos ANSI para formatar o texto, é recomendado que você adicione `\033[0m` para redefinir as configurações e evitar que a formatação se aplique ao texto posterior.
176 | 
177 | <Exemplos em código - ex004>
178 | 
179 | ------
180 | 
181 | ### Estrutura de Repetição - FOR
182 | 
183 | Em Python, existem duas estruturas principais de repetição: `while` e `for`. Ambas permitem que você execute um bloco de código várias vezes com base em uma condição ou em um conjunto de elementos.
184 | 
185 | **Estrutura de repetição com while:**
186 | 
187 | O `while` repete um bloco de código enquanto uma condição específica for verdadeira. ssa estrutura de repetição executa um ciclo para cada elemento do objeto que está sendo iterado. Nas vezes em que precisamos que determinada variável seja incrementado ou decrementada a cada ciclo, a forma mais simples, é gerando uma lista com a função **range()**.
188 | 
189 | Sintaxe do comando **WHILE** em Python é a seguinte:
190 | 
191 | **while** condição:
192 | 
193 | ​           **comando_verdadeiro**
194 | 
195 | Os comandos (ou instruções) dentro do corpo da estrutura **while** são executados (ou repetidos) ENQUANTO a condição for verdadeira 
196 | (True).
197 | ​                    Quando a condição se torna falsa (False), os 
198 | comandos não são executados e o programa continua depois da instrução **while**.
199 | 
200 | **Estrutura de repetição com for:**
201 | 
202 | O `for` é usado para percorrer uma sequência de elementos, como uma lista, tupla ou string. Ele executará um bloco de código para cada elemento na sequência.
203 | 
204 | Sintaxe do comando **FOR** em Python é a seguinte:
205 | 
206 | **for** item **in range**(início, fim, passo):
207 | 
208 | ​           **item **    
209 | 
210 | Podemos usar o `break` para sair de um loop antes que a condição seja falsa, e o `continue` para pular a iteração atual e ir para a próxima.
211 | 
212 | <Exemplos em código - ex006, ex007>
213 | 
214 | ------
215 | 
216 | ### Estrutura de Dados
217 | 
218 | Estas estruturas resolvem um tipo de problema e podem ser úteis em diversas situações.  As principais estruturas são as Listas, Sets, Dicionários e Tuplas.
219 | 
220 | ####     **Listas**
221 | 
222 | Uma lista é a estrutura de dados mais básica do Python e armazena os dados em sequência, onde cada elemento possui sua posição na lista, denominada de índice. O primeiro elemento é sempre o índice zero e a cada elemento inserido na lista esse valor é    incrementado.
223 | 
224 | No Python, uma lista pode armazenar qualquer tipo de dado primitivo (string, inteiro, float, etc).
225 | 
226 | ##### **Declarando Listas**
227 | 
228 | Para a criação de uma lista no Python, a sintaxe é a seguinte:
229 | 
230 | ```python
231 | nome_da_lista = [] # Criação de uma lista vazianome_da_lista = [1, 2, 3] # Criação de uma lista de inteirosnome_da_lista = [1, "Olá, mundo!", 1.1] # Criação de uma lista com vários tipos diferentes
232 | ```
233 | 
234 | Podemos também criar listas dentro de outras listas. Essas são chamadas de nested lists e sua sintaxe é a seguinte:
235 | 
236 | ```python
237 | nome_da_lista = ["Olá, mundo",  [1, 2, 3], ["outra_lista"]]
238 | ```
239 | 
240 | ####     **Tuplas**
241 | 
242 | Uma tupla é uma estrutura bastante similar a uma lista, com apenas uma diferença: **os elementos inseridos em uma tupla não podem ser alterados**, diferente de uma lista onde podem ser    alterados livremente. Sendo assim, em um primeiro momento, podemos pensar em uma tupla como uma lista que não pode ser alterada, mas não é bem assim…
243 | 
244 | É certo que as tuplas possuem diversas características das listas, porém os usos são distintos. As listas são destinadas a serem sequências homogêneas, enquanto que as Tuplas são estruturas de dados heterogêneas.
245 | 
246 | Sendo assim, apesar de bastante similares, a tupla é utilizada para armazenar dados de tipos diferentes, enquanto que a lista é para dados do mesmo tipo.
247 | 
248 | ##### **Tuplas x Listas**
249 | 
250 | As tuplas possuem algumas vantagens com relação às listas, que são:
251 | 
252 | - Como as tuplas são imutáveis, a iteração sobre elas é mais rápida e, consequentemente, possuem um ganho de desempenho com relação às listas;
253 | - Tuplas podem ser utilizadas como chave para um dicionário, já que seus elementos são imutáveis. Já com a lista, isso não é possível;
254 | - Se for necessário armazenar dados que não serão alterados, utilize uma tupla. Isso garantirá que esses sejam protegidos de alterações posteriores.
255 | 
256 | ##### **Declarando Tuplas**
257 | 
258 | A sintaxe para criação de uma tupla, assim como uma lista, também é bem simples. Ao invés de se utilizar colchetes (listas), são utilizados parênteses, como podemos ver abaixo:
259 | 
260 | ```python
261 | nome_da_tupla = (1, 2, 3) #tupla de inteirosnome_da_tupla = (1, "olá", 1.5) #tupla heterogênea
262 | ```
263 | 
264 | ####     **Sets**
265 | 
266 | No Python, os sets são uma coleção de itens desordenada, parcialmente imutável e que não podem conter elementos duplicados. Por ser parcialmente imutável, os sets possuem permissão de adição e remoção de elementos.
267 | 
268 | Além disso, os sets são utilizados, normalmente, com operações matemáticas de união, interseção e diferença simétrica, conforme veremos nos próximos tópicos.
269 | 
270 | ##### **Declarando Sets**
271 | 
272 | Para a criação de um set no Python há duas formas: A primeira é bem similar às listas e tuplas, porém utilizando chaves **{}** para determinar os elementos do set:
273 | 
274 | ```python
275 | nome_do_set = {1, 2, 3, 4}
276 | 
277 | ```
278 | 
279 | A segunda é utilizando o método **set** presente no Python:
280 | 
281 | ```python
282 | nome_do_set = set([1, 2, 3, 4])
283 | ```
284 | 
285 | ####     **Dicionários**
286 | 
287 | No Python, os dicionários são coleções de itens desordenados com uma diferença bem grande quando comparados às outras coleções (*listas, sets, tuplas, etc*): **um elemento dentro de um dicionário possui uma chave atrelada a ele, uma espécie de identificador**.    Sendo assim, é muito utilizado quando queremos armazenar dados de forma organizada e que possuem identificação única (como acontece em bancos de dados).
288 | 
289 | | Chaves | Valores         |
290 | | ------ | --------------- |
291 | | Nome   | Aelin           |
292 | | Idade  | 31              |
293 | | Cidade | Areia Branca/RN |
294 | 
295 | Onde cada valor é “atrelado” à uma chave, seu identificador. Vale lembrar que, por necessitar que cada valor possua uma chave relacionada a ele, as chaves dos dicionários devem ser únicas para que possam ser acessadas, também, através do seu índice.
296 | 
297 | **ATENÇÃO:** As chaves também não são armazenadas em qualquer ordem, elas apenas são associadas aos valores que pertencem.
298 | 
299 | ##### **Declarando Dicionários**
300 | 
301 | Existem duas formas de se criar um dicionário utilizando o Python. A primeira delas é utilizando chaves ( {} ) e separando os elementos das chaves com dois pontos ( : ) e os outros elementos por vírgula ( , ):
302 | 
303 | ```python
304 | nome_do_dicionario = {1: ‘João’, 2: ‘José’}nome_do_dicionario = {‘nome’: ‘João’, ‘sobrenome’: ‘Silva’}
305 | ```
306 | 
307 | A segunda forma é utilizando o método **dict()** com o dicionário sendo passado como parâmetro:
308 | 
309 | ```python
310 | nome_do_dicionario = dict({1: ‘João’, 2: ‘José’})nome_do_dicionario = dict({‘nome’: ‘João’, ‘sobrenome’: ‘Silva’})
311 | ```
312 | 
313 | 
314 | 
315 | ### Listas
316 | 
317 | Vamos agora aprofundar o nosso estudo em torno da estrutura de dados* "lista"*. Não se preocupe, que o estudo anterior também irá se aplicar aqui, pois precisamos das estruturas de repetição    para percorrer as listas.
318 | 
319 | Trabalhar com listas nos permite resolver vários problemas. Você pode criar listas de cada um dos tipos básicos e até mesmo de outras listas. 
320 | 
321 | **Mas, o quem vem a ser uma lista?** 
322 | 
323 | *Ora tenho certeza que você já criou uma lista alguma vez na vida. Podemos citar diversos exemplos, como uma lista de compras no supermercado, a lista dos seus filmes favoritos, a lista das matérias que você precisa estudar mais.*
324 | 
325 | Em Python, uma lista é uma sequência mutável de n valores que podem ser de qualquer tipo
326 | (inclusive outras listas, tuplas e dicionários).
327 | De forma simples, uma lista pode ser entendida como um vetor de elementos que podem ser de
328 | qualquer tipo. As listas são exatamente iguais às Strings, exceto pelo fato de Strings serem
329 | imutáveis e listas serem mutáveis.
330 | 
331 | As listas podem ser percorridas, “fatiadas” e concatenadas da mesma forma que as Strings. A diferença é que em se tratando de Strings, cada elemento é um caractere e, em se tratando de listas, cada elemento pode ser qualquer tipo de variável. Além disso, uma String pode ser convertida para uma lista (como já foi visto) e uma lista pode ser convertida para uma string.
332 | 
333 | ____________
334 | 
335 | ### Modularização
336 | 
337 | Técnica de programação que visa a organização do código em partes menores, reutilizáveis e mais gerenciáveis. Ao dividir o código em módulos ou funções, o programador pode focar em resolver pequenas partes do problema por vez, tornando o código mais legível e facilitando a manutenção. 
338 | 
339 | ##### Escopo de Variáveis 
340 | 
341 | O escopo de uma variável refere-se ao contexto no qual essa variável está definida e por onde pode ser acessada. 
342 | 
343 | - **Variáveis Locais:** São definidas dentro de uma função e não podem ser acessadas fora dela.
344 | 
345 | - **Variáveis Globais:** São definidas no corpo principal do código e podem ser acessadas através
346 |    de sua palavra-chave em outra parte do código e, até mesmo, em funções.
347 | 
348 |   ​
349 | 
350 | ##### Funções
351 | 
352 | Funções são blocos de 
353 | código que executam uma tarefa específica e que podem ser reutilizados. 
354 | Elas permitem a modularização do código, reduzindo a repetição de 
355 | trechos específicos e tornando o código mais legível.
356 | 
357 | - **Definição:** Uma função é definida usando a palavra-chave `def`, seguida pelo nome da função e parênteses.
358 | - **Chamada:** Uma vez definida, uma função pode ser chamada pelo seu nome, seguida de parênteses.
359 | 
360 | 
361 | 
362 | ##### Passagem de Parâmetro
363 | 
364 | Python tem um comportamento interessante ao passar argumentos para funções. A depender do tipo de dado, a passagem pode se comportar como por valor ou por referência.
365 | 
366 | - **Por Valor:** Tipos imutáveis como inteiros, strings e tuplas são passados por valor. Isso significa que qualquer alteração feita no parâmetro dentro da função não afeta o valor original.
367 | - **Por Referência:** Tipos mutáveis como listas, dicionários e conjuntos são passados por referência. Portanto, se você modificar o parâmetro dentro da função, o valor original também será alterado.
368 | 
369 | <Exemplos em código - ex030, ex035>
370 | 
371 | ### Bibliotecas
372 | 
373 | As bibliotecas em Python são uma das principais razões para a popularidade e extensão da linguagem. Eles nos permitem que aproveitemos os recursos preexistentes sem ter que reinventar a roda e, que assim, acelerar o nosso processo de desenvolvimento.
374 | 
375 | **Uma biblioteca em Python é uma coleção de módulos que fornecem funcionalidades prontas para uso.** Estas funcionalidades podem variar de operações matemáticas simples a complexos frameworks de desenvolvimento web.
376 | 
377 | - **Bibliotecas Padrão**: Python inclui uma vasta biblioteca padrão que oferece funcionalidades para muitas operações comuns, como manipulação de arquivos, operações de rede e gerenciamento de sistema. Essas bibliotecas são parte integrante da instalação do Python e podem ser acessadas sem qualquer instalação adicional.
378 | - **Bibliotecas de Terceiros**: Além das bibliotecas padrão, há uma imensa variedade de bibliotecas de terceiros disponíveis para Python que podem ser instaladas usando ferramentas como pip. Essas bibliotecas abrangem uma vasta gama de funcionalidades, de análise de dados a desenvolvimento de jogos.
379 | 
380 | ##### Utilização
381 | 
382 | Usar uma biblioteca em Python geralmente requer duas etapas. Primeiro, você precisa instalar a biblioteca (a menos que seja parte da biblioteca padrão). Isso geralmente é feito utilizando pip. Depois de instalado, você pode importar a biblioteca ou partes dela em seu código e usar suas funcionalidades.
383 | 
384 | ##### Criação
385 | 
386 | Criar sua própria biblioteca pode parecer uma tarefa assustadora, mas é essencial para organizar seu código de forma modular e reutilizável. Se você tem um conjunto de funções que você acha que pode utilizar em múltiplos projetos, ou acredita que outros possam se beneficiar, pode ser hora de empacotá-los em uma biblioteca.
387 | 
388 | - **Organização do Código**: O primeiro passo é organizar seu código. Crie um diretório para sua biblioteca e coloque seu código em um ou mais arquivos `.py` neste diretório.
389 | - **Criar setup.py**: Este é o arquivo de configuração necessário para empacotar sua biblioteca para distribuição. Ele contém informações sobre a biblioteca e suas dependências.
390 | 
391 | Entender as bibliotecas e como elas operam é fundamental para qualquer desenvolvedor Python, seja utilizando funcionalidades preexistentes para acelerar seu trabalho ou compartilhando suas próprias criações com a comunidade de desenvolvedores Python.
392 | 
393 | <Exemplos em código - ex036, ex037, ex038>
394 | 
395 | 
396 | 
397 | 
398 | 
399 | Glossário:
400 | 
401 | Interpretador:
402 | 
403 | Linguagem de Máquina:
404 | 
405 | 


--------------------------------------------------------------------------------
/code-atividades/041.py:
--------------------------------------------------------------------------------
1 | # Lendo de um arquivo
2 | 
3 | with open('ex040.py', 'r') as arquivo:
4 |     conteudo = arquivo.read()
5 |     print(conteudo)


--------------------------------------------------------------------------------
/code-atividades/__pycache__/calcArea.cpython-311.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/allineantunnes/estudos-logica-com-python/ec7089fc48cdca33bf63ad6a9460f57b21f7f481/code-atividades/__pycache__/calcArea.cpython-311.pyc


--------------------------------------------------------------------------------
/code-atividades/calcArea.py:
--------------------------------------------------------------------------------
 1 | import math
 2 | 
 3 | def calcular_area_circulo(raio):
 4 |     return math.pi * raio**2
 5 | 
 6 | def calcular_area_triangulo(base, altura):
 7 |     return (base * altura) / 2
 8 | 
 9 | def calcular_area_retangulo(largura, altura):
10 |     return largura * altura


--------------------------------------------------------------------------------
/code-atividades/ex001.py:
--------------------------------------------------------------------------------
 1 | #Declaração de variáveis
 2 | #Atribuição de valores
 3 | #Nomes de variáveis(nome, tipo, xp)
 4 | #Reatribuição de valores(xp = xp + 1500)
 5 | #Tipos de dados(Str, Str, Int)
 6 | 
 7 | nome = "Gandalf"
 8 | tipo = "Mago"
 9 | xp = 1500
10 | 
11 | xp = xp + 1500
12 | 
13 | print("Seu personagem é,", nome,"do tipo, ", tipo,"e xp:", xp)


--------------------------------------------------------------------------------
/code-atividades/ex002.py:
--------------------------------------------------------------------------------
 1 | #Crie um programa que realize a soma entre dois números
 2 | #Crie um programa que leia uma variável e retorne diversas informações sobre ela
 3 | 
 4 | x = 50
 5 | y = 30
 6 | 
 7 | a = "Eu sou uma String"
 8 | b = 1.70
 9 | 
10 | print("A soma de x e y: ", x + y)
11 | print("Qual o seu Tipo?", type(a))
12 | print("Qual o seu Tipo?", type(b))
13 | print("Qual o seu Tipo?", type(x))
14 | 


--------------------------------------------------------------------------------
/code-atividades/ex003.py:
--------------------------------------------------------------------------------
 1 | #Crie um programa que calcule o antecessor e sucessor de um número [ OK ]
 2 | #Crie um programa que calcule o dobro, triplo e raiz quadrada de um número [ OK ]
 3 | #Crie um programa que calcule a média aritmética entre dois números
 4 | import math
 5 | 
 6 | num1 = int(input("Digite um número:"))
 7 | num2 = int(input("Digite o segundo número número:"))
 8 | 
 9 | antecessor = num1 -1
10 | sucessor = num1 +1
11 | 
12 | dobro = num1 + num1
13 | triplo = num1 * 3
14 | raiz_quadrada = math.sqrt(num1) #num** 0.5
15 | media = (num1 + num2)/2
16 | 
17 | print(f'O antecessor do número 1 informado é {antecessor} e sucessor o número é {sucessor}. O dobro é {dobro}, o triplo é {triplo} e a sua raiz quadrada é {raiz_quadrada} :')
18 | 
19 | print(f'A média dos números, {media}')


--------------------------------------------------------------------------------
/code-atividades/ex004.py:
--------------------------------------------------------------------------------
 1 | nomeAluno = str(input("Digite o nome do Aluno:"))
 2 | nota1 = int(input("Nota do 1º Bimestre (0 a 100):"))
 3 | nota2 = int(input("Nota do 2º Bimestre (0 a 100):"))
 4 | nota3 = int(input("Nota do 3º Bimestre (0 a 100):"))
 5 | nota4 = int(input("Nota do 4º Bimestre (0 a 100):"))
 6 | 
 7 | peso_bimestal1 = 2
 8 | peso_bimestral2 = 3
 9 | 
10 | calc_media_ponderada = (nota1 * peso_bimestal1 + nota2 * peso_bimestal1 + nota3 * peso_bimestral2 + nota4 * peso_bimestral2) / (peso_bimestal1 * 2 + peso_bimestral2 * 2)
11 | 
12 | media_ponderada_inteira = round(calc_media_ponderada)
13 | 
14 | if media_ponderada_inteira >= 60:
15 |     print(f'\033[1;40;42mO Aluno {nomeAluno} obteve a média de {media_ponderada_inteira} e está aprovado.')
16 | elif 20 <= media_ponderada_inteira <= 59:
17 |     print(f'\033[1;30;43mO Aluno {nomeAluno} obteve a média de {media_ponderada_inteira} e está em recuperação.')
18 | elif media_ponderada_inteira < 20:
19 |     print(f'\033[30;41mO Aluno {nomeAluno} obteve a média de {media_ponderada_inteira} e está reprovado.')
20 | 


--------------------------------------------------------------------------------
/code-atividades/ex005.py:
--------------------------------------------------------------------------------
1 | #Cores no Terminal
2 | print('\033[1;32;40mOlá, Mundo!')
3 | 
4 | 
5 | 


--------------------------------------------------------------------------------
/code-atividades/ex006.py:
--------------------------------------------------------------------------------
 1 | #Estruturas de Repetições
 2 | #Atividades de fixação
 3 | #Desenvolva um programa que faça uma contagem regressiva para o estouro de fogos de artifício,
 4 | #indo de 10 até 0, com uma pausa de 1 segundo entre eles.
 5 | 
 6 | #FOR
 7 | 
 8 | soma = 0
 9 | n1 = float(input('Nota Aluno 1:'))
10 | soma = soma +n1
11 | 
12 | n2 = float(input('Nota Aluno 2:'))
13 | soma = soma +n2
14 | 
15 | n3 = float(input('Nota Aluno 3:'))
16 | soma = soma +n3
17 | 
18 | n4 = float(input('Nota Aluno 4:'))
19 | soma = soma +n4
20 | 
21 | n5 = float(input('Nota Aluno 5:'))
22 | soma = soma +n5
23 | 
24 | n6 = float(input('Nota Aluno 6:'))
25 | soma = soma +n6
26 | 
27 | n7 = float(input('Nota Aluno 7:'))
28 | soma = soma +n7
29 | 
30 | n8 = float(input('Nota Aluno 8:'))
31 | soma = soma +n8
32 | 
33 | media = soma + 8
34 | media = soma/8
35 | print('A media da turma foi {}'.format(round(media)))


--------------------------------------------------------------------------------
/code-atividades/ex007.py:
--------------------------------------------------------------------------------
 1 | #Estruturas de Repetições
 2 | #Atividades de fixação
 3 | #Desenvolva um programa que faça uma contagem regressiva para o estouro de fogos de artifício
 4 | 
 5 | #ATENÇÃO: definimos que o parâmetro start seja igual a 9, stop igual a -1, e step igual -1.
 6 | 
 7 | #FOR II
 8 | 
 9 | soma = 0
10 | for i in range(1, 9):
11 |     nota = float(input('Nota Aluno {} :'.format(i)))
12 |     soma = soma + nota
13 | media = soma/8
14 | print('A media da turma foi {}'.format(round(media)))


--------------------------------------------------------------------------------
/code-atividades/ex008.py:
--------------------------------------------------------------------------------
 1 | #Estruturas de Repetições
 2 | #Atividades de fixação
 3 | #Desenvolva um programa que faça uma contagem regressiva para o estouro de fogos de artifício
 4 | 
 5 | soma = 0
 6 | quantidade = 1
 7 | while quantidade <= 8:
 8 |     nota = float(input('Nota Aluno  {}:'.format(quantidade)))
 9 |     soma = soma + nota
10 |     quantidade = quantidade + 1
11 | media = soma/8
12 | print('A média da turma foi {}'.format(round(media)))


--------------------------------------------------------------------------------
/code-atividades/ex009.py:
--------------------------------------------------------------------------------
 1 | # Desenvolva um programa que realize a validação de dados.
 2 | # O script deve ler o sexo de uma pessoa, mas só aceitar os valores 'M' ou 'F'.
 3 | # Caso esteja errado, peça a digitação novamente até ter um valor válido.
 4 | 
 5 | #Estrutura de Repetição While - Exercícios de Fixação
 6 | 
 7 | cont = 1
 8 | s = 0
 9 | 
10 | while cont <= 6:
11 |     s += cont
12 |     cont += 2
13 | print(s)


--------------------------------------------------------------------------------
/code-atividades/ex010.py:
--------------------------------------------------------------------------------
1 | s = 'rato'
2 | r = ''
3 | 
4 | for item in s:
5 |     r = item.upper() + r
6 | print(r)


--------------------------------------------------------------------------------
/code-atividades/ex011.py:
--------------------------------------------------------------------------------
1 | for time1 in ('Flamengo', 'Fluminence', 'Botafogo', 'Vasco', 'America - RJ'):
2 |     for time2 in ('Flamengo', 'Fluminence', 'Botafogo', 'Vasco', 'America - RJ'):
3 |         if time1 != time2:
4 |             print(time1, 'x', time2)


--------------------------------------------------------------------------------
/code-atividades/ex012.py:
--------------------------------------------------------------------------------
1 | i = 1
2 | a = 5
3 | while i <= 3:
4 |     a = a*2 - 3
5 |     i += 1
6 | print(a)


--------------------------------------------------------------------------------
/code-atividades/ex013.py:
--------------------------------------------------------------------------------
1 | numero = 5
2 | while numero <= 5:
3 |     if numero < 5:
4 |         numero += numero
5 |     print(numero)


--------------------------------------------------------------------------------
/code-atividades/ex014.py:
--------------------------------------------------------------------------------
 1 | while True:
 2 |     numero = int(input("Informe um número inteiro maior que zero: "))
 3 |     if numero > 1:
 4 |         break
 5 | 
 6 | divisores = 0
 7 | for i in range(1, numero + 1):
 8 |     if numero % i == 0:
 9 |         divisores += 1
10 | 
11 | print(f"O número {numero} é primo" if divisores == 2 else f"O número {numero} tem {divisores} divisores, portanto não é primo")
12 | 


--------------------------------------------------------------------------------
/code-atividades/ex015.py:
--------------------------------------------------------------------------------
1 | i = 1
2 | a = 5
3 | while i <= 3:
4 |     a = a*2 -3
5 |     i += 1
6 | print(a)


--------------------------------------------------------------------------------
/code-atividades/ex016.py:
--------------------------------------------------------------------------------
 1 | #Utilizando a linguagem Python, simule um caixa eletrônico que pergunte o valor a ser sacado e qual a cédula
 2 | # de maior valor que o cliente deseja receber, em seguida retorne o valor retirado
 3 | # e o número de todas as cédulas utilizadas na composição do saque.
 4 | #Para os critérios de avaliação, o programa deverá:
 5 |     #Solicitar o valor (inteiro) a ser sacado;
 6 |     #Garantir que esse valor seja maior ou igual a 1 real;
 7 |     #Solicitar o valor máximo de cédula que o cliente deseja receber no saque (100, 50, 20, 10, 5, 2 e 1);
 8 |     #Garantir que valor de cédula informado seja válido, além de ser igual ou superior ao valor do saque;
 9 |     #Calcular a quantidade de cédulas (de cada tipo) utilizadas para a composição do valor a ser sacado;
10 |     #O cálculo dever seguir a seguinte lógica: Utilizar a cédula (de maior valor informada pelo cliente) até que não seja mais possível, e então buscar a cédula imediatamente inferior e repetir o processo até que a composição do valor total seja satisfeita.
11 |     #Informar o valor sacado e a quantidade de cédulas (de cada tipo) utlizadas.
12 | 
13 | #ALGORITMO DE SOLUÇÃO:
14 | saque = int(input("Qual o valor que deseja sacar? "))
15 | while saque < 1:
16 |     print("O valor informado deve ser maior ou igual a 1 Real!")
17 |     saque = int(input("Qual o valor que deseja sacar? "))
18 | 
19 | cedulas_aceitaveis = [1, 2, 5, 10, 20, 50, 100]
20 | 
21 | cedula = int(input("Valor máximo das cédulas (1 - 2 - 5 - 10 - 20 - 50 - 100)? "))
22 | while cedula not in cedulas_aceitaveis:
23 |     print("A cédula informada é inválida, informe um novo valor de cédula.")
24 |     cedula = int(input("Valor máximo das cédulas (1 - 2 - 5 - 10 - 20 - 50 - 100)? "))
25 | 
26 | total = saque
27 | cedulas_utilizadas = []
28 | 
29 | print(f"O valor sacado foi de R$ {saque}")
30 | print("Cédulas:")
31 | 
32 | while total > 0:
33 |     if total >= cedula:
34 |         quantidade_cedulas = total // cedula
35 |         total -= quantidade_cedulas * cedula
36 |         cedulas_utilizadas.append((cedula, quantidade_cedulas))
37 | 
38 |     if cedula == 100:
39 |         cedula = 50
40 |     elif cedula == 50:
41 |         cedula = 20
42 |     elif cedula == 20:
43 |         cedula = 10
44 |     elif cedula == 10:
45 |         cedula = 5
46 |     elif cedula == 5:
47 |         cedula = 2
48 |     elif cedula == 2:
49 |         cedula = 1
50 | 
51 | for cedula, quantidade in cedulas_utilizadas:
52 |     print(f"{quantidade} de R$ {cedula}")
53 | 


--------------------------------------------------------------------------------
/code-atividades/ex017.py:
--------------------------------------------------------------------------------
 1 | # Aula de Estrutura de Dados
 2 | # Listas, Tulpas, Dicionarios
 3 | 
 4 | num2 = (2, 8, 6, 9, 10 ) #Tulpa
 5 | num = [2, 8, 6, 9, 10] #Lista
 6 | num[2] = 3 #Substituiu o 6 pelo 3
 7 | num.append(7) #Adicionou um elemento [7] a lista
 8 | num.sort() #Colocou em ordem sort e o reverse=True inverteu a ordem(crescente-> decrescente)
 9 | num.insert(2, 0) #Inserirr valores, valor 0 na posição 2 [ao aldo do 3]
10 | #num.pop(2) #Apagou o elemento da posição 2 [o zero que havia adicionado]
11 | if 4 in num:
12 |     num.remove(4)
13 | else:
14 |     print('Não achei o número 4')
15 | print(num)
16 | 
17 | print(f'Essa lista tem {len(num)} elementos') #Imprime o total de elementos dentro da lista


--------------------------------------------------------------------------------
/code-atividades/ex018.py:
--------------------------------------------------------------------------------
 1 | valores = []
 2 | valores.append(8)
 3 | valores.append(16)
 4 | valores.append(32)
 5 | 
 6 | #for v in valores:
 7 |     #print(f'{v}...')
 8 | 
 9 | for c, v in enumerate(valores):
10 |     print(f'Na posição {c} encontrei o valor {v}')
11 | print(f'Cheguei no fim da lista!')


--------------------------------------------------------------------------------
/code-atividades/ex019.py:
--------------------------------------------------------------------------------
1 | valores = list()
2 | for cont in range (0, 5):
3 |     valores.append(int(input('Digite um valor:')))
4 | 
5 | for c, v in enumerate(valores):
6 |     print(f'Na posição {c} encontrei o valor {v}!')
7 | print('Cheguei no final da lista.')


--------------------------------------------------------------------------------
/code-atividades/ex039.py:
--------------------------------------------------------------------------------
1 | #Coletando entrada do usuário
2 | 
3 | nome = input('Qual é o seu nome?')
4 | print(f"Olá, {nome}!")
5 | 
6 | #Saída formatada
7 | 
8 | idade = 31
9 | print(f"Eu tenho {idade} anos.")


--------------------------------------------------------------------------------
/code-atividades/ex040.py:
--------------------------------------------------------------------------------
1 | #Escrevendo em um arquivo
2 | 
3 | nome = input('Qual é o seu nome?')
4 | print(f"Olá, {nome}!")
5 | 
6 | 


--------------------------------------------------------------------------------
/code-atividades/ex042.py:
--------------------------------------------------------------------------------
1 | import math
2 | num = int(input("Digite um número:"))
3 | print(f"O fatorial {num} é", math.factorial(num))


--------------------------------------------------------------------------------
/code-atividades/ex043.py:
--------------------------------------------------------------------------------
1 | numero = int(input("Digite um número:"))
2 | print(f"O fatorial desse número é", math.factorial(numero))


--------------------------------------------------------------------------------
/code-atividades/ex044.py:
--------------------------------------------------------------------------------
1 | def pegaMes(m):
2 | 
3 |     if m < 1 or m > 12:
4 |         raise ValueError("Mês inválido!")
5 |     print(m)
6 | pegaMes(int(input("Digite um mês:")))
7 | 


--------------------------------------------------------------------------------
/code-atividades/ex045.py:
--------------------------------------------------------------------------------
1 | def externo(a, b):
2 |     def interno(c, d):
3 |         return c + d
4 |     return interno(a, b)
5 | 
6 | res = externo(5, 10)
7 | 
8 | print(res)


--------------------------------------------------------------------------------
/code-atividades/ex20.py:
--------------------------------------------------------------------------------
1 | a = [2, 3, 5, 6]
2 | b = a[:] #copia de a dentro de b
3 | b[2] = 8
4 | print(f'Lista A: {a}')
5 | print(f'Lista A: {b}')


--------------------------------------------------------------------------------
/code-atividades/ex21.py:
--------------------------------------------------------------------------------
1 | l1 = [[1, 2], [3, 4], [5, 6]]
2 | l2 = []
3 | for i in l1:
4 |     for j in i:
5 |         l2.append(j)
6 | print(l2)


--------------------------------------------------------------------------------
/code-atividades/ex22.py:
--------------------------------------------------------------------------------
1 | l1 = [2, 3, 5, 6]
2 | l2 = l1.append(8)
3 | print(l1)


--------------------------------------------------------------------------------
/code-atividades/ex23.py:
--------------------------------------------------------------------------------
1 | lista = [1, 2, 3, 4, 5]
2 | soma = 0
3 | for i in lista:
4 |     if i % 2 == 0:
5 |         soma += i
6 |     else:
7 |         soma -= i
8 | print(soma)


--------------------------------------------------------------------------------
/code-atividades/ex24.py:
--------------------------------------------------------------------------------
1 | frutas = {'maçãs': 1, 'bananas': 2, 'peras': 3, 'laranjas': 4 }
2 | frutas['uvas'] = 15
3 | 
4 | print(frutas)


--------------------------------------------------------------------------------
/code-atividades/ex25.py:
--------------------------------------------------------------------------------
1 | dicionario = {'a': 1, 'b': 2, 'c': 3}
2 | soma = 0
3 | for chave, valor in dicionario.items():
4 |     if valor % 2 == 0:
5 |         soma += valor
6 |     else:
7 |         soma -= valor
8 | print(soma)


--------------------------------------------------------------------------------
/code-atividades/ex26.py:
--------------------------------------------------------------------------------
1 | l1 = [1, 2, 3, 4, 5]
2 | l2 = l1[1:4]
3 | print(l2)


--------------------------------------------------------------------------------
/code-atividades/ex27.py:
--------------------------------------------------------------------------------
 1 | brasil = (('Alisson', 1), ('Dini Alves', 2), ('Miranda', 3), ('Rodrigo Caio', 4), ('Casemiro', 5), ('Felipe Luis', 6), ('Taison', 7), ('R. Augusto', 8), ('Gabriel Jesus', 9), ('Neymar', 10), ('P. Coutinho', 11), ('Marcelo', 12), ('Marquinhos', 13), ('T. Silva', 14), ('Paulinho', 15))
 2 | while True:
 3 |     numero = int(input("Digite um número entre 1 e 15: "))
 4 |     if 1 <= numero <= 15:
 5 |         jogador, brasil = brasil[numero - 1]
 6 |         print(f"O jogador {jogador} vestiu a camisa {brasil} nesta convocação.")
 7 |         break
 8 |     else:
 9 |         print("Número fora do intervalo.", end=' ')
10 | 


--------------------------------------------------------------------------------
/code-atividades/ex28.py:
--------------------------------------------------------------------------------
 1 | while True:
 2 |     produtos = []
 3 | 
 4 |     print('=' * 40)
 5 |     print("Supermercado Tabajara".center(40))
 6 |     print('=' * 40)
 7 | 
 8 |     produto_numero = 1
 9 | 
10 |     while True:
11 |         info_produto = {}
12 | 
13 |         info_produto["nome"] = input(f"Produto {produto_numero}: ")
14 |         info_produto["valor"] = float(input("Valor: "))
15 |         info_produto["quantidade"] = int(input("Quantidade: "))
16 |         info_produto["numero"] = produto_numero
17 |         info_produto["total"] = info_produto["valor"] * info_produto["quantidade"]
18 | 
19 |         produtos.append(info_produto)
20 | 
21 |         resposta = input("Quer inserir outro produto? S/N: ")
22 |         if resposta.lower() != "s":
23 |             break
24 | 
25 |         produto_numero += 1
26 | 
27 |     print('=' * 40)
28 |     print("Confirmação e Exclusão".center(40))
29 |     print('=' * 40)
30 | 
31 |     while True:
32 |         retirar = input("Quer retirar algum produto? S/N: ")
33 |         if retirar.lower() == "n":
34 |             break
35 |         elif retirar.lower() != "s":
36 |             continue
37 | 
38 |         numero_produto = int(input("Qual o número do produto? "))
39 | 
40 |         encontrado = False
41 |         for produto in produtos:
42 |             if produto["numero"] == numero_produto:
43 |                 produtos.remove(produto)
44 |                 encontrado = True
45 |                 print(f"Item {produto['nome']} excluído!")
46 |                 break
47 | 
48 |         if not encontrado:
49 |             print("Item não encontrado")
50 | 
51 |     print('=' * 40)
52 |     print("Resumo das Compras".center(40))
53 |     print('=' * 40)
54 | 
55 |     total_compras = 0
56 | 
57 |     print(f"{'Nº':<5}{'Produto':<10}{'Valor':<10}{'Qnt':<10}{'Total':<10}")
58 |     for produto in produtos:
59 |         print(f"{produto['numero']:<5}{produto['nome']:<10}{produto['valor']:<10.2f}{produto['quantidade']:<10}{produto['total']:<10.2f}")
60 |         total_compras += produto["total"]
61 | 
62 |     print(f"{'--> ':>35}{total_compras:.2f}")
63 | 
64 |     resposta_final = input("Deseja realizar outra compra? S/N: ")
65 |     if resposta_final.lower() != "s":
66 |         break


--------------------------------------------------------------------------------
/code-atividades/ex29.py:
--------------------------------------------------------------------------------
 1 | print('=' * 40)
 2 | print('{:^40}'.format('Supermercado Tabajara'))
 3 | print('=' * 40)
 4 | info_produto = dict()
 5 | produtos = list()
 6 | 
 7 | while True:
 8 | 
 9 |     numero = len(produtos) + 1
10 |     info_produto['numero'] = numero
11 |     info_produto['nome'] = str(input(f'Produto {numero}: '))
12 |     info_produto['valor'] = float(input('Valor: '))
13 |     info_produto['qtd'] = int(input('Quantidade: '))
14 |     info_produto['total'] = (info_produto['valor'] * info_produto['qtd'])
15 |     produtos.append(info_produto.copy())
16 |     continuar = input('Quer inserir outro produto?S/N ')
17 | 
18 |     if continuar.lower() == 'n':
19 |         break
20 |     elif continuar.lower() != 's':
21 |         print('Digite novamente! ', end="")
22 |         continuar = input('Quer inserir outro produto?S/N ')
23 | 
24 | 
25 | print('=' * 40)
26 | print('{:^40}'.format('Confirmação e Exclusão'))
27 | print('=' * 40)
28 | 
29 | while True:
30 | 
31 |     retirar = input('Quer retirar algum produto?S/N ')
32 | 
33 |     if retirar.lower() == 'n':
34 |         break
35 |     elif retirar.lower() != 's':
36 |         retirar = input('Quer retirar algum produto?S/N ')
37 | 
38 |     num_produto = int(input("Qual o número do produto? "))
39 |     produto_encontrado = None
40 | 
41 |     for produto in produtos:
42 |         if produto["numero"] == num_produto:
43 |             produto_encontrado = produto
44 |             produtos.remove(produto)
45 |             print(f"Item {produto['nome']} excluído!")
46 |             break
47 | 
48 |     if produto_encontrado is None:
49 |         print("Item não encontrado")
50 | 
51 | print('=' * 50)
52 | print('{:^50}'.format('Resumo das Compras'))
53 | print('=' * 50)
54 | total_compras = 0
55 | print("{:<5} {:<15} {:<10} {:<10} {:<10}".format("Nº", "Produto", "Valor", "Qnt", "Total"))
56 | 
57 | for produto in produtos:
58 |     numero, nome, valor, qtd, total = produto.values()
59 |     total_compras += total
60 |     print("{:<5} {:<15} {:<10.2f} {:<10} {:<10.2f}".format(numero, nome, valor, qtd, total))
61 | 
62 | print("\nTotal: {:>25.2f}".format(total_compras))


--------------------------------------------------------------------------------
/code-atividades/ex30.py:
--------------------------------------------------------------------------------
1 | #VARIÁVEL LOCAL
2 | def funcao():
3 |     variavel_local = "Estou dentro da funcao"
4 |     print(variavel_local) #ISSO CAUSARÁ UM ERRO
5 | 
6 | funcao()


--------------------------------------------------------------------------------
/code-atividades/ex31.py:
--------------------------------------------------------------------------------
1 | #VARIAVEL GLOBAL
2 | 
3 | variavel_local = "Estou fora da funcao"
4 | def funcao():
5 |     global variavel_local
6 |     print(variavel_local)
7 | 
8 | funcao() #Vai imprimir: Estou fora da funcao


--------------------------------------------------------------------------------
/code-atividades/ex32.py:
--------------------------------------------------------------------------------
1 | #FUNÇÕES
2 | 
3 | #Definindo e Chamando a função
4 | 
5 | def saudacao():
6 |     print("Olá, Mundo!")
7 | saudacao()


--------------------------------------------------------------------------------
/code-atividades/ex33.py:
--------------------------------------------------------------------------------
1 | #Função com parametros
2 | def soma(a, b):
3 |     return a + b
4 | 
5 | resultado = soma(3, 5)
6 | print(resultado)


--------------------------------------------------------------------------------
/code-atividades/ex34.py:
--------------------------------------------------------------------------------
1 | #Passagem por valor
2 | def modificar(x):
3 |     x = 5
4 |     print("Valor dentro da função:", x)
5 | 
6 | num  = 10
7 | modificar(num)
8 | print("valor fora da função", num)


--------------------------------------------------------------------------------
/code-atividades/ex35.py:
--------------------------------------------------------------------------------
1 | #Passagem por referência
2 | 
3 | def adicionar_elemento(lista):
4 |     lista.append(4)
5 |     print("Lista dentro da função:", lista)
6 | 
7 | minha_lista = [1, 2, 3]
8 | adicionar_elemento(minha_lista)
9 | print("Lista fora da função:", minha_lista)


--------------------------------------------------------------------------------
/code-atividades/ex36.py:
--------------------------------------------------------------------------------
1 | #Bibliotecas
2 | import datetime
3 | 
4 | hoje = datetime.date.today()
5 | print("A data de hoje é: ", hoje)


--------------------------------------------------------------------------------
/code-atividades/ex37.py:
--------------------------------------------------------------------------------
1 | import requests
2 | 
3 | resposta = requests.get('https://www.google.com.br')
4 | print(resposta.status_code)


--------------------------------------------------------------------------------
/code-atividades/ex38.py:
--------------------------------------------------------------------------------
 1 | from setuptools import setup, find_packages
 2 | 
 3 | setup (
 4 |     name="minha_biblioteca",
 5 |     version="0.1",
 6 |     packages=find_packages(),
 7 |     install_requires=[
 8 |         #Dependencias da sua biblioteca (se holver)
 9 | 
10 | #Com a biblioteca organizada desta forma,você pode facilmente distribuí-la usando
11 | #ferramentas como pip ou compartilhá-la no PyPI para que outros possam usar.
12 | 
13 |     ],
14 | )


--------------------------------------------------------------------------------
/code-atividades/ex41.py:
--------------------------------------------------------------------------------
 1 | #ATV
 2 | def printMax(a, b):
 3 |     if a > b:
 4 |         print(a, 'é o maior')
 5 |     elif a==b:
 6 |         print(a, 'é igual a', b)
 7 |     else:
 8 |         print(b, 'é o maior')
 9 | 
10 | printMax(3, 4)


--------------------------------------------------------------------------------
/code-atividades/ex46.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | def saqueDinheiro(valor):
 3 |     notas_disponiveis = [50, 20, 10]
 4 | 
 5 |     if valor < 10 or valor > 600:
 6 |         print("Valor inválido. O valor deve estar entre R$ 10,00 e R$ 600,00.")
 7 |         return
 8 | 
 9 |     if valor % 10 != 0:
10 |         print("Impossível sacar esse valor nesse caixa eletrônico com as notas disponíveis!")
11 |         return
12 | 
13 |     print("IMPRIMINDO...")
14 |     time.sleep(1)
15 |     for nota in notas_disponiveis:
16 |         quantidade_notas = valor // nota
17 |         valor %= nota
18 |         time.sleep(1)  # Simulando o processo de contagem e distribuição de notas
19 |         print(f"{quantidade_notas} nota(s) de R$ {nota},00")
20 | 
21 | valor_saque = int(input("Nesse caixa você pode sacar até R$600,00 -Notas disponíveis: R$ 10,00, R$20, R$20 e R$50- "))
22 | print('Valor do saque R$', valor_saque)
23 | saqueDinheiro(valor_saque)
24 | 


--------------------------------------------------------------------------------
/code-atividades/ex48.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/allineantunnes/estudos-logica-com-python/ec7089fc48cdca33bf63ad6a9460f57b21f7f481/code-atividades/ex48.py


--------------------------------------------------------------------------------
/code-atividades/main.py:
--------------------------------------------------------------------------------
 1 | import calcArea
 2 | 
 3 | def main():
 4 |     print("Cálculo das áreas de figuras geométricas:")
 5 |     print("1. Círculo")
 6 |     print("2. Triângulo")
 7 |     print("3. Retângulo")
 8 | 
 9 |     try:
10 |         opcao = int(input("Qual figura deseja calcular a área? "))
11 | 
12 |         if opcao < 1 or opcao > 3:
13 |             print("ERRO! Essa não é uma opção válida!")
14 |         else:
15 |             if opcao == 1:
16 |                 raio = float(input("Digite o raio do círculo: "))
17 |                 area = calcArea.calcular_area_circulo(raio)
18 |                 print(f"A área do círculo é: {area:.2f}")
19 |             elif opcao == 2:
20 |                 base = float(input("Digite a base do triângulo: "))
21 |                 altura = float(input("Digite a altura do triângulo: "))
22 |                 area = calcArea.calcular_area_triangulo(base, altura)
23 |                 print(f"A área do triângulo é: {area:.2f}")
24 |             elif opcao == 3:
25 |                 largura = float(input("Digite a largura do retângulo: "))
26 |                 altura = float(input("Digite a altura do retângulo: "))
27 |                 area = calcArea.calcular_area_retangulo(largura, altura)
28 |                 print(f"A área do retângulo é: {area:.2f}")
29 |     except ValueError:
30 |         print("ERRO! Essa não é uma opção válida!")
31 | 
32 | 
33 | if __name__ == "__main__":
34 |     main()
35 | 


--------------------------------------------------------------------------------
/novos-codigos/ex01.py:
--------------------------------------------------------------------------------
1 | # Neste algoritmo, crie uma variável que armazene uma string e uma lista que armazena várias strings.
2 | 


--------------------------------------------------------------------------------