diff --git a/.hintrc b/.hintrc deleted file mode 100644 index cb34607..0000000 --- a/.hintrc +++ /dev/null @@ -1,8 +0,0 @@ -{ - "extends": [ - "development" - ], - "hints": { - "no-inline-styles": "off" - } -} \ No newline at end of file diff --git a/1_section_Programming_logic/Dictionaries.ipynb b/1_section_Programming_logic/Dictionaries.ipynb index 381f7db..0b76ee1 100644 --- a/1_section_Programming_logic/Dictionaries.ipynb +++ b/1_section_Programming_logic/Dictionaries.ipynb @@ -2396,7 +2396,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "id": "97c8c4e0", "metadata": {}, "outputs": [ @@ -2413,23 +2413,9 @@ "5. Sair\n", "Escolha uma opção: 1\n", "\n", - "Digite o nome do contato: A\n", - "Digite o número de telefone: 778787\n", - "{'A': '778787'}\n", - "\n", - "Contato adicionado com sucesso!\n", - "\n", - "MENU:\n", - "1. Adicionar contato\n", - "2. Alterar contato\n", - "3. Remover contato\n", - "4. Listar contatos\n", - "5. Sair\n", - "Escolha uma opção: 1\n", - "\n", - "Digite o nome do contato: Bia\n", - "Digite o número de telefone: 78787\n", - "{'A': '778787', 'Bia': '78787'}\n", + "Digite o nome do contato: Steve\n", + "Digite o número de telefone: 55554555\n", + "{'Steve': '55554555'}\n", "\n", "Contato adicionado com sucesso!\n", "\n", @@ -2439,51 +2425,9 @@ "3. Remover contato\n", "4. Listar contatos\n", "5. Sair\n", - "Escolha uma opção: 4\n", - "\n", - "Nome: A\n", - "Telefone: 778787\n", - "\n", - "Nome: Bia\n", - "Telefone: 78787\n", - "\n", - "MENU:\n", - "1. Adicionar contato\n", - "2. Alterar contato\n", - "3. Remover contato\n", - "4. Listar contatos\n", - "5. Sair\n", - "Escolha uma opção: 2\n", - "\n", - "Digite o nome do contato que deseja alterar: A\n", - "Digite o novo nome para o contato (deixe em branco para manter o nome atual): Amanda\n", - "Digite o novo número de telefone (deixe em branco para manter o atual): 5659\n", - "\n", - "Contato atualizado com sucesso!\n", - "\n", - "MENU:\n", - "1. Adicionar contato\n", - "2. Alterar contato\n", - "3. Remover contato\n", - "4. Listar contatos\n", - "5. Sair\n", - "Escolha uma opção: 4\n", - "\n", - "Nome: Bia\n", - "Telefone: 78787\n", - "\n", - "Nome: Amanda\n", - "Telefone: 5659\n", - "\n", - "MENU:\n", - "1. Adicionar contato\n", - "2. Alterar contato\n", - "3. Remover contato\n", - "4. Listar contatos\n", - "5. Sair\n", "Escolha uma opção: 3\n", "\n", - "Digite o nome do contato que deseja remover: Bia\n", + "Digite o nome do contato que deseja remover: Steve\n", "\n", "Contato removido com sucesso!\n", "\n", @@ -2493,16 +2437,6 @@ "3. Remover contato\n", "4. Listar contatos\n", "5. Sair\n", - "Escolha uma opção: 9\n", - "\n", - "Opção inválida!\n", - "\n", - "MENU:\n", - "1. Adicionar contato\n", - "2. Alterar contato\n", - "3. Remover contato\n", - "4. Listar contatos\n", - "5. Sair\n", "Escolha uma opção: 5\n" ] } @@ -2679,12 +2613,14 @@ " # Se o usuário escolher uma opção que não está no menu:\n", " else:\n", " \n", - " # Exibe uma mensagem de erro.\n", - " print(\"\\nOpção inválida!\")\n", + " # Exibe uma mensagem de erro:\n", + " \n", + " print(\"\\nDigite a opção comforme a tabela mostra:\")\n", "\n", "\n", "# Chama a função principal para executar o programa\n", - "main()\n" + "main()\n", + " \n" ] }, { diff --git a/1_section_Programming_logic/Matrices.ipynb b/1_section_Programming_logic/Matrices.ipynb new file mode 100644 index 0000000..6a60169 --- /dev/null +++ b/1_section_Programming_logic/Matrices.ipynb @@ -0,0 +1,1278 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "b0452902", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[10, 11, 12], [13, 14, 15], [16, 17, 18]]\n", + "\n", + "Imprimindo Matriz A\n", + "Matriz A:\n", + "\n", + "10 11 12 \n", + "13 14 15 \n", + "16 17 18 \n", + "\n", + "Matriz B:\n", + "1 2 3 \n", + "4 5 6 \n", + "7 8 9 \n", + "\n", + "Matriz D:\n", + "0 0 0 \n", + "0 0 0 \n", + "0 0 0 \n", + "\n", + "Subtração das matrizes A e B\n", + "[9, 9, 9]\n", + "[9, 9, 9]\n", + "[9, 9, 9]\n", + "\n", + "Soma das matrizes A e B:\n", + "11 13 15 \n", + "17 19 21 \n", + "23 25 27 \n", + "\n", + "A soma dos elementos da diagonal da matriz A é: 42\n" + ] + } + ], + "source": [ + "\"\"\"\n", + "Matrizes:\n", + "\n", + " Inicializando as duas matrizes e a matriz resultado\n", + " Usando loops for aninhados para subtrair elementos correspondentes\n", + "\"\"\"\n", + "\n", + "#Exemplo Prático: Subtração de Matrizes 3x3 em Python\n", + "\n", + "#A subtração de matrizes, assim como a adição, é uma operação elemento \n", + "#a elemento. Para subtrair duas matrizes, elas devem ter as mesmas dimensões. \n", + "#O resultado é uma nova matriz com a mesma dimensão, onde cada elemento é a diferença \n", + "#dos elementos correspondentes das duas matrizes originais.\n", + "\n", + "#Inicializando as duas matrizes e a matriz resultado:\n", + "\n", + "# Inicializa a matriz A com valores pré-definidos\n", + "A = [[10, 11, 12], [13, 14, 15], [16, 17, 18]]\n", + "print(A)\n", + "\n", + "# Imprime uma quebra de linha seguida de um título para a matriz A\n", + "print(\"\\nImprimindo Matriz A\")\n", + "\n", + "# Imprime o título para a matriz A\n", + "print(\"Matriz A:\\n\")\n", + "\n", + "# Inicia um loop para percorrer as linhas da matriz\n", + "for row in range(3): \n", + " \n", + " # Inicia um loop interno para percorrer as colunas da matriz\n", + " for column in range(3): \n", + " \n", + " # Imprime o valor do elemento atual da matriz seguido de dois espaços, sem quebrar a linha\n", + " print(f\"{A[row][column]}\", end=\" \") \n", + " \n", + " # Imprime uma quebra de linha após imprimir todos os elementos de uma linha completa da matriz\n", + " print() \n", + "\n", + "\n", + "# Inicializa a matriz B com valores pré-definidos\n", + "B = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n", + "\n", + "# Imprime uma quebra de linha seguida de um título para a matriz B\n", + "print(\"\\nMatriz B:\")\n", + "\n", + "# Inicia um loop para percorrer as linhas da matriz\n", + "for row in range(3): \n", + " \n", + " # Inicia um loop interno para percorrer as colunas da matriz\n", + " for column in range(3): \n", + " \n", + " # Imprime o valor do elemento atual da matriz seguido de dois espaços, sem quebrar a linha\n", + " print(f\"{B[row][column]}\", end=\" \") \n", + " \n", + " # Imprime uma quebra de linha após imprimir todos os elementos de uma linha completa da matriz\n", + " print() \n", + "\n", + "\n", + "# Inicializa a matriz D com todos os elementos sendo zero\n", + "D = [\n", + " [0, 0, 0], \n", + " [0, 0, 0], \n", + " [0, 0, 0]\n", + "]\n", + "\n", + "# Imprime o título para a matriz D\n", + "print(\"\\nMatriz D:\")\n", + "\n", + "# Inicia um loop para percorrer as linhas da matriz\n", + "for row in range(3):\n", + " \n", + " # Inicia um loop interno para percorrer as colunas da matriz\n", + " for column in range(3):\n", + " \n", + " # Imprime o valor do elemento atual da matriz seguido de dois espaços, sem quebrar a linha\n", + " print(f\"{D[row][column]}\", end=\" \")\n", + " \n", + " # Imprime uma quebra de linha após imprimir todos os elementos de uma linha completa da matriz\n", + " print()\n", + " \n", + " \n", + "# Subtração das matrizes A e B\n", + "\n", + "print(\"\\nSubtração das matrizes A e B\")\n", + "# Inicia um loop para percorrer as linhas da matriz\n", + "for row in range(3): \n", + " \n", + " # Inicia um loop interno para percorrer as colunas da matriz\n", + " for column in range(3): \n", + " \n", + " # Subtrai o valor da matriz B do valor correspondente na matriz A e armazena o resultado na matriz D\n", + " D[row][column] = A[row][column] - B[row][column]\n", + "\n", + "# Inicia um loop para percorrer cada linha da matriz D\n", + "for row in D:\n", + " \n", + " # Imprime a linha atual da matriz D\n", + " print(row)\n", + "\n", + " \n", + "print(\"\\nSoma das matrizes A e B:\")\n", + "\n", + "# Inicia um loop para percorrer as linhas da matriz\n", + "for row in range(3): \n", + " \n", + " # Inicia um loop interno para percorrer as colunas da matriz\n", + " for column in range(3): \n", + " \n", + " # Soma o valor da matriz A com o valor correspondente na matriz B e armazena o resultado na matriz D\n", + " D[row][column] = A[row][column] + B[row][column]\n", + " \n", + " # Imprime o valor resultante da soma atual seguido de dois espaços, sem quebrar a linha\n", + " print(f\"{D[row][column]}\", end=\" \") \n", + " \n", + " # Imprime uma quebra de linha após imprimir todos os elementos de uma linha completa da matriz\n", + " print() \n", + " \n", + " \n", + "# Inicializa a variável que armazenará a soma dos elementos da diagonal principal da matriz\n", + "soma_diagonal = 0\n", + "\n", + "# Inicia um loop para percorrer os elementos da diagonal principal da matriz 3x3\n", + "for i in range(3):\n", + " \n", + " # Adiciona o valor do elemento atual da diagonal principal ao acumulador soma_diagonal\n", + " #soma_diagonal = soma_diagonal + B[i][i]\n", + " soma_diagonal += A[i][i]\n", + "\n", + "# Imprime o resultado da soma dos elementos da diagonal principal\n", + "print(f\"\\nA soma dos elementos da diagonal da matriz A é: {soma_diagonal}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "16e23444", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ecab12a6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The sum of the even numbers in the matrix is: 72\n" + ] + } + ], + "source": [ + "\"\"\"\n", + "Exercício: Soma dos Números Pares em uma Matriz 4x4\n", + "\n", + "Enunciado:\n", + "\n", + "Dada a seguinte matriz 4x4:\n", + "1 2 3 4\n", + "5 6 7 8\n", + "9 10 11 12\n", + "13 14 15 16\n", + "\n", + " - Escreva um programa em Python que percorre cada elemento da matriz.\n", + " - Some todos os números pares presentes na matriz.\n", + " - Imprima o resultado da soma.\n", + "\n", + "Dica: Use loops for aninhados para percorrer cada linha e coluna da matriz. \n", + "Utilize o operador % para verificar se um número é par.\n", + "\n", + "Ao resolver o exercício, os alunos devem ser capazes de navegar pelos elementos \n", + "da matriz, aplicar condições lógicas e acumular valores baseados em critérios específicos.\n", + "\"\"\"\n", + "\n", + "#Solução:\n", + "\n", + "# Dada matriz 4x4\n", + "M = [\n", + " [1, 2, 3, 4],\n", + " [5, 6, 7, 8],\n", + " [9, 10, 11, 12],\n", + " [13, 14, 15, 16]\n", + "]\n", + "\n", + "# Inicializa o acumulador para armazenar a soma dos elementos pares da matriz\n", + "soma_pares = 0\n", + "\n", + "# Inicia um loop para percorrer as linhas da matriz\n", + "for linha in range(4): \n", + " \n", + " # Inicia um loop interno para percorrer as colunas da matriz\n", + " for coluna in range(4): \n", + " \n", + " # Verifica se o elemento atual da matriz é par\n", + " if M[linha][coluna] % 2 == 0:\n", + " \n", + " # Se o elemento for par, adiciona seu valor ao acumulador soma_pares\n", + " soma_pares += M[linha][coluna] \n", + "\n", + "\n", + "# Imprimindo o resultado\n", + "print(f\"The sum of the even numbers in the matrix is: {soma_pares}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "52a43ded", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "e2e8c9f6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matriz\n", + "1 2 3 4 \n", + "5 6 7 8 \n", + "9 10 11 12 \n", + "13 14 15 16 \n", + "\n", + "A soma dos valores da coluna 0 é: 28\n", + "\n", + "A soma dos valores da linha 3 é: 58\n" + ] + } + ], + "source": [ + "#Somar uma coluna\n", + "\n", + "#Podemos criar um código para somar os valores de uma coluna \n", + "#específica em uma matriz. Para este exemplo, vamos considerar \n", + "#que desejamos somar os valores da primeira coluna.\n", + "\n", + "# Inicializa a matriz M com valores pré-definidos\n", + "M = [\n", + " [1, 2, 3, 4],\n", + " [5, 6, 7, 8],\n", + " [9, 10, 11, 12],\n", + " [13, 14, 15, 16]\n", + "]\n", + "\n", + "# Imprime um título para a matriz\n", + "print(\"Matriz\")\n", + "\n", + "# Inicia um loop para percorrer as linhas da matriz\n", + "for linha in range(4): \n", + " \n", + " # Inicia um loop interno para percorrer as colunas da matriz\n", + " for coluna in range(4): \n", + " \n", + " # Imprime o valor do elemento atual da matriz seguido de dois espaços, sem quebrar a linha\n", + " print(f\"{M[linha][coluna]}\", end=\" \") \n", + " \n", + " # Imprime uma quebra de linha após imprimir todos os elementos de uma linha completa da matriz\n", + " print() \n", + " \n", + "# Define a coluna que desejamos somar (neste caso, a primeira coluna, cujo índice é 0)\n", + "coluna_especifica = 0\n", + "\n", + "# Inicializa o acumulador para armazenar a soma dos elementos da coluna especificada\n", + "soma_coluna = 0\n", + "\n", + "# Inicia um loop para percorrer as linhas da matriz\n", + "for linha in range(4): \n", + " \n", + " # Adiciona o valor do elemento atual da coluna especificada ao acumulador soma_coluna\n", + " soma_coluna += M[linha][coluna_especifica] \n", + "\n", + "# Imprime a soma dos valores da coluna especificada\n", + "print(f\"\\nA soma dos valores da coluna {coluna_especifica} é: {soma_coluna}\")\n", + "\n", + "\n", + "#Somar os valores da terceira linha:\n", + "\n", + "# Define a linha que desejamos somar (neste caso, a terceira linha, cujo índice é 2)\n", + "linha_especifica = 2\n", + "\n", + "# Inicializa o acumulador para armazenar a soma dos elementos da linha especificada\n", + "soma_linha = 0\n", + "\n", + "# Inicia um loop para percorrer as colunas da matriz\n", + "for coluna in range(4): \n", + " \n", + " # Adiciona o valor do elemento atual da linha especificada ao acumulador soma_linha\n", + " soma_linha += M[linha_especifica][coluna] \n", + "\n", + "# Imprime a soma dos valores da linha especificada\n", + "print(f\"A soma dos valores da linha {linha_especifica} é: {soma_linha}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88957d35", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "71aa39a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Digite o nome do aluno 1: Allan\n", + "Digite a nota 1 do aluno Allan: 10\n", + "Digite a nota 2 do aluno Allan: 9\n", + "Digite a nota 3 do aluno Allan: 8\n", + "Digite a nota 4 do aluno Allan: 6\n", + "Digite o nome do aluno 2: Bia\n", + "Digite a nota 1 do aluno Bia: 8\n", + "Digite a nota 2 do aluno Bia: 7\n", + "Digite a nota 3 do aluno Bia: 8\n", + "Digite a nota 4 do aluno Bia: 6\n", + "Digite o nome do aluno 3: Nicole\n", + "Digite a nota 1 do aluno Nicole: 10\n", + "Digite a nota 2 do aluno Nicole: 6\n", + "Digite a nota 3 do aluno Nicole: 5\n", + "Digite a nota 4 do aluno Nicole: 10\n", + "\n", + "----------------------------------------\n", + "Nome: Allan\n", + "Notas: [10.0, 9.0, 8.0, 6.0]\n", + "Média: 8.25\n", + "\n", + "----------------------------------------\n", + "Nome: Bia\n", + "Notas: [8.0, 7.0, 8.0, 6.0]\n", + "Média: 7.25\n", + "\n", + "----------------------------------------\n", + "Nome: Nicole\n", + "Notas: [10.0, 6.0, 5.0, 10.0]\n", + "Média: 7.75\n", + "\n" + ] + } + ], + "source": [ + "\"\"\"\n", + "Exemplo de Matrizes e Média de Notas\n", + "\n", + "Você foi contratado para desenvolver um sistema simples de registro de \n", + "notas para uma escola. O professor possui 3 alunos e para cada um, ele \n", + "deseja registrar 4 notas correspondentes aos bimestres do ano letivo.\n", + "\n", + "Tarefas:\n", + "\n", + " - Solicite ao usuário o nome de cada aluno.\n", + " - Para cada aluno, solicite as 4 notas correspondentes.\n", + " - Armazene todas essas informações em uma matriz, onde cada \n", + " linha representa um aluno e as colunas contêm o nome do \n", + " aluno seguido por suas 4 notas.\n", + " - Calcule a média das notas de cada aluno.\n", + " - Imprima o nome, as notas e a média de cada aluno.\n", + "\n", + "Dicas:\n", + "\n", + " Utilize loops for para percorrer os alunos e as notas.\n", + " Lembre-se de que a média é a soma das notas dividida pelo número total de notas.\n", + " Mantenha a organização do código para facilitar a leitura e a correção.\n", + "\"\"\"\n", + "\n", + "# Inicializa uma matriz vazia para armazenar os nomes e as notas dos alunos\n", + "student_matrix = []\n", + "\n", + "# Inicia um loop para coletar informações de 3 alunos\n", + "for i in range(3):\n", + " \n", + " # Solicita o nome do aluno atual\n", + " name = input(f\"Digite o nome do aluno {i + 1}: \")\n", + " \n", + " # Inicializa uma lista vazia para armazenar as notas do aluno atual\n", + " grades = []\n", + " \n", + " # Inicia um loop para coletar as 4 notas do aluno atual\n", + " for j in range(4):\n", + " \n", + " # Solicita a nota atual do aluno\n", + " grade = float(input(f\"Digite a nota {j + 1} do aluno {nome}: \"))\n", + " \n", + " # Adiciona a nota coletada à lista de notas\n", + " grades.append(grade)\n", + " \n", + " # Adiciona o nome do aluno e suas notas à matriz de alunos\n", + " student_matrix.append([name] + grades)\n", + " \n", + "\n", + "# Inicia um loop para imprimir as informações de cada aluno\n", + "for student in student_matrix:\n", + " \n", + " # Extrai o nome do aluno da lista atual\n", + " name = aluno[0]\n", + " \n", + " # Extrai as notas do aluno da lista atual\n", + " grade = aluno[1:]\n", + " \n", + " # Calcula a média das notas do aluno\n", + " average = sum(grades) / 4\n", + " \n", + " # Imprime as informações do aluno\n", + " print(\"\\n\" + \"-\"*40)\n", + " print(f\"Nome: {name}\")\n", + " print(f\"Notas: {grades}\")\n", + " print(f\"Média: {average:.2f}\")\n", + "\n", + " \n", + " \n", + "\"\"\"\n", + "Em Python, uma matriz é frequentemente representada como \n", + "uma lista de listas, e a palavra \"lista\" é usada para se referir \n", + "à estrutura de dados básica de sequência em Python, que é \n", + "implementada como uma array dinâmica.\n", + "\n", + "Quando dizemos \"matriz\" neste contexto, estamos nos referindo \n", + "a uma representação de uma matriz matemática. Então, matriz_alunos \n", + "é uma lista em Python, mas consideramos cada elemento dessa \n", + "lista (que também é uma lista) como uma linha da matriz. \n", + "\n", + "Isso nos permite acessar e manipular elementos da matriz usando \n", + "dois índices: um para a linha e outro para a coluna.\n", + "\"\"\"\n", + "print()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8151b02", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4f64e3ae", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[['Gato', 'Cachorro'], ['Pássaro', 'Peixe']]\n", + "Gato Cachorro \n", + "Pássaro Peixe \n", + "\n", + "Ana\n", + "Alice\n", + "Amanda\n", + "Arnaldo\n", + "Alfredo\n", + "Ariel\n", + "Alberto\n", + "Adriana\n" + ] + } + ], + "source": [ + "\"\"\"\n", + "Uma matriz de strings é basicamente uma lista de listas em \n", + "que cada elemento interno é uma string. Vamos a um exemplo prático:\n", + "\n", + "Vamos considerar uma matriz 2x2, onde cada elemento é uma string \n", + "representando um nome de animal:\n", + "\n", + " Coluna 0 Coluna 1\n", + "0 \"Gato\" \"Cachorro\"\n", + "1 \"Pássaro\" \"Peixe\"\n", + "\n", + "\"\"\"\n", + "\n", + "# Criar e imprimir essa matriz:\n", + "\n", + "# Criando a matriz 2x2 de strings\n", + "animals = [\n", + " [\"Gato\", \"Cachorro\"],\n", + " [\"Pássaro\", \"Peixe\"]\n", + "]\n", + "\n", + "print(animals)\n", + "\n", + "# Imprimindo a matriz\n", + "for i in range(2): # i representa as linhas\n", + " for j in range(2): # j representa as colunas\n", + " print(animals[i][j], end=\" \")\n", + " print() # Adiciona uma nova linha após cada linha da matriz\n", + "\n", + "#Este é um exemplo mais direto e simplificado de uma matriz de strings em Python.\n", + "print()\n", + "\n", + "\"\"\"\n", + "Vamos criar uma matriz 4x4 com alguns nomes e, em seguida, imprimir \n", + "apenas os que começam com a letra \"A\".\n", + "\n", + " Primeiro, criamos a matriz:\n", + " \n", + " 0 1 2 3\n", + "0 \"Ana\" \"Bruno\" \"Carlos\" \"Alice\"\n", + "1 \"Amanda\" \"Beatriz\" \"Clara\" \"Arnaldo\"\n", + "2 \"Alfredo\" \"Bianca\" \"Cesar\" \"Ariel\"\n", + "3 \"Alberto\" \"Beto\" \"Camila\" \"Adriana\"\n", + "\n", + "\"\"\"\n", + "\n", + "# Criando a matriz 4x4\n", + "names = [\n", + " [\"Ana\", \"Bruno\", \"Carlos\", \"Alice\"],\n", + " [\"Amanda\", \"Beatriz\", \"Clara\", \"Arnaldo\"],\n", + " [\"Alfredo\", \"Bianca\", \"Cesar\", \"Ariel\"],\n", + " [\"Alberto\", \"Beto\", \"Camila\", \"Adriana\"]\n", + "]\n", + "\n", + "# Procurando e imprimindo nomes que começam com a letra 'A'\n", + "for i in range(4): # i representa as linhas\n", + " for j in range(4): # j representa as colunas\n", + " if names[i][j][0] == \"A\": # Checando se o primeiro caractere é 'A'\n", + " print(names[i][j])\n", + "\n", + "# Esses são os nomes na matriz 4x4 que começam com a letra 'A'." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e77597a8", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "41756163", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bruno - 31\n", + "Alice - 34\n", + "Beatriz - 45\n", + "Alfredo - 35\n", + "Cesar - 32\n", + "Alberto - 40\n", + "Adriana - 37\n" + ] + } + ], + "source": [ + "\"\"\"\n", + "Exercício:\n", + "\n", + "Dada a matriz matriz_pessoas, escreva um programa que imprima \n", + "os nomes das pessoas com mais de 30 anos.\n", + "\n", + " matriz_pessoas = [\n", + " [[\"Ana\", 25], [\"Bruno\", 31], [\"Carlos\", 29], [\"Alice\", 34]],\n", + " [[\"Amanda\", 22], [\"Beatriz\", 45], [\"Clara\", 30], [\"Arnaldo\", 27]],\n", + " [[\"Alfredo\", 35], [\"Bianca\", 28], [\"Cesar\", 32], [\"Ariel\", 23]],\n", + " [[\"Alberto\", 40], [\"Beto\", 24], [\"Camila\", 21], [\"Adriana\", 37]]\n", + "]\n", + "\n", + "\"\"\"\n", + "\n", + "# Solução:\n", + "\n", + "# Criando uma matriz 4x4, onde cada elemento é uma lista contendo um nome e uma idade.\n", + "matriz_pessoas = [\n", + " [[\"Ana\", 25], [\"Bruno\", 31], [\"Carlos\", 29], [\"Alice\", 34]], # Primeira linha da matriz\n", + " [[\"Amanda\", 22], [\"Beatriz\", 45], [\"Clara\", 30], [\"Arnaldo\", 27]], # Segunda linha da matriz\n", + " [[\"Alfredo\", 35], [\"Bianca\", 28], [\"Cesar\", 32], [\"Ariel\", 23]], # Terceira linha da matriz\n", + " [[\"Alberto\", 40], [\"Beto\", 24], [\"Camila\", 21], [\"Adriana\", 37]] # Quarta linha da matriz\n", + "]\n", + "\n", + "# Iniciando um loop para percorrer cada linha da matriz\n", + "for i in range(4):\n", + " \n", + " # Iniciando um loop interno para percorrer cada coluna da matriz\n", + " for j in range(4):\n", + " \n", + " # Extraindo o nome da pessoa na posição atual da matriz\n", + " nome = matriz_pessoas[i][j][0]\n", + " \n", + " # Extraindo a idade da pessoa na posição atual da matriz\n", + " idade = matriz_pessoas[i][j][1]\n", + " \n", + " # Verificando se a idade da pessoa é maior que 30\n", + " if idade > 30:\n", + " \n", + " # Imprimindo o nome da pessoa caso a condição acima seja verdadeira\n", + " print(f\"{nome} - {idade}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1be8e45e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4be3adb9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Digite o nome do candidato em quem deseja votar (Alice, Bob ou Charlie): Alice\n", + "Digite o nome do candidato em quem deseja votar (Alice, Bob ou Charlie): Bob\n", + "Digite o nome do candidato em quem deseja votar (Alice, Bob ou Charlie): Charlie\n", + "Digite o nome do candidato em quem deseja votar (Alice, Bob ou Charlie): Alice\n", + "\n", + "Resultados:\n", + "Alice: 2 votos\n", + "Bob: 1 votos\n", + "Charlie: 1 votos\n", + "\n", + "O vencedor é Alice com 2 votos!\n" + ] + } + ], + "source": [ + "\"\"\"\n", + "Exercício: Urna Eletrônica com Matrizes\n", + "\n", + "Imagine que estamos conduzindo uma eleição para escolher o representante \n", + "estudantil de uma universidade. Existem três candidatos concorrendo e, para \n", + "simplificar, cada aluno pode votar apenas uma vez.\n", + "\n", + "Seu objetivo é criar um programa que simule uma urna eletrônica \n", + "simples usando matrizes.\n", + "\n", + "Especificações:\n", + "\n", + " - A matriz terá 2 colunas: a primeira para armazenar o nome do \n", + " candidato e a segunda para armazenar a quantidade de votos.\n", + " \n", + " - O usuário deve inserir o nome do candidato em quem deseja votar. \n", + " Se o voto for para um candidato não listado, ele será considerado nulo.\n", + " \n", + " - Depois que todos os votos forem inseridos, o programa deve imprimir \n", + " o nome de cada candidato, o número total de votos que receberam e o vencedor da eleição.\n", + "\n", + "Dica: Para simplificar, considere que o número total de eleitores é fixo, digamos 10.\n", + "\"\"\"\n", + "\n", + "#Solução\n", + "\n", + "# Inicializa uma matriz com os nomes dos candidatos e seus respectivos votos\n", + "urna = [[\"Alice\", 0], [\"Bob\", 0], [\"Charlie\", 0]]\n", + "\n", + "# Simula a votação de 4 eleitores\n", + "for i in range(4):\n", + " \n", + " # Solicita ao eleitor o nome do candidato em quem deseja votar\n", + " voto = input(\"Digite o nome do candidato em quem deseja votar (Alice, Bob ou Charlie): \")\n", + "\n", + " # Inicializa uma flag para verificar se o voto foi válido\n", + " encontrado = False\n", + " \n", + " # Percorre a lista de candidatos\n", + " for candidato in urna:\n", + " \n", + " # Se o nome do candidato corresponder ao voto do eleitor\n", + " if candidato[0] == voto:\n", + " \n", + " # Incrementa o número de votos do candidato\n", + " # candidato[1] = candidato[1] + 1\n", + " candidato[1] += 1\n", + " \n", + " # Atualiza a flag indicando que o voto foi válido\n", + " encontrado = True\n", + " break\n", + "\n", + " # Se o voto não foi válido (candidato não encontrado)\n", + " if not encontrado:\n", + " print(\"Voto nulo.\")\n", + " \n", + "\n", + "# Imprime os resultados da votação\n", + "print(\"\\nResultados:\")\n", + "\n", + "# Inicializa variáveis para identificar o candidato com o maior número de votos\n", + "votos_maximos = -1\n", + "vencedor = \"\"\n", + "\n", + "# Inicia um loop para percorrer a lista de candidatos\n", + "for candidato in urna:\n", + " \n", + " # Imprime o nome do candidato e o número de votos que ele recebeu\n", + " print(f\"{candidato[0]}: {candidato[1]} votos\") \n", + "\n", + " # Verifica se o número de votos do candidato atual é maior do que o número máximo de votos registrado até agora\n", + " if candidato[1] > votos_maximos:\n", + " \n", + " # Se o candidato atual tem mais votos, atualiza o número máximo de votos\n", + " votos_maximos = candidato[1]\n", + " \n", + " # Define o candidato atual como o vencedor até o momento\n", + " vencedor = candidato[0]\n", + "\n", + "\n", + "# Imprime o nome do vencedor e o número de votos que ele recebeu\n", + "print(f\"\\nO vencedor é {vencedor} com {votos_maximos} votos!\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b972270c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef7e3e99", + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "Exercício: Reserva de Assentos no Cinema usando Matrizes\n", + "\n", + "Você foi contratado para criar um sistema simples de reserva de \n", + "assentos para um pequeno cinema. O cinema tem 5 fileiras e 10 assentos \n", + "em cada fileira, totalizando 50 assentos.\n", + "\n", + "Cada assento pode estar disponível, reservado ou ocupado.\n", + "\n", + "Especificações:\n", + "\n", + " Inicie com todos os assentos disponíveis.\n", + " - O usuário pode escolher entre ver a disposição dos assentos, \n", + " reservar um assento ou sair.\n", + " \n", + " - A disposição dos assentos deve mostrar \"D\" para assentos \n", + " disponíveis, \"R\" para assentos reservados e \"O\" para assentos ocupados.\n", + " \n", + " - Para reservar um assento, o usuário deve inserir a fileira e o número do assento.\n", + " \n", + " - Uma vez que um assento é reservado, ele não pode ser selecionado por outro usuário.\n", + "\n", + "Dica: Use uma matriz 5x10 para representar o cinema, onde cada elemento é uma \n", + "string que indica o status do assento.\n", + "\"\"\"\n", + "\n", + "#Solução\n", + "\n", + "# Inicializa uma lista vazia para a matriz do cinema\n", + "cinema = []\n", + "\n", + "# Loop externo para percorrer as fileiras\n", + "for i in range(5):\n", + " \n", + " # Inicializa uma lista vazia para a fileira atual\n", + " fileira = []\n", + " \n", + " # Loop interno para percorrer os assentos dentro de uma fileira\n", + " for j in range(10):\n", + " \n", + " # Adiciona um assento disponível ('D') à fileira atual\n", + " fileira.append('D')\n", + " \n", + " # Adiciona a fileira completa à matriz do cinema\n", + " cinema.append(fileira)\n", + " \n", + " \n", + "# Inicia um loop infinito para o menu de opções\n", + "while True:\n", + " \n", + " # Imprime o menu de opções\n", + " print(\"\\nMenu:\")\n", + " print(\"1. Ver disposição dos assentos\")\n", + " print(\"2. Reservar um assento\")\n", + " print(\"3. Sair\")\n", + " \n", + " # Solicita ao usuário que escolha uma opção\n", + " escolha = input(\"Escolha uma opção: \")\n", + "\n", + " # Se o usuário escolher a opção 1\n", + " if escolha == '1':\n", + " \n", + " # Inicia um loop para percorrer cada fileira da matriz do cinema\n", + " for fileira in cinema:\n", + " \n", + " # Inicia um loop interno para percorrer cada assento na fileira atual\n", + " for assento in fileira:\n", + " \n", + " # Imprime o status do assento (por exemplo, 'D' para disponível ou 'R' para reservado) sem quebrar a linha\n", + " print(assento, end=\" \")\n", + " \n", + " # Imprime uma quebra de linha após imprimir todos os assentos de uma fileira completa\n", + " print()\n", + "\n", + " # Se o usuário escolher a opção 2\n", + " elif escolha == '2':\n", + " \n", + " # Solicita ao usuário que escolha a fileira e o assento que deseja reservar\n", + " fileira = int(input(\"Digite o número da fileira / Linha (0-4): \"))\n", + " assento = int(input(\"Digite o número do assento / Coluna (0-9): \"))\n", + "\n", + " # Verifica se o assento escolhido está disponível\n", + " if cinema[fileira][assento] == 'D':\n", + " \n", + " # Se estiver disponível, marca o assento como reservado (R = Reservado)\n", + " cinema[fileira][assento] = 'R'\n", + " print(\"Assento reservado com sucesso!\")\n", + " \n", + " else:\n", + " # Se o assento já estiver reservado, informa ao usuário\n", + " print(\"Assento já está reservado ou ocupado.\")\n", + "\n", + " # Se o usuário escolher a opção 3\n", + " elif escolha == '3':\n", + " \n", + " # Agradece ao usuário e encerra o programa\n", + " print(\"Obrigado por usar nosso sistema!\")\n", + " break\n", + " \n", + " # Se o usuário escolher uma opção inválida\n", + " else:\n", + " \n", + " print(\"Opção inválida!\")\n", + " \n", + "\n", + "print()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0beeb95a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ed1cb3ee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " | | \n", + "-----\n", + " | | \n", + "-----\n", + " | | \n", + "-----\n", + "Jogador X, escolha a linha e coluna (ex: 0 2): 0 1\n", + " |X| \n", + "-----\n", + " | | \n", + "-----\n", + " | | \n", + "-----\n", + "Jogador O, escolha a linha e coluna (ex: 0 2): 02\n", + "Entrada inválida. Tente novamente.\n", + "Jogador O, escolha a linha e coluna (ex: 0 2): 0 2\n", + " |X|O\n", + "-----\n", + " | | \n", + "-----\n", + " | | \n", + "-----\n", + "Jogador X, escolha a linha e coluna (ex: 0 2): 1 1 \n", + " |X|O\n", + "-----\n", + " |X| \n", + "-----\n", + " | | \n", + "-----\n", + "Jogador O, escolha a linha e coluna (ex: 0 2): 2 1\n", + " |X|O\n", + "-----\n", + " |X| \n", + "-----\n", + " |O| \n", + "-----\n", + "Jogador X, escolha a linha e coluna (ex: 0 2): 2 2\n", + " |X|O\n", + "-----\n", + " |X| \n", + "-----\n", + " |O|X\n", + "-----\n", + "Jogador O, escolha a linha e coluna (ex: 0 2): 1 0\n", + " |X|O\n", + "-----\n", + "O|X| \n", + "-----\n", + " |O|X\n", + "-----\n", + "Jogador X, escolha a linha e coluna (ex: 0 2): 0 0\n", + "X|X|O\n", + "-----\n", + "O|X| \n", + "-----\n", + " |O|X\n", + "-----\n", + "Jogador X venceu!\n" + ] + } + ], + "source": [ + "\"\"\"\n", + "Exercício - Jogo da Velha com Matriz\n", + "\n", + "Objetivo: Implementar o jogo da velha usando uma matriz 3x3 e permitir que dois jogadores joguem um contra o outro.\n", + "\n", + "Instruções:\n", + "\n", + " Inicialize uma matriz 3x3 com espaços em branco para representar o tabuleiro do jogo da velha.\n", + " Crie uma função para exibir o tabuleiro atualizado a cada jogada.\n", + " Crie uma função para verificar se há um vencedor.\n", + " Implemente um loop que alterna entre os jogadores (X e O) e permite que eles escolham uma posição no tabuleiro.\n", + " Após cada jogada, verifique se há um vencedor ou se o tabuleiro está cheio.\n", + " Se houver um vencedor ou o tabuleiro estiver cheio, termine o jogo e exiba o resultado.\n", + "\n", + "Dicas:\n", + "\n", + " Lembre-se de verificar as linhas, colunas e diagonais ao procurar por um vencedor.\n", + " Certifique-se de que os jogadores não possam escolher uma posição que já foi ocupada.\n", + " Use funções para organizar seu código e torná-lo mais legível.\n", + "\n", + "\"\"\"\n", + "\n", + "#Solução:\n", + "\n", + "# Inicializa o tabuleiro\n", + "# tabuleiro = [[' ' for _ in range(3)] for _ in range(3)]\n", + "\n", + "# Inicializa o tabuleiro como uma lista vazia\n", + "tabuleiro = []\n", + "\n", + "# Loop para adicionar 3 linhas ao tabuleiro\n", + "for i in range(3):\n", + " \n", + " # Cria uma linha vazia\n", + " linha = []\n", + " \n", + " # Loop para adicionar 3 espaços em branco a cada linha\n", + " for j in range(3):\n", + " \n", + " # Adiciona um espaço em branco à linha\n", + " linha.append(' ')\n", + " \n", + " # Adiciona a linha completa ao tabuleiro\n", + " tabuleiro.append(linha)\n", + " \n", + "def exibir_tabuleiro():\n", + " \n", + " \"\"\"Exibe o tabuleiro atual.\"\"\"\n", + " \n", + " # Loop para percorrer cada linha do tabuleiro\n", + " for linha in tabuleiro:\n", + " \n", + " # Imprime a linha atual do tabuleiro, separando cada célula por \"|\"\n", + " print(\"|\".join(linha))\n", + " \n", + " # Imprime um separador para visualizar melhor as linhas do tabuleiro\n", + " print(\"-\" * 5)\n", + " \n", + " \n", + "def verificar_vencedor(jogador):\n", + " \n", + " \"\"\"Verifica se o jogador atual é o vencedor.\"\"\"\n", + " \n", + " # Loop para percorrer as linhas e colunas do tabuleiro\n", + " for i in range(3):\n", + " \n", + " # Inicializa variáveis para verificar se todas as células são iguais ao jogador\n", + " todas_celulas_linha = True\n", + " todas_celulas_coluna = True\n", + " \n", + " # Loop para percorrer cada coluna(j) da linha atual (i)\n", + " for j in range(3):\n", + "\n", + " # Verifica se a célula atual na linha (i) e coluna (j) é diferente do jogador\n", + " # Se for diferente, atualiza a variável 'todas_celulas_linha' para False\n", + " if tabuleiro[i][j] != jogador:\n", + " todas_celulas_linha = False\n", + "\n", + " # Verifica se a célula atual na coluna (i) e linha (j) é diferente do jogador\n", + " # Se for diferente, atualiza a variável 'todas_celulas_coluna' para False\n", + " if tabuleiro[j][i] != jogador:\n", + " todas_celulas_coluna = False\n", + " \n", + " \"\"\"\n", + " Parte onde é verificado se um jogador venceu o jogo:\n", + "\n", + " Verificação de Linhas e Colunas:\n", + " As variáveis todas_celulas_linha e todas_celulas_coluna são inicializadas como \n", + " True para cada iteração do loop que percorre as linhas e colunas do tabuleiro. Isso \n", + " acontece para cada valor de i, que representa o índice da linha atual. O loop interno \n", + " percorre as colunas (índices de j) para cada linha. Durante a iteração, se uma célula na \n", + " linha i e coluna j não contiver o símbolo do jogador atual, a respectiva variável todas_celulas_linha \n", + " ou todas_celulas_coluna é definida como False. Isso acontece para garantir que todas as células em uma \n", + " linha ou coluna sejam do mesmo jogador.\n", + "\n", + " Se, após as iterações do loop, todas_celulas_linha ou todas_celulas_coluna forem True, isso significa \n", + " que todas as células na linha ou coluna contêm o símbolo do jogador atual, o que resulta em uma vitória.\n", + "\n", + " Verificação de Diagonais:\n", + " As duas diagonais do tabuleiro são verificadas separadamente. A primeira diagonal (de cima à esquerda \n", + " para baixo à direita) é verificada comparando os elementos das células (0, 0), (1, 1) e (2, 2) com o \n", + " símbolo do jogador atual. A segunda diagonal (de cima à direita para baixo à esquerda) é verificada comparando \n", + " os elementos das células (0, 2), (1, 1) e (2, 0).\n", + "\n", + " Se uma das diagonais contiver apenas o símbolo do jogador atual, isso indica uma vitória.\n", + "\n", + " Retorno de Resultado:\n", + " Se qualquer uma das condições acima for verdadeira (ou seja, uma linha, coluna ou diagonal contém apenas\n", + " o símbolo do jogador atual), a função retorna True, indicando que o jogador venceu. Se nenhuma das condições \n", + " for atendida, isso significa que não há vencedor e a função retorna False.\n", + "\n", + " Essa estratégia verifica todas as possibilidades onde um jogador pode ganhar o jogo: todas as linhas, \n", + " colunas e diagonais. Se alguma dessas condições for atendida, a função verificar_vencedor retorna True, caso \n", + " contrário, retorna False.\n", + " \"\"\"\n", + " \n", + " # Se todas as células em uma linha ou coluna são iguais ao jogador\n", + " if todas_celulas_linha or todas_celulas_coluna:\n", + " return True\n", + " \n", + " # Verifica a diagonal principal (de cima à esquerda para baixo à direita)\n", + " if tabuleiro[0][0] == jogador and tabuleiro[1][1] == jogador and tabuleiro[2][2] == jogador:\n", + " return True\n", + "\n", + " # Verifica a diagonal secundária (de cima à direita para baixo à esquerda)\n", + " if tabuleiro[0][2] == jogador and tabuleiro[1][1] == jogador and tabuleiro[2][0] == jogador:\n", + " return True\n", + "\n", + " # Se nenhuma das condições acima for atendida, retorna False (não há vencedor)\n", + " return False\n", + "\n", + "def jogada(jogador):\n", + " \n", + " \"\"\"Permite ao jogador atual fazer uma jogada.\"\"\"\n", + " \n", + " # Inicia um loop infinito para garantir que o jogador faça uma jogada válida\n", + " while True:\n", + " \n", + " # Solicita ao jogador que insira a linha e a coluna onde deseja jogar\n", + " jogada = input(f\"Jogador {jogador}, escolha a linha e coluna (ex: 0 2): \")\n", + "\n", + " # Tenta converter a entrada do jogador em coordenadas de linha e coluna\n", + " try:\n", + " \n", + " \"\"\"\n", + " jogada.split(): A função split() é um método de strings que divide uma string em \n", + " uma lista, usando espaços como delimitadores por padrão. Por exemplo, se jogada for \n", + " a string \"1 2\", então jogada.split() retornará a lista ['1', '2'].\n", + "\n", + " map(int, jogada.split()): A função map() aplica uma função a todos os itens em \n", + " uma entrada de lista (ou qualquer outro iterável). Neste caso, estamos aplicando a \n", + " função int a cada item da lista resultante de jogada.split(). Isso converte cada string \n", + " da lista em um número inteiro. Continuando com o exemplo anterior, isso transformaria ['1', '2'] em [1, 2].\n", + "\n", + " linha, coluna = ...: Isso é chamado de desempacotamento de lista. Estamos \n", + " atribuindo os valores da lista resultante às variáveis linha e coluna. No exemplo dado, \n", + " linha receberia o valor 1 e coluna receberia o valor 2\n", + " \"\"\"\n", + " linha, coluna = map(int, jogada.split())\n", + " \n", + " # Verifica se a célula escolhida no tabuleiro está vazia (representada por um espaço em branco)\n", + " if tabuleiro[linha][coluna] == ' ':\n", + "\n", + " # Se estiver vazia, atualiza a célula com o símbolo do jogador atual (X ou O)\n", + " tabuleiro[linha][coluna] = jogador\n", + "\n", + " # Sai do loop, pois a jogada foi válida\n", + " break\n", + "\n", + " # Se a célula já estiver ocupada (não estava vazia)\n", + " else:\n", + "\n", + " # Informa ao jogador que a posição escolhida já está ocupada\n", + " print(\"Posição já ocupada. Tente novamente.\")\n", + "\n", + "\n", + " # Se ocorrer um erro (entrada inválida ou fora do intervalo), informa ao jogador\n", + " except:\n", + " print(\"Entrada inválida. Tente novamente.\")\n", + "\n", + "\n", + "# Loop principal do jogo\n", + "# Define o jogador inicial como 'X'\n", + "jogador_atual = 'X'\n", + "\n", + "# Inicia um loop para as 9 possíveis jogadas no jogo da velha\n", + "\n", + "\"\"\"\n", + " range(9): A função range(9) retorna uma sequência de números, começando \n", + " de 0 e indo até 8 (um total de 9 números). Portanto, o loop irá iterar 9 vezes.\n", + "\n", + " for _ in ...: Aqui, estamos usando um loop for para iterar sobre cada número \n", + " na sequência retornada por range(9).\n", + "\n", + " _: O sublinhado (_) é uma convenção em Python que indica que a variável não será \n", + " usada dentro do loop. É uma maneira de dizer \"estamos iterando 9 vezes, mas não nos \n", + " importamos com o valor específico em cada iteração\". Em outras palavras, estamos \n", + " interessados apenas no número de iterações, e não no valor em cada iteração.\n", + "\n", + " Então, em resumo, a linha for _ in range(9): é uma maneira concisa de escrever\n", + " um loop que se repete 9 vezes, sem se preocupar com o valor da variável de loop \n", + " em cada iteração.\n", + "\n", + "\"\"\"\n", + "for _ in range(9):\n", + " \n", + " # Exibe o tabuleiro atualizado\n", + " exibir_tabuleiro()\n", + " \n", + " # Permite que o jogador atual faça sua jogada\n", + " jogada(jogador_atual)\n", + " \n", + " # Verifica se a jogada resultou em uma vitória para o jogador atual\n", + " if verificar_vencedor(jogador_atual):\n", + " \n", + " # Exibe o tabuleiro final\n", + " exibir_tabuleiro()\n", + " \n", + " # Informa que o jogador atual venceu o jogo\n", + " print(f\"Jogador {jogador_atual} venceu!\")\n", + " \n", + " # Encerra o loop, pois o jogo terminou\n", + " break\n", + " \n", + " # Alterna o jogador atual (de 'X' para 'O' ou vice-versa)\n", + " jogador_atual = 'O' if jogador_atual == 'X' else 'X'\n", + "\n", + "# Caso o loop termine sem encontrar um vencedor (todas as 9 jogadas foram feitas)\n", + "else:\n", + " \n", + " # Exibe o tabuleiro final\n", + " exibir_tabuleiro()\n", + " \n", + " # Informa que o jogo terminou em empate\n", + " print(\"Empate!\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c4329bc1", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "87b9ce1d", + "metadata": {}, + "outputs": [], + "source": [ + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f82c8d28", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b5e0137", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3bb2ea61", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/1_section_Programming_logic/Set+(Conjuntos).ipynb b/1_section_Programming_logic/Set.ipynb similarity index 93% rename from 1_section_Programming_logic/Set+(Conjuntos).ipynb rename to 1_section_Programming_logic/Set.ipynb index 6baef9c..70d4a18 100644 --- a/1_section_Programming_logic/Set+(Conjuntos).ipynb +++ b/1_section_Programming_logic/Set.ipynb @@ -18,25 +18,25 @@ "\"\"\"\n", "Set (conjuntos):\n", "\n", - " Definição e Características\n", + " Definição e Características:\n", " - Um \"set\" é uma coleção desordenada de elementos únicos. Isso \n", " significa que não permite duplicatas.\n", " \n", " Sets são mutáveis, mas os elementos contidos neles devem \n", " ser imutáveis (por exemplo, números, strings e tuplas).\n", "\n", - " Criando um Conjunto\n", + " Criando um Conjunto:\n", " Usando chaves: s = {1, 2, 3}\n", " Usando a função set(): s = set([1, 2, 3])\n", "\n", - " Adicionando e Removendo Elementos\n", + " Adicionando e Removendo Elementos:\n", " add(): Adiciona um elemento ao conjunto.\n", " remove(): Remove um elemento do conjunto. Gera um erro se o elemento não existir.\n", " discard(): Remove um elemento do conjunto se ele existir.\n", " pop(): Remove e retorna um elemento do conjunto. Como os sets são desordenados, você não sabe qual item será removido.\n", " clear(): Remove todos os elementos do conjunto.\n", "\n", - " Operações com Conjuntos\n", + " Operações com Conjuntos:\n", " União: s1 | s2 ou s1.union(s2)\n", " Intersecção: s1 & s2 ou s1.intersection(s2)\n", " Diferença: s1 - s2 ou s1.difference(s2)\n", @@ -44,20 +44,20 @@ " Subset (subconjunto): s1.issubset(s2)\n", " Superset (superconjunto): s1.issuperset(s2)\n", "\n", - " Outras Funções e Métodos\n", + " Outras Funções e Métodos:\n", " len(): Retorna o número de elementos no conjunto.\n", " in: Verifica a existência de um elemento no conjunto.\n", " copy(): Retorna uma cópia do conjunto.\n", "\n", - " Imutabilidade e Frozensets\n", + " Imutabilidade e Frozensets:\n", " Como mencionado, os elementos de um set devem ser imutáveis. No entanto, o próprio set é mutável. Se você precisar de um conjunto imutável, pode usar um frozenset.\n", "\n", - " Aplicações Práticas\n", + " Aplicações Práticas:\n", " Sets são frequentemente usados para remover duplicatas de uma lista.\n", " Eles são úteis para testar a pertença de um elemento.\n", " São utilizados em operações matemáticas de conjunto, como união, interseção e diferença.\n", "\n", - " Limitações\n", + " Limitações:\n", " Conjuntos não suportam indexação, fatiamento ou outras operações de sequência.\n", " Não podem conter elementos duplicados.\n", "\n", @@ -245,7 +245,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 3, "id": "66b0e361", "metadata": {}, "outputs": [ @@ -253,10 +253,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'pera', 'cereja', 'banana', 'maçã'}\n", + "{'maçã', 'pera', 'banana', 'cereja'}\n", "['uva', 'manga', 'manga', 'uva', 'maçã', 'pera']\n", - "{'manga', 'pera', 'uva', 'maçã'}\n", - "Fruta(s) em comum: {'pera', 'maçã'}\n", + "{'maçã', 'pera', 'manga', 'uva'}\n", + "Fruta(s) em comum: {'maçã', 'pera'}\n", "\n" ] } @@ -304,9 +304,9 @@ " Imprima o conjunto.\n", "\"\"\"\n", "\n", - "frutas_chaves = {\"maçã\", \"banana\", \"cereja\", \"pera\"}\n", + "frutas_chave = {\"maçã\", \"banana\", \"uva\", \"pera\"}\n", "\n", - "print(frutas_chaves)\n", + "print(frutas_chave)\n", "\n", "\n", "\"\"\"\n", @@ -467,7 +467,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 2, "id": "4db52201", "metadata": {}, "outputs": [ @@ -475,12 +475,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'gato', 'cachorro', 'pássaro'}\n", - "{'gato', 'cachorro', 'pássaro', 'peixe'}\n", - "{'gato', 'cachorro', 'peixe'}\n", - "{'gato', 'cachorro', 'peixe'}\n", - "Animal removido: gato\n", - "{'cachorro', 'peixe'}\n", + "{'pássaro', 'cachorro', 'gato'}\n", + "{'pássaro', 'cachorro', 'gato', 'peixe'}\n", + "{'cachorro', 'gato', 'peixe'}\n", + "Animal removido: cachorro\n", + "{'gato', 'peixe'}\n", "set()\n" ] } @@ -560,7 +559,6 @@ "\"\"\"\n", "\n", "animais.remove(\"pássaro\")\n", - "print(animais)\n", "\n", "#animais.remove(\"lagarto\")\n", "#print(animais)\n", @@ -753,7 +751,7 @@ }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 3, "id": "e4f1ec27", "metadata": {}, "outputs": [ @@ -768,6 +766,7 @@ "{1, 2, 3}\n", "{1, 2, 3}\n", "{1, 2, 3, 6, 7, 8}\n", + "{1, 2, 3, 6, 7, 8}\n", "False\n", "False\n" ] @@ -843,7 +842,6 @@ " Imprima o resultado.\n", " Repita usando o método union().\n", "\"\"\"\n", - "\n", "uniao = s1 | s2\n", "print(uniao)\n", "print(s1.union(s2))\n", @@ -857,8 +855,8 @@ " Repita usando o método intersection().\n", "\"\"\"\n", "\n", - "interseccao = s1 & s2\n", - "print(interseccao)\n", + "intersection = s1 & s2\n", + "print(intersection)\n", "print(s1.intersection(s2))\n", "\n", "\"\"\"\n", @@ -870,8 +868,8 @@ " Repita usando o método difference().\n", "\"\"\"\n", "\n", - "diferenca = s1 - s2\n", - "print(diferenca)\n", + "difference = s1 - s2\n", + "print(difference)\n", "print(s1.difference(s2))\n", "\n", "\"\"\"\n", @@ -883,8 +881,9 @@ " Repita usando o método symmetric_difference().\n", "\"\"\"\n", "\n", - "diff_simetrica = s1 ^ s2\n", - "print(diff_simetrica)\n", + "symmetrical_difference = s1 ^ s2\n", + "print(symmetrical_difference)\n", + "print(s1.symmetric_difference(s2))\n", "\n", "\"\"\"\n", "6. Subset e Superset:\n", @@ -923,7 +922,7 @@ ], "source": [ "\"\"\"\n", - "Outras Funções e Métodos\n", + "Outras Funções e Métodos:\n", " len(): Retorna o número de elementos no conjunto.\n", " in: Verifica a existência de um elemento no conjunto.\n", " copy(): Retorna uma cópia do conjunto.\n", @@ -979,7 +978,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 2, "id": "fdb0966c", "metadata": {}, "outputs": [ @@ -987,14 +986,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'cachorro', 'gato', 'pássaro', 'coelho', 'peixe'}\n", + "{'gato', 'pássaro', 'cachorro', 'peixe', 'coelho'}\n", "\n", - "O conjunto 'animais' contém 5.\n", - "gato está no conjunto de animais!\n", - "elefante não está no conjunto de animais!\n", + "O conjunto 'animais' contém 5\n", + "gato está no conjunto dos animais\n", + "elefante não está no conjunto dos animais\n", "False\n", - "{'cachorro', 'gato', 'pássaro', 'coelho', 'peixe'}\n", - "{'cachorro', 'tartaruga', 'gato', 'pássaro', 'coelho', 'peixe'}\n" + "{'gato', 'pássaro', 'cachorro', 'peixe', 'coelho'}\n", + "{'tartaruga', 'gato', 'pássaro', 'cachorro', 'peixe', 'coelho'}\n" ] } ], @@ -1049,7 +1048,7 @@ " existem no conjunto animais.\n", "\"\"\"\n", "\n", - "print(f\"O conjunto 'animais' contém {len(animais)}.\")\n", + "print(f\"O conjunto 'animais' contém {len(animais)}\")\n", "\n", "\n", "\"\"\"\n", @@ -1064,12 +1063,11 @@ "def verificar_animal(nome):\n", " \n", " if nome in animais:\n", - " \n", - " print(f\"{nome} está no conjunto de animais!\")\n", + " \n", + " print(f\"{nome} está no conjunto dos animais\") \n", " \n", " else:\n", - " \n", - " print(f\"{nome} não está no conjunto de animais!\")\n", + " print(f\"{nome} não está no conjunto dos animais\") \n", "\n", "verificar_animal(\"gato\")\n", "verificar_animal(\"elefante\")\n", @@ -1121,11 +1119,11 @@ " próprio set é mutável. Se você precisar de um conjunto imutável, pode usar um frozenset.\n", "\"\"\"\n", "\n", - "#Imutabilidade dos elementos do conjunto\n", + "# Imutabilidade dos elementos do conjunto\n", "\n", - "#Os conjuntos (set) em Python exigem que seus elementos sejam imutáveis. \n", - "#Isso significa que você pode ter uma string, int, float ou tuple como elemento \n", - "#de um conjunto, mas não pode ter tipos mutáveis, como list ou outro set.\n", + "# Os conjuntos (set) em Python exigem que seus elementos sejam imutáveis. \n", + "# Isso significa que você pode ter uma string, int, float ou tuple como elemento \n", + "# de um conjunto, mas não pode ter tipos mutáveis, como list ou outro set.\n", "# Isto é válido\n", "conjunto_valido = {1, 2.5, \"string\", (10, 20)}\n", "\n", @@ -1173,7 +1171,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 3, "id": "093b8b72", "metadata": {}, "outputs": [ @@ -1181,9 +1179,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "{1, 'Python', (10, 20)}\n", + "{'Python', 1, (10, 20)}\n", "\n", - "{1, 'Python', 5, (10, 20)}\n", + "{'Python', 1, 5, (10, 20)}\n", "{'Python', 5, (10, 20)}\n", "\n", "{frozenset({1, 2, 3}), frozenset({4, 5, 6})}\n" @@ -1272,7 +1270,7 @@ "\n", "conjunto_b = {fs1, fs2}\n", "\n", - "print(conjunto_b) # Saída: {frozenset({1, 2, 3}), frozenset({4, 5, 6})}\n", + "print(conjunto_b) # Saída: {frozenset({1, 2, 3}), frozenset({4, 5, 6})}\n", "# Tentando adicionar um novo número ao fs1 resultará em um erro:\n", "# fs1.add(7)\n", "\n", @@ -1310,7 +1308,7 @@ ], "source": [ "\"\"\"\n", - "Aplicações Práticas\n", + "Aplicações Práticas:\n", " Sets são frequentemente usados para remover duplicatas de uma lista.\n", " Eles são úteis para testar a pertença de um elemento.\n", " São utilizados em operações matemáticas de conjunto, como união, interseção e diferença.\n", @@ -1382,7 +1380,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 1, "id": "58481286", "metadata": {}, "outputs": [ @@ -1392,18 +1390,18 @@ "text": [ "{40, 10, 20, 30}\n", "\n", - "O número 25 não está presente.\n", + "O número 25 não está presente\n", "\n", - "União\n", + "Union\n", "{1, 2, 3, 4, 5, 6}\n", "\n", - "interseção\n", + "Intececion\n", "{3, 4}\n", "\n", - "diferença\n", + "Difference\n", "{1, 2}\n", "\n", - "diferença simétrica\n", + "Symmetric difference\n", "{1, 2, 5, 6}\n" ] } @@ -1445,9 +1443,9 @@ " resultante.\n", "\"\"\"\n", "\n", - "numeros = [10, 20, 30, 10, 40, 20]\n", - "numeros_unicos = set(numeros)\n", - "print(numeros_unicos)\n", + "numbers = [10, 20, 30, 10, 40, 20]\n", + "numbers_unique = set(numbers)\n", + "print(numbers_unique)\n", "\n", "print()\n", "\n", @@ -1457,13 +1455,10 @@ " mensagem apropriada.\n", "\"\"\"\n", "\n", - "if 25 in numeros_unicos:\n", - " \n", - " print(\"O número 25 está presente.\")\n", - " \n", - "else:\n", - " \n", - " print(\"O número 25 não está presente.\")\n", + "if 25 in numbers_unique:\n", + " print(\"O número 25 está presente\")\n", + "else: \n", + " print(\"O número 25 não está presente\")\n", " \n", "\"\"\"\n", "3. Operações de Conjunto:\n", @@ -1476,19 +1471,23 @@ "\"\"\"\n", "\n", "conjunto_a = {1, 2, 3, 4}\n", - "conjunto_b = {3, 4, 5, 6}\n", + "conjunto_b = {3, 4, 5, 6}\n", "\n", - "print(\"\\nUnião\")\n", - "print(conjunto_a | conjunto_b)\n", + "print(\"\\nUnion\")\n", + "s1_union = conjunto_a | conjunto_b\n", + "print(s1_union)\n", "\n", - "print(\"\\ninterseção\")\n", - "print(conjunto_a & conjunto_b)\n", + "print(\"\\nIntececion\")\n", + "s2_intercesion = conjunto_a & conjunto_b\n", + "print(s2_intercesion)\n", "\n", - "print(\"\\ndiferença\")\n", - "print(conjunto_a - conjunto_b)\n", + "print(\"\\nDifference\")\n", + "s3_difference = conjunto_a - conjunto_b\n", + "print(s3_difference)\n", "\n", - "print(\"\\ndiferença simétrica\")\n", - "print(conjunto_a ^ conjunto_b)" + "print(\"\\nSymmetric difference\")\n", + "s4_symmetric_difference = conjunto_a ^ conjunto_b\n", + "print(s4_symmetric_difference)" ] }, { @@ -1501,7 +1500,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 1, "id": "24bff602", "metadata": {}, "outputs": [ @@ -1515,17 +1514,17 @@ ], "source": [ "\"\"\"\n", - "Limitações\n", + "Limitações:\n", " Conjuntos não suportam indexação, fatiamento ou outras operações de sequência.\n", " Não podem conter elementos duplicados.\n", "\"\"\"\n", "\n", - "#1. Sem Indexação e Fatiamento\n", + "#1. Sem Indexação e Fatiamento:\n", "\n", "#Conjuntos não são sequências ordenadas, então você não pode acessar ou modificar \n", "#um elemento de um conjunto usando indexação ou fatiamento.\n", "\n", - "meu_conjunto = {1, 2, 3, 4, 5}\n", + "my_set = {1, 2, 3, 4, 5}\n", "\n", "# Tentando acessar um elemento pelo índice resultará em erro\n", "# Descomente a linha abaixo e o Python lançará um TypeError\n", @@ -1541,13 +1540,13 @@ "#conjunto com elementos duplicados, ele automaticamente os removerá.\n", "\n", "# Criando um conjunto com números duplicados\n", - "numeros = {1, 2, 2, 3, 4, 4, 5}\n", + "numbers = {1, 2, 2, 3, 4, 4, 5}\n", "\n", "# O Python automaticamente removerá os duplicados\n", - "print(numeros) # Saída: {1, 2, 3, 4, 5}\n", + "print(numbers) # Saída: {1, 2, 3, 4, 5}\n", "\n", "\n", - "#3. Elementos do Conjunto Devem Ser Imutáveis\n", + "#3. Elementos do Conjunto Devem Ser Imutáveis:\n", "\n", "#Isso significa que você não pode ter, por exemplo, listas ou \n", "#dicionários como elementos de um conjunto, pois são tipos mutáveis.\n", @@ -1574,7 +1573,7 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 2, "id": "91ae77b9", "metadata": {}, "outputs": [ @@ -1624,7 +1623,7 @@ " Tente obter um subconjunto de frutas usando fatiamento.\n", "\"\"\"\n", "\n", - "frutas = {\"maçã\", \"banana\", \"cereja\"}\n", + "fruts = {\"maçã\", \"banana\", \"cereja\"}\n", "\n", "# Ambas as próximas linhas resultarão em erros quando descomentadas\n", "# print(frutas[0]) # TypeError: 'set' object is not subscriptable\n", @@ -1636,8 +1635,8 @@ " Imprima o conjunto números e observe o resultado.\n", "\"\"\"\n", "\n", - "numeros = { 5, 5, 5, 2, 2, 1}\n", - "print(numeros)\n", + "numbers = {5, 5, 5, 2, 2, 1}\n", + "print(numbers)\n", "\n", "\"\"\"\n", "3. Adicionar Elementos Mutáveis:\n", @@ -1672,7 +1671,7 @@ "porque listas e dicionários são mutáveis e não podem ser usados como elementos de \n", "um conjunto.\n", "\n", - "Lembrem-se de que conjuntos são adequados para armazenar elementos únicos e \n", + "Os conjuntos são adequados para armazenar elementos únicos e \n", "imutáveis, e eles são otimizados para operações de pertencimento (verificar se \n", "um elemento está no conjunto) e para remover duplicatas de uma sequência.\n", "\"\"\"\n", @@ -1704,7 +1703,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.11.5" } }, "nbformat": 4, diff --git a/1_section_Programming_logic/Untitled.ipynb b/1_section_Programming_logic/Untitled.ipynb deleted file mode 100644 index 24c8434..0000000 --- a/1_section_Programming_logic/Untitled.ipynb +++ /dev/null @@ -1,251 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 25, - "id": "7f94c527", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Exception in Tkinter callback\n", - "Traceback (most recent call last):\n", - " File \"C:\\Users\\Micro\\AlunoPython\\MyAnaconda\\anaconda3\\Lib\\tkinter\\__init__.py\", line 1948, in __call__\n", - " return self.func(*args)\n", - " ^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\Micro\\AppData\\Local\\Temp\\ipykernel_7224\\4009696883.py\", line 31, in \n", - " command=lambda i=i, j=j: self.click_square(i, j))\n", - " ^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\Micro\\AppData\\Local\\Temp\\ipykernel_7224\\4009696883.py\", line 51, in click_square\n", - " self.valid_moves = self.get_valid_moves(row, col)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\Micro\\AppData\\Local\\Temp\\ipykernel_7224\\4009696883.py\", line 153, in get_valid_moves\n", - " if self.is_valid_move(row, col, dest_row, dest_col):\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\Micro\\AppData\\Local\\Temp\\ipykernel_7224\\4009696883.py\", line 71, in is_valid_move\n", - " return self.valid_pawn_move(src_row, src_col, dest_row, dest_col)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\Micro\\AppData\\Local\\Temp\\ipykernel_7224\\4009696883.py\", line 108, in valid_pawn_move\n", - " return dest_piece and dest_piece.isupper() if direction == 1 else dest_piece and dest_piece.islower()\n", - " ^^^^^^^^^^\n", - "NameError: name 'dest_piece' is not defined\n", - "Exception in Tkinter callback\n", - "Traceback (most recent call last):\n", - " File \"C:\\Users\\Micro\\AlunoPython\\MyAnaconda\\anaconda3\\Lib\\tkinter\\__init__.py\", line 1948, in __call__\n", - " return self.func(*args)\n", - " ^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\Micro\\AppData\\Local\\Temp\\ipykernel_7224\\4009696883.py\", line 31, in \n", - " command=lambda i=i, j=j: self.click_square(i, j))\n", - " ^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\Micro\\AppData\\Local\\Temp\\ipykernel_7224\\4009696883.py\", line 51, in click_square\n", - " self.valid_moves = self.get_valid_moves(row, col)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\Micro\\AppData\\Local\\Temp\\ipykernel_7224\\4009696883.py\", line 153, in get_valid_moves\n", - " if self.is_valid_move(row, col, dest_row, dest_col):\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\Micro\\AppData\\Local\\Temp\\ipykernel_7224\\4009696883.py\", line 71, in is_valid_move\n", - " return self.valid_pawn_move(src_row, src_col, dest_row, dest_col)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\Micro\\AppData\\Local\\Temp\\ipykernel_7224\\4009696883.py\", line 108, in valid_pawn_move\n", - " return dest_piece and dest_piece.isupper() if direction == 1 else dest_piece and dest_piece.islower()\n", - " ^^^^^^^^^^\n", - "NameError: name 'dest_piece' is not defined\n" - ] - } - ], - "source": [ - "import tkinter as tk\n", - "\n", - "class ChessGame:\n", - " def __init__(self, master):\n", - " self.master = master\n", - " self.master.title(\"Chess Game\")\n", - "\n", - " self.board = [\n", - " [\"r\", \"n\", \"b\", \"q\", \"k\", \"b\", \"n\", \"r\"],\n", - " [\"p\"] * 8,\n", - " [\"\"] * 8,\n", - " [\"\"] * 8,\n", - " [\"\"] * 8,\n", - " [\"\"] * 8,\n", - " [\"P\"] * 8,\n", - " [\"R\", \"N\", \"B\", \"Q\", \"K\", \"B\", \"N\", \"R\"]\n", - " ]\n", - "\n", - " self.selected_piece = None\n", - " self.valid_moves = set()\n", - "\n", - " self.create_board_gui()\n", - "\n", - " def create_board_gui(self):\n", - " self.blocos = [[0 for _ in range(8)] for _ in range(8)]\n", - "\n", - " for i in range(8):\n", - " for j in range(8):\n", - " color = \"#f0d9b5\" if (i + j) % 2 == 0 else \"#b58863\"\n", - " self.blocos[i][j] = tk.Button(self.master, width=6, height=3, bg=color, relief=\"flat\",\n", - " command=lambda i=i, j=j: self.click_square(i, j))\n", - " self.blocos[i][j].grid(row=i, column=j)\n", - " self.update_piece_gui(i, j)\n", - "\n", - " def update_piece_gui(self, row, col):\n", - " piece = self.board[row][col]\n", - " text = self.piece_to_unicode(piece) if piece else \"\"\n", - " self.blocos[row][col].config(text=text, font=(\"Helvetica\", 16, \"bold\"))\n", - "\n", - " if (row, col) in self.valid_moves:\n", - " self.blocos[row][col].config(bg=\"#a1e1d4\")\n", - " else:\n", - " color = \"#f0d9b5\" if (row + col) % 2 == 0 else \"#b58863\"\n", - " self.blocos[row][col].config(bg=color)\n", - "\n", - " def click_square(self, row, col):\n", - " if self.selected_piece is None:\n", - " piece = self.board[row][col]\n", - " if piece != \"\":\n", - " self.selected_piece = (row, col)\n", - " self.valid_moves = self.get_valid_moves(row, col)\n", - " else:\n", - " dest_row, dest_col = row, col\n", - " src_row, src_col = self.selected_piece\n", - "\n", - " if (dest_row, dest_col) in self.valid_moves:\n", - " self.board[dest_row][dest_col] = self.board[src_row][src_col]\n", - " self.board[src_row][src_col] = \"\"\n", - " self.update_piece_gui(src_row, src_col)\n", - " self.update_piece_gui(dest_row, dest_col)\n", - "\n", - " self.selected_piece = None\n", - " self.valid_moves = set()\n", - "\n", - " def is_valid_move(self, src_row, src_col, dest_row, dest_col):\n", - " piece = self.board[src_row][src_col]\n", - " dest_piece = self.board[dest_row][dest_col]\n", - "\n", - " # Lógica de movimento para peão\n", - " if piece.lower() == \"p\":\n", - " return self.valid_pawn_move(src_row, src_col, dest_row, dest_col)\n", - "\n", - " # Lógica de movimento para torre\n", - " if piece.lower() == \"r\":\n", - " return self.valid_rook_move(src_row, src_col, dest_row, dest_col)\n", - "\n", - " # Lógica de movimento para cavalo\n", - " if piece.lower() == \"n\":\n", - " return self.valid_knight_move(src_row, src_col, dest_row, dest_col)\n", - "\n", - " # Lógica de movimento para bispo\n", - " if piece.lower() == \"b\":\n", - " return self.valid_bishop_move(src_row, src_col, dest_row, dest_col)\n", - "\n", - " # Lógica de movimento para rainha\n", - " if piece.lower() == \"q\":\n", - " return self.valid_queen_move(src_row, src_col, dest_row, dest_col)\n", - "\n", - " # Lógica de movimento para rei\n", - " if piece.lower() == \"k\":\n", - " return self.valid_king_move(src_row, src_col, dest_row, dest_col)\n", - "\n", - " return False\n", - "\n", - " def valid_pawn_move(self, src_row, src_col, dest_row, dest_col):\n", - " direction = 1 if self.board[src_row][src_col].islower() else -1\n", - "\n", - " # Movimento básico para frente\n", - " if src_col == dest_col and self.board[dest_row][dest_col] == \"\":\n", - " if src_row + direction == dest_row:\n", - " return True\n", - " elif src_row + 2 * direction == dest_row and self.board[src_row + direction][dest_col] == \"\":\n", - " # Movimento inicial de duas casas\n", - " return True\n", - "\n", - " # Captura diagonal\n", - " if abs(src_col - dest_col) == 1 and src_row + direction == dest_row:\n", - " return dest_piece and dest_piece.isupper() if direction == 1 else dest_piece and dest_piece.islower()\n", - "\n", - " return False\n", - "\n", - " def valid_rook_move(self, src_row, src_col, dest_row, dest_col):\n", - " # Movimento na mesma linha ou coluna\n", - " return src_row == dest_row or src_col == dest_col and self.clear_path(src_row, src_col, dest_row, dest_col)\n", - "\n", - " def clear_path(self, src_row, src_col, dest_row, dest_col):\n", - " # Verificar se não há peças no caminho entre src e dest\n", - " if src_row == dest_row:\n", - " for col in range(min(src_col, dest_col) + 1, max(src_col, dest_col)):\n", - " if self.board[src_row][col] != \"\":\n", - " return False\n", - " elif src_col == dest_col:\n", - " for row in range(min(src_row, dest_row) + 1, max(src_row, dest_row)):\n", - " if self.board[row][src_col] != \"\":\n", - " return False\n", - " return True\n", - "\n", - " def valid_knight_move(self, src_row, src_col, dest_row, dest_col):\n", - " # Movimento em L\n", - " return (abs(dest_row - src_row) == 2 and abs(dest_col - src_col) == 1) or \\\n", - " (abs(dest_col - src_col) == 2 and abs(dest_row - src_row) == 1)\n", - "\n", - " def valid_bishop_move(self, src_row, src_col, dest_row, dest_col):\n", - " # Movimento na diagonal\n", - " return abs(dest_row - src_row) == abs(dest_col - src_col) and self.clear_path(src_row, src_col, dest_row, dest_col)\n", - "\n", - " def valid_queen_move(self, src_row, src_col, dest_row, dest_col):\n", - " # Movimento como torre ou bispo\n", - " return (src_row == dest_row or src_col == dest_col or\n", - " abs(dest_row - src_row) == abs(dest_col - src_col)) and self.clear_path(src_row, src_col, dest_row, dest_col)\n", - "\n", - " def valid_king_move(self, src_row, src_col, dest_row, dest_col):\n", - " # Movimento para qualquer direção (uma casa)\n", - " return abs(dest_row - src_row) <= 1 and abs(dest_col - src_col) <= 1\n", - "\n", - " def get_valid_moves(self, row, col):\n", - " piece = self.board[row][col]\n", - " valid_moves = set()\n", - "\n", - " for i in range(8):\n", - " for j in range(8):\n", - " dest_row, dest_col = i, j\n", - " if self.is_valid_move(row, col, dest_row, dest_col):\n", - " valid_moves.add((dest_row, dest_col))\n", - "\n", - " return valid_moves\n", - "\n", - " def piece_to_unicode(self, piece):\n", - " piece_unicode = {\n", - " \"p\": \"♟\", \"r\": \"♜\", \"n\": \"♞\", \"b\": \"♝\", \"q\": \"♛\", \"k\": \"♚\",\n", - " \"P\": \"♙\", \"R\": \"♖\", \"N\": \"♘\", \"B\": \"♗\", \"Q\": \"♕\", \"K\": \"♔\"\n", - " }\n", - " return piece_unicode.get(piece, \"\")\n", - "\n", - "if __name__ == \"__main__\":\n", - " root = tk.Tk()\n", - " game = ChessGame(root)\n", - " root.mainloop()\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.5" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/2_section_Exercises/Exercise+Python.ipynb b/2_section_Exercises/Exercise+Python.ipynb index a3a7f09..d197b2b 100644 --- a/2_section_Exercises/Exercise+Python.ipynb +++ b/2_section_Exercises/Exercise+Python.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 15, + "execution_count": 1, "id": "8dcfced0", "metadata": {}, "outputs": [ @@ -14,8 +14,8 @@ "\n", "O número informado foi 9.0.\n", "O número 9.0 é ímpar.\n", - "O número 9.0 é positivo\n", - "A raiz quadrada de 9 é 3.\n" + "O número 9.0 é positivo.\n", + "A raiz quadrada de 9e+00 é 3.\n" ] } ], @@ -34,13 +34,13 @@ "\"\"\"\n", "\n", "# Solicita ao usuário que insira um número e converte a entrada em float\n", - "num = float(input(\"Por favor, digite um número: \"))\n", + "number = float(input(\"Por favor, digite um número: \"))\n", "\n", "\n", "#1. Mostrar o número informado.\n", "\n", "# Exibe o número que o usuário inseriu\n", - "print(f\"\\nO número informado foi {num}.\")\n", + "print(f\"\\nO número informado foi {number}.\")\n", "\n", "\n", "#2. Informar se o número é par ou ímpar.\n", @@ -49,15 +49,15 @@ "# Se o resto da divisão do número por 2 é zero, é porque ele é par\n", "# if - Se\n", "# else - Senão\n", - "if num % 2 == 0:\n", + "if number % 2 == 0:\n", " \n", " # Imprime que o número é par\n", - " print(f\"O número {num} é par.\")\n", + " print(f\"O número {number} é par.\")\n", " \n", "else:\n", " \n", " # Caso contrário, imprime que o número é ímpar\n", - " print(f\"O número {num} é ímpar.\")\n", + " print(f\"O número {number} é ímpar.\")\n", " \n", " \n", "#3. Informar se o número é positivo, negativo ou zero.\n", @@ -67,25 +67,25 @@ "# if - Se\n", "# elif - Senão Se\n", "# else - Senão\n", - "if num > 0:\n", + "if number > 0:\n", " \n", " # Imprime que o número é positivo\n", - " print(f\"O número {num} é positivo.\")\n", + " print(f\"O número {number} é positivo.\")\n", " \n", " \n", " #4. Se o número for positivo, calcular e mostrar sua raiz quadrada.\n", " \n", " # Calcula a raiz quadrada do número elevando-o à potência 0.5\n", - " raiz = num ** 0.5\n", + " root = number ** 0.5\n", " \n", " # Imprime a raiz quadrada do número\n", - " print(f\"A raiz quadrada de {num:.0} é {raiz:.0f}.\")\n", + " print(f\"A raiz quadrada de {number:.0} é {root:.0f}.\")\n", " \n", "# Se o número for menor que zero, ele é negativo\n", - "elif num < 0:\n", + "elif number < 0:\n", " \n", " # Imprime que o número é negativo\n", - " print(f\"O número {num} é negativo.\")\n", + " print(f\"O número {number} é negativo.\")\n", " \n", "else:\n", " # Se o número não for nem positivo nem negativo, ele é zero\n", @@ -4968,7 +4968,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.11.5" } }, "nbformat": 4, diff --git a/3_section_OOP_Object_Oriented_Programming/Object+Oriented Programming (OOP).ipynb b/3_section_OOP_Object_Oriented_Programming/Object+Oriented Programming (OOP).ipynb index bc9e3f4..398ab8d 100644 --- a/3_section_OOP_Object_Oriented_Programming/Object+Oriented Programming (OOP).ipynb +++ b/3_section_OOP_Object_Oriented_Programming/Object+Oriented Programming (OOP).ipynb @@ -718,11 +718,11 @@ " \n", " # Método inicializador (construtor) da classe que é invocado quando um objeto \n", " # da classe é criado\n", - " def __init__(self, marca, modelo, cor):\n", - " self.marca = marca # Define o atributo marca do carro com o valor fornecido\n", - " self.modelo = modelo # Define o atributo modelo do carro com o valor fornecido\n", - " self.cor = cor # Define o atributo cor do carro com o valor fornecido\n", - " self.velocidade = 0 # Inicializa o atributo velocidade atual do carro com 0\n", + " def __init__(self, name):\n", + " self.marca = marca # Define o atributo marca do carro com o valor fornecido\n", + " self.modelo = modelo # Define o atributo modelo do carro com o valor fornecido\n", + " self.cor = cor # Define o atributo cor do carro com o valor fornecido\n", + " self.velocidade = velocidade # Inicializa o atributo velocidade atual do carro com 0\n", "\n", " \n", " # Método que aumenta a velocidade do carro em 10 km/h\n", @@ -973,7 +973,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 1, "id": "f44e161b", "metadata": {}, "outputs": [ @@ -984,7 +984,7 @@ "Nome da Fruta: Maçã\n", "Preço por Kg: R$2.50\n", "Quantidade em Estoque: 10kg\n", - "-------------\n", + "--------\n", "Nome da Fruta: Banana\n", "Preço por Kg: R$1.80\n", "Quantidade em Estoque: 15kg\n" @@ -1041,7 +1041,7 @@ " self.quantidade_em_estoque = quantidade_em_estoque # Atribui o valor do parâmetro 'quantidade_em_estoque' ao atributo 'quantidade_em_estoque' da instância\n", " \n", " \"\"\"\n", - " 3. Acesse os atributos das frutas instanciadas e exiba suas informações de forma organizada, como:\n", + " 2. Acesse os atributos das frutas instanciadas e exiba suas informações de forma organizada, como:\n", " \n", " Nome da Fruta: [nome da fruta]\n", " Preço por Kg: [preço da fruta por quilograma]\n", @@ -1062,14 +1062,14 @@ "\n", "\n", "\n", - "# 2. Instancie pelo menos duas frutas diferentes, fornecendo valores específicos para seus atributos.\n", + "# 3. Instancie pelo menos duas frutas diferentes, fornecendo valores específicos para seus atributos.\n", "\n", "# Instanciando duas frutas diferentes\n", "maca = Fruta(\"Maçã\", 2.5, 10)\n", "banana = Fruta(\"Banana\", 1.8, 15)\n", "\n", "maca.exibir_info()\n", - "print(\"-------------\")\n", + "print(\"--------\")\n", "banana.exibir_info()" ] }, @@ -1083,7 +1083,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 5, "id": "9af6d6dc", "metadata": {}, "outputs": [ @@ -1091,25 +1091,25 @@ "name": "stdout", "output_type": "stream", "text": [ - "João acordou.\n", - "João já está acordado.\n", - "João começou a comer.\n", - "João já está comendo.\n", - "João terminou de comer.\n", - "João não está comendo no momento.\n", - "João começou a dirigir.\n", - "João não pode dormir enquanto dirige.\n", - "João não pode comer enquanto dirige.\n", - "João já está dirigindo.\n", - "João parou de dirigir.\n", - "João começou a comer.\n", - "João não pode dormir enquanto come.\n", - "João não deve dirigir enquanto come.\n", - "João terminou de comer.\n", - "João foi dormir.\n", - "João não pode comer enquanto está dormindo.\n", - "João já está dormindo.\n", - "João não pode dirigir enquanto está dormindo.\n" + "steve acordou.\n", + "steve já está acordado.\n", + "steve começou a comer.\n", + "steve já está comendo.\n", + "steve terminou de comer.\n", + "steve não está comendo no momento.\n", + "steve não deve dirigir enquanto come.\n", + "steve não pode dormir enquanto come.\n", + "steve começou a comer.\n", + "steve não deve dirigir enquanto come.\n", + "steve terminou de comer.\n", + "steve começou a comer.\n", + "steve não pode dormir enquanto come.\n", + "steve não deve dirigir enquanto come.\n", + "steve terminou de comer.\n", + "steve não pode dormir enquanto come.\n", + "steve começou a comer.\n", + "steve não pode dormir enquanto come.\n", + "steve não deve dirigir enquanto come.\n" ] } ], @@ -1148,8 +1148,8 @@ "\n", "#Solução\n", "\n", - "# Define uma classe chamada \"Pessoa\"\n", - "class Pessoa:\n", + "# Define uma classe chamada \"Person\"\n", + "class Person:\n", " \n", " \"\"\"\n", " 1. A classe deve ter um construtor que aceite o nome da pessoa como \n", @@ -1157,11 +1157,11 @@ " \"\"\"\n", " \n", " # O construtor da classe, inicializa um novo objeto Pessoa com o nome fornecido\n", - " def __init__(self, nome):\n", - " self.nome = nome # Define o nome da pessoa como o nome fornecido\n", - " self.acordado = False # Inicialmente define o estado \"acordado\" como Falso\n", - " self.comendo = False # Inicialmente define o estado \"comendo\" como Falso\n", - " self.dirigindo = False # Inicialmente define o estado \"dirigindo\" como Falso\n", + " def __init__(self, name):\n", + " self.name = name # Define o nome da pessoa como o nome fornecido\n", + " self.awake = False # Inicialmente define o estado \"acordado\" como Falso\n", + " self.eating = False # Inicialmente define o estado \"comendo\" como Falso\n", + " self.drive = False # Inicialmente define o estado \"dirigindo\" como Falso\n", " \n", " \"\"\"\n", " 2. Implemente métodos para as seguintes ações:\n", @@ -1174,152 +1174,152 @@ " \"\"\"\n", " \n", " # Método para fazer a pessoa acordar\n", - " def acordar(self):\n", + " def wake_up(self):\n", " \n", " # Verifica se a pessoa já está acordada\n", - " if self.acordado:\n", + " if self.awake:\n", " \n", " # Se sim, imprime que a pessoa já está acordada\n", - " print(f\"{self.nome} já está acordado.\")\n", + " print(f\"{self.name} já está acordado.\")\n", " \n", " else:\n", " \n", " # Se não, muda o estado \"acordado\" para Verdadeiro\n", - " self.acordado = True\n", + " self.awake = True\n", " \n", " # E imprime que a pessoa acordou\n", - " print(f\"{self.nome} acordou.\")\n", + " print(f\"{self.name} acordou.\")\n", " \n", " # Método para fazer a pessoa comer\n", - " def comer(self):\n", + " def eat(self):\n", " \n", " # Verifica se a pessoa está dirigindo\n", - " if self.dirigindo:\n", + " if self.drive:\n", " \n", " # Se sim, imprime que não pode comer enquanto dirige\n", - " print(f\"{self.nome} não pode comer enquanto dirige.\")\n", + " print(f\"{self.name} não pode comer enquanto dirige.\")\n", " \n", " # Verifica se a pessoa está dormindo\n", - " elif not self.acordado:\n", + " elif not self.awake:\n", " \n", " # Se sim, imprime que não pode comer enquanto dorme\n", - " print(f\"{self.nome} não pode comer enquanto está dormindo.\")\n", + " print(f\"{self.name} não pode comer enquanto está dormindo.\")\n", " \n", " # Verifica se a pessoa já está comendo\n", - " elif self.comendo:\n", + " elif self.eating:\n", " \n", " # Se sim, imprime que a pessoa já está comendo\n", - " print(f\"{self.nome} já está comendo.\")\n", + " print(f\"{self.name} já está comendo.\")\n", " \n", " else:\n", " \n", " # Se todas as condições acima não forem verdadeiras, então a pessoa pode comer\n", - " self.comendo = True\n", + " self.eating = True\n", " \n", " # Imprime que a pessoa começou a comer\n", - " print(f\"{self.nome} começou a comer.\")\n", + " print(f\"{self.name} começou a comer.\")\n", " \n", " # Método para fazer a pessoa parar de comer\n", - " def parar_de_comer(self):\n", + " def stop_eating(self):\n", " \n", " # Verifica se a pessoa não está comendo\n", - " if not self.comendo:\n", + " if not self.eating:\n", " \n", " # Se sim, imprime que a pessoa não está comendo\n", - " print(f\"{self.nome} não está comendo no momento.\")\n", + " print(f\"{self.name} não está comendo no momento.\")\n", " \n", " else:\n", " \n", " # Se a pessoa estiver comendo, então ela pode parar de comer\n", - " self.comendo = False\n", + " self.eating = False\n", " \n", " # Imprime que a pessoa parou de comer\n", - " print(f\"{self.nome} terminou de comer.\")\n", + " print(f\"{self.name} terminou de comer.\")\n", " \n", " # Método para fazer a pessoa dirigir\n", - " def dirigir(self):\n", + " def driving(self):\n", " \n", " # Verifica se a pessoa está dormindo\n", - " if not self.acordado:\n", + " if not self.awake:\n", " \n", " # Se sim, imprime que não pode dirigir\n", - " print(f\"{self.nome} não pode dirigir enquanto está dormindo.\")\n", + " print(f\"{self.name} não pode dirigir enquanto está dormindo.\")\n", " \n", " # Verifica se a pessoa está comendo\n", - " elif self.comendo:\n", + " elif self.eat:\n", " \n", " # Se sim, imprime que não deve dirigir enquanto come\n", - " print(f\"{self.nome} não deve dirigir enquanto come.\")\n", + " print(f\"{self.name} não deve dirigir enquanto come.\")\n", " \n", " # Verifica se a pessoa já está dirigindo\n", - " elif self.dirigindo:\n", + " elif self.drive:\n", " \n", " # Se sim, imprime que a pessoa já está dirigindo\n", - " print(f\"{self.nome} já está dirigindo.\")\n", + " print(f\"{self.name} já está dirigindo.\")\n", " \n", " else:\n", " \n", " # Se nenhuma das condições acima for verdadeira, a pessoa pode dirigir\n", - " self.dirigindo = True\n", + " self.drive = True\n", " \n", " # Imprime que a pessoa começou a dirigir\n", - " print(f\"{self.nome} começou a dirigir.\")\n", + " print(f\"{self.name} começou a dirigir.\")\n", " \n", " # Método para fazer a pessoa parar de dirigir\n", - " def parar_de_dirigir(self):\n", + " def stop_driving(self):\n", " \n", " # Verifica se a pessoa não está dirigindo\n", - " if not self.dirigindo:\n", + " if not self.drive:\n", " \n", " # Se sim, imprime que a pessoa não está dirigindo\n", - " print(f\"{self.nome} não está dirigindo no momento.\")\n", + " print(f\"{self.name} não está dirigindo no momento.\")\n", " \n", " else:\n", " \n", " # Se a pessoa estiver dirigindo, então ela pode parar\n", - " self.dirigindo = False\n", + " self.drive = False\n", " \n", " # Imprime que a pessoa parou de dirigir\n", - " print(f\"{self.nome} parou de dirigir.\")\n", + " print(f\"{self.name} parou de dirigir.\")\n", "\n", " \n", " # Método para fazer a pessoa dormir\n", - " def dormir(self):\n", + " def sleep(self):\n", " \n", " # Verifica se a pessoa está dirigindo\n", - " if self.dirigindo:\n", + " if self.drive:\n", " \n", " # Se sim, imprime que não pode dormir enquanto dirige\n", - " print(f\"{self.nome} não pode dormir enquanto dirige.\")\n", + " print(f\"{self.name} não pode dormir enquanto dirige.\")\n", " \n", " # Verifica se a pessoa está comendo\n", - " elif self.comendo:\n", + " elif self.eat:\n", " \n", " # Se sim, imprime que não pode dormir enquanto come\n", - " print(f\"{self.nome} não pode dormir enquanto come.\")\n", + " print(f\"{self.name} não pode dormir enquanto come.\")\n", " \n", " # Verifica se a pessoa já está dormindo\n", - " elif not self.acordado:\n", + " elif not self.awake:\n", " \n", " # Se sim, imprime que a pessoa já está dormindo\n", - " print(f\"{self.nome} já está dormindo.\")\n", + " print(f\"{self.name} já está dormindo.\")\n", " \n", " else:\n", " \n", " # Se nenhuma das condições acima for verdadeira, a pessoa pode dormir\n", - " print(f\"{self.nome} foi dormir.\")\n", + " print(f\"{self.name} foi dormir.\")\n", " \n", " # Define o estado \"acordado\" como Falso\n", - " self.acordado = False\n", + " self.awake = False\n", " \n", " # Define o estado \"comendo\" como Falso\n", - " self.comendo = False\n", + " self.eat = False\n", " \n", " # Aqui, não redefinimos 'self.dirigindo' para manter seu estado atual\n", " \n", " \n", - "# Criando um objeto \"joao\" da classe \"Pessoa\" e passando \"João\" como nome para o construtor\n", - "joao = Pessoa(\"João\")\n", + "# Criando um objeto \"joao\" da classe \"Pessoa\" e passando \"Steve\" como nome para o construtor\n", + "Steve = Person(\"steve\")\n", "\n", "\"\"\"\n", "4. Teste a classe criando um objeto e chamando vários métodos em sequência, simulando \n", @@ -1327,57 +1327,57 @@ "\"\"\"\n", "\n", "# Tentando fazer João acordar\n", - "joao.acordar() # Ação de acordar é executada, João agora está acordado\n", - "joao.acordar() # Já está acordado, então uma mensagem informando isso é impressa\n", + "Steve.wake_up() # Ação de acordar é executada, João agora está acordado\n", + "Steve.wake_up() # Já está acordado, então uma mensagem informando isso é impressa\n", "\n", "# Fazendo João comer\n", - "joao.comer() # Ação de comer é executada, João agora está comendo\n", + "Steve.eat() # Ação de comer é executada, João agora está comendo\n", "\n", "# Tentando fazer João comer novamente\n", - "joao.comer() # Já está comendo, então uma mensagem informando isso é impressa\n", + "Steve.eat() # Já está comendo, então uma mensagem informando isso é impressa\n", "\n", "# Tentando fazer João parar de comer\n", - "joao.parar_de_comer() # Ação de parar de comer é executada, João agora parou de comer\n", - "joao.parar_de_comer() # Não está comendo, então uma mensagem informando isso é impressa\n", + "Steve.stop_eating() # Ação de parar de comer é executada, João agora parou de comer\n", + "Steve.stop_eating() # Não está comendo, então uma mensagem informando isso é impressa\n", "\n", "# Fazendo João dirigir\n", - "joao.dirigir() # Ação de dirigir é executada, João agora está dirigindo\n", + "Steve.driving() # Ação de dirigir é executada, João agora está dirigindo\n", "\n", "# Tentando fazer João dormir\n", - "joao.dormir() # Não pode dormir enquanto dirige, então uma mensagem informando isso é impressa\n", + "Steve.sleep() # Não pode dormir enquanto dirige, então uma mensagem informando isso é impressa\n", "\n", "# Tentando fazer João comer enquanto dirige\n", - "joao.comer() # Não pode comer enquanto dirige, então uma mensagem informando isso é impressa\n", + "Steve.eat() # Não pode comer enquanto dirige, então uma mensagem informando isso é impressa\n", "\n", "# Tentando fazer João dirigir novamente\n", - "joao.dirigir() # Já está dirigindo, então uma mensagem informando isso é impressa\n", + "Steve.driving() # Já está dirigindo, então uma mensagem informando isso é impressa\n", "\n", "# Fazendo João parar de dirigir\n", - "joao.parar_de_dirigir() # Ação de parar de dirigir é executada, João agora parou de dirigir\n", + "Steve.stop_eating() # Ação de parar de dirigir é executada, João agora parou de dirigir\n", "\n", "# Fazendo João comer\n", - "joao.comer() # Ação de comer é executada, João agora está comendo\n", + "Steve.eat() # Ação de comer é executada, João agora está comendo\n", "\n", "# Tentando fazer João dormir enquanto come\n", - "joao.dormir() # Não pode dormir enquanto come, então uma mensagem informando isso é impressa\n", + "Steve.sleep() # Não pode dormir enquanto come, então uma mensagem informando isso é impressa\n", "\n", "# Tentando fazer João dirigir enquanto come\n", - "joao.dirigir() # Não pode dirigir enquanto come, então uma mensagem informando isso é impressa\n", + "Steve.driving() # Não pode dirigir enquanto come, então uma mensagem informando isso é impressa\n", "\n", "# Tentando fazer João parar de comer quando não está comendo\n", - "joao.parar_de_comer() # Ação de parar de comer é executada, João agora parou de comer\n", + "Steve.stop_eating() # Ação de parar de comer é executada, João agora parou de comer\n", "\n", "# Tentando fazer João dormir\n", - "joao.dormir() # Ação de dormir é executada, João agora está dormindo\n", + "Steve.sleep() # Ação de dormir é executada, João agora está dormindo\n", "\n", "# Tentando fazer João comer enquanto dorme\n", - "joao.comer() # Não pode comer enquanto dorme, então uma mensagem informando isso é impressa\n", + "Steve.eat() # Não pode comer enquanto dorme, então uma mensagem informando isso é impressa\n", "\n", "# Tentando fazer João dormir quando já está dormindo\n", - "joao.dormir() # Já está dormindo, então uma mensagem informando isso é impressa\n", + "Steve.sleep() # Já está dormindo, então uma mensagem informando isso é impressa\n", "\n", "# Tentando fazer João dirigir enquanto dorme\n", - "joao.dirigir() # Não pode dirigir enquanto dorme, então uma mensagem informando isso é impressa" + "Steve.driving() # Não pode dirigir enquanto dorme, então uma mensagem informando isso é impressa" ] }, { @@ -1390,7 +1390,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 8, "id": "423f3ac3", "metadata": {}, "outputs": [ @@ -1398,13 +1398,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Temperatura aumentada em 5°. Nova temperatura: 25°.\n", - "Temperatura diminuída em 5°. Nova temperatura: 20°.\n", - "Temperatura configurada para 10°.\n", + "Increase temperature in 5°. New temeprature: 25°.\n", + "Decrese temperature in 5°. New temeprature: 20°.\n", + "Config temperature for 10°.\n", "Temperatura atual: 10°.\n", - "Temperatura aumentada em 50°. Nova temperatura: 60°.\n", - "Temperatura diminuída em 25°. Nova temperatura: 35°.\n", - "Temperatura configurada para 15°.\n", + "Increase temperature in 50°. New temeprature: 60°.\n", + "Decrese temperature in 25°. New temeprature: 35°.\n", + "Config temperature for 15°.\n", "Temperatura atual: 15°.\n" ] } @@ -1428,69 +1428,69 @@ "#1. Definição da Classe Termostato:\n", "\n", "# Define a classe Termostato\n", - "class Termostato:\n", + "class Thermostat:\n", " \n", " # Método inicializador da classe Termostato\n", - " def __init__(self, temperatura_atual=20):\n", + " def __init__(self, actual_temperature=20):\n", " \n", " # Inicializa o atributo 'temperatura_atual' com o valor fornecido ou 20 graus por padrão\n", - " self.temperatura_atual = temperatura_atual \n", + " self.actual_temperature = actual_temperature \n", "\n", " # Método para aumentar a temperatura\n", - " def aumentar_temperatura(self, valor):\n", + " def increase_temperature(self, value):\n", " \n", " # Adiciona o valor fornecido ao atributo 'temperatura_atual'\n", - " self.temperatura_atual += valor \n", + " self.actual_temperature += value \n", " \n", " # Imprime a nova temperatura após o aumento\n", - " print(f\"Temperatura aumentada em {valor}°. Nova temperatura: {self.temperatura_atual}°.\") \n", + " print(f\"Increase temperature in {value}°. New temeprature: {self.actual_temperature}°.\") \n", " \n", " # Método para diminuir a temperatura\n", - " def diminuir_temperatura(self, valor):\n", + " def decrease_temperature(self, value):\n", " \n", " # Subtrai o valor fornecido do atributo 'temperatura_atual'\n", - " self.temperatura_atual -= valor \n", + " self.actual_temperature -= value \n", " \n", " # Imprime a nova temperatura após a diminuição\n", - " print(f\"Temperatura diminuída em {valor}°. Nova temperatura: {self.temperatura_atual}°.\") \n", + " print(f\"Decrese temperature in {value}°. New temeprature: {self.actual_temperature}°.\") \n", " \n", " # Método para configurar (definir) a temperatura\n", - " def configurar_temperatura(self, nova_temperatura):\n", + " def config_temperature(self, new_temperature):\n", " \n", " # Define a 'temperatura_atual' para o novo valor fornecido\n", - " self.temperatura_atual = nova_temperatura \n", + " self.actual_temperature = new_temperature\n", " \n", " # Imprime a temperatura após ser reconfigurada\n", - " print(f\"Temperatura configurada para {nova_temperatura}°.\")\n", + " print(f\"Config temperature for {new_temperature}°.\")\n", " \n", " # Método para exibir a temperatura atual\n", - " def mostrar_temperatura(self):\n", + " def show_temperature(self):\n", " \n", " # Imprime o valor atual do atributo 'temperatura_atual'\n", - " print(f\"Temperatura atual: {self.temperatura_atual}°.\")\n", + " print(f\"Actual temperature: {self.actual_temperature}°.\")\n", " \n", "\n", "#2. Interagindo com o Termostato:\n", "\n", "# Instanciando um termostato\n", - "meu_termostato = Termostato()\n", + "my_thermostat = Thermostat()\n", "\n", "# Usando métodos para interagir com o termostato\n", - "meu_termostato.aumentar_temperatura(5) # Aumenta a temperatura em 5°\n", + "my_thermostat.increase_temperature(5) # Aumenta a temperatura em 5°\n", "\n", - "meu_termostato.diminuir_temperatura(5) # Aumenta a temperatura em 5°\n", + "my_thermostat.decrease_temperature(5) # Aumenta a temperatura em 5°\n", "\n", - "meu_termostato.configurar_temperatura(10) # Configura diretamente a temperatura para 10°\n", + "my_thermostat.config_temperature(10) # Configura diretamente a temperatura para 10°\n", "\n", - "meu_termostato.mostrar_temperatura() # Mostra a temperatura atual (deveria ser 10°)\n", + "my_thermostat.show_temperature() # Mostra a temperatura atual (deveria ser 10°)\n", "\n", - "meu_termostato.aumentar_temperatura(50) # Aumenta a temperatura em 50°\n", + "my_thermostat.increase_temperature(50) # Aumenta a temperatura em 50°\n", "\n", - "meu_termostato.diminuir_temperatura(25) # Aumenta a temperatura em 25°\n", + "my_thermostat.decrease_temperature(25) # Aumenta a temperatura em 25°\n", "\n", - "meu_termostato.configurar_temperatura(15)\n", + "my_thermostat.config_temperature(15)\n", "\n", - "meu_termostato.mostrar_temperatura()" + "my_thermostat.show_temperature()" ] }, { @@ -1503,7 +1503,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "71f54e8b", "metadata": {}, "outputs": [ @@ -1512,38 +1512,37 @@ "output_type": "stream", "text": [ "\n", - "Bem-vindo ao Formatador de Frase!\n", - "Por favor, digite uma frase: teste\n", - "\n", - "Escolha uma opção para formatar a sua frase:\n", - "1. Converter para maiúsculas\n", - "2. Converter para minúsculas\n", - "3. Capitalizar a primeira letra da frase\n", - "4. Converter para o formato título.\n", - "5. Contar Vogais\n", - "6. Contar Consoantes\n", - "7. Contar letra 'a'\n", - "8. Pesquisar palavra\n", - "9. Mostrar frase atual\n", - "10. Sair\n", - "\n", - "Digite o número da sua escolha: 9\n", - "\n", - "Frase atual: teste\n", - "\n", - "Escolha uma opção para formatar a sua frase:\n", - "1. Converter para maiúsculas\n", - "2. Converter para minúsculas\n", - "3. Capitalizar a primeira letra da frase\n", - "4. Converter para o formato título.\n", - "5. Contar Vogais\n", - "6. Contar Consoantes\n", - "7. Contar letra 'a'\n", - "8. Pesquisar palavra\n", - "9. Mostrar frase atual\n", - "10. Sair\n", - "\n", - "Digite o número da sua escolha: 10\n", + "Welcome to the formatting phrase!\n", + "Please, input a phrase.Steve a new programmer in the world.\n", + "\n", + "Choose an option to format your sentence:\n", + "1. Convert to uppercase.\n", + "2. Convert to lowercase.\n", + "3. Capitalize at the first phrase's letter.\n", + "4. Convert to the title format.\n", + "5. Count Vowels\n", + "6. Count Consonants\n", + "7. Count letter 'a'\n", + "8. Search Word\n", + "9. Show actual phrase\n", + "10. To go out\n", + "\n", + "Enter the number of your choice: 1\n", + "Frase atual: STEVE A NEW PROGRAMMER IN THE WORLD.\n", + "\n", + "Choose an option to format your sentence:\n", + "1. Convert to uppercase.\n", + "2. Convert to lowercase.\n", + "3. Capitalize at the first phrase's letter.\n", + "4. Convert to the title format.\n", + "5. Count Vowels\n", + "6. Count Consonants\n", + "7. Count letter 'a'\n", + "8. Search Word\n", + "9. Show actual phrase\n", + "10. To go out\n", + "\n", + "Enter the number of your choice: 10\n", "Saindo do programa. Até mais!\n" ] } @@ -1593,130 +1592,130 @@ "#Solução\n", "\n", "# Definindo a classe FormatadorDeFrase\n", - "class FormatadorDeFrase:\n", + "class FormattingPhrase:\n", " \n", " # Método construtor, que é chamado quando um novo objeto da classe é instanciado\n", - " def __init__(self, frase):\n", + " def __init__(self, phrase):\n", " \n", " # Inicializa a variável de instância 'frase' com o valor passado como argumento\n", - " self.frase = frase\n", + " self.phrase = phrase\n", " \n", " # Método para converter todos os caracteres da frase para maiúsculas\n", - " def para_maiusculas(self):\n", + " def to_upperCase(self):\n", " \n", " # Usa o método upper() para converter a frase para maiúsculas e \n", " # armazena na variável de instância 'frase'\n", - " self.frase = self.frase.upper()\n", + " self.phrase = self.phrase.upper()\n", " \n", " # Método para converter todos os caracteres da frase para minúsculas\n", - " def para_minusculas(self):\n", + " def to_lowerCase(self):\n", " \n", " # Usa o método lower() para converter a frase para minúsculas e \n", " # armazena na variável de instância 'frase'\n", - " self.frase = self.frase.lower()\n", + " self.phrase = self.phrase.lower()\n", " \n", " # Método para capitalizar a primeira letra da frase\n", - " def capitalizar(self):\n", + " def capitalize(self):\n", " \n", " # Usa o método capitalize() para capitalizar a primeira letra da \n", " # frase e armazena na variável de instância 'frase'\n", - " self.frase = self.frase.capitalize()\n", + " self.phrase = self.phrase.capitalize()\n", " \n", " # Método para converter a frase para o formato de título\n", - " def formato_titulo(self):\n", + " def title_format(self):\n", " \n", " # Usa o método title() para capitalizar a primeira letra de cada\n", " # palavra na frase\n", - " self.frase = self.frase.title()\n", + " self.phrase = self.phrase.title()\n", " \n", " # Método para contar o número de vogais na frase\n", - " def contar_vogais(self):\n", + " def vowels_count(self):\n", " \n", " # Define uma string contendo todas as vogais\n", " # vogais = 'aeiou'\n", - " vogais = 'aeiouáéíóúàèìòùãõâêîôû'\n", + " vowels = 'aeiouáéíóúàèìòùãõâêîôû'\n", " \n", " # Conta as vogais na frase (convertida para minúsculas) e retorna a soma\n", " # return sum(1 for letra in self.frase.lower() if letra in vogais)\n", " \n", " # Inicializa uma variável de contagem para armazenar o número de vogais\n", - " contagem = 0\n", + " score = 0\n", "\n", " # Converte a frase para minúsculas para simplificar a comparação\n", - " frase_minuscula = self.frase.lower()\n", + " lowerCase_phrase = self.frase.lower()\n", "\n", " # Percorre cada letra da frase\n", - " for letra in frase_minuscula:\n", + " for letter in lowerCase_phrase:\n", " \n", " # Verifica se a letra atual é uma vogal\n", - " if letra in vogais:\n", + " if letter in vowels:\n", " \n", " # Incrementa a variável de contagem\n", - " contagem += 1\n", + " score += 1\n", "\n", " # Retorna o total de vogais encontradas\n", - " return contagem\n", + " return score\n", " \n", " # Método para contar o número de consoantes na frase\n", - " def contar_consoantes(self):\n", + " def consonants_count(self):\n", " \n", " # Define uma string contendo todas as consoantes\n", - " consoantes = 'bcdfghjklmnpqrstvwxyzç'\n", + " consonants = 'bcdfghjklmnpqrstvwxyzç'\n", " \n", " # Conta as consoantes na frase (convertida para minúsculas) e retorna a soma\n", " # return sum(1 for letra in self.frase.lower() if letra in consoantes)\n", " \n", " # Inicializa uma variável de contagem para armazenar o número de consoantes\n", - " contagem = 0\n", + " score = 0\n", "\n", " # Converte a frase para minúsculas para facilitar a comparação\n", - " frase_minuscula = self.frase.lower()\n", + " lowerCase_phrase = self.phrase.lower()\n", "\n", " # Loop para percorrer cada letra da frase\n", - " for letra in frase_minuscula:\n", + " for letter in lowerCase_phrase:\n", " \n", " # Checa se a letra atual é uma consoante\n", - " if letra in consoantes:\n", + " if letter in consonants:\n", " \n", " # Incrementa a variável de contagem\n", - " contagem += 1\n", + " score += 1\n", "\n", " # Retorna o total de consoantes encontradas\n", - " return contagem\n", + " return score\n", " \n", " # Método para contar o número de ocorrências da letra 'a' na frase\n", - " def contar_letra_a(self):\n", + " def count_letter_a(self):\n", " \n", " # Usa o método count() para contar o número de ocorrências da \n", " # letra 'a' na frase (convertida para minúsculas)\n", - " return self.frase.lower().count('a')\n", + " return self.phrase.lower().count('a')\n", " \n", " # Método para procurar e contar o número de ocorrências de uma palavra específica na frase\n", - " def procurar_palavra(self, palavra):\n", + " def find_letter(self, word):\n", " \n", " # Usa o método count() para contar o número de ocorrências da \n", " # palavra na frase (ambas convertidas para minúsculas)\n", - " return self.frase.lower().count(palavra.lower())\n", + " return self.phrase.lower().count(word.lower())\n", " \n", " # Método para obter a frase atual\n", - " def obter_frase(self):\n", + " def get_phrase(self):\n", " \n", " # Retorna a variável de instância 'frase'\n", - " return self.frase\n", + " return self.phrase\n", "\n", "\n", "# Definindo a função menu, que será a interface do usuário para o programa\n", "def menu():\n", " \n", " # Imprime uma mensagem de boas-vindas\n", - " print(\"\\nBem-vindo ao Formatador de Frase!\")\n", + " print(\"\\nWelcome to the formatting phrase!\")\n", " \n", " # Solicita ao usuário que digite uma frase\n", - " frase = input(\"Por favor, digite uma frase: \")\n", + " phrase = input(\"Please, input a phrase.\")\n", " \n", " # Cria um objeto 'formatador' da classe FormatadorDeFrase, \n", " # passando a frase digitada como argumento\n", - " formatador = FormatadorDeFrase(frase)\n", + " formatting = FormattingPhrase(phrase)\n", " \n", " # Enquanto verdadeiro, o menu ficará em execução\n", " while True:\n", @@ -1734,79 +1733,79 @@ " \"\"\"\n", " \n", " # Imprime as opções do menu\n", - " print(\"\\nEscolha uma opção para formatar a sua frase:\")\n", - " print(\"1. Converter para maiúsculas\")\n", - " print(\"2. Converter para minúsculas\")\n", - " print(\"3. Capitalizar a primeira letra da frase\")\n", - " print(\"4. Converter para o formato título.\")\n", - " print(\"5. Contar Vogais\")\n", - " print(\"6. Contar Consoantes\")\n", - " print(\"7. Contar letra 'a'\")\n", - " print(\"8. Pesquisar palavra\")\n", - " print(\"9. Mostrar frase atual\")\n", - " print(\"10. Sair\")\n", + " print(\"\\nChoose an option to format your sentence:\")\n", + " print(\"1. Convert to uppercase.\")\n", + " print(\"2. Convert to lowercase.\")\n", + " print(\"3. Capitalize at the first phrase's letter.\")\n", + " print(\"4. Convert to the title format.\")\n", + " print(\"5. Count Vowels\")\n", + " print(\"6. Count Consonants\")\n", + " print(\"7. Count letter 'a'\")\n", + " print(\"8. Search Word\")\n", + " print(\"9. Show actual phrase\")\n", + " print(\"10. To go out\")\n", " \n", " # Solicita ao usuário que escolha uma opção\n", - " escolha = input(\"\\nDigite o número da sua escolha: \")\n", + " choice = input(\"\\nEnter the number of your choice: \")\n", " \n", " # Verifica qual opção foi escolhida e chama o método correspondente\n", " # do objeto 'formatador'\n", - " if escolha == \"1\":\n", + " if choice == \"1\":\n", " \n", " # Chama o método para converter a frase para maiúsculas\n", - " formatador.para_maiusculas()\n", + " formatting.to_upperCase()\n", " \n", - " elif escolha == \"2\":\n", + " elif choice == \"2\":\n", " \n", " # Chama o método para converter a frase para minúsculas\n", - " formatador.para_minusculas()\n", + " formatting.to_lowerCase()\n", " \n", - " elif escolha == \"3\":\n", + " elif choice == \"3\":\n", " \n", " # Chama o método para capitalizar a primeira letra da frase\n", - " formatador.capitalizar()\n", + " formatting.capitalize()\n", " \n", - " elif escolha == \"4\":\n", + " elif choice == \"4\":\n", " \n", " # Chama o método para converter a frase para o formato de título\n", - " formatador.formato_titulo()\n", + " formatting.title_formatting()\n", " \n", - " elif escolha == \"5\":\n", + " elif choice == \"5\":\n", " \n", " # Chama o método para contar as vogais na frase e imprime o resultado\n", - " print(f\"Total de vogais: {formatador.contar_vogais()}\")\n", + " print(f\"Total de vogais: {formatting.vowels_count()}\")\n", " \n", - " elif escolha == \"6\":\n", + " elif choice == \"6\":\n", " \n", " # Chama o método para contar as consoantes na frase e imprime o resultado\n", - " print(f\"Total de consoantes: {formatador.contar_consoantes()}\")\n", + " print(f\"Total de consoantes: {formatting.consonants_count()}\")\n", " \n", - " elif escolha == \"7\":\n", + " elif choice == \"7\":\n", " \n", " # Chama o método para contar ocorrências da letra 'a' na frase e imprime o resultado\n", - " print(f\"Total de ocorrências da letra 'a': {formatador.contar_letra_a()}\")\n", + " print(f\"Total de ocorrências da letra 'a': {formatting.count_letter_a()}\")\n", "\n", - " elif escolha == \"8\":\n", + " elif choice == \"8\":\n", " \n", " # Solicita ao usuário a palavra que deseja pesquisar\n", - " palavra = input(\"Digite a palavra que você quer pesquisar: \")\n", + " word = input(\"Enter the word that you want to search: \")\n", " \n", " # Chama o método para pesquisar a palavra e armazena o resultado\n", - " contagem = formatador.procurar_palavra(palavra)\n", + " count = formatting.find_letter(word)\n", " \n", " # Exibe o resultado da pesquisa\n", - " if contagem > 0:\n", - " print(f\"A palavra '{palavra}' aparece {contagem} vez(es) na frase.\")\n", + " if score > 0:\n", + " print(f\"A palavra '{word}' aparece {score} vez(es) na frase.\")\n", " else:\n", - " print(f\"A palavra '{palavra}' não foi encontrada na frase.\")\n", + " print(f\"A palavra '{word}' não foi encontrada na frase.\")\n", " \n", - " elif escolha == \"9\":\n", + " elif choice == \"9\":\n", " \n", " # Mostra a frase atualizada\n", - " print(\"\\nFrase atual:\", formatador.obter_frase())\n", + " print(\"\\nFrase atual:\", formatting.get_phrase())\n", " continue\n", " \n", - " elif escolha == \"10\":\n", + " elif choice == \"10\":\n", " \n", " # Encerra o programa\n", " print(\"Saindo do programa. Até mais!\")\n", @@ -1818,7 +1817,7 @@ " print(\"Escolha inválida. Tente novamente.\")\n", "\n", " # Mostra a frase atualizada após aplicar qualquer formatação\n", - " print(\"Frase atual: \", formatador.obter_frase())\n", + " print(\"Frase atual: \", formatting.get_phrase())\n", "\n", "# Verifica se o script está sendo executado como programa \n", "# principal e, nesse caso, chama a função menu\n", @@ -2559,7 +2558,8 @@ " \n", " # Inicializa o atributo '_idade' da instância com o valor fornecido.\n", " # Este é um atributo protegido, indicado pelo prefixo de sublinhado simples.\n", - " # Ele pode ser acessado dentro da classe e suas subclasses, mas o acesso direto de fora da classe não é recomendado.\n", + " # Ele pode ser acessado dentro da classe e suas subclasses, mas o acesso direto \n", + " # de fora da classe não é recomendado.\n", " self._idade = idade \n", " \n", " # Inicializa o atributo '__saldo' da instância com o valor 0.\n", @@ -2835,7 +2835,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 17, "id": "6a953609", "metadata": {}, "outputs": [ @@ -2843,21 +2843,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "Nome: Bob\n", - "Idade: 5\n", - "Peso: 9.5 kg\n", + "Name: Buddy\n", + "Age: 5\n", + "Weight: 9.5 kg\n", "\n", "-----------------\n", "\n", - "Nome: Toto\n", - "Idade: 8\n", - "Peso: 7.5 kg\n", + "Name: Toto\n", + "Age: 8\n", + "Weight: 7.5 kg\n", "\n", "-----------------\n", "\n", - "Nome: Lua\n", - "Idade: 12\n", - "Peso: 9.3 kg\n" + "Name: Lua\n", + "Age: 12\n", + "Weight: 9.3 kg\n" ] } ], @@ -2897,137 +2897,102 @@ "# 1. Crie uma classe chamada Pet.\n", "# Definindo a classe Pet\n", "class Pet:\n", - " \n", " \"\"\"\n", " 2. A classe deve ter os seguintes atributos privados: _nome, _idade e _peso.\n", " - Utilize métodos \"getters\" para cada um desses atributos.\n", " - Utilize métodos \"setters\" para cada um desses atributos. \n", " \"\"\"\n", " # Método construtor para inicializar os atributos quando um objeto da classe é criado\n", - " def __init__(self):\n", - " \n", + " def __init__(self, name, age, weight):\n", " # Inicializa o atributo '_nome' como uma string vazia. \n", " # O prefixo \"_\" indica que é um atributo protegido.\n", - " self._nome = \"\"\n", + " self._name = name\n", " \n", " # Inicializa o atributo '_idade' como 0. \n", " # O prefixo \"_\" indica que é um atributo protegido.\n", - " self._idade = 0\n", + " self._age = age\n", " \n", " # Inicializa o atributo '_peso' como 0.0. \n", " # O prefixo \"_\" indica que é um atributo protegido.\n", - " self._peso = 0.0\n", + " self._weight = weight\n", " \n", " # Método \"getter\" para o nome, permite obter o valor do atributo '_nome'\n", - " def get_nome(self):\n", - " \n", - " return self._nome\n", + " def get_name(self):\n", + " return self._name\n", " \n", - " \"\"\"\n", - " Os \"setters\" devem conter as seguintes validações:\n", - " - O nome deve ser uma string e não pode ser vazio.\n", - " - A idade deve ser um número inteiro e deve ser maior ou igual a 0.\n", - " - O peso deve ser um número flutuante e deve ser maior que 0.\n", - " \"\"\"\n", - "\n", " # Método \"setter\" para o nome, permite definir um novo valor para o atributo '_nome'\n", - " def set_nome(self, novo_nome):\n", - " \n", + " def set_name(self, new_name):\n", " \"\"\"\n", " Os \"setters\" devem conter as seguintes validações:\n", " - O nome deve ser uma string e não pode ser vazio.\n", " \"\"\"\n", - " # Verifica se o novo_nome é uma string e se não está vazio\n", - " if isinstance(novo_nome, str) and novo_nome != \"\":\n", - " \n", + " # Verifica se o new_name é uma string e se não está vazio\n", + " if isinstance(new_name, str) and new_name != \"\":\n", " # Atualiza o valor do atributo '_nome'\n", - " self._nome = novo_nome\n", - " \n", + " self._name = new_name\n", " else:\n", - " \n", " # Imprime uma mensagem de erro se o nome fornecido não for válido\n", - " print(\"Nome inválido.\")\n", + " print(\"Invalid name\")\n", " \n", " # Método \"getter\" para a idade, permite obter o valor do atributo '_idade'\n", - " def get_idade(self):\n", - " \n", - " return self._idade\n", - " \n", + " def get_age(self):\n", + " return self._age\n", " \n", " # Método \"setter\" para a idade, permite definir um novo valor para o atributo '_idade'\n", - " def set_idade(self, nova_idade):\n", - " \n", + " def set_age(self, new_age):\n", " \"\"\"\n", - " Os \"setters\" devem conter as seguintes validações:\n", + " Os \"setters\" devem conter as seguintes validações:\n", " - A idade deve ser um número inteiro e deve ser maior ou igual a 0.\n", " \"\"\"\n", - " # Verifica se a nova_idade é um inteiro e se é maior ou igual a 0\n", - " if isinstance(nova_idade, int) and nova_idade >= 0:\n", - " \n", + " # Verifica se o new_age é um inteiro e se é maior ou igual a 0\n", + " if isinstance(new_age, int) and new_age >= 0:\n", " # Atualiza o valor do atributo '_idade'\n", - " self._idade = nova_idade\n", - " \n", + " self._age = new_age\n", " else:\n", - " \n", " # Imprime uma mensagem de erro se a idade fornecida não for válida\n", - " print(\"Idade inválida.\")\n", - " \n", - " # ---------------------------------------------\n", + " print(\"Invalid age\")\n", " \n", " # Método \"getter\" para o peso, permite obter o valor do atributo '_peso'\n", - " def get_peso(self):\n", - " \n", - " return self._peso\n", - "\n", + " def get_weight(self):\n", + " return self._weight\n", + " \n", " # Método \"setter\" para o peso, permite definir um novo valor para o atributo '_peso'\n", - " def set_peso(self, novo_peso):\n", - " \n", + " def set_weight(self, new_weight):\n", " \"\"\"\n", " Os \"setters\" devem conter as seguintes validações:\n", - " - O peso deve ser um número flutuante e deve ser maior que 0.\n", + " - O peso deve ser um número flutuante e deve ser maior que 0.\n", " \"\"\"\n", - " \n", - " # Verifica se o novo_peso é um número flutuante e se é maior que 0\n", - " if isinstance(novo_peso, float) and novo_peso > 0:\n", - " \n", + " # Verifica se o new_weight é um número flutuante e se é maior que 0\n", + " if isinstance(new_weight, float) and new_weight > 0:\n", " # Atualiza o valor do atributo '_peso'\n", - " self._peso = novo_peso\n", - " \n", + " self._weight = new_weight\n", " else:\n", - " \n", " # Imprime uma mensagem de erro se o peso fornecido não for válido\n", - " print(\"Peso inválido.\")\n", - " \n", - " \n", - " \n", - " # 3. Adicione um método exibir_info() que mostre as informações do pet.\n", - " def exibir_info(self):\n", - " \n", - " print(f\"Nome: {self._nome}\")\n", - " print(f\"Idade: {self._idade}\")\n", - " print(f\"Peso: {self._peso} kg\")\n", - " \n", + " print(\"Invalid weight\")\n", " \n", + " # Método show_info() para exibir as informações do pet\n", + " def show_info(self):\n", + " print(f\"Name: {self._name}\")\n", + " print(f\"Age: {self._age}\")\n", + " print(f\"Weight: {self._weight} kg\")\n", + "\n", "# Teste sua implementação\n", - "meu_pet = Pet()\n", - "meu_pet.set_nome(\"Bob\")\n", - "meu_pet.set_idade(5)\n", - "meu_pet.set_peso(9.5)\n", - "meu_pet.exibir_info()\n", + "my_pet = Pet(\"Buddy\", 5, 9.5)\n", + "my_pet.show_info()\n", "\n", "print(\"\\n-----------------\\n\")\n", "\n", - "meu_pet.set_nome(\"Toto\")\n", - "meu_pet.set_idade(8)\n", - "meu_pet.set_peso(7.5)\n", - "meu_pet.exibir_info()\n", + "my_pet.set_name(\"Toto\")\n", + "my_pet.set_age(8)\n", + "my_pet.set_weight(7.5)\n", + "my_pet.show_info()\n", "\n", "print(\"\\n-----------------\\n\")\n", "\n", - "meu_pet.set_nome(\"Lua\")\n", - "meu_pet.set_idade(12)\n", - "meu_pet.set_peso(9.3)\n", - "meu_pet.exibir_info()" + "my_pet.set_name(\"Lua\")\n", + "my_pet.set_age(12)\n", + "my_pet.set_weight(9.3)\n", + "my_pet.show_info()" ] }, { @@ -3040,7 +3005,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 3, "id": "b206054d", "metadata": {}, "outputs": [ @@ -3049,105 +3014,23 @@ "output_type": "stream", "text": [ "\n", - "---- Menu de Gerenciamento de Pet ----\n", - "1. Definir o nome do pet\n", - "2. Definir a idade do pet\n", - "3. Definir o peso do pet\n", - "4. Exibir informações do pet\n", - "5. Sair\n", - "Escolha uma opção: 4\n", - "Nome: \n", - "Idade: 0\n", - "Peso: 0.0 kg\n", - "\n", - "---- Menu de Gerenciamento de Pet ----\n", - "1. Definir o nome do pet\n", - "2. Definir a idade do pet\n", - "3. Definir o peso do pet\n", - "4. Exibir informações do pet\n", - "5. Sair\n", - "Escolha uma opção: 1\n", - "Digite o novo nome do pet: Totó\n", - "\n", - "---- Menu de Gerenciamento de Pet ----\n", - "1. Definir o nome do pet\n", - "2. Definir a idade do pet\n", - "3. Definir o peso do pet\n", - "4. Exibir informações do pet\n", - "5. Sair\n", - "Escolha uma opção: 4\n", - "Nome: Totó\n", - "Idade: 0\n", - "Peso: 0.0 kg\n", - "\n", - "---- Menu de Gerenciamento de Pet ----\n", - "1. Definir o nome do pet\n", - "2. Definir a idade do pet\n", - "3. Definir o peso do pet\n", - "4. Exibir informações do pet\n", - "5. Sair\n", - "Escolha uma opção: 2\n", - "Digite a nova idade do pet: 6\n", - "\n", - "---- Menu de Gerenciamento de Pet ----\n", - "1. Definir o nome do pet\n", - "2. Definir a idade do pet\n", - "3. Definir o peso do pet\n", - "4. Exibir informações do pet\n", - "5. Sair\n", - "Escolha uma opção: 4\n", - "Nome: Totó\n", - "Idade: 6\n", - "Peso: 0.0 kg\n", - "\n", - "---- Menu de Gerenciamento de Pet ----\n", - "1. Definir o nome do pet\n", - "2. Definir a idade do pet\n", - "3. Definir o peso do pet\n", - "4. Exibir informações do pet\n", - "5. Sair\n", - "Escolha uma opção: 3\n", - "Digite o novo peso do pet: 12.5\n", - "\n", - "---- Menu de Gerenciamento de Pet ----\n", - "1. Definir o nome do pet\n", - "2. Definir a idade do pet\n", - "3. Definir o peso do pet\n", - "4. Exibir informações do pet\n", - "5. Sair\n", - "Escolha uma opção: 4\n", - "Nome: Totó\n", - "Idade: 6\n", - "Peso: 12.5 kg\n", - "\n", - "---- Menu de Gerenciamento de Pet ----\n", - "1. Definir o nome do pet\n", - "2. Definir a idade do pet\n", - "3. Definir o peso do pet\n", - "4. Exibir informações do pet\n", - "5. Sair\n", - "Escolha uma opção: 1\n", - "Digite o novo nome do pet: Ruivo\n", - "\n", - "---- Menu de Gerenciamento de Pet ----\n", - "1. Definir o nome do pet\n", - "2. Definir a idade do pet\n", - "3. Definir o peso do pet\n", - "4. Exibir informações do pet\n", - "5. Sair\n", - "Escolha uma opção: 4\n", - "Nome: Ruivo\n", - "Idade: 6\n", - "Peso: 12.5 kg\n", - "\n", - "---- Menu de Gerenciamento de Pet ----\n", - "1. Definir o nome do pet\n", - "2. Definir a idade do pet\n", - "3. Definir o peso do pet\n", - "4. Exibir informações do pet\n", - "5. Sair\n", - "Escolha uma opção: 5\n", - "Saindo do programa...\n" + "---- Pet Management Menu ----\n", + "1. Define name of pet\n", + "2. Define age of pet\n", + "3. Define weight of pet\n", + "4. Show info of pet\n", + "5. Go out\n", + "Choose an option: 1\n", + "Input a new name of pet: Pituca\n", + "\n", + "---- Pet Management Menu ----\n", + "1. Define name of pet\n", + "2. Define age of pet\n", + "3. Define weight of pet\n", + "4. Show info of pet\n", + "5. Go out\n", + "Choose an option: 5\n", + "Go out to the program...\n" ] } ], @@ -3182,20 +3065,20 @@ " \n", " # Inicializa o atributo '_nome' como uma string vazia. \n", " # O prefixo \"_\" indica que é um atributo protegido.\n", - " self._nome = \"\"\n", + " self._name = \"\"\n", " \n", " # Inicializa o atributo '_idade' como 0. \n", " # O prefixo \"_\" indica que é um atributo protegido.\n", - " self._idade = 0\n", + " self._age = 0\n", " \n", " # Inicializa o atributo '_peso' como 0.0. \n", " # O prefixo \"_\" indica que é um atributo protegido.\n", - " self._peso = 0.0\n", + " self._weight = 0.0\n", " \n", " # Método \"getter\" para o nome, permite obter o valor do atributo '_nome'\n", - " def get_nome(self):\n", + " def get_name(self):\n", " \n", - " return self._nome\n", + " return self._name\n", " \n", " \"\"\"\n", " Os \"setters\" devem conter as seguintes validações:\n", @@ -3205,56 +3088,56 @@ " \"\"\"\n", "\n", " # Método \"setter\" para o nome, permite definir um novo valor para o atributo '_nome'\n", - " def set_nome(self, novo_nome):\n", + " def set_name(self, new_name):\n", " \n", " \"\"\"\n", " Os \"setters\" devem conter as seguintes validações:\n", " - O nome deve ser uma string e não pode ser vazio.\n", " \"\"\"\n", " # Verifica se o novo_nome é uma string e se não está vazio\n", - " if isinstance(novo_nome, str) and novo_nome != \"\":\n", + " if isinstance(new_name, str) and new_name != \"\":\n", " \n", " # Atualiza o valor do atributo '_nome'\n", - " self._nome = novo_nome\n", + " self._name = new_name\n", " \n", " else:\n", " \n", " # Imprime uma mensagem de erro se o nome fornecido não for válido\n", - " print(\"Nome inválido.\")\n", + " print(\"Invalid name\")\n", " \n", " # Método \"getter\" para a idade, permite obter o valor do atributo '_idade'\n", - " def get_idade(self):\n", + " def get_age(self):\n", " \n", - " return self._idade\n", + " return self._age\n", " \n", " \n", " # Método \"setter\" para a idade, permite definir um novo valor para o atributo '_idade'\n", - " def set_idade(self, nova_idade):\n", + " def set_age(self, new_age):\n", " \n", " \"\"\"\n", " Os \"setters\" devem conter as seguintes validações:\n", " - A idade deve ser um número inteiro e deve ser maior ou igual a 0.\n", " \"\"\"\n", " # Verifica se a nova_idade é um inteiro e se é maior ou igual a 0\n", - " if isinstance(nova_idade, int) and nova_idade >= 0:\n", + " if isinstance(new_age, int) and new_age >= 0:\n", " \n", " # Atualiza o valor do atributo '_idade'\n", - " self._idade = nova_idade\n", + " self._age = new_age\n", " \n", " else:\n", " \n", " # Imprime uma mensagem de erro se a idade fornecida não for válida\n", - " print(\"Idade inválida.\")\n", + " print(\"Invalid age.\")\n", " \n", " # ---------------------------------------------\n", " \n", " # Método \"getter\" para o peso, permite obter o valor do atributo '_peso'\n", - " def get_peso(self):\n", + " def get_weight(self):\n", " \n", - " return self._peso\n", + " return self._weight\n", "\n", " # Método \"setter\" para o peso, permite definir um novo valor para o atributo '_peso'\n", - " def set_peso(self, novo_peso):\n", + " def set_weight(self, new_weight):\n", " \n", " \"\"\"\n", " Os \"setters\" devem conter as seguintes validações:\n", @@ -3262,71 +3145,71 @@ " \"\"\"\n", " \n", " # Verifica se o novo_peso é um número flutuante e se é maior que 0\n", - " if isinstance(novo_peso, float) and novo_peso > 0:\n", + " if isinstance(new_weight, float) and new_weight > 0:\n", " \n", " # Atualiza o valor do atributo '_peso'\n", - " self._peso = novo_peso\n", + " self._weight = new_weight\n", " \n", " else:\n", " \n", " # Imprime uma mensagem de erro se o peso fornecido não for válido\n", - " print(\"Peso inválido.\")\n", + " print(\"Invalid weight\")\n", " \n", " \n", " \n", " # 3. Adicione um método exibir_info() que mostre as informações do pet.\n", - " def exibir_info(self):\n", + " def show_info(self):\n", " \n", - " print(f\"Nome: {self._nome}\")\n", - " print(f\"Idade: {self._idade}\")\n", - " print(f\"Peso: {self._peso} kg\")\n", + " print(f\"Name: {self._name}\")\n", + " print(f\"Age: {self._age}\")\n", + " print(f\"Weight: {self._weight} kg\")\n", " \n", " \n", "# Função para mostrar o menu de opções\n", - "def mostrar_menu():\n", + "def show_menu():\n", " \n", - " print(\"\\n---- Menu de Gerenciamento de Pet ----\")\n", - " print(\"1. Definir o nome do pet\")\n", - " print(\"2. Definir a idade do pet\")\n", - " print(\"3. Definir o peso do pet\")\n", - " print(\"4. Exibir informações do pet\")\n", - " print(\"5. Sair\")\n", + " print(\"\\n---- Pet Management Menu ----\")\n", + " print(\"1. Define name of pet\")\n", + " print(\"2. Define age of pet\")\n", + " print(\"3. Define weight of pet\")\n", + " print(\"4. Show info of pet\")\n", + " print(\"5. Go out\")\n", " \n", - " escolha = input(\"Escolha uma opção: \")\n", + " choice = input(\"Choose an option: \")\n", " \n", - " return escolha\n", + " return choice\n", "\n", "# Função principal que coordena a execução do programa.\n", "def main():\n", " \n", " # Cria uma nova instância (objeto) da classe Pet.\n", " # O objeto representará um pet específico.\n", - " meu_pet = Pet()\n", + " my_pet = Pet()\n", " \n", " # Inicia um loop infinito para exibir o menu e interagir com o usuário.\n", " while True:\n", " \n", " # Chama a função 'mostrar_menu()' para exibir as opções do menu e\n", " # captura a escolha do usuário como uma string.\n", - " escolha = mostrar_menu()\n", + " choice = show_menu()\n", " \n", " # Verifica se o usuário escolheu a opção 1 para definir o nome do pet.\n", - " if escolha == '1':\n", + " if choice == '1':\n", " \n", " # Solicita que o usuário digite o nome do pet.\n", - " nome = input(\"Digite o novo nome do pet: \")\n", + " name = input(\"Input a new name of pet: \")\n", " \n", " # Utiliza o método 'set_nome' para atualizar o nome do pet.\n", - " meu_pet.set_nome(nome)\n", + " my_pet.set_name(name)\n", " \n", " # Verifica se o usuário escolheu a opção 2 para definir a idade do pet.\n", - " elif escolha == '2':\n", + " elif choice == '2':\n", " \n", " # Utiliza um bloco try-except para capturar erros na conversão de tipos.\n", " try:\n", " \n", " # Solicita que o usuário digite a idade do pet e tenta converter para int.\n", - " idade = int(input(\"Digite a nova idade do pet: \"))\n", + " age = int(input(\"Input a new name of pet: \"))\n", " \n", " # Utiliza o método 'set_idade' para atualizar a idade do pet.\n", " meu_pet.set_idade(idade)\n", @@ -3335,37 +3218,37 @@ " except ValueError:\n", " \n", " # Informa ao usuário que o valor inserido não é um número inteiro válido.\n", - " print(\"Idade inválida. Por favor, insira um número inteiro.\")\n", + " print(\"Invalid age, please input a integer number for age\")\n", " \n", " # Verifica se o usuário escolheu a opção 3 para definir o peso do pet.\n", - " elif escolha == '3':\n", + " elif choice == '3':\n", " \n", " # Utiliza um bloco try-except para capturar erros na conversão de tipos.\n", " try:\n", " \n", " # Solicita que o usuário digite o peso do pet e tenta converter para float.\n", - " peso = float(input(\"Digite o novo peso do pet: \"))\n", + " weight = float(input(\"Input a weight of pet:\"))\n", " \n", " # Utiliza o método 'set_peso' para atualizar o peso do pet.\n", - " meu_pet.set_peso(peso)\n", + " my_pet.set_weight(weight)\n", " \n", " # Se a conversão falhar, um ValueError será lançado.\n", " except ValueError:\n", " \n", " # Informa ao usuário que o valor inserido não é um número válido.\n", - " print(\"Peso inválido. Por favor, insira um número.\")\n", + " print(\"Invalid weight, please input a float number for weight\")\n", " \n", " # Verifica se o usuário escolheu a opção 4 para exibir as informações do pet.\n", - " elif escolha == '4':\n", + " elif choice == '4':\n", " \n", " # Chama o método 'exibir_info' para mostrar as informações atuais do pet.\n", - " meu_pet.exibir_info()\n", + " my_pet.show_info()\n", " \n", " # Verifica se o usuário escolheu a opção 5 para sair do programa.\n", - " elif escolha == '5':\n", + " elif choice == '5':\n", " \n", " # Exibe uma mensagem informando que o programa será encerrado.\n", - " print(\"Saindo do programa...\")\n", + " print(\"Go out to the program...\")\n", " \n", " # Encerra o loop, encerrando assim o programa.\n", " break\n", @@ -3373,7 +3256,7 @@ " # Caso o usuário não escolha uma opção válida, uma mensagem de erro é exibida.\n", " else:\n", " \n", - " print(\"Opção inválida. Tente novamente.\")\n", + " print(\"Invalid option, try again.\")\n", " \n", "\n", "# Chama a função 'main' para iniciar a execução do programa.\n",