From d6cea7ccdf1a8c01fc5b3dbb44d076269c118ea2 Mon Sep 17 00:00:00 2001 From: Steve Date: Sun, 7 Jan 2024 23:06:06 -0300 Subject: [PATCH 01/25] Delete file Untitled. --- 1_section_Programming_logic/Untitled.ipynb | 251 --------------------- 1 file changed, 251 deletions(-) delete mode 100644 1_section_Programming_logic/Untitled.ipynb 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 -} From 219234c20e1080b685a0156b7f26be4c18656e9b Mon Sep 17 00:00:00 2001 From: Steve Date: Mon, 8 Jan 2024 23:37:54 -0300 Subject: [PATCH 02/25] Finished topics of dictionaries --- 1_section_Programming_logic/Dictionaries.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1_section_Programming_logic/Dictionaries.ipynb b/1_section_Programming_logic/Dictionaries.ipynb index 381f7db..144b80d 100644 --- a/1_section_Programming_logic/Dictionaries.ipynb +++ b/1_section_Programming_logic/Dictionaries.ipynb @@ -2679,12 +2679,12 @@ " # Se o usuário escolher uma opção que não está no menu:\n", " else:\n", " \n", - " # Exibe uma mensagem de erro.\n", + " # Exibe uma mensagem de erro:\n", " print(\"\\nOpção inválida!\")\n", "\n", "\n", "# Chama a função principal para executar o programa\n", - "main()\n" + "main(:\n" ] }, { From 6ca7d9232d342cb28c3aa072ab4c52c9161f799b Mon Sep 17 00:00:00 2001 From: Steve Date: Tue, 9 Jan 2024 23:34:26 -0300 Subject: [PATCH 03/25] A some modifications in dictionaries --- .../Dictionaries.ipynb | 82 ++----------------- 1 file changed, 9 insertions(+), 73 deletions(-) diff --git a/1_section_Programming_logic/Dictionaries.ipynb b/1_section_Programming_logic/Dictionaries.ipynb index 144b80d..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" ] } @@ -2680,11 +2614,13 @@ " else:\n", " \n", " # Exibe uma mensagem de erro:\n", - " print(\"\\nOpção inválida!\")\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" ] }, { From 59113c783cf9ad4c963d5129c8d0172838720dcd Mon Sep 17 00:00:00 2001 From: Steve Date: Wed, 10 Jan 2024 22:38:38 -0300 Subject: [PATCH 04/25] A some modifications about set. --- .../Set+(Conjuntos).ipynb | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/1_section_Programming_logic/Set+(Conjuntos).ipynb b/1_section_Programming_logic/Set+(Conjuntos).ipynb index 6baef9c..644ea7d 100644 --- a/1_section_Programming_logic/Set+(Conjuntos).ipynb +++ b/1_section_Programming_logic/Set+(Conjuntos).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", @@ -1704,7 +1704,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.11.5" } }, "nbformat": 4, From 3230a980a178c3e6a06843147b7a654bbe4b66d8 Mon Sep 17 00:00:00 2001 From: Steve Date: Fri, 12 Jan 2024 23:52:45 -0300 Subject: [PATCH 05/25] Finished first exercise --- .hintrc | 8 -------- 1_section_Programming_logic/Set+(Conjuntos).ipynb | 12 ++++++------ 2 files changed, 6 insertions(+), 14 deletions(-) delete mode 100644 .hintrc 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/Set+(Conjuntos).ipynb b/1_section_Programming_logic/Set+(Conjuntos).ipynb index 644ea7d..800661c 100644 --- a/1_section_Programming_logic/Set+(Conjuntos).ipynb +++ b/1_section_Programming_logic/Set+(Conjuntos).ipynb @@ -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\", \"cereja\", \"pera\"}\n", "\n", - "print(frutas_chaves)\n", + "print(frutas_chave)\n", "\n", "\n", "\"\"\"\n", From 61f8b61a0d2fc79551f5c6140a610f3bd2ba3eaa Mon Sep 17 00:00:00 2001 From: Steve Date: Sat, 13 Jan 2024 23:22:58 -0300 Subject: [PATCH 06/25] Exercise Set manipulation in Python --- .../Set+(Conjuntos).ipynb | 28 +++++++++++-------- 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/1_section_Programming_logic/Set+(Conjuntos).ipynb b/1_section_Programming_logic/Set+(Conjuntos).ipynb index 800661c..33f7598 100644 --- a/1_section_Programming_logic/Set+(Conjuntos).ipynb +++ b/1_section_Programming_logic/Set+(Conjuntos).ipynb @@ -304,7 +304,7 @@ " Imprima o conjunto.\n", "\"\"\"\n", "\n", - "frutas_chave = {\"maçã\", \"banana\", \"cereja\", \"pera\"}\n", + "frutas_chave = {\"maçã\", \"banana\", \"uva\", \"pera\"}\n", "\n", "print(frutas_chave)\n", "\n", @@ -467,7 +467,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 1, "id": "4db52201", "metadata": {}, "outputs": [ @@ -475,13 +475,19 @@ "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", - "set()\n" + "{'pássaro', 'cachorro', 'gato'}\n", + "{'pássaro', 'cachorro', 'gato', 'peixe'}\n" + ] + }, + { + "ename": "TypeError", + "evalue": "set.discard() takes exactly one argument (0 given)", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[1], line 85\u001b[0m\n\u001b[0;32m 76\u001b[0m \u001b[38;5;66;03m#animais.remove(\"lagarto\")\u001b[39;00m\n\u001b[0;32m 77\u001b[0m \u001b[38;5;66;03m#print(animais)\u001b[39;00m\n\u001b[0;32m 79\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 80\u001b[0m \u001b[38;5;124;03m4. Usando discard():\u001b[39;00m\n\u001b[0;32m 81\u001b[0m \u001b[38;5;124;03m Descarte \"lagarto\" do conjunto usando discard(). Observe o que acontece.\u001b[39;00m\n\u001b[0;32m 82\u001b[0m \u001b[38;5;124;03m Imprima o conjunto atualizado.\u001b[39;00m\n\u001b[0;32m 83\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m---> 85\u001b[0m animais\u001b[38;5;241m.\u001b[39mdiscard()\n\u001b[0;32m 86\u001b[0m \u001b[38;5;28mprint\u001b[39m(animais)\n\u001b[0;32m 88\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 89\u001b[0m \u001b[38;5;124;03m5. Usando pop():\u001b[39;00m\n\u001b[0;32m 90\u001b[0m \u001b[38;5;124;03m Use o método pop() para remover um elemento aleatório do conjunto \u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 93\u001b[0m \u001b[38;5;124;03m Imprima o conjunto atualizado.\u001b[39;00m\n\u001b[0;32m 94\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n", + "\u001b[1;31mTypeError\u001b[0m: set.discard() takes exactly one argument (0 given)" ] } ], @@ -560,7 +566,6 @@ "\"\"\"\n", "\n", "animais.remove(\"pássaro\")\n", - "print(animais)\n", "\n", "#animais.remove(\"lagarto\")\n", "#print(animais)\n", @@ -571,8 +576,7 @@ " Imprima o conjunto atualizado.\n", "\"\"\"\n", "\n", - "animais.discard(\"lagarto\")\n", - "print(animais)\n", + "animais.discard()\n", "\n", "\"\"\"\n", "5. Usando pop():\n", From 72964e418dff4600b03ba3c85be0d6507cc3ac12 Mon Sep 17 00:00:00 2001 From: Steve Date: Sun, 14 Jan 2024 23:13:32 -0300 Subject: [PATCH 07/25] Operations with Sets in Python --- .../Set+(Conjuntos).ipynb | 39 +++++++++++-------- 1 file changed, 22 insertions(+), 17 deletions(-) diff --git a/1_section_Programming_logic/Set+(Conjuntos).ipynb b/1_section_Programming_logic/Set+(Conjuntos).ipynb index 33f7598..f4cbd65 100644 --- a/1_section_Programming_logic/Set+(Conjuntos).ipynb +++ b/1_section_Programming_logic/Set+(Conjuntos).ipynb @@ -467,7 +467,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "4db52201", "metadata": {}, "outputs": [ @@ -476,18 +476,11 @@ "output_type": "stream", "text": [ "{'pássaro', 'cachorro', 'gato'}\n", - "{'pássaro', 'cachorro', 'gato', 'peixe'}\n" - ] - }, - { - "ename": "TypeError", - "evalue": "set.discard() takes exactly one argument (0 given)", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[1;32mIn[1], line 85\u001b[0m\n\u001b[0;32m 76\u001b[0m \u001b[38;5;66;03m#animais.remove(\"lagarto\")\u001b[39;00m\n\u001b[0;32m 77\u001b[0m \u001b[38;5;66;03m#print(animais)\u001b[39;00m\n\u001b[0;32m 79\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 80\u001b[0m \u001b[38;5;124;03m4. Usando discard():\u001b[39;00m\n\u001b[0;32m 81\u001b[0m \u001b[38;5;124;03m Descarte \"lagarto\" do conjunto usando discard(). Observe o que acontece.\u001b[39;00m\n\u001b[0;32m 82\u001b[0m \u001b[38;5;124;03m Imprima o conjunto atualizado.\u001b[39;00m\n\u001b[0;32m 83\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m---> 85\u001b[0m animais\u001b[38;5;241m.\u001b[39mdiscard()\n\u001b[0;32m 86\u001b[0m \u001b[38;5;28mprint\u001b[39m(animais)\n\u001b[0;32m 88\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 89\u001b[0m \u001b[38;5;124;03m5. Usando pop():\u001b[39;00m\n\u001b[0;32m 90\u001b[0m \u001b[38;5;124;03m Use o método pop() para remover um elemento aleatório do conjunto \u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 93\u001b[0m \u001b[38;5;124;03m Imprima o conjunto atualizado.\u001b[39;00m\n\u001b[0;32m 94\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n", - "\u001b[1;31mTypeError\u001b[0m: set.discard() takes exactly one argument (0 given)" + "{'pássaro', 'cachorro', 'gato', 'peixe'}\n", + "{'cachorro', 'gato', 'peixe'}\n", + "Animal removido: cachorro\n", + "{'gato', 'peixe'}\n", + "set()\n" ] } ], @@ -576,7 +569,8 @@ " Imprima o conjunto atualizado.\n", "\"\"\"\n", "\n", - "animais.discard()\n", + "animais.discard(\"lagarto\")\n", + "print(animais)\n", "\n", "\"\"\"\n", "5. Usando pop():\n", @@ -1685,11 +1679,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "261f3b72", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "baz\n" + ] + } + ], + "source": [ + "x = [10, [3.141, 20, [30, \"baz\", 2.718]], \"foo\"]\n", + "print(x[1][2][1])" + ] } ], "metadata": { From 3b1ab36df77a33d16208e442a99f36a0367edc0d Mon Sep 17 00:00:00 2001 From: Steve Date: Mon, 15 Jan 2024 23:52:42 -0300 Subject: [PATCH 08/25] Other Functions and Methods --- 1_section_Programming_logic/Set+(Conjuntos).ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1_section_Programming_logic/Set+(Conjuntos).ipynb b/1_section_Programming_logic/Set+(Conjuntos).ipynb index f4cbd65..e3798ce 100644 --- a/1_section_Programming_logic/Set+(Conjuntos).ipynb +++ b/1_section_Programming_logic/Set+(Conjuntos).ipynb @@ -921,7 +921,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", From b438e7fd64963a98b752409fd363ce37ec8e2419 Mon Sep 17 00:00:00 2001 From: Steve Date: Tue, 16 Jan 2024 23:04:49 -0300 Subject: [PATCH 09/25] Exercise with other functions and methods on set concepts in Python. --- 1_section_Programming_logic/Set+(Conjuntos).ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/1_section_Programming_logic/Set+(Conjuntos).ipynb b/1_section_Programming_logic/Set+(Conjuntos).ipynb index e3798ce..72171d2 100644 --- a/1_section_Programming_logic/Set+(Conjuntos).ipynb +++ b/1_section_Programming_logic/Set+(Conjuntos).ipynb @@ -1119,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", From f91b81d3eae42ff74a05f3966c413dffaf3e92c8 Mon Sep 17 00:00:00 2001 From: Steve Date: Sat, 20 Jan 2024 23:15:03 -0300 Subject: [PATCH 10/25] Imutabilidade e Frozensets --- 1_section_Programming_logic/Set+(Conjuntos).ipynb | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/1_section_Programming_logic/Set+(Conjuntos).ipynb b/1_section_Programming_logic/Set+(Conjuntos).ipynb index 72171d2..482c718 100644 --- a/1_section_Programming_logic/Set+(Conjuntos).ipynb +++ b/1_section_Programming_logic/Set+(Conjuntos).ipynb @@ -1308,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", @@ -1513,7 +1513,7 @@ ], "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", @@ -1691,10 +1691,7 @@ ] } ], - "source": [ - "x = [10, [3.141, 20, [30, \"baz\", 2.718]], \"foo\"]\n", - "print(x[1][2][1])" - ] + "source": [] } ], "metadata": { From 647e9ea8946f0311b2cfc4d8a621ee6e5f089530 Mon Sep 17 00:00:00 2001 From: Steve Date: Sun, 21 Jan 2024 23:48:20 -0300 Subject: [PATCH 11/25] Limitations of a set --- 1_section_Programming_logic/Set+(Conjuntos).ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1_section_Programming_logic/Set+(Conjuntos).ipynb b/1_section_Programming_logic/Set+(Conjuntos).ipynb index 482c718..f7483f0 100644 --- a/1_section_Programming_logic/Set+(Conjuntos).ipynb +++ b/1_section_Programming_logic/Set+(Conjuntos).ipynb @@ -1518,7 +1518,7 @@ " 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", @@ -1545,7 +1545,7 @@ "print(numeros) # 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", From 54a9b4da19d637209507cd2ecf6332c091480eb7 Mon Sep 17 00:00:00 2001 From: Steve Date: Wed, 24 Jan 2024 23:47:48 -0300 Subject: [PATCH 12/25] Resolving a some works --- 1_section_Programming_logic/Set+(Conjuntos).ipynb | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/1_section_Programming_logic/Set+(Conjuntos).ipynb b/1_section_Programming_logic/Set+(Conjuntos).ipynb index f7483f0..0194236 100644 --- a/1_section_Programming_logic/Set+(Conjuntos).ipynb +++ b/1_section_Programming_logic/Set+(Conjuntos).ipynb @@ -1679,18 +1679,10 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "261f3b72", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "baz\n" - ] - } - ], + "outputs": [], "source": [] } ], From 8201d97a3ef0812c453c2dd3747ca3015415aeda Mon Sep 17 00:00:00 2001 From: Steve Date: Sun, 4 Feb 2024 21:45:02 -0300 Subject: [PATCH 13/25] Finished an exercise about set Limitations in Python --- .../Set+(Conjuntos).ipynb | 57 ++++++++++--------- 1 file changed, 29 insertions(+), 28 deletions(-) diff --git a/1_section_Programming_logic/Set+(Conjuntos).ipynb b/1_section_Programming_logic/Set+(Conjuntos).ipynb index 0194236..eecd731 100644 --- a/1_section_Programming_logic/Set+(Conjuntos).ipynb +++ b/1_section_Programming_logic/Set+(Conjuntos).ipynb @@ -751,7 +751,7 @@ }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 3, "id": "e4f1ec27", "metadata": {}, "outputs": [ @@ -766,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" ] @@ -841,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", @@ -855,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", @@ -868,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", @@ -881,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", @@ -1380,7 +1381,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 3, "id": "58481286", "metadata": {}, "outputs": [ @@ -1443,9 +1444,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", @@ -1455,7 +1456,7 @@ " mensagem apropriada.\n", "\"\"\"\n", "\n", - "if 25 in numeros_unicos:\n", + "if 25 in numbers_unique:\n", " \n", " print(\"O número 25 está presente.\")\n", " \n", @@ -1473,20 +1474,20 @@ " Encontre a diferença simétrica entre os dois conjuntos e imprima o resultado.\n", "\"\"\"\n", "\n", - "conjunto_a = {1, 2, 3, 4}\n", - "conjunto_b = {3, 4, 5, 6}\n", + "set_a = {1, 2, 3, 4}\n", + "set_b = {3, 4, 5, 6}\n", "\n", "print(\"\\nUnião\")\n", - "print(conjunto_a | conjunto_b)\n", + "print(set_a | set_b)\n", "\n", "print(\"\\ninterseção\")\n", - "print(conjunto_a & conjunto_b)\n", + "print(set_a & set_b)\n", "\n", "print(\"\\ndiferença\")\n", - "print(conjunto_a - conjunto_b)\n", + "print(set_a - set_b)\n", "\n", "print(\"\\ndiferença simétrica\")\n", - "print(conjunto_a ^ conjunto_b)" + "print(set_a ^ set_b)" ] }, { @@ -1499,7 +1500,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 1, "id": "24bff602", "metadata": {}, "outputs": [ @@ -1523,7 +1524,7 @@ "#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", @@ -1539,10 +1540,10 @@ "#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", @@ -1572,7 +1573,7 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 2, "id": "91ae77b9", "metadata": {}, "outputs": [ @@ -1587,7 +1588,7 @@ ], "source": [ "\"\"\"\n", - "Exercício: Explorando as Limitações dos Conjuntos\n", + "Exercício: Explorando asc\n", "\n", "Objetivo: Compreender as limitações fundamentais dos conjuntos (sets) em Python.\n", "\n", @@ -1622,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", @@ -1634,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", From 4c2f114a3328f060f77d7d7add16244efe0eef13 Mon Sep 17 00:00:00 2001 From: Steve Date: Mon, 5 Feb 2024 21:12:16 -0300 Subject: [PATCH 14/25] Finished first exercise Number Analysis --- 2_section_Exercises/Exercise+Python.ipynb | 30 +++++++++++------------ 1 file changed, 15 insertions(+), 15 deletions(-) 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, From a4d835742363e56241b263f27f3ffe9ab1f0065f Mon Sep 17 00:00:00 2001 From: Steve Date: Sun, 11 Feb 2024 11:04:55 -0300 Subject: [PATCH 15/25] Finished class about Set and init class Matrices --- 1_section_Programming_logic/Matrices.ipynb | 1335 +++++++++++++++++ .../{Set+(Conjuntos).ipynb => Set.ipynb} | 80 +- 2 files changed, 1375 insertions(+), 40 deletions(-) create mode 100644 1_section_Programming_logic/Matrices.ipynb rename 1_section_Programming_logic/{Set+(Conjuntos).ipynb => Set.ipynb} (97%) diff --git a/1_section_Programming_logic/Matrices.ipynb b/1_section_Programming_logic/Matrices.ipynb new file mode 100644 index 0000000..043ca2c --- /dev/null +++ b/1_section_Programming_logic/Matrices.ipynb @@ -0,0 +1,1335 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 13, + "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 linha in range(3): \n", + " \n", + " # Inicia um loop interno para percorrer as colunas da matriz\n", + " for coluna 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[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", + "\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 linha in range(3): \n", + " \n", + " # Inicia um loop interno para percorrer as colunas da matriz\n", + " for coluna 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[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", + "\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 linha in range(3):\n", + " \n", + " # Inicia um loop interno para percorrer as colunas da matriz\n", + " for coluna 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[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", + " \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 linha in range(3): \n", + " \n", + " # Inicia um loop interno para percorrer as colunas da matriz\n", + " for coluna 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[linha][coluna] = A[linha][coluna] - B[linha][coluna]\n", + "\n", + "# Inicia um loop para percorrer cada linha da matriz D\n", + "for linha in D:\n", + " \n", + " # Imprime a linha atual da matriz D\n", + " print(linha)\n", + "\n", + " \n", + "print(\"\\nSoma das matrizes A e B:\")\n", + "\n", + "# Inicia um loop para percorrer as linhas da matriz\n", + "for linha in range(3): \n", + " \n", + " # Inicia um loop interno para percorrer as colunas da matriz\n", + " for coluna 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[linha][coluna] = A[linha][coluna] + B[linha][coluna]\n", + " \n", + " # Imprime o valor resultante da soma atual seguido de dois espaços, sem quebrar a linha\n", + " print(f\"{D[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", + " \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": 18, + "id": "ecab12a6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A soma dos números pares da matriz é: 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\"A soma dos números pares da matriz é: {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", + "matriz_alunos = []\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", + " nome = input(f\"Digite o nome do aluno {i + 1}: \")\n", + " \n", + " # Inicializa uma lista vazia para armazenar as notas do aluno atual\n", + " notas = []\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", + " nota = float(input(f\"Digite a nota {j + 1} do aluno {nome}: \"))\n", + " \n", + " # Adiciona a nota coletada à lista de notas\n", + " notas.append(nota)\n", + " \n", + " # Adiciona o nome do aluno e suas notas à matriz de alunos\n", + " matriz_alunos.append([nome] + notas)\n", + " \n", + "\n", + "# Inicia um loop para imprimir as informações de cada aluno\n", + "for aluno in matriz_alunos:\n", + " \n", + " # Extrai o nome do aluno da lista atual\n", + " nome = aluno[0]\n", + " \n", + " # Extrai as notas do aluno da lista atual\n", + " notas = aluno[1:]\n", + " \n", + " # Calcula a média das notas do aluno\n", + " media = sum(notas) / 4\n", + " \n", + " # Imprime as informações do aluno\n", + " print(\"\\n\" + \"-\"*40)\n", + " print(f\"Nome: {nome}\")\n", + " print(f\"Notas: {notas}\")\n", + " print(f\"Média: {media:.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": 15, + "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", + "animais = [\n", + " [\"Gato\", \"Cachorro\"],\n", + " [\"Pássaro\", \"Peixe\"]\n", + "]\n", + "\n", + "print(animais)\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(animais[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", + "nomes = [\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 nomes[i][j][0] == \"A\": # Checando se o primeiro caractere é 'A'\n", + " print(nomes[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": 17, + "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": 28, + "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): Alice\n", + "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", + "\n", + "Resultados:\n", + "Alice: 3 votos\n", + "Bob: 1 votos\n", + "Charlie: 0 votos\n", + "\n", + "O vencedor é Alice com 3 votos!\n", + "\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": 5, + "id": "ef7e3e99", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Menu:\n", + "1. Ver disposição dos assentos\n", + "2. Reservar um assento\n", + "3. Sair\n", + "Escolha uma opção: 1\n", + "D D D D D D D D D D \n", + "D D D D D D D D D D \n", + "D D D D D D D D D D \n", + "D D D D D D D D D D \n", + "D D D D D D D D D D \n", + "\n", + "Menu:\n", + "1. Ver disposição dos assentos\n", + "2. Reservar um assento\n", + "3. Sair\n", + "Escolha uma opção: 2\n", + "Digite o número da fileira / Linha (0-4): 3\n", + "Digite o número do assento / Coluna (0-9): 2\n", + "Assento reservado com sucesso!\n", + "\n", + "Menu:\n", + "1. Ver disposição dos assentos\n", + "2. Reservar um assento\n", + "3. Sair\n", + "Escolha uma opção: 1\n", + "D D D D D D D D D D \n", + "D D D D D D D D D D \n", + "D D D D D D D D D D \n", + "D D R D D D D D D D \n", + "D D D D D D D D D D \n", + "\n", + "Menu:\n", + "1. Ver disposição dos assentos\n", + "2. Reservar um assento\n", + "3. Sair\n", + "Escolha uma opção: 3\n", + "Obrigado por usar nosso sistema!\n", + "\n" + ] + } + ], + "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": 14, + "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 0\n", + "X| | \n", + "-----\n", + " | | \n", + "-----\n", + " | | \n", + "-----\n", + "Jogador O, escolha a linha e coluna (ex: 0 2): 0 1\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): 0 2\n", + "X|O|O\n", + "-----\n", + " |X| \n", + "-----\n", + " | | \n", + "-----\n", + "Jogador X, escolha a linha e coluna (ex: 0 2): 1 0\n", + "X|O|O\n", + "-----\n", + "X|X| \n", + "-----\n", + " | | \n", + "-----\n", + "Jogador O, escolha a linha e coluna (ex: 0 2): 1 2\n", + "X|O|O\n", + "-----\n", + "X|X|O\n", + "-----\n", + " | | \n", + "-----\n", + "Jogador X, escolha a linha e coluna (ex: 0 2): 2 1\n", + "X|O|O\n", + "-----\n", + "X|X|O\n", + "-----\n", + " |X| \n", + "-----\n", + "Jogador O, escolha a linha e coluna (ex: 0 2): 2 0\n", + "X|O|O\n", + "-----\n", + "X|X|O\n", + "-----\n", + "O|X| \n", + "-----\n", + "Jogador X, escolha a linha e coluna (ex: 0 2): 2 2\n", + "X|O|O\n", + "-----\n", + "X|X|O\n", + "-----\n", + "O|X|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": [] + }, + { + "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.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/1_section_Programming_logic/Set+(Conjuntos).ipynb b/1_section_Programming_logic/Set.ipynb similarity index 97% rename from 1_section_Programming_logic/Set+(Conjuntos).ipynb rename to 1_section_Programming_logic/Set.ipynb index eecd731..70d4a18 100644 --- a/1_section_Programming_logic/Set+(Conjuntos).ipynb +++ b/1_section_Programming_logic/Set.ipynb @@ -978,7 +978,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 2, "id": "fdb0966c", "metadata": {}, "outputs": [ @@ -986,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" ] } ], @@ -1048,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", @@ -1063,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", @@ -1172,7 +1171,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 3, "id": "093b8b72", "metadata": {}, "outputs": [ @@ -1180,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" @@ -1271,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", @@ -1381,7 +1380,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "id": "58481286", "metadata": {}, "outputs": [ @@ -1391,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" ] } @@ -1457,12 +1456,9 @@ "\"\"\"\n", "\n", "if 25 in numbers_unique:\n", - " \n", - " print(\"O número 25 está presente.\")\n", - " \n", - "else:\n", - " \n", - " print(\"O número 25 não está presente.\")\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", @@ -1474,20 +1470,24 @@ " Encontre a diferença simétrica entre os dois conjuntos e imprima o resultado.\n", "\"\"\"\n", "\n", - "set_a = {1, 2, 3, 4}\n", - "set_b = {3, 4, 5, 6}\n", + "conjunto_a = {1, 2, 3, 4}\n", + "conjunto_b = {3, 4, 5, 6}\n", "\n", - "print(\"\\nUnião\")\n", - "print(set_a | set_b)\n", + "print(\"\\nUnion\")\n", + "s1_union = conjunto_a | conjunto_b\n", + "print(s1_union)\n", "\n", - "print(\"\\ninterseção\")\n", - "print(set_a & set_b)\n", + "print(\"\\nIntececion\")\n", + "s2_intercesion = conjunto_a & conjunto_b\n", + "print(s2_intercesion)\n", "\n", - "print(\"\\ndiferença\")\n", - "print(set_a - set_b)\n", + "print(\"\\nDifference\")\n", + "s3_difference = conjunto_a - conjunto_b\n", + "print(s3_difference)\n", "\n", - "print(\"\\ndiferença simétrica\")\n", - "print(set_a ^ set_b)" + "print(\"\\nSymmetric difference\")\n", + "s4_symmetric_difference = conjunto_a ^ conjunto_b\n", + "print(s4_symmetric_difference)" ] }, { @@ -1588,7 +1588,7 @@ ], "source": [ "\"\"\"\n", - "Exercício: Explorando asc\n", + "Exercício: Explorando as Limitações dos Conjuntos\n", "\n", "Objetivo: Compreender as limitações fundamentais dos conjuntos (sets) em Python.\n", "\n", @@ -1671,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", From f0070f3a80382044308a906b8030387794011e5d Mon Sep 17 00:00:00 2001 From: Steve Date: Mon, 12 Feb 2024 23:39:02 -0300 Subject: [PATCH 16/25] (1 topic of matrices) Initializing the two matrices and the result matrix Using loops are nested to subtract corresponding elements --- 1_section_Programming_logic/Matrices.ipynb | 36 +++++++++++----------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/1_section_Programming_logic/Matrices.ipynb b/1_section_Programming_logic/Matrices.ipynb index 043ca2c..e77154b 100644 --- a/1_section_Programming_logic/Matrices.ipynb +++ b/1_section_Programming_logic/Matrices.ipynb @@ -71,13 +71,13 @@ "print(\"Matriz A:\\n\")\n", "\n", "# Inicia um loop para percorrer as linhas da matriz\n", - "for linha in range(3): \n", + "for row in range(3): \n", " \n", " # Inicia um loop interno para percorrer as colunas da matriz\n", - " for coluna in range(3): \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[linha][coluna]}\", end=\" \") \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", @@ -90,13 +90,13 @@ "print(\"\\nMatriz B:\")\n", "\n", "# Inicia um loop para percorrer as linhas da matriz\n", - "for linha in range(3): \n", + "for row in range(3): \n", " \n", " # Inicia um loop interno para percorrer as colunas da matriz\n", - " for coluna in range(3): \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[linha][coluna]}\", end=\" \") \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", @@ -113,13 +113,13 @@ "print(\"\\nMatriz D:\")\n", "\n", "# Inicia um loop para percorrer as linhas da matriz\n", - "for linha in range(3):\n", + "for row in range(3):\n", " \n", " # Inicia um loop interno para percorrer as colunas da matriz\n", - " for coluna in range(3):\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[linha][coluna]}\", end=\" \")\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", @@ -129,31 +129,31 @@ "\n", "print(\"\\nSubtração das matrizes A e B\")\n", "# Inicia um loop para percorrer as linhas da matriz\n", - "for linha in range(3): \n", + "for row in range(3): \n", " \n", " # Inicia um loop interno para percorrer as colunas da matriz\n", - " for coluna in range(3): \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[linha][coluna] = A[linha][coluna] - B[linha][coluna]\n", + " D[row][column] = A[row][column] - B[row][column]\n", "\n", "# Inicia um loop para percorrer cada linha da matriz D\n", - "for linha in D:\n", + "for row in D:\n", " \n", " # Imprime a linha atual da matriz D\n", - " print(linha)\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 linha in range(3): \n", + "for row in range(3): \n", " \n", " # Inicia um loop interno para percorrer as colunas da matriz\n", - " for coluna in range(3): \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[linha][coluna] = A[linha][coluna] + B[linha][coluna]\n", + " D[row][column] = A[row][coluna] + B[linha][coluna]\n", " \n", " # Imprime o valor resultante da soma atual seguido de dois espaços, sem quebrar a linha\n", " print(f\"{D[linha][coluna]}\", end=\" \") \n", @@ -1327,7 +1327,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.11.5" } }, "nbformat": 4, From 371bec3ee9428f72a582147e32f473bd9afd0bbc Mon Sep 17 00:00:00 2001 From: Steve Date: Thu, 15 Feb 2024 19:56:12 -0300 Subject: [PATCH 17/25] Sum of Even Numbers in a 4x4 Matrix --- 1_section_Programming_logic/Matrices.ipynb | 43 +++++++++++++++++----- 1 file changed, 33 insertions(+), 10 deletions(-) diff --git a/1_section_Programming_logic/Matrices.ipynb b/1_section_Programming_logic/Matrices.ipynb index e77154b..8232a9d 100644 --- a/1_section_Programming_logic/Matrices.ipynb +++ b/1_section_Programming_logic/Matrices.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 13, + "execution_count": 2, "id": "b0452902", "metadata": {}, "outputs": [ @@ -153,10 +153,10 @@ " 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][coluna] + B[linha][coluna]\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[linha][coluna]}\", end=\" \") \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", @@ -186,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 3, "id": "ecab12a6", "metadata": {}, "outputs": [ @@ -194,7 +194,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "A soma dos números pares da matriz é: 72\n" + "The sum of the even numbers in the matrix is: 72\n" ] } ], @@ -248,7 +248,7 @@ "\n", "\n", "# Imprimindo o resultado\n", - "print(f\"A soma dos números pares da matriz é: {soma_pares}\")\n" + "print(f\"The sum of the even numbers in the matrix is: {soma_pares}\")\n" ] }, { @@ -1272,11 +1272,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 59, "id": "c4329bc1", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n", + "630\n" + ] + } + ], + "source": [ + "economias = 10\n", + "semana = 1\n", + "total_economizado = economias\n", + " \n", + "while total_economizado < 320:\n", + " semana += 1\n", + " economias *= 2\n", + " total_economizado += economias\n", + " \n", + "print(semana)\n", + "print(total_economizado)" + ] }, { "cell_type": "code", @@ -1284,7 +1305,9 @@ "id": "87b9ce1d", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "\n" + ] }, { "cell_type": "code", From 923916c45e7cf835505b2e5265f732625e209cf6 Mon Sep 17 00:00:00 2001 From: Steve Date: Sun, 18 Feb 2024 21:39:56 -0300 Subject: [PATCH 18/25] Finished Matrices and Average of Grades --- 1_section_Programming_logic/Matrices.ipynb | 26 +++++++++++----------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/1_section_Programming_logic/Matrices.ipynb b/1_section_Programming_logic/Matrices.ipynb index 8232a9d..db417b4 100644 --- a/1_section_Programming_logic/Matrices.ipynb +++ b/1_section_Programming_logic/Matrices.ipynb @@ -423,47 +423,47 @@ "\"\"\"\n", "\n", "# Inicializa uma matriz vazia para armazenar os nomes e as notas dos alunos\n", - "matriz_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", - " nome = input(f\"Digite o nome do aluno {i + 1}: \")\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", - " notas = []\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", - " nota = float(input(f\"Digite a nota {j + 1} do aluno {nome}: \"))\n", + " grade = float(input(f\"Digite a nota {j + 1} do aluno {nome}: \"))\n", " \n", " # Adiciona a nota coletada à lista de notas\n", - " notas.append(nota)\n", + " grades.append(grade)\n", " \n", " # Adiciona o nome do aluno e suas notas à matriz de alunos\n", - " matriz_alunos.append([nome] + notas)\n", + " student_matrix.append([name] + grades)\n", " \n", "\n", "# Inicia um loop para imprimir as informações de cada aluno\n", - "for aluno in matriz_alunos:\n", + "for student in student_matrix:\n", " \n", " # Extrai o nome do aluno da lista atual\n", - " nome = aluno[0]\n", + " name = aluno[0]\n", " \n", " # Extrai as notas do aluno da lista atual\n", - " notas = aluno[1:]\n", + " grade = aluno[1:]\n", " \n", " # Calcula a média das notas do aluno\n", - " media = sum(notas) / 4\n", + " average = sum(grades) / 4\n", " \n", " # Imprime as informações do aluno\n", " print(\"\\n\" + \"-\"*40)\n", - " print(f\"Nome: {nome}\")\n", - " print(f\"Notas: {notas}\")\n", - " print(f\"Média: {media:.2f}\")\n", + " print(f\"Nome: {name}\")\n", + " print(f\"Notas: {grades}\")\n", + " print(f\"Média: {average:.2f}\")\n", "\n", " \n", " \n", From c64f83ec05df90ad5c14985af24615e547a8c3c5 Mon Sep 17 00:00:00 2001 From: Steve Date: Mon, 19 Feb 2024 21:48:28 -0300 Subject: [PATCH 19/25] Array of strings --- 1_section_Programming_logic/Matrices.ipynb | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/1_section_Programming_logic/Matrices.ipynb b/1_section_Programming_logic/Matrices.ipynb index db417b4..4e7f00c 100644 --- a/1_section_Programming_logic/Matrices.ipynb +++ b/1_section_Programming_logic/Matrices.ipynb @@ -494,7 +494,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 2, "id": "4f64e3ae", "metadata": {}, "outputs": [ @@ -534,17 +534,17 @@ "# Criar e imprimir essa matriz:\n", "\n", "# Criando a matriz 2x2 de strings\n", - "animais = [\n", + "animals = [\n", " [\"Gato\", \"Cachorro\"],\n", " [\"Pássaro\", \"Peixe\"]\n", "]\n", "\n", - "print(animais)\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(animais[i][j], end=\" \")\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", @@ -565,7 +565,7 @@ "\"\"\"\n", "\n", "# Criando a matriz 4x4\n", - "nomes = [\n", + "names = [\n", " [\"Ana\", \"Bruno\", \"Carlos\", \"Alice\"],\n", " [\"Amanda\", \"Beatriz\", \"Clara\", \"Arnaldo\"],\n", " [\"Alfredo\", \"Bianca\", \"Cesar\", \"Ariel\"],\n", @@ -575,8 +575,8 @@ "# 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 nomes[i][j][0] == \"A\": # Checando se o primeiro caractere é 'A'\n", - " print(nomes[i][j])\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'." ] From 46b67ac5d608262e543af6180cf98e847049c79c Mon Sep 17 00:00:00 2001 From: Steve Date: Thu, 7 Mar 2024 10:36:53 -0300 Subject: [PATCH 20/25] Exercise - Electronic Urn with Matrices --- 1_section_Programming_logic/Matrices.ipynb | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/1_section_Programming_logic/Matrices.ipynb b/1_section_Programming_logic/Matrices.ipynb index 4e7f00c..0b34b7b 100644 --- a/1_section_Programming_logic/Matrices.ipynb +++ b/1_section_Programming_logic/Matrices.ipynb @@ -591,7 +591,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 1, "id": "41756163", "metadata": {}, "outputs": [ @@ -664,7 +664,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 3, "id": "4be3adb9", "metadata": {}, "outputs": [ @@ -672,18 +672,17 @@ "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): Alice\n", "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: 3 votos\n", + "Alice: 2 votos\n", "Bob: 1 votos\n", - "Charlie: 0 votos\n", + "Charlie: 1 votos\n", "\n", - "O vencedor é Alice com 3 votos!\n", - "\n" + "O vencedor é Alice com 2 votos!\n" ] } ], @@ -756,7 +755,7 @@ "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", + " 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", From bc229960783ec6187cb59a53886202bef8f60e94 Mon Sep 17 00:00:00 2001 From: Steve Date: Thu, 7 Mar 2024 11:59:27 -0300 Subject: [PATCH 21/25] Exercise: Reserve Cinema Seats using Arrays --- 1_section_Programming_logic/Matrices.ipynb | 50 +--------------------- 1 file changed, 2 insertions(+), 48 deletions(-) diff --git a/1_section_Programming_logic/Matrices.ipynb b/1_section_Programming_logic/Matrices.ipynb index 0b34b7b..551c7f8 100644 --- a/1_section_Programming_logic/Matrices.ipynb +++ b/1_section_Programming_logic/Matrices.ipynb @@ -781,56 +781,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "ef7e3e99", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Menu:\n", - "1. Ver disposição dos assentos\n", - "2. Reservar um assento\n", - "3. Sair\n", - "Escolha uma opção: 1\n", - "D D D D D D D D D D \n", - "D D D D D D D D D D \n", - "D D D D D D D D D D \n", - "D D D D D D D D D D \n", - "D D D D D D D D D D \n", - "\n", - "Menu:\n", - "1. Ver disposição dos assentos\n", - "2. Reservar um assento\n", - "3. Sair\n", - "Escolha uma opção: 2\n", - "Digite o número da fileira / Linha (0-4): 3\n", - "Digite o número do assento / Coluna (0-9): 2\n", - "Assento reservado com sucesso!\n", - "\n", - "Menu:\n", - "1. Ver disposição dos assentos\n", - "2. Reservar um assento\n", - "3. Sair\n", - "Escolha uma opção: 1\n", - "D D D D D D D D D D \n", - "D D D D D D D D D D \n", - "D D D D D D D D D D \n", - "D D R D D D D D D D \n", - "D D D D D D D D D D \n", - "\n", - "Menu:\n", - "1. Ver disposição dos assentos\n", - "2. Reservar um assento\n", - "3. Sair\n", - "Escolha uma opção: 3\n", - "Obrigado por usar nosso sistema!\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"\n", "Exercício: Reserva de Assentos no Cinema usando Matrizes\n", From 679f646e054e30c67d20962ccba44d7da0b1a5ce Mon Sep 17 00:00:00 2001 From: Steve Date: Thu, 14 Mar 2024 19:10:51 -0300 Subject: [PATCH 22/25] Finished a program of Tic-tac-toe. --- 1_section_Programming_logic/Matrices.ipynb | 83 +++++++--------------- 1 file changed, 25 insertions(+), 58 deletions(-) diff --git a/1_section_Programming_logic/Matrices.ipynb b/1_section_Programming_logic/Matrices.ipynb index 551c7f8..6a60169 100644 --- a/1_section_Programming_logic/Matrices.ipynb +++ b/1_section_Programming_logic/Matrices.ipynb @@ -904,7 +904,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 8, "id": "ed1cb3ee", "metadata": {}, "outputs": [ @@ -918,68 +918,56 @@ "-----\n", " | | \n", "-----\n", - "Jogador X, escolha a linha e coluna (ex: 0 2): 0 0\n", - "X| | \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): 0 1\n", - "X|O| \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", + "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): 0 2\n", - "X|O|O\n", + "Jogador O, escolha a linha e coluna (ex: 0 2): 2 1\n", + " |X|O\n", "-----\n", " |X| \n", "-----\n", - " | | \n", - "-----\n", - "Jogador X, escolha a linha e coluna (ex: 0 2): 1 0\n", - "X|O|O\n", - "-----\n", - "X|X| \n", - "-----\n", - " | | \n", - "-----\n", - "Jogador O, escolha a linha e coluna (ex: 0 2): 1 2\n", - "X|O|O\n", - "-----\n", - "X|X|O\n", - "-----\n", - " | | \n", + " |O| \n", "-----\n", - "Jogador X, escolha a linha e coluna (ex: 0 2): 2 1\n", - "X|O|O\n", - "-----\n", - "X|X|O\n", + "Jogador X, escolha a linha e coluna (ex: 0 2): 2 2\n", + " |X|O\n", "-----\n", " |X| \n", "-----\n", - "Jogador O, escolha a linha e coluna (ex: 0 2): 2 0\n", - "X|O|O\n", + " |O|X\n", "-----\n", - "X|X|O\n", + "Jogador O, escolha a linha e coluna (ex: 0 2): 1 0\n", + " |X|O\n", "-----\n", "O|X| \n", "-----\n", - "Jogador X, escolha a linha e coluna (ex: 0 2): 2 2\n", - "X|O|O\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|X\n", + "O|X| \n", + "-----\n", + " |O|X\n", "-----\n", "Jogador X venceu!\n" ] @@ -1225,32 +1213,11 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": null, "id": "c4329bc1", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "6\n", - "630\n" - ] - } - ], - "source": [ - "economias = 10\n", - "semana = 1\n", - "total_economizado = economias\n", - " \n", - "while total_economizado < 320:\n", - " semana += 1\n", - " economias *= 2\n", - " total_economizado += economias\n", - " \n", - "print(semana)\n", - "print(total_economizado)" - ] + "outputs": [], + "source": [] }, { "cell_type": "code", From 64770ffe15b27bebb1c549e445a049b4e8935c5d Mon Sep 17 00:00:00 2001 From: Steve Date: Fri, 19 Apr 2024 23:03:03 -0300 Subject: [PATCH 23/25] Finished simulate exercise people routine --- .../Object+Oriented Programming (OOP).ipynb | 188 ++++++++---------- 1 file changed, 81 insertions(+), 107 deletions(-) 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..2b07776 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,36 +1083,10 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": null, "id": "9af6d6dc", "metadata": {}, - "outputs": [ - { - "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" - ] - } - ], + "outputs": [], "source": [ "\"\"\"\n", "Exercício Simulando a Rotina de uma Pessoa\n", @@ -1157,11 +1131,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.driving = False # Inicialmente define o estado \"dirigindo\" como Falso\n", " \n", " \"\"\"\n", " 2. Implemente métodos para as seguintes ações:\n", @@ -1174,152 +1148,152 @@ " \"\"\"\n", " \n", " # Método para fazer a pessoa acordar\n", - " def acordar(self):\n", + " def awake(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.driving:\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 top_stop_of_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.eating:\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.driving:\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.driving = 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 to_stop_driving(self):\n", " \n", " # Verifica se a pessoa não está dirigindo\n", - " if not self.dirigindo:\n", + " if not self.driving:\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.driving = 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.driving:\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.eating:\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.eating = 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 = Pessoa(\"steve\")\n", "\n", "\"\"\"\n", "4. Teste a classe criando um objeto e chamando vários métodos em sequência, simulando \n", @@ -1327,57 +1301,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.awake() # Ação de acordar é executada, João agora está acordado\n", + "steve.awake() # 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.eating() # 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.eating() # 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.top_stop_of_eating() # Ação de parar de comer é executada, João agora parou de comer\n", + "steve.top_stop_of_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.dirigir() # 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.dormir() # 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.eating() # 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.dirigir() # 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.parar_de_dirigir() # 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.eating() # 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.top_stop_of_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.eating() # 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.drinving() # Não pode dirigir enquanto dorme, então uma mensagem informando isso é impressa" ] }, { From 5759b7d3114224375101bad2edff2c4f84a9c6b6 Mon Sep 17 00:00:00 2001 From: Steve Date: Wed, 10 Jul 2024 22:09:43 -0300 Subject: [PATCH 24/25] Methods Defining and calling methods of a class --- .../Object+Oriented Programming (OOP).ipynb | 367 ++++++++++-------- 1 file changed, 196 insertions(+), 171 deletions(-) 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 2b07776..3b08988 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 @@ -1083,10 +1083,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "9af6d6dc", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "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" + ] + } + ], "source": [ "\"\"\"\n", "Exercício Simulando a Rotina de uma Pessoa\n", @@ -1122,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", @@ -1135,7 +1161,7 @@ " 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.driving = False # Inicialmente define o estado \"dirigindo\" 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", @@ -1148,7 +1174,7 @@ " \"\"\"\n", " \n", " # Método para fazer a pessoa acordar\n", - " def awake(self):\n", + " def wake_up(self):\n", " \n", " # Verifica se a pessoa já está acordada\n", " if self.awake:\n", @@ -1168,7 +1194,7 @@ " def eat(self):\n", " \n", " # Verifica se a pessoa está dirigindo\n", - " if self.driving:\n", + " if self.drive:\n", " \n", " # Se sim, imprime que não pode comer enquanto dirige\n", " print(f\"{self.name} não pode comer enquanto dirige.\")\n", @@ -1194,7 +1220,7 @@ " print(f\"{self.name} começou a comer.\")\n", " \n", " # Método para fazer a pessoa parar de comer\n", - " def top_stop_of_eating(self):\n", + " def stop_eating(self):\n", " \n", " # Verifica se a pessoa não está comendo\n", " if not self.eating:\n", @@ -1220,13 +1246,13 @@ " print(f\"{self.name} não pode dirigir enquanto está dormindo.\")\n", " \n", " # Verifica se a pessoa está comendo\n", - " elif self.eating:\n", + " elif self.eat:\n", " \n", " # Se sim, imprime que 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.driving:\n", + " elif self.drive:\n", " \n", " # Se sim, imprime que a pessoa já está dirigindo\n", " print(f\"{self.name} já está dirigindo.\")\n", @@ -1234,16 +1260,16 @@ " else:\n", " \n", " # Se nenhuma das condições acima for verdadeira, a pessoa pode dirigir\n", - " self.driving = True\n", + " self.drive = True\n", " \n", " # Imprime que a pessoa 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 to_stop_driving(self):\n", + " def stop_driving(self):\n", " \n", " # Verifica se a pessoa não está dirigindo\n", - " if not self.driving:\n", + " if not self.drive:\n", " \n", " # Se sim, imprime que a pessoa não está dirigindo\n", " print(f\"{self.name} não está dirigindo no momento.\")\n", @@ -1251,7 +1277,7 @@ " else:\n", " \n", " # Se a pessoa estiver dirigindo, então ela pode parar\n", - " self.driving = False\n", + " self.drive = False\n", " \n", " # Imprime que a pessoa parou de dirigir\n", " print(f\"{self.name} parou de dirigir.\")\n", @@ -1261,13 +1287,13 @@ " def sleep(self):\n", " \n", " # Verifica se a pessoa está dirigindo\n", - " if self.driving:\n", + " if self.drive:\n", " \n", " # Se sim, imprime que 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.eating:\n", + " elif self.eat:\n", " \n", " # Se sim, imprime que não pode dormir enquanto come\n", " print(f\"{self.name} não pode dormir enquanto come.\")\n", @@ -1287,13 +1313,13 @@ " self.awake = False\n", " \n", " # Define o estado \"comendo\" como Falso\n", - " self.eating = 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 \"Steve\" como nome para o construtor\n", - "Steve = Pessoa(\"steve\")\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", @@ -1301,57 +1327,57 @@ "\"\"\"\n", "\n", "# Tentando fazer João acordar\n", - "steve.awake() # Ação de acordar é executada, João agora está acordado\n", - "steve.awake() # 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", - "steve.eating() # 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", - "steve.eating() # 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", - "steve.top_stop_of_eating() # Ação de parar de comer é executada, João agora parou de comer\n", - "steve.top_stop_of_eating() # 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", - "steve.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", - "steve.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", - "steve.eating() # 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", - "steve.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", - "steve.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", - "steve.eating() # 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", - "steve.sleep() # 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", - "steve.driving() # 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", - "steve.top_stop_of_eating() # 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", - "steve.sleep() # 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", - "steve.eating() # 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", - "steve.sleep() # 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", - "steve.drinving() # 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" ] }, { @@ -1364,7 +1390,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 8, "id": "423f3ac3", "metadata": {}, "outputs": [ @@ -1372,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" ] } @@ -1402,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()" ] }, { @@ -1477,7 +1503,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "71f54e8b", "metadata": {}, "outputs": [ @@ -1486,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" ] } @@ -1567,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", "\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", @@ -1708,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", @@ -1792,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", From 13b5792619b0815ec6644b17144345d738153818 Mon Sep 17 00:00:00 2001 From: Steve Date: Tue, 23 Jul 2024 23:08:53 -0300 Subject: [PATCH 25/25] Pet exercise --- .../Object+Oriented Programming (OOP).ipynb | 368 ++++++------------ 1 file changed, 126 insertions(+), 242 deletions(-) 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 3b08988..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 @@ -1642,7 +1642,7 @@ " 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 letter in lowerCase_phrase:\n", @@ -2558,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", @@ -2834,7 +2835,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 17, "id": "6a953609", "metadata": {}, "outputs": [ @@ -2842,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" ] } ], @@ -2896,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()" ] }, { @@ -3039,7 +3005,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 3, "id": "b206054d", "metadata": {}, "outputs": [ @@ -3048,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" ] } ], @@ -3181,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", @@ -3204,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", @@ -3261,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", @@ -3334,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", @@ -3372,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",