├── .gitignore ├── Controle-de-fluxo ├── for.md ├── if_else.md ├── introdução.md ├── list_comprehensions.md └── while.md ├── Expressões ├── assets │ ├── maior_igual.png │ ├── maior_que.png │ ├── menor_igual.png │ ├── menor_que.png │ ├── operador_diferenca.png │ └── simples.png ├── comparacoes.md ├── expressoes_condicionais.md ├── expressões_aritmeticas.md ├── introdução.md └── variaveis.md ├── Extras ├── Assistente_Virtual.md ├── assets │ ├── and.png │ ├── keywords.png │ ├── not.png │ ├── or.png │ └── true_false.png ├── bloco_de_notas.md ├── calculadora.md ├── keywords.md └── magic_methods.md ├── Gerando-gráficos ├── aprimorando_graficos.md ├── assets │ ├── barchart.png │ ├── barcharthorizontal.png │ ├── matplotlib.svg │ ├── piechart.png │ ├── plot.png │ ├── plot_aprimorado.png │ ├── save.png │ ├── saveaspng.png │ └── saveconfig.png ├── como_funciona.md ├── grafico_barras.md ├── grafico_simples.md ├── pie_chart.md └── salvando_grafico_arquivo.md ├── Instalação ├── Linux.md ├── MacOS.md └── Windows.md ├── Instruções-simples ├── assert.md ├── del.md ├── global.md ├── nonlocal.md ├── pass.md ├── raise.md └── return.md ├── Introdução ├── assets │ ├── python_logo.png │ └── python_logo_extended.png ├── introducao.MD └── motivacao.MD ├── LICENSE.md ├── Manipulando-arquivos ├── assets │ ├── readline_param.png │ ├── retorno_leitura.png │ ├── retorno_leitura_varias_linhas.png │ ├── tabela-informativa.png │ └── writelines.png ├── criando_abrindo_arquivos.md ├── entendendo_manipulacao_arquivos.md ├── escrevendo_em_arquivos.md └── lendo_arquivos.md ├── Módulo-Tkinter ├── assets │ ├── button.png │ ├── checkbutton.png │ ├── combobox.png │ ├── entry.png │ ├── frame.png │ ├── hello_world_tkinter.png │ ├── install.png │ ├── label.png │ ├── radiobutton.png │ ├── tk.png │ ├── tk_atributos.png │ ├── tk_grid.png │ └── tk_pack.png ├── gerenciamento_geometria-.md ├── hello_world.md ├── interfaces_graficas_tkinter.md ├── posicionamento_atributos.md └── widgets_tkinter.md ├── POO ├── Oque-é-poo.md ├── Trabalhando_com_objetos.md ├── class.md ├── heranca.md ├── pictures │ └── classes │ │ ├── instance_in.png │ │ ├── instance_out.png │ │ ├── not_str_method.png │ │ └── str_method.png └── polimorfismo.md ├── README.md ├── Testes-Unitários ├── Introdução.md ├── assets │ ├── terminal1.jpeg │ ├── terminal2.jpeg │ ├── terminal3.jpeg │ └── terminal4.jpeg ├── testes-funções.md └── testes-métodos.md ├── Tipos ├── booleanos.md ├── dicionarios.md ├── introducao_estrutura_dados.md ├── listas.md ├── numbers.md ├── sets.md ├── strings.md └── tuplas.md └── Trabalhando-com-API's ├── Conteúdo-da-resposta ├── conteudo_resposta.md ├── resposta_binaria.md ├── resposta_crua.md └── resposta_json.md ├── Realizando-requisições ├── delete.md ├── get.md ├── post.md └── put.md ├── assets ├── headers.png ├── r_content.png ├── r_encoding.png ├── r_raw_read.png └── r_text.png ├── biblioteca_requests.md ├── cookies.md ├── erros_excecoes.md ├── headers.md ├── introducao_apis.md └── timeouts.md /.gitignore: -------------------------------------------------------------------------------- 1 | .venv 2 | env 3 | .vscode 4 | .idea -------------------------------------------------------------------------------- /Controle-de-fluxo/for.md: -------------------------------------------------------------------------------- 1 | ## Python "For" Loops 2 | 3 | 4 | O loop __for__ é usado para iteragir em uma sequencia, sendo uma lista, tupla, dicionario, etc... 5 | 6 | Podemos usar o loop __for__ para percorrer uma lista, como no exemplo abaixo: 7 | 8 | ```python 9 | In[]: 10 | 11 | fruits = ["apple", "banana", "cherry"] 12 | for x in fruits: 13 | print(x) 14 | 15 | ``` 16 | 17 | ```python 18 | Out[]: 19 | 20 | apple 21 | banana 22 | cherry 23 | 24 | ``` 25 | 26 | - Podemos fazer com que o loop pare assim que ache uma opção desejada. Para que isso ocorra, usamos a declaração __break__: 27 | 28 | ```python 29 | In[]: 30 | 31 | fruits = ["apple", "banana", "cherry"] 32 | for x in fruits: 33 | print(x) 34 | if x == "banana": 35 | break 36 | 37 | 38 | ``` 39 | 40 | ```python 41 | Out[]: 42 | 43 | apple 44 | banana 45 | 46 | ``` 47 | 48 | - E se colocarmos o retorno do loop após do __break__: 49 | 50 | ```python 51 | In[]: 52 | 53 | fruits = ["apple", "banana", "cherry"] 54 | for x in fruits: 55 | if x == "banana": 56 | break 57 | print(x) 58 | 59 | 60 | ``` 61 | 62 | obteremos o seguinte retorno: 63 | 64 | ```python 65 | Out[]: 66 | 67 | apple 68 | 69 | ``` 70 | 71 | ## Declaração continue 72 | 73 | Com a declaração __continue__ podemos parar a iteração atual e ir para a proxima: 74 | 75 | ```python 76 | In[]: 77 | 78 | fruits = ["apple", "banana", "cherry"] 79 | for x in fruits: 80 | if x == "banana": 81 | continue 82 | print(x) 83 | 84 | ``` 85 | 86 | ```python 87 | Out[]: 88 | 89 | apple 90 | cherry 91 | 92 | ``` 93 | 94 | ## Função range() 95 | 96 | - Para percorrer um conjunto de códigos um número especificado de vezes, podemos usar a função range(). 97 | 98 | - A função range() retorna uma sequência de números, iniciando em 0 por padrão e incrementando em 1 (por padrão), e termina em um número especificado. 99 | 100 | ```python 101 | In[]: 102 | 103 | for x in range(6): 104 | print(x) 105 | 106 | ``` 107 | 108 | ```python 109 | Out[]: 110 | 111 | 0 112 | 1 113 | 2 114 | 3 115 | 4 116 | 5 117 | 118 | ``` 119 | 120 | - Como dito, por padrão a função __range()__ inicia do contador 0, mas podemos especificar o valor inicial adicionando os parâmetros iniciais e finais, da seguinte forma: 121 | 122 | ```python 123 | In[]: 124 | 125 | for x in range(2, 6): 126 | print(x) 127 | 128 | ``` 129 | 130 | ```python 131 | Out[]: 132 | 133 | 2 134 | 3 135 | 4 136 | 5 137 | 138 | ``` 139 | 140 | - Por padrão, a função __range()__ incrementa os valores de um a um, mas podemos mudar isso adicionando um terceiro parâmetro à função: 141 | 142 | ```python 143 | In[]: 144 | 145 | for x in range(2, 30, 3): 146 | print(x) 147 | 148 | ``` 149 | 150 | ```python 151 | Out[]: 152 | 153 | 2 154 | 5 155 | 8 156 | 11 157 | 14 158 | 17 159 | 20 160 | 23 161 | 26 162 | 29 163 | 164 | ``` 165 | 166 | ## Keyword ELSE 167 | 168 | - A Keyword __else__ em um loop __for__, especifica um bloco de código a ser executado quando o loop for concluído: 169 | 170 | ```python 171 | In[]: 172 | 173 | for x in range(6): 174 | print(x) 175 | else: 176 | print("Finally finished!") 177 | 178 | ``` 179 | 180 | ```python 181 | Out[]: 182 | 183 | 0 184 | 1 185 | 2 186 | 3 187 | 4 188 | 5 189 | Finally finished! 190 | 191 | ``` 192 | 193 | ## Loops aninhados 194 | 195 | - Loops aninhados são loops dentro de outros; 196 | 197 | - O "loop interno" será executado uma vez para cada iteração do "loop externo": 198 | 199 | ```python 200 | In[]: 201 | 202 | adj = ["red", "big", "tasty"] 203 | fruits = ["apple", "banana", "cherry"] 204 | 205 | for x in adj: 206 | for y in fruits: 207 | print(x, y) 208 | 209 | ``` 210 | 211 | ```python 212 | Out[]: 213 | 214 | red apple 215 | red banana 216 | red cherry 217 | big apple 218 | big banana 219 | big cherry 220 | tasty apple 221 | tasty banana 222 | tasty cherry 223 | 224 | ``` 225 | 226 | ## Declaração pass 227 | 228 | - os loops __for__ não podem estar vazios, mas se, por algum motivo, você tiver um loop for sem conteúdo, insira a instrução pass para evitar erros: 229 | 230 | ```python 231 | In[]: 232 | 233 | for x in [0, 1, 2]: 234 | pass 235 | 236 | ``` 237 | 238 | ```python 239 | Out[]: 240 | 241 | # ter um loop for vazio como esse, geraria um erro sem a instrução pass 242 | 243 | ``` 244 | 245 | ## Importante saber... 246 | 247 | É importante que saiba a diferença entre interação e iteração. 248 | 249 | - __Iteração__: se define por um processo que se repete diversas vezes para se chegar a um resultado e a cada vez gera um resultado parcial que será usado na vez seguinte; 250 | 251 | - __Interação__: Diferente do tópico anterior onde é preciso realizar uma ação, na interação é a ação realizada pelo usuário com determinada situação ou produto. -------------------------------------------------------------------------------- /Controle-de-fluxo/if_else.md: -------------------------------------------------------------------------------- 1 | ## Estruturas de condição com o IF/ELSE 2 | 3 | 4 | - Imagina a seguinte situação: 5 | - Temos que atravessar de um lado para outro na rua, precisamos montar uma estrutura de condição em nossa cabeça, para decidir se vamos atravessar ou não, sendo essas condições: 6 | 7 | ``` 8 | Se vier carro: 9 | Eu espero 10 | Senão: 11 | Eu atravesso 12 | ``` 13 | 14 | - Pode parecer besteira, mas uma estrutura de condição simples é, basicamente, isso. Vamos ver outro exemplo: 15 | 16 | ``` 17 | Imagina que estamos calculando se um aluno passou de ano na escola, conforme as notas obtidas nas provas. 18 | 19 | Foram três provas, com as notas: 20 | 21 | Prova 1 => 7.0 22 | Prova 2 => 6.0 23 | Prova 3 => 5.0 24 | 25 | A média é 6.0, se somarmos as três notas e dividirmos pela mesma quantidade, teremos: 26 | 27 | (7.0 + 6.0 + 5.0) / 3 = 6.0 28 | 29 | Dessa forma o sistema irá decidir se ele passou de ano na escola, a estrutura de condição ficaria dessa forma: 30 | 31 | Se a nota > 6.0: 32 | APROVADO 33 | Senão: 34 | REPROVADO 35 | ``` 36 | - Agora que ja viu como é na lógico, vamos ver no codigo como funcionaria uma estrutura de if/else. Digamos que, uma pessoa abaixo dos 50 anos seja jovem senão, será considerada idosa. Coloquemos isso em codigo: 37 | 38 | ```python 39 | 40 | idade = 18 41 | if idade < 50: 42 | print('Você é jovem!') 43 | else: 44 | print('Você é idoso(a)!') 45 | 46 | Na linguagem Python, a indentação (espaço dado antes de uma linha) é utilizada para demarcar os blocos de código, e são obrigatórios quando se usa estruturas de controle. 47 | 48 | ``` 49 | 50 | - Também é possível checar mais de uma condição com o __elif__. É a abreviatura para else __if__. Ou seja, se o __if__ for falso, testa outra condição antes do __else__: 51 | 52 | ```python 53 | In[]: 54 | 55 | idade = 18 56 | if idade < 50: 57 | print('Você é jovem!') 58 | elif idade > 50: 59 | print('Você é velho(a)!') 60 | else: 61 | print('idade inválida!') 62 | ``` 63 | ```python 64 | Out[]: 65 | 66 | Você é jovem! 67 | ``` 68 | 69 | Outro exemplo, mais extenso: 70 | 71 | ```python 72 | In[]: 73 | 74 | valor_entrada = 10 75 | if valor_entrada == 1: 76 | print("a entrada era 1") 77 | elif valor_entrada == 2: 78 | print("a entrada era 2") 79 | elif valor_entrada == 3: 80 | print("a entrada era 3") 81 | elif valor_entrada == 4: 82 | print("a entrada era 4") 83 | else: 84 | print("o valor de entrada não era esperado em nenhum if") 85 | ``` 86 | 87 | ```python 88 | Out[]: 89 | 90 | o valor de entrada não era esperado em nenhum if 91 | ``` 92 | 93 | - Note que quando uma condição for verdadeira, aquele bloco de código é executado e as demais condições (__elif__ e __else__) são puladas: 94 | 95 | ```python 96 | In[]: 97 | 98 | a = 1 99 | if a == 1: 100 | print("é 1") 101 | elif a >= 1: 102 | print("é maior ou igual a 1") 103 | else: 104 | print("é qualquer outra coisa") 105 | 106 | ``` 107 | 108 | ```python 109 | Out[]: 110 | 111 | é 1 112 | ``` 113 | 114 | 115 | ## É bom saber... 116 | 117 | - Para condições muito extensas o correto é usar outro tipo de estrutura codigo, sendo elas, while/for. Veja isso, nos outros conteudos desse capitulo. -------------------------------------------------------------------------------- /Controle-de-fluxo/introdução.md: -------------------------------------------------------------------------------- 1 | # Estruturas de controle e repetição 2 | 3 | - Em Python, assim como na maioria das linguagens de programação, o programa deve ser capaz de tomar decisões com base em valores e resultados gerados durante sua execução, ou seja, deve ser capaz de decidir se determinada instrução deve ou não ser executada de acordo com uma condição. Para atender a esse tipo de situação, podemos utilizar instruções especiais denominadas estruturas condicionais. -------------------------------------------------------------------------------- /Controle-de-fluxo/list_comprehensions.md: -------------------------------------------------------------------------------- 1 | ## List Comprehensions em python 2 | 3 | 4 | - O List Comprehensions fornece uma maneira concisa de criar listas; 5 | - O List Comprehensions sempre retorna uma lista de resultados. 6 | 7 | Se você costumava fazer assim: 8 | 9 | ```python 10 | 11 | nova_lista = [] 12 | for i in lista_antiga: 13 | if filter(i): 14 | nova_lista.append(expressions(i)) 15 | ``` 16 | 17 | Você pode obter a mesma coisa usando o list comprehensions: 18 | 19 | 20 | ```python 21 | 22 | new_list = [expression(i) for i in old_list if filter(i)] 23 | # Observe que o método de acréscimo desapareceu 24 | ``` 25 | 26 | ## Sintaxe 27 | 28 | O list comprehension começa com colchetes *‘[‘* e fecha com colchetes *‘]’*, para ficar melhor o entendimento, vamos para um exemplo mais pratico, visualmente falando: 29 | 30 | ```python 31 | 32 | [ expressao for item in list if condicao ] 33 | ``` 34 | 35 | Isso é equivalente a: 36 | 37 | ```python 38 | 39 | for item in list: 40 | if condicao: 41 | expressao 42 | ``` 43 | 44 | Vamos analisar isso e ver o que ele faz: 45 | 46 | ```python 47 | 48 | nova_lista = [expression(i) for i in lista_antiga if filter(i)] 49 | ``` 50 | 51 | __nova_lista__: Lista nova que será gerada; 52 | __for i in lista_antiga__: A palavra __for__ seguida pelo nome da variável a ser usada, seguida pela palavra lista_antiga; 53 | __expression(i)__: A expressão é baseada na variável usada para cada elemento na lista_antiga; 54 | __if filter(i)__: Aplique um filtro com uma instrução __if__. 55 | 56 | 57 | ## Complementando... 58 | 59 | - List Comprehensions é um assunto complexo e mais complexo do que o apresentado acima, mas deixaremos conteudo para que veja mais sobre o tema: 60 | 61 | Documentação oficial - list-comprehensions 62 | Medium - Indo mais além no assunto 63 | -------------------------------------------------------------------------------- /Controle-de-fluxo/while.md: -------------------------------------------------------------------------------- 1 | ## Python While Loops 2 | 3 | - Python contém dois tipos primitivos de loops: 4 | 5 | ``` 6 | - while loops; 7 | - for loops. 8 | ``` 9 | 10 | ## While 11 | 12 | - Com o loop __while__, podemos executar um conjunto de instruções desde que uma condição seja verdadeira: 13 | 14 | ```python 15 | In[]: 16 | 17 | i = 1 18 | while i < 6: 19 | print(i) 20 | i += 1 21 | 22 | ``` 23 | ```python 24 | Out[]: 25 | 26 | 1 27 | 2 28 | 3 29 | 4 30 | 5 31 | 32 | ``` 33 | 34 | __Observação__: *lembre-se de incrementar i, caso contrário, o loop continuará para sempre.* 35 | 36 | ## Break 37 | 38 | Com a instrução __break__, podemos parar o loop mesmo se a condição while for verdadeira: 39 | 40 | ```python 41 | In[]: 42 | 43 | i = 1 44 | while i < 6: 45 | print(i) 46 | if i == 3: 47 | break 48 | i += 1 49 | 50 | ``` 51 | ```python 52 | Out[]: 53 | 54 | 1 55 | 2 56 | 3 57 | 58 | ``` 59 | 60 | ## Continue 61 | 62 | Com a instrução __continue__, podemos parar a iteração atual e continuar com a próxima: 63 | 64 | ```python 65 | In[]: 66 | 67 | i = 0 68 | while i < 6: 69 | i += 1 70 | if i == 3: 71 | continue 72 | print(i) 73 | 74 | ``` 75 | ```python 76 | Out[]: 77 | 78 | 1 79 | 2 80 | 4 81 | 5 82 | 6 83 | 84 | # Observe que o número 3 está ausente no resultado 85 | 86 | ``` 87 | 88 | ## Else 89 | 90 | Com a instrução __else__, podemos executar um bloco de código uma vez, quando a condição não for mais verdadeira: 91 | 92 | ```python 93 | In[]: 94 | 95 | i = 1 96 | while i < 6: 97 | print(i) 98 | i += 1 99 | else: 100 | print("i não é menor que 6") 101 | 102 | ``` 103 | 104 | ```python 105 | Out[]: 106 | 107 | 1 108 | 2 109 | 3 110 | 4 111 | 5 112 | i não é menor que 6 113 | 114 | ``` -------------------------------------------------------------------------------- /Expressões/assets/maior_igual.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Expressões/assets/maior_igual.png -------------------------------------------------------------------------------- /Expressões/assets/maior_que.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Expressões/assets/maior_que.png -------------------------------------------------------------------------------- /Expressões/assets/menor_igual.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Expressões/assets/menor_igual.png -------------------------------------------------------------------------------- /Expressões/assets/menor_que.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Expressões/assets/menor_que.png -------------------------------------------------------------------------------- /Expressões/assets/operador_diferenca.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Expressões/assets/operador_diferenca.png -------------------------------------------------------------------------------- /Expressões/assets/simples.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Expressões/assets/simples.png -------------------------------------------------------------------------------- /Expressões/comparacoes.md: -------------------------------------------------------------------------------- 1 | ## Comparando objetos com o operador == 2 | 3 | - Imagina a situação em que temos uma biblioteca e nela temos um acervo de diversos livros. Digamos que quero ver se um livro ja existe no meu acervo; 4 | 5 | Temos uma lista de livros 6 | 7 | ```python 8 | livros = [ 9 | "Harry potter e a pedra filosofal", 10 | "Cidades de papel", 11 | "O Anticristo", 12 | "Além do Bem e do Mal", 13 | "Ecce homo", 14 | ] 15 | ``` 16 | 17 | Agora, quero ver se algum livro dos quais tenho na lista, ja existe comparados com os livros novos que recebi de uma editora. Para isso, vamos usar a seguinte função: 18 | 19 | ```python 20 | In[]: 21 | 22 | def verifica_livro(livro_procurado): 23 | meus_livros = funcao_lista_todos_livros() 24 | for livro in meus_livros: 25 | if livro_procurado == livro: 26 | return True 27 | return False 28 | 29 | livro_procurado = "Ecce homo" 30 | 31 | if verifica_livro(livro_procurado): 32 | print("Tenho o livro!") 33 | else: 34 | print("Não tenho o livro!") 35 | ``` 36 | *__OBS__: esse é apenas um exemplo generico.* 37 | 38 | Ao rodarmos o codigo, o resultado sera esse: 39 | 40 | ```python 41 | Out[]: 42 | 43 | Tenho o livro! 44 | ``` 45 |
46 | 47 | ## Simplificando nossa verificação com o operador in 48 | 49 | - Podemos, ainda, simplificar o código em nossa função verifica_livro() utilizando o operador __in__ para verificar se o livro já está na lista, já que este operador também se baseia no retorno de __==__. 50 | 51 | 52 | 53 | ```python 54 | 55 | def verifica_livro(livro_procurado): 56 | meus_livros = funcao_lista_todos_livros() 57 | return livro_procurado in meus_livros 58 | ``` 59 | 60 | ## Comparando objetos com o operador != 61 | 62 | - Esse operador tem como objetivo comparar a diferença dos itens. Veja o exemplo abaixo: 63 | 64 | python_logo_extended 65 | 66 | - Este operador compara duas coisas, e retorna True se forem diferentes e False se forem iguais. 67 | 68 | 69 | ## Comparando objetos com o operador < 70 | 71 | - Ao fazer: __x < y__, estamos perguntando ao Python se __x__ é menor que __y__, 72 | Se ele for menor mesmo, retorna *True*. 73 | Se for igual ou maior que __y__, retorna *False*. 74 | 75 | python_logo_extended 76 | 77 | ## Comparando objetos com o operador > 78 | 79 | - Quando fazemos: __x > y__, estamos querendo saber se __x__ é maior que __y__. 80 | Se for verdade, retorna *True*. 81 | Se __x__ por igual ou menor que __y__, retorna *False*. 82 | 83 | python_logo_extended 84 | 85 | ## Comparando objetos com o operador >= 86 | 87 | Na operação: __x >= y__ 88 | Você deve ler: __x__ maior ou igual a __y__ 89 | 90 | Esse operador vai retornar *True* (verdadeiro) se __x__ for igual a __y__ ou se __x__ for maior que __y__. 91 | Vai retornar *False* apenas se __x__ for menor que __y__. 92 | 93 | python_logo_extended 94 | 95 | ## Comparando objetos com o operador <= 96 | 97 | Na operação: __x <= y__ 98 | Você deve ler: __x__ menor ou igual a __y__ 99 | 100 | Retorna *True* se __x__ for igual a __y__ ou menor. 101 | Se __x__ for maior que __y__, retorna *False*. 102 | 103 | python_logo_extended 104 | 105 | ## Resumindo... 106 | 107 | 108 | | Operação | Comparação | 109 | | ------------- | ------------- | 110 | | __x == y__ | __x__ é igual a __y__?| 111 | | __x != y__ | __x__ é diferente de __y__? | 112 | | __x > y__ | __x__ é maior que __y__? | 113 | | __x < y__ | __x__ é menor que __y__? | 114 | | __x >= y__ | __x__ é maior ou igual a __y__? | 115 | | __x <= y__ | __x__ é menor ou igual a __y__? | 116 | 117 | 118 | ## É bom saber 119 | 120 | - todas as operações de comparação em Python têm a mesma prioridade. 121 | 122 | 123 | 124 | 125 | 126 | -------------------------------------------------------------------------------- /Expressões/expressoes_condicionais.md: -------------------------------------------------------------------------------- 1 | ## Expressões Condicionais 2 | 3 | - Expressões condicionais (às vezes chamadas de “operador ternário”) têm a prioridade mais baixa de todas as operações Python; 4 | - A expressão if C else y avalia primeiro a condição *C* em vez de *x*. Se *C* for verdadeiro, *x* é avaliado e seu valor é retornado; caso contrário, *y* é avaliado e seu valor é retornado. 5 | 6 | Sintaxe: 7 | ```python 8 | (if : else: ) 9 | 10 | # Primeiramente, a é avaliada. 11 | 12 | # Se a receber True, é validada e retorna o resultado; 13 | 14 | # Se a receber False, é validada e retorna o resultado. 15 | ``` 16 | 17 | 18 | Exemplo: 19 | ```python 20 | [IN]: 21 | 22 | num1 = 255 23 | if(num1 % 2 == 0): 24 | s = "par" 25 | else: 26 | s = "ímpar" 27 | 28 | s = "par" if num1 % 2 == 0 else "ímpar" 29 | print("O número digitado é ", s) 30 | ``` 31 | 32 | ```python 33 | [OUT]: 34 | 35 | O número digitado é ímpar 36 | ``` 37 | 38 | ## Para entender melhor 39 | 40 | 41 | Consulte PEP 308 para obter mais detalhes sobre expressões condicionais. -------------------------------------------------------------------------------- /Expressões/expressões_aritmeticas.md: -------------------------------------------------------------------------------- 1 | ## Expressões aritméticas 2 | 3 | - Uma expressõe aritmética é formada por numeros (chamados de operandos) e operadores; 4 | - Abaixo veremos um exemplo de uma operação matematica simples, contendo apenas dois operandos e um operador: 5 | 6 | python_logo_extended 7 | 8 | 9 | ## Operadores logicos 10 | 11 | - Há três operadores logicos, sendo eles, __and__, __or__ e __not__. Sua semantica/significado é o mesmo do que no ingles; 12 | 13 | Vejamos alguns exemplos teoricos: 14 | 15 | __and__: 16 | ```python 17 | x>0 and x<10 18 | ``` 19 | 20 | A expressão acima só retornará *true* caso as duas condições forem cumpridas. Ou seja, se ambos os casos a variavel *x* for maior que zero e menor que 10. 21 |
22 | 23 | __or__: 24 | ```python 25 | n%2 == 0 or n%3 == 0 26 | ``` 27 | 28 | A expressão acima só retornará *true* caso uma das duas condições forem cumpridas. Isto é, se o número for divisível por 2 ou 3. 29 |
30 | 31 | __not__: 32 | Finalmente, o operador not nega uma expressão booleana, então __not(x > y)__ é verdade se __x > y__ for falso, isto é, se __x__ for menor que ou igual a __y__. 33 |
-------------------------------------------------------------------------------- /Expressões/introdução.md: -------------------------------------------------------------------------------- 1 | ## Expressões 2 | 3 | - Sabemos que grande parte do trabalho do computador é realizar calculos e, com base nesses calculos, executar ações que auxiliam o usuário no dia a dia; 4 | - Uma regra básica é que toda expressão calculada pelo computador deve sempre devolver o mesmo resultado. Por exemplo, a expressão 2 + 3 * 4 poderia devolver o valor 20 caso a soma 2+3 seja calculada antes da multiplicação. Felizmente o Python segue as regras de precedência dos operadores que nós estamos acostumados e o resultado devolvido é 14. Faça um teste você mesmo digitando essa expressão no Python shell como: 5 | 6 | ```python 7 | In[] 8 | 9 | 2+3*4 10 | ``` 11 | ```python 12 | Out[] 13 | 14 | 14 15 | ``` 16 |
17 | 18 | Nesse modulo iremos aprender como realizar calculos matematicos com python e conhecer seus operadores. -------------------------------------------------------------------------------- /Expressões/variaveis.md: -------------------------------------------------------------------------------- 1 |

Variáveis em python

2 |
3 | 4 | ##### O que são variaveis? 5 | 6 | - Variáveis são espaços reservados na memória para armazenar dados que serão utilizados durante a execução do programa. Podem ter valores de diversos tamanhos e tipos, tais como números inteiros, números reais, caracteres, frases, etc. 7 | 8 | ##### Criando variáveis em Python 9 | 10 | - Para criar uma variável em Python, tudo o que você precisa fazer é especificar o nome da variável e, em seguida, atribuir um valor a ela: 11 | 12 | ``` 13 | variavel = valor 14 | ``` 15 | 16 | O Python usa o sinal de igual **' = '** para atribuir valores a variáveis. Sendo assim, não há necessidade de declarar uma variável antecipadamente. Atribuir um valor a uma variável em si declara e inicializa a variável com esse valor. Não há como declarar uma variável lhe atribuir um valor inicial. 17 | 18 | ##### Bom saber 19 | 20 | - Existem palavras reservadas na linguagem python, palavras nas quais não podemos usar como nomes para variaveis. Veja o conteúdo a seguir para entender melhor: [Palavras chaves (Keywords)](/Extras/keywords.md) -------------------------------------------------------------------------------- /Extras/Assistente_Virtual.md: -------------------------------------------------------------------------------- 1 | # Desenvolvendo uma assistente virtual 2 | Requisitos: 3 |
    4 |
  • Um microfone.
    • 5 |
  • Python e o pacote pip instalados na máquina.
    • 6 |
7 | Já pensou em desenvolver uma nova siri?
8 | Já pensou em desenvolver a sua cortana?
9 | Então, você está no lugar certo.
10 | Neste .md te ensinarei a desenvolver sua própria assistente virtual. 11 | 12 | ## Instalação 13 | Como primeiro passo, precisamos baixar a biblioteca e ferramenta cli, gtts (Google Text-to-Speech) para interagir com a API do google translate. Para gravar os dados falados num arquivo .mp3.
14 | Para instalar é preciso usar o seguinte comando: 15 | (Use este comando no seu terminal) 16 |
17 | 18 | 19 | 20 | pip install gTTS 21 | 22 |
23 | Após, instalado o gtts é necessário a biblioteca playsound para reproduzir este áudio. 24 | Para instalar só preciso usar o seguinte comando: 25 | (Use este comando no seu terminal) 26 | 27 | 28 | pip install playsound 29 | 30 | 31 | Agora, com todas as bibliotecas instaladas podemos iniciar a parte de desenvolvimento. 32 | 33 | ## 1° linhas de código 34 | 35 | ### Função de fala 36 | Vamos começar!!! 37 | 38 |
    39 |
  1. Abra o seu editor de código favorito.
    2. 40 |
  2. Crie um arquivo .py
    3. 41 | 42 | 43 |
44 | 45 | Para iniciar, devemos importar as bibliotecas instaladas. 46 | 47 | 48 | 49 | #biblioteca de criação do áudio 50 | from gtts import gTTS 51 | #biblioteca de reprodução do áudio 52 | import playsound 53 | 54 | 55 | 56 | 57 | Agora, vamos criar a função que faz nossa assistente virtual. 58 | 59 | 60 | 61 | #biblioteca de criação do áudio 62 | from gtts import gTTS 63 | #biblioteca de reprodução do áudio 64 | import playsound 65 | 66 | #Função que faz a assistente virtual falar 67 | #O parâmetro text é o texto que desejamos que seja falado 68 | def falar(text): 69 | #Nesta linha acontece a mágica 70 | tts = gTTS(text=text,lang="pt") 71 | arquivo = "voz.mp3" 72 | #Aqui salvamos o arquivo .mp3 73 | tts.save(arquivo) 74 | #Aqui reproduzimos 75 | playsound.playsound(arquivo) 76 | 77 | 78 | A função de fala está pronta. Basta agora usarmos ela 79 | 80 | 81 | 82 | #biblioteca de criação do áudio 83 | from gtts import gTTS 84 | #biblioteca de reprodução do áudio 85 | import playsound 86 | 87 | #Função que faz a assistente virtual falar 88 | #O parâmetro text é o texto que desejamos que seja falado 89 | def falar(text): 90 | #Nesta linha acontece a mágica 91 | tts = gTTS(text=text,lang="pt") 92 | arquivo = "voz.mp3" 93 | #Aqui salvamos o arquivo .mp3 94 | tts.save(arquivo) 95 | #Aqui reproduzimos 96 | playsound.playsound(arquivo) 97 | 98 | #Fazendo falar 99 | falar("Bom dia") 100 | 101 | Agora, é só executar. 102 | 103 | ### Função para escutar 104 | 105 | Para que nossa assistente nos escute é necessário baixar mais uma biblioteca. 106 | (Use este comando no seu terminal) 107 | 108 | 109 | 110 | pip install SpeechRecognition 111 | 112 | 113 | Com ela instalada vamos criar a função escutar. 114 | Não esqueça de importar a biblioteca baixada. 115 | 116 | 117 | #biblioteca de criação do áudio 118 | from gtts import gTTS 119 | #biblioteca de reprodução do áudio 120 | import playsound 121 | #biblioteca que recebe o áudio do microfone 122 | import speech_recognition as sr 123 | 124 | #Função que faz a assistente virtual falar 125 | #O parâmetro text é o texto que desejamos que seja falado 126 | def falar(text): 127 | #Nesta linha acontece a mágica 128 | tts = gTTS(text=text,lang="pt") 129 | arquivo = "voz.mp3" 130 | #Aqui salvamos o arquivo .mp3 131 | tts.save(arquivo) 132 | #Aqui reproduzimos 133 | playsound.playsound(arquivo) 134 | 135 | #Função que faz a assistente virtual capturar áudio do microfone 136 | def escutar(): 137 | #Cria "ouvidos" 138 | r = sr.Recognizer() 139 | #procura por um microfone 140 | with sr.Microphone() as s: 141 | #Configura o ambiente 142 | r.adjust_for_ambient_noise(s) 143 | #Captura o audio 144 | audio = r.listen(s) 145 | #Transforma em texto 146 | fala = r.recognize_google(audio, language="pt-br") 147 | return fala 148 | 149 | 150 | Agora, com a função escutar pronta, basta inicializarmos ela. 151 | 152 | 153 | 154 | #biblioteca de criação do áudio 155 | from gtts import gTTS 156 | #biblioteca de reprodução do áudio 157 | import playsound 158 | #biblioteca que recebe o áudio do microfone 159 | import speech_recognition as sr 160 | 161 | #Função que faz a assistente virtual falar 162 | #O parâmetro text é o texto que desejamos que seja falado 163 | def falar(text): 164 | #Nesta linha acontece a mágica 165 | tts = gTTS(text=text,lang="pt") 166 | arquivo = "voz.mp3" 167 | #Aqui salvamos o arquivo .mp3 168 | tts.save(arquivo) 169 | #Aqui reproduzimos 170 | playsound.playsound(arquivo) 171 | 172 | #Função que faz a assistente virtual capturar áudio do microfone 173 | def escutar(): 174 | #Cria "ouvidos" 175 | r = sr.Recognizer() 176 | #procura por um microfone 177 | with sr.Microphone() as s: 178 | #Configura o ambiente 179 | r.adjust_for_ambient_noise(s) 180 | #Captura o audio 181 | audio = r.listen(s) 182 | #Transforma em texto 183 | fala = r.recognize_google(audio, language="pt-br") 184 | return fala 185 | 186 | print(escutar()) 187 | 188 | Por fim, é só executar no script e conferir como ficou. 189 | 190 | ### Contando piadas 191 | 192 |

Vamos, dar uma funcionalidade muito boa a nossa assistente virtual que é contar piadas. 193 | Para isso, busquei algumas na internet e a salvei-as num vetor. 194 |

195 | 196 | 197 | 198 | #biblioteca de criação do áudio 199 | from gtts import gTTS 200 | #biblioteca de reprodução do áudio 201 | import playsound 202 | #biblioteca que recebe o áudio do microfone 203 | import speech_recognition as sr 204 | #biblioteca que gera números aleatórios 205 | import random 206 | 207 | #Função que faz a assistente virtual falar 208 | #O parâmetro text é o texto que desejamos que seja falado 209 | def falar(text): 210 | #Nesta linha acontece a mágica 211 | tts = gTTS(text=text,lang="pt") 212 | arquivo = "voz.mp3" 213 | #Aqui salvamos o arquivo .mp3 214 | tts.save(arquivo) 215 | #Aqui reproduzimos 216 | playsound.playsound(arquivo) 217 | 218 | #Função que faz a assistente virtual capturar áudio do microfone 219 | def escutar(): 220 | #Cria "ouvidos" 221 | r = sr.Recognizer() 222 | #procura por um microfone 223 | with sr.Microphone() as s: 224 | #Configura o ambiente 225 | r.adjust_for_ambient_noise(s) 226 | #Captura o audio 227 | audio = r.listen(s) 228 | #Transforma em texto 229 | fala = r.recognize_google(audio, language="pt-br") 230 | return fala 231 | 232 | escutar() 233 | 234 | #Número aleatório 235 | #Não se esqueça de importar a biblioteca random 236 | num = random.radint(0,2) 237 | 238 | #Vetor com três piadas 239 | Piadas = ["Então, porque a aranha é o animal mais carente do mundo? Por que, ela é uma ar", 240 | "Afinal, você conhece a piada do pônei? Pô nei eu kkkkkkkkkkkk.", 241 | "Afinal, o que a vaca disse para o boi? Te amuuuuuuuuuuuuuuuu."] 242 | 243 | """Se a função escutar, retornar "piadas", então nossa assistente conta uma piada""" 244 | 245 | if escutar() == "piadas": 246 | falar(piadas[num]) 247 | 248 | 249 | ### Enviando e-mails 250 | 251 | Enviar e-mails é uma tarefa tão repetitiva, por que não deixarmos nossa assistente fazer isso por nós.
252 | 253 | OBS: Para darmos esta funcionalidade a nossa assistente usaremos uma biblioteca no próprio python. 254 | 255 | 256 | 257 | #biblioteca de criação do áudio 258 | from gtts import gTTS 259 | #biblioteca de reprodução do áudio 260 | import playsound 261 | #biblioteca que recebe o áudio do microfone 262 | import speech_recognition as sr 263 | #biblioteca que gera números aleatórios 264 | import random 265 | #biblioteca para envio de e-mails 266 | import smtplib 267 | 268 | #Função que faz a assistente virtual falar 269 | #O parâmetro text é o texto que desejamos que seja falado 270 | def falar(text): 271 | #Nesta linha acontece a mágica 272 | tts = gTTS(text=text,lang="pt") 273 | arquivo = "voz.mp3" 274 | #Aqui salvamos o arquivo .mp3 275 | tts.save(arquivo) 276 | #Aqui reproduzimos 277 | playsound.playsound(arquivo) 278 | 279 | #Função que faz a assistente virtual capturar áudio do microfone 280 | def escutar(): 281 | #Cria "ouvidos" 282 | r = sr.Recognizer() 283 | #procura por um microfone 284 | with sr.Microphone() as s: 285 | #Configura o ambiente 286 | r.adjust_for_ambient_noise(s) 287 | #Captura o audio 288 | audio = r.listen(s) 289 | #Transforma em texto 290 | fala = r.recognize_google(audio, language="pt-br") 291 | return fala 292 | 293 | escutar() 294 | #Número aleatório 295 | #Não se esqueça de importar a biblioteca random 296 | num = random.radint(0,2) 297 | 298 | #Vetor com três piadas 299 | Piadas = ["Então, porque a aranha é o animal mais carente do mundo? Por que, ela é uma ar", 300 | "Afinal, você conhece a piada do pônei? Pô nei eu kkkkkkkkkkkk.", 301 | "Afinal, o que a vaca disse para o boi? Te amuuuuuuuuuuuuuuuu."] 302 | 303 | """Se a função escutar, retornar "piadas", então nossa assistente conta uma piada""" 304 | 305 | if escutar() == "piadas": 306 | falar(piadas[num]) 307 | #Envia um e-mail 308 | elif escutar() == "e-mail": 309 | email_remetente = "Digite aqui seu e-mail" 310 | senha_rementente = "Digite aqui a senha do seu e-mail" 311 | email_destinatario = "Digite o e-mail que vai receber sua mensagem" 312 | mensagem = "Digite aqui a mensagem que você deseja enviar" 313 | 314 | #Conexão com o servidor do gmail, via protocolo SMTP 315 | """Caso, deseje mudar o servidor de e-mail, verifique o endereço smtp e a porta, do novo servidor""" 316 | email = smtplib.SMTP("smtp.gmail.com",587) 317 | 318 | #Inicia conexão com protocolo TTLS 319 | email.starttls() 320 | 321 | #Faz login na sua conta de e-mail, no caso gmail 322 | email.login(email_remetente,senha_remetente) 323 | 324 | #Envia o e-mail 325 | email.sendmail(email_remetente,email_destinatario,mensagem) 326 | 327 | falar("Enviei o e-mail") 328 | 329 | 330 | OBS1: Caso, esteja usando o gmail você terá que liberar o acesso da nossa assistente nas configurações do gmail. 331 | 332 | ### Acessando sites 333 | 334 | Nossa assistente, já tem 4 funcionalidades, por que não programarmos mais uma?
335 | Vamos, ensinar ela a abrir um site agora. 336 | 337 | OBS: Usaremos a biblioteca webbrowser não se esqueça de importa-la. 338 | 339 | 340 | 341 | #biblioteca de criação do áudio 342 | from gtts import gTTS 343 | #biblioteca de reprodução do áudio 344 | import playsound 345 | #biblioteca que recebe o áudio do microfone 346 | import speech_recognition as sr 347 | #biblioteca que gera números aleatórios 348 | import random 349 | #biblioteca para envio de e-mails 350 | import smtplib 351 | #biblioteca para controlar o navegador 352 | import webbrowser as nav 353 | 354 | #Função que faz a assistente virtual falar 355 | #O parâmetro text é o texto que desejamos que seja falado 356 | def falar(text): 357 | #Nesta linha acontece a mágica 358 | tts = gTTS(text=text,lang="pt") 359 | arquivo = "voz.mp3" 360 | #Aqui salvamos o arquivo .mp3 361 | tts.save(arquivo) 362 | #Aqui reproduzimos 363 | playsound.playsound(arquivo) 364 | 365 | #Função que faz a assistente virtual capturar áudio do microfone 366 | def escutar(): 367 | #Cria "ouvidos" 368 | r = sr.Recognizer() 369 | #procura por um microfone 370 | with sr.Microphone() as s: 371 | #Configura o ambiente 372 | r.adjust_for_ambient_noise(s) 373 | #Captura o audio 374 | audio = r.listen(s) 375 | #Transforma em texto 376 | fala = r.recognize_google(audio, language="pt-br") 377 | return fala 378 | 379 | escutar() 380 | #Número aleatório 381 | #Não se esqueça de importar a biblioteca random 382 | num = random.radint(0,2) 383 | 384 | #Vetor com três piadas 385 | Piadas = ["Então, porque a aranha é o animal mais carente do mundo? Por que, ela é uma ar", 386 | "Afinal, você conhece a piada do pônei? Pô nei eu kkkkkkkkkkkk.", 387 | "Afinal, o que a vaca disse para o boi? Te amuuuuuuuuuuuuuuuu."] 388 | 389 | """Se a função escutar, retornar "piadas", então nossa assistente conta uma piada""" 390 | 391 | if escutar() == "piadas": 392 | falar(piadas[num]) 393 | #Envia um e-mail 394 | elif escutar() == "e-mail": 395 | email_remetente = "Digite aqui seu e-mail" 396 | senha_rementente = "Digite aqui a senha do seu e-mail" 397 | email_destinatario = "Digite o e-mail que vai receber sua mensagem" 398 | mensagem = "Digite aqui a mensagem que você deseja enviar" 399 | 400 | #Conexão com o servidor do gmail, via protocolo SMTP 401 | """Caso, deseje mudar o servidor de e-mail, verifique o endereço smtp e a porta, do novo servidor""" 402 | email = smtplib.SMTP("smtp.gmail.com",587) 403 | 404 | #Inicia conexão com protocolo TTLS 405 | email.starttls() 406 | 407 | #Faz login na sua conta de e-mail, no caso gmail 408 | email.login(email_remetente,senha_remetente) 409 | 410 | #Envia o e-mail 411 | email.sendmail(email_remetente,email_destinatario,mensagem) 412 | 413 | falar("Enviei o e-mail") 414 | 415 | elif escutar() == "google": 416 | nav.open("www.google.com.br") 417 | 418 | 419 | Enfim, projeto concluido, nomeie sua AV e divirta-se. 420 | 421 | 422 | ## Caso precise de ajuda 423 | Caso, tenha ficado uma dúvida sobre o conteúdo apresentado neste readme, acesse o discord da heartdevs que a comunidade fornecerá o melhor suporte para você.
424 | Discord: discord 425 |
426 | 427 | -------------------------------------------------------------------------------- /Extras/assets/and.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Extras/assets/and.png -------------------------------------------------------------------------------- /Extras/assets/keywords.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Extras/assets/keywords.png -------------------------------------------------------------------------------- /Extras/assets/not.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Extras/assets/not.png -------------------------------------------------------------------------------- /Extras/assets/or.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Extras/assets/or.png -------------------------------------------------------------------------------- /Extras/assets/true_false.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Extras/assets/true_false.png -------------------------------------------------------------------------------- /Extras/bloco_de_notas.md: -------------------------------------------------------------------------------- 1 | # Bloco de notas 2 | 3 | ## Introdução 4 | 5 | - Esse contéudo extra trata-se de um bloco de notas simples, somente para fins de complementar os estudos e conhecimentos adquiridos nesse projeto; 6 | - Para comerçarmos, precisamos estar a par de algumas configurações, sendo elas: 7 | 8 | - Virtualenv: 9 | ```python 10 | 11 | # Instalando virtualenv 12 | sudo apt install virtualenv 13 | pip install virtualenv 14 | 15 | # Criando o ambiente virtual 16 | virtualenv -p python3 venv 17 | ``` 18 | 19 | - Tkinter: 20 | ```python 21 | 22 | # Instalando módulo tkinter 23 | sudo apt-get install python3-tk 24 | ``` 25 | 26 | - Para chegar até aqui, iremos supor que você ja passou pelos outros capitulos desse projeto. É de suma importancia que tal ação seja feita, para que surja o minimo de duvidas possiveis, quanto aos assuntos mais basicos. 27 | 28 | 29 | ## Hora do código 30 | 31 | - Dando inicio ao codigo, iremos importar a biblioteca tkinter e alguns de seus módulos: 32 | 33 | ```python 34 | 35 | # importando todos os objetos do modulo tkinter 36 | from tkinter import * 37 | 38 | # importando os objetos asksaveasfilename e askopenfilename, usados para salvar e abrir arquivos. 39 | from tkinter.filedialog import asksaveasfilename,askopenfilename 40 | ``` 41 | 42 | - Agora, vamos instanciar nossa classe que comportará todo o codigo do nosso bloco de notas. 43 | 44 | Vamos dar o nome de __PyNotePad__ e definir o construtor da nossa classe: 45 | 46 | 47 | ```python 48 | 49 | # Instanciando nossa classe 50 | class PyNotePad: 51 | # instanciando nosso construtor 52 | def __init__(self): 53 | # Inicializando o interpretador 54 | self.root = Tk() 55 | 56 | # Nomeando a janela do bloco de notas 57 | self.root.wm_title("Bloco de notas da he4rt") 58 | 59 | # criando uma barra de rolagem e permitindo que a mesma seja "ativada" quando for necessario. 60 | scrollbar = Scrollbar(self.root) 61 | scrollbar.pack(side=RIGHT, fill=Y) 62 | 63 | 64 | # Nesse trecho de código estamos criando o menu de navegação do nosso bloco de notas. 65 | menubar = Menu(self.root) 66 | MENUarquivo = Menu(menubar) 67 | 68 | MENUarquivo.add_command(label="Salvar", command=self.salvar) 69 | 70 | MENUarquivo.add_command(label="Abrir", command=self.abrir) 71 | 72 | menubar.add_cascade(label="Arquivo", menu=MENUarquivo) 73 | 74 | MENUajuda = Menu(menubar) 75 | MENUajuda.add_command(label="Sobre", command=self.sobre) 76 | 77 | menubar.add_cascade(label="Ajuda", menu=MENUajuda) 78 | self.root.config(menu=menubar) 79 | 80 | # Aqui estamos criando um campo que permite escrevermos varias linhas de texto. 81 | self.text = Text(self.root) 82 | self.text.pack(expand=YES, fill=BOTH) 83 | self.text.config(yscrollcommand=scrollbar.set) 84 | scrollbar.config(command=self.text.yview) 85 | 86 | self.root.mainloop() 87 | ``` 88 | 89 | Com nosso construtor criado, vamos iniciar nossa função que será responsavel por executar a ação de salvar o nosso arquivo de texto: 90 | 91 | 92 | ```python 93 | 94 | # Aqui é a função que salva o arquivo 95 | def salvar(self): 96 | 97 | # Instanciando a função que permite que a gente salve nosso arquivo e execute a janela de dialogo para escolher o local onde será salvo e o nome do arquivo. 98 | fileName = asksaveasfilename() 99 | 100 | # o bloco de codigo a seguir, resumidamente, permite que o nosso arquivo seja salvo, porém essa execução vem dentro de um bloco try/except/finally, fazendo com que a coordenação da ação seja feita de forma primordial. 101 | try: 102 | file = open(fileName, 'w') 103 | textoutput = self.text.get(0.0, END) 104 | file.write(textoutput) 105 | except: 106 | pass 107 | finally: 108 | file.close() 109 | ``` 110 | 111 | 112 | Temos o construtor da nossa classe e nossa função para salvar nosso arquivo, então vamos para a função que permite abrir arquivos salvos em nosso computador: 113 | 114 | ```python 115 | 116 | # Aqui é a função que abre um arquivo 117 | def abrir(self): 118 | 119 | # Instanciando a função que permite que a gente abra um arquivo salvo em nosso computador. 120 | fileName = askopenfilename() 121 | 122 | # o bloco de codigo a seguir, resumidamente, permite que a gente possa abrir um arquivo dentro do nosso bloco de notas, porém essa execução vem dentro de um bloco try/except/finally, fazendo com que a coordenação da ação seja feita de forma primordial. 123 | try: 124 | file = open(fileName, 'r') 125 | contents = file.read() 126 | 127 | self.text.delete(0.0, END) 128 | self.text.insert(0.0, contents) 129 | except: 130 | pass 131 | ``` 132 | 133 | Por ultimo, mas não menos importante, teremos uma área do nosso bloco de notas, onde podemos excrever um texto grande ou apenas a versão do bloco de notas: 134 | 135 | 136 | ```python 137 | 138 | # uma pequena função "sobre" :D 139 | def sobre(self): 140 | 141 | # Inicializando o interpretador 142 | root = Tk() 143 | 144 | # Definindo o titulo da janela 145 | root.wm_title("Sobre") 146 | 147 | # O bloco abaixo cria um label e atribui um texto somente de leitura (intuito do widget label) 148 | texto=("python4noobs notepad: Versão 1.0") 149 | textONlabel = Label(root, text=texto) 150 | textONlabel.pack() 151 | ``` 152 | 153 | Fora da nossa clase, iremos instancia-la para que o python consiga chamar e executar a mesma: 154 | 155 | ```python 156 | 157 | # inicia o programa: 158 | PyNotePad() 159 | ``` 160 | 161 | Nosso bloco de notas esta pronto, segue abaixo o codigo completo e comentado para facilitar a visualização e entendimento do mesmo: 162 | 163 | ```python 164 | # Instanciando nossa classe 165 | class PyNotePad: 166 | # instanciando nosso construtor 167 | def __init__(self): 168 | # Inicializando o interpretador 169 | self.root = Tk() 170 | 171 | # Nomeando a janela do bloco de notas 172 | self.root.wm_title("Bloco de notas da he4rt") 173 | 174 | # criando uma barra de rolagem e permitindo que a mesma seja "ativada" quando for necessario. 175 | scrollbar = Scrollbar(self.root) 176 | scrollbar.pack(side=RIGHT, fill=Y) 177 | 178 | 179 | # Nesse trecho de código estamos criando o menu de navegação do nosso bloco de notas. 180 | menubar = Menu(self.root) 181 | MENUarquivo = Menu(menubar) 182 | 183 | MENUarquivo.add_command(label="Salvar", command=self.salvar) 184 | 185 | MENUarquivo.add_command(label="Abrir", command=self.abrir) 186 | 187 | menubar.add_cascade(label="Arquivo", menu=MENUarquivo) 188 | 189 | MENUajuda = Menu(menubar) 190 | MENUajuda.add_command(label="Sobre", command=self.sobre) 191 | 192 | menubar.add_cascade(label="Ajuda", menu=MENUajuda) 193 | self.root.config(menu=menubar) 194 | 195 | # Aqui estamos criando um campo que permite escrevermos varias linhas de texto. 196 | self.text = Text(self.root) 197 | self.text.pack(expand=YES, fill=BOTH) 198 | self.text.config(yscrollcommand=scrollbar.set) 199 | scrollbar.config(command=self.text.yview) 200 | 201 | self.root.mainloop() 202 | 203 | # Aqui é a função que salva o arquivo 204 | def salvar(self): 205 | 206 | # Instanciando a função que permite que a gente salve nosso arquivo e execute a janela de dialogo para escolher o local onde será salvo e o nome do arquivo. 207 | fileName = asksaveasfilename() 208 | 209 | # o bloco de codigo a seguir, resumidamente, permite que o nosso arquivo seja salvo, porém essa execução vem dentro de um bloco try/except/finally, fazendo com que a coordenação da ação seja feita de forma primordial. 210 | try: 211 | file = open(fileName, 'w') 212 | textoutput = self.text.get(0.0, END) 213 | file.write(textoutput) 214 | except: 215 | pass 216 | finally: 217 | file.close() 218 | 219 | # Aqui é a função que abre um arquivo 220 | def abrir(self): 221 | 222 | # Instanciando a função que permite que a gente abra um arquivo salvo em nosso computador. 223 | fileName = askopenfilename() 224 | 225 | # o bloco de codigo a seguir, resumidamente, permite que a gente possa abrir um arquivo dentro do nosso bloco de notas, porém essa execução vem dentro de um bloco try/except/finally, fazendo com que a coordenação da ação seja feita de forma primordial. 226 | try: 227 | file = open(fileName, 'r') 228 | contents = file.read() 229 | 230 | self.text.delete(0.0, END) 231 | self.text.insert(0.0, contents) 232 | except: 233 | pass 234 | 235 | # uma pequena função "sobre" :D 236 | def sobre(self): 237 | 238 | # Inicializando o interpretador 239 | root = Tk() 240 | 241 | # Definindo o titulo da janela 242 | root.wm_title("Sobre") 243 | 244 | # O bloco abaixo cria um label e atribui um texto somente de leitura (intuito do widget label) 245 | texto=("python4noobs notepad: Versão 1.0") 246 | textONlabel = Label(root, text=texto) 247 | textONlabel.pack() 248 | 249 | 250 | # inicia o programa: 251 | PyNotePad() 252 | ``` -------------------------------------------------------------------------------- /Extras/calculadora.md: -------------------------------------------------------------------------------- 1 | # Desenvolvendo uma calculadora 2 | 3 | ## Requisitos 4 | - Python instalado no computador 5 | - Biblioteca tkinter instalada no computador 6 | 7 | 8 | pip install python-tk 9 | 10 | 11 | 12 | ## Hora do código 13 | Após, a criação do .py começamos importando a biblioteca. 14 | 15 | 16 | 17 | from tkinter import * 18 | 19 | 20 | Depois inicialize ela. 21 | 22 | 23 | 24 | tela = Tk() 25 | 26 | Vamos definir algumas configurações da nossa tela. 27 | 28 | 29 | #Importando a biblioteca 30 | from tkinter import * 31 | #Definindo um título para a janela 32 | tela.title("4noobs") 33 | #cor de fundo da tela 34 | tela.configure(background="#F4F5F4") 35 | tela.resizable(False,False) 36 | #Icone da janela 37 | tela.iconbitmap("ico.ico") 38 | #Manter a janela aberta 39 | tela.mainloop() 40 | 41 | 42 | OBS: O ícone deve estar no mesmo diretório do .py
43 | OBS: Nomeie o ícone com o nome ico. 44 | link do ícone: https://icon-icons.com/pt/icone/calculadora/34473 45 | 46 | Depois, basta executar e conferir como ficou.
47 | 48 | Vamos, criar agora os botões e a caixa texto que receberá as operações. 49 | 50 | 51 | 52 | 53 | #Criando caixa de texto 54 | txt = Entry(tela) 55 | 56 | #Criando botões 57 | btn0 = Button(tela,text="0",fg="black",bg="#F4F5F4",width = 5 ,height = 2) 58 | btn1 = Button(tela,text="1",fg="black",bg="#F4F5F4",width = 5 ,height = 2) 59 | btn2 = Button(tela,text="2",fg="black",bg="#F4F5F4",width = 5 ,height = 2 60 | btn3 = Button(tela,text="3",fg="black",bg="#F4F5F4",width = 5 ,height = 2) 61 | btn4 = Button(tela,text="4",fg="black",bg="#F4F5F4",width = 5 ,height = 2) 62 | btn5 = Button(tela,text="5",fg="black",bg="#F4F5F4",width = 5 ,height = 2) 63 | btn6 = Button(tela,text="6",fg="black",bg="#F4F5F4",width = 5 ,height = 2) 64 | btn7 = Button(tela,text="7",fg="black",bg="#F4F5F4",width = 5 ,height = 2) 65 | btn8 = Button(tela,text="8",fg="black",bg="#F4F5F4",width = 5 ,height = 2) 66 | btn9 = Button(tela,text="9",fg="black",bg="#F4F5F4",width = 5 ,height = 2) 67 | 68 | btnPonto = Button(tela,text=".",fg="black",bg="#F4F5F4",width = 5 ,height = 2) 69 | btnLimpar = Button(tela,text="Limpar",fg="black",bg="#F4F5F4",width = 5 ,height = 2) 70 | btnResul = Button(tela,text="=",fg="black",bg="#F4F5F4",width = 10 ,height = 2) 71 | 72 | btnSoma = Button(tela,text="+",fg="black",bg="#F4F5F4",width = 5 ,height = 2) 73 | btnSubt = Button(tela,text="-",fg="black",bg="#F4F5F4",width = 5 ,height = 2) 74 | btnDiv = Button(tela,text="/",fg="black",bg="#F4F5F4",width = 5 ,height = 2) 75 | btnMulti = Button(tela,text="*",fg="black",bg="#F4F5F4",width = 5 ,height = 2) 76 | 77 | 78 | #Definindo como aloca-los na interface 79 | 80 | txt.grid(row = 0, columnspan = 10,padx = 10, pady = 2) 81 | 82 | btn7.grid(row = 1, column = 1, padx = 5, pady = 5) 83 | btn8.grid(row = 1, column = 2, padx = 5, pady = 5) 84 | btn9.grid(row = 1, column = 3, padx = 5, pady = 5) 85 | btnSoma.grid(row = 1, column = 4, padx = 5, pady = 5) 86 | 87 | btn4.grid(row = 2, column = 1, padx = 5, pady = 5) 88 | btn5.grid(row = 2, column = 2, padx = 5, pady = 5) 89 | btn6.grid(row = 2, column = 3, padx = 5, pady = 5) 90 | btnSubt.grid(row = 2, column = 4, padx = 5, pady = 5) 91 | 92 | btn1.grid(row = 3, column = 1, padx = 5, pady = 5) 93 | btn2.grid(row = 3, column = 2, padx = 5, pady = 5) 94 | btn3.grid(row = 3, column = 3, padx = 5, pady = 5) 95 | btnDiv.grid(row = 3, column = 4, padx = 5, pady = 5) 96 | 97 | btnPonto.grid(row = 4,column = 1, padx = 5, pady = 5) 98 | btn0.grid(row = 4, column = 2, padx = 5, pady = 5) 99 | btnLimpar.grid(row = 4, column = 3, padx = 5, pady = 5) 100 | btnMulti.grid(row = 4, column = 4, padx = 5, pady = 5) 101 | 102 | btnResul.grid(row = 5, column = 1, columnspan = 10,padx = 5, pady = 5) 103 | #Mantém a janela aberta 104 | tela.mainloop() 105 | 106 | 107 | Antes de execurtamos novamente vamos criar as funções dos botões e adiciona-las. 108 | 109 | 110 | 111 | #Importa a biblioteca 112 | from tkinter import * 113 | 114 | tela = Tk() 115 | i = 0 116 | #Título da janela 117 | tela.title("4noobs") 118 | #cor de fundo da tela 119 | tela.configure(background="#F4F5F4") 120 | #Redimensionamento da janela 121 | tela.resizable(False,False) 122 | #Icone da janela 123 | tela.iconbitmap("ico.ico") 124 | 125 | def clickEscrever(valor): 126 | global i 127 | txt.insert(i,valor) 128 | i += 1 129 | 130 | def clickLimpar(): 131 | txt.delete(0,END) 132 | i = 0 133 | 134 | def clickResul(): 135 | conta = txt.get() 136 | resultado = eval(conta) 137 | txt.delete(0,END) 138 | txt.insert(i,str(resultado)) 139 | #Criando caixa de texto 140 | txt = Entry(tela) 141 | 142 | #Criando botões 143 | btn0 = Button(tela,text="0",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(0)) 144 | btn1 = Button(tela,text="1",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(1)) 145 | btn2 = Button(tela,text="2",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(2)) 146 | btn3 = Button(tela,text="3",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(3)) 147 | btn4 = Button(tela,text="4",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(4)) 148 | btn5 = Button(tela,text="5",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(5)) 149 | btn6 = Button(tela,text="6",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(6)) 150 | btn7 = Button(tela,text="7",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(7)) 151 | btn8 = Button(tela,text="8",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(8)) 152 | btn9 = Button(tela,text="9",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(9)) 153 | 154 | btnPonto = Button(tela,text=".",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(".")) 155 | btnLimpar = Button(tela,text="Limpar",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickLimpar()) 156 | btnResul = Button(tela,text="=",fg="black",bg="#F4F5F4",width = 10 ,height = 2,command = lambda: clickResul()) 157 | 158 | btnSoma = Button(tela,text="+",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever("+")) 159 | btnSubt = Button(tela,text="-",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever("-")) 160 | btnDiv = Button(tela,text="/",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever("/")) 161 | btnMulti = Button(tela,text="*",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever("*")) 162 | 163 | txt.grid(row = 0, columnspan = 10,padx = 10, pady = 2) 164 | 165 | btn7.grid(row = 1, column = 1, padx = 5, pady = 5) 166 | btn8.grid(row = 1, column = 2, padx = 5, pady = 5) 167 | btn9.grid(row = 1, column = 3, padx = 5, pady = 5) 168 | btnSoma.grid(row = 1, column = 4, padx = 5, pady = 5) 169 | 170 | btn4.grid(row = 2, column = 1, padx = 5, pady = 5) 171 | btn5.grid(row = 2, column = 2, padx = 5, pady = 5) 172 | btn6.grid(row = 2, column = 3, padx = 5, pady = 5) 173 | btnSubt.grid(row = 2, column = 4, padx = 5, pady = 5) 174 | 175 | btn1.grid(row = 3, column = 1, padx = 5, pady = 5) 176 | btn2.grid(row = 3, column = 2, padx = 5, pady = 5) 177 | btn3.grid(row = 3, column = 3, padx = 5, pady = 5) 178 | btnDiv.grid(row = 3, column = 4, padx = 5, pady = 5) 179 | 180 | btnPonto.grid(row = 4,column = 1, padx = 5, pady = 5) 181 | btn0.grid(row = 4, column = 2, padx = 5, pady = 5) 182 | btnLimpar.grid(row = 4, column = 3, padx = 5, pady = 5) 183 | btnMulti.grid(row = 4, column = 4, padx = 5, pady = 5) 184 | 185 | btnResul.grid(row = 5, column = 1, columnspan = 10,padx = 5, pady = 5) 186 | #Mantém a janela aberta 187 | tela.mainloop() 188 | 189 | 190 | 191 | Agora, sua calculadora está pronta, basta executar e verificar como ficou. Enfim,você tem uma calculadora desenvolvida por sí mesmo, aproveite. Fique a vontade para explorar o código da calculadora e entender como cada linha funciona. 192 | 193 | ## Caso precise de ajuda 194 | Caso, tenha ficado uma dúvida sobre o conteúdo apresentado neste readme, acesse o discord da heartdevs que a comunidade fornecerá o melhor suporte para você.
195 | Discord: discord 196 |
197 | -------------------------------------------------------------------------------- /Extras/magic_methods.md: -------------------------------------------------------------------------------- 1 |

Magic Methods

2 |
3 | 4 | - O metodos magicos são uma forma de adicionar uma "magia" para seu codigo. Esses metodos não são invocados diretamente por você, mas são usados internomente pelo python; 5 | - Por exemplo, em uma soma de dois numeros usamos o operador **+**, porém, internomente o método **__ add __()** é chamado. Veja o exemplo pratico, realizando uma soma da forma convencional: 6 | 7 | ```python 8 | 9 | >>> num = 10 10 | >>> num + 5 11 | 15 12 | ``` 13 | 14 | - O mesmo resultado é retornado se usarmos o método **__ add __()**: 15 | 16 | ```python 17 | 18 | >>> num.__add__(5) 19 | 15 20 | ``` 21 | 22 | - As classes padrões no python usam esses métodos magicos. Para visualizar esses métodos, use a função **dir()**, veja abaixo a lista de atributos e métodos magicos usados pela classe **int**: 23 | 24 | ```python 25 | 26 | >>> dir(int) 27 | 28 | ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', 29 | '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', 30 | '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', 31 | '__getattribute__', '__getnewargs__', '__gt__', '__hash__', 32 | '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', 33 | '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', 34 | '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', 35 | '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', 36 | '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', 37 | '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', 38 | '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', 39 | '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 40 | 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 41 | 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes'] 42 | ``` 43 | 44 | ##### Como invocar esses métodos 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 |
Método magicoQuando é invocado (exemplo)Explicação
__new__(cls [,...])instancia = MinhaClasse(arg1, arg2)__new__ é chamado quando criamos um instancia.
__init__(self [,...])instancia = MinhaClasse(arg1, arg2)__init__ é chamado quando a instancia que criamos será inicializada.
__cmp__(self, other)self == other, self > other, etc...Chamado quando vamos realizar qualquer compração.
__pos__(self)+selfSinal de "mais".
__neg__(self)-selfSinal de "menos".
__invert__(self)~selfInversão de bits.
__index__(self)x[self]Para ser chamado na conversão de tipo para um int quando o objeto é usado em uma slice expression. (explicado no final desse tópico).
__bool__(self)bool(self)Retorna o valor booleano de um objeto.
__getattr__(self, nome)self.nome # nome doesn't existVocê pode usar para dizer a uma classe como lidar com atributos que ela não gerencia explicitamente.
__setattr__(self, nome, val)self.nome = valDefinir um valor para um atributo.
__delattr__(self, nome)del self.nomeDeletar um atributo.
__getattribute__(self, nome)self.nomeAcessar qualquer atributo.
__getitem__(self, key)self[key]Acessar qualquer item, usando um indice.
__setitem__(self, key, val)self[key] = valAtribuir um valor a um item, por meio de um indice.
__delitem__(self, key)del self[key]Deletar um item, por meio de um indice.
__iter__(self)for x in selfInteração
__contains__(self, value)value in self, value not in selfUsado para verificar se um item contém certo valor.in
__call__(self [,...])self(args)"Chamar" uma instancia de algo (variavel, função, etc...).
__enter__(self)with self as x:with Gerenciador de contexto.
__exit__(self, exc, val, trace)with self as x:with Gerenciador de contexto.
__getstate__(self)pickle.dump(pkl_file, self)Serialização.
__setstate__(self)data = pickle.load(pkl_file)Serialização.
__slots__(self)__slots__ = 'foo', 'bar'permite que você indique explicitamente quais atributos de instância você espera que suas instâncias de objeto tenham.
172 | 173 | 174 | #### Bom saber: 175 | 176 | - **slice expression**: 177 | - A função **slice()** retorna a fatia de um objeto; 178 | - Você pode usar essa função para separar uma sequencia de valores (uma lista, por exemplo). 179 | - **Syntax**: 180 | - slice(inicio, fim, intervalo) 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 200 | 201 |
ParametroDescrição
inicioOpcional. Usando um numero inteiro, você poderá definir por onde o "corte" iniciará. O padrão 0 (zero).
fimUsando um numero inteiro, você poderá definir por onde o "corte" terminará.
intervaloOpcional. Um numero inteiro definirá o intervalo no qual a função irá percorrer. O padrão é 1 (Um).
202 | 203 | - **gerenciadores de contexto**: 204 | - Os gerenciadores de contexto permitem que você aloque e libere recursos precisamente quando desejar. O exemplo mais amplamente usado de gerenciadores de contexto é a instrução with. Por exemplo: 205 | 206 | ```python 207 | 208 | with open('arquivo.txt', 'w') as arq: 209 | arq.write('Olá, mundo!') 210 | ``` 211 | 212 | 213 | -------------------------------------------------------------------------------- /Gerando-gráficos/aprimorando_graficos.md: -------------------------------------------------------------------------------- 1 | ## Graficos aprimorados 2 | 3 | 4 | - No [capítulo anterior](/Gerando-gráficos/grafico_simples.md), vimos uma forma básica de como gerar um gráfico, agora vamos um pouco mais além; 5 | 6 | - No próximo exemplo foram inseridos mais parâmetros para criar um gráfico mais completo e com mais informações: 7 | 8 | ```python 9 | In[]: 10 | 11 | # Definindo variáveis 12 | x = [1, 3, 5] 13 | y = [1, 2, 5] 14 | 15 | # Criando um gráfico e atribuindo etiquetas 16 | plt.plot(x, y, linewidth=2, linestyle='--', marker='o', label = 'Uma legenda') 17 | plt.plot(y, x, linewidth=2, linestyle=':', marker='D', label = 'Outra legenda') 18 | 19 | # Atribuindo um título ao gráfico 20 | plt.title('Exemplo utilizando Plot') 21 | plt.xlabel('Variavel 1') 22 | plt.ylabel('Variavel 2') 23 | 24 | # Aplicando legenda 25 | plt.legend() 26 | 27 | # Exibindo o gráfico gerado 28 | plt.show() 29 | ``` 30 | 31 | ```python 32 | Out[]: 33 | ``` 34 |

35 | 36 | Existem outras propriedades que não foram incluídas nesse exemplo, [clique aqui](https://matplotlib.org/api/_as_gen/matplotlib.pyplot.plot.html) para mais informações. -------------------------------------------------------------------------------- /Gerando-gráficos/assets/barchart.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Gerando-gráficos/assets/barchart.png -------------------------------------------------------------------------------- /Gerando-gráficos/assets/barcharthorizontal.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Gerando-gráficos/assets/barcharthorizontal.png -------------------------------------------------------------------------------- /Gerando-gráficos/assets/matplotlib.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Gerando-gráficos/assets/piechart.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Gerando-gráficos/assets/piechart.png -------------------------------------------------------------------------------- /Gerando-gráficos/assets/plot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Gerando-gráficos/assets/plot.png -------------------------------------------------------------------------------- /Gerando-gráficos/assets/plot_aprimorado.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Gerando-gráficos/assets/plot_aprimorado.png -------------------------------------------------------------------------------- /Gerando-gráficos/assets/save.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Gerando-gráficos/assets/save.png -------------------------------------------------------------------------------- /Gerando-gráficos/assets/saveaspng.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Gerando-gráficos/assets/saveaspng.png -------------------------------------------------------------------------------- /Gerando-gráficos/assets/saveconfig.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Gerando-gráficos/assets/saveconfig.png -------------------------------------------------------------------------------- /Gerando-gráficos/como_funciona.md: -------------------------------------------------------------------------------- 1 |

2 | 3 | - O Matplotlib é uma biblioteca para a visualização de dados em Python. Ele apresenta uma API orientada a objetos que permite a criação de gráficos em 2D de uma forma simples e com poucos comandos. A ferramenta disponibiliza diversos tipos de gráficos, como em barra, em linha, em pizza, histogramas entre outras opções. 4 | 5 | - Para conseguirmos usar a ferramenta, devemos primeiro, instala-la: 6 | 7 | ```python 8 | pip install -U matplotlib 9 | 10 | # Usamos o gerenciado de pacotes (pip), para instalar a ferramenta. 11 | ``` 12 |
13 | 14 | Caso queira conhecer melhor a biblioteca: 15 | Site oficial do projeto -------------------------------------------------------------------------------- /Gerando-gráficos/grafico_barras.md: -------------------------------------------------------------------------------- 1 | ## Grafico de barras 2 | 3 | - Os gráficos de barras são usados ​​para exibir valores associados aos dados categóricos; 4 | - A função __plt.bar()__, recebe uma lista de posições e valores; 5 | - Os labels para *x* são fornecidos pela função __plt.xticks()__. 6 | 7 | 8 | ## Gerando um grafico de barras simples 9 | 10 | - Vamos gerar uma grafico de barras com o tema futebolistico; 11 | 12 | - Nesse grafico, mostraremos os 5 maiores campeões brasileiros de futebol. 13 | 14 | ```python 15 | In[]: 16 | 17 | import matplotlib.pyplot as plt 18 | 19 | 20 | plt.style.use('ggplot') 21 | 22 | x = ['Palmeiras', 'Santos', 'Corinthians', 'São Paulo', 'Flamengo'] 23 | quant = [10, 8, 7, 6, 6] 24 | 25 | x_pos = [i for i, _ in enumerate(x)] 26 | 27 | plt.bar(x_pos, quant, color='green') 28 | plt.xlabel("Clubes") 29 | plt.ylabel("Campeonatos Brasileiros") 30 | plt.title("5 maiores vencedores do campeonato brasileiro de futebol") 31 | 32 | plt.xticks(x_pos, x) 33 | 34 | plt.show() 35 | 36 | ``` 37 | 38 | ```python 39 | Out[]: 40 | ``` 41 |

42 | 43 | 44 | ## Curiosidades... 45 | 46 | - Podemos gerar o gráfico na horizontal também, sem muito esforço, usando a função __plt.barh()__: 47 | 48 | ```python 49 | In[]: 50 | 51 | import matplotlib.pyplot as plt 52 | 53 | 54 | plt.style.use('ggplot') 55 | 56 | x = ['Palmeiras', 'Santos', 'Corinthians', 'São Paulo', 'Flamengo'] 57 | quant = [10, 8, 7, 6, 6] 58 | 59 | x_pos = [i for i, _ in enumerate(x)] 60 | 61 | plt.barh(x_pos, quant, color='green') 62 | plt.xlabel("Clubes") 63 | plt.ylabel("Campeonatos Brasileiros") 64 | plt.title("5 maiores vencedores do campeonato brasileiro de futebol") 65 | 66 | plt.yticks(x_pos, x) 67 | 68 | plt.show() 69 | 70 | ``` 71 | 72 | ```python 73 | Out[]: 74 | ``` 75 |

76 | -------------------------------------------------------------------------------- /Gerando-gráficos/grafico_simples.md: -------------------------------------------------------------------------------- 1 | ## Gerando um gráfico simples 2 | 3 | - Nesse capitulo usaremos a biblioteca Matplotlib, para saber mais sobre ela, [clique aqui](/Gerando-gráficos/como_funciona.md); 4 | - Basicamente, a ferramenta Matplotlib gera um gráfico de duas dimensões, onde na parte de baixo fica o eixo X, a esquerda o eixo Y e, entre eles, nossos dados. 5 | 6 | #### Visualização de dados com PyPlot 7 | 8 | - O PyPlot é um módulo do matplotlib para criação de gráficos. Para utilizá-lo é necessário fazer a importação: 9 | 10 | ```python 11 | import matplotlib.pyplot as plt 12 | ``` 13 | - Após importar o módulo, já é possível criar gráficos de uma forma simples e com poucos comandos, conforme pode ser visto no exemplo abaixo: 14 | 15 | ```python 16 | In[]: 17 | # Criando um gráfico 18 | plt.plot( 19 | [1, 3, 5], 20 | [2, 5, 7] 21 | ) 22 | plt.show() 23 | ``` 24 | ```python 25 | Out[]: 26 | ``` 27 |

28 | 29 | - Dessa forma, criamos o mais simples dos graficos com python utilizando a biblioteca matplotlib. -------------------------------------------------------------------------------- /Gerando-gráficos/pie_chart.md: -------------------------------------------------------------------------------- 1 | ## Pie Chart 2 | 3 | - O que é um __pie chart__? 4 | __R:__ *É um diagrama estatístico circular*. 5 |
6 | - A área do gráfico inteiro representa 100% ou o conjunto dos dados; 7 | - As partes de um gráfico de pizza são chamadas de fatias. 8 | - As fatias presentes no pie chart representam a porcentagem de partes dos dados. 9 | 10 | 11 | ## Desenhando um gráfico de pizza simples usando o Python Matplotlib 12 | 13 | - Os gráficos de pizza podem ser desenhados usando a função __pie()__ no módulo *pyplot*. O exemplo de código python abaixo desenha um gráfico de pizza usando a função __pie()__. 14 | 15 | ```python 16 | In[]: 17 | 18 | import matplotlib.pyplot as plt 19 | 20 | 21 | pieLabels = 'Asia', 'Africa', 'Europe', 'North America', 'South America', 'Australia' 22 | populationShare = [59.69, 16, 9.94, 7.79, 5.68, 0.54] 23 | 24 | figureObject, axesObject = plt.subplots() 25 | 26 | axesObject.pie( 27 | populationShare, 28 | labels=pieLabels, 29 | autopct='%1.2f', 30 | startangle=90 31 | ) 32 | axesObject.axis('equal') 33 | 34 | plt.show() 35 | ``` 36 | 37 | ```python 38 | Out[]: 39 | ``` 40 |

41 | 42 | __Obs:__ Por padrão, a função __pie()__ do *pyplot* organiza as fatias em um gráfico de pizza no sentido anti-horário. -------------------------------------------------------------------------------- /Gerando-gráficos/salvando_grafico_arquivo.md: -------------------------------------------------------------------------------- 1 | ## Salvando uma imagem do grafico gerado 2 | 3 | - Com o matplotlib podemos salvar um grafico como imagem para utilizar em relatórios, por exemplo; 4 | 5 | - É muito simples realizar tal operação. Essa opção aparece na propria interface da biblioteca: 6 | 7 |

8 | 9 | - A barra inferior da interface é onde encontrará esse icone: . Clique nele e a seguinte tela aparecerá: 10 | 11 |

12 | 13 | - Escolha o diretorio onde quer salvar a imagem gerada e o nome do arquivo, após isso clique no botão *salvar* e pronto, sua figura ja esta salva no local escolhido. 14 | 15 | ### Forma alternativa 16 | - Além da possibilidade de salvar os gráficos utilizando a interface da biblioteca, é possível salvar por meio de código. 17 | 18 | - Utilizando a função `plt.savefig('nome_do_gráfico.formato')`, é possivel salvar o gráfico em diferentes formatos. Os formatos incluem: .png, .svg e .jpg. 19 | 20 | - Exemplo: 21 | 22 | ```python 23 | plt.plot( 24 | [1, 3, 5], 25 | [2, 5, 7] 26 | ) 27 | plt.savefig('grafico.png') 28 | plt.show() 29 | ``` 30 | 31 | - Se desejar saber outros formatos disponíveis, a função `plt.gcf().canvas.get_supported_filetypes()` retorna a lista dos formatos suportados. -------------------------------------------------------------------------------- /Instalação/Linux.md: -------------------------------------------------------------------------------- 1 |

Instalação do python no linux

2 |

3 | Fala primo!!!
4 | Vamos aprender agora como baixar o python no seu SO(sistema operacional) linux.
5 | E ainda baixar um editor de código, para melhorar sua produtividade.
6 |

Vamos começar?

7 | No linux, o processo de instalação do python,
8 | é muito mais simples que no windows.
9 | Pois, o linux já vem com o python baixado. 10 |

Como conferir se o python está instalado?

11 |
    12 |
  • Para conferir, você deve acessar o terminal linux
    • 13 |
  • E digitar: python
    • 14 |
  • Pronto
    • 15 |

    16 |
17 |

Vamos baixar um editor de código?

18 |
  • O editor de código escolhido foi o visual studio code.

    • 19 |

    20 |
  • Digite no seu terminal: sudo snap install code --classic
    • 21 |
  • Aguarde o fim da instalação...
    • 22 |
  • Pronto
    • 23 | 24 |

    Estamos prontos agora

    25 | Agora, com o python e vs code baixados e instalados, em sua máquina
    26 | você já está preparado para codar. 27 |
    28 |
    29 | OBS: Qualquer problema com a instalação ou dúvida relacionado ao contéudo apresentado neste repositório.
    30 | Acesse o discord da heart developers, que a comunidade irá fornecer o suporte necessário, para você.
    31 | Discord: discord 32 | -------------------------------------------------------------------------------- /Instalação/MacOS.md: -------------------------------------------------------------------------------- 1 |

    Instalação do python no MAC/OS

    2 |

    3 | Fala primo!!!
    4 | Vamos aprender agora como baixar o python no seu SO(sistema operacional) MAC/OS.
    5 | E ainda baixar um editor de código, para melhorar sua produtividade.
    6 |

    Vamos começar?

    7 | No MAC/OS, o processo de instalação do python,
    8 | é bem simples.
    9 | Pois, o MAC/OS, assim como o linux, pode vir com o python instalado. 10 |

    Como conferir se o python está instalado?

    11 |
      12 |
    • Para conferir, você deve acessar o terminal do MAC/OS
      • 13 |
    • E digitar: python
      • 14 |
    • Pronto
      • 15 |

      wwwwwww 16 |
    17 |

    Python não está instalado?

    18 | Caso, o python não esteja instalado em seu MAC/OS.
    19 | Faça a instalação do Xcode via App Store. 20 | Após, instalado o Xcode, siga os seguintes passos: 21 |
      22 |
    • Acesse o terminal.
      • 23 |
    • Digite: xcode-select --install
      • 24 |
    • Digite: sudo easy_install pip
      • 25 |
    • Digite: sudo pip install --upgrade pip
      • 26 |
    • Digite: ruby -e "$(curl -fsSL https://raw.github.com/mxcl/homebrew/go)"
      • 27 |
    • Digite: brew install python3
      • 28 |
    • Pronto
      • 29 |
    30 |

    Vamos baixar um editor de código?

    31 |
  • O editor de código escolhido foi o visual studio code.

    • 32 |

    33 |
  • Baixe o Visual Studio Code para o macOS: Download
    • 34 |
  • Abra a lista de downloads do navegador e localize o arquivo baixado.
    • 35 |
  • Selecione o ícone 'lupa' para abrir o arquivo no Finder.
    • 36 |
  • Arraste Visual Studio Code.app para a Applications pasta, disponibilizando-a no Launchpad do MAC/OS.
    • 37 |
  • Adicione o código VS ao seu Dock clicando com o botão direito do mouse no ícone para abrir o menu de contexto e escolhendo Opções , Manter no Dock .
    • 38 |
  • Pronto
    • 39 | 40 |

    Estamos prontos agora

    41 | Agora, com o python e vs code baixados e instalados, em sua máquina
    42 | você já está preparado para codar. 43 |
    44 |
    45 | OBS: Qualquer problema com a instalação ou dúvida relacionado ao contéudo apresentado neste repositório.
    46 | Acesse o discord da heart developers, que a comunidade irá fornecer o suporte necessário, para você.
    47 | Discord: discord 48 | -------------------------------------------------------------------------------- /Instalação/Windows.md: -------------------------------------------------------------------------------- 1 | 

    Instalação do python no ambiente Windows

    2 |

    3 | Fala primo!!!
    4 | Você aprenderá agora como baixar e instalar o python em sua máquina de SO(sistema operacional) Windows.
    5 | Para dar início a instalação do python.
    6 | É necessário que você acesse o seguinte link: Download
    7 | Após, ter acessado o link, basta seguir os seguintes passos:
    8 |
    9 |
      10 |
    1. Passe o mouse em Downloads
      2. 11 |
    2. Clique em Windows
      3. 12 |
    3. Selecione um dos links conforme a arquitetura(x86 - 32 bits ou x64 - 64 bits) do seu SO
      4. 13 |
    4. Agora é só acessar o instalador, no diretório que o seu navegador deixou.
      5. 14 | OBS:Não se esqueça de marca TODAS as boxes enquanto estiver no instalador. 15 |
    16 | Após, ter concluído a instalação, você pode conferir se o python está instalado acessando seu terminal 17 |
      18 |
    1. Aperte WIN + R
      2. 19 |
    2. Na telinha do canto inferior esquerdo digite: cmd
      3. 20 |
    3. Com o terminal aberto digite: python

      4. 21 |

      22 |
      23 |
    24 | Pronto, agora o python está instalado, em sua máquina.
    25 | Mas, já posso sair codando agora?

    26 |

    27 | A resposta pra está pergunta é: sim, mas...
    28 | Sim, por que podemos criar arquivos .TXT e salva-los como .pye compila-los. 29 | Porém, para melhor a produtividade baixaremos um editor de código.
    30 | O editor escolhido foi o visual studio code.
    31 | OBS: Sinta-se livre para escolher outro editor de código ou até mesmo uma IDE. 32 |

    33 | Para baixar e instalar, o visual studio code é necessário seguir os seguintes passos: 34 |
      35 |
    1. Acesse o link: Visual Studio
      2. 36 |
    2. Clique em: download for windows
      3. 37 |
    3. Agora é só acessar o instalador, no diretório que o seu navegador deixou.
      4. 38 |
      39 |
    40 | Agora, você tem o python e um editor de código instalados em sua máquina.
    41 | Com todo esse armamento, você está pronto codar.
    42 | Siga para o próxima aula.
    43 |
    44 | OBS: Qualquer problema com a instalação ou dúvida relacionado ao contéudo apresentado neste repositório.
    45 | Acesse o discord da heart developers, que a comunidade irá fornecer o suporte necessário, para sua você.
    46 | Discord: discord 47 | -------------------------------------------------------------------------------- /Instruções-simples/assert.md: -------------------------------------------------------------------------------- 1 | ## Assert 2 | 3 | - O __assert__ nada mais é do que uma verificação, em tempo de execução, de uma condição qualquer do codigo; 4 | - Se a condição não for verdadeira, uma exceção __AssertionError__ acontece e o programa pára; 5 | - Não se usa para condições de erro "esperadas", como por exemplo uma conexão de rede que não abriu. O objetivo do __assert__ é auxiliar na depuração, verificando a sanidade interna do programa. 6 |
    7 | 8 | A sintaxe usada é a seguinte: 9 | 10 | ```python 11 | 12 | assert Expression[, Arguments] 13 | ``` 14 | 15 | ## Exemplo 16 | 17 | ```python 18 | In[]: 19 | 20 | def kelvin_fahrenheit(Temperatura): 21 | assert (Temperatura >= 0),"Mais frio que o zero absoluto!" 22 | 23 | return ((Temperatura-273)*1.8)+32 24 | 25 | print kelvin_fahrenheit(273) 26 | print int(kelvin_fahrenheit(505.78)) 27 | print kelvin_fahrenheit(-5) 28 | 29 | ``` 30 | 31 | ```python 32 | Out[]: 33 | 34 | 32.0 35 | 451 36 | 37 | Traceback (most recent call last): 38 | File "kelvin_fahrenheit.py", line 9, in 39 | print kelvin_fahrenheit(-5) 40 | File "kelvin_fahrenheit.py", line 4, in kelvin_fahrenheit 41 | assert (Temperatura >= 0),"Mais frio que o zero absoluto!" 42 | AssertionError: Mais frio que o zero absoluto! 43 | ``` -------------------------------------------------------------------------------- /Instruções-simples/del.md: -------------------------------------------------------------------------------- 1 | ## Keyword del 2 | 3 | - A palavra-chave __del__ é usada para excluir objetos. No Python, tudo é um objeto. Portanto, a palavra-chave __del__ também pode ser usada para excluir *variáveis*, *listas* ou *partes de uma lista*, etc. 4 | 5 | ## Exemplos 6 | 7 | - Podemos excluir uma classe, por exemplo: 8 | 9 | ```python 10 | In[]: 11 | 12 | class Name: 13 | name = "Drxw" 14 | 15 | del Name 16 | print(Name) 17 | 18 | ``` 19 | ```python 20 | Out[]: 21 | 22 | Traceback (most recent call last): 23 | File "keyword_del.py", line 6, in 24 | print(Name) 25 | NameError: name 'Name' is not defined 26 | ``` 27 | 28 | - Podemos usar o __del__ para remover uma variavel: 29 | 30 | ```python 31 | In[]: 32 | 33 | x = "he4rt developers" 34 | 35 | del x 36 | print(x) 37 | 38 | ``` 39 | ```python 40 | Out[]: 41 | 42 | Traceback (most recent call last): 43 | File "keyword_del2.py", line 5, in 44 | print(x) 45 | NameError: name 'x' is not defined 46 | ``` 47 | 48 | - Também podemos remover um item de uma lista, como no exemplo a seguir: 49 | 50 | ```python 51 | In[]: 52 | 53 | x = ["Coca-cola", "Fanta uva", "Pepsi"] 54 | 55 | del x[0] 56 | print(x) 57 | 58 | 59 | ``` 60 | ```python 61 | Out[]: 62 | 63 | ["Fanta uva", "Pepsi"] 64 | ``` -------------------------------------------------------------------------------- /Instruções-simples/global.md: -------------------------------------------------------------------------------- 1 | ## Declaração global 2 | 3 | - Variáveis ​​criadas fora de uma função são conhecidas como variáveis ​​globais; 4 | - Variáveis ​​globais podem ser usadas por todos, dentro e fora das funções. 5 | 6 | ```python 7 | In[]: 8 | 9 | x = "4noobs" 10 | 11 | def myfunc(): 12 | print("Python" + x) 13 | 14 | myfunc() 15 | 16 | ``` 17 | ```python 18 | Out[]: 19 | 20 | Python4noobs 21 | ``` 22 | 23 | - Se você criar uma variável com o mesmo nome dentro de uma função, essa variável será local e só poderá ser usada dentro da função. A variável global com o mesmo nome permanecerá como era, global e com o valor original. 24 | 25 | ```python 26 | In[]: 27 | 28 | x = "4noobs" 29 | 30 | def myfunc(): 31 | x = "He4rt" 32 | print(x + " developers") 33 | 34 | myfunc() 35 | 36 | print("Python" + x) 37 | 38 | 39 | ``` 40 | ```python 41 | Out[]: 42 | 43 | He4rt developers 44 | Python4noobs 45 | ``` 46 | 47 | ## Palavra-chave global 48 | 49 | - como dito anteriormente, quando você cria uma variável dentro de uma função, essa variável é local e só pode ser usada dentro dessa função; 50 | 51 | - Para criar uma variável global dentro de uma função, você pode usar a palavra-chave __global__. 52 | 53 | Se você usar a palavra-chave __global__, a variável pertencerá ao escopo global: 54 | 55 | ```python 56 | In[]: 57 | 58 | def string_func(): 59 | global x 60 | x = "fantastico" 61 | 62 | string_func() 63 | print("Python é " + x) 64 | 65 | ``` 66 | ```python 67 | Out[]: 68 | 69 | Python é fantastico 70 | ``` 71 | 72 | - Além disso, use a palavra-chave __global__ se desejar alterar uma variável global dentro de uma função: 73 | 74 | 75 | ```python 76 | In[]: 77 | 78 | x = "divertido" 79 | 80 | def string_func(): 81 | global x 82 | x = "fantastico" 83 | 84 | string_func() 85 | print("Python é " + x) 86 | 87 | ``` 88 | ```python 89 | Out[]: 90 | 91 | Python é fantastico 92 | ``` -------------------------------------------------------------------------------- /Instruções-simples/nonlocal.md: -------------------------------------------------------------------------------- 1 | ## Nonlocal 2 | 3 | - A palavra-chave __nonlocal__ é usada para trabalhar com variáveis ​​dentro de funções aninhadas, nas quais a variável não deve pertencer à função interna. 4 | 5 | 6 | ```python 7 | In[]: 8 | 9 | def nonlocal_string(): 10 | x = "Drxw" 11 | def nonlocal_string2(): 12 | x = "hello" 13 | nonlocal_string2() 14 | return x 15 | 16 | print(nonlocal_string()) 17 | 18 | ``` 19 | ```Python 20 | Out[]: 21 | 22 | Drxw 23 | ``` 24 | 25 | - Agora criamos uma função dentro de uma função, que use a variável *x* como uma variável __nonlocal__: 26 | 27 | ```python 28 | In[]: 29 | 30 | def nonlocal_string(): 31 | x = "Drxw" 32 | def nonlocal_string2(): 33 | nonlocal x 34 | x = "hello" 35 | nonlocal_string2() 36 | return x 37 | 38 | print(nonlocal_string()) 39 | 40 | ``` 41 | ```Python 42 | Out[]: 43 | 44 | hello 45 | ``` -------------------------------------------------------------------------------- /Instruções-simples/pass.md: -------------------------------------------------------------------------------- 1 | ## Declaração pass 2 | 3 | - Essa declaração é usada quando uma instrução é requerida sintaticamente, mas você não deseja que nenhum comando ou código seja executado; 4 | - A declaração __pass__ é uma operação *null*, nada acontece quando ela é usada. 5 | 6 | ## Exemplo 7 | 8 | ```python 9 | In[]: 10 | 11 | for letra in 'Python': 12 | if letra == 'h': 13 | pass 14 | print 'Esse é um bloco usando a declaração pass' 15 | print 'Letra atual :', letra 16 | print "aaaaadeus!" 17 | 18 | ``` 19 | ```python 20 | Out[]: 21 | 22 | Letra atual : P 23 | Letra atual : y 24 | Letra atual : t 25 | Esse é um bloco usando a declaração pass 26 | Letra atual : h 27 | Letra atual : o 28 | Letra atual : n 29 | aaaaadeus! 30 | 31 | ``` -------------------------------------------------------------------------------- /Instruções-simples/raise.md: -------------------------------------------------------------------------------- 1 | ## raise Keyword 2 | 3 | - Essa palavra chave tem como função gerar uma exceção; 4 | - Você pode definir que tipo de erro gerar e o texto a ser impresso para o usuário. 5 | 6 | Vejamos um exemplo simples: 7 | 8 | ```python 9 | In[]: 10 | 11 | x = 7 12 | 13 | if x < 8: 14 | raise Exception("Desculpe, digite 8 caracteres ou mais") 15 | 16 | ``` 17 | ```python 18 | Out[]: 19 | 20 | Exception: Desculpe, digite 8 caracteres ou mais 21 | ``` 22 | 23 | Outro exemplo que podemos usar é a verificação do tipo do dado de entrada. Digamos que o sistema só aceite numeros *inteiros*, mas foi passado uma *string*, usariamos o seguinte trecho de codigo para retornar ao usuário uma mensagem: 24 | 25 | ```python 26 | In[]: 27 | 28 | x = "He4rt developers" 29 | 30 | if not type(x) is int: 31 | raise TypeError("Digite apenas numeros inteiros!") 32 | 33 | ``` 34 | ```python 35 | Out[]: 36 | 37 | TypeError: Digite apenas numeros inteiros! 38 | ``` -------------------------------------------------------------------------------- /Instruções-simples/return.md: -------------------------------------------------------------------------------- 1 | ## Instrução return 2 | 3 | 4 | - O **return** é utilizado em funções para sinalizar que a função obeteve um resultado e este deve ser retornado; 5 | - Após a declaração dessa instrução, outras instruções não serão executadas até que a função seja chamada novamente; 6 | - Se a instrução **return** estiver sem nenhuma expressão, será retornado `None`. 7 | * Caso a instrução não seja declarada, o retorno será `None`. 8 | 9 | 10 | ## Sintaxe 11 | 12 | ```python 13 | def function_name(): 14 | statements 15 | . 16 | . 17 | return [expression] 18 | ``` 19 | 20 | ## Exemplos 21 | 22 | Vamos fazer uma soma de dois numeros e usar o **return** para nos mostrar o valor da operação 23 | 24 | ```python 25 | >>> def add(a, b): 26 | ... """Essa função junta `a` com `b` e retorna o resultado."" 27 | ... return a + b 28 | ... 29 | >>> 30 | >>> resultado = add(2, 3) 31 | >>> print("O resultado da operação é:", res) 32 | O resultado da operação é: 5 33 | ``` 34 | 35 | Vamos ver o que a função retorna se não colocarmos o **return**. 36 | ```python 37 | >>> def algo(): 38 | ... pass 39 | ... 40 | >>> resultado = algo() 41 | >>> resultado 42 | None 43 | ``` 44 | Eita, mas eu não utilizei o **return**, por que ele retornou `None`? 45 | Todas as funções em Python retornam alguma coisa quando executadas, por padrão, esse retorno é `None`. 46 | Ou seja, a nossa função não retorna nada, literalmente! 47 | 48 | Faça o teste, tente guardar o retorno da função `print` e veja o que acontece! 49 | -------------------------------------------------------------------------------- /Introdução/assets/python_logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Introdução/assets/python_logo.png -------------------------------------------------------------------------------- /Introdução/assets/python_logo_extended.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Introdução/assets/python_logo_extended.png -------------------------------------------------------------------------------- /Introdução/introducao.MD: -------------------------------------------------------------------------------- 1 |

    2 | 3 | Python logomarca 4 | 5 |

    6 | 7 | 8 | # Historia 9 | 10 | Python é uma linguagem de programação de alto nível e uso geral, foi criada por Guido van Rossum em 1991 e posteriormente desenvolvido pela Python Software Foundation. 11 | 12 | ## É usado para: 13 | 14 | - desenvolvimento web (lado do servidor); 15 | - desenvolvimento de software; 16 | - matemática; 17 | - analise de dados; 18 | - inteligencia artificial (I.A). 19 | 20 | 21 | ## Zen do Python 22 | 23 | - O Zen do Python é uma coleção de princípios, para escrever programas de computador que influenciam o design da linguagem de programação Python. 24 | 25 | - Bonito é melhor que feio. 26 | - Explícito é melhor que implícito. 27 | - Simples é melhor que complexo. 28 | - Complexo é melhor que complicado. 29 | - Plano é melhor que aglomerado. 30 | - Esparso é melhor que denso. 31 | - Legibilidade faz diferença. 32 | - Casos especiais não são especiais o bastante para quebrar as regras. 33 | - Embora a praticidade vença a pureza. 34 | - Erros nunca devem passar silenciosamente. 35 | - A menos que sejam explicitamente silenciados. 36 | - Diante da ambigüidade, recuse a tentação de adivinhar. 37 | - Deve haver um - e preferencialmente só um - modo óbvio para fazer algo. 38 | - Embora esse modo possa não ser óbvio à primeira vista a menos que você seja holandês. 39 | - Agora é melhor que nunca. 40 | - Embora nunca freqüentemente seja melhor que *exatamente* agora. 41 | - Se a implementação é difícil de explicar, é uma má idéia. 42 | - Se a implementação é fácil de explicar, pode ser uma boa idéia. 43 | - Namespaces são uma grande idéia -- vamos fazer mais dessas! 44 | 45 |
    46 | 47 | Segue o link para uma explicação mais pratica sobre cada item do zen do python: Zen of python explained. 48 | 49 | ## Bom saber: 50 | 51 | - A versão principal mais recente do Python é o Python 3, que usaremos neste tutorial. No entanto, o Python 2, embora não esteja sendo atualizado com nada além de atualizações de segurança, ainda é bastante popular; 52 | 53 | - É possível escrever Python em um ambiente de desenvolvimento integrado, como Thonny, Pycharm, Netbeans, Eclipse, Visual studio code, entre outros. -------------------------------------------------------------------------------- /Introdução/motivacao.MD: -------------------------------------------------------------------------------- 1 |

    2 | 3 | Logo da He4rtDevs 4 | 5 |

    6 | 7 | # He4rtLabs - Série 4Noobs 8 | 9 | O intuito deste repositório é mostrar projetos desenvolvidos para facilitar o estudos dos devs iniciantes feitos pela nossa comunidade! 10 | 11 | Vários repositórios serão adicionados na medida que forem sendo desenvolvidos e entregue um material estável e de fácil entendimento pros iniciantes (aka Noobs). 12 | 13 | Segue a lista dos repositórios -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 DrxwHe4rt 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Manipulando-arquivos/assets/readline_param.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Manipulando-arquivos/assets/readline_param.png -------------------------------------------------------------------------------- /Manipulando-arquivos/assets/retorno_leitura.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Manipulando-arquivos/assets/retorno_leitura.png -------------------------------------------------------------------------------- /Manipulando-arquivos/assets/retorno_leitura_varias_linhas.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Manipulando-arquivos/assets/retorno_leitura_varias_linhas.png -------------------------------------------------------------------------------- /Manipulando-arquivos/assets/tabela-informativa.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Manipulando-arquivos/assets/tabela-informativa.png -------------------------------------------------------------------------------- /Manipulando-arquivos/assets/writelines.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Manipulando-arquivos/assets/writelines.png -------------------------------------------------------------------------------- /Manipulando-arquivos/criando_abrindo_arquivos.md: -------------------------------------------------------------------------------- 1 | ## Criando e abrindo arquivos 2 | 3 | - Aqui, veremos como criar e abrir um arquivo ja criado; 4 | - A criação e abertura de um arquivo funciona usando o método __open()__. Este método irá abrir o arquivo que passarmos como parâmetro com um determinado modo de uso (que também será passado como parâmetro). 5 | 6 | __Obs:__ Os modos de uso estão descritos na [Introdução](/Manipulando-arquivos/entendendo_manipulacao_arquivos.md) desse módulo. 7 | 8 |
    9 | 10 | - Para abrir um arquivo da forma mais basica possivel, usa-se o seguinte trecho de codigo: 11 | 12 | ```python 13 | arquivo = open("lista_de_compras.txt", "r") 14 | ``` 15 | 16 | - No techo de codigo acima, passamos dois parâmetros ao metodo __open()__, sendo eles, o nome do arquivo (ou o caminho do mesmo) e o modo de uso do método, nesse caso, a letra *r* (modo de leitura); 17 | - Caso o arquivo não exista o console retornará: *FileNotFoundError: [Errno 2] No such file or directory: 'nome_do_arquivo'*. 18 | - Para que a mensagem acima não ocorra, podemos trocar o modo de uso e fazer com que o python crie o arquivo caso ele não e exista, dessa forma, garantimos que o erro não ocorra e o sistema continue sendo executado normalmente. Para isso, alteraremos o modo de uso para *"a"*: 19 | 20 | ```python 21 | arquivo = open("lista_de_compras.txt", "a") 22 | ``` 23 | 24 | ## Importante saber... 25 | 26 | - Quando usamos o operador *"b"* junto com outro parâmetro, por exemplo *"rb"*, dizemos que o arquivo será aberto para leitura em modo binário, segue o exemplo: 27 | 28 | ```python 29 | arquivo = open("teste.bin", "ab") 30 | ``` -------------------------------------------------------------------------------- /Manipulando-arquivos/entendendo_manipulacao_arquivos.md: -------------------------------------------------------------------------------- 1 | ## Entendendo... 2 | 3 |

    4 | A manipulação de arquivos é um trabalho muito importante para todo o desenvolvedor, seja para alterar um arquivo ou fazer um backup e muitas vezes chega a ser desafiador e, convenhamos, isso da um sabor a tudo! 5 |

    6 |

    7 | No Python não é diferente e a manipulação de arquivos é mais simples do que você possa imaginar. Por isso, veremos neste capitulo como realizar as principais operações com arquivos utilizando o Python. 8 |

    9 |

    10 | A manipulação de arquivos contém alguns termos importantes e que serão de conhecimento obrigatorio para dominar essa parte dos estudos. A tabela abaixo representa o que foi dito nesse tópico: 11 |

    12 |

    13 | Tabela informativa 14 |

    15 |
    16 | 17 | ## Bom saber: 18 | 19 | - A versão principal mais recente do Python é o Python 3, que usaremos neste capitulo, ja que a versão 2 do python foi descontinuada definitivamente. 20 | -------------------------------------------------------------------------------- /Manipulando-arquivos/escrevendo_em_arquivos.md: -------------------------------------------------------------------------------- 1 | ## Escrevendo informações em um arquivo 2 | 3 |

    4 | Neste tópico, veremos como escrever dados e salvar em arquivo utilizando o Python. 5 |

    6 |
    7 | 8 | - Para isso, a linguagem fornece dois métodos. O primeiro é o método __write()__ que recebe uma string como parâmetro e a insere no arquivo: 9 | 10 | ```python 11 | arquivo = open("ola_mundo.txt", "a") 12 | arquivo.write("Olá, mundo!") 13 | ``` 14 | 15 | Com a execução das linhas acima o python criará o arquivo, caso não exista e irá inserir o texto *"Olá, mundo!"*. 16 | 17 |
    18 | 19 | - O segundo método é o __writelines()__, onde pode ser usado um objeto iteravel (lista, tupla, dicionario, etc...). Dessa forma, varias linhas podem ser inseridas de uma unica vez no arquivo, diferente do método __write()__, que insere uma string por vez apenas. 20 | 21 | 22 | ```python 23 | In[]: 24 | arquivo = open("texto.txt", "a") 25 | 26 | frases = list() 27 | frases.append("Python \n") 28 | frases.append("4 \n") 29 | frases.append("Noobs \n") 30 | frases.append("He4rt Developers \n") 31 | 32 | arquivo.writelines(frases) 33 | ``` 34 | 35 | - A __lista__ é um objeto iterável, então podemos passa-la como parâmetro do método __writelines()__. Utilizamos, também, o *\n* para saltar a linha ao escrevê-la no arquivo. Com isso, o resultado será o seguinte: 36 | 37 | ```python 38 | Out[]: 39 | ``` 40 | 41 |

    42 | writelines 43 |

    44 | -------------------------------------------------------------------------------- /Manipulando-arquivos/lendo_arquivos.md: -------------------------------------------------------------------------------- 1 | ## Lendo dados de arquivos 2 | 3 | - Além de abrir e criar um arquivo, precisamos saber mostrar ao usuário o conteúdo do mesmo; 4 | 5 | - Existem duas possibilidades de fazer a leitura, usando o método __readline()__, que mostra uma unica linha do arquivo: 6 | 7 | Esse é o conteúdo do nosso arquivo: 8 |

    9 | readline 10 |

    11 | 12 | Esse é o retorno no console, após usar o método: 13 |

    14 | readline 15 |

    16 | 17 | - A outra possibilidade é usar o método __readlines()__, que trará todo o conteudo do arquivo escolhido: 18 | 19 |

    20 | retorno da leitura com varias linhas 21 |

    22 | 23 | 24 | ## Saiba que... 25 | 26 | - Se usar o método __readline()__ e definir um parâmetro para ele, será retornado a quantidade de caracteres equivalentes ao fornecido no metodo. Por exemplo: 27 | 28 | ```python 29 | In[]: 30 | arquivo = open("texto.txt", "r") 31 | 32 | print(arquivo.readline(3)) 33 | ``` 34 | 35 | O retorno será esse: 36 | 37 | ```python 38 | Out[]: 39 | ``` 40 |

    41 | readline 42 |

    43 | 44 | Como o método __readline()__ retorna apenas a primeira linha do arquivo, passando um valor inteiro, ele pegará a quantidade de caracteres conforme o inteiro passado como parâmetro. -------------------------------------------------------------------------------- /Módulo-Tkinter/assets/button.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Módulo-Tkinter/assets/button.png -------------------------------------------------------------------------------- /Módulo-Tkinter/assets/checkbutton.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Módulo-Tkinter/assets/checkbutton.png -------------------------------------------------------------------------------- /Módulo-Tkinter/assets/combobox.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Módulo-Tkinter/assets/combobox.png -------------------------------------------------------------------------------- /Módulo-Tkinter/assets/entry.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Módulo-Tkinter/assets/entry.png -------------------------------------------------------------------------------- /Módulo-Tkinter/assets/frame.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Módulo-Tkinter/assets/frame.png -------------------------------------------------------------------------------- /Módulo-Tkinter/assets/hello_world_tkinter.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Módulo-Tkinter/assets/hello_world_tkinter.png -------------------------------------------------------------------------------- /Módulo-Tkinter/assets/install.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Módulo-Tkinter/assets/install.png -------------------------------------------------------------------------------- /Módulo-Tkinter/assets/label.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Módulo-Tkinter/assets/label.png -------------------------------------------------------------------------------- /Módulo-Tkinter/assets/radiobutton.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Módulo-Tkinter/assets/radiobutton.png -------------------------------------------------------------------------------- /Módulo-Tkinter/assets/tk.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Módulo-Tkinter/assets/tk.png -------------------------------------------------------------------------------- /Módulo-Tkinter/assets/tk_atributos.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Módulo-Tkinter/assets/tk_atributos.png -------------------------------------------------------------------------------- /Módulo-Tkinter/assets/tk_grid.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Módulo-Tkinter/assets/tk_grid.png -------------------------------------------------------------------------------- /Módulo-Tkinter/assets/tk_pack.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Módulo-Tkinter/assets/tk_pack.png -------------------------------------------------------------------------------- /Módulo-Tkinter/gerenciamento_geometria-.md: -------------------------------------------------------------------------------- 1 | ## Gerenciamento do layout e geometria 2 | 3 | - Aqui vamos ver como gerenciar e entender a geometria das janelas e widgets de uma aplicação tkinter; 4 | 5 | Para isso, vamos listar três pontos importantes: 6 | 7 | 1. Método __pack__ 8 | 2. Método __grid__ 9 | 3. Método __place__ 10 | 11 | ## Método pack 12 | 13 | - O método __pack__ empacota/agrupa os widgets dentro da janela. 14 | 15 | Vamos ver como funciona na pratica. Iremos adicionar um texto na parte superior e na parte inferior da janela 16 | 17 | ```python 18 | In[]: 19 | 20 | import tkinter as tk 21 | 22 | 23 | app = tk.Tk() 24 | # Definindo o tamanho padrão da janela 25 | app.geometry('300x200') 26 | 27 | label_top = tk.Label(app, text="Top side", width=15) 28 | label_top.pack(side='top') 29 | 30 | label_bottom = tk.Label(app, text="bottom side", width=15) 31 | label_bottom.pack(side='bottom') 32 | 33 | app.mainloop() 34 | ``` 35 | ```python 36 | Out[]: 37 | ``` 38 | 39 | 40 | 41 | - Veja que nesse codigo vimos como funciona o método __pack__ e também como definir as dimensoes da janela; 42 | 43 | - A propriedade __side__ contém quatro opções: 44 | 45 | - top 46 | - bottom 47 | - left 48 | - right 49 | 50 | 51 | ## Método grid 52 | 53 | - Esse método pode ser considerado o mais importante; 54 | - O método __grid__ é costantemente usado em caixas de diálogo. O método de layout grid pode ter posições relativas estáveis de todos os widgets. 55 | 56 | O exemplo que vamos ver agora é mais extenso e complexo do que vimos até agora, mas fique tranquilo, pois será tudo explicado na sequencia: 57 | 58 | ```python 59 | In[]: 60 | 61 | import tkinter as tk 62 | 63 | 64 | app = tk.Tk() 65 | # Definindo o tamanho padrão da janela 66 | app.geometry('300x200') 67 | 68 | label_top = tk.Label(app, text="Top side", width=15) 69 | label_top.pack(side='top') 70 | 71 | label_bottom = tk.Label(app, text="bottom side", width=15) 72 | label_bottom.pack(side='bottom') 73 | 74 | app.mainloop() 75 | ``` 76 | ```python 77 | Out[]: 78 | ``` 79 | 80 | 81 | - A coordenada da célula é determinada por __column__ e __row__; 82 | - A widget __labelWidth__ é colocada na célula da *posição (0, 0)*. A coordenada começa a partir do canto superior esquerdo da janela; 83 | - Em alguns casos, você precisa adicionar algum detalhe dentro ou fora do widget para que haja menos congestionamento entre os widgets, e também entre o texto do widget e os limites do widget. Agora, você precisa de opções como __padx__, __pady__, __ipadx__ e __ipadx__; 84 | - O __sticky__ determina, basicamente, como o widget irá se comportar; 85 | 86 | | Sticky | Significado | 87 | | ------------- | ------------- | 88 | | W | virar à esquerda| 89 | | E | ater-se à direita | 90 | | N | limitar-se ao topo | 91 | | S | ater-se ao fundo | 92 | 93 | - Veja esse trecho de código abaixo referente as propriedades __columnspan__ e __rowspan__: 94 | 95 | ```python 96 | In[]: 97 | 98 | labelLogo.grid(row=0, column=2, columnspan=2, rowspan=2, 99 | sticky=tk.W+tk.E+tk.N+tk.S, padx=5, pady=5) 100 | ``` 101 | 102 | __columnspan=2__ e __rowspan=2__ significa que o widget tem intervalos de duas células tanto em *X* como em *Y*, começando a partir da posição do widget. 103 | 104 | 105 | ## Método place 106 | 107 | - O método __place__ coloca o widget em uma posição absoluta ou relativa na janela. Veja o trecho de codigo abaixo: 108 | 109 | ```python 110 | 111 | import tkinter as tk 112 | 113 | 114 | app = tk.Tk() 115 | app.geometry('300x300') 116 | 117 | labelA = tk.Label(app, text = "Label (0, 0)", fg="blue", bg="#FF0") 118 | labelB = tk.Label(app, text = "Label (20, 20)", fg="green", bg="#300") 119 | labelC = tk.Label(app, text = "Label (40, 50)", fg="black", bg="#f03") 120 | labelD = tk.Label(app, text = "Label (0.5, 0.5)", fg="orange", bg="#0ff") 121 | 122 | labelA.place(x=0, y=0) 123 | labelB.place(x=20, y=20) 124 | labelC.place(x=40, y=50) 125 | labelD.place(relx=0.5, rely=0.5) 126 | 127 | app.mainloop() 128 | 129 | ``` 130 | 131 | - As opções *x=* e *y=* em __place__ determinam as posições absolutas do widget, medidas em pixel. Por exemplo, *lableB.place(x=20, y=20)* significa que *labelB* é colocado na coordenada de *(20, 20)*; 132 | - O problema de utilizar uma posição absoluta é que se a janela for ampliada, outros widgets na janela podem se sobrepor; 133 | 134 | Para sanar essa questão, o método __place__ conta com a opção de posição relativa, definido da seguinte forma: 135 | 136 | ```python 137 | 138 | labelD.place(relx=0.5, rely=0.5) 139 | ``` 140 | 141 | - __relx__ e __rely__ estão na faixa entre 0.0 e 1.0. É a percentagem relativa da posição do widget para o tamanho da janela; 142 | - Por exemplo, __relx=0.5__, __rely=0.5__ significa que o widget é colocado nos 50% da largura da janela e 50% da altura da janela. 143 | 144 | -------------------------------------------------------------------------------- /Módulo-Tkinter/hello_world.md: -------------------------------------------------------------------------------- 1 | ## Hello World 2 | 3 | 4 | #### Montando a interface 5 | 6 | - Podemos criar uma interface simples com __tkinter__, da seguinte forma: 7 | 8 | ```python 9 | # importando a biblioteca. 10 | import tkinter 11 | 12 | # criando a classe principal da aplicação, onde será armazenada as configurações de execução do codigo. 13 | class Application: 14 | def __init__(self, master=None): 15 | pass 16 | 17 | root = tkinter.Tk() 18 | 19 | # Aqui passamos a variável root como parâmetro do método construtor da classe Application 20 | Application(root) 21 | 22 | # chamamos o método root.mainloop() para exibirmos a tela. 23 | root.mainloop() 24 | ``` 25 | 26 | 27 |
    28 | 29 | - Agora, vamos dar uma enfeitada na tela e adicionar nosso __hello world__ nela: 30 | 31 | ```python 32 | # importando a biblioteca. 33 | import tkinter 34 | 35 | # criando a classe principal da aplicação, onde será armazenada as configurações de execução do codigo. 36 | class Application: 37 | ''' 38 | O método __init__ representa os valores do construtor. 39 | ''' 40 | def __init__(self, master=None): 41 | self.widget1 = tkinter.Frame(master) 42 | self.widget1.pack() 43 | self.msg = tkinter.Label(self.widget1, text="Hello, world!") 44 | self.msg.pack () 45 | 46 | root = tkinter.Tk() 47 | 48 | # Aqui passamos a variável root como parâmetro do método construtor da classe Application 49 | Application(root) 50 | 51 | # chamamos o método root.mainloop() para exibirmos a tela. 52 | root.mainloop() 53 | ``` 54 | 55 | 56 | 57 | 58 | Agora que ja temos uma base, podemos ir para o [proximo passo](/Módulo-Tkinter/widgets_tkinter.md) e conhecer os atributos padrões do tkinter. 59 | -------------------------------------------------------------------------------- /Módulo-Tkinter/interfaces_graficas_tkinter.md: -------------------------------------------------------------------------------- 1 | ## Interfaces graficas com Python e Tkinter 2 | 3 | - __Tkinter__ é a biblioteca *GUI* padrão para Python. O Python, quando combinado com o Tkinter, fornece uma maneira rápida e fácil de criar aplicativos *GUI*. O __Tkinter__ fornece uma poderosa interface orientada a objetos para o kit de ferramentas *Tk GUI*. 4 | 5 | __GUI__: abreviadamente, o acrônimo __GUI__, vem do inglês *Graphical User Interface* (*interface gráfica do utilizador*). 6 | 7 | 8 | Para utilizar tal módulo do python, o mesmo precisa ser instalado em seu OS. 9 | 10 | ``` sudo apt install python-tk ``` 11 | 12 | __Obs:__ *Lembrando que, a instalação dessa biblioteca é altamente recomendada para ser usada em ambientes linux, ja que a instalação da mesma em outros OS demanda muito tempo e trabalho de configuração, que no final acabam não valendo a pena.* 13 | 14 | 15 | 16 | Após a instalação concluida, podemos ir para o [proximo passo](/Módulo-Tkinter/hello_world.md). -------------------------------------------------------------------------------- /Módulo-Tkinter/posicionamento_atributos.md: -------------------------------------------------------------------------------- 1 | ## Posicionamento e atributos 2 | 3 | 4 | - Quem ja trabalho com *CSS* ja vai ter visto falar, pelo menos, na maioria dos atributos encontrados aqui abaixo: 5 | 6 | - __Width__ – Largura do widget; 7 | - __Height__ – Altura do widget; 8 | - __Text__ – Texto a ser exibido no widget; 9 | - __Font__ – Família da fonte do texto; 10 | - __Fg__ – Cor do texto do widget; 11 | - __Bg__ – Cor de fundo do widget; 12 | - __Side__ – Define em que lado o widget se posicionará (Left, Right, Top, Bottom). 13 | 14 | Aproveitando que estamos aqui, vamos testar esses atributos: 15 | 16 | ```python 17 | In[]: 18 | 19 | import tkinter 20 | 21 | 22 | class Application: 23 | def __init__(self, master=None): 24 | self.widget1 = tkinter.Frame(master) 25 | self.widget1.pack() 26 | self.msg = tkinter.Label(self.widget1, text="Hello, world!") 27 | self.msg.pack() 28 | # Criando um botão na janela 29 | self.sair = tkinter.Button(self.widget1) 30 | # Definindo um texto para esse botão 31 | self.sair["text"] = "Sair" 32 | # Definindo a fonte e o tamanho do texto 33 | self.sair["font"] = ("Arial", "10") 34 | # Definindo o tamanho do botão 35 | self.sair["width"] = 6 36 | # Definindo a ação que o botão terá 37 | self.sair["command"] = self.widget1.quit 38 | # Definindo o posicionamento do botão na janela 39 | self.sair.pack(side=tkinter.BOTTOM) 40 | 41 | root = tkinter.Tk() 42 | Application(root) 43 | root.mainloop() 44 | 45 | ``` 46 | 47 | 48 | 49 | - Ao clicar no botão *SAIR*, a ação atribuida ao mesmo é acionada e a janela se fecha, encerrando a aplicação. -------------------------------------------------------------------------------- /Módulo-Tkinter/widgets_tkinter.md: -------------------------------------------------------------------------------- 1 | ## Widgets 2 | 3 | - Aqui veremos os widgets mais comuns quando usamos a lib tkinter, sendo eles, __frames__, __labels__, __buttons__, __checkbuttons__, __radiobuttons__, __entries__ and __comboboxes__; 4 | - Lembrando que, o tkinter tem muitos widgets, por isso iremos citar os principais e comumente usados em todas as telas de uma aplicação que utiliza essa biblioteca. 5 | 6 | 7 | ## Frames 8 | 9 | - Vamos começar pelos __frames__, que são usados, normalmente, para receber outros widgets. 10 | 11 | #### Sintaxe 12 | 13 | ```python 14 | 15 | frame = Frame( master, option, ... ) 16 | ``` 17 | 18 | #### Parametros da classe 19 | 20 | - __master__ − Representa a janela principal, ou janela pai. 21 | - __options__ − Esse parâmetro é uma lista de opções (como o proprio nome ja diz) para aperfeiçoar o widget. 22 | 23 | Acompanhe o exemplo abaixo: 24 | 25 | ```python 26 | In[]: 27 | 28 | from Tkinter import * 29 | 30 | root = Tk() 31 | frame = Frame(root) 32 | frame.pack() 33 | 34 | bottomframe = Frame(root) 35 | bottomframe.pack( side = BOTTOM ) 36 | 37 | redbutton = Button(frame, text="Red", fg="red") 38 | redbutton.pack( side = LEFT) 39 | 40 | greenbutton = Button(frame, text="Brown", fg="brown") 41 | greenbutton.pack( side = LEFT ) 42 | 43 | bluebutton = Button(frame, text="Blue", fg="blue") 44 | bluebutton.pack( side = LEFT ) 45 | 46 | blackbutton = Button(bottomframe, text="Black", fg="black") 47 | blackbutton.pack( side = BOTTOM) 48 | 49 | root.mainloop() 50 | 51 | ``` 52 | ```python 53 | Out[] 54 | ``` 55 | 56 | 57 | 58 | ## Label 59 | 60 | - Um __label__ é um widget que exibe texto ou imagens, normalmente com o qual o usuário apenas visualiza, mas sem interagir com ele. 61 | 62 | #### Sintaxe 63 | 64 | ```python 65 | 66 | lbl = Label( master, option, ... ) 67 | ``` 68 | 69 | #### Parâmetros 70 | 71 | - __master__ − Representa a janela principal, ou janela pai. 72 | - __options__ − Esse parâmetro é uma lista de opções (como o proprio nome ja diz) para aperfeiçoar o widget. 73 | 74 | Acompanhe o exemplo abaixo: 75 | 76 | ```python 77 | In[]: 78 | 79 | from tkinter import * 80 | 81 | root = Tk() 82 | var = StringVar() 83 | label = Label(root, textvariable=var, relief=RAISED) 84 | 85 | var.set("He4rt developers!!") 86 | label.pack() 87 | root.mainloop() 88 | 89 | ``` 90 | ```python 91 | Out[] 92 | ``` 93 | 94 | 95 | 96 | 97 | ## Button 98 | 99 | - Um __button__, diferentemente de um quadro ou rótulo, é muito projetado para o usuário interagir e, em particular, pressionar para executar alguma ação. 100 | 101 | #### Sintaxe 102 | 103 | ```python 104 | 105 | btn = Button(master, option=value, ...) 106 | ``` 107 | 108 | #### Parâmetros 109 | 110 | - __master__ − Representa a janela principal, ou janela pai. 111 | - __options__ − Esse parâmetro é uma lista de opções (como o proprio nome ja diz) para aperfeiçoar o widget. 112 | 113 | 114 | Exemplo: 115 | 116 | ```python 117 | In[]: 118 | 119 | import tkinter 120 | import tkinter.messagebox 121 | 122 | 123 | top = tkinter.Tk() 124 | 125 | def helloCallBack(): 126 | tkinter.messagebox.showinfo(message="Python4Noobs.") 127 | 128 | B = tkinter.Button(top, text ="Clique aqui!", command=helloCallBack) 129 | 130 | B.pack() 131 | top.mainloop() 132 | 133 | ``` 134 | ```python 135 | Out[] 136 | ``` 137 | 138 | 139 | 140 | 141 | ## Checkbutton 142 | 143 | - Os __checkbuttons__ são como um botão comum, exceto que o usuário não apenas pode pressioná-lo, o que invocará um retorno de chamada de comando, mas também possui um valor binário de algum tipo (ou seja, uma alternância). 144 | 145 | #### Sintaxe 146 | 147 | ```python 148 | 149 | cb = Checkbutton(master, option, ...) 150 | ``` 151 | 152 | #### Parâmetros 153 | 154 | - __master__ − Representa a janela principal, ou janela pai. 155 | - __options__ − Esse parâmetro é uma lista de opções (como o proprio nome ja diz) para aperfeiçoar o widget. 156 | 157 | 158 | Exemplo: 159 | 160 | ```python 161 | In[]: 162 | 163 | from tkinter import * 164 | import tkinter 165 | 166 | 167 | top = tkinter.Tk() 168 | CheckVar1 = IntVar() 169 | CheckVar2 = IntVar() 170 | C1 = Checkbutton(top, text = "Python4noobs", variable = CheckVar1, \ 171 | onvalue = 1, offvalue = 0, height=5, \ 172 | width = 20) 173 | C2 = Checkbutton(top, text = "anything else", variable = CheckVar2, \ 174 | onvalue = 1, offvalue = 0, height=5, \ 175 | width = 20) 176 | C1.pack() 177 | C2.pack() 178 | top.mainloop() 179 | 180 | ``` 181 | ```python 182 | Out[] 183 | ``` 184 | 185 | 186 | 187 | https://tkdocs.com/tutorial/widgets.html 188 | https://www.tutorialspoint.com/python/tk_frame.html 189 | 190 | 191 | ## Radiobutton 192 | 193 | - Um __radiobutton__ lhe permite escolher uma opção entre varias, mutuamente exclusivas. 194 | 195 | #### Sintaxe 196 | 197 | ```python 198 | 199 | rb = Radiobutton(master, option, ...) 200 | ``` 201 | 202 | #### Parâmetros 203 | 204 | - __master__ − Representa a janela principal, ou janela pai. 205 | - __options__ − Esse parâmetro é uma lista de opções (como o proprio nome ja diz) para aperfeiçoar o widget. 206 | 207 | 208 | Exemplo: 209 | 210 | ```python 211 | In[]: 212 | 213 | from tkinter import * 214 | 215 | 216 | def sel(): 217 | selection = "Selecione o conteúdo " + str(var.get()) 218 | label.config(text = selection) 219 | 220 | root = Tk() 221 | var = IntVar() 222 | R1 = Radiobutton(root, text="Python4noobs", variable=var, value=1, 223 | command=sel) 224 | R1.pack( anchor = W ) 225 | 226 | R2 = Radiobutton(root, text="Cpp4noobs", variable=var, value=2, 227 | command=sel) 228 | R2.pack( anchor = W ) 229 | 230 | R3 = Radiobutton(root, text="PHP4noobs", variable=var, value=3, 231 | command=sel) 232 | R3.pack( anchor = W) 233 | 234 | label = Label(root) 235 | label.pack() 236 | root.mainloop() 237 | ``` 238 | ```python 239 | Out[] 240 | ``` 241 | 242 | 243 | 244 | 245 | ## Entry 246 | 247 | - Um __Entry__ apresenta ao usuário um campo de texto de linha única que ele pode usar para digitar um valor. Podem ser praticamente qualquer coisa: nome, cidade, senha, número do seguro social e assim por diante. 248 | 249 | 250 | #### Sintaxe 251 | 252 | ```python 253 | 254 | entry = Entry(master, option, ...) 255 | ``` 256 | 257 | #### Parâmetros 258 | 259 | - __master__ − Representa a janela principal, ou janela pai. 260 | - __options__ − Esse parâmetro é uma lista de opções (como o proprio nome ja diz) para aperfeiçoar o widget. 261 | 262 | 263 | Exemplo: 264 | 265 | ```python 266 | In[]: 267 | 268 | from tkinter import * 269 | 270 | 271 | top = Tk() 272 | L1 = Label(top, text="Nome da empresa: ") 273 | L1.pack( side = LEFT) 274 | E1 = Entry(top, bd =5) 275 | E1.pack(side = RIGHT) 276 | 277 | top.mainloop() 278 | ``` 279 | ```python 280 | Out[] 281 | ``` 282 | 283 | 284 | 285 | 286 | ## Combobox 287 | 288 | - Os __combobox__ combina o componente __entry__ com uma lista de opções disponíveis para o usuário. Isso permite que você escolha um conjunto de valores que você forneceu. 289 | 290 | 291 | #### Sintaxe 292 | 293 | ```python 294 | 295 | combobox = Combobox(master, option, ...) 296 | ``` 297 | 298 | #### Parâmetros 299 | 300 | - __master__ − Representa a janela principal, ou janela pai. 301 | - __options__ − Esse parâmetro é uma lista de opções (como o proprio nome ja diz) para aperfeiçoar o widget. 302 | 303 | 304 | Exemplo: 305 | 306 | ```python 307 | In[]: 308 | 309 | from tkinter import * 310 | 311 | 312 | top = Tk() 313 | L1 = Label(top, text="Nome da empresa: ") 314 | L1.pack( side = LEFT) 315 | E1 = Entry(top, bd =5) 316 | E1.pack(side = RIGHT) 317 | 318 | top.mainloop() 319 | ``` 320 | ```python 321 | Out[] 322 | ``` 323 | 324 | -------------------------------------------------------------------------------- /POO/Oque-é-poo.md: -------------------------------------------------------------------------------- 1 | # O que é POO 2 | 3 | POO(programação orientada a objetos) é um paradigma de programação que tem como objetivo deixar o código, durante a fase desenvolvimento, mais inteligível e seguro. 4 | 5 | ## Pilares da POO 6 | Abstração: É a capacidade de estipular características(atributos) e ações(métodos) a um objeto. 7 |
    8 |
    9 | Encapsulamento: O objetivo desta técnica é esconder os atributos do objeto, tornando assim sua aplicação mais segura. 10 |
    11 |
    12 | Herança: O objetivo desta técnica é de poder reutilizar o código que já foi escrito, fazendo com que uma classe filha herde os atributos e métodos da classe mãe, assim, poupando tempo de desenvolvimento e linhas de código mais rápidas e menos volumosas em disco. 13 |
    14 |
    15 | Polimorfismo: O objetivo desta técnica é reutilizar métodos e atributos. 16 | 17 | OBS: No python, encapsulamento não é um assunto tão abordado, então, não haverá um .md para esta técnica. 18 | 19 | ### Algumas definições 20 | Objeto: É a instância de uma classe. 21 |
    22 |
    23 | Atributos: São as variáveis de uma classe. 24 |
    25 |
    26 | Métodos: São funções de uma classe. 27 | 28 | OBS: Estes arquivos, forneceram uma visão bem superficial sobre POO. 29 | 30 | ### Bom saber 31 | 32 | - Em Python, todo valor é na verdade um objeto. Seja ele uma lista, um inteiro ou uma string, tanto faz. Um script manipula esses objetos e/ou seus métodos a modo de realizar uma ação. Por exemplo, em uma *class Pessoa* o nome *Wendrew* é um objeto, a altura *1,85* também é um objeto e assim sucessivamente. Uma classe em python é um construtor de objetos e não apenas uma declaração qualquer. 33 | 34 | - Uma classe constrói objetos do tipo *type*, permitindo assim que criemos objetos desse tipo recém criado, veja: 35 | 36 | ```python 37 | [IN]: 38 | 39 | class Teste(object): pass 40 | print(type(Teste)) 41 | ``` 42 | 43 | ```python 44 | [OUT]: 45 | 46 | 47 | ``` 48 | 49 | Isso não é muito diferente de outras linguagens de programação, mas a magica ainda esta por vir, pois tendo criado o *objeto* com a declaração *class* podemos acessa-lo como qualquer outro objeto, inclusive acrescentar atributos a ele: 50 | 51 | ```python 52 | [IN]: 53 | 54 | Teste.x = 0 55 | print(Teste.x) 56 | 57 | ``` 58 | 59 | ```python 60 | [OUT]: 61 | 62 | 0 63 | ``` 64 | 65 | Perceba que acrescentamos o atributo *x* ao objeto *Teste*, e isso faz com que as instancias desse objeto passe a ter esse atributo. -------------------------------------------------------------------------------- /POO/Trabalhando_com_objetos.md: -------------------------------------------------------------------------------- 1 | # Trabalhando com objetos 2 | 3 | Como vimos nos readmes anteriores, um objeto, é uma classe quando instanciada.
    4 | EXEMPLO:
    5 | 6 | 7 | 8 | #Classe pc 9 | class pc: 10 | #Método inicializador 11 | def __init__(self, placaMae, cpu, memRam, hd, fonte, placaVideo): 12 | self.placaMae = placaMae 13 | self.cpu = cpu 14 | self.memRam = memRam 15 | self.hd = hd 16 | self.fonte = fonte 17 | self.placaVideo = placaVideo 18 | 19 | #Método 20 | def ligar(self): 21 | return "Ligando..." 22 | 23 | #Inicializando a classe 24 | #Objeto pc 25 | MeuPc = pc("GigaByte","Intel","Corsair","80GB","500w","Nvidia") 26 | 27 | 28 | 29 | OBS1: Essa classe, pode ter funções, que quando englobadas a ela se tornam métodos como o método ligar. 30 | 31 | OBS2: Já quando a classe possui variáveis, denominamo-as como atributos. 32 | 33 | ## Acessando os atributos e métodos do objeto 34 |
    35 | Vamos agora acessar os atributos e métodos do objeto meu PC.
    36 | Digite no seu computador a classe PC e inicialize ela. 37 |
    38 |
    39 | Primeiro eu quero saber a marca da placa mãe do meu PC. 40 | Para isso preciso exibir na tela, através do comando print o atributo do objeto MeuPc, placaMae. 41 |
    42 |
    43 | 44 | 45 | print("A placa mãe do seu PC é: ",MeuPc.placaMae) 46 | 47 | 48 | Saída: 49 | 50 | 51 | 52 | A placa mãe do seu PC é: GigaByte 53 | 54 | 55 | 56 | Eu quero experimentar uma nova configuração para o meu PC. 57 | 58 | Então, vou mudar o atributo cpu. 59 | 60 | 61 | 62 | MeuPc.cpu = "AMD" 63 | print("O processador do seu PC é: ",MeuPc.cpu) 64 | 65 | 66 | Saída: 67 | 68 | 69 | O processador do seu PC é: AMD 70 | 71 | 72 | 73 | Agora eu to afim de jogar alguma coisa, quero ligar meu PC. 74 | 75 | Basta nós usarmos o método ligar do nosso objeto. 76 | 77 | 78 | 79 | print(MeuPc.ligar()) 80 | 81 | Saída: 82 | 83 | 84 | 85 | Ligando... 86 | 87 | 88 | 89 | Por último, mas não menos importante eu quero saber toda a configuração do meu PC, em apenas um print. 90 | 91 | Para isso acontecer usaremos o __dict__ que é: um atributo da classe. 92 | 93 | 94 | 95 | print(MeuPc.__dict) 96 | 97 | 98 | Saída: 99 | 100 | 101 | {'placaMae': 'GigaByte', 'cpu': 'Intel', 'memRam': 'Corsair', 'hd': '80GB', 'fonte': '500w', 'placaVideo': 'Nvidia'} 102 | 103 | 104 | Temos todos os atributos do objeto MeuPc, em um dicionário quando utilizamos o atributo __dict__. 105 | 106 | ## Considerações finais. 107 | 108 | Agora, você possui uma visão básica de como trabalhar com um objeto em python. 109 |
    110 | Pule para os próximos readmes e bons estudos. 111 |
    112 |
    113 | OBS: Qualquer dúvida relacionada ao contéudo apresentado neste repositório.
    114 | Acesse o discord da heart developers, que a comunidade irá fornecer o suporte necessário, para você.
    115 | Discord: discord 116 |
    -------------------------------------------------------------------------------- /POO/class.md: -------------------------------------------------------------------------------- 1 | # Classes 2 | 3 | - ***Atributo x Método:*** 4 | - ***Atributo:*** 5 | 6 | Podemos dizer de forma grosseira que o atributo de uma classe é uma variável de uma classe. 7 | ```python3 8 | class Personagem: 9 | mana = 200 10 | ``` 11 | - ***Método:*** 12 | 13 | Podemos dizer de forma grosseira que o método de uma classe é uma função de uma classe. 14 | ```python3 15 | class Personagem: 16 | def andar(self) -> None: 17 | pass 18 | ``` 19 | 20 | - ***"self":*** 21 | 22 | O uso do "self" como primeiro parámetro de um método é convencional segundo a [PEP8](https://peps.python.org/pep-0008/). 23 | O self é usado em classes para indicar que está referenciado alguma coisa do próprio objeto (sejam eles atributos ou métodos) - na verdade, o self é o próprio objeto em si. 24 | ```python3 25 | class Personagem: 26 | def __init__(self, name: str) -> None: 27 | self.name = name 28 | 29 | def get_name(self) -> str: 30 | return self.name 31 | ``` 32 | 33 | - ***Métodos especias:*** 34 | 35 | - ***\_\_init__:*** 36 | 37 | É um método chamado toda vez q a classe é instanciada. 38 | 39 | ```python3 40 | class Personagem: 41 | def __init__(self, name: str) -> None: 42 | # método construtor: ele irá iniciar toda vez q a classe for chamada. 43 | self.name = name 44 | 45 | ``` 46 | 47 | 48 | - ***\_\_str__:*** 49 | 50 | Usado para retornar uma representação de string de um objeto. 51 | - sem o método \_\_str__: 52 | 53 | ```python3 54 | class Personagem: 55 | pass 56 | ``` 57 | ` 58 | out: 59 | ` 60 | 61 | ![not_str_method](/pictures/classes/not_str_method.png) 62 | - com o método \_\_str__: 63 | ```python3 64 | class Personagem: 65 | def __str__(self) -> str: 66 | return f"This is a class" 67 | ``` 68 | ` 69 | out: 70 | ` 71 | 72 | ![str_method](/pictures/classes/str_method.png) 73 | 74 | - ***Instanciando uma classe:*** 75 | 76 | Para instanciarmos uma classe, basta fazermos como qual uma variável. 77 | ```python3 78 | class Personagem: 79 | def __init__(self, name: str) -> None: 80 | self.name = name 81 | 82 | def print_name(self) -> str: 83 | print(self.name) 84 | 85 | ``` 86 | ` 87 | In: 88 | ` 89 | 90 | ![instance_in](/pictures/classes/instance_in.png) 91 | 92 | ` 93 | Out: 94 | ` 95 | 96 | ![instance_out](/pictures/classes/instance_out.png) 97 | -------------------------------------------------------------------------------- /POO/heranca.md: -------------------------------------------------------------------------------- 1 | # Herança 2 | 3 | Já vimos anteriormente a definição de Herança, seguiremos para a parte prática agora. 4 | 5 | ## Hora do código 6 | 7 | Primeiros passos: 8 |
      9 |
    • Abra o seu editor de código ou IDE
      • 10 |
    • Crie um arquivo .py, com o nome poo
      • 11 |
    • Vamos começar!!!
      • 12 |
    13 | 14 | Considere que você está desenvolvendo um jogo eletrônico de corrida entre carros e motos. Em que, o objeto é veículo e possui os atributos: rodas, cor e modelo e os métodos: andar e frear.
    15 | Então, criemos agora o objeto, seus atributos e métodos. 16 | 17 | 18 | #Classe veiculo 19 | class veiculo(): 20 | #Método inicializador 21 | def __init__(self,rodas,cor,modelo): 22 | #Atributos 23 | self.rodas = rodas 24 | self.cor = cor 25 | self.modelo = modelo 26 | 27 | #Método andar 28 | def andar(self): 29 | return "Andando..." 30 | #Método frear 31 | def freando(self): 32 | return "Freando" 33 | 34 | 35 | 36 | Com a classe veiculo, pronta precisamos agora aplicar a herança nas classes no moto e carro, que serão os objetos usados no nosso game. 37 | 38 | 39 | 40 | #Classe veiculo 41 | class veiculo(): 42 | #Método inicializador 43 | def __init__(self,rodas,cor,modelo): 44 | #Atributos 45 | self.rodas = rodas 46 | self.cor = cor 47 | self.modelo = modelo 48 | 49 | #Método andar 50 | def andar(self): 51 | return "Andando..." 52 | #Método frear 53 | def frear(self): 54 | return "Freando" 55 | 56 | #Classe carro 57 | class carro(veiculo): 58 | pass 59 | 60 | #Classe moto 61 | class moto(veiculo): 62 | pass 63 | 64 | 65 | Agora, para conferirmos a herança funcionando crie um outro arquivo .py de qualquer nome.
    66 | nesse arquivo você vai instanciar os objetos carro e moto, e usar seus seus métodos. 67 | 68 | 69 | 70 | #Script que contém as classes 71 | import poo 72 | 73 | #Instância do objeto carro 74 | carro1 = poo.carro(4,"vermelha","Ferrari") 75 | #Instância do objeto moto 76 | moto1 = poo.moto(2,"preta","Yamaha") 77 | #Usando o método andar do objeto carro1 78 | print(carro1.andar()) 79 | 80 | #Usando o método frear do objeto carro1 81 | print(carro1.frear()) 82 | 83 | #Usando o método andar do objeto moto1 84 | print(moto1.andar()) 85 | 86 | #Usando o método frear do objeto moto1 87 | print(moto1.frear()) 88 | 89 | 90 | 91 | Execute o script com as instâncias e observe que a herança funcionou 92 | e assim não precisamos digitar o método andar para as classes moto e carro, o mesmo ocorreu para o método frear, pois eles foram ,HERDADOS da classe mãe veiculo. -------------------------------------------------------------------------------- /POO/pictures/classes/instance_in.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/POO/pictures/classes/instance_in.png -------------------------------------------------------------------------------- /POO/pictures/classes/instance_out.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/POO/pictures/classes/instance_out.png -------------------------------------------------------------------------------- /POO/pictures/classes/not_str_method.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/POO/pictures/classes/not_str_method.png -------------------------------------------------------------------------------- /POO/pictures/classes/str_method.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/POO/pictures/classes/str_method.png -------------------------------------------------------------------------------- /POO/polimorfismo.md: -------------------------------------------------------------------------------- 1 | # Polimorfismo 2 | 3 | Já vimos anteriormente a definição de polimorfismo, seguiremos para a parte prática agora. 4 | 5 | ## Hora do código 6 | 7 | Peguemos como exemplo os objetos cão, gato e galinha, todos herdeiros da classe mãe animal, esses objetos tem um método em comum que é emitir um som, porém, os sons desses animais são diferentes, afinal, um cachorro late, um gato mia e uma galinha cacareja, então os retornos do método emitir som devem ser diferentes. Para resolver esse problema usaremos o polimorfismo. 8 | 9 |
      10 |
    • Abra seu editor.
      • 11 |
    • Crie um arquivo .py de nome poo, onde ficaram as classes.
      • 12 |
    • Crie outro arquivo no nome que desejar, este script conterá as instâncias dos objetos.
      • 13 |
    • Vamos começar
      • 14 |
    15 | 16 | 17 | 18 | #Classe mãe animal 19 | class animal(): 20 | def emitir_som(self): 21 | pass 22 | 23 | #Classe cao 24 | class cao(animal): 25 | #Método em que o polimorfismo é aplicado 26 | def emitir_som(self): 27 | return "Au Au Au" 28 | 29 | #Classe gato 30 | class gato(animal): 31 | #Método em que o polimorfismo é aplicado 32 | def emitir_som(self): 33 | return "Miau Miau Miau" 34 | 35 | #Classe galinha 36 | class galinha(animal): 37 | #Método em que o polimorfismo é aplicado 38 | def emitir_som(self): 39 | return "Cocoricó" 40 | 41 | 42 | 43 | Agora, com as classes prontas vamos instanciar nossos objetos, no outro script. 44 | 45 | 46 | 47 | #Importação do script com as classes 48 | import poo 49 | 50 | #Instâncias 51 | cao = poo.cao() 52 | gato = poo.gato() 53 | galinha = poo.galinha() 54 | 55 | #Exibindo o retorno do método emitir_som 56 | print(cao.emitir_som()) 57 | print(gato.emitir_som()) 58 | print(galinha.emitir_som()) 59 | 60 | Por fim, com os dois scripts basta executar o script com as instâncias e visualizar como ficou. -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 

    2 | python_logo_extended 3 |

    4 | 5 |

    6 | Como todos os conteúdos da he4rt, esse tem o objetivo de compartilhar conhecimento 7 | de forma acessível e gratuita, atingindo todos os publicos. 8 |

    9 | 10 | ## ROADMAP 11 | 12 | ### 1. Introdução 13 | 14 | [Motivação do projeto](/Introdução/motivacao.MD)
    15 | [Introdução](/Introdução/introducao.MD) 16 | 17 | ### 2. Instalação 18 | 19 | [Windows](/Instalação/Windows.md)
    20 | [Linux](/Instalação/Linux.md)
    21 | [MacOS](/Instalação/MacOS.md) 22 | 23 | ### 3. Estrutura de dados em python 24 | 25 | [Introdução a estrutura de dados em python](/Tipos/introducao_estrutura_dados.md)
    26 | [String](/Tipos/strings.md)
    27 | [Numbers](/Tipos/numbers.md)
    28 | [Listas](/Tipos/listas.md)
    29 | [Dicionarios](/Tipos/dicionarios.md)
    30 | [Tuplas](/Tipos/tuplas.md)
    31 | [Sets](/Tipos/sets.md)
    32 | [Booleanos](/Tipos/booleanos.md)
    33 | 34 | ### 4. Estruturas de condição 35 | 36 | [if e else](/Controle-de-fluxo/if_else.md)
    37 | [for](/Controle-de-fluxo/for.md)
    38 | [while](/Controle-de-fluxo/while.md)
    39 | [List Comprehensions](/Controle-de-fluxo/list_comprehensions.md) 40 | 41 | ### 5. Expressões 42 | 43 | [Expressões aritméticas](/Expressões/expressões_aritmeticas.md)
    44 | [Comparações](/Expressões/comparacoes.md)
    45 | [Comparações](/Expressões/expressoes_condicionais.md)
    46 | [Introdução](/Expressões/introdução.md)
    47 | 48 | ### 6. Instruções simples 49 | 50 | [Expressão assert](/Instruções-simples/assert.md)
    51 | [Expressão pass](/Instruções-simples/pass.md)
    52 | [Expressão del](/Instruções-simples/del.md)
    53 | [Expressão return](/Instruções-simples/return.md)
    54 | [Expressão raise](/Instruções-simples/raise.md)
    55 | [Expressão global](/Instruções-simples/global.md)
    56 | [Expressão nonlocal](/Instruções-simples/nonlocal.md) 57 | 58 | ### 7. Manipulando arquivos 59 | 60 | [Entendendo a manipulação de arquivos](/Manipulando-arquivos/entendendo_manipulacao_arquivos.md)
    61 | [Lendo arquivos](/Manipulando-arquivos/lendo_arquivos.md)
    62 | [Criando e abrindo arquivos](/Manipulando-arquivos/criando_abrindo_arquivos.md)
    63 | [Escrevendo em arquivos](/Manipulando-arquivos/escrevendo_em_arquivos.md) 64 | 65 | ### 8. Módulo TKinter (interface grafica desktop) 66 | 67 | [Interfaces Gráficas com Tk](/Módulo-Tkinter/interfaces_graficas_tkinter.md)
    68 | [Hello World](/Módulo-Tkinter/hello_world.md)
    69 | [Widgets Tkinter](/Módulo-Tkinter/widgets_tkinter.md)
    70 | [Gerenciamento da geometria](/Módulo-Tkinter/gerenciamento_geometria-.md) 71 | 72 | ### 9. Gerando gráficos com python 73 | 74 | [Como isso funciona?](/Gerando-gráficos/como_funciona.md)
    75 | [Gerando grafico simples](/Gerando-gráficos/grafico_simples.md)
    76 | [Aprimorando graficos](/Gerando-gráficos/aprimorando_graficos.md)
    77 | [PieChart](/Gerando-gráficos/pie_chart.md)
    78 | [BarChart](/Gerando-gráficos/grafico_barras.md)
    79 | [Salvando gráfico em um arquivo](/Gerando-gráficos/salvando_grafico_arquivo.md) 80 | 81 | ### 10. Trabalhando com API's 82 | 83 | [Biblioteca requests](/Trabalhando-com-API's/biblioteca_requests.md)
    84 | [Introdução ao conceito de API's](/Trabalhando-com-API's/introducao_apis.md)
    85 | [Headers](/Trabalhando-com-API's/headers.md)
    86 | [Conteúdo da resposta](/Trabalhando-com-API's/Conteúdo-da-resposta)
    87 | [Resposta binária](/Trabalhando-com-API's/Conteúdo-da-resposta/resposta_binaria.md)
    88 | [Resposta JSON](/Trabalhando-com-API's/Conteúdo-da-resposta/resposta_json.md)
    89 | [Resposta crua](/Trabalhando-com-API's/Conteúdo-da-resposta/resposta_crua.md)
    90 | [Realizando requisições](/Trabalhando-com-API's/Realizando-requisições)
    91 | [GET](/Trabalhando-com-API's/Realizando-requisições/get.md)
    92 | [POST](/Trabalhando-com-API's/Realizando-requisições/post.md)
    93 | [UPDATE](/Trabalhando-com-API's/Conteúdo-da-resposta/update.md)
    94 | [DELETE](/Trabalhando-com-API's/Conteúdo-da-resposta/delete.md)
    95 | [Cookies](/Trabalhando-com-API's/cookies.md)
    96 | [Timeouts](/Trabalhando-com-API's/timeouts.md)
    97 | [Erros e Exceções](/Trabalhando-com-API's/erros_excecoes.md) 98 | 99 | ### 11. POO 100 | 101 | [O que é POO](/POO/Oque-é-poo.md)
    102 | [Herança](/POO/heranca.md)
    103 | [Polimorfismo](/POO/polimorfismo.md)
    104 | [Trabalhando com objetos](/POO/Trabalhando_com_objetos.md) 105 | 106 | ### 12. Testes unitários 107 | [Introdução](/Testes-Unitários/Introdução.md)
    108 | [Funções](/Testes-Unitários/testes-funções.md)
    109 | [Métodos](/Testes-Unitários/testes-métodos.md) 110 | 111 | ### 13. Extras 112 | 113 | [Bloco de notas com tkinter](/Extras/bloco_de_notas.md)
    114 | [Assistente virtual](/Extras/Assistente_Virtual.md)
    115 | [Calculadora](/Extras/calculadora.md)
    116 | [Keywords](/Extras/keywords.md)
    117 | [Magic Methods](/Extras/magic_methods.md)
    118 | 119 | 120 | ## Autores & Contribuidores 121 | 122 | - **Wendrew Oliveira** - _Python developer_ - [Github](https://github.com/wendrewdevelop) - [Twitter](https://twitter.com/dreeeew_s) 123 | 124 | - **Matheus Morata** - [Github](https://github.com/MatheusMorata)- [Twitter](https://twitter.com/M4theus_Morata) 125 | 126 |

    Made with 💜

    127 | -------------------------------------------------------------------------------- /Testes-Unitários/Introdução.md: -------------------------------------------------------------------------------- 1 | # Introdução aos testes unitários 2 | 3 | ## O que são testes unitários? 4 | 5 | Teste unitário, é o nível mais baixo de teste de software. Ele é responsável por testar os menores componentes(Métodos, funções e classes) de um sistema. 6 | 7 | ## Por que fazer testes? 8 | 9 | - Aumenta a qualidade do software 10 | - Diminui a quantidade de bugs 11 | - Ganho de tempo na produção de um software 12 | 13 | ## O que é necessário para realizar testes unitários? 14 | 15 | Para realizar testes unitários, em nossos programas python usaremos a biblioteca pytest. 16 | 17 | Comando de instalação: 18 | 19 | 20 | 21 | pip install pytest 22 | -------------------------------------------------------------------------------- /Testes-Unitários/assets/terminal1.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Testes-Unitários/assets/terminal1.jpeg -------------------------------------------------------------------------------- /Testes-Unitários/assets/terminal2.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Testes-Unitários/assets/terminal2.jpeg -------------------------------------------------------------------------------- /Testes-Unitários/assets/terminal3.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Testes-Unitários/assets/terminal3.jpeg -------------------------------------------------------------------------------- /Testes-Unitários/assets/terminal4.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Testes-Unitários/assets/terminal4.jpeg -------------------------------------------------------------------------------- /Testes-Unitários/testes-funções.md: -------------------------------------------------------------------------------- 1 | # Realizando testes em funções 2 | 3 | Para começarmos é necessário que você: 4 | 5 | - Abra seu editor de código favorito 6 | - Crie dois arquivos .py com os nomes: teste e teste2 7 | - Salva os dois arquivos no mesmo diretório 8 | - Abra o diretório dos arquivos pelo terminal 9 | - Certifique-se que a biblioteca pytest está instalada 10 | 11 | ## Hora do código 12 | 13 | No script de nome teste crie uma simples função de soma. 14 | 15 | 16 | 17 | def soma(a,b): 18 | return a+b 19 | 20 | 21 | Agora, no script teste2 iremos realizar nosso primeiro teste. 22 |
    23 |
    24 | OBS: Certifique-se, que os dois .py estão nos mesmo diretório. 25 | 26 | 27 | #Importando a biblioteca pytest 28 | import pytest 29 | #Importando o .py com a função de soma 30 | import teste 31 | 32 | 33 | #primeiro teste 34 | def teste1(): 35 | assert 5 == teste.soma(3,2) 36 | 37 | 38 | Salve os dois .py e execute via terminal o teste2. 39 | 40 | 41 | 42 | pytest teste2.py 43 | 44 | Essa será sua saída: 45 |
    46 |
    47 | 48 |
    49 | Podemos, vê que nossa função de soma passou no teste, afinal três mais dois resulta realmente em cinco. 50 | 51 | ## Teste com erro 52 | 53 | Agora no teste2, vamos escrever um teste com erro. 54 | 55 | 56 | 57 | #Importando a biblioteca pytest 58 | import pytest 59 | #Importando o .py com a função de soma 60 | import teste 61 | 62 | 63 | #primeiro teste 64 | def teste1(): 65 | assert 5 == teste.soma(3,2) 66 | 67 | #teste com erro 68 | def teste2(): 69 | assert 6 == teste.soma(2,2) 70 | 71 | 72 | Salve o teste2.py
    73 | E excute via terminal novamente. 74 |
    75 |
    76 | 77 | 78 | Um teste não passou e outro sim, ou seja, foi uma saída e esperada nossos testes funcionaram. -------------------------------------------------------------------------------- /Testes-Unitários/testes-métodos.md: -------------------------------------------------------------------------------- 1 | # Realizando testes em métodos 2 | 3 | Para começarmos é necessário que você: 4 | 5 | - Abra seu editor de código favorito 6 | - Crie dois arquivos .py com os nomes: teste e teste2 7 | - Salva os dois arquivos no mesmo diretório 8 | - Abra o diretório dos arquivos pelo terminal 9 | - Certifique-se que a biblioteca pytest está instalada 10 | 11 | ## Hora do código 12 | 13 | No arquivo teste criaremos o método que será testado. 14 | 15 | OBS: Lembre-se, que o método é a função de uma classe, então, para isso criaremos uma classe. 16 | 17 | 18 | 19 | #Classe teste 20 | class teste(): 21 | 22 | #Método de multiplicação da classe teste 23 | def metodo_multiplicacao(self,a,b): 24 | return a * b 25 | 26 | 27 | Agora no arquivo teste2 criaremos os testes. 28 | 29 | 30 | 31 | #Importando a biblioteca pytest 32 | import pytest 33 | #Importando o .py com a função de soma 34 | import teste 35 | 36 | #objeto da classe teste 37 | obj = teste.teste() 38 | 39 | #primeiro teste 40 | def teste1(): 41 | assert 10 == obj.metodo_multiplicacao(2,5) 42 | 43 | 44 | Agora, basta executar o teste2 e observar o resultado. 45 |
    46 |
    47 | 48 |
    49 |
    50 | O teste passou com sucesso, afinal, dois vezes cinco é realmente dez. 51 | 52 | ## Teste com erro 53 | 54 | Vamos realizar agora um teste com erro. 55 | 56 | 57 | 58 | #teste com erro 59 | def teste2(): 60 | assert 11 == obj.metodo_multiplicacao(3,5) 61 | 62 | Salve e execute o arquivo teste2. 63 |
    64 |
    65 | 66 |
    67 |
    68 | Podemos ver que um teste passou e outro não, então, tivemos o resultado esperado. -------------------------------------------------------------------------------- /Tipos/booleanos.md: -------------------------------------------------------------------------------- 1 | # Booleanos 2 |

    Booleano, são os valores True (verdadeiro) ou False (falso). Esses valores são úteis para representar, o resultado de uma comparação.

    3 | 4 | OBS1: Antes dos exemplos precisamos conferir as tabelas verdade. 5 | 6 | |and | A | B | 7 | |-----|-----|-----| 8 | |True |True |True | 9 | |False|False|False| 10 | |False|True |False| 11 | |False|False|True | 12 |
    13 | OBS2: Observe que quando usamos AND uma preposição só é verdadeira quando as duas condições forem verdadeiras.
    14 | 15 | 16 | |or | A | B | 17 | |-----|-----|-----| 18 | |True |True |True | 19 | |False|False|False| 20 | |True |True |False| 21 | |True |False|True | 22 | 23 |
    24 | OBS2: Observe que quando usamos OR uma preposição só é falsa quando as duas condições forem falsas. 25 | 26 | ## Exemplos 27 | 28 | 29 | 30 | a = True 31 | b = False 32 | 33 | c = a and b 34 | print(c) 35 | c = a or b 36 | print(c) 37 | c = a and a 38 | print(c) 39 | c = a or a 40 | print(c) 41 | c = b or b 42 | print(c) 43 | 44 | Saída 45 | 46 | 47 | False 48 | True 49 | True 50 | True 51 | False 52 | 53 | 54 | ## Finalizando 55 | Você agora possui conhecimento sobre oque são os booleanos e como eles funcionam, em python. Prossiga nos seus estudos e pule para o próximo readme. 56 |
    57 |
    58 | OBS: Qualquer dúvida relacionada ao contéudo apresentado neste repositório.
    59 | Acesse o discord da heart developers, que a comunidade irá fornecer o suporte necessário, para você.
    60 | Discord: discord 61 |
    62 | -------------------------------------------------------------------------------- /Tipos/dicionarios.md: -------------------------------------------------------------------------------- 1 | # Dicionários 2 | 3 |

    Os dicionários, são estruturas de dados envolvidas por chaves {} e identificadas por uma key.

    4 | 5 | ## Exemplos 6 | 7 | 8 | 9 | #nome_dicionario = {"key":"valor"} 10 | #nome_dicionario = {key:valor} 11 | telefones = {"Roberval":"3344-9090","Mônica":"1331-2020"} 12 | print("Número do Roberval: ",telefones["Roberval"]) 13 | print("Número da Mônica: ",telefones["Mônica"]) 14 | 15 | Saída 16 | 17 | 18 | Número do Roberval: 3344-9090 19 | Número da Mônica: 1331-2020 20 | 21 | 22 | ## Métodos 23 | 24 | Os dicionários, possuem um método que exibe uma resposta caso não seja encontrada a key. 25 | 26 | 27 | 28 | print(telefones.get("Antonio","Contato inexistente")) 29 | 30 | Saída 31 | 32 | 33 | Contato inexistente 34 | 35 | 36 | ## Adicionando valores 37 | 38 |

    Vamos adicionar um novo número a nossa lista telefônica.

    39 | 40 | 41 | 42 | telefones["Yudi"] = "4002-8922" 43 | print(telefones) 44 | 45 | 46 | Saída 47 | 48 | 49 | {'Roberval': '3344-9090', 'Mônica': '1331-2020', 'Yudi': '4002-8922'} 50 | 51 | Pronto, o número do Yudi foi adicionado. 52 | 53 | ## Removendo valores 54 | 55 |

    Vamos remover o número do Roberval agora

    56 | 57 | 58 | 59 | del telefones["Roberval"] 60 | print(telefones) 61 | 62 | Saída 63 | 64 | 65 | {'Mônica': '1331-2020', 'Yudi': '4002-8922'} 66 | 67 | 68 | ## Finalizando 69 | Você agora possui conhecimento sobre como funcionam os dicionários, em python. Prossiga nos seus estudos e pule para o próximo readme. 70 |
    71 |
    72 | OBS: Qualquer dúvida relacionada ao contéudo apresentado neste repositório.
    73 | Acesse o discord da heart developers, que a comunidade irá fornecer o suporte necessário, para você.
    74 | Discord: discord 75 |
    -------------------------------------------------------------------------------- /Tipos/introducao_estrutura_dados.md: -------------------------------------------------------------------------------- 1 |

    Introdução a estrutura de dados em Python

    2 | Uma estrutura de dados, é uma coleção tanto de valores quanto de operações.
    3 | É uma implementação concreta de um tipo abstrato de dado ou um tipo de dado básico ou primitivo.
    4 | Um pouco complexo não é?
    5 | Vamos ver alguns exemplos de estrutura de dados.
    6 |

    Exemplos de estruturas de dados

    7 |

    Listas

    8 |

    A lista é a estrutura de dados mais básica do Python ela armazena os dados em sequência,estes dados podem ser(Strings,números inteiros,números de ponto-flutuante e dados booleanos).Cada elemento na lista possui uma posição, denominada de índice. O primeiro elemento da esquerda é sempre o índice zero e o da direita o -1.

    9 |

    Tuplas

    10 |

    A tupla é uma estrutura bastante similar a uma lista.Há apenas uma diferença é que na tupla não podemos remover os dados contidos nela.

    11 |

    Sets

    12 |

    Os sets, são um coleção de dados desordenados quase imutáveis e que não contém dados iguais.Os sets, necessitam de um permissão de exclusão e de adição de dados.

    13 |

    Dicionários

    14 |

    Os dicionários, são coleções de itens desordenados, cada elemento de um dicionário possui uma chave atrelada a ele, estas chaves devem ser únicas afinal, precisamos delas para acessar cada elemento.

    15 | 16 | Você foi introduzido as estruturas de dados. 17 | Agora, para vê os exemplos, as aplicações e como fica cada estrutura, na sintaxe do python.
    18 | Você deve prosseguir para os próximos readme deste repositório.
    19 | 20 | OBS: Qualquer dúvida relacionado ao contéudo apresentado neste repositório.
    21 | Acesse o discord da heart developers, que a comunidade irá fornecer o suporte necessário, para você.
    22 | Discord: discord 23 | -------------------------------------------------------------------------------- /Tipos/listas.md: -------------------------------------------------------------------------------- 1 | # Listas 2 | ## Definição 3 | O interpretador python reconhece como uma lista, uma sequência de objetos que estejam envolvidas por [ ] (conchetes) e separadas por vírgulas. 4 | 5 | Assim, como as Strings, as listas também tem índices. 6 | 7 | |"python"|"php"| 8 | |--------|-----| 9 | | 0 | 1 | 10 | | -2 | -1 | 11 | 12 | 13 | ## Exemplos 14 | 15 | 16 | 17 | #Estas duas listas são simples, e então denominadas de vetores. 18 | lista1 = ["python","php"] 19 | lista2 = [312.5,22 + 4j] 20 | 21 | #Esta lista é composta, e então considerada uma matriz. 22 | lista3 = [["c#","go lang"],[40,-8.980]] 23 | 24 | 25 | 26 | ## Acessando os dados de uma lista 27 | 28 | 29 | 30 | #Buscando na lista1 a palavra python 31 | print(lista1[0]) 32 | print(lista1[-2]) 33 | 34 | #Buscando na lista2 o número complexo 35 | print(lista2[1]) 36 | print(lista2[-1]) 37 | 38 | 39 | Saída 40 | 41 | 42 | python 43 | python 44 | (22+4j) 45 | (22+4j) 46 | 47 | 48 | Agora, vamos buscar na matriz 49 | 50 | 51 | 52 | #Buscando na lista3 a palavra go lang 53 | print(lista3[0][1]) 54 | 55 | #Buscando o número inteiro positivo 56 | print(lista3[1][0]) 57 | 58 | 59 | Saída 60 | 61 | 62 | go lang 63 | 40 64 | 65 | 66 | ## Comprimento de uma lista 67 | 68 |

    Para verificar o comprimento de uma lista usaremos o método len.

    69 | 70 | 71 | 72 | print(len(lista1)) 73 | print(len(lista2)) 74 | #Número de linhas 75 | print(len(lista3)) 76 | #Número de colunas 77 | print(len(lista3[0])) 78 | print(len(lista3[1])) 79 | 80 | 81 | 82 | 83 | 2 84 | 2 85 | 2 86 | 2 87 | 2 88 | 89 | 90 | 91 | ## Valores 92 | 93 | 94 | 95 | #Valor máximo da lista3 coluna 1 96 | print(max(lista3[1])) 97 | 98 | #Valor mínimo da lista3 coluna 1 99 | print(min(lista3[1])) 100 | 101 | #soma da lista3 coluna 1 102 | print(sum(lista3[1])) 103 | 104 | 105 | Saída 106 | 107 | 108 | 109 | 40 110 | -8.98 111 | 31.02 112 | 113 | 114 | 115 | 116 | ## Métodos 117 | 118 |
      119 |
    • Append: Usamos ele para acrescentar um novo dado a lista
      • 120 |
    • Insert: Usamos ele para acrescentar um novo dado a lista, de acordo com o índice.
      • 121 |
    • Remove: Remover um dado de acordo com índice.
      • 122 |
    • Sort: Ordena a lista.
      • 123 |
    • Reserve: Inverte a posição dos itens
      • 124 |
    • Count: Número de vezes que um dado aparece na lista
      • 125 | 126 |
    127 |
    128 | 129 | ### Como fica na prática 130 | 131 | 132 | 133 | lista1.append("java") 134 | print(lista1) 135 | 136 | Saída 137 | 138 | 139 | ['python', 'php', 'java'] 140 | 141 |
    142 | 143 | 144 | lista1.insert(1,"c") 145 | print(lista1) 146 | 147 | 148 | Saída 149 | 150 | 151 | ['python', 'c', 'php', 'java'] 152 | 153 |
    154 | 155 | 156 | lista1.remove("php") 157 | print(lista1) 158 | 159 | Saída 160 | 161 | 162 | ['python', 'c', 'java'] 163 | 164 |
    165 | 166 | 167 | 168 | #Vamos,criar uma nova lista e adicionar diretamente agora, para testar o sort e reverse. 169 | 170 | lista_nova = [99,-9,6.7,86,10.6] 171 | lista_nova.sort() 172 | print(lista_nova) 173 | 174 | Saída 175 | 176 | 177 | [-9, 6.7, 10.6, 86, 99] 178 | 179 |
    180 | 181 | 182 | lista_nova.reverse() 183 | print(lista_nova) 184 | 185 | Saída 186 | 187 | 188 | [10.6, 86, 6.7, -9, 99] 189 | 190 |
    191 | 192 | 193 | #Vamos, criar nossas últimas listas para usar o método count 194 | 195 | ultima_lista1 = [0,11,2,"python","python"] 196 | ultima_lista2 = [11,22,45] 197 | 198 | print(ultima_lista1.count("python")) 199 | print(ultima_lista2.count("python")) 200 | 201 | Saída 202 | 203 | 204 | 2 205 | 0 206 | 207 | 208 | ## Finalizando 209 | Você agora possui conhecimento sobre como funcionam as listas, em python. Prossiga nos seus estudos e pule para o próximo readme. 210 |
    211 |
    212 | OBS: Qualquer dúvida relacionada ao contéudo apresentado neste repositório.
    213 | Acesse o discord da heart developers, que a comunidade irá fornecer o suporte necessário, para você.
    214 | Discord: discord 215 |
    -------------------------------------------------------------------------------- /Tipos/numbers.md: -------------------------------------------------------------------------------- 1 | # Numbers 2 | 3 | ## Tipos 4 |

    No python, existem três tipos de números:

    5 |
      6 |
    • int
      • 7 |
    • float
      • 8 |
    • complex
      • 9 |
    10 | 11 | ### Int 12 | 13 |

    Os números do tipo int, são os números inteiros, ou seja, são números positivos e negativos que não possuem casa decimal.

    14 | Exemplos: 15 | 16 | 17 | 18 | #Exemplos de números inteiros 19 | num1 = 300 20 | num2 = -80 21 | 22 | 23 | 24 | Façamos como no arquivo anterior e perguntemos ao python como ele define estas variáveis. 25 | 26 | 27 | 28 | print(type(num1)) 29 | print(type(num2)) 30 | 31 | 32 | 33 | Saída 34 | 35 | 36 | 37 | 38 | 39 | 40 | Como já era esperado, o interpretador python definiu estas variáveis como números inteiros. 41 | 42 | ### Float 43 | 44 |

    Os números do tipo float, são os números racionais e irracionais, ou seja, são números positivos e negativos que possuem casa decimal.

    45 | Exemplos: 46 | 47 | 48 | #Exemplos de números do tipo float 49 | num3 = 300.5 #número positivo com uma casa decimal 50 | num4 = -433.6776 #número negativo com quatro casas decimais 51 | 52 | 53 | Consultemos, agora ao interpretador python. 54 | 55 | 56 | 57 | print(type(num3)) 58 | print(type(num4)) 59 | 60 | 61 | Saída 62 | 63 | 64 | 65 | 66 | 67 | 68 | ### Complex 69 | 70 |

    Os números do tipo complex, são compostos por uma parte real e outra imaginária.

    71 | Exemplos: 72 | 73 | 74 | 75 | num5 = 2 + 4j 76 | num6 = 4j 77 | num7 = -10j 78 | 79 | Consultemos, agora ao interpretador python. 80 | 81 | 82 | print(type(num5)) 83 | print(type(num6)) 84 | print(type(num7)) 85 | 86 | Saída 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | ### Número aleatório 95 | 96 |

    O python, possui um módulo que gera um número aleatório.

    97 | 98 | 99 | 100 | import random 101 | #Gera um número inteiro aleatório entre 0 e 10 102 | print(random.randint(0,10)) 103 | 104 | 105 | 106 | ## Conversões 107 | 108 |

    Como vimos no arquivo anterior podiamos transformar variáveis de um tipo inicial para um novo tipo.

    109 | Vejamos agora conversões com números. 110 | 111 | 112 | num8 = 80 #Número do tipo int 113 | num9 = -9.6 #Número do tipo float 114 | 115 | 116 | 117 | 118 | 119 | print(type(float(num8))) #Convertendo de int para float 120 | 121 | print(type(int(num9))) #Convertendo de float para int 122 | 123 | print(type(complex(num8)) #Convertendo de int para complex 124 | 125 | print(float(num8)) 126 | print(int(num9)) 127 | print(complex(num8)) 128 | 129 | Saída 130 | 131 | 132 | 133 | 134 | 135 | 80.0 136 | -9 137 | (80+0j) 138 | 139 | 140 | ## Operações aritméticas 141 | 142 | | Operação | Operador | 143 | |----------------|-----------| 144 | |Adição | + | 145 | |Subtração | - | 146 | |Multiplicação | * | 147 | |Divisão | / | 148 | |Divisão inteira | // | 149 | |Exponenciação | ** | 150 | |Resto da divisão| % | 151 | 152 | ### Operações com int. 153 | 154 | 155 | print(10 + 9) #Soma de inteiros 156 | print(9 - 8) #Subtração de inteiros 157 | print(-9 * -9) # Multiplicação de inteiros 158 | print(10 / 3) # Divisão de inteiros 159 | print(10 // 3) # Parte inteira da divisão entre inteiros 160 | print(10**2) #Exponenciação entre inteiros 161 | print(10 % 2) #Resto da divisão entre inteiros 162 | 163 | Saída 164 | 165 | 166 | 19 167 | 1 168 | 81 169 | 3.3333333333333335 170 | 3 171 | 100 172 | 0 173 | 174 | 175 | ### Operações com float. 176 | 177 | 178 | 179 | print(10.5 + 8.2) #Soma com floats 180 | print(-98.66 - 8.99) #Subtração com floats 181 | print(27.5 * 3.7) # Multiplicação com floats 182 | print(99.2 / 3.2) # Divisão com floats 183 | print(99.2 // 3.2) # Parte inteira da divisão com floats 184 | print(0.25**2) #Exponenciação com floats 185 | print(5.0 % 2.5) #Resto da divisão com floats 186 | 187 | Saída 188 | 189 | 190 | 18.7 191 | -107.64999999999999 192 | 101.75 193 | 31.0 194 | 30.0 195 | 0.0625 196 | 0.0 197 | 198 | 199 | ### Operações com complex. 200 | 201 | 202 | 203 | print(3 + 4j + 3 + 4j) #Soma com complex 204 | print(2 + 4j - 2 + 8j) #Subtração com complex 205 | print(-2 + 9j * 16 + 90j) # Multiplicação com complex 206 | print(2 + 10j/ 2j) # Divisão com complex 207 | print(25 + 2j ** 3 + 2j) #Exponenciação com complex 208 | 209 | 210 | OBS1: j equivale a -1
    211 | OBS2: Divisão inteira e resto não funcionam em números complexos. 212 | 213 | Saída 214 | 215 | 216 | (6+8j) 217 | 12j 218 | (-2+234j) 219 | (7+0j) 220 | (25-6j) 221 | 222 | 223 | ## Finalizando 224 | Você agora possui conhecimento sobre como funcionam os números, em python e como fazer operações e conversões aos mesmos. Prossiga nos seus estudos e pule para o próximo readme. 225 |
    226 |
    227 | OBS: Qualquer dúvida relacionada ao contéudo apresentado neste repositório.
    228 | Acesse o discord da heart developers, que a comunidade irá fornecer o suporte necessário, para você.
    229 | Discord: discord 230 |
    -------------------------------------------------------------------------------- /Tipos/sets.md: -------------------------------------------------------------------------------- 1 | # Sets 2 |

    Os sets, são estruturas de dados, parcialmente imutáveis, que não podem conter itens duplicados e são envolvidos por ({}) ou inicializados com o método set.

    3 | 4 | ## Exemplos 5 | 6 | 7 | 8 | set1 = ({1,2,3,4}) 9 | set2 = set([2,90,8,5]) 10 | 11 | print(type(set1)) 12 | print(type(set2)) 13 | 14 | 15 | Saída 16 | 17 | 18 | 19 | 20 | 21 | 22 | ## Adicionando dados 23 | 24 | 25 | 26 | set1.add(40) 27 | print(set1) 28 | 29 | set2.add(65) 30 | print(set2) 31 | 32 | Saída 33 | 34 | 35 | {1, 2, 3, 4, 40} 36 | {65, 2, 5, 8, 90} 37 | 38 | 39 | ## Atualizando dados 40 | 41 | 42 | 43 | set1.update([10,8,67]) 44 | print(set1) 45 | 46 | set2.update([22,33,78]) 47 | print(set2) 48 | 49 | Saída 50 | 51 | 52 | {1, 2, 3, 4, 67, 8, 10} 53 | {33, 2, 5, 8, 78, 22, 90} 54 | 55 | 56 | ## Remoção de dados 57 | 58 | 59 | 60 | #O método discard, só faz uma remoção por vez 61 | set1.discard(8) 62 | print(set1) 63 | 64 | set2.discard(78) 65 | print(set2) 66 | 67 | Saída 68 | 69 | 70 | {1, 2, 3, 4, 67, 10} 71 | {33, 2, 5, 8, 22, 90} 72 | 73 | 74 | ## Operações matemáticas 75 | 76 | ### União 77 |

    Na união, todos os dados dos dois sets serão “unidos” em um um único set com todos os elementos, não Haverá repetições.

    78 | 79 | OBS: Crie dois novos sets 80 | 81 | 82 | set_novo1 = ({1,2,3}) 83 | set_novo2 = set([4,5,6]) 84 | 85 | print(set_novo1.union(set_novo2)) 86 | 87 | 88 | Saída 89 | 90 | 91 | {1, 2, 3, 4, 5, 6} 92 | 93 | 94 | ### Interseção 95 |

    96 | Na interseção, apenas os dados que estiverem nos dois sets serão exibidos. 97 |

    98 | OBS2: Crie dois novos sets 99 | 100 | 101 | set_novo3 = ({4,7,8}) 102 | set_novo4 = set([4,5,6]) 103 | 104 | print(set_novo3.intersection(set_novo4)) 105 | 106 | 107 | Saída 108 | 109 | 110 | {4} 111 | 112 | 113 | ### Diferença 114 |

    Na diferença, restarão apenas os dados que estiverem em um dos sets.

    115 | 116 | 117 | set_novo3 = ({4,7,8}) 118 | set_novo4 = set([4,5,6]) 119 | 120 | print(set_novo3.difference(set_novo4)) 121 | 122 | Saída 123 | 124 | 125 | {8, 7} 126 | 127 | 128 | ### Diferença simétrica 129 |

    Na diferença simétrica, apenas os dados que estiverem nos dois sets,não haverá repetições

    130 | 131 | 132 | set_novo3 = ({4,7,8}) 133 | set_novo4 = set([4,5,6]) 134 | 135 | print(set_novo3.symmetric_difference(set_novo4)) 136 | 137 | Saída 138 | 139 | 140 | {5, 6, 7, 8} 141 | 142 | 143 | ## Finalizando 144 | Você agora possui conhecimento sobre oque é um set e como funciona, em python. Prossiga nos seus estudos e pule para o próximo readme. 145 |
    146 |
    147 | OBS: Qualquer dúvida relacionada ao contéudo apresentado neste repositório.
    148 | Acesse o discord da heart developers, que a comunidade irá fornecer o suporte necessário, para você.
    149 | Discord: discord 150 |
    -------------------------------------------------------------------------------- /Tipos/strings.md: -------------------------------------------------------------------------------- 1 | # 3.2 - String 2 | String é uma cadeia de caracteres. Uma string **sempre** estará entre aspas simples, duplas, triplas simples ou triplas duplas. 3 | Como nos seguintes, exemplos: 4 | 5 | Exemplo 1: 6 | ```python 7 | >>> 'Olá Mundo' 8 | 'Olá Mundo' 9 | >>> "H4rtDevs o melhor grupo de devs do Brasil" 10 | 'H4rtDevs o melhor grupo de devs do Brasil' 11 | >>> """Nossa, bem grande essa string...""" 12 | 'Nossa, bem grande essa string...' 13 | ``` 14 | 15 | Agora, vamos tirar a prova e conferir se o python reconhece estas cadeias como uma string. 16 | 17 | 18 | ## Hora do código 19 | 1. Agora você irá abrir o seu editor de código, criar um arquivo com extensão a **.py**. 20 | 2. Criar três variáveis com nomes de sua escolha. 21 | 3. Em seguida, usaremos duas funções, **print** e **type**. 22 | * Usaremos **type** para verificar o tipo das variáveis e o **print** para ver o que **type** nos retorna! 23 | 24 | O seu arquivo deverá ficar assim: 25 | ```python 26 | string1 = 'Olá mundo' 27 | string2 = "H4rtDevs é maior grupo de devs do Brasil" 28 | string3 = """Nossa, bem grande essa string...""" 29 | 30 | print(type(string1)) 31 | print(type(string2)) 32 | print(type(string3)) 33 | ``` 34 | 35 | ## Hora de ver funcionando! 36 | Basta executar o script para recebermos a seguinte saída.

    37 | ```python 38 | 39 | 40 | 41 | ``` 42 | 43 | ## Conversão para String 44 | Variáveis que inicialmente não são do tipo **string** podem ser convertidas para uma. 45 | Vamos conferir retirando as aspas do valor da váriavel `string3`. 46 | ``` 47 | >>> string3 = "321123" 48 | >>> string3 = 321123 49 | >>> # Vamos agora conferir o novo tipo da variável `string3`. 50 | >>> type(string3) 51 | 52 | ``` 53 | 54 | O novo tipo da nossa variável é **int** (integer ou inteiro), ou seja, o interpretador do python reconheceu nossa variável como um número do tipo **int**. 55 | Mas, se quiséssemos transformar esta variável em string novamente sem usar as aspas? 56 | Basta, usar o "método" interno **str** na nossa impressão. 57 | ``` 58 | >>> string3 = 321123 59 | >>> str(string3) 60 | '321123' 61 | ``` 62 | E assim, a nossa `string3` "volta a ser" uma **string**. 63 | 64 | ## Concatenação 65 | 66 | A concatenação é uma operação de unir duas strings. 67 | Crie uma nova variável e atribua a ela duas strings e separe-as por um sinal de adição e veja a saída. 68 | ```python 69 | >>> string4 = "Python" + "é legal" 70 | >>> string4 71 | 'Pythoné legal' 72 | ``` 73 | 74 | Que tal demonstrarmos o quanto gostamos de python, repetindo três vezes a palavra muito na nossa saída?
    75 | Use a String4. 76 |

    77 | 78 | 79 | 80 | String4 = "Python é" + " muito " * 3 + " legal" 81 | 82 | 83 | Agora, basta rodar nosso script para recerbemos a seguinte saída. 84 | 85 | 86 | Python é muito muito muito legal 87 | 88 | 89 | 90 | 91 | ## Descontruindo uma String 92 | 93 |

    No python, todas as classes/tipos que possuem ideia de 94 | ordenação (como a classe STRING) podem ser 95 | acessadas por partes. 96 |

    97 | 98 | |P|Y|T|H|O|N| 99 | |-|-|-|-|-|-| 100 | |0|1|2|3|4|5| 101 | |-6|-5|-4|-3|-2|-1| 102 | 103 | Crie uma nova variável do tipo String e atribua a ela a palavra: python 104 | 105 | 106 | String5 = "python" 107 | 108 | 109 |

    Agora, quero exibir apenas a letra p.
    110 |

    111 | 112 | 113 | print(String5[0]) 114 | 115 | Ou 116 | 117 | 118 | print(String5[-6]) 119 | 120 | Saída 121 | 122 | 123 | p 124 | p 125 | 126 | Agora, eu quero exibir todas as letras com exceção do P e N. 127 | 128 | 129 | print(String5[1:5]) 130 | 131 | saída. 132 | 133 | 134 | ytho 135 | 136 | Agora, eu quero todas as letras com exceção do O e N 137 | 138 | 139 | print(String5[:4]) 140 | 141 | 142 | saída. 143 | 144 | 145 | pyth 146 | 147 | 148 | Por fim, vamos pegar caracteres alternados 149 | 150 | 151 | print(String5[0:5:2]) 152 | 153 | Saída. 154 | 155 | 156 | pto 157 | 158 | 159 | 160 | ## Métodos internos 161 | Um dos métodos internos do python é o len.
    162 | O método len, tem como utilidade mostrar o número de caracteres de uma string.
    163 | Crie uma nova variável do tipo String. 164 | 165 | 166 | 167 | String6 = "Python4Noobs" 168 | 169 | Agora, vejamos o método len em ação. 170 | 171 | 172 | print(len(String6)) 173 | 174 | Saída. 175 | 176 | 177 | 12 178 | 179 | 180 | Count é mais uma destes métodos internos. 181 | A sua função é verificar quantas vezes determinado caractere aparece, em uma String. 182 | 183 | 184 | print(String6.count("o")) 185 | 186 | saída. 187 | 188 | 189 | 3 190 | 191 | Podemos definir também de onde iniciar e onde parar. 192 | 193 | 194 | print(String6.count("o",3,7)) 195 | 196 | 197 | Saída. 198 | 199 | 200 | 1 201 | 202 | Entre o caractere de índice três e o de índice sete, contém apenas uma letra O, segundo a nossa saída.
    203 |
    204 |

    205 | Outros, dois métodos são o UPPER e LOWER.
    206 | Suas funções, são respectivamente, deixar a string em caixa alta e caixa baixa.
    207 | Vejamos, com nossa String5. 208 |

    209 | 210 | 211 | print(String5.upper()) 212 | print(String5.lower()) 213 | 214 | Saída. 215 | 216 | 217 | PYTHON 218 | python 219 | 220 |

    221 | Por fim, temos mais três métodos.
    222 | Os métodos: Isalnum, replace e split.
    223 | Isalnum: Retorna true se todos os caracteres forem alfanúmericos.
    224 | replace:Retorna uma nova string 225 | substituindo na string a todas 226 | as ocorrências de uma string b 227 | por uma nova string c.
    228 | split:Separa a string a toda vez que 229 | for encontrada uma string b. 230 |

    231 | 232 | Vejamos, estes métodos na prática. 233 | 234 | 235 | 236 | String7 = "melancia321" 237 | String8 = "melancia321*%#" 238 | String9 = "Brasil" 239 | 240 | print(String7.isalnum()) 241 | print(String8.isalnum()) 242 | print(String9.replace("s","z")) 243 | print(String9.split("as")) 244 | 245 | Saída. 246 | 247 | 248 | #Isto é um comentário, ou seja, a linha não é executada pelo interpretador 249 | 250 | True #True, pois só há caracteres alfanúmericos na String7 251 | 252 | False #False, pois há caracteres que não são alfanúmericos na String8 253 | 254 | Brazil #A letra s foi substituida pela letra z 255 | 256 | ['Br', 'il'] #Foi criado um vetor para separar entre a letra a 257 | 258 | 259 | 260 | ## Finalizando 261 | Você agora possui conhecimento sobre oque é uma string, em python e como fazer manipulações com a mesma. Prossiga nos seus estudos e pule para o próximo readme. 262 |
    263 |
    264 | OBS: Qualquer dúvida relacionada ao contéudo apresentado neste repositório.
    265 | Acesse o discord da heart developers, que a comunidade irá fornecer o suporte necessário, para você.
    266 | Discord: discord 267 |
    268 | -------------------------------------------------------------------------------- /Tipos/tuplas.md: -------------------------------------------------------------------------------- 1 | # Tuplas 2 | 3 | As tuplas, são estruturas de dados imutáveis(não podem ter seus dados alterados) envolvidas por parênteses ( ). 4 | 5 | 6 | ## Exemplo 7 | Vamos armazenar dados aleatórios e tentar alterá-los. 8 | 9 | 10 | dados = (3.14,"hert developers") 11 | 12 | 13 | 14 | 15 | dados.append(75) 16 | 17 | Saída 18 | 19 | 20 | 'tuple' object has no attribute 'append' 21 | 22 | 23 |
    24 | 25 | 26 | 27 | dados.remove(3.14) 28 | 29 | Saída 30 | 31 | 32 | 'tuple' object has no attribute 'remove' 33 | 34 |
    35 | 36 | 37 | dados[0] = -5 38 | 39 | Saída 40 | 41 | 42 | 'tuple' object does not support item assignment 43 | 44 | 45 | ## Finalizando 46 | Você agora possui conhecimento sobre oque é uma tupla e como funcionam, em python. Prossiga nos seus estudos e pule para o próximo readme. 47 |
    48 |
    49 | OBS: Qualquer dúvida relacionada ao contéudo apresentado neste repositório.
    50 | Acesse o discord da heart developers, que a comunidade irá fornecer o suporte necessário, para você.
    51 | Discord: discord 52 |
    -------------------------------------------------------------------------------- /Trabalhando-com-API's/Conteúdo-da-resposta/conteudo_resposta.md: -------------------------------------------------------------------------------- 1 | ## Conteúdo da resposta 2 | 3 | - Podemos ler o que o servidor retornou, quando fizemos um requisição. Para isso, existem algumas formas de realizar tal leitura, por exemplo: 4 | 5 | ```python 6 | In[]: 7 | 8 | import requests 9 | 10 | 11 | # Aqui vamos utilizar uma API publica. 12 | r = requests.get('https://jsonplaceholder.typicode.com/todos/1') 13 | # Utilizamos o tratamento de retorno em forma de texto plano. 14 | print(r.text) 15 | 16 | ``` 17 | ```python 18 | Out[]: 19 | ``` 20 | 21 | 22 | - O encoding do conteúdo costuma ser automatico baseada nos cabeçalhos HTTP, mas você pode descobrir qual codificação *Requests* está usando, e mudá-la, utilizando a propriedade __r.encoding__: 23 | 24 | ```python 25 | In[]: 26 | 27 | import requests 28 | 29 | 30 | r = requests.get('https://jsonplaceholder.typicode.com/todos/1') 31 | # Retornando o encode da resposta. 32 | print(r.encoding) 33 | # Alterando o tipo do econde 34 | r.encoding = "ISO-8859-1" 35 | print(r.text) 36 | 37 | ``` 38 | ```python 39 | Out[]: 40 | ``` 41 | 42 | 43 | Se você mudar a codificação, *Requests* irá usar o novo valor de __r.encoding__ sempre que você chamar __r.text__. -------------------------------------------------------------------------------- /Trabalhando-com-API's/Conteúdo-da-resposta/resposta_binaria.md: -------------------------------------------------------------------------------- 1 | ## Resposta binária 2 | 3 | - Você pode acessar o corpo da resposta como bytes, para requisições que não são textos: 4 | 5 | ```python 6 | In[]: 7 | 8 | import requests 9 | 10 | 11 | r = requests.get('https://jsonplaceholder.typicode.com/todos/1') 12 | print(r.content) 13 | ``` 14 | ``` 15 | Out[]: 16 | ``` 17 | 18 | 19 | - As codificações de transferências *gzip* e *deflate* são decodificadas automaticamente para você. -------------------------------------------------------------------------------- /Trabalhando-com-API's/Conteúdo-da-resposta/resposta_crua.md: -------------------------------------------------------------------------------- 1 | ## Resposta crua 2 | 3 | - Caso seja necessario retornar a resposta crua do servidor, podemos usar o __raw__ para isso: 4 | 5 | ```python 6 | In[]: 7 | 8 | import requests 9 | 10 | 11 | r = requests.get('https://jsonplaceholder.typicode.com/todos/1') 12 | print(r.raw) 13 | ``` 14 | ```python 15 | Out[]: 16 | 17 | 18 | ``` 19 | 20 | - O conteudo retorna acima é um objeto da resposta do servidor. Para obter a resposta crua de fato, devemos incluir o parâmetro *stream=True* e atribuir ao método __r.raw__ a função __read()__, onde pconseguimos, de fato, o retorno "cru" do servidor: 21 | 22 | ```python 23 | In[]: 24 | 25 | import requests 26 | 27 | 28 | r = requests.get('https://jsonplaceholder.typicode.com/todos/1', stream=True) 29 | print(r.raw.read()) 30 | ``` 31 | ```python 32 | Out[]: 33 | ``` 34 | 35 | -------------------------------------------------------------------------------- /Trabalhando-com-API's/Conteúdo-da-resposta/resposta_json.md: -------------------------------------------------------------------------------- 1 | ## Resposta JSON 2 | 3 | 4 | - No caso de você estar lidando com dados JSON, a biblioteca contém o decodificador integrado: 5 | 6 | ```python 7 | In[]: 8 | 9 | import requests 10 | 11 | 12 | r = requests.get('https://jsonplaceholder.typicode.com/todos/1') 13 | print(r.json()) 14 | ``` 15 | ```python 16 | Out[]: 17 | 18 | {'userId': 1, 'id': 1, 'title': 'delectus aut autem', 'completed': False} 19 | ``` 20 | 21 | - No caso da decodificação do __JSON__ falhar, __r.json__ levanta uma exceção retornada pelo servidor. 22 | 23 | -------------------------------------------------------------------------------- /Trabalhando-com-API's/Realizando-requisições/delete.md: -------------------------------------------------------------------------------- 1 | ## Requisição DELETE 2 | 3 | - Com a lib *requests* podemos enviar uma simples requisição __DELETE__, da seguinte forma: 4 | 5 | ```python 6 | In[]: 7 | 8 | import requests 9 | 10 | 11 | r = requests.delete("http://httpbin.org/delete") 12 | print(r) 13 | ``` 14 | ```python 15 | Out[]: 16 | 17 | # Retornando o codigo 504 18 | 19 | 20 | # Esta resposta de erro é dada quando o servidor está atuando como um gateway e não obtém uma resposta a tempo. 21 | ``` 22 | 23 | Se quiser saber mais sobre os retornos HTTP, entre em: [Respostas informativas](https://developer.mozilla.org/pt-BR/docs/Web/HTTP/Status) -------------------------------------------------------------------------------- /Trabalhando-com-API's/Realizando-requisições/get.md: -------------------------------------------------------------------------------- 1 | ## Fazendo uma requisição 2 | 3 | Fazer uma requisição com Requests é muito simples: 4 | 5 | ```python 6 | In[]: 7 | 8 | # importe a biblioteca 9 | import requests 10 | 11 | 12 | # criando objeto para armazenar informações de uma requisição 13 | r = requests.get('https://github.com/timeline.json') 14 | print(r) 15 | ``` 16 | ```python 17 | Out[]: 18 | 19 | 20 | # O retorno é uma resposta do servidor 21 | # Nesse caso, o código 410 siginifica que a pagina não esta mais disponivel 22 | 23 | ``` 24 | 25 | - O site da mozilla deixa a seguinte descrição para esse retorno: 26 | - __410 Gone__: 27 | - *"Esta resposta será enviada quando o conteúdo requisitado foi permanentemente deletado do servidor, sem nenhum endereço de redirecionamento. É experado que clientes removam seus caches e links para o recurso. A especificação HTTP espera que este código de status seja usado para "serviços promocionais de tempo limitado". APIs não devem se sentir obrigadas a indicar que recursos foram removidos com este código de status."* 28 | 29 | 30 | Para entender como tratar melhor o retorno da requisição, acesse [Esse capitulo](/Trabalhando-com-API's/Conteúdo-da-resposta) desse módulo que estamos. 31 | 32 | Se quiser saber mais sobre os retornos HTTP, entre em: [Respostas informativas](https://developer.mozilla.org/pt-BR/docs/Web/HTTP/Status) -------------------------------------------------------------------------------- /Trabalhando-com-API's/Realizando-requisições/post.md: -------------------------------------------------------------------------------- 1 | ## Requisição POST 2 | 3 | - Com a lib *requests* podemos enviar uma simples requisição __POST__, da seguinte forma: 4 | 5 | ```python 6 | In[]: 7 | 8 | import requests 9 | 10 | 11 | r = requests.post("http://httpbin.org/post") 12 | print(r) 13 | ``` 14 | ```python 15 | Out[]: 16 | 17 | # Retornand o codigo 200 18 | 19 | 20 | # Codigo 200 significa que essa requisição foi bem sucedida. 21 | ``` 22 | 23 | Se quiser saber mais sobre os retornos HTTP, entre em: [Respostas informativas](https://developer.mozilla.org/pt-BR/docs/Web/HTTP/Status) -------------------------------------------------------------------------------- /Trabalhando-com-API's/Realizando-requisições/put.md: -------------------------------------------------------------------------------- 1 | ## Requisição PUT 2 | 3 | - Com a lib *requests* podemos enviar uma simples requisição __PUT__, da seguinte forma: 4 | 5 | ```python 6 | In[]: 7 | 8 | import requests 9 | 10 | 11 | r = requests.put("http://httpbin.org/put") 12 | print(r) 13 | ``` 14 | ```python 15 | Out[]: 16 | 17 | # Retornando o codigo 200 18 | 19 | 20 | # Codigo 200 significa que essa requisição foi bem sucedida. 21 | ``` 22 | 23 | Se quiser saber mais sobre os retornos HTTP, entre em: [Respostas informativas](https://developer.mozilla.org/pt-BR/docs/Web/HTTP/Status) -------------------------------------------------------------------------------- /Trabalhando-com-API's/assets/headers.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Trabalhando-com-API's/assets/headers.png -------------------------------------------------------------------------------- /Trabalhando-com-API's/assets/r_content.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Trabalhando-com-API's/assets/r_content.png -------------------------------------------------------------------------------- /Trabalhando-com-API's/assets/r_encoding.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Trabalhando-com-API's/assets/r_encoding.png -------------------------------------------------------------------------------- /Trabalhando-com-API's/assets/r_raw_read.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Trabalhando-com-API's/assets/r_raw_read.png -------------------------------------------------------------------------------- /Trabalhando-com-API's/assets/r_text.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wendrewdevelop/python4noobs/ff770fee59324d55e43781a6d44d7a66a2c4c010/Trabalhando-com-API's/assets/r_text.png -------------------------------------------------------------------------------- /Trabalhando-com-API's/biblioteca_requests.md: -------------------------------------------------------------------------------- 1 | ## Biblioteca requests 2 | 3 | Seguindo a [docmentação oficial](https://requests.readthedocs.io/pt_BR/latest/index.html) do projeto: 4 | 5 | 6 | *"Requests é uma biblioteca HTTP licensiada sob Apache2, escrita em Python, para seres humanos.* 7 | 8 | *O módulo urllib2, parte da biblioteca padrão do Python, oferece a maioria das funcionalidades do protocolo HTTP que você precisa, mas a API está completamente quebrada. Ela foi feita para uma época diferente — e uma web diferente. Ela demanda uma enorme quantidade de trabalho (inclusive para sobrescrever métodos) para realizar as tarefas mais simples."* 9 |
    10 | 11 | ## Instalação 12 | 13 | Para instalar esse biblioteca recomendamos o uso de um ambiente virtual, para que todo o seu projeto fique isolado dentro de um ambiente onde não afetará seu S.O ou outros projetos que esteja fazendo, então: 14 | 15 | ```python 16 | 17 | # Instalando a biblioteca virtualenv 18 | pip install virtualenv 19 | 20 | # Verifique se foi instalado corretamente 21 | virtualenv --version 22 | 23 | # Criando o ambiente virtual 24 | virtualenv -p python3 venv 25 | 26 | # Acessando o ambiente virtual no linux 27 | . venv/bin/activate 28 | 29 | # instalando a biblioteca requests 30 | pip install requests 31 | ``` 32 | 33 | Após seguir esse script de instalação e configuração, estamos prontos para seguir adiante. -------------------------------------------------------------------------------- /Trabalhando-com-API's/cookies.md: -------------------------------------------------------------------------------- 1 | ## Cookies 2 | 3 | - Basicamente, os __cookies__ são arquivos de internet que armazenam temporariamente o que o internauta está visitando na rede. Esses bytes geralmente possuem formato de texto e não ocupam praticamente nenhum espaço no disco rígido do computador. 4 | 5 | 6 | Se uma resposta contém alguns cookies, você tem acesso rápido a eles: 7 | 8 | ```python 9 | In[]: 10 | 11 | import requests 12 | 13 | 14 | # Instanciando a URL 15 | url = 'http://httpbin.org/cookies' 16 | 17 | # criando um dicionario do cookie 18 | cookies = dict(cookies_are='working') 19 | 20 | # Realizando a requisição 21 | r = requests.get(url, cookies=cookies) 22 | 23 | # Retornando o dict criado 24 | print(r.text) 25 | 26 | ``` 27 | ```python 28 | Out[]: 29 | 30 | { 31 | "cookies": { 32 | "cookies_are": "working" 33 | } 34 | } 35 | ``` -------------------------------------------------------------------------------- /Trabalhando-com-API's/erros_excecoes.md: -------------------------------------------------------------------------------- 1 | ## Erros e Exceções 2 | 3 | 4 | - Toda __API__ contém um tratamento de erros e exceções, para caso haja a necessidade de retornar alguma mensagem de erro/aviso ao usuário. Por exemplo, se houver uma falha na conexão o *Requests* irá levantar uma exceção *ConnectionError*; 5 | - Na ocasião de uma rara resposta *HTTP* inválida, *Requests* irá levantar uma exceção *HTTPError*; 6 | - Se uma requisição excede o tempo limite, uma exceção *Timeout* é levantada; 7 | - Se uma requisição excede o número máximo de redirecionamentos configurado, uma exceção *TooManyRedirects* é levantada; 8 | - Todas as exceções levantadas explicitamente pelo *Requests* são herdadas de *requests.exceptions.RequestException*. 9 | 10 | -------------------------------------------------------------------------------- /Trabalhando-com-API's/headers.md: -------------------------------------------------------------------------------- 1 | ## Cabeçalhos personalizados 2 | 3 | - Podemos adicionar cabeçalhos a uma requisição, para isso basta criar um __dict__, especificando os valores a serem utilizados: 4 | 5 | ```python 6 | import requests 7 | import json 8 | 9 | 10 | url = 'https://jsonplaceholder.typicode.com/posts' 11 | payload = { 12 | 'title': 'foo', 13 | 'body': 'bar', 14 | 'userId': 1 15 | } 16 | headers = {'content-type': 'application/json'} 17 | r = requests.post(url, data=json.dumps(payload), headers=headers) 18 | print(r) 19 | ``` 20 | ```python 21 | Out[]: 22 | ``` 23 | 24 | 25 | Dessa forma, passamos os valores de um formulário pelo headers da *URL* e criamos um novo registro na *API*. -------------------------------------------------------------------------------- /Trabalhando-com-API's/introducao_apis.md: -------------------------------------------------------------------------------- 1 | ## O que são API's 2 | 3 | - De uma maneira simples e ilustrativa, API's são "pontes" que conectam aplicações; 4 | - As API's proporcionam a integração entre sistemas que possuem linguagens até mesmo distintas, de maneira agil e segura. 5 | 6 | ## Protocolo HTTP 7 | 8 | *HTTP é um protocolo que permite enviar e receber informações na web.* 9 | 10 | - Primeiramente, o que é protocolo? 11 | __R:__ é um conjunto de regras que determinam que tipo de informações podem ser trocadas, basicamente. 12 | 13 | - Agora, o que é HTTP? 14 | __R:__ HTTP é um protocolo que permite enviar e receber informações na web. 15 | 16 |
    17 | 18 | Dois importantes personagens no funcionamento do *HTTP* são o *cliente* e o *servidor*. Por padrão, o *cliente* sempre inicia a conversa e então o *servidor* responde. 19 | 20 | ## URLS 21 | 22 | - __URLS__ são como identificamos o caminho que queremos operar; 23 | - Cada __URL__ determina um recurso. 24 | 25 | Digamos, que queremos obter a listagem de usuários de um sistema: 26 | 27 | ``` 28 | /users/ 29 | ``` 30 | 31 | Agora, quando queremos especificar qual usuário queremos retornar, normalmente, usamos o ID de registro do mesmo: 32 | 33 | ``` 34 | /user/1 35 | ``` 36 | 37 | ## Verbos HTTP 38 | 39 | - Cada requisição está atrelada a um verbo *HTTP*, ou método, no cabeçalho de requisição. São as letras maiúsculas no início do cabeçalho. Por exemplo: 40 | 41 | ``` 42 | GET / HTTP/1.1 43 | ``` 44 | 45 | Significa que o método __GET__ está sendo utilizado, enquanto: 46 | 47 | ``` 48 | DELETE /users/1 HTTP/1.1 49 | ``` 50 | significa que o método __DELETE__ está sendo utilizado. 51 | 52 | - Os verbos *HTTP* dizem ao servidor o que ele deve fazer com a informação identificada na __URL__. 53 | 54 | 55 | #### Conhecendo os verbos HTTP 56 | 57 | __GET__ 58 | ``` 59 | GET pode ser considerado o método mais simples, com as informações passadas por meio dele o servidor retorna as informações. 60 | ``` 61 | 62 | __POST__ 63 | ``` 64 | requisições POST devem executar o processo no corpo como um subordinado da URL que você está postando. 65 | ``` 66 | 67 | __DELETE__ 68 | ``` 69 | O DELETE deve atuar ao contrária do PUT; deve ser utilizado quando você deseja deletar o recurso identificar pela URL, na requisição. 70 | ``` 71 | 72 | __PUT__ 73 | ``` 74 | Uma requisição PUT é utilizada quando desejamos criar ou atualizar uma informação identificada por uma URL. 75 | ``` -------------------------------------------------------------------------------- /Trabalhando-com-API's/timeouts.md: -------------------------------------------------------------------------------- 1 | ## Timeouts 2 | 3 | 4 | - Você pode dizer para as requisições pararem de esperar por uma resposta depois de um dado número de segundos com o parâmetro __timeout__: 5 | 6 | ```python 7 | In[]: 8 | 9 | import requests 10 | 11 | # Criando o objeto e definindo o timeout da requisição. 12 | r = requests.get('http://github.com', timeout=0.001) 13 | print(r.text) 14 | 15 | ``` 16 | ```python 17 | Out[]: 18 | 19 | Traceback (most recent call last): 20 | File "", line 1, in 21 | requests.exceptions.Timeout: HTTPConnectionPool(host='github.com', port=80): Request timed out. (timeout=0.001) 22 | ``` 23 | 24 | __OBS:__ *timeout somente afeta o processo da conexão, não o download do corpo da resposta.* 25 | 26 | --------------------------------------------------------------------------------