├── APC.txt ├── Atv ├── Calc_Case.py ├── Calc_Case_Mod.py ├── Calc_If.py ├── Calc_Loop.py ├── Mani_Vet.py └── Matrizes.py ├── Aula 15 ├── Ex1.py └── Ex2.py ├── Aula 16 ├── Ex3.py └── Ex4.py ├── Aula 17 ├── Ex5.py └── Ex6.py ├── Aula 18 ├── Ex7.py └── Ex8.py ├── Aula 19 ├── Ex10.py └── Ex9.py ├── Aula 20 ├── Ex11.py └── Ex12.py ├── Aula 21 ├── Ex13.py └── Ex14.py ├── Aula 22 ├── Ex15.py └── Ex16.py ├── Aula 23 ├── Ex17.py └── Ex18.py ├── Aula 24 ├── Ex19.py └── Ex20.py ├── Aula 25 ├── Ex21.py └── Ex22.py ├── Aula 26 ├── Ex23.py └── Ex24.py ├── Aula 27 ├── Ex25.py └── Ex26.py ├── Aula 28 ├── Ex27.py └── Ex28.py ├── Jogos ├── Adivinhacao.py ├── JogoDaVelha.py └── Termoo.py ├── README.md └── Rev ├── 1.py ├── 2.py ├── 3.py ├── 4.py ├── 5.py └── Revisao.py /APC.txt: -------------------------------------------------------------------------------- 1 | 1. (1,0) 2 | Como podemos criar uma matriz em Python usando listas dentro de listas? Mostre um exemplo de uma matriz 3x3. 3 | Qual é uma vantagem e uma desvantagem desse jeito? 4 | 5 | 2. (1,0) 6 | O que são as diagonais principal e secundária de uma matriz quadrada? 7 | Escreva um pseudocódigo que calcule a diferença entre a soma das duas diagonais. 8 | 9 | 3. (1,0) 10 | Como somar todos os elementos de uma lista em Python? 11 | Escreva um exemplo simples com uma lista de 5 números. 12 | 13 | 4. (1,0) 14 | O que significa modularizar um programa? 15 | Cite duas vantagens de usar funções separadas no código. 16 | 17 | 5. (1,0) 18 | Como acessar e modificar um valor específico em uma matriz? 19 | Escreva um pseudocódigo simples que altera um elemento específico em uma matriz e depois imprime a matriz atualizada. 20 | 21 | 6. (1,0) 22 | Qual a diferença entre if-elif e match-case no Python? 23 | Quando é melhor usar um ou outro? 24 | 25 | 7. (1,0) 26 | O que é list comprehension (Compreensão de listas)? 27 | Por que ela é útil para trabalhar com listas? 28 | 29 | 8. (1,0) 30 | O que é tratamento de erro? 31 | Para que serve o bloco try-except? Dê um exemplo simples. 32 | 33 | 9. (1,0) 34 | Como encontrar o valor mínimo e máximo de cada linha de uma matriz em Python? 35 | Dê um exemplo simples feito "na mão", sem usar funções prontas como min() ou max(). 36 | 37 | 10. (1,0) 38 | Por que é importante verificar o que o usuário digita em um programa? 39 | Dê dois exemplos de validações comuns. -------------------------------------------------------------------------------- /Atv/Calc_Case.py: -------------------------------------------------------------------------------- 1 | # Implemente uma calculadora simples utilizando a estrutura match-case do Python 2 | # 3.10+ com as seguintes especificações: 3 | 4 | # 1. O programa deve apresentar um menu com 4 operações básicas: 5 | # - Soma 6 | # - Subtração 7 | # - Multiplicação 8 | # - Divisão 9 | # 2. O usuário deve poder escolher a operação através de números (1-4) 10 | # 3. O programa deve solicitar dois números para realizar a operação 11 | # 4. Implemente tratamento de erros para: 12 | # - Entradas não numéricas 13 | # - Divisão por zero 14 | # - Opções de menu inválidas 15 | # 5. Use f-strings para formatar a saída dos resultados 16 | 17 | 18 | def calculadora(): 19 | print("Calculadora Simples") 20 | print("1. Soma") 21 | print("2. Subtração") 22 | print("3. Multiplicação") 23 | print("4. Divisão") 24 | 25 | try: 26 | opcao = int(input("Escolha a operação (1-4): ")) 27 | if opcao < 1 or opcao > 4: 28 | print("Operação inválida! Escolha entre 1 e 4.") 29 | return 30 | except ValueError: 31 | print("Entrada inválida! Digite um número.") 32 | return 33 | 34 | try: 35 | num1 = float(input("Digite o primeiro número: ")) 36 | num2 =float(input("Digite o segundo número: ")) 37 | except ValueError: 38 | print("Entrada inválida! Digite apenas números .") 39 | return 40 | 41 | match opcao: 42 | case 1: 43 | resultado = num1 + num2 44 | print(f"Resultado: {num1} + {num2} = {resultado}") 45 | 46 | case 2: 47 | resultado = num1 - num2 48 | print(f"Resultado: {num1} - {num2} = {resultado}") 49 | 50 | case 3: 51 | resultado = num1 * num2 52 | print(f"Resultado: {num1} * {num2} = {resultado}") 53 | 54 | case 4: 55 | if num2 == 0: 56 | print("Erro: Divisão por zero não é permitida!") 57 | return 58 | 59 | resultado = num1 / num2 60 | print(f"Resultado: {num1} / {num2} = {resultado}") 61 | 62 | case _: 63 | print("Operação inválida!") 64 | 65 | if __name__ == "__main__": 66 | calculadora() -------------------------------------------------------------------------------- /Atv/Calc_Case_Mod.py: -------------------------------------------------------------------------------- 1 | def exibir_menu(): 2 | """Exibe o menu de opções da calculadora.""" 3 | print("Calculadora Simples") 4 | print("1. Soma") 5 | print("2. Subtração") 6 | print("3. Multiplicação") 7 | print("4. Divisão") 8 | print("5. Raiz Quadrada") 9 | print("6. Potência") 10 | print("0. Sair") 11 | 12 | 13 | def obter_operacao(): 14 | """Obtém a escolha de operação do usuário com tratamento de erro.""" 15 | try: 16 | opcao = int(input("Escolha a operação (0-6): ")) 17 | if opcao < 0 or opcao > 6: 18 | print("Operação inválida! Escolha entre 0 e 6.") 19 | return None 20 | return opcao 21 | except ValueError: 22 | print("Entrada inválida! Digite um número.") 23 | return None 24 | 25 | 26 | def obter_numeros(): 27 | """Obtém os números de entrada com tratamento de erro.""" 28 | try: 29 | num1 = float(input("Digite o primeiro número: ")) 30 | num2 = float(input("Digite o segundo número: ")) 31 | return num1, num2 32 | except ValueError: 33 | print("Entrada inválida! Digite apenas números.") 34 | return None, None 35 | 36 | 37 | def soma(a, b): 38 | """Realiza a operação de soma.""" 39 | return a + b 40 | 41 | 42 | def subtracao(a, b): 43 | """Realiza a operação de subtração.""" 44 | return a - b 45 | 46 | 47 | def multiplicacao(a, b): 48 | """Realiza a operação de multiplicação.""" 49 | return a * b 50 | 51 | 52 | def divisao(a, b): 53 | """Realiza a operação de divisão com verificação de divisão por zero.""" 54 | if b == 0: 55 | print("Erro: Divisão por zero não é permitida!") 56 | return None 57 | return a / b 58 | 59 | 60 | def raiz(a): 61 | """Calcula a raiz quadrada de um número.""" 62 | if a < 0: 63 | print("Erro: Não é possível calcular a raiz de um número negativo!") 64 | return None 65 | return a ** 0.5 66 | 67 | 68 | def potencia(a, b): 69 | """Calcula a potência de um número elevado a outro.""" 70 | return a ** b 71 | 72 | 73 | def exibir_resultado(a, b, operacao, resultado): 74 | """Exibe o resultado formatado da operação.""" 75 | operadores = { 76 | 1: '+', 77 | 2: '-', 78 | 3: '*', 79 | 4: '/', 80 | 5: '√', 81 | 6: '^' 82 | } 83 | operador = operadores.get(operacao) 84 | if operacao == 5: # Raiz quadrada 85 | print(f"Resultado: √{a} = {resultado}") 86 | else: 87 | print(f"Resultado: {a} {operador} {b} = {resultado}") 88 | 89 | 90 | def obter_entrada_para_operacao(opcao): 91 | """Obtém os números necessários para a operação escolhida.""" 92 | if opcao == 5: # Raiz quadrada só precisa de um número 93 | try: 94 | num1 = float(input("Digite o número para cálculo da raiz: ")) 95 | num2 = None 96 | except ValueError: 97 | print("Entrada inválida! Digite apenas números.") 98 | return None, None 99 | else: 100 | num1, num2 = obter_numeros() 101 | return num1, num2 102 | 103 | def executar_operacao(opcao, num1, num2): 104 | """Executa a operação escolhida.""" 105 | match opcao: 106 | case 1: 107 | return soma(num1, num2) 108 | case 2: 109 | return subtracao(num1, num2) 110 | case 3: 111 | return multiplicacao(num1, num2) 112 | case 4: 113 | return divisao(num1, num2) 114 | case 5: 115 | return raiz(num1) 116 | case 6: 117 | return potencia(num1, num2) 118 | return None 119 | 120 | def calculadora(): 121 | """Função principal da calculadora.""" 122 | while True: 123 | exibir_menu() 124 | 125 | opcao = obter_operacao() 126 | if opcao is None: 127 | continue 128 | if opcao == 0: 129 | print("Encerrando calculadora...") 130 | break 131 | 132 | num1, num2 = obter_entrada_para_operacao(opcao) 133 | if num1 is None or (opcao != 5 and num2 is None): 134 | continue 135 | 136 | resultado = executar_operacao(opcao, num1, num2) 137 | 138 | if resultado is not None: 139 | exibir_resultado(num1, num2, opcao, resultado) 140 | print() # Linha em branco para separar as operações 141 | 142 | 143 | if __name__ == "__main__": 144 | calculadora() 145 | -------------------------------------------------------------------------------- /Atv/Calc_If.py: -------------------------------------------------------------------------------- 1 | # Desenvolva uma calculadora utilizando estruturas condicionais if-elif com os seguintes requisitos: 2 | 3 | # 1. O programa deve oferecer as mesmas 4 operações básicas: 4 | # - Soma 5 | # - Subtração 6 | # - Multiplicação 7 | # - Divisão 8 | # 2. Utilize if-elif para controle do fluxo do programa 9 | # 3. Implemente validações para: 10 | # - Entradas numéricas válidas 11 | # - Prevenção de divisão por zero 12 | # - Opções de menu dentro do intervalo permitido 13 | # 4. Formate a saída usando f-strings para mostrar a operação completa e seu resultado 14 | 15 | 16 | def calculadora(): 17 | print("=== Calculadora Simples ===") 18 | print("1. Soma") 19 | print("2. Subtração") 20 | print("3. Multiplicação") 21 | print("4. Divisão") 22 | 23 | # Input da operação 24 | try: 25 | opcao = int(input("Escolha a operação (1-4): ")) 26 | if opcao < 1 or opcao > 4: 27 | print("Operação inválida! Escolha entre 1 e 4.") 28 | return 29 | except ValueError: 30 | print("Entrada inválida! Digite um número.") 31 | return 32 | 33 | # Input dos números 34 | try: 35 | num1 = float(input("Digite o primeiro número: ")) 36 | num2 = float(input("Digite o segundo número: ")) 37 | except ValueError: 38 | print("Entrada inválida! Digite apenas números.") 39 | return 40 | 41 | # Operações 42 | if opcao == 1: 43 | resultado = num1 + num2 44 | print(f"Resultado: {num1} + {num2} = {resultado}") 45 | 46 | elif opcao == 2: 47 | resultado = num1 - num2 48 | print(f"Resultado: {num1} - {num2} = {resultado}") 49 | 50 | elif opcao == 3: 51 | resultado = num1 * num2 52 | print(f"Resultado: {num1} * {num2} = {resultado}") 53 | 54 | elif opcao == 4: 55 | if num2 == 0: 56 | print("Erro: Divisão por zero não é permitida!") 57 | return 58 | resultado = num1 / num2 59 | print(f"Resultado: {num1} / {num2} = {resultado}") 60 | 61 | 62 | # Executar a calculadora 63 | if __name__ == "__main__": 64 | calculadora() 65 | -------------------------------------------------------------------------------- /Atv/Calc_Loop.py: -------------------------------------------------------------------------------- 1 | # Crie uma calculadora que execute em loop contínuo com as seguintes características: 2 | 3 | # 1. O programa deve apresentar 5 opções: 4 | # - Soma 5 | # - Subtração 6 | # - Multiplicação 7 | # - Divisão 8 | # - Sair 9 | # 2. O programa deve continuar executando até que o usuário escolha sair 10 | # 3. Utilize a estrutura match-case para processar as escolhas 11 | # 4. Implemente tratamento de erros para todas as entradas 12 | # 5. Adicione a opção de sair do programa (opção 5) 13 | # 6. O programa deve limpar a tela ou mostrar o menu novamente após cada operação 14 | # 7. Use f-strings para mostrar os resultados das operações 15 | 16 | 17 | def calculadora(): 18 | print("=== Calculadora Simples ===") 19 | print("1. Soma") 20 | print("2. Subtração") 21 | print("3. Multiplicação") 22 | print("4. Divisão") 23 | print("5. Sair") 24 | 25 | # Input da operação 26 | try: 27 | opcao = int(input("Escolha a operação (1-5): ")) 28 | if opcao < 1 or opcao > 5: 29 | print("Operação inválida! Escolha entre 1 e 5.") 30 | return False 31 | if opcao == 5: 32 | print("Programa encerrado!") 33 | return True 34 | except ValueError: 35 | print("Entrada inválida! Digite um número.") 36 | return False 37 | 38 | # Input dos números 39 | try: 40 | num1 = float(input("Digite o primeiro número: ")) 41 | num2 = float(input("Digite o segundo número: ")) 42 | except ValueError: 43 | print("Entrada inválida! Digite apenas números.") 44 | return False 45 | 46 | # Operações usando match case 47 | match opcao: 48 | case 1: 49 | resultado = num1 + num2 50 | print(f"Resultado: {num1} + {num2} = {resultado}") 51 | 52 | case 2: 53 | resultado = num1 - num2 54 | print(f"Resultado: {num1} - {num2} = {resultado}") 55 | 56 | case 3: 57 | resultado = num1 * num2 58 | print(f"Resultado: {num1} * {num2} = {resultado}") 59 | 60 | case 4: 61 | if num2 == 0: 62 | print("Erro: Divisão por zero não é permitida!") 63 | return False 64 | resultado = num1 / num2 65 | print(f"Resultado: {num1} / {num2} = {resultado}") 66 | 67 | case _: 68 | print("Operação inválida!") 69 | 70 | return False 71 | 72 | 73 | # Executar a calculadora 74 | if __name__ == "__main__": 75 | sair = False 76 | while not sair: 77 | sair = calculadora() 78 | -------------------------------------------------------------------------------- /Atv/Mani_Vet.py: -------------------------------------------------------------------------------- 1 | # Desenvolva um programa que permita manipular um vetor de números inteiros com as seguintes funcionalidades: 2 | 3 | # 1. O usuário deve poder especificar o tamanho do vetor e preencher seus valores 4 | # 2. O programa deve oferecer um menu com as seguintes operações: 5 | # - Ordenar o vetor(usando Bubble Sort) 6 | # - Encontrar o valor máximo e mínimo 7 | # - Dobrar todos os elementos 8 | # - Inverter a ordem dos elementos 9 | # - Visualizar o vetor atual 10 | # - Restaurar o vetor ao estado original 11 | # 3. Após cada operação que modifica o vetor, o usuário deve poder escolher se deseja manter as alterações 12 | # 4. O programa deve continuar executando até que o usuário escolha sair 13 | # 5. Todas as operações devem ser implementadas sem usar funções prontas do Python 14 | 15 | 16 | def ordenar_vetor(vetor): 17 | """ 18 | Ordena o vetor usando Bubble Sort e retorna um novo vetor 19 | Parâmetro: vetor - lista de números 20 | Retorno: novo_vetor - nova lista ordenada 21 | """ 22 | # Cria uma cópia do vetor original para não modificá-lo 23 | novo_vetor = vetor.copy() 24 | # Implementação do algoritmo Bubble Sort - compara pares adjacentes 25 | for i in range(len(novo_vetor)): 26 | for j in range(i + 1, len(novo_vetor)): 27 | # Se o elemento atual for maior que o próximo, troca suas posições 28 | if novo_vetor[i] > novo_vetor[j]: 29 | novo_vetor[i], novo_vetor[j] = novo_vetor[j], novo_vetor[i] 30 | return novo_vetor 31 | 32 | 33 | def encontrar_max_min(vetor): 34 | """ 35 | Encontra valores máximo e mínimo sem modificar o vetor original 36 | Parâmetro: vetor - lista de números 37 | Retorno: tupla (máximo, mínimo) 38 | """ 39 | # Inicializa máximo e mínimo com o primeiro elemento do vetor 40 | maximo = minimo = vetor[0] 41 | # Percorre o vetor a partir do segundo elemento para comparações 42 | for x in vetor[1:]: 43 | # Atualiza o máximo se encontrar um valor maior 44 | if x > maximo: 45 | maximo = x 46 | # Atualiza o mínimo se encontrar um valor menor 47 | if x < minimo: 48 | minimo = x 49 | return maximo, minimo 50 | 51 | 52 | def dobrar_elementos(vetor): 53 | """ 54 | Cria um novo vetor com elementos dobrados 55 | Parâmetro: vetor - lista de números 56 | Retorno: novo_vetor - nova lista com elementos dobrados 57 | """ 58 | # Inicializa uma lista vazia para armazenar os elementos dobrados 59 | novo_vetor = [] 60 | # Percorre cada elemento do vetor original 61 | for elemento in vetor: 62 | # Multiplica o elemento por 2 e adiciona ao novo vetor 63 | novo_vetor.append(elemento * 2) 64 | return novo_vetor 65 | 66 | 67 | def inverter_vetor(vetor): 68 | """ 69 | Cria um novo vetor com ordem invertida 70 | Parâmetro: vetor - lista de números 71 | Retorno: novo_vetor - nova lista invertida 72 | """ 73 | novo_vetor = [] 74 | # Percorre o vetor do último ao primeiro elemento 75 | for i in range(len(vetor) - 1, -1, -1): 76 | novo_vetor.append(vetor[i]) 77 | return novo_vetor 78 | 79 | 80 | def main(): 81 | # Inicializa os vetores vazios 82 | vetor_original = [] 83 | vetor_atual = [] 84 | 85 | # Obtém o tamanho do vetor do usuário 86 | n = int(input("Digite o tamanho do vetor: ")) 87 | 88 | # Preenche o vetor original com valores fornecidos pelo usuário 89 | for i in range(n): 90 | valor = int(input(f"Digite o {i + 1}º valor: ")) 91 | vetor_original.append(valor) 92 | 93 | # Cria uma cópia do vetor original para manipulação 94 | vetor_atual = vetor_original.copy() 95 | 96 | # Loop principal do programa 97 | while True: 98 | # Exibe o menu de opções 99 | print("\n=== Menu de Operações ===") 100 | print("1 - Ordenar vetor") 101 | print("2 - Encontrar valor máximo e mínimo") 102 | print("3 - Dobrar elementos") 103 | print("4 - Inverter vetor") 104 | print("5 - Mostrar vetor atual") 105 | print("6 - Restaurar vetor original") 106 | print("0 - Sair") 107 | 108 | # Obtém a escolha do usuário 109 | opcao = input("\nEscolha uma opção: ") 110 | 111 | # Estrutura match-case para processar a escolha do usuário 112 | match opcao: 113 | case "1": 114 | # Ordena o vetor e mostra o resultado 115 | novo_vetor = ordenar_vetor(vetor_atual) 116 | print("Vetor original:", vetor_atual) 117 | print("Novo vetor ordenado:", novo_vetor) 118 | # Permite ao usuário manter ou descartar as alterações 119 | if input("Deseja manter o novo vetor? (s/n): ").lower() == 's': 120 | vetor_atual = novo_vetor 121 | 122 | case "2": 123 | # Encontra e exibe os valores máximo e mínimo 124 | maximo, minimo = encontrar_max_min(vetor_atual) 125 | print(f"Valor máximo: {maximo}") 126 | print(f"Valor mínimo: {minimo}") 127 | 128 | case "3": 129 | # Dobra os elementos e mostra o resultado 130 | novo_vetor = dobrar_elementos(vetor_atual) 131 | print("Vetor original:", vetor_atual) 132 | print("Novo vetor com elementos dobrados:", novo_vetor) 133 | # Permite ao usuário manter ou descartar as alterações 134 | if input("Deseja manter o novo vetor? (s/n): ").lower() == 's': 135 | vetor_atual = novo_vetor 136 | 137 | case "4": 138 | # Inverte o vetor e mostra o resultado 139 | novo_vetor = inverter_vetor(vetor_atual) 140 | print("Vetor original:", vetor_atual) 141 | print("Novo vetor invertido:", novo_vetor) 142 | # Permite ao usuário manter ou descartar as alterações 143 | if input("Deseja manter o novo vetor? (s/n): ").lower() == 's': 144 | vetor_atual = novo_vetor 145 | 146 | case "5": 147 | # Exibe os vetores atual e original 148 | print("Vetor atual:", vetor_atual) 149 | print("Vetor original:", vetor_original) 150 | 151 | case "6": 152 | # Restaura o vetor para seu estado original 153 | vetor_atual = vetor_original.copy() 154 | print("Vetor restaurado ao original!") 155 | 156 | case "0": 157 | # Encerra o programa 158 | print("Programa encerrado!") 159 | break 160 | 161 | case _: 162 | # Trata opções inválidas 163 | print("Opção inválida!") 164 | 165 | 166 | # Ponto de entrada do programa 167 | if __name__ == "__main__": 168 | main() 169 | 170 | 171 | # Exemplos das funções usando as ferramentas inclusas no python: 172 | 173 | 174 | # def ordenar_vetor(vetor): 175 | # return sorted(vetor) # Usa a ferramenta inclusa no python para ordenar o vetor 176 | 177 | 178 | # def encontrar_max_min(vetor): 179 | # return max(vetor), min(vetor) # Retorna uma tupla com os valores máximo e mínimo 180 | 181 | 182 | # def dobrar_elementos(vetor): 183 | # return [elemento * 2 for elemento in vetor] 184 | 185 | 186 | # def dobrar_elementos(vetor): 187 | # return [x * 2 for x in vetor] # Compreensão de lista para multiplicar cada elemento por 2 188 | 189 | 190 | # def inverter_vetor(vetor): 191 | # return vetor[::-1] # Utiliza slice com passo -1 para inverter a ordem dos elementos 192 | -------------------------------------------------------------------------------- /Atv/Matrizes.py: -------------------------------------------------------------------------------- 1 | # Código para criação e manipulação de elementos de uma matriz 2 | 3 | def criar_matriz(): 4 | # Solicita as dimensões da matriz 5 | linhas = int(input("Digite o número de linhas: ")) 6 | colunas = int(input("Digite o número de colunas: ")) 7 | 8 | # Cria a matriz vazia 9 | matriz = [] 10 | 11 | # Preenche a matriz com valores informados pelo usuário 12 | print("\nDigite os valores para a matriz:") 13 | for i in range(linhas): 14 | linha = [] 15 | for j in range(colunas): 16 | valor = int(input(f"Digite o valor para posição [{i}][{j}]: ")) 17 | linha.append(valor) 18 | matriz.append(linha) 19 | 20 | return matriz 21 | 22 | 23 | def mostrar_matriz(matriz): 24 | print("\nSua matriz:") 25 | for linha in matriz: 26 | for elemento in linha: 27 | print(f"{elemento:4}", end="") 28 | print() 29 | 30 | 31 | def alterar_elemento(matriz, linha, coluna, valor): 32 | """Altera o valor de um elemento da matriz. 33 | Verifica se a posição especificada é válida antes de realizar a alteração. 34 | """ 35 | if 0 <= linha < len(matriz) and 0 <= coluna < len(matriz[0]): 36 | matriz[linha][coluna] = valor 37 | else: 38 | # Exibe uma mensagem de erro se a posição for inválida. 39 | print("Posição inválida!") 40 | 41 | 42 | def somar_linhas(matriz): 43 | """Retorna uma lista com a soma de cada linha da matriz. 44 | Cada elemento da lista corresponde à soma dos elementos de uma linha. 45 | """ 46 | return [sum(linha) for linha in matriz] 47 | 48 | 49 | def somar_colunas(matriz): 50 | """Retorna uma lista com a soma de cada coluna da matriz. 51 | Cada elemento da lista corresponde à soma dos elementos de uma coluna. 52 | """ 53 | return [sum(matriz[i][j] for i in range(len(matriz))) for j in range(len(matriz[0]))] 54 | 55 | 56 | # Programa principal 57 | matriz = criar_matriz() 58 | mostrar_matriz(matriz) 59 | 60 | # Altera o elemento na posição (1, 1) para o valor 5. 61 | alterar_elemento(matriz, 1, 1, -1) 62 | print("\nMatriz após alteração:") # Exibe a matriz após a alteração. 63 | mostrar_matriz(matriz) 64 | 65 | # Calcula e exibe a soma de cada linha. 66 | print("\nSoma das linhas:", somar_linhas(matriz)) 67 | # Calcula e exibe a soma de cada coluna. 68 | print("Soma das colunas:", somar_colunas(matriz)) 69 | -------------------------------------------------------------------------------- /Aula 15/Ex1.py: -------------------------------------------------------------------------------- 1 | # Enunciado 1: Escreva um programa que solicite um número inteiro positivo N ao usuário e imprima os N primeiros números da sequência de Fibonacci. 2 | 3 | def fibonacci(n: int) -> None: 4 | """ 5 | Função que imprime os N primeiros números da sequência de Fibonacci 6 | Args: 7 | n (int): Quantidade de números da sequência a serem impressos 8 | Returns: 9 | None: A função apenas imprime os valores 10 | """ 11 | 12 | # Verifica se o número é positivo 13 | if n <= 0: 14 | print("Por favor, digite um número inteiro positivo.") 15 | return 16 | 17 | # Inicializa as variáveis para os dois primeiros números da sequência 18 | a, b = 0, 1 # a é o número atual, b é o próximo número 19 | 20 | # Loop que executa N vezes para gerar a sequência 21 | for _ in range(n): 22 | print(a, end=" ") # Imprime o número atual sem quebrar a linha 23 | a, b = b, a + b # Atualiza os valores: a recebe b, b recebe a soma dos anteriores 24 | 25 | print() # Adiciona uma nova linha ao final da sequência 26 | 27 | 28 | # Bloco principal do programa 29 | try: 30 | # Solicita e converte a entrada do usuário para inteiro 31 | n = int(input("Digite um número inteiro positivo: ")) 32 | fibonacci(n) # Chama a função fibonacci com o número informado 33 | except ValueError: 34 | # Trata o erro caso o usuário digite algo que não seja um número 35 | print("Entrada inválida. Por favor, digite um número inteiro.") 36 | -------------------------------------------------------------------------------- /Aula 15/Ex2.py: -------------------------------------------------------------------------------- 1 | # Enunciado 2: Escreva um programa que leia um número inteiro e exiba sua tabuada de 1 a 10. 2 | 3 | # Solicita ao usuário que digite um número e armazena em 'n' 4 | # A função input() captura a entrada como string 5 | # int() converte a string para um número inteiro 6 | n = int(input("Digite um número: ")) 7 | 8 | # Utiliza um loop for com a função range() 9 | # range(1, 11) cria uma sequência de números de 1 até 10 10 | # O primeiro parâmetro (1) é inclusivo 11 | # O segundo parâmetro (11) é exclusivo 12 | for i in range(1, 11): 13 | # Para cada valor de i no loop: 14 | # - Usa f-string (formatted string) para criar a saída 15 | # - {n} representa o número escolhido pelo usuário 16 | # - {i} representa o multiplicador atual (1 a 10) 17 | # - {n * i} calcula e mostra o resultado da multiplicação 18 | print(f"{n} x {i} = {n * i}") 19 | -------------------------------------------------------------------------------- /Aula 16/Ex3.py: -------------------------------------------------------------------------------- 1 | # Enunciado 1: Crie um programa que leia 5 números inteiros e os armazene em uma lista. 2 | # Em seguida, exiba a lista na ordem inversa. 3 | 4 | # Criação da lista usando list comprehension: 5 | # - Executa o loop 5 vezes (range(5)) 6 | # - Para cada iteração, solicita um número via input() 7 | # - Converte a entrada para inteiro com int() 8 | # - Armazena cada número na lista 'numeros' 9 | numeros = [int(input("Digite um número: ")) for _ in range(5)] 10 | 11 | # Exibe a lista na ordem inversa: 12 | # - numeros[::-1] usa slice com passo -1 para inverter a lista 13 | # - O primeiro : significa "do início" 14 | # - O segundo : significa "até o fim" 15 | # - O -1 significa "ande para trás" 16 | print("Números na ordem inversa:", numeros[::-1]) 17 | -------------------------------------------------------------------------------- /Aula 16/Ex4.py: -------------------------------------------------------------------------------- 1 | # Enunciado 2: Desenvolva um programa que leia 10 números e exiba apenas os números pares. 2 | 3 | # ========== Entrada de Dados ========== 4 | # Utiliza list comprehension para criar uma lista de 10 números 5 | # List comprehension é uma forma concisa de criar listas em Python 6 | # O loop range(10) executa 10 vezes, gerando índices de 0 a 9 7 | # O underscore (_) é usado como variável descartável já que não utilizamos o índice 8 | # int(input()) converte a entrada do usuário de string para número inteiro 9 | # A lista final 'numeros' armazenará os 10 valores fornecidos pelo usuário 10 | numeros = [int(input("Digite um número: ")) for _ in range(10)] 11 | 12 | # ========== Processamento ========== 13 | # Filtra apenas os números pares 14 | pares = [n for n in numeros if n % 2 == 0] 15 | 16 | # ========== Saída ========== 17 | # Exibe os números pares 18 | print("Números pares:", pares) -------------------------------------------------------------------------------- /Aula 17/Ex5.py: -------------------------------------------------------------------------------- 1 | # Enunciado 1: Escreva um programa que receba 5 notas e calcule a média delas. 2 | 3 | # Cria uma lista com 5 notas usando list comprehension 4 | # O loop range(5) executa 5 vezes 5 | # float() converte a entrada do usuário (string) para número decimal 6 | # input() solicita que o usuário digite uma nota 7 | notas = [float(input("Digite uma nota: ")) for _ in range(5)] 8 | 9 | # Calcula a média das notas 10 | # sum() soma todos os valores da lista 11 | # len() retorna o tamanho da lista (quantidade de notas) 12 | # A divisão resulta na média aritmética 13 | media = sum(notas) / len(notas) 14 | 15 | # Exibe a média formatada com 2 casas decimais 16 | # f-string permite inserir variáveis dentro da string 17 | # :.2f formata o número com 2 casas decimais 18 | print(f"Média das notas: {media:.2f}") 19 | -------------------------------------------------------------------------------- /Aula 17/Ex6.py: -------------------------------------------------------------------------------- 1 | # Programa para contar números positivos e negativos em uma sequência de 10 números 2 | 3 | # Cria uma lista com 10 números usando list comprehension: 4 | # - Solicita entrada do usuário 10 vezes através do range(10) 5 | # - Converte cada entrada para inteiro usando int() 6 | numeros = [int(input("Digite um número: ")) for _ in range(10)] 7 | 8 | # Conta números positivos usando sum() e generator expression: 9 | # - Para cada número na lista, retorna 1 se for positivo (>0) 10 | # - sum() soma todos os 1s, resultando no total de positivos 11 | positivos = sum(1 for num in numeros if num > 0) 12 | 13 | # Conta números negativos de forma similar: 14 | # - Para cada número na lista, retorna 1 se for negativo (<0) 15 | # - sum() soma todos os 1s, resultando no total de negativos 16 | negativos = sum(1 for num in numeros if num < 0) 17 | 18 | # Exibe o resultado formatado usando f-string 19 | print(f"Positivos: {positivos}, Negativos: {negativos}") 20 | -------------------------------------------------------------------------------- /Aula 18/Ex7.py: -------------------------------------------------------------------------------- 1 | # Enunciado 1: Leia um vetor de 8 números inteiros e exiba a soma de seus elementos. 2 | 3 | # Cria uma lista de 8 números inteiros usando list comprehension 4 | # [int(input("Digite um número: ")) for _ in range(8)] faz o seguinte: 5 | # 1. range(8) gera uma sequência de 0 a 7 6 | # 2. for _ in range(8) itera 8 vezes (o _ é usado quando não precisamos da variável de iteração) 7 | # 3. int(input("Digite um número: ")) em cada iteração: 8 | # - Solicita um número ao usuário 9 | # - Converte a entrada de string para inteiro 10 | numeros = [int(input("Digite um número: ")) for _ in range(8)] 11 | 12 | # Exibe a soma de todos os elementos do vetor usando a função sum() 13 | # sum() soma todos os valores da lista 'numeros' 14 | print("Soma dos elementos:", sum(numeros)) 15 | -------------------------------------------------------------------------------- /Aula 18/Ex8.py: -------------------------------------------------------------------------------- 1 | # Enunciado 2: Peça ao usuário para digitar 6 números inteiros e mostre apenas os ímpares. 2 | 3 | # Usando list comprehension para solicitar 6 números ao usuário 4 | # O loop range(6) executa 6 vezes 5 | # Cada número digitado é convertido para inteiro com int() 6 | numeros = [int(input("Digite um número: ")) for _ in range(6)] 7 | 8 | # Criando uma nova lista apenas com os números ímpares 9 | # Usa list comprehension para filtrar os números 10 | # A condição num % 2 != 0 verifica se o número é ímpar 11 | # Se o resto da divisão por 2 é diferente de 0, o número é ímpar 12 | impares = [num for num in numeros if num % 2 != 0] 13 | 14 | # Exibe a lista de números ímpares 15 | print("Números ímpares:", impares) 16 | -------------------------------------------------------------------------------- /Aula 19/Ex10.py: -------------------------------------------------------------------------------- 1 | # Enunciado 2: Ordene uma lista de 6 números inteiros digitados pelo usuário utilizando Selection Sort. 2 | 3 | def selection_sort(lista): 4 | # Percorre toda a lista do início até o penúltimo elemento 5 | for i in range(len(lista)): 6 | # Assume que o elemento atual é o mínimo 7 | min_idx = i 8 | 9 | # Procura o menor elemento no resto da lista (parte não ordenada) 10 | for j in range(i + 1, len(lista)): 11 | # Se encontrar um elemento menor que o atual mínimo 12 | if lista[j] < lista[min_idx]: 13 | # Atualiza o índice do menor elemento 14 | min_idx = j 15 | 16 | # Troca o elemento atual com o menor elemento encontrado 17 | # Isso coloca o menor elemento na posição correta 18 | lista[i], lista[min_idx] = lista[min_idx], lista[i] 19 | 20 | 21 | # Cria uma lista com 6 números inteiros fornecidos pelo usuário 22 | # usando list comprehension para solicitar cada entrada 23 | numeros = [int(input("Digite um número: ")) for _ in range(6)] 24 | 25 | # Aplica o algoritmo de ordenação Selection Sort na lista 26 | selection_sort(numeros) 27 | 28 | # Exibe a lista após a ordenação 29 | print("Lista ordenada:", numeros) 30 | -------------------------------------------------------------------------------- /Aula 19/Ex9.py: -------------------------------------------------------------------------------- 1 | # Enunciado 1: Implemente o algoritmo Bubble Sort para ordenar uma lista de números digitados pelo usuário. 2 | 3 | def bubble_sort(lista): 4 | # Obtém o tamanho da lista 5 | n = len(lista) 6 | 7 | # Loop externo: controla o número de passagens pela lista 8 | # A cada passagem, o maior elemento "flutua" para o final 9 | for i in range(n): 10 | # Loop interno: compara elementos adjacentes 11 | # (n-i-1) porque após cada passagem i, os últimos i elementos já estão ordenados 12 | for j in range(n - i - 1): 13 | # Compara elementos adjacentes 14 | # Se o elemento atual for maior que o próximo, troca suas posições 15 | if lista[j] > lista[j + 1]: 16 | # Realiza a troca (swap) dos elementos 17 | lista[j], lista[j + 1] = lista[j + 1], lista[j] 18 | 19 | 20 | # Cria uma lista com 5 números inteiros fornecidos pelo usuário 21 | # usando list comprehension para solicitar cada entrada 22 | numeros = [int(input("Digite um número: ")) for _ in range(5)] 23 | 24 | # Aplica o algoritmo de ordenação Bubble Sort na lista 25 | bubble_sort(numeros) 26 | 27 | # Exibe a lista após a ordenação 28 | print("Lista ordenada:", numeros) 29 | -------------------------------------------------------------------------------- /Aula 20/Ex11.py: -------------------------------------------------------------------------------- 1 | # Função que implementa o algoritmo Insertion Sort (ordenação por inserção) 2 | def insertion_sort(lista): 3 | # Percorre a lista a partir do segundo elemento (índice 1) 4 | for i in range(1, len(lista)): 5 | # Guarda o elemento atual que será comparado e inserido na posição correta 6 | chave = lista[i] 7 | # j é o índice do elemento anterior ao elemento atual 8 | j = i - 1 9 | 10 | # Move os elementos maiores que a chave uma posição para frente 11 | # até encontrar a posição correta para inserir a chave 12 | while j >= 0 and lista[j] > chave: 13 | lista[j + 1] = lista[j] # Desloca o elemento maior para a direita 14 | j -= 1 # Move para o próximo elemento à esquerda 15 | 16 | # Insere a chave na posição correta encontrada 17 | lista[j + 1] = chave 18 | 19 | 20 | # Cria uma lista com 5 números inseridos pelo usuário 21 | # Usa list comprehension para solicitar cada número 22 | numeros = [int(input("Digite um número: ")) for _ in range(5)] 23 | 24 | # Chama a função insertion_sort para ordenar a lista 25 | insertion_sort(numeros) 26 | 27 | # Exibe a lista após a ordenação 28 | print("Lista ordenada:", numeros) 29 | -------------------------------------------------------------------------------- /Aula 20/Ex12.py: -------------------------------------------------------------------------------- 1 | # Enunciado 2: Ordene um vetor de 7 números utilizando QuickSort. 2 | 3 | def quicksort(lista): 4 | # Caso base: se a lista tiver 1 ou menos elementos, já está ordenada 5 | if len(lista) <= 1: 6 | return lista 7 | 8 | # Seleciona o elemento do meio como pivô para melhor performance em média 9 | pivo = lista[len(lista) // 2] 10 | 11 | # Divide a lista em três partes: 12 | # menores: todos os elementos menores que o pivô 13 | menores = [x for x in lista if x < pivo] 14 | # iguais: todos os elementos iguais ao pivô 15 | iguais = [x for x in lista if x == pivo] 16 | # maiores: todos os elementos maiores que o pivô 17 | maiores = [x for x in lista if x > pivo] 18 | 19 | # Recursivamente ordena as sublistas e concatena o resultado: 20 | # 1. Ordena a lista de elementos menores 21 | # 2. Adiciona os elementos iguais ao pivô 22 | # 3. Ordena a lista de elementos maiores 23 | return quicksort(menores) + iguais + quicksort(maiores) 24 | 25 | 26 | # Cria uma lista com 7 números inseridos pelo usuário 27 | numeros = [int(input("Digite um número: ")) for _ in range(7)] 28 | # Aplica o algoritmo quicksort para ordenar a lista 29 | numeros = quicksort(numeros) 30 | # Exibe a lista ordenada 31 | print("Lista ordenada:", numeros) 32 | -------------------------------------------------------------------------------- /Aula 21/Ex13.py: -------------------------------------------------------------------------------- 1 | # Enunciado 1: Leia uma lista de 10 números e exiba o menor e o maior valor encontrado. 2 | 3 | # Cria uma lista com 10 números fornecidos pelo usuário usando list comprehension 4 | 5 | # numeros = [int(input("Digite um número: ")) for _ in range(10)] 6 | 7 | # Usa as funções min() e max() para encontrar o menor e maior valor 8 | # Exibe os resultados usando f-string 9 | 10 | # print(f"Menor valor: {min(numeros)}, Maior valor: {max(numeros)}") 11 | 12 | 13 | # Enunciado 1: Leia uma lista de 10 números e exiba o menor e o maior valor encontrado. 14 | 15 | # Cria uma lista com 10 números fornecidos pelo usuário usando list comprehension 16 | numeros = [int(input("Digite um número: ")) for _ in range(10)] 17 | 18 | # Inicializa menor e maior com o primeiro elemento da lista 19 | menor = numeros[0] 20 | maior = numeros[0] 21 | 22 | # Percorre a lista para encontrar o menor e maior valor 23 | for num in numeros: 24 | if num < menor: 25 | menor = num 26 | if num > maior: 27 | maior = num 28 | 29 | # Exibe os resultados usando f-string 30 | print(f"Menor valor: {menor}, Maior valor: {maior}") -------------------------------------------------------------------------------- /Aula 21/Ex14.py: -------------------------------------------------------------------------------- 1 | # Enunciado 2: Implemente uma função que encontre o segundo maior número de um vetor de 8 elementos digitados pelo usuário. 2 | 3 | def segundo_maior(lista): 4 | # Remove números duplicados usando set e converte de volta para lista 5 | lista = list(set(lista)) 6 | # Ordena a lista em ordem crescente 7 | lista.sort() 8 | # Retorna o penúltimo elemento se a lista tiver mais de 1 elemento, senão retorna None 9 | return lista[-2] if len(lista) > 1 else None 10 | 11 | 12 | # Cria uma lista com 8 números fornecidos pelo usuário usando list comprehension 13 | numeros = [int(input("Digite um número: ")) for _ in range(8)] 14 | # Exibe o segundo maior número encontrado 15 | print("Segundo maior número:", segundo_maior(numeros)) 16 | -------------------------------------------------------------------------------- /Aula 22/Ex15.py: -------------------------------------------------------------------------------- 1 | """ 2 | Exercício 15 - Manipulação de Matrizes 3 | 4 | Objetivo: Demonstrar diferentes formas de criar e manipular matrizes em Python, 5 | utilizando tanto listas aninhadas quanto a biblioteca NumPy. 6 | 7 | Tarefas: 8 | 1. Criar uma matriz 3x3 usando listas aninhadas 9 | 2. Acessar elementos específicos da matriz 10 | 3. Criar a mesma matriz usando NumPy 11 | 4. Comparar as diferentes representações 12 | 13 | Obs: Este exercício ilustra as diferenças entre matrizes implementadas com 14 | listas Python puras e arrays NumPy. 15 | """ 16 | 17 | import numpy as np 18 | 19 | matriz = [ 20 | [1, 2, 3], [4, 5, 6], [7, 8, 9] 21 | ] 22 | 23 | print(matriz) # Saida: [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 24 | # Saida: 1 Acessa o elemento na primeira linha e primeira coluna 25 | print(matriz[0][0]) 26 | # Saida: 6 Acessa o elemento na segunda linha e terceira coluna 27 | print(matriz[1][2]) 28 | 29 | 30 | matriz2 = np.array([ 31 | [1, 2, 3], 32 | [4, 5, 6], 33 | [7, 8, 9] 34 | ]) 35 | 36 | print(matriz2) 37 | -------------------------------------------------------------------------------- /Aula 22/Ex16.py: -------------------------------------------------------------------------------- 1 | """ 2 | Exercício 16 - Introdução a Matrizes 3 | 4 | Objetivo: Criar, acessar e modificar elementos de uma matriz simples. 5 | 6 | Tarefas: 7 | 1. Criar uma matriz 3x3 com valores numéricos sequenciais 8 | 2. Acessar um elemento específico da matriz e exibi-lo 9 | 3. Modificar o valor de um elemento da matriz 10 | 4. Exibir o elemento modificado para verificar a alteração 11 | 5. Calcular a soma de todos os elementos 12 | 13 | Conceitos abordados: 14 | - Representação de matrizes como listas aninhadas 15 | - Acesso a elementos por índice 16 | - Modificação de elementos de matrizes 17 | """ 18 | 19 | # Criação da matriz 3x3 20 | matriz = [ 21 | [1, 2, 3], 22 | [4, 5, 6], 23 | [7, 8, 9] 24 | ] 25 | 26 | # Exibição da matriz original de forma estruturada 27 | print("Matriz original:") 28 | for linha in matriz: 29 | print(linha) 30 | 31 | # Acessando e exibindo um elemento específico 32 | print("\nElemento na posição [0][0]:", matriz[0][0]) 33 | 34 | # Modificando um elemento 35 | matriz[0][0] = 10 36 | print("Elemento modificado [0][0]:", matriz[0][0]) 37 | 38 | # Matriz após modificação 39 | print("\nMatriz após modificação:") 40 | for linha in matriz: 41 | print(linha) 42 | 43 | # Calculando a soma de todos os elementos 44 | soma = 0 45 | for i in range(len(matriz)): 46 | for j in range(len(matriz[i])): 47 | soma += matriz[i][j] 48 | print("\nSoma de todos os elementos:", soma) 49 | -------------------------------------------------------------------------------- /Aula 23/Ex17.py: -------------------------------------------------------------------------------- 1 | """ 2 | Exercício 17 - Soma de Matrizes 3 | 4 | Objetivo: Implementar a soma de duas matrizes 2x2 utilizando list comprehension. 5 | 6 | Descrição: 7 | - Criar duas matrizes A e B de dimensão 2x2 8 | - Realizar a soma elemento por elemento das matrizes 9 | - Utilizar list comprehension para uma implementação concisa 10 | - Exibir o resultado da soma 11 | 12 | Conceitos abordados: 13 | - Matrizes como listas aninhadas 14 | - List comprehension 15 | - Operações com matrizes 16 | """ 17 | 18 | # Definição das matrizes de entrada 19 | A = [[1, 2, 3], 20 | [4, 5, 6], 21 | [7, 8, 9]] # Matriz A 2x2 22 | 23 | B = [[9, 8, 7], 24 | [6, 5, 4], 25 | [3, 2, 1]] # Matriz B 2x2 26 | 27 | # Soma das matrizes usando list comprehension 28 | # Para cada linha i e coluna j, soma os elementos correspondentes de A e B 29 | # O primeiro loop (i) percorre as linhas 30 | # O segundo loop (j) percorre as colunas 31 | 32 | soma = [[A[i][j] + B[i][j] for j in range(len(A[0]))] for i in range(len(A))] 33 | 34 | # Exibe o resultado da soma das matrizes 35 | print("Resultado da soma das matrizes:") 36 | print(soma) # Resultado esperado: [[6, 8], [10, 12]] 37 | 38 | for i in range(len(A)): 39 | for j in range((len(A[0]))): 40 | print(f"A[{i}][{j}] + B[{i}][{j}] = {A[i][j]} + {B[i][j]}") 41 | 42 | -------------------------------------------------------------------------------- /Aula 23/Ex18.py: -------------------------------------------------------------------------------- 1 | """ 2 | Exercício 18 - Soma de Matrizes com NumPy 3 | 4 | Objetivo: Implementar a soma de duas matrizes 2x2 utilizando a biblioteca NumPy. 5 | 6 | Descrição: 7 | - Criar duas matrizes A e B de dimensão 2x2 usando NumPy arrays 8 | - Realizar a soma das matrizes utilizando operadores NumPy 9 | - Comparar a simplicidade em relação à implementação com list comprehension 10 | 11 | Conceitos abordados: 12 | - NumPy arrays 13 | - Operações matriciais com NumPy 14 | - Vantagens do NumPy sobre listas puras Python 15 | """ 16 | 17 | import numpy as np 18 | 19 | # Criação das matrizes usando np.array 20 | A = np.array([[1, 2], [3, 4]]) # Matriz A 2x2 21 | B = np.array([[5, 6], [7, 8]]) # Matriz B 2x2 22 | 23 | # Soma das matrizes A e B 24 | # NumPy permite soma direta de arrays usando o operador + 25 | soma = A + B 26 | 27 | print("Resultado da soma das matrizes A e B:") 28 | print(soma) # Resultado esperado: [[6 8], [10 12]] 29 | -------------------------------------------------------------------------------- /Aula 24/Ex19.py: -------------------------------------------------------------------------------- 1 | """ 2 | Exercício 19 - Multiplicação por Escalar 3 | 4 | Objetivo: Criar um programa que multiplique cada elemento de uma matriz por um número. 5 | 6 | Tarefas: 7 | 1. Criar uma matriz 3x3 com valores fornecidos pelo usuário 8 | 2. Solicitar um número (escalar) para multiplicação 9 | 3. Multiplicar cada elemento da matriz pelo escalar 10 | 4. Exibir a matriz original e o resultado 11 | 12 | Exemplo: 13 | Matriz: Escalar: 2 Resultado: 14 | [1 2 3] [2 4 6] 15 | [4 5 6] → [8 10 12] 16 | [7 8 9] [14 16 18] 17 | """ 18 | 19 | def criar_matriz(): 20 | matriz = [] 21 | print("Digite os valores para a matriz 3x3:") 22 | for i in range(3): 23 | linha = [] 24 | for j in range(3): 25 | valor = int(input(f"Digite o valor para posição [{i}][{j}]: ")) 26 | linha.append(valor) 27 | matriz.append(linha) 28 | return matriz 29 | 30 | 31 | def multiplicar_por_escalar(matriz, escalar): 32 | resultado = [] 33 | for i in range(3): 34 | linha = [] 35 | for j in range(3): 36 | linha.append(matriz[i][j] * escalar) 37 | resultado.append(linha) 38 | return resultado 39 | 40 | 41 | def exibir_matriz(matriz): 42 | for linha in matriz: 43 | print(linha) 44 | 45 | 46 | def main(): 47 | # Criar matriz original 48 | print("Vamos criar a matriz 3x3") 49 | matriz_original = criar_matriz() 50 | 51 | # Solicitar o escalar 52 | escalar = int(input("\nDigite o número escalar para multiplicação: ")) 53 | 54 | # Calcular o resultado 55 | matriz_resultado = multiplicar_por_escalar(matriz_original, escalar) 56 | 57 | # Exibir resultados 58 | print("\nMatriz Original:") 59 | exibir_matriz(matriz_original) 60 | 61 | print(f"\nEscalar: {escalar}") 62 | 63 | print("\nMatriz Resultado:") 64 | exibir_matriz(matriz_resultado) 65 | 66 | if __name__ == "__main__": 67 | main() 68 | -------------------------------------------------------------------------------- /Aula 24/Ex20.py: -------------------------------------------------------------------------------- 1 | """ 2 | Exercício 20 - Soma das Diagonais 3 | 4 | Objetivo: Calcular e comparar a soma das diagonais principal e secundária. 5 | 6 | Tarefas: 7 | 1. Criar uma matriz quadrada 4x4 8 | 2. Calcular a soma da diagonal principal (↘) 9 | 3. Calcular a soma da diagonal secundária (↙) 10 | 4. Determinar qual diagonal tem a maior soma 11 | 5. Exibir os elementos de cada diagonal 12 | """ 13 | 14 | # Criar matriz 4x4 15 | matriz = [ 16 | [1, 2, 3, 4], 17 | [5, 6, 7, 8], 18 | [9, 10, 11, 12], 19 | [13, 14, 15, 16] 20 | ] 21 | 22 | # Função para imprimir a matriz de forma organizada 23 | 24 | 25 | def imprimir_matriz(mat): 26 | for linha in mat: 27 | for elemento in linha: 28 | print(f"|{elemento:3d}|", end=" ") 29 | print() 30 | 31 | 32 | # Calcular soma da diagonal principal 33 | diagonal_principal = [] 34 | soma_principal = 0 35 | for i in range(4): 36 | diagonal_principal.append(matriz[i][i]) 37 | soma_principal += matriz[i][i] 38 | 39 | # Calcular soma da diagonal secundária 40 | diagonal_secundaria = [] 41 | soma_secundaria = 0 42 | for i in range(4): 43 | diagonal_secundaria.append(matriz[i][3-i]) 44 | soma_secundaria += matriz[i][3-i] 45 | # Exibir resultados 46 | print("\nMatriz:") 47 | imprimir_matriz(matriz) 48 | 49 | print(f"\nElementos da diagonal principal: {diagonal_principal}") 50 | print(f"Soma da diagonal principal: {soma_principal}") 51 | 52 | print(f"\nElementos da diagonal secundária: {diagonal_secundaria}") 53 | print(f"Soma da diagonal secundária: {soma_secundaria}") 54 | 55 | if soma_principal > soma_secundaria: 56 | print("\nA diagonal principal tem a maior soma") 57 | elif soma_secundaria > soma_principal: 58 | print("\nA diagonal secundária tem a maior soma") 59 | else: 60 | print("\nAs diagonais têm a mesma soma") 61 | -------------------------------------------------------------------------------- /Aula 25/Ex21.py: -------------------------------------------------------------------------------- 1 | """ 2 | Exercício 21 - Matriz Transposta 3 | 4 | Objetivo: Criar a transposta de uma matriz (trocar linhas por colunas). 5 | 6 | Tarefas: 7 | 1. Criar uma matriz 2x3 8 | 2. Gerar sua transposta (3x2) 9 | 3. Exibir ambas as matrizes de forma organizada 10 | 4. Verificar se os elementos foram corretamente transpostos 11 | 12 | Exemplo: 13 | Original (2x3): Transposta (3x2): 14 | [1 2 3] [1 4] 15 | [4 5 6] → [2 5] 16 | [3 6] 17 | """ 18 | 19 | def criar_matriz(linhas, colunas): 20 | matriz = [] 21 | valor = 1 22 | for i in range(linhas): 23 | linha = [] 24 | for j in range(colunas): 25 | linha.append(valor) 26 | valor += 1 27 | matriz.append(linha) 28 | return matriz 29 | 30 | def transpor_matriz(matriz): 31 | linhas = len(matriz) 32 | colunas = len(matriz[0]) 33 | transposta = [] 34 | 35 | for j in range(colunas): 36 | nova_linha = [] 37 | for i in range(linhas): 38 | nova_linha.append(matriz[i][j]) 39 | transposta.append(nova_linha) 40 | 41 | return transposta 42 | 43 | def imprimir_matriz(matriz): 44 | for linha in matriz: 45 | print([f"{num:2d}" for num in linha]) 46 | print() 47 | 48 | # Criar matriz original 2x3 49 | matriz_original = criar_matriz(2, 3) 50 | 51 | # Gerar matriz transposta 52 | matriz_transposta = transpor_matriz(matriz_original) 53 | 54 | # Exibir resultados 55 | print("Matriz Original (2x3):") 56 | imprimir_matriz(matriz_original) 57 | 58 | print("Matriz Transposta (3x2):") 59 | imprimir_matriz(matriz_transposta) 60 | -------------------------------------------------------------------------------- /Aula 25/Ex22.py: -------------------------------------------------------------------------------- 1 | """ 2 | Exercício 22 - Matriz Espelhada 3 | 4 | Objetivo: Criar uma matriz e gerar sua versão espelhada horizontalmente. 5 | 6 | Tarefas: 7 | 1. Criar uma matriz 3x4 com valores fornecidos pelo usuário 8 | 2. Gerar uma nova matriz espelhada horizontalmente (invertendo a ordem das colunas) 9 | 3. Exibir ambas as matrizes lado a lado 10 | 4. Verificar se o espelhamento foi feito corretamente 11 | 12 | Exemplo: 13 | Original (3x4): Espelhada (3x4): 14 | [1 2 3 4] [4 3 2 1] 15 | [5 6 7 8] → [8 7 6 5] 16 | [9 10 11 12] [12 11 10 9] 17 | """ 18 | 19 | 20 | def criar_matriz(): 21 | matriz = [] 22 | valor = 0 23 | print("Digite os valores para a matriz 3x4:") 24 | for i in range(3): 25 | linha = [] 26 | for j in range(4): 27 | valor += 1 28 | linha.append(valor) 29 | matriz.append(linha) 30 | return matriz 31 | 32 | 33 | def espelhar_matriz(matriz): 34 | matriz_espelhada = [] 35 | for linha in matriz: 36 | matriz_espelhada.append(linha[::-1]) 37 | return matriz_espelhada 38 | 39 | 40 | def exibir_matrizes(original, espelhada): 41 | print("\nMatriz Original:") 42 | for linha in original: 43 | print([f"{num:2d}" for num in linha]) 44 | 45 | print("\nMatriz Espelhada:") 46 | for linha in espelhada: 47 | print([f"{num:2d}" for num in linha]) 48 | 49 | 50 | def main(): 51 | matriz_original = criar_matriz() 52 | matriz_espelhada = espelhar_matriz(matriz_original) 53 | exibir_matrizes(matriz_original, matriz_espelhada) 54 | 55 | 56 | if __name__ == "__main__": 57 | main() 58 | -------------------------------------------------------------------------------- /Aula 26/Ex23.py: -------------------------------------------------------------------------------- 1 | """ 2 | Exercício 23 - Valores Extremos em Matriz 3 | Desenvolva um programa em Python que: 4 | 5 | Crie uma matriz 3x3 com valores inteiros digitados pelo usuário 6 | Encontre o valor mínimo e o valor máximo presentes na matriz, bem como suas respectivas posições 7 | Exiba a matriz formatada na tela 8 | Mostre o menor e o maior valor encontrados, junto com suas posições na matriz no formato (linha, coluna) 9 | Observação: Implemente a busca pelos valores mínimos e máximos sem utilizar as funções prontas min() e max() do Python. 10 | """ 11 | 12 | def encontrar_min_max_matriz(matriz): 13 | """ 14 | Encontra os valores mínimos e máximos da matriz manualmente, 15 | sem usar funções prontas como min() e max() 16 | """ 17 | # Inicializa com o primeiro elemento da matriz 18 | menor = matriz[0][0] 19 | maior = matriz[0][0] 20 | pos_menor = (0, 0) 21 | pos_maior = (0, 0) 22 | 23 | # Percorre a matriz 24 | for i in range(len(matriz)): 25 | for j in range(len(matriz[0])): 26 | # Verifica se encontrou um valor menor 27 | if matriz[i][j] < menor: 28 | menor = matriz[i][j] 29 | pos_menor = (i, j) 30 | # Verifica se encontrou um valor maior 31 | if matriz[i][j] > maior: 32 | maior = matriz[i][j] 33 | pos_maior = (i, j) 34 | 35 | return menor, pos_menor, maior, pos_maior 36 | 37 | def criar_matriz(): 38 | """Cria uma matriz 3x3 com valores digitados pelo usuário""" 39 | matriz = [] 40 | for i in range(3): 41 | linha = [] 42 | for j in range(3): 43 | valor = int(input(f"Digite o valor para posição [{i}][{j}]: ")) 44 | linha.append(valor) 45 | matriz.append(linha) 46 | return matriz 47 | 48 | def exibir_matriz(matriz): 49 | """Exibe a matriz de forma organizada""" 50 | print("\nMatriz:") 51 | for linha in matriz: 52 | for valor in linha: 53 | print(f"{valor:4}", end="") 54 | print() 55 | 56 | def main(): 57 | # Cria a matriz 58 | print("Digite os valores para a matriz 3x3:") 59 | matriz = criar_matriz() 60 | 61 | # Exibe a matriz 62 | exibir_matriz(matriz) 63 | 64 | # Encontra os valores mínimos e máximos 65 | menor, pos_menor, maior, pos_maior = encontrar_min_max_matriz(matriz) 66 | 67 | # Exibe os resultados 68 | print(f"\nMenor valor: {menor} na posição {pos_menor}") 69 | print(f"Maior valor: {maior} na posição {pos_maior}") 70 | 71 | if __name__ == "__main__": 72 | main() -------------------------------------------------------------------------------- /Aula 26/Ex24.py: -------------------------------------------------------------------------------- 1 | """ 2 | Exercício 24 - Matriz Aleatória 3 | Desenvolva um programa em Python que: 4 | 1. Crie uma matriz 3x3 5 | 2. Preencha a matriz com números inteiros aleatórios entre 1 e 100 6 | 3. Exiba a matriz na tela de forma organizada, com cada elemento entre colchetes 7 | """ 8 | 9 | # Importando o módulo random para gerar números aleatórios 10 | import random 11 | 12 | # Criando uma matriz 3x3 usando compreensão de lista aninhada: 13 | # - A compreensão externa cria 3 linhas 14 | # - A compreensão interna cria 3 colunas para cada linha 15 | # - random.randint(1, 100) gera números inteiros aleatórios entre 1 e 100 16 | # - _ é usado como variável descartável já que não precisamos da variável do loop 17 | matrix = [[random.randint(1, 100) for _ in range(3)] for _ in range(3)] 18 | 19 | for i in range(3): 20 | ale= random.randint(1,100) 21 | print(ale) 22 | for j in range(3): 23 | matrix[i][j] = ale 24 | 25 | # Exibindo a matriz em formato de grade: 26 | print("Matriz 3x3 em grade:") 27 | for row in matrix: 28 | for num in row: 29 | print(f"[{num:3d}]", end=" ") 30 | print() 31 | 32 | 33 | # Exibindo a matriz em linha, sem formatação: 34 | print("\nMatriz 3x3 em linha, sem formatação: ") 35 | for row in matrix: 36 | for num in row: 37 | print(f"[{num:3d}]", end=" ") 38 | -------------------------------------------------------------------------------- /Aula 27/Ex25.py: -------------------------------------------------------------------------------- 1 | """ 2 | Exercício - Análise de Matriz 3 | Desenvolva um programa que: 4 | 1. Crie uma matriz 4x4 com números aleatórios entre 0 e 50 5 | 2. Calcule e mostre: 6 | - A soma da diagonal principal 7 | - A soma da diagonal secundária 8 | - O maior valor de cada linha 9 | 3. Exiba a matriz de forma organizada 10 | """ 11 | 12 | import random 13 | 14 | 15 | def criar_matriz(tamanho): 16 | return [[random.randint(0, 50) for _ in range(tamanho)] for _ in range(tamanho)] 17 | 18 | 19 | def exibir_matriz(matriz): 20 | print("\nMatriz 4x4:") 21 | print("-" * 25) 22 | for linha in matriz: 23 | for num in linha: 24 | print(f"|{num:3d}|", end=" ") 25 | print() 26 | print("-" * 25) 27 | 28 | 29 | def soma_diagonal_principal(matriz): 30 | return sum(matriz[i][i] for i in range(len(matriz))) 31 | 32 | 33 | def soma_diagonal_secundaria(matriz): 34 | tamanho = len(matriz) 35 | return sum(matriz[i][tamanho-1-i] for i in range(tamanho)) 36 | 37 | 38 | def maiores_valores_linhas(matriz): 39 | return [max(linha) for linha in matriz] 40 | 41 | 42 | # Programa principal 43 | tamanho = 4 44 | matriz = criar_matriz(tamanho) 45 | 46 | 47 | # Exibe a matriz 48 | exibir_matriz(matriz) 49 | 50 | # Calcula e exibe os resultados 51 | print(f"\nSoma da diagonal principal: {soma_diagonal_principal(matriz)}") 52 | print(f"Soma da diagonal secundária: {soma_diagonal_secundaria(matriz)}") 53 | 54 | # Exibe o maior valor de cada linha 55 | maiores = maiores_valores_linhas(matriz) 56 | for i, valor in enumerate(maiores): 57 | print(f"Maior valor da linha {i+1}: {valor}") 58 | -------------------------------------------------------------------------------- /Aula 27/Ex26.py: -------------------------------------------------------------------------------- 1 | """ 2 | Exercício 26 - Multiplicação por Escalar com Menu Interativo 3 | 4 | Objetivo: Criar um programa que multiplique cada elemento de uma matriz por um número, 5 | com interface de menu para o usuário. 6 | """ 7 | 8 | 9 | def criar_matriz(): 10 | linhas = int(input("Digite o número de linhas da matriz: ")) 11 | colunas = int(input("Digite o número de colunas da matriz: ")) 12 | 13 | if linhas <= 0 or colunas <= 0: 14 | print("Erro: As dimensões devem ser maiores que zero!") 15 | return None 16 | 17 | matriz = [] 18 | print(f"\nDigite os valores para a matriz {linhas}x{colunas}:") 19 | for i in range(linhas): 20 | linha = [] 21 | for j in range(colunas): 22 | valor = int(input(f"Digite o valor para posição [{i}][{j}]: ")) 23 | linha.append(valor) 24 | matriz.append(linha) 25 | return matriz 26 | 27 | 28 | def multiplicar_por_escalar(matriz, escalar): 29 | if not matriz: 30 | return None 31 | resultado = [] 32 | for i in range(3): 33 | linha = [] 34 | for j in range(3): 35 | linha.append(matriz[i][j] * escalar) 36 | resultado.append(linha) 37 | return resultado 38 | 39 | 40 | def exibir_matriz(matriz): 41 | if not matriz: 42 | print("A matriz está vazia!") 43 | return 44 | for linha in matriz: 45 | print(linha) 46 | 47 | 48 | def mostrar_menu(): 49 | print("\n=== Menu de Operações ===") 50 | print("1. Criar nova matriz") 51 | print("2. Multiplicar matriz por escalar") 52 | print("3. Exibir matriz atual") 53 | print("4. Sair") 54 | return input("Escolha uma opção: ") 55 | 56 | 57 | def main(): 58 | matriz_atual = None 59 | 60 | while True: 61 | if matriz_atual is not None: 62 | print("\nMatriz atual:") 63 | exibir_matriz(matriz_atual) 64 | 65 | opcao = mostrar_menu() 66 | 67 | match opcao: 68 | case "1": 69 | print("\nCriando nova matriz...") 70 | matriz_atual = criar_matriz() 71 | print("\nMatriz criada com sucesso!") 72 | print("\nNova matriz:") 73 | exibir_matriz(matriz_atual) 74 | 75 | case "2": 76 | if matriz_atual is None: 77 | print("\nERRO: Primeiro crie uma matriz (opção 1)!") 78 | else: 79 | print("\nMatriz atual para multiplicação:") 80 | exibir_matriz(matriz_atual) 81 | escalar = int( 82 | input("\nDigite o número escalar para multiplicação: ")) 83 | matriz_atual = multiplicar_por_escalar( 84 | matriz_atual, escalar) 85 | print("\nResultado da multiplicação:") 86 | exibir_matriz(matriz_atual) 87 | 88 | case "3": 89 | print("\nMatriz atual:") 90 | exibir_matriz(matriz_atual) 91 | 92 | case "4": 93 | if matriz_atual is not None: 94 | print("\nMatriz final:") 95 | exibir_matriz(matriz_atual) 96 | print("\nEncerrando o programa...") 97 | break 98 | 99 | case _: 100 | print("\nOpção inválida! Por favor, escolha uma opção válida.") 101 | 102 | 103 | if __name__ == "__main__": 104 | main() 105 | -------------------------------------------------------------------------------- /Aula 28/Ex27.py: -------------------------------------------------------------------------------- 1 | # Comparação de strings em Python - Versão Expandida 2 | 3 | # Strings para comparação 4 | texto1 = "Python" 5 | texto2 = "python" 6 | texto3 = "Python" 7 | texto4 = "Java" 8 | texto5 = " Python " 9 | texto6 = "Python é incrível!" 10 | 11 | # 1. Comparações básicas 12 | print("=== Comparações básicas ===") 13 | print(f"'Python' == 'python': {texto1 == texto2}") 14 | print(f"'Python' == 'Python': {texto1 == texto3}") 15 | print(f"'Python' != 'Java': {texto1 != texto4}") 16 | 17 | # 2. Comparação ignorando maiúsculas/minúsculas 18 | print("\n=== Comparação ignorando case ===") 19 | print( 20 | f"'Python'.lower() == 'python'.lower(): {texto1.lower() == texto2.lower()}") 21 | print( 22 | f"'Python'.casefold() == 'python'.casefold(): {texto1.casefold() == texto2.casefold()}") 23 | 24 | # 3. Comparação de ordem alfabética 25 | print("\n=== Comparação alfabética ===") 26 | print(f"'Python' < 'Java': {texto1 < texto4}") 27 | print(f"'Java' < 'Python': {texto4 < texto1}") 28 | print(f"Ordem alfabética: {sorted([texto1, texto2, texto4])}") 29 | 30 | # 4. Métodos de verificação 31 | palavra = "Hello World" 32 | print("\n=== Métodos de verificação ===") 33 | print(f"Começa com 'He': {palavra.startswith('He')}") 34 | print(f"Termina com 'rld': {palavra.endswith('rld')}") 35 | print(f"'World' está contido: {'World' in palavra}") 36 | print(f"Posição de 'World': {palavra.find('World')}") 37 | 38 | # 5. Comparação de tamanhos 39 | print("\n=== Comparação de tamanhos ===") 40 | print(f"Tamanho de '{texto1}': {len(texto1)}") 41 | print(f"Tamanho de '{texto4}': {len(texto4)}") 42 | print(f"'{texto1}' tem mais caracteres que '{texto4}': {len(texto1) > len(texto4)}") 43 | 44 | # 6. Manipulação de espaços 45 | print("\n=== Manipulação de espaços ===") 46 | print(f"String original: '{texto5}'") 47 | print(f"Removendo espaços à direita: '{texto5.rstrip()}'") 48 | print(f"Removendo espaços à esquerda: '{texto5.lstrip()}'") 49 | print(f"Removendo espaços dos dois lados: '{texto5.strip()}'") 50 | 51 | # 7. Métodos de substituição 52 | print("\n=== Métodos de substituição ===") 53 | print(f"Substituindo 'Python' por 'Java': {texto6.replace('Python', 'Java')}") 54 | print(f"Substituindo espaços por hífen: {texto6.replace(' ', '-')}") 55 | 56 | # 8. Verificação de conteúdo 57 | print("\n=== Verificação de conteúdo ===") 58 | 59 | # Verifica se todos os caracteres são alfanuméricos (letras ou números) 60 | # Retorna False se contiver espaços ou caracteres especiais 61 | print(f"É alfanumérico? {texto1.isalnum()}") 62 | 63 | # Verifica se todos os caracteres são letras do alfabeto 64 | # Retorna False se contiver números, espaços ou caracteres especiais 65 | print(f"É alfabético? {texto1.isalpha()}") 66 | 67 | # Verifica se a string contém apenas dígitos decimais (0-9) 68 | # Retorna False para números em outros formatos (hex, binary) ou caracteres não numéricos 69 | print(f"É decimal? {texto1.isdecimal()}") 70 | 71 | # Verifica se a string está formatada como título 72 | # Exemplo de título: "Hello World" (primeira letra de cada palavra em maiúsculo) 73 | print(f"É título? {texto1.istitle()}") 74 | 75 | # Verifica se todos os caracteres estão em minúsculo 76 | # Retorna False se houver qualquer caractere em maiúsculo 77 | print(f"É minúsculo? {texto1.islower()}") 78 | 79 | # Verifica se todos os caracteres estão em maiúsculo 80 | # Retorna False se houver qualquer caractere em minúsculo 81 | print(f"É maiúsculo? {texto1.isupper()}") 82 | 83 | # 9. Comparação usando operadores de cadeia 84 | print("\n=== Comparação encadeada ===") 85 | print(f"'A' <= 'Python' <= 'Z': {'A' <= texto1 <= 'Z'}") 86 | print(f"Comparação múltipla: {3 < len(texto1) < 10}") 87 | -------------------------------------------------------------------------------- /Aula 28/Ex28.py: -------------------------------------------------------------------------------- 1 | # Conceitos avançados de manipulação de strings 2 | texto = "Python Programming" 3 | texto_espacado = " Python com espaços " 4 | 5 | # 1. Acessando caracteres por índice 6 | primeiro_caractere = texto[0] # P 7 | ultimo_caractere = texto[-1] # g 8 | 9 | # 2. Fatiamento (slicing) 10 | primeiras_letras = texto[0:6] # Python 11 | 12 | # 3. Métodos básicos de string 13 | texto_maiusculo = texto.upper() # Converte para maiúsculo 14 | texto_minusculo = texto.lower() # Converte para minúsculo 15 | texto_titulo = texto.title() # Primeira letra de cada palavra em maiúsculo 16 | 17 | # 4. Verificação de conteúdo 18 | contem_python = "Python" in texto # Verifica se contém a palavra 19 | comeca_com = texto.startswith("Py") # Verifica se começa com 20 | 21 | # 5. Remoção de espaços em branco 22 | texto_sem_espacos = texto_espacado.strip() # Remove espaços no início e fim 23 | texto_sem_espacos_esq = texto_espacado.lstrip() # Remove espaços à esquerda 24 | texto_sem_espacos_dir = texto_espacado.rstrip() # Remove espaços à direita 25 | 26 | # 6. Substituição de caracteres 27 | texto_substituido = texto.replace("Python", "Java") 28 | 29 | # 7. Dividindo strings 30 | palavras = texto.split() # Divide por espaços 31 | caracteres = list(texto) # Converte string em lista de caracteres 32 | 33 | # 8. Encontrando posições 34 | # Retorna o índice onde começa "Programming" 35 | posicao = texto.find("Programming") 36 | contagem = texto.count("m") # Conta quantas vezes 'm' aparece 37 | 38 | # 9. Junção de strings 39 | lista_palavras = ["Python", "é", "incrível"] 40 | texto_junto = " ".join(lista_palavras) 41 | 42 | # 10. Verificações adicionais 43 | e_alfanumerico = texto.isalnum() # Verifica se são só letras e números 44 | e_alfabetico = texto.isalpha() # Verifica se são só letras 45 | e_decimal = "123".isdecimal() # Verifica se são só números decimais 46 | 47 | # Exibindo os resultados 48 | print(f"Texto original: {texto}") 49 | print(f"Primeiro caractere: {primeiro_caractere}") 50 | print(f"Último caractere: {ultimo_caractere}") 51 | print(f"Primeiras letras: {primeiras_letras}") 52 | print(f"Maiúsculas: {texto_maiusculo}") 53 | print(f"Minúsculas: {texto_minusculo}") 54 | print(f"Título: {texto_titulo}") 55 | print(f"Contém 'Python'?: {contem_python}") 56 | print(f"Começa com 'Py'?: {comeca_com}") 57 | 58 | # Exibindo os novos resultados 59 | print("\nResultados adicionais:") 60 | print(f"Texto sem espaços: '{texto_sem_espacos}'") 61 | print(f"Texto substituído: {texto_substituido}") 62 | print(f"Palavras separadas: {palavras}") 63 | print(f"Lista de caracteres: {caracteres}") 64 | print(f"Posição de 'Programming': {posicao}") 65 | print(f"Quantidade de 'm': {contagem}") 66 | print(f"Palavras unidas: {texto_junto}") 67 | print(f"É alfanumérico?: {e_alfanumerico}") 68 | print(f"É alfabético?: {e_alfabetico}") 69 | print(f"'123' é decimal?: {e_decimal}") 70 | -------------------------------------------------------------------------------- /Jogos/Adivinhacao.py: -------------------------------------------------------------------------------- 1 | import random 2 | 3 | def gerar_numero_aleatorio(min_val=1, max_val=100): 4 | return random.randint(min_val, max_val) 5 | 6 | def verificar_palpite(palpite, numero_secreto): 7 | if palpite < numero_secreto: 8 | return "maior" 9 | elif palpite > numero_secreto: 10 | return "menor" 11 | else: 12 | return "igual" 13 | 14 | def jogo_adivinhacao(): 15 | numero_secreto = gerar_numero_aleatorio(1, 100) 16 | tentativas = 0 17 | max_tentativas = 7 18 | 19 | print("=== JOGO DE ADIVINHAÇÃO ===") 20 | print(f"Tente adivinhar o número entre 1 e 100 em {max_tentativas} tentativas!") 21 | 22 | while tentativas < max_tentativas: 23 | try: 24 | palpite = int(input("Seu palpite: ")) 25 | tentativas += 1 26 | 27 | resultado = verificar_palpite(palpite, numero_secreto) 28 | if resultado == "igual": 29 | print(f"Parabéns! Você acertou em {tentativas} tentativas!") 30 | return True 31 | elif resultado == "maior": 32 | print(f"Tente um número MAIOR! Tentativas restantes: {max_tentativas - tentativas}") 33 | else: 34 | print(f"Tente um número MENOR! Tentativas restantes: {max_tentativas - tentativas}") 35 | 36 | except ValueError: 37 | print("Por favor, digite um número válido!") 38 | 39 | print(f"Game over! O número secreto era {numero_secreto}.") 40 | return False 41 | 42 | # Para jogar o jogo de adivinhação, descomente a linha abaixo 43 | jogo_adivinhacao() 44 | 45 | -------------------------------------------------------------------------------- /Jogos/JogoDaVelha.py: -------------------------------------------------------------------------------- 1 | # Estrutura para um jogo da velha usando matriz 2 | 3 | def jogar_velha(): 4 | # Inicializa um tabuleiro 3x3 vazio 5 | tabuleiro = [[" " for _ in range(3)] for _ in range(3)] 6 | jogador_atual = "X" 7 | jogo_ativo = True 8 | 9 | def mostrar_tabuleiro(): 10 | print(" 1 2 3") # Índices das colunas 11 | for i in range(3): 12 | print( 13 | f"{i+1} {tabuleiro[i][0]}|{tabuleiro[i][1]}|{tabuleiro[i][2]}") 14 | if i < 2: 15 | print(" -+-+-") 16 | 17 | def verificar_vitoria(): 18 | # Verificar linhas 19 | for i in range(3): 20 | if tabuleiro[i][0] == tabuleiro[i][1] == tabuleiro[i][2] != " ": 21 | return True 22 | 23 | # Verificar colunas 24 | for j in range(3): 25 | if tabuleiro[0][j] == tabuleiro[1][j] == tabuleiro[2][j] != " ": 26 | return True 27 | 28 | # Verificar diagonais 29 | if tabuleiro[0][0] == tabuleiro[1][1] == tabuleiro[2][2] != " ": 30 | return True 31 | if tabuleiro[0][2] == tabuleiro[1][1] == tabuleiro[2][0] != " ": 32 | return True 33 | 34 | return False 35 | 36 | def verificar_empate(): 37 | for i in range(3): 38 | for j in range(3): 39 | if tabuleiro[i][j] == " ": 40 | return False 41 | return True 42 | 43 | print("Jogo da Velha") 44 | print("Digite a linha (1-3) e coluna (1-3)") 45 | 46 | while jogo_ativo: 47 | mostrar_tabuleiro() 48 | try: 49 | linha = int( 50 | input(f"Jogador {jogador_atual}, escolha a linha (1-3): ")) - 1 51 | coluna = int( 52 | input(f"Jogador {jogador_atual}, escolha a coluna (1-3): ")) - 1 53 | 54 | if 0 <= linha <= 2 and 0 <= coluna <= 2 and tabuleiro[linha][coluna] == " ": 55 | tabuleiro[linha][coluna] = jogador_atual 56 | 57 | if verificar_vitoria(): 58 | mostrar_tabuleiro() 59 | print(f"Jogador {jogador_atual} venceu!") 60 | jogo_ativo = False 61 | elif verificar_empate(): 62 | mostrar_tabuleiro() 63 | print("Empate!") 64 | jogo_ativo = False 65 | else: 66 | jogador_atual = "O" if jogador_atual == "X" else "X" 67 | else: 68 | print("Posição inválida ou já ocupada!") 69 | except ValueError: 70 | print("Digite apenas números!") 71 | 72 | 73 | # Inicia o jogo quando o arquivo é executado diretamente 74 | if __name__ == "__main__": 75 | jogar_velha() 76 | -------------------------------------------------------------------------------- /Jogos/Termoo.py: -------------------------------------------------------------------------------- 1 | import random 2 | 3 | 4 | def escolher_palavra(): 5 | palavras = [ 6 | "python", "matriz", "codigo", "arcade", "banana", "caneta", 7 | "dormir", "escola", "folhas", "girafa", "hokage", "imagem", 8 | "janela", "kinder", "limpar", "manter", "navios", "objeto", 9 | "pacote", "quarto", "relevo", "senado", "triste", "urbano", 10 | "viagem", "xamego", "zeloso", "amores", "buscar", "cinema", 11 | "danado", "errado", "frente", "geladp", "humano", "indice", 12 | "jornal", "logica", "manual", "nitido", "operar", "plural", 13 | "quieto", "rapido", "sombra", "trator", "unicos", "vagoes", 14 | "widget", "xingar" 15 | ] 16 | # Filtrar apenas palavras com até 6 letras 17 | palavras_filtradas = [palavra for palavra in palavras if len(palavra) == 6] 18 | return random.choice(palavras_filtradas) 19 | 20 | 21 | def analisar_palpite(palpite, palavra_secreta): 22 | if len(palpite) != len(palavra_secreta): 23 | return f"O palpite deve ter {len(palavra_secreta)} letras!" 24 | 25 | resultado = "" 26 | # Cria uma cópia da palavra secreta para marcar letras já utilizadas 27 | palavra_copia = list(palavra_secreta) 28 | 29 | # Primeiro, marca as letras na posição correta 30 | for i, letra in enumerate(palpite): 31 | if i < len(palavra_secreta) and letra == palavra_secreta[i]: 32 | resultado += f"[{letra}] " # Letra na posição correta 33 | palavra_copia[i] = "*" # Marca como utilizada 34 | else: 35 | resultado += "_ " 36 | 37 | # Depois, verifica as letras na posição errada 38 | resultado += "\nLetras na palavra, mas em posição errada: " 39 | encontradas = False 40 | 41 | for i, letra in enumerate(palpite): 42 | if i < len(palavra_secreta) and letra != palavra_secreta[i] and letra in palavra_copia: 43 | resultado += letra + " " 44 | # Marca a primeira ocorrência como utilizada 45 | palavra_copia[palavra_copia.index(letra)] = "*" 46 | encontradas = True 47 | 48 | if not encontradas: 49 | resultado += "nenhuma" 50 | 51 | return resultado 52 | 53 | 54 | def exibir_palavra(palavra, palpites): 55 | if not palpites: 56 | return "_ " * len(palavra) 57 | 58 | # Retorna a análise do último palpite 59 | return analisar_palpite(palpites[-1], palavra) 60 | 61 | 62 | def menu_principal(): 63 | print("="*18) 64 | print("ADIVINHE A PALAVRA") 65 | print("="*18) 66 | print("- Letras na posição correta aparecem entre colchetes [A]") 67 | print("- Letras na palavra mas na posição errada são listadas separadamente") 68 | 69 | palavra_secreta = escolher_palavra() 70 | tentativas_maximas = 6 71 | tentativas = 0 72 | palpites = [] 73 | 74 | print(f"\nA palavra tem {len(palavra_secreta)} letras") 75 | 76 | while tentativas < tentativas_maximas: 77 | print(f"\nTentativa {tentativas+1}/{tentativas_maximas}") 78 | 79 | if palpites: 80 | print("\nSeus palpites anteriores:") 81 | for i, p in enumerate(palpites): 82 | print(f"Tentativa {i+1}: {p}") 83 | print(analisar_palpite(p, palavra_secreta)) 84 | print("----------------------------------------") 85 | 86 | palpite = input( 87 | f"Digite uma palavra com {len(palavra_secreta)} letras: ").lower() 88 | 89 | if len(palpite) != len(palavra_secreta): 90 | print( 91 | f"Por favor, digite exatamente {len(palavra_secreta)} letras!") 92 | continue 93 | 94 | palpites.append(palpite) 95 | tentativas += 1 96 | 97 | if palpite == palavra_secreta: 98 | print(f"\nPARABÉNS! Você acertou a palavra: {palavra_secreta}") 99 | break 100 | 101 | print("\nAnálise do seu palpite:") 102 | print(analisar_palpite(palpite, palavra_secreta)) 103 | 104 | if tentativas == tentativas_maximas and palpites[-1] != palavra_secreta: 105 | print(f"\nVocê perdeu! A palavra era: {palavra_secreta}") 106 | 107 | jogar_novamente = input("\nDeseja jogar novamente? (s/n): ").lower() 108 | if jogar_novamente == "s": 109 | menu_principal() 110 | else: 111 | print("Obrigado por jogar!") 112 | 113 | 114 | # Iniciar o jogo 115 | if __name__ == "__main__": 116 | menu_principal() 117 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # 🐍 Repositório de Códigos Python para Estudo e Ensino 2 | 3 | Este repositório contém códigos desenvolvidos em Python com o objetivo de auxiliar no ensino e na aprendizagem de conceitos fundamentais de programação. Os códigos são utilizados nas aulas e também organizados para estudo individual. 4 | 5 | ## 📚 Objetivo 6 | 7 | Disponibilizar exemplos práticos, simples e didáticos para apoiar o ensino de lógica de programação, algoritmos e fundamentos da linguagem Python. 8 | 9 | ## 🎓 Público-alvo 10 | 11 | Estudantes iniciantes em programação, ou profissionais que queiram revisar conceitos da linguagem de forma simples e explicada. 12 | 13 | ## 🧠 O que você encontrará aqui? 14 | 15 | - Exemplos de sintaxe básica em Python 16 | - Algoritmos clássicos (estrutura de decisão, repetição, listas, etc.) 17 | - Práticas com funções e modularização 18 | - Conceitos de Programação Orientada a Objetos (POO) 19 | - Exercícios resolvidos com comentários 20 | - Projetos simples com interface em terminal 21 | - Scripts organizados por tema ou aula 22 | 23 | --- 24 | 25 | > ✨ Sinta-se à vontade para explorar, adaptar e contribuir com o repositório para fortalecer o aprendizado colaborativo. 26 | -------------------------------------------------------------------------------- /Rev/1.py: -------------------------------------------------------------------------------- 1 | # Seção 1: Manipulação de Strings 2 | # Limpeza de Texto: Crie uma função que remova espaços em branco extras no início e fim de uma string, e entre palavras deixe apenas um espaço. 3 | def limpar_texto(texto): 4 | """Remove espaços extras no início, fim e entre palavras.""" 5 | # Remove espaços no início e fim, depois substitui múltiplos espaços por um só 6 | return " ".join(texto.strip().split()) 7 | 8 | # Teste da função limpar_texto 9 | texto_sujo = " Olá, mundo ! " 10 | print(f"Original: '{texto_sujo}'") 11 | print(f"Limpo: '{limpar_texto(texto_sujo)}'") 12 | 13 | 14 | # Extração de Substrings: Escreva um programa que extrai partes específicas de uma string usando fatiamento (slicing). 15 | def extrair_substrings(texto): 16 | """Demonstra diferentes técnicas de fatiamento de strings.""" 17 | print(f"Texto original: '{texto}'") 18 | print(f"Primeiros 5 caracteres: '{texto[:5]}'") 19 | print(f"Últimos 5 caracteres: '{texto[-5:]}'") 20 | print(f"Do 6º ao 10º caractere: '{texto[5:10]}'") 21 | print(f"Caracteres em posições pares: '{texto[::2]}'") 22 | print(f"Texto reverso: '{texto[::-1]}'") 23 | 24 | # Teste da função extrair_substrings 25 | texto_exemplo = "O aprendizado é uma jornada, não um destino" 26 | extrair_substrings(texto_exemplo) 27 | 28 | 29 | # Comparação Insensível a Caso: Implemente uma função que verifica se duas strings são iguais, ignorando diferenças entre maiúsculas e minúsculas. 30 | def comparar_strings_insensivel(str1, str2): 31 | """Verifica se duas strings são iguais, ignorando maiúsculas e minúsculas.""" 32 | return str1.lower() == str2.lower() 33 | 34 | # Teste da função comparar_strings_insensivel 35 | string1 = "Python" 36 | string2 = "PYTHON" 37 | string3 = "python!" 38 | print(f"'{string1}' == '{string2}' (ignorando caso): {comparar_strings_insensivel(string1, string2)}") 39 | print(f"'{string1}' == '{string3}' (ignorando caso): {comparar_strings_insensivel(string1, string3)}") 40 | 41 | 42 | # Validação de Texto: Crie um programa que verifica se uma string contém apenas letras do alfabeto. 43 | def contem_apenas_letras(texto): 44 | """Verifica se uma string contém apenas letras do alfabeto.""" 45 | return texto.isalpha() 46 | 47 | # Teste da função contem_apenas_letras 48 | texto1 = "Teste" 49 | texto2 = "Teste3" 50 | texto3 = "Teste!" 51 | print(f"'{texto1}' contém apenas letras? {contem_apenas_letras(texto1)}") 52 | print(f"'{texto2}' contém apenas letras? {contem_apenas_letras(texto2)}") 53 | print(f"'{texto3}' contém apenas letras? {contem_apenas_letras(texto3)}") 54 | 55 | 56 | # Substituição de Texto: Escreva uma função que substitui todas as ocorrências de uma palavra por outra em um texto. 57 | def substituir_palavra(texto, palavra_antiga, palavra_nova): 58 | """Substitui todas as ocorrências de uma palavra por outra em um texto.""" 59 | return texto.replace(palavra_antiga, palavra_nova) 60 | 61 | # Teste da função substituir_palavra 62 | frase = "Não se trata de saber tudo, mas de saber onde encontrar as respostas." 63 | nova_frase = substituir_palavra(frase, "respostas", "perguntas") 64 | print(f"Original: '{frase}'") 65 | print(f"Substituída: '{nova_frase}'") -------------------------------------------------------------------------------- /Rev/2.py: -------------------------------------------------------------------------------- 1 | import random 2 | 3 | # Seção 2: Matrizes e Listas 4 | 5 | # Criação de Matriz: matriz 3x3 com números aleatórios entre 1 e 100 6 | 7 | 8 | def criar_matriz(): 9 | matriz = [[random.randint(1, 100) for _ in range(3)] for _ in range(3)] 10 | return matriz 11 | 12 | # Manipulação de Elementos: acessa e modifica elementos específicos em uma matriz 13 | 14 | 15 | def manipular_elementos(matriz): 16 | print("Matriz original:") 17 | for linha in matriz: 18 | print(linha) 19 | 20 | # Acessando elemento na posição [1][1] (centro da matriz 3x3) 21 | elemento_central = matriz[1][1] 22 | print(f"\nElemento central [1][1]: {elemento_central}") 23 | 24 | # Modificando o elemento na posição [0][2] (canto superior direito) 25 | matriz[0][2] = 999 26 | print("\nMatriz após modificação:") 27 | for linha in matriz: 28 | print(linha) 29 | 30 | return matriz 31 | 32 | # Soma Diagonal: calcula a soma da diagonal principal 33 | 34 | 35 | def soma_diagonal(matriz): 36 | soma = sum(matriz[i][i] for i in range(len(matriz))) 37 | return soma 38 | 39 | # Transposição de Matriz: troca linhas por colunas 40 | 41 | 42 | def transpor_matriz(matriz): 43 | transposta = [[matriz[j][i] 44 | for j in range(len(matriz))] for i in range(len(matriz[0]))] 45 | return transposta 46 | 47 | 48 | # Demonstração das funções 49 | if __name__ == "__main__": 50 | print("=== Demonstração da Seção 2: Matrizes e Listas ===\n") 51 | 52 | # Criar matriz 53 | print("1. Criação de Matriz:") 54 | matriz = criar_matriz() 55 | for linha in matriz: 56 | print(linha) 57 | print() 58 | 59 | # Manipular elementos 60 | print("2. Manipulação de Elementos:") 61 | matriz = manipular_elementos(matriz) 62 | print() 63 | 64 | # Soma diagonal 65 | print("3. Soma da Diagonal Principal:") 66 | soma = soma_diagonal(matriz) 67 | print(f"A soma da diagonal principal é: {soma}") 68 | print() 69 | 70 | # Transposição 71 | print("4. Transposição de Matriz:") 72 | transposta = transpor_matriz(matriz) 73 | print("Matriz original:") 74 | for linha in matriz: 75 | print(linha) 76 | print("Matriz transposta:") 77 | for linha in transposta: 78 | print(linha) 79 | -------------------------------------------------------------------------------- /Rev/3.py: -------------------------------------------------------------------------------- 1 | # Seção 3: List Comprehensions 2 | # Filtro de Pares/Ímpares: Use list comprehension para filtrar números pares e ímpares de uma lista. 3 | 4 | import random 5 | 6 | 7 | def filtrar_pares_impares(numeros): 8 | """ 9 | Filtra números pares e ímpares de uma lista usando list comprehension. 10 | """ 11 | pares = [num for num in numeros if num % 2 == 0] 12 | impares = [num for num in numeros if num % 2 != 0] 13 | return pares, impares 14 | 15 | # Exemplo de uso: 16 | numeros_exemplo = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 17 | pares, impares = filtrar_pares_impares(numeros_exemplo) 18 | print(f"Números originais: {numeros_exemplo}") 19 | print(f"Números pares: {pares}") 20 | print(f"Números ímpares: {impares}") 21 | 22 | # Criação de uma matriz 3x3 usando list comprehension 23 | matriz_3x3 = [[col for col in range(1, 4)] for _ in range(3)] 24 | print("Matriz 3x3:") 25 | for linha in matriz_3x3: 26 | print(linha) 27 | 28 | matriz = [[random.randint(1, 100) for _ in range(3)] for _ in range(3)] 29 | 30 | for linha in matriz: 31 | print(linha) -------------------------------------------------------------------------------- /Rev/4.py: -------------------------------------------------------------------------------- 1 | # Seção 4: Estruturas de Controle e Funções 2 | 3 | # Match-Case: Implemente um programa que utiliza a estrutura match-case (Python 3.10+) para diferentes opções de menu. 4 | def menu_com_match_case(): 5 | print("\n===== Menu de Opções =====") 6 | print("1. Calcular área de um círculo") 7 | print("2. Verificar se número é par ou ímpar") 8 | print("3. Converter temperatura para Fahrenheit") 9 | print("4. Sair") 10 | 11 | opcao = input("Escolha uma opção (1-4): ") 12 | 13 | match opcao: 14 | case "1": 15 | raio = float(input("Digite o raio do círculo: ")) 16 | area = 3.14159 * raio * raio 17 | print(f"A área do círculo é: {area:.2f}") 18 | case "2": 19 | num = int(input("Digite um número inteiro: ")) 20 | resultado = "par" if num % 2 == 0 else "ímpar" 21 | print(f"O número {num} é {resultado}.") 22 | case "3": 23 | celsius = float(input("Digite a temperatura em Celsius: ")) 24 | fahrenheit = (celsius * 9/5) + 32 25 | print(f"{celsius}°C equivale a {fahrenheit:.1f}°F") 26 | case "4": 27 | print("Saindo do programa...") 28 | return False 29 | case _: 30 | print("Opção inválida! Tente novamente.") 31 | return True 32 | 33 | # Função com Tratamento de Erros: Crie uma função de divisão que trata adequadamente possíveis divisões por zero. 34 | def divisao_segura(numerador, denominador): 35 | try: 36 | resultado = numerador / denominador 37 | return resultado 38 | except ZeroDivisionError: 39 | return "Erro: Divisão por zero não é permitida" 40 | except TypeError: 41 | return "Erro: Os valores fornecidos devem ser numéricos" 42 | 43 | # Estrutura Principal: Implemente um programa que usa a estrutura if __name__ == "__main__" corretamente. 44 | def calcular_media(numeros): 45 | if not numeros: 46 | return 0 47 | return sum(numeros) / len(numeros) 48 | 49 | def obter_lista_numeros(): 50 | entrada = input("Digite números separados por espaço: ") 51 | try: 52 | return [float(num) for num in entrada.split()] 53 | except ValueError: 54 | print("Entrada inválida. Use apenas números.") 55 | return [] 56 | 57 | if __name__ == "__main__": 58 | print("Executando o programa como script principal") 59 | 60 | # Demonstração da função divisão segura 61 | print(f"10 / 2 = {divisao_segura(10, 2)}") 62 | print(f"10 / 0 = {divisao_segura(10, 0)}") 63 | 64 | # Demonstração do cálculo de média 65 | numeros = obter_lista_numeros() 66 | if numeros: 67 | print(f"A média dos números é: {calcular_media(numeros):.2f}") 68 | 69 | # Demonstração do menu com match-case 70 | executando = True 71 | while executando: 72 | executando = menu_com_match_case() 73 | else: 74 | print("Este módulo foi importado por outro script") -------------------------------------------------------------------------------- /Rev/5.py: -------------------------------------------------------------------------------- 1 | def formatar_numeros(): 2 | """ 3 | Demonstração de formatação de números com diferentes precisões decimais usando f-strings. 4 | """ 5 | valor = 123.456789 6 | 7 | print("Exemplos de formatação com f-strings:") 8 | print(f"Valor original: {valor}") 9 | print(f"Com 2 casas decimais: {valor:.2f}") 10 | print(f"Com 4 casas decimais: {valor:.4f}") 11 | print(f"Notação científica: {valor:.2e}") 12 | print(f"Preenchimento com zeros (total 10 dígitos): {valor:010.2f}") 13 | print(f"Com separador de milhar: {1234567.89:,.2f}") 14 | print(f"Porcentagem: {0.7251:.2%}") 15 | 16 | # Alinhamento e espaçamento 17 | print(f"{'Alinhado à direita':>20}") 18 | print(f"{'Centralizado':^20}") 19 | print(f"{'Alinhado à esquerda':<20}") 20 | 21 | 22 | def entrada_segura(mensagem, tipo=float): 23 | """ 24 | Solicita entrada numérica do usuário com tratamento de exceções. 25 | """ 26 | while True: 27 | try: 28 | valor = tipo(input(mensagem)) 29 | return valor 30 | except ValueError: 31 | print(f"Erro: Por favor, digite um valor {tipo.__name__} válido.") 32 | except KeyboardInterrupt: 33 | print("\nOperação cancelada pelo usuário.") 34 | return None 35 | 36 | 37 | def exibir_matriz_formatada(matriz): 38 | """ 39 | Exibe uma matriz formatada com alinhamento e espaçamento adequados. 40 | """ 41 | if not matriz: 42 | print("Matriz vazia.") 43 | return 44 | 45 | # Determinar a largura máxima para cada coluna 46 | num_colunas = len(matriz[0]) 47 | larguras = [0] * num_colunas 48 | 49 | for linha in matriz: 50 | for i, valor in enumerate(linha): 51 | larguras[i] = max(larguras[i], len(str(valor))) 52 | 53 | # Imprimir a matriz formatada 54 | print("Matriz formatada:") 55 | for linha in matriz: 56 | linha_str = " | ".join(f"{str(valor):^{larguras[i]}}" for i, valor in enumerate(linha)) 57 | print(f"| {linha_str} |") 58 | 59 | 60 | def demonstrar_todos(): 61 | """Demonstra todas as funções de tratamento de entrada/saída.""" 62 | 63 | # 1. Formatação de saída 64 | formatar_numeros() 65 | print("\n" + "-" * 50 + "\n") 66 | 67 | # 2. Entrada segura 68 | print("Demonstração de entrada segura:") 69 | idade = entrada_segura("Digite sua idade (número inteiro): ", int) 70 | if idade is not None: 71 | print(f"Idade registrada: {idade}") 72 | 73 | altura = entrada_segura("Digite sua altura em metros: ") 74 | if altura is not None: 75 | print(f"Altura registrada: {altura:.2f} metros") 76 | 77 | print("\n" + "-" * 50 + "\n") 78 | 79 | # 3. Exibição formatada 80 | print("Demonstração de exibição formatada de matriz:") 81 | matriz_exemplo = [ 82 | [10, 25, 8, 100], 83 | [5, 12345, 7, 9], 84 | [42, 98, 1000, 3] 85 | ] 86 | exibir_matriz_formatada(matriz_exemplo) 87 | 88 | 89 | if __name__ == "__main__": 90 | demonstrar_todos() -------------------------------------------------------------------------------- /Rev/Revisao.py: -------------------------------------------------------------------------------- 1 | # Seção 1: Manipulação de Strings 2 | # Limpeza de Texto: Crie uma função que remova 3 | # espaços em branco extras no início e 4 | # fim de uma string, e entre palavras deixe apenas 5 | # um espaço. 6 | 7 | 8 | # Extração de Substrings: Escreva um programa que 9 | # extrai partes específicas de 10 | # uma string usando fatiamento (slicing). 11 | 12 | 13 | # Comparação Insensível a Caso: Implemente uma função que verifica se duas 14 | # strings são iguais, ignorando diferenças entre maiúsculas e minúsculas. 15 | 16 | 17 | # Validação de Texto: Crie um programa que verifica se uma string contém apenas 18 | # letras do alfabeto. 19 | 20 | 21 | # Substituição de Texto: Escreva uma função que substitui todas as ocorrências de 22 | # uma palavra por outra em um texto. 23 | 24 | 25 | # Seção 2: Matrizes e Listas 26 | # Criação de Matriz: Crie uma matriz 3x3 com números aleatórios entre 1 e 100 usando 27 | # list comprehension. 28 | 29 | 30 | # Manipulação de Elementos: Escreva um programa que acessa e modifica elementos específicos 31 | # em uma matriz. 32 | 33 | 34 | # Soma Diagonal: Implemente uma função que calcula a soma da diagonal principal de 35 | # uma matriz quadrada. 36 | 37 | 38 | # Transposição de Matriz: Crie uma função que transpõe uma matriz (troca linhas por colunas). 39 | 40 | 41 | # Seção 3: List Comprehensions 42 | # Filtro de Pares/Ímpares: Use list comprehension para filtrar números pares e ímpares 43 | # de uma lista. 44 | 45 | 46 | # Seção 4: Estruturas de Controle e Funções 47 | # Match-Case: Implemente um programa que utiliza a estrutura match-case (Python 3.10+) 48 | # para diferentes opções de menu. 49 | 50 | 51 | # Função com Tratamento de Erros: Crie uma função de divisão que trata adequadamente 52 | # possíveis divisões por zero. 53 | 54 | 55 | # Estrutura Principal: Implemente um programa que usa a estrutura if __name__ == "__main__" 56 | # corretamente. 57 | 58 | 59 | # Seção 5: Tratamento de Entrada/Saída 60 | # Formatação de Saída: Escreva um programa que usa f-strings para formatar 61 | # números com diferentes precisões decimais. 62 | 63 | 64 | # Entrada Segura: Implemente uma função que solicita entrada numérica do 65 | # usuário com tratamento de exceções. 66 | 67 | 68 | # Exibição Formatada: Crie um programa que exibe uma matriz com alinhamento e 69 | # espaçamento adequados. --------------------------------------------------------------------------------