├── .gitignore ├── Imersao Python - Pré.ipynb ├── Imersao Python - Pós.ipynb ├── Imersão Python.pdf └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | *.ppt 2 | *pptx 3 | *.ipynb_checkpoints 4 | .ipynb_checkpoints* -------------------------------------------------------------------------------- /Imersao Python - Pré.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Imersao Python\n", 8 | "\n", 9 | "## Uma breve introdução ao Python.\n", 10 | "\n", 11 | "Vamos conhecer todas as estruturas básicas da linguagem. Tudo o que é necessário para escrever programas minimamente úteis.\n", 12 | "\n", 13 | "## Tipos de dados\n", 14 | "\n", 15 | "Vamos dar \"olá\" para o mundo..." 16 | ] 17 | }, 18 | { 19 | "cell_type": "code", 20 | "execution_count": 1, 21 | "metadata": {}, 22 | "outputs": [ 23 | { 24 | "name": "stdout", 25 | "output_type": "stream", 26 | "text": [ 27 | "Olá mundo!!\n" 28 | ] 29 | } 30 | ], 31 | "source": [ 32 | "print(\"Olá mundo!!\")" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": {}, 38 | "source": [ 39 | "### Como pedir informação para o usuário??" 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": 2, 45 | "metadata": {}, 46 | "outputs": [ 47 | { 48 | "name": "stdout", 49 | "output_type": "stream", 50 | "text": [ 51 | "Qual o seu nome? teo\n" 52 | ] 53 | } 54 | ], 55 | "source": [ 56 | "nome = input(\"Qual o seu nome? \")" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": 3, 62 | "metadata": {}, 63 | "outputs": [ 64 | { 65 | "data": { 66 | "text/plain": [ 67 | "str" 68 | ] 69 | }, 70 | "execution_count": 3, 71 | "metadata": {}, 72 | "output_type": "execute_result" 73 | } 74 | ], 75 | "source": [ 76 | "type(nome)" 77 | ] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "metadata": {}, 82 | "source": [ 83 | "### Toda informação que é requisitada pelo usuário é do tipo STRING\n", 84 | "\n", 85 | "Ou seja, mesmo que o usuário coloque um número, o mesmo é tratado como texto. Assim que desejemos obter a idade do indivíduo, precisamos converter para INTEIRO." 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": 4, 91 | "metadata": {}, 92 | "outputs": [ 93 | { 94 | "name": "stdout", 95 | "output_type": "stream", 96 | "text": [ 97 | "Qual sua idade? 27\n" 98 | ] 99 | } 100 | ], 101 | "source": [ 102 | "idade = input(\"Qual sua idade? \")\n", 103 | "idade = int(idade)" 104 | ] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": 5, 109 | "metadata": {}, 110 | "outputs": [ 111 | { 112 | "data": { 113 | "text/plain": [ 114 | "int" 115 | ] 116 | }, 117 | "execution_count": 5, 118 | "metadata": {}, 119 | "output_type": "execute_result" 120 | } 121 | ], 122 | "source": [ 123 | "type(idade)" 124 | ] 125 | }, 126 | { 127 | "cell_type": "markdown", 128 | "metadata": {}, 129 | "source": [ 130 | "## Abrindo o capô das Strings\n", 131 | "\n", 132 | "Strings são um conjunto de caracteres, sendo possível navegar por elas, fatiar, remover caracteres, etc...\n", 133 | "\n", 134 | "Strings possuem métodos e atributos, mas o que e isso? Uma pessoa, possui características e ações possíveis de serem executadas.\n", 135 | "\n", 136 | "Exemplo de atributos (características):\n", 137 | "\n", 138 | "- cor do cabelo\n", 139 | "- cor dos olhos\n", 140 | "- idade\n", 141 | "- sexo\n", 142 | "\n", 143 | "Exemplo de métodos (ações):\n", 144 | "\n", 145 | "- Viajar\n", 146 | "- Estudar\n", 147 | "- Pintar o cabelo\n", 148 | "\n", 149 | "Vamos conferrir isso nas strings?" 150 | ] 151 | }, 152 | { 153 | "cell_type": "code", 154 | "execution_count": 6, 155 | "metadata": {}, 156 | "outputs": [], 157 | "source": [ 158 | "# Posições de caracteres\n", 159 | "\n", 160 | "# Fatiamento\n", 161 | "\n", 162 | "# Caixa alta\n", 163 | "\n", 164 | "# Caixa Baixa\n", 165 | "\n", 166 | "# Concatenação\n", 167 | "\n", 168 | "# Alteração\n", 169 | "\n", 170 | "# Começa com, termina com" 171 | ] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": {}, 176 | "source": [ 177 | "## Vamos para os números?\n", 178 | "\n", 179 | "Python pode servir de calculadora, por exemplo somar, dividir, exponenciar, módulo, etc...\n", 180 | "\n", 181 | "Lembrando que temos dois tipos básicos de numéricos: int e float.\n", 182 | "\n", 183 | "Adicionando ainda, os booleanos: True e False" 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": 7, 189 | "metadata": {}, 190 | "outputs": [], 191 | "source": [ 192 | "# 1 + 1\n", 193 | "\n", 194 | "# 1 - 1\n", 195 | "\n", 196 | "# 1 / 1\n", 197 | "\n", 198 | "# 1 * 1\n", 199 | "\n", 200 | "# 1 % 1\n", 201 | "\n", 202 | "# 1 ** 1\n", 203 | "\n", 204 | "# True + True" 205 | ] 206 | }, 207 | { 208 | "cell_type": "markdown", 209 | "metadata": {}, 210 | "source": [ 211 | "## Tipos iteráveis\n", 212 | "\n", 213 | "Tipos iteráveis são tipos de dados que podemos de alguma forma iterar por eles. Mas o que diabos é iterar? Iterar é a possibilidade de criar iterações (loops) a partir de uma determinada condição lógica ou objeto a ser percorrido (iterado).\n", 214 | "\n", 215 | "Exemplo de iteráveis:\n", 216 | "\n", 217 | "- listas\n", 218 | "- tuplas\n", 219 | "- dicionários\n", 220 | "- range\n", 221 | "\n", 222 | "ps. Strings são iteráveis também.\n", 223 | "\n", 224 | "Vamos começar com listas...\n", 225 | "\n", 226 | "## Listas\n", 227 | "\n", 228 | "Listas são objetos que carregam (apontam) para um conjunto finito de quaiquer outros tipos de objetos. Pense me listas como vagões de trem que carregam uma determinada carga, onde cada um desses vagões pode conter tipos de carga totalmente diferentes. Ou seja, em um vagão pode haver minério, no outro madeira, e no outro conter pessoas." 229 | ] 230 | }, 231 | { 232 | "cell_type": "code", 233 | "execution_count": 8, 234 | "metadata": {}, 235 | "outputs": [], 236 | "source": [ 237 | "# Exemplo de listas\n", 238 | "\n", 239 | "# Posição de um elemento\n", 240 | "\n", 241 | "# Concatenação de listas\n", 242 | "\n", 243 | "# Métodos de listas\n", 244 | "\n", 245 | "# Fatiamento" 246 | ] 247 | }, 248 | { 249 | "cell_type": "markdown", 250 | "metadata": {}, 251 | "source": [ 252 | "## Tuplas\n", 253 | "\n", 254 | "### Maneira feia de definir tuplas:\n", 255 | "\n", 256 | "Tuplas são listas imutáveis. Mas o que e isso?" 257 | ] 258 | }, 259 | { 260 | "cell_type": "code", 261 | "execution_count": 9, 262 | "metadata": {}, 263 | "outputs": [], 264 | "source": [ 265 | "# Exemplo de tuplas\n", 266 | "\n", 267 | "# Posição de um elemento\n", 268 | "\n", 269 | "# Concatenação de tuplas\n", 270 | "\n", 271 | "# Métodos de tuplas\n", 272 | "\n", 273 | "# Fatiamento" 274 | ] 275 | }, 276 | { 277 | "cell_type": "markdown", 278 | "metadata": {}, 279 | "source": [ 280 | "## Dicionários\n", 281 | "\n", 282 | "Dicionários não estruturas de dados referentes à pares de chave/valor. Isso significa que vc atrela um valor a determinada chave, ao invés de uma posição, como no caso das listas e tuplas. Ressalto que o 'valor' pode ser qualquer tipo de objeto." 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "execution_count": 10, 288 | "metadata": {}, 289 | "outputs": [], 290 | "source": [ 291 | "# Exemplo de dicionário\n", 292 | "\n", 293 | "# Valor de uma chave\n", 294 | "\n", 295 | "# Mostrar todas as chaves\n", 296 | "\n", 297 | "# Mostrar todos os valores" 298 | ] 299 | }, 300 | { 301 | "cell_type": "markdown", 302 | "metadata": {}, 303 | "source": [ 304 | "## Funções\n", 305 | "\n", 306 | "Funções são nossas amigas para reaproveitar código. Assim, caso tenha algum tipo de execução que seja parecido, não é necessário escrever o mesmo código toda vez." 307 | ] 308 | }, 309 | { 310 | "cell_type": "code", 311 | "execution_count": 11, 312 | "metadata": {}, 313 | "outputs": [], 314 | "source": [ 315 | "# f(x) = x**2 + 2 * x + 10" 316 | ] 317 | }, 318 | { 319 | "cell_type": "markdown", 320 | "metadata": {}, 321 | "source": [ 322 | "## Controle de Fluxo\n", 323 | "\n", 324 | "No python é possível alterar a sequencia de leitura das linhas, fazendo uso de 'funções' especiais para tal. Exemplo de operadores que alteram o fluxo de um programa:\n", 325 | "\n", 326 | "- if\n", 327 | "\n", 328 | "- elif\n", 329 | "\n", 330 | "- else\n", 331 | "\n", 332 | "- for\n", 333 | "\n", 334 | "- while\n", 335 | "\n", 336 | "- try\n", 337 | "\n", 338 | "Lembre-se que é obrigatório o uso de identação, 4 espaços são o padrão.\n", 339 | "\n", 340 | "### if, elif e else\n", 341 | "\n", 342 | "Tabelinha verdade, vocês viram em algebra elementar, certo?\n", 343 | "\n", 344 | "Então, verdade verdade => verdade ?\n", 345 | "\n", 346 | "Mesma coisa por aqui:\n", 347 | "\n", 348 | "if verdade => verdade e executamos\n", 349 | "\n", 350 | "else => executamos aqui" 351 | ] 352 | }, 353 | { 354 | "cell_type": "code", 355 | "execution_count": 12, 356 | "metadata": {}, 357 | "outputs": [], 358 | "source": [ 359 | "# if\n", 360 | "\n", 361 | "# elif\n", 362 | "\n", 363 | "# else" 364 | ] 365 | }, 366 | { 367 | "cell_type": "markdown", 368 | "metadata": {}, 369 | "source": [ 370 | "### Laços de repetição\n", 371 | "\n", 372 | "For percorre um iterável (iterador), ou seja, enquanto o iterador tiver valores para ser iterado, o laço for continua:" 373 | ] 374 | }, 375 | { 376 | "cell_type": "code", 377 | "execution_count": 13, 378 | "metadata": {}, 379 | "outputs": [], 380 | "source": [ 381 | "# for i in [1,2,3]" 382 | ] 383 | }, 384 | { 385 | "cell_type": "markdown", 386 | "metadata": {}, 387 | "source": [ 388 | "## Importação de bibliotecas\n", 389 | "\n", 390 | "É comum fazer uso de código opensource que não vem \"empacotado\" junto com o python, assim, você pode querer usar pacotes de terceiros como também criar seus próprios módulos e bibliotecas. Para fazer reuso de códigos é necessário importa-los." 391 | ] 392 | }, 393 | { 394 | "cell_type": "code", 395 | "execution_count": 14, 396 | "metadata": {}, 397 | "outputs": [], 398 | "source": [ 399 | "# import time\n", 400 | "# import random" 401 | ] 402 | } 403 | ], 404 | "metadata": { 405 | "file_extension": ".py", 406 | "kernelspec": { 407 | "display_name": "Python 3", 408 | "language": "python", 409 | "name": "python3" 410 | }, 411 | "language_info": { 412 | "codemirror_mode": { 413 | "name": "ipython", 414 | "version": 3 415 | }, 416 | "file_extension": ".py", 417 | "mimetype": "text/x-python", 418 | "name": "python", 419 | "nbconvert_exporter": "python", 420 | "pygments_lexer": "ipython3", 421 | "version": "3.8.3" 422 | }, 423 | "mimetype": "text/x-python", 424 | "name": "python", 425 | "npconvert_exporter": "python", 426 | "pygments_lexer": "ipython3", 427 | "version": 3 428 | }, 429 | "nbformat": 4, 430 | "nbformat_minor": 2 431 | } 432 | -------------------------------------------------------------------------------- /Imersao Python - Pós.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Imersao Python\n", 8 | "\n", 9 | "## Uma breve introdução ao Python.\n", 10 | "\n", 11 | "Vamos conhecer todas as estruturas básicas da linguagem. Tudo o que é necessário para escrever programas minimamente úteis.\n", 12 | "\n", 13 | "## Tipos de dados\n", 14 | "\n", 15 | "Vamos dar \"olá\" para o mundo..." 16 | ] 17 | }, 18 | { 19 | "cell_type": "code", 20 | "execution_count": 2, 21 | "metadata": { 22 | "scrolled": true 23 | }, 24 | "outputs": [ 25 | { 26 | "name": "stdout", 27 | "output_type": "stream", 28 | "text": [ 29 | "Olá mundo!!\n" 30 | ] 31 | } 32 | ], 33 | "source": [ 34 | "print(\"Olá mundo!!\")" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 7, 40 | "metadata": {}, 41 | "outputs": [ 42 | { 43 | "name": "stdout", 44 | "output_type": "stream", 45 | "text": [ 46 | "Seja bem vindo à Imersão de Python!!\n" 47 | ] 48 | } 49 | ], 50 | "source": [ 51 | "print(\"Seja bem vindo à Imersão de Python!!\")" 52 | ] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": 8, 57 | "metadata": {}, 58 | "outputs": [ 59 | { 60 | "name": "stdout", 61 | "output_type": "stream", 62 | "text": [ 63 | "Olá Téo!!\n" 64 | ] 65 | } 66 | ], 67 | "source": [ 68 | "print('Olá Téo!!')" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": 9, 74 | "metadata": {}, 75 | "outputs": [ 76 | { 77 | "name": "stdout", 78 | "output_type": "stream", 79 | "text": [ 80 | "Muito obrigado, galera\n" 81 | ] 82 | } 83 | ], 84 | "source": [ 85 | "print('''Muito obrigado, galera''')" 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "metadata": {}, 91 | "source": [ 92 | "### Como pedir informação para o usuário??" 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": 12, 98 | "metadata": {}, 99 | "outputs": [ 100 | { 101 | "name": "stdout", 102 | "output_type": "stream", 103 | "text": [ 104 | "Qual o seu nome? Téo Calvo\n", 105 | "Qual a sua idade? 28\n" 106 | ] 107 | } 108 | ], 109 | "source": [ 110 | "nome = input(\"Qual o seu nome? \")\n", 111 | "idade = input(\"Qual a sua idade? \")" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": 15, 117 | "metadata": {}, 118 | "outputs": [ 119 | { 120 | "name": "stdout", 121 | "output_type": "stream", 122 | "text": [ 123 | "Téo Calvo\n", 124 | "28\n" 125 | ] 126 | } 127 | ], 128 | "source": [ 129 | "print(nome)\n", 130 | "print(idade)" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": 18, 136 | "metadata": {}, 137 | "outputs": [ 138 | { 139 | "name": "stdout", 140 | "output_type": "stream", 141 | "text": [ 142 | "\n", 143 | "\n" 144 | ] 145 | } 146 | ], 147 | "source": [ 148 | "print(type(idade))\n", 149 | "print(type(nome)) # str = string" 150 | ] 151 | }, 152 | { 153 | "cell_type": "markdown", 154 | "metadata": {}, 155 | "source": [ 156 | "### Toda informação que é requisitada para usuário é do tipo STRING\n", 157 | "\n", 158 | "Ou seja, mesmo que o usuário coloque um número, o mesmo é tratado como texto. Assim que desejemos obter a idade do indivíduo, precisamos converter para INTEIRO." 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": 21, 164 | "metadata": {}, 165 | "outputs": [ 166 | { 167 | "name": "stdout", 168 | "output_type": "stream", 169 | "text": [ 170 | "Qual sua idade? 28\n" 171 | ] 172 | } 173 | ], 174 | "source": [ 175 | "idade = input(\"Qual sua idade? \")\n", 176 | "idade = int(idade)" 177 | ] 178 | }, 179 | { 180 | "cell_type": "code", 181 | "execution_count": 22, 182 | "metadata": {}, 183 | "outputs": [ 184 | { 185 | "name": "stdout", 186 | "output_type": "stream", 187 | "text": [ 188 | "Qual a sua idade?28\n" 189 | ] 190 | } 191 | ], 192 | "source": [ 193 | "idade = int(input(\"Qual a sua idade?\"))" 194 | ] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": 28, 199 | "metadata": {}, 200 | "outputs": [ 201 | { 202 | "name": "stdout", 203 | "output_type": "stream", 204 | "text": [ 205 | "\n", 206 | "\n" 207 | ] 208 | } 209 | ], 210 | "source": [ 211 | "print(type(idade))\n", 212 | "print(type(nome))" 213 | ] 214 | }, 215 | { 216 | "cell_type": "markdown", 217 | "metadata": {}, 218 | "source": [ 219 | "## Abrindo o capô das Strings\n", 220 | "\n", 221 | "Strings são um conjunto de caracteres, sendo possível navegar por elas, fatiar, remover caracteres, etc...\n", 222 | "\n", 223 | "Strings possuem métodos e atributos, mas o que e isso? Uma pessoa, possui características e ações possíveis de serem executadas.\n", 224 | "\n", 225 | "Exemplo de atributos (características):\n", 226 | "\n", 227 | "- cor do cabelo\n", 228 | "- cor dos olhos\n", 229 | "- idade\n", 230 | "- sexo\n", 231 | "\n", 232 | "Exemplo de métodos (ações):\n", 233 | "\n", 234 | "- Viajar\n", 235 | "- Estudar\n", 236 | "- Pintar o cabelo\n", 237 | "\n", 238 | "Vamos conferrir isso nas strings?" 239 | ] 240 | }, 241 | { 242 | "cell_type": "code", 243 | "execution_count": 48, 244 | "metadata": {}, 245 | "outputs": [ 246 | { 247 | "name": "stdout", 248 | "output_type": "stream", 249 | "text": [ 250 | "Entre com o seu nome: Téo Calvo\n" 251 | ] 252 | } 253 | ], 254 | "source": [ 255 | "nome = input(\"Entre com o seu nome: \")" 256 | ] 257 | }, 258 | { 259 | "cell_type": "code", 260 | "execution_count": 30, 261 | "metadata": {}, 262 | "outputs": [ 263 | { 264 | "data": { 265 | "text/plain": [ 266 | "str" 267 | ] 268 | }, 269 | "execution_count": 30, 270 | "metadata": {}, 271 | "output_type": "execute_result" 272 | } 273 | ], 274 | "source": [ 275 | "type(nome)" 276 | ] 277 | }, 278 | { 279 | "cell_type": "code", 280 | "execution_count": 68, 281 | "metadata": { 282 | "scrolled": true 283 | }, 284 | "outputs": [ 285 | { 286 | "name": "stdout", 287 | "output_type": "stream", 288 | "text": [ 289 | "A primeira letra do nome é: T\n", 290 | "A segunda letra do nome é: é\n", 291 | "A terceira letra do nome é: o\n", 292 | "A última letra do nome é: o\n", 293 | "A penúltima letra do nome é: v\n", 294 | "O nome 'Téo Calvo' tem 9 caracteres.\n" 295 | ] 296 | } 297 | ], 298 | "source": [ 299 | "# Téo Calvo\n", 300 | "print(\"A primeira letra do nome é:\", nome[0])\n", 301 | "print(\"A segunda letra do nome é: \", nome[1])\n", 302 | "print(\"A terceira letra do nome é:\", nome[2])\n", 303 | "\n", 304 | "print(\"A última letra do nome é: \", nome[-1], sep=\"\")\n", 305 | "print(\"A penúltima letra do nome é: \", nome[-2], sep=\"\")\n", 306 | "\n", 307 | "print(\"O nome '\", nome, \"' tem \", len(nome), ' caracteres.', sep=\"\")" 308 | ] 309 | }, 310 | { 311 | "cell_type": "code", 312 | "execution_count": 69, 313 | "metadata": {}, 314 | "outputs": [ 315 | { 316 | "name": "stdout", 317 | "output_type": "stream", 318 | "text": [ 319 | "Entre com o seu nome: Nah Ataide\n", 320 | "A primeira letra do nome é: N\n", 321 | "A segunda letra do nome é: a\n", 322 | "A terceira letra do nome é: h\n", 323 | "A última letra do nome é: e\n", 324 | "A penúltima letra do nome é: d\n", 325 | "O nome 'Nah Ataide' tem 10 caracteres.\n" 326 | ] 327 | } 328 | ], 329 | "source": [ 330 | "nome_nah = input(\"Entre com o seu nome: \")\n", 331 | "\n", 332 | "# Nah Ataíde\n", 333 | "print(\"A primeira letra do nome é:\", nome_nah[0])\n", 334 | "print(\"A segunda letra do nome é: \", nome_nah[1])\n", 335 | "print(\"A terceira letra do nome é:\", nome_nah[2])\n", 336 | "\n", 337 | "print(\"A última letra do nome é: \", nome_nah[-1], sep=\"\")\n", 338 | "print(\"A penúltima letra do nome é: \", nome_nah[-2], sep=\"\")\n", 339 | "\n", 340 | "print(\"O nome '\", nome_nah, \"' tem \", len(nome_nah), ' caracteres.', sep=\"\")" 341 | ] 342 | }, 343 | { 344 | "cell_type": "code", 345 | "execution_count": 86, 346 | "metadata": {}, 347 | "outputs": [ 348 | { 349 | "name": "stdout", 350 | "output_type": "stream", 351 | "text": [ 352 | "Os três primeiros caracteres: Téo\n", 353 | "Os três primeiros caracteres: Téo\n", 354 | "Os três últimos caracteres: lvo\n", 355 | "Intercalando: ToClo\n", 356 | "Invertendo: ovlaC oéT\n", 357 | "Invertendo no passo largo: olCoT\n" 358 | ] 359 | } 360 | ], 361 | "source": [ 362 | "print(\"Os três primeiros caracteres:\", nome[0:3]) # slice\n", 363 | "print(\"Os três primeiros caracteres:\", nome[:3]) # slice\n", 364 | "print(\"Os três últimos caracteres:\", nome[-3:]) # slice\n", 365 | "\n", 366 | "print(\"Intercalando:\",nome[::2])\n", 367 | "print(\"Invertendo:\",nome[::-1])\n", 368 | "print(\"Invertendo no passo largo:\", nome[::-2])\n", 369 | "\n", 370 | "# fim - inicio = range\n", 371 | "# 3 - 0 = 3" 372 | ] 373 | }, 374 | { 375 | "cell_type": "code", 376 | "execution_count": 95, 377 | "metadata": {}, 378 | "outputs": [], 379 | "source": [ 380 | "# Métodos !!!!!\n", 381 | "nome_upper = nome.upper()\n", 382 | "nome_lower = nome.lower()\n", 383 | "nome_prim_upper = nome.capitalize()\n", 384 | "nome_title = nome_upper.title()" 385 | ] 386 | }, 387 | { 388 | "cell_type": "code", 389 | "execution_count": 107, 390 | "metadata": {}, 391 | "outputs": [ 392 | { 393 | "name": "stdout", 394 | "output_type": "stream", 395 | "text": [ 396 | "Téo Calvo termina com Calvo? True\n", 397 | "Lara Calvo termina com Calvo? True\n", 398 | "Nah Ataide termina com Calvo? False\n" 399 | ] 400 | } 401 | ], 402 | "source": [ 403 | "# Ainda em métodos!!\n", 404 | "lara = \"Lara Calvo\"\n", 405 | "teo = \"Téo Calvo\"\n", 406 | "nah = \"Nah Ataide\"\n", 407 | "\n", 408 | "print(teo, \"termina com Calvo?\", teo.endswith(\"Calvo\"))\n", 409 | "print(lara, \"termina com Calvo?\", lara.endswith(\"Calvo\"))\n", 410 | "print(nah, \"termina com Calvo?\", nah.endswith(\"Calvo\"))" 411 | ] 412 | }, 413 | { 414 | "cell_type": "code", 415 | "execution_count": 114, 416 | "metadata": {}, 417 | "outputs": [ 418 | { 419 | "name": "stdout", 420 | "output_type": "stream", 421 | "text": [ 422 | "Téo Calvo\n", 423 | "C://FileFolder/dados.csv\n" 424 | ] 425 | } 426 | ], 427 | "source": [ 428 | "# Concatenação\n", 429 | "nome_teo = \"Téo\" + \" \" + \"Calvo\"\n", 430 | "endereco_arquivo = \"C://FileFolder/\" + \"dados.csv\"\n", 431 | "\n", 432 | "print(nome_teo)\n", 433 | "print(endereco_arquivo)" 434 | ] 435 | }, 436 | { 437 | "cell_type": "code", 438 | "execution_count": 119, 439 | "metadata": {}, 440 | "outputs": [ 441 | { 442 | "name": "stdout", 443 | "output_type": "stream", 444 | "text": [ 445 | "Doa aeeewwww!!\n", 446 | "Doa aeeewwww!!\n", 447 | "Doa aeeewwww!!\n", 448 | "Doa aeeewwww!!\n", 449 | "Doa aeeewwww!!\n", 450 | "Doa aeeewwww!!\n", 451 | "Doa aeeewwww!!\n", 452 | "Doa aeeewwww!!\n", 453 | "Doa aeeewwww!!\n", 454 | "Doa aeeewwww!!\n", 455 | "\n" 456 | ] 457 | } 458 | ], 459 | "source": [ 460 | "# Multiplicacao\n", 461 | "donate = \"Doa aeeewwww!!\\n\" * 10\n", 462 | "print(donate)" 463 | ] 464 | }, 465 | { 466 | "cell_type": "code", 467 | "execution_count": 132, 468 | "metadata": {}, 469 | "outputs": [ 470 | { 471 | "name": "stdout", 472 | "output_type": "stream", 473 | "text": [ 474 | "Entre com o seu nome: Téo Calvo\n", 475 | "Olá Téo Calvo. Tudo bem?\n", 476 | "Olá Téo Calvo. Tudo bem?\n", 477 | "Olá Téo Calvo. Tudo bem?\n", 478 | "Olá Téo Calvo. Tudo bem?\n", 479 | "Olá Téo Calvo. Tudo bem?\n", 480 | "Olá Téo Calvo. Tudo bem?\n", 481 | "Olá Téo Calvo. Tudo bem?\n", 482 | "Olá Téo Calvo. Tudo bem?\n", 483 | "Olá Téo Calvo. Tudo bem?\n", 484 | "Olá Téo Calvo. Tudo bem?\n", 485 | "\n" 486 | ] 487 | } 488 | ], 489 | "source": [ 490 | "nome = input(\"Entre com o seu nome: \")\n", 491 | "\n", 492 | "print( (\"Olá \" + nome + \". Tudo bem?\\n\") * 10 )" 493 | ] 494 | }, 495 | { 496 | "cell_type": "markdown", 497 | "metadata": {}, 498 | "source": [ 499 | "## Vamos para os números?\n", 500 | "\n", 501 | "Python pode servir de calculadora, por exemplo somar, dividir, exponenciar, módulo, etc...\n", 502 | "\n", 503 | "Lembrando que temos dois tipos básicos de numéricos: int e float.\n", 504 | "\n", 505 | "Adicionando ainda, os booleanos: True e False" 506 | ] 507 | }, 508 | { 509 | "cell_type": "code", 510 | "execution_count": 144, 511 | "metadata": {}, 512 | "outputs": [], 513 | "source": [ 514 | "numA = 10\n", 515 | "numB = 20\n", 516 | "\n", 517 | "soma = numA + numB\n", 518 | "sub = numA - numB\n", 519 | "mult = numA * numB\n", 520 | "divisao = numA / numB\n", 521 | "resto = 5 % 2\n", 522 | "potencia = 10 ** 2\n", 523 | "raiz = 4 ** (1/2)" 524 | ] 525 | }, 526 | { 527 | "cell_type": "code", 528 | "execution_count": 145, 529 | "metadata": {}, 530 | "outputs": [ 531 | { 532 | "name": "stdout", 533 | "output_type": "stream", 534 | "text": [ 535 | "30\n", 536 | "-10\n", 537 | "200\n", 538 | "0.5\n", 539 | "1\n", 540 | "100\n", 541 | "2.0\n" 542 | ] 543 | } 544 | ], 545 | "source": [ 546 | "print(soma)\n", 547 | "print(sub)\n", 548 | "print(mult)\n", 549 | "print(divisao)\n", 550 | "print(resto)\n", 551 | "print(potencia)\n", 552 | "print(raiz)" 553 | ] 554 | }, 555 | { 556 | "cell_type": "code", 557 | "execution_count": null, 558 | "metadata": {}, 559 | "outputs": [], 560 | "source": [ 561 | "# inteiros\n", 562 | "# -1, 10, 2000000000000\n", 563 | "\n", 564 | "# float\n", 565 | "# -2.345, 8.76217356, 10.0000001, 1.0\n", 566 | "\n", 567 | "# Booleanos\n", 568 | "# True, False" 569 | ] 570 | }, 571 | { 572 | "cell_type": "code", 573 | "execution_count": 154, 574 | "metadata": {}, 575 | "outputs": [ 576 | { 577 | "data": { 578 | "text/plain": [ 579 | "12" 580 | ] 581 | }, 582 | "execution_count": 154, 583 | "metadata": {}, 584 | "output_type": "execute_result" 585 | } 586 | ], 587 | "source": [ 588 | "True + True + 10" 589 | ] 590 | }, 591 | { 592 | "cell_type": "code", 593 | "execution_count": 7, 594 | "metadata": {}, 595 | "outputs": [], 596 | "source": [ 597 | "# 1 + 1\n", 598 | "\n", 599 | "# 1 - 1\n", 600 | "\n", 601 | "# 1 / 1\n", 602 | "\n", 603 | "# 1 * 1\n", 604 | "\n", 605 | "# 1 % 1\n", 606 | "\n", 607 | "# 1 ** 1\n", 608 | "\n", 609 | "# True + True" 610 | ] 611 | }, 612 | { 613 | "cell_type": "code", 614 | "execution_count": 155, 615 | "metadata": {}, 616 | "outputs": [ 617 | { 618 | "name": "stdout", 619 | "output_type": "stream", 620 | "text": [ 621 | "Entre com seu nome: Téo\n", 622 | "Olá Téo! Seja bem vindo!\n" 623 | ] 624 | } 625 | ], 626 | "source": [ 627 | "# Exercicio 01\n", 628 | "# Nome da pessoa na saudação\n", 629 | "\n", 630 | "nome = input(\"Entre com seu nome: \")\n", 631 | "print(\"Olá \", nome, \"! Seja bem vindo!\", sep=\"\")" 632 | ] 633 | }, 634 | { 635 | "cell_type": "code", 636 | "execution_count": 157, 637 | "metadata": {}, 638 | "outputs": [ 639 | { 640 | "name": "stdout", 641 | "output_type": "stream", 642 | "text": [ 643 | "Entre com o seu nome: Téo\n", 644 | "Entre com a sua idade: 28\n", 645 | "Olá Téo!! Que bom saber que você tem 28 anos. Seja bem vindo!\n" 646 | ] 647 | } 648 | ], 649 | "source": [ 650 | "# Exercicio 2\n", 651 | "# Nome e idade da pessoa na saudação\n", 652 | "\n", 653 | "nome = input(\"Entre com o seu nome: \")\n", 654 | "idade = input(\"Entre com a sua idade: \")\n", 655 | "msg = f\"Olá {nome}!! Que bom saber que você tem {idade} anos. Seja bem vindo!\"\n", 656 | "print(msg)" 657 | ] 658 | }, 659 | { 660 | "cell_type": "code", 661 | "execution_count": 164, 662 | "metadata": {}, 663 | "outputs": [ 664 | { 665 | "name": "stdout", 666 | "output_type": "stream", 667 | "text": [ 668 | "Entre com o raio: 13\n", 669 | "Área: 530.66\n", 670 | "Área: 81.64\n" 671 | ] 672 | } 673 | ], 674 | "source": [ 675 | "# Exercicio 3\n", 676 | "# Área e Perimetro\n", 677 | "\n", 678 | "raio = float(input(\"Entre com o raio: \"))\n", 679 | "area = 3.14 * raio * raio\n", 680 | "perimetro = round(2 * 3.14 * raio, 2)\n", 681 | "\n", 682 | "print(f\"Área: {area:.2f}\")\n", 683 | "print(f\"Área: {perimetro:.2f}\")" 684 | ] 685 | }, 686 | { 687 | "cell_type": "markdown", 688 | "metadata": {}, 689 | "source": [ 690 | "## Tipos iteráveis\n", 691 | "\n", 692 | "Tipos iteráveis são tipos de dados que podemos de alguma forma iterar por eles. Mas o que diabos é iterar? Iterar é a possibilidade de criar iterações (loops) a partir de uma determinada condição lógica ou objeto a ser percorrido (iterado).\n", 693 | "\n", 694 | "Exemplo de iteráveis:\n", 695 | "\n", 696 | "- listas\n", 697 | "- tuplas\n", 698 | "- dicionários\n", 699 | "- range\n", 700 | "\n", 701 | "ps. Strings são iteráveis também.\n", 702 | "\n", 703 | "Vamos começar com listas...\n", 704 | "\n", 705 | "## Listas\n", 706 | "\n", 707 | "Listas são objetos que carregam (apontam) para um conjunto finito de quaiquer outros tipos de objetos. Pense me listas como vagões de trem que carregam uma determinada carga, onde cada um desses vagões pode conter tipos de carga totalmente diferentes. Ou seja, em um vagão pode haver minério, no outro madeira, e no outro conter pessoas." 708 | ] 709 | }, 710 | { 711 | "cell_type": "code", 712 | "execution_count": 166, 713 | "metadata": {}, 714 | "outputs": [ 715 | { 716 | "name": "stdout", 717 | "output_type": "stream", 718 | "text": [ 719 | "Entre com a nota1: 10\n", 720 | "Entre com a nota2: 9.3\n", 721 | "Entre com a nota3: 8.5\n", 722 | "Entre com a nota4: 4\n" 723 | ] 724 | } 725 | ], 726 | "source": [ 727 | "nota1 = float(input(\"Entre com a nota1: \"))\n", 728 | "nota2 = float(input(\"Entre com a nota2: \"))\n", 729 | "nota3 = float(input(\"Entre com a nota3: \"))\n", 730 | "nota4 = float(input(\"Entre com a nota4: \"))" 731 | ] 732 | }, 733 | { 734 | "cell_type": "code", 735 | "execution_count": 169, 736 | "metadata": {}, 737 | "outputs": [], 738 | "source": [ 739 | "llista_vazia = []\n", 740 | "notas = [nota1, nota2, nota3, nota4]" 741 | ] 742 | }, 743 | { 744 | "cell_type": "code", 745 | "execution_count": 170, 746 | "metadata": {}, 747 | "outputs": [ 748 | { 749 | "name": "stdout", 750 | "output_type": "stream", 751 | "text": [ 752 | "Primeira nota: 10.0\n", 753 | "Primeira segunda: 9.3\n", 754 | "Primeira terceira: 8.5\n", 755 | "Primeira quarta: 4.0\n" 756 | ] 757 | } 758 | ], 759 | "source": [ 760 | "print(\"Primeira nota:\", notas[0])\n", 761 | "print(\"Primeira segunda:\", notas[1])\n", 762 | "print(\"Primeira terceira:\", notas[2])\n", 763 | "print(\"Primeira quarta:\", notas[3])" 764 | ] 765 | }, 766 | { 767 | "cell_type": "code", 768 | "execution_count": 172, 769 | "metadata": {}, 770 | "outputs": [ 771 | { 772 | "data": { 773 | "text/plain": [ 774 | "[9.3, 8.5]" 775 | ] 776 | }, 777 | "execution_count": 172, 778 | "metadata": {}, 779 | "output_type": "execute_result" 780 | } 781 | ], 782 | "source": [ 783 | "notas[1:3]" 784 | ] 785 | }, 786 | { 787 | "cell_type": "code", 788 | "execution_count": 228, 789 | "metadata": {}, 790 | "outputs": [], 791 | "source": [ 792 | "dados_teo = [\"Teo\", \"Calvo\", 28, \"Nah\", \"Kira\",\n", 793 | " [\"Camis\", \"Jacque\"],\n", 794 | " [\"Ana\", \"Maria\", \"Judite\", \"Clara\"] ]" 795 | ] 796 | }, 797 | { 798 | "cell_type": "code", 799 | "execution_count": 229, 800 | "metadata": {}, 801 | "outputs": [ 802 | { 803 | "data": { 804 | "text/plain": [ 805 | "7" 806 | ] 807 | }, 808 | "execution_count": 229, 809 | "metadata": {}, 810 | "output_type": "execute_result" 811 | } 812 | ], 813 | "source": [ 814 | "len(dados_teo)" 815 | ] 816 | }, 817 | { 818 | "cell_type": "code", 819 | "execution_count": 230, 820 | "metadata": {}, 821 | "outputs": [ 822 | { 823 | "data": { 824 | "text/plain": [ 825 | "'Jacque'" 826 | ] 827 | }, 828 | "execution_count": 230, 829 | "metadata": {}, 830 | "output_type": "execute_result" 831 | } 832 | ], 833 | "source": [ 834 | "# Ultima pessoa que lidero\n", 835 | "dados_teo[5][-1]" 836 | ] 837 | }, 838 | { 839 | "cell_type": "code", 840 | "execution_count": 231, 841 | "metadata": {}, 842 | "outputs": [ 843 | { 844 | "data": { 845 | "text/plain": [ 846 | "['Ana', 'Maria', 'Judite', 'Clara']" 847 | ] 848 | }, 849 | "execution_count": 231, 850 | "metadata": {}, 851 | "output_type": "execute_result" 852 | } 853 | ], 854 | "source": [ 855 | "# Lista das Ex-namoradas\n", 856 | "dados_teo[-1]" 857 | ] 858 | }, 859 | { 860 | "cell_type": "code", 861 | "execution_count": 234, 862 | "metadata": {}, 863 | "outputs": [ 864 | { 865 | "data": { 866 | "text/plain": [ 867 | "'h'" 868 | ] 869 | }, 870 | "execution_count": 234, 871 | "metadata": {}, 872 | "output_type": "execute_result" 873 | } 874 | ], 875 | "source": [ 876 | "# Ultima letra do nome da esposa\n", 877 | "dados_teo[3][-1]" 878 | ] 879 | }, 880 | { 881 | "cell_type": "code", 882 | "execution_count": 233, 883 | "metadata": {}, 884 | "outputs": [], 885 | "source": [ 886 | "# Remove a coitada da Maria\n", 887 | "dados_teo[-1].remove(\"Maria\") # Altera a própria lista" 888 | ] 889 | }, 890 | { 891 | "cell_type": "code", 892 | "execution_count": 217, 893 | "metadata": {}, 894 | "outputs": [ 895 | { 896 | "name": "stdout", 897 | "output_type": "stream", 898 | "text": [ 899 | "Entre com sua nota: 10\n", 900 | "Entre com sua nota: 9.5\n", 901 | "Entre com sua nota: 8.4\n", 902 | "Entre com sua nota: 4.8\n", 903 | "Entre com sua nota: 10\n", 904 | "[10.0, 9.5, 8.4, 4.8, 10.0]\n", 905 | "8.174999999999999\n", 906 | "10.674999999999999\n", 907 | "8.54\n" 908 | ] 909 | } 910 | ], 911 | "source": [ 912 | "# Como adicionar um elemento à listas\n", 913 | "\n", 914 | "notas = []\n", 915 | "n = float(input(\"Entre com sua nota: \"))\n", 916 | "notas.append(n)\n", 917 | "\n", 918 | "n = float(input(\"Entre com sua nota: \"))\n", 919 | "notas.append(n)\n", 920 | "\n", 921 | "n = float(input(\"Entre com sua nota: \"))\n", 922 | "notas.append(n)\n", 923 | "\n", 924 | "n = float(input(\"Entre com sua nota: \"))\n", 925 | "notas.append(n)\n", 926 | "\n", 927 | "n = float(input(\"Entre com sua nota: \"))\n", 928 | "notas.append(n)\n", 929 | "\n", 930 | "print(notas)\n", 931 | "\n", 932 | "print( (notas[0] + notas[1] + notas[2] + notas[3])/4 )\n", 933 | "print( sum(notas)/4 )\n", 934 | "print( sum(notas)/len(notas) )" 935 | ] 936 | }, 937 | { 938 | "cell_type": "code", 939 | "execution_count": 242, 940 | "metadata": {}, 941 | "outputs": [ 942 | { 943 | "name": "stdout", 944 | "output_type": "stream", 945 | "text": [ 946 | "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n" 947 | ] 948 | } 949 | ], 950 | "source": [ 951 | "# LISTA SÃO OBJETOS MUTAVEIS!!!!\n", 952 | "numeros = [1,2,3]\n", 953 | "numeros = numeros + [4,5,6]\n", 954 | "numeros.extend([7,8,9]) # Isso altera a própria lista\n", 955 | "numeros += [10,11,12]\n", 956 | "print(numeros)" 957 | ] 958 | }, 959 | { 960 | "cell_type": "code", 961 | "execution_count": 243, 962 | "metadata": {}, 963 | "outputs": [], 964 | "source": [ 965 | "# Inverte a ordem dos elementos da própria lista\n", 966 | "# Isso altera a própria lista\n", 967 | "numeros.reverse()" 968 | ] 969 | }, 970 | { 971 | "cell_type": "code", 972 | "execution_count": 254, 973 | "metadata": {}, 974 | "outputs": [ 975 | { 976 | "data": { 977 | "text/plain": [ 978 | "[30, 28, 'Calvo', 'Lara', 'Téo']" 979 | ] 980 | }, 981 | "execution_count": 254, 982 | "metadata": {}, 983 | "output_type": "execute_result" 984 | } 985 | ], 986 | "source": [ 987 | "minha_lista = [\"Téo\", \"Lara\", \"Calvo\", 28, 30]\n", 988 | "minha_lista.reverse()\n", 989 | "minha_lista" 990 | ] 991 | }, 992 | { 993 | "cell_type": "code", 994 | "execution_count": 255, 995 | "metadata": {}, 996 | "outputs": [ 997 | { 998 | "name": "stdout", 999 | "output_type": "stream", 1000 | "text": [ 1001 | "O elemento Téo foi removido\n", 1002 | "O elemento 30 foi removido\n" 1003 | ] 1004 | } 1005 | ], 1006 | "source": [ 1007 | "print(\"O elemento\", minha_lista.pop(), \"foi removido\")\n", 1008 | "\n", 1009 | "removido = minha_lista.pop(0)\n", 1010 | "print(\"O elemento\", removido, \"foi removido\")" 1011 | ] 1012 | }, 1013 | { 1014 | "cell_type": "code", 1015 | "execution_count": 252, 1016 | "metadata": {}, 1017 | "outputs": [], 1018 | "source": [ 1019 | "# Isso é um reverse que retorna uma nova lista\n", 1020 | "numeros_asc = numeros[::-1]" 1021 | ] 1022 | }, 1023 | { 1024 | "cell_type": "code", 1025 | "execution_count": 8, 1026 | "metadata": {}, 1027 | "outputs": [], 1028 | "source": [ 1029 | "# Exemplo de listas\n", 1030 | "\n", 1031 | "# Posição de um elemento\n", 1032 | "\n", 1033 | "# Concatenação de listas\n", 1034 | "\n", 1035 | "# Métodos de listas\n", 1036 | "\n", 1037 | "# Fatiamento" 1038 | ] 1039 | }, 1040 | { 1041 | "cell_type": "markdown", 1042 | "metadata": {}, 1043 | "source": [ 1044 | "## Tuplas\n", 1045 | "\n", 1046 | "### Maneira feia de definir tuplas:\n", 1047 | "\n", 1048 | "Tuplas são listas imutáveis. Mas o que e isso?" 1049 | ] 1050 | }, 1051 | { 1052 | "cell_type": "code", 1053 | "execution_count": 269, 1054 | "metadata": {}, 1055 | "outputs": [ 1056 | { 1057 | "data": { 1058 | "text/plain": [ 1059 | "(1,)" 1060 | ] 1061 | }, 1062 | "execution_count": 269, 1063 | "metadata": {}, 1064 | "output_type": "execute_result" 1065 | } 1066 | ], 1067 | "source": [ 1068 | "tupla_unitaria = (1,)\n", 1069 | "tupla_unitaria" 1070 | ] 1071 | }, 1072 | { 1073 | "cell_type": "code", 1074 | "execution_count": 271, 1075 | "metadata": {}, 1076 | "outputs": [ 1077 | { 1078 | "data": { 1079 | "text/plain": [ 1080 | "(1, 2, 3, 4, 5, 6)" 1081 | ] 1082 | }, 1083 | "execution_count": 271, 1084 | "metadata": {}, 1085 | "output_type": "execute_result" 1086 | } 1087 | ], 1088 | "source": [ 1089 | "minha_tupla = (1,2,3,4,5)\n", 1090 | "\n", 1091 | "outra_tupla = 1,2,3,4,5,6\n", 1092 | "outra_tupla" 1093 | ] 1094 | }, 1095 | { 1096 | "cell_type": "code", 1097 | "execution_count": 261, 1098 | "metadata": {}, 1099 | "outputs": [ 1100 | { 1101 | "data": { 1102 | "text/plain": [ 1103 | "[1, 2, 3, 4, 5]" 1104 | ] 1105 | }, 1106 | "execution_count": 261, 1107 | "metadata": {}, 1108 | "output_type": "execute_result" 1109 | } 1110 | ], 1111 | "source": [ 1112 | "lista_da_tuplas = list(minha_tupla)\n", 1113 | "lista_da_tupla" 1114 | ] 1115 | }, 1116 | { 1117 | "cell_type": "code", 1118 | "execution_count": 263, 1119 | "metadata": {}, 1120 | "outputs": [ 1121 | { 1122 | "data": { 1123 | "text/plain": [ 1124 | "(1, 2, 3, 4, 5)" 1125 | ] 1126 | }, 1127 | "execution_count": 263, 1128 | "metadata": {}, 1129 | "output_type": "execute_result" 1130 | } 1131 | ], 1132 | "source": [ 1133 | "volta_tupla = tuple(lista_da_tuplas)\n", 1134 | "volta_tupla" 1135 | ] 1136 | }, 1137 | { 1138 | "cell_type": "code", 1139 | "execution_count": 9, 1140 | "metadata": {}, 1141 | "outputs": [], 1142 | "source": [ 1143 | "# Exemplo de tuplas\n", 1144 | "\n", 1145 | "# Posição de um elemento\n", 1146 | "\n", 1147 | "# Concatenação de tuplas\n", 1148 | "\n", 1149 | "# Métodos de tuplas\n", 1150 | "\n", 1151 | "# Fatiamento" 1152 | ] 1153 | }, 1154 | { 1155 | "cell_type": "markdown", 1156 | "metadata": {}, 1157 | "source": [ 1158 | "## Dicionários\n", 1159 | "\n", 1160 | "Dicionários não estruturas de dados referentes à pares de chave/valor. Isso significa que vc atrela um valor a determinada chave, ao invés de uma posição, como no caso das listas e tuplas. Ressalto que o 'valor' pode ser qualquer tipo de objeto." 1161 | ] 1162 | }, 1163 | { 1164 | "cell_type": "code", 1165 | "execution_count": 317, 1166 | "metadata": {}, 1167 | "outputs": [], 1168 | "source": [ 1169 | "dados_teo = [\"Teo\", \"Calvo\", 28, \"Nah\", \"Kira\",\n", 1170 | " [\"Camis\", \"Jacque\"],\n", 1171 | " [\"Ana\", \"Maria\", \"Judite\", \"Clara\"] ]" 1172 | ] 1173 | }, 1174 | { 1175 | "cell_type": "code", 1176 | "execution_count": 339, 1177 | "metadata": {}, 1178 | "outputs": [], 1179 | "source": [ 1180 | "meu_dict = {'nome':\"Téo\",\n", 1181 | " \n", 1182 | " 'sobrenome':\"Calvo\",\n", 1183 | " \n", 1184 | " 'liderados(as)':[{\"nome\":\"Camis\",\"cargo\":\"DSIII\"},\n", 1185 | " {\"nome\":\"Jacque\",\"cargo\":\"DSIII\"}],\n", 1186 | " \n", 1187 | " 'exs':[{\"nome\":\"Ana\", \"ano\":2010},\n", 1188 | " {\"nome\":\"Maria\",\"ano\":2008},\n", 1189 | " {\"nome\":\"Judite\",\"ano\":2005},\n", 1190 | " {\"nome\":\"Clara\",\"ano\":2004}]\n", 1191 | " }" 1192 | ] 1193 | }, 1194 | { 1195 | "cell_type": "code", 1196 | "execution_count": 340, 1197 | "metadata": {}, 1198 | "outputs": [ 1199 | { 1200 | "data": { 1201 | "text/plain": [ 1202 | "'Ana'" 1203 | ] 1204 | }, 1205 | "execution_count": 340, 1206 | "metadata": {}, 1207 | "output_type": "execute_result" 1208 | } 1209 | ], 1210 | "source": [ 1211 | "meu_dict['exs'][0]['nome']" 1212 | ] 1213 | }, 1214 | { 1215 | "cell_type": "code", 1216 | "execution_count": 341, 1217 | "metadata": {}, 1218 | "outputs": [ 1219 | { 1220 | "data": { 1221 | "text/plain": [ 1222 | "{'nome': 'Ana', 'ano': 2010}" 1223 | ] 1224 | }, 1225 | "execution_count": 341, 1226 | "metadata": {}, 1227 | "output_type": "execute_result" 1228 | } 1229 | ], 1230 | "source": [ 1231 | "# Removendo a Ana das Exs\n", 1232 | "meu_dict['exs'].pop(0)" 1233 | ] 1234 | }, 1235 | { 1236 | "cell_type": "code", 1237 | "execution_count": 342, 1238 | "metadata": {}, 1239 | "outputs": [ 1240 | { 1241 | "data": { 1242 | "text/plain": [ 1243 | "{'nome': 'Téo',\n", 1244 | " 'sobrenome': 'Calvo',\n", 1245 | " 'liderados(as)': [{'nome': 'Camis', 'cargo': 'DSIII'},\n", 1246 | " {'nome': 'Jacque', 'cargo': 'DSIII'}],\n", 1247 | " 'exs': [{'nome': 'Maria', 'ano': 2008},\n", 1248 | " {'nome': 'Judite', 'ano': 2005},\n", 1249 | " {'nome': 'Clara', 'ano': 2004}]}" 1250 | ] 1251 | }, 1252 | "execution_count": 342, 1253 | "metadata": {}, 1254 | "output_type": "execute_result" 1255 | } 1256 | ], 1257 | "source": [ 1258 | "meu_dict" 1259 | ] 1260 | }, 1261 | { 1262 | "cell_type": "code", 1263 | "execution_count": 343, 1264 | "metadata": {}, 1265 | "outputs": [ 1266 | { 1267 | "data": { 1268 | "text/plain": [ 1269 | "dict" 1270 | ] 1271 | }, 1272 | "execution_count": 343, 1273 | "metadata": {}, 1274 | "output_type": "execute_result" 1275 | } 1276 | ], 1277 | "source": [ 1278 | "type(meu_dict)" 1279 | ] 1280 | }, 1281 | { 1282 | "cell_type": "code", 1283 | "execution_count": 344, 1284 | "metadata": {}, 1285 | "outputs": [ 1286 | { 1287 | "data": { 1288 | "text/plain": [ 1289 | "list" 1290 | ] 1291 | }, 1292 | "execution_count": 344, 1293 | "metadata": {}, 1294 | "output_type": "execute_result" 1295 | } 1296 | ], 1297 | "source": [ 1298 | "type(meu_dict['liderados(as)'])" 1299 | ] 1300 | }, 1301 | { 1302 | "cell_type": "code", 1303 | "execution_count": 345, 1304 | "metadata": {}, 1305 | "outputs": [ 1306 | { 1307 | "data": { 1308 | "text/plain": [ 1309 | "{'nome': 'Maria', 'ano': 2008}" 1310 | ] 1311 | }, 1312 | "execution_count": 345, 1313 | "metadata": {}, 1314 | "output_type": "execute_result" 1315 | } 1316 | ], 1317 | "source": [ 1318 | "meu_dict['exs'][0]" 1319 | ] 1320 | }, 1321 | { 1322 | "cell_type": "code", 1323 | "execution_count": 346, 1324 | "metadata": {}, 1325 | "outputs": [ 1326 | { 1327 | "data": { 1328 | "text/plain": [ 1329 | "dict" 1330 | ] 1331 | }, 1332 | "execution_count": 346, 1333 | "metadata": {}, 1334 | "output_type": "execute_result" 1335 | } 1336 | ], 1337 | "source": [ 1338 | "type(meu_dict)" 1339 | ] 1340 | }, 1341 | { 1342 | "cell_type": "code", 1343 | "execution_count": 347, 1344 | "metadata": {}, 1345 | "outputs": [ 1346 | { 1347 | "data": { 1348 | "text/plain": [ 1349 | "{'nome': 'Téo',\n", 1350 | " 'sobrenome': 'Calvo',\n", 1351 | " 'liderados(as)': [{'nome': 'Camis', 'cargo': 'DSIII'},\n", 1352 | " {'nome': 'Jacque', 'cargo': 'DSIII'}]}" 1353 | ] 1354 | }, 1355 | "execution_count": 347, 1356 | "metadata": {}, 1357 | "output_type": "execute_result" 1358 | } 1359 | ], 1360 | "source": [ 1361 | "# removendo ex namoradas\n", 1362 | "ex = meu_dict.pop(\"exs\")\n", 1363 | "meu_dict" 1364 | ] 1365 | }, 1366 | { 1367 | "cell_type": "code", 1368 | "execution_count": 348, 1369 | "metadata": {}, 1370 | "outputs": [ 1371 | { 1372 | "data": { 1373 | "text/plain": [ 1374 | "dict_keys(['nome', 'sobrenome', 'liderados(as)'])" 1375 | ] 1376 | }, 1377 | "execution_count": 348, 1378 | "metadata": {}, 1379 | "output_type": "execute_result" 1380 | } 1381 | ], 1382 | "source": [ 1383 | "# Quais são as chaves do meu dicionário?\n", 1384 | "meu_dict.keys()" 1385 | ] 1386 | }, 1387 | { 1388 | "cell_type": "code", 1389 | "execution_count": 349, 1390 | "metadata": {}, 1391 | "outputs": [ 1392 | { 1393 | "data": { 1394 | "text/plain": [ 1395 | "dict_values(['Téo', 'Calvo', [{'nome': 'Camis', 'cargo': 'DSIII'}, {'nome': 'Jacque', 'cargo': 'DSIII'}]])" 1396 | ] 1397 | }, 1398 | "execution_count": 349, 1399 | "metadata": {}, 1400 | "output_type": "execute_result" 1401 | } 1402 | ], 1403 | "source": [ 1404 | "# Quais são os valores?\n", 1405 | "meu_dict.values()" 1406 | ] 1407 | }, 1408 | { 1409 | "cell_type": "code", 1410 | "execution_count": 350, 1411 | "metadata": {}, 1412 | "outputs": [ 1413 | { 1414 | "data": { 1415 | "text/plain": [ 1416 | "dict_items([('nome', 'Téo'), ('sobrenome', 'Calvo'), ('liderados(as)', [{'nome': 'Camis', 'cargo': 'DSIII'}, {'nome': 'Jacque', 'cargo': 'DSIII'}])])" 1417 | ] 1418 | }, 1419 | "execution_count": 350, 1420 | "metadata": {}, 1421 | "output_type": "execute_result" 1422 | } 1423 | ], 1424 | "source": [ 1425 | "# Quais são os items?\n", 1426 | "meu_dict.items()" 1427 | ] 1428 | }, 1429 | { 1430 | "cell_type": "code", 1431 | "execution_count": 351, 1432 | "metadata": {}, 1433 | "outputs": [], 1434 | "source": [ 1435 | "# Criando nova chave\n", 1436 | "meu_dict['pet'] = 'Kira'" 1437 | ] 1438 | }, 1439 | { 1440 | "cell_type": "code", 1441 | "execution_count": 352, 1442 | "metadata": {}, 1443 | "outputs": [], 1444 | "source": [ 1445 | "meu_dict['liderados(as)'][0]['olhos'] = 'verdes'" 1446 | ] 1447 | }, 1448 | { 1449 | "cell_type": "code", 1450 | "execution_count": 357, 1451 | "metadata": {}, 1452 | "outputs": [ 1453 | { 1454 | "data": { 1455 | "text/plain": [ 1456 | "'verdes'" 1457 | ] 1458 | }, 1459 | "execution_count": 357, 1460 | "metadata": {}, 1461 | "output_type": "execute_result" 1462 | } 1463 | ], 1464 | "source": [ 1465 | "meu_dict['liderados(as)'][0]['olhos']" 1466 | ] 1467 | }, 1468 | { 1469 | "cell_type": "code", 1470 | "execution_count": 358, 1471 | "metadata": {}, 1472 | "outputs": [ 1473 | { 1474 | "data": { 1475 | "text/plain": [ 1476 | "{'nome': 'Téo',\n", 1477 | " 'sobrenome': 'Calvo',\n", 1478 | " 'liderados(as)': [{'nome': 'Camis', 'cargo': 'DSIII', 'olhos': 'verdes'},\n", 1479 | " {'nome': 'Jacque', 'cargo': 'DSIII'}],\n", 1480 | " 'pet': 'Kira'}" 1481 | ] 1482 | }, 1483 | "execution_count": 358, 1484 | "metadata": {}, 1485 | "output_type": "execute_result" 1486 | } 1487 | ], 1488 | "source": [ 1489 | "meu_dict" 1490 | ] 1491 | }, 1492 | { 1493 | "cell_type": "code", 1494 | "execution_count": 359, 1495 | "metadata": {}, 1496 | "outputs": [ 1497 | { 1498 | "name": "stdout", 1499 | "output_type": "stream", 1500 | "text": [ 1501 | "Téo Kira\n" 1502 | ] 1503 | } 1504 | ], 1505 | "source": [ 1506 | "print(meu_dict['nome'], meu_dict['pet'])" 1507 | ] 1508 | }, 1509 | { 1510 | "cell_type": "code", 1511 | "execution_count": 360, 1512 | "metadata": {}, 1513 | "outputs": [ 1514 | { 1515 | "data": { 1516 | "text/plain": [ 1517 | "{'nome': 'Téo',\n", 1518 | " 'sobrenome': 'Calvo',\n", 1519 | " 'liderados(as)': [{'nome': 'Camis', 'cargo': 'DSIII', 'olhos': 'verdes'},\n", 1520 | " {'nome': 'Jacque', 'cargo': 'DSIII'}],\n", 1521 | " 'pet': 'Kira'}" 1522 | ] 1523 | }, 1524 | "execution_count": 360, 1525 | "metadata": {}, 1526 | "output_type": "execute_result" 1527 | } 1528 | ], 1529 | "source": [ 1530 | "meu_dict" 1531 | ] 1532 | }, 1533 | { 1534 | "cell_type": "code", 1535 | "execution_count": 10, 1536 | "metadata": {}, 1537 | "outputs": [], 1538 | "source": [ 1539 | "# Exemplo de dicionário\n", 1540 | "\n", 1541 | "# Valor de uma chave\n", 1542 | "\n", 1543 | "# Mostrar todas as chaves\n", 1544 | "\n", 1545 | "# Mostrar todos os valores" 1546 | ] 1547 | }, 1548 | { 1549 | "cell_type": "markdown", 1550 | "metadata": {}, 1551 | "source": [ 1552 | "## Funções\n", 1553 | "\n", 1554 | "Funções são nossas amigas para reaproveitar código. Assim, caso tenha algum tipo de execução que seja parecido, não é necessário escrever o mesmo código toda vez." 1555 | ] 1556 | }, 1557 | { 1558 | "cell_type": "code", 1559 | "execution_count": 11, 1560 | "metadata": {}, 1561 | "outputs": [], 1562 | "source": [ 1563 | "# f(x) = x**2 + 2 * x + 10" 1564 | ] 1565 | }, 1566 | { 1567 | "cell_type": "code", 1568 | "execution_count": 367, 1569 | "metadata": {}, 1570 | "outputs": [], 1571 | "source": [ 1572 | "def f(x):\n", 1573 | " resultado = x**2 + 2 * x + 10\n", 1574 | " return resultado" 1575 | ] 1576 | }, 1577 | { 1578 | "cell_type": "code", 1579 | "execution_count": 372, 1580 | "metadata": {}, 1581 | "outputs": [], 1582 | "source": [ 1583 | "minha_var = f(10)\n", 1584 | "minha_var" 1585 | ] 1586 | }, 1587 | { 1588 | "cell_type": "code", 1589 | "execution_count": 369, 1590 | "metadata": {}, 1591 | "outputs": [], 1592 | "source": [ 1593 | "def ola():\n", 1594 | " print(\"Olá pessoal\")" 1595 | ] 1596 | }, 1597 | { 1598 | "cell_type": "code", 1599 | "execution_count": 374, 1600 | "metadata": {}, 1601 | "outputs": [ 1602 | { 1603 | "name": "stdout", 1604 | "output_type": "stream", 1605 | "text": [ 1606 | "Olá pessoal\n" 1607 | ] 1608 | } 1609 | ], 1610 | "source": [ 1611 | "nova_var = ola()" 1612 | ] 1613 | }, 1614 | { 1615 | "cell_type": "code", 1616 | "execution_count": 379, 1617 | "metadata": {}, 1618 | "outputs": [ 1619 | { 1620 | "data": { 1621 | "text/plain": [ 1622 | "NoneType" 1623 | ] 1624 | }, 1625 | "execution_count": 379, 1626 | "metadata": {}, 1627 | "output_type": "execute_result" 1628 | } 1629 | ], 1630 | "source": [ 1631 | "type(nova_var)" 1632 | ] 1633 | }, 1634 | { 1635 | "cell_type": "code", 1636 | "execution_count": 382, 1637 | "metadata": {}, 1638 | "outputs": [], 1639 | "source": [ 1640 | "def saudacao(nome):\n", 1641 | " print(\"Olá \", nome, \". Seja bem vindo!!\",sep=\"\")" 1642 | ] 1643 | }, 1644 | { 1645 | "cell_type": "code", 1646 | "execution_count": 384, 1647 | "metadata": {}, 1648 | "outputs": [ 1649 | { 1650 | "name": "stdout", 1651 | "output_type": "stream", 1652 | "text": [ 1653 | "Olá Téo. Seja bem vindo!!\n", 1654 | "Olá Mari. Seja bem vindo!!\n" 1655 | ] 1656 | } 1657 | ], 1658 | "source": [ 1659 | "saudacao(\"Téo\")\n", 1660 | "saudacao(\"Mari\")" 1661 | ] 1662 | }, 1663 | { 1664 | "cell_type": "code", 1665 | "execution_count": 386, 1666 | "metadata": {}, 1667 | "outputs": [ 1668 | { 1669 | "name": "stdout", 1670 | "output_type": "stream", 1671 | "text": [ 1672 | "Entre com o seu nomeTéo Calvo\n", 1673 | "Olá Téo Calvo. Seja bem vindo!!\n", 1674 | "Entre com o seu nomeMari Lima\n", 1675 | "Olá Mari Lima. Seja bem vindo!!\n" 1676 | ] 1677 | } 1678 | ], 1679 | "source": [ 1680 | "def saudacao(nome):\n", 1681 | " print(\"Olá \", nome, \". Seja bem vindo!!\",sep=\"\")\n", 1682 | " \n", 1683 | "nome_pessoa = input(\"Entre com o seu nome\")\n", 1684 | "saudacao(nome_pessoa)\n", 1685 | "\n", 1686 | "nome_pessoa = input(\"Entre com o seu nome\")\n", 1687 | "saudacao(nome_pessoa)" 1688 | ] 1689 | }, 1690 | { 1691 | "cell_type": "markdown", 1692 | "metadata": {}, 1693 | "source": [ 1694 | "## Controle de Fluxo\n", 1695 | "\n", 1696 | "No python é possível alterar a sequencia de leitura das linhas, fazendo uso de 'funções' especiais para tal. Exemplo de operadores que alteram o fluxo de um programa:\n", 1697 | "\n", 1698 | "- if\n", 1699 | "\n", 1700 | "- elif\n", 1701 | "\n", 1702 | "- else\n", 1703 | "\n", 1704 | "- for\n", 1705 | "\n", 1706 | "- while\n", 1707 | "\n", 1708 | "- try\n", 1709 | "\n", 1710 | "Lembre-se que é obrigatório o uso de identação, 4 espaços são o padrão.\n", 1711 | "\n", 1712 | "### if, elif e else\n", 1713 | "\n", 1714 | "Tabelinha verdade, vocês viram em algebra elementar, certo?\n", 1715 | "\n", 1716 | "Então, verdade verdade => verdade ?\n", 1717 | "\n", 1718 | "Mesma coisa por aqui:\n", 1719 | "\n", 1720 | "if verdade => verdade e executamos\n", 1721 | "\n", 1722 | "else => executamos aqui" 1723 | ] 1724 | }, 1725 | { 1726 | "cell_type": "code", 1727 | "execution_count": 412, 1728 | "metadata": {}, 1729 | "outputs": [ 1730 | { 1731 | "data": { 1732 | "text/plain": [ 1733 | "False" 1734 | ] 1735 | }, 1736 | "execution_count": 412, 1737 | "metadata": {}, 1738 | "output_type": "execute_result" 1739 | } 1740 | ], 1741 | "source": [ 1742 | "a = [\"téo\", \"calvo\"]\n", 1743 | "b = [\"téo\", \"calvo\"]\n", 1744 | "a is b" 1745 | ] 1746 | }, 1747 | { 1748 | "cell_type": "code", 1749 | "execution_count": 413, 1750 | "metadata": {}, 1751 | "outputs": [ 1752 | { 1753 | "data": { 1754 | "text/plain": [ 1755 | "True" 1756 | ] 1757 | }, 1758 | "execution_count": 413, 1759 | "metadata": {}, 1760 | "output_type": "execute_result" 1761 | } 1762 | ], 1763 | "source": [ 1764 | "nome = \"Téo Calvo\"\n", 1765 | "\"Calvo\" in nome" 1766 | ] 1767 | }, 1768 | { 1769 | "cell_type": "code", 1770 | "execution_count": 414, 1771 | "metadata": {}, 1772 | "outputs": [ 1773 | { 1774 | "data": { 1775 | "text/plain": [ 1776 | "True" 1777 | ] 1778 | }, 1779 | "execution_count": 414, 1780 | "metadata": {}, 1781 | "output_type": "execute_result" 1782 | } 1783 | ], 1784 | "source": [ 1785 | "nums = [1,2,3,4,5,6]\n", 1786 | "4 in nums" 1787 | ] 1788 | }, 1789 | { 1790 | "cell_type": "code", 1791 | "execution_count": 405, 1792 | "metadata": {}, 1793 | "outputs": [ 1794 | { 1795 | "name": "stdout", 1796 | "output_type": "stream", 1797 | "text": [ 1798 | "Entre com a sua idade: 15\n", 1799 | "Vá para casa beber leite!\n" 1800 | ] 1801 | } 1802 | ], 1803 | "source": [ 1804 | "idade = int(input(\"Entre com a sua idade: \"))\n", 1805 | "\n", 1806 | "if idade >= 65:\n", 1807 | " print(\"Beba com calma, você já tem idade demais.\")\n", 1808 | "\n", 1809 | "elif idade >= 18:\n", 1810 | " print(\"Beba a vontade, só não perca a cabeça ou dirija!\")\n", 1811 | "else:\n", 1812 | " print(\"Vá para casa beber leite!\")" 1813 | ] 1814 | }, 1815 | { 1816 | "cell_type": "code", 1817 | "execution_count": 432, 1818 | "metadata": {}, 1819 | "outputs": [ 1820 | { 1821 | "name": "stdout", 1822 | "output_type": "stream", 1823 | "text": [ 1824 | "Tente a sorte: 5\n", 1825 | "Tente um número maior\n" 1826 | ] 1827 | } 1828 | ], 1829 | "source": [ 1830 | "# LOTERIA DA BABILONIA!!!\n", 1831 | "num = 7\n", 1832 | "palpite = int(input(\"Tente a sorte: \"))\n", 1833 | "\n", 1834 | "if palpite == num:\n", 1835 | " print(\"ACERTOU, MISERAVI!!\")\n", 1836 | "elif palpite > num:\n", 1837 | " print(\"Tente um número menor\")\n", 1838 | "else:\n", 1839 | " print(\"Tente um número maior\")" 1840 | ] 1841 | }, 1842 | { 1843 | "cell_type": "code", 1844 | "execution_count": 12, 1845 | "metadata": {}, 1846 | "outputs": [], 1847 | "source": [ 1848 | "# if\n", 1849 | "\n", 1850 | "# elif\n", 1851 | "\n", 1852 | "# else" 1853 | ] 1854 | }, 1855 | { 1856 | "cell_type": "markdown", 1857 | "metadata": {}, 1858 | "source": [ 1859 | "### Laços de repetição\n", 1860 | "\n", 1861 | "For percorre um iterável (iterador), ou seja, enquanto o iterador tiver valores para ser iterado, o laço for continua:" 1862 | ] 1863 | }, 1864 | { 1865 | "cell_type": "code", 1866 | "execution_count": 417, 1867 | "metadata": {}, 1868 | "outputs": [ 1869 | { 1870 | "name": "stdout", 1871 | "output_type": "stream", 1872 | "text": [ 1873 | "l\n", 1874 | "a\n", 1875 | "r\n", 1876 | "a\n", 1877 | "n\n", 1878 | "j\n", 1879 | "a\n" 1880 | ] 1881 | } 1882 | ], 1883 | "source": [ 1884 | "# string é iterável\n", 1885 | "# listas é iterável\n", 1886 | "# tuplas é iterável\n", 1887 | "# dicionários é iteravel\n", 1888 | "\n", 1889 | "for f in \"laranja\":\n", 1890 | " print(f)" 1891 | ] 1892 | }, 1893 | { 1894 | "cell_type": "code", 1895 | "execution_count": 418, 1896 | "metadata": {}, 1897 | "outputs": [ 1898 | { 1899 | "name": "stdout", 1900 | "output_type": "stream", 1901 | "text": [ 1902 | "laranja\n", 1903 | "limão\n", 1904 | "maçã\n" 1905 | ] 1906 | } 1907 | ], 1908 | "source": [ 1909 | "frutas = ['laranja', 'limão', 'maçã']\n", 1910 | "for f in frutas:\n", 1911 | " print(f)" 1912 | ] 1913 | }, 1914 | { 1915 | "cell_type": "code", 1916 | "execution_count": 423, 1917 | "metadata": {}, 1918 | "outputs": [ 1919 | { 1920 | "data": { 1921 | "text/plain": [ 1922 | "[0, 1, 2, 3]" 1923 | ] 1924 | }, 1925 | "execution_count": 423, 1926 | "metadata": {}, 1927 | "output_type": "execute_result" 1928 | } 1929 | ], 1930 | "source": [ 1931 | "list(range(0,4))" 1932 | ] 1933 | }, 1934 | { 1935 | "cell_type": "code", 1936 | "execution_count": null, 1937 | "metadata": {}, 1938 | "outputs": [], 1939 | "source": [ 1940 | "# Como adicionar um elemento à listas\n", 1941 | "\n", 1942 | "notas = []\n", 1943 | "n = float(input(\"Entre com sua nota: \"))\n", 1944 | "notas.append(n)\n", 1945 | "\n", 1946 | "n = float(input(\"Entre com sua nota: \"))\n", 1947 | "notas.append(n)\n", 1948 | "\n", 1949 | "n = float(input(\"Entre com sua nota: \"))\n", 1950 | "notas.append(n)\n", 1951 | "\n", 1952 | "n = float(input(\"Entre com sua nota: \"))\n", 1953 | "notas.append(n)\n", 1954 | "\n", 1955 | "print( sum(notas)/len(notas) )" 1956 | ] 1957 | }, 1958 | { 1959 | "cell_type": "code", 1960 | "execution_count": 431, 1961 | "metadata": {}, 1962 | "outputs": [ 1963 | { 1964 | "name": "stdout", 1965 | "output_type": "stream", 1966 | "text": [ 1967 | "Entre com sua nota: 10\n", 1968 | "Entre com sua nota: 8.4\n", 1969 | "Entre com sua nota: 9.5\n", 1970 | "Entre com sua nota: 4.8\n", 1971 | "Sua média é: 8.17\n" 1972 | ] 1973 | } 1974 | ], 1975 | "source": [ 1976 | "notas = []\n", 1977 | "for i in range(4):\n", 1978 | " n = float(input(\"Entre com sua nota: \")) # recebe string e converte para numero real\n", 1979 | " notas.append(n) # Adiciona nota nova à lista de notas\n", 1980 | "\n", 1981 | "print(\"Sua média é: {0:.2f}\".format(sum(notas)/len(notas)))" 1982 | ] 1983 | }, 1984 | { 1985 | "cell_type": "code", 1986 | "execution_count": 7, 1987 | "metadata": { 1988 | "scrolled": true 1989 | }, 1990 | "outputs": [ 1991 | { 1992 | "name": "stdout", 1993 | "output_type": "stream", 1994 | "text": [ 1995 | "Tente a sorte: 7\n", 1996 | "ACERTOU, MISERAVI!!\n" 1997 | ] 1998 | } 1999 | ], 2000 | "source": [ 2001 | "# LOTERIA DA BABILONIA!!!\n", 2002 | "num = 7\n", 2003 | "\n", 2004 | "for i in range(3):\n", 2005 | " palpite = int(input(\"Tente a sorte: \"))\n", 2006 | " if palpite == num:\n", 2007 | " print(\"ACERTOU, MISERAVI!!\")\n", 2008 | " break\n", 2009 | " elif palpite > num:\n", 2010 | " print(\"Tente um número menor, restam\", 3-i-1, \"tentativas\")\n", 2011 | " else:\n", 2012 | " print(\"Tente um número maior, restam\", 3-i-1, \"tentativas\")\n", 2013 | "else:\n", 2014 | " print(\"Errou tudo, otário!\")" 2015 | ] 2016 | }, 2017 | { 2018 | "cell_type": "code", 2019 | "execution_count": 8, 2020 | "metadata": {}, 2021 | "outputs": [ 2022 | { 2023 | "name": "stdout", 2024 | "output_type": "stream", 2025 | "text": [ 2026 | "3 é divisivel por 3\n", 2027 | "6 é divisivel por 3\n", 2028 | "9 é divisivel por 3\n", 2029 | "12 é divisivel por 3\n", 2030 | "15 é divisivel por 3\n", 2031 | "18 é divisivel por 3\n", 2032 | "21 é divisivel por 3\n", 2033 | "24 é divisivel por 3\n", 2034 | "27 é divisivel por 3\n", 2035 | "30 é divisivel por 3\n", 2036 | "33 é divisivel por 3\n", 2037 | "36 é divisivel por 3\n", 2038 | "39 é divisivel por 3\n", 2039 | "42 é divisivel por 3\n", 2040 | "45 é divisivel por 3\n", 2041 | "48 é divisivel por 3\n", 2042 | "51 é divisivel por 3\n", 2043 | "54 é divisivel por 3\n", 2044 | "57 é divisivel por 3\n", 2045 | "60 é divisivel por 3\n", 2046 | "63 é divisivel por 3\n", 2047 | "66 é divisivel por 3\n", 2048 | "69 é divisivel por 3\n", 2049 | "72 é divisivel por 3\n", 2050 | "75 é divisivel por 3\n", 2051 | "78 é divisivel por 3\n", 2052 | "81 é divisivel por 3\n", 2053 | "84 é divisivel por 3\n", 2054 | "87 é divisivel por 3\n", 2055 | "90 é divisivel por 3\n", 2056 | "93 é divisivel por 3\n", 2057 | "96 é divisivel por 3\n", 2058 | "99 é divisivel por 3\n" 2059 | ] 2060 | } 2061 | ], 2062 | "source": [ 2063 | "for i in range(1,101):\n", 2064 | " if i % 3 == 0:\n", 2065 | " print(i, \"é divisivel por 3\")" 2066 | ] 2067 | }, 2068 | { 2069 | "cell_type": "code", 2070 | "execution_count": 19, 2071 | "metadata": {}, 2072 | "outputs": [], 2073 | "source": [ 2074 | "board = [[\"_\"]*3]*3\n", 2075 | "board[1][2] = \"X\"" 2076 | ] 2077 | }, 2078 | { 2079 | "cell_type": "code", 2080 | "execution_count": 26, 2081 | "metadata": {}, 2082 | "outputs": [], 2083 | "source": [ 2084 | "a = [1,2,3]\n", 2085 | "b = a.copy()" 2086 | ] 2087 | }, 2088 | { 2089 | "cell_type": "code", 2090 | "execution_count": 13, 2091 | "metadata": {}, 2092 | "outputs": [ 2093 | { 2094 | "name": "stdout", 2095 | "output_type": "stream", 2096 | "text": [ 2097 | "1\n", 2098 | "2\n", 2099 | "3\n", 2100 | "4\n", 2101 | "5\n", 2102 | "6\n", 2103 | "7\n", 2104 | "8\n", 2105 | "9\n", 2106 | "10\n" 2107 | ] 2108 | } 2109 | ], 2110 | "source": [ 2111 | "count = 1\n", 2112 | "while count <= 10:\n", 2113 | " print(count)\n", 2114 | " count += 1" 2115 | ] 2116 | }, 2117 | { 2118 | "cell_type": "code", 2119 | "execution_count": 29, 2120 | "metadata": {}, 2121 | "outputs": [], 2122 | "source": [ 2123 | "dados = {\"nome\":\"Téo\",\n", 2124 | " \"sobrenome\":\"Calvo\",\n", 2125 | " \"idade\":28}" 2126 | ] 2127 | }, 2128 | { 2129 | "cell_type": "code", 2130 | "execution_count": 34, 2131 | "metadata": {}, 2132 | "outputs": [ 2133 | { 2134 | "name": "stdout", 2135 | "output_type": "stream", 2136 | "text": [ 2137 | "Infelizmente essa pessoa não curte Pets\n" 2138 | ] 2139 | } 2140 | ], 2141 | "source": [ 2142 | "# Lidando com erros e excessoes\n", 2143 | "\n", 2144 | "try:\n", 2145 | " print(dados['pet'])\n", 2146 | "except KeyError:\n", 2147 | " print(\"Infelizmente essa pessoa não curte Pets\")" 2148 | ] 2149 | }, 2150 | { 2151 | "cell_type": "code", 2152 | "execution_count": 52, 2153 | "metadata": {}, 2154 | "outputs": [ 2155 | { 2156 | "name": "stdout", 2157 | "output_type": "stream", 2158 | "text": [ 2159 | "Tente a sorte: 10\n", 2160 | "Tente um número menor, restam 2 tentativas\n", 2161 | "Tente a sorte: 6\n", 2162 | "Tente um número maior, restam 1 tentativas\n", 2163 | "Tente a sorte: 9\n", 2164 | "Tente um número menor, restam 0 tentativas\n", 2165 | "Errou tudo, otário!\n" 2166 | ] 2167 | } 2168 | ], 2169 | "source": [ 2170 | "# LOTERIA DA BABILONIA!!!\n", 2171 | "\n", 2172 | "def valida_entrada(msg):\n", 2173 | " numero = None\n", 2174 | " while numero is None:\n", 2175 | " try:\n", 2176 | " numero = int(input(msg))\n", 2177 | " return numero\n", 2178 | " except ValueError:\n", 2179 | " print(\"Entre com um número válido!\")\n", 2180 | "\n", 2181 | "num = 7\n", 2182 | "\n", 2183 | "for i in range(3):\n", 2184 | " palpite = valida_entrada(\"Tente a sorte: \")\n", 2185 | " if palpite == num:\n", 2186 | " print(\"ACERTOU, MISERAVI!!\")\n", 2187 | " break\n", 2188 | " elif palpite > num:\n", 2189 | " print(\"Tente um número menor, restam\", 3-i-1, \"tentativas\")\n", 2190 | " else:\n", 2191 | " print(\"Tente um número maior, restam\", 3-i-1, \"tentativas\")\n", 2192 | "else:\n", 2193 | " print(\"Errou tudo, otário!\")" 2194 | ] 2195 | }, 2196 | { 2197 | "cell_type": "code", 2198 | "execution_count": 13, 2199 | "metadata": {}, 2200 | "outputs": [], 2201 | "source": [ 2202 | "# for i in [1,2,3]" 2203 | ] 2204 | }, 2205 | { 2206 | "cell_type": "markdown", 2207 | "metadata": {}, 2208 | "source": [ 2209 | "## Importação de bibliotecas\n", 2210 | "\n", 2211 | "É comum fazer uso de código opensource que não vem \"empacotado\" junto com o python, assim, você pode querer usar pacotes de terceiros como também criar seus próprios módulos e bibliotecas. Para fazer reuso de códigos é necessário importa-los." 2212 | ] 2213 | }, 2214 | { 2215 | "cell_type": "code", 2216 | "execution_count": 14, 2217 | "metadata": {}, 2218 | "outputs": [], 2219 | "source": [ 2220 | "# import time\n", 2221 | "# import random" 2222 | ] 2223 | }, 2224 | { 2225 | "cell_type": "code", 2226 | "execution_count": 56, 2227 | "metadata": {}, 2228 | "outputs": [], 2229 | "source": [ 2230 | "import math # importa a biblioteca inteira!!!!" 2231 | ] 2232 | }, 2233 | { 2234 | "cell_type": "code", 2235 | "execution_count": 57, 2236 | "metadata": {}, 2237 | "outputs": [ 2238 | { 2239 | "data": { 2240 | "text/plain": [ 2241 | "3.141592653589793" 2242 | ] 2243 | }, 2244 | "execution_count": 57, 2245 | "metadata": {}, 2246 | "output_type": "execute_result" 2247 | } 2248 | ], 2249 | "source": [ 2250 | "math.pi" 2251 | ] 2252 | }, 2253 | { 2254 | "cell_type": "code", 2255 | "execution_count": 58, 2256 | "metadata": {}, 2257 | "outputs": [ 2258 | { 2259 | "data": { 2260 | "text/plain": [ 2261 | "6" 2262 | ] 2263 | }, 2264 | "execution_count": 58, 2265 | "metadata": {}, 2266 | "output_type": "execute_result" 2267 | } 2268 | ], 2269 | "source": [ 2270 | "math.factorial(3)" 2271 | ] 2272 | }, 2273 | { 2274 | "cell_type": "code", 2275 | "execution_count": 67, 2276 | "metadata": {}, 2277 | "outputs": [], 2278 | "source": [ 2279 | "from math import pi\n", 2280 | "from math import factorial\n", 2281 | "\n", 2282 | "from math import e, exp" 2283 | ] 2284 | }, 2285 | { 2286 | "cell_type": "code", 2287 | "execution_count": 63, 2288 | "metadata": {}, 2289 | "outputs": [ 2290 | { 2291 | "data": { 2292 | "text/plain": [ 2293 | "6" 2294 | ] 2295 | }, 2296 | "execution_count": 63, 2297 | "metadata": {}, 2298 | "output_type": "execute_result" 2299 | } 2300 | ], 2301 | "source": [ 2302 | "factorial(3)" 2303 | ] 2304 | }, 2305 | { 2306 | "cell_type": "code", 2307 | "execution_count": 61, 2308 | "metadata": {}, 2309 | "outputs": [ 2310 | { 2311 | "data": { 2312 | "text/plain": [ 2313 | "3.141592653589793" 2314 | ] 2315 | }, 2316 | "execution_count": 61, 2317 | "metadata": {}, 2318 | "output_type": "execute_result" 2319 | } 2320 | ], 2321 | "source": [ 2322 | "pi" 2323 | ] 2324 | }, 2325 | { 2326 | "cell_type": "code", 2327 | "execution_count": 64, 2328 | "metadata": {}, 2329 | "outputs": [], 2330 | "source": [ 2331 | "from math import * # isso não é legal!!!!" 2332 | ] 2333 | }, 2334 | { 2335 | "cell_type": "code", 2336 | "execution_count": 65, 2337 | "metadata": {}, 2338 | "outputs": [ 2339 | { 2340 | "data": { 2341 | "text/plain": [ 2342 | "2.718281828459045" 2343 | ] 2344 | }, 2345 | "execution_count": 65, 2346 | "metadata": {}, 2347 | "output_type": "execute_result" 2348 | } 2349 | ], 2350 | "source": [ 2351 | "e" 2352 | ] 2353 | }, 2354 | { 2355 | "cell_type": "code", 2356 | "execution_count": 66, 2357 | "metadata": {}, 2358 | "outputs": [ 2359 | { 2360 | "data": { 2361 | "text/plain": [ 2362 | "4.0" 2363 | ] 2364 | }, 2365 | "execution_count": 66, 2366 | "metadata": {}, 2367 | "output_type": "execute_result" 2368 | } 2369 | ], 2370 | "source": [ 2371 | "pow(2,2)" 2372 | ] 2373 | }, 2374 | { 2375 | "cell_type": "code", 2376 | "execution_count": 70, 2377 | "metadata": {}, 2378 | "outputs": [ 2379 | { 2380 | "name": "stdout", 2381 | "output_type": "stream", 2382 | "text": [ 2383 | "0\n", 2384 | "1\n", 2385 | "2\n", 2386 | "3\n", 2387 | "4\n", 2388 | "5\n", 2389 | "6\n", 2390 | "7\n", 2391 | "8\n", 2392 | "9\n" 2393 | ] 2394 | } 2395 | ], 2396 | "source": [ 2397 | "import time\n", 2398 | "\n", 2399 | "for i in range(10):\n", 2400 | " print(i)\n", 2401 | " time.sleep(2)" 2402 | ] 2403 | }, 2404 | { 2405 | "cell_type": "code", 2406 | "execution_count": 104, 2407 | "metadata": {}, 2408 | "outputs": [ 2409 | { 2410 | "name": "stdout", 2411 | "output_type": "stream", 2412 | "text": [ 2413 | "Tente a sorte: 7\n", 2414 | "Tente um número maior, restam 2 tentativas\n", 2415 | "Tente a sorte: 9\n", 2416 | "Tente um número maior, restam 1 tentativas\n", 2417 | "Tente a sorte: 10\n", 2418 | "Tente um número maior, restam 0 tentativas\n", 2419 | "Errou tudo, otário! O número era: 13\n" 2420 | ] 2421 | } 2422 | ], 2423 | "source": [ 2424 | "# LOTERIA DA BABILONIA!!!\n", 2425 | "\n", 2426 | "import random\n", 2427 | "\n", 2428 | "def valida_entrada(msg):\n", 2429 | " numero = None\n", 2430 | " while numero is None:\n", 2431 | " try:\n", 2432 | " numero = int(input(msg))\n", 2433 | " return numero\n", 2434 | " except ValueError:\n", 2435 | " print(\"Entre com um número válido!\")\n", 2436 | "\n", 2437 | "num = random.randint(1,15)\n", 2438 | "\n", 2439 | "for i in range(3):\n", 2440 | " palpite = valida_entrada(\"Tente a sorte: \")\n", 2441 | " if palpite == num:\n", 2442 | " print(\"ACERTOU, MISERAVI!!\")\n", 2443 | " break\n", 2444 | " elif palpite > num:\n", 2445 | " print(\"Tente um número menor, restam\", 3-i-1, \"tentativas\")\n", 2446 | " else:\n", 2447 | " print(\"Tente um número maior, restam\", 3-i-1, \"tentativas\")\n", 2448 | "else:\n", 2449 | " print(\"Errou tudo, otário! O número era:\", num)" 2450 | ] 2451 | } 2452 | ], 2453 | "metadata": { 2454 | "file_extension": ".py", 2455 | "kernelspec": { 2456 | "display_name": "Python [conda env:twitch]", 2457 | "language": "python", 2458 | "name": "conda-env-twitch-py" 2459 | }, 2460 | "language_info": { 2461 | "codemirror_mode": { 2462 | "name": "ipython", 2463 | "version": 3 2464 | }, 2465 | "file_extension": ".py", 2466 | "mimetype": "text/x-python", 2467 | "name": "python", 2468 | "nbconvert_exporter": "python", 2469 | "pygments_lexer": "ipython3", 2470 | "version": "3.7.7" 2471 | }, 2472 | "mimetype": "text/x-python", 2473 | "name": "python", 2474 | "npconvert_exporter": "python", 2475 | "pygments_lexer": "ipython3", 2476 | "version": 3 2477 | }, 2478 | "nbformat": 4, 2479 | "nbformat_minor": 2 2480 | } 2481 | -------------------------------------------------------------------------------- /Imersão Python.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TeoCalvo/imersao-python/a3809c371415829e0ee25dd7b9adf12375a0ec45/Imersão Python.pdf -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Imersão de Python 2 | 3 | Que bom ter você por aqui! Seja mega bem vindo(a) à nossa imersão de Python do Zero! Um evento totalmente gratuito feito para nossa comunidade na [Twitch](https://www.twitch.tv/teomewhy/)! 4 | 5 | Para participar, basta acessar nosso canal [Téo Me Why](https://www.twitch.tv/teomewhy/) no dia 19/12/2020 as 9:00 horas. Por lá, você acompanhará nosso conteúdo durante toda live, podendo fazer perguntas pelo chat. 6 | 7 | Não se esqueça de adicionar este evento em seu [calendário clicando aqui](https://calendar.google.com/event?action=TEMPLATE&tmeid=MjdoNWwxcnZkMjhrZTBuZW5kNTZmNTdodTcgZ2hwamE0ZTJpYjhvZmdpZDk5OTVlZDExcmNAZw&tmsrc=ghpja4e2ib8ofgid9995ed11rc%40group.calendar.google.com). 8 | 9 | ## [Calendário (19/12/2020)](https://calendar.google.com/event?action=TEMPLATE&tmeid=MjdoNWwxcnZkMjhrZTBuZW5kNTZmNTdodTcgZ2hwamE0ZTJpYjhvZmdpZDk5OTVlZDExcmNAZw&tmsrc=ghpja4e2ib8ofgid9995ed11rc%40group.calendar.google.com) 10 | 11 | |Etapa|Início|Fim| 12 | |---|---|---| 13 | |Parte I|9:00|12:30| 14 | |Almoço|12:30|14:00| 15 | |Parte II|14:00|18:00| 16 | |Encerramento|18:00| - | 17 | 18 | ## Conteúdo 19 | 20 | Começamos com uma breve introdução sobre o que é o Python e porque utilizá-lo no seu dia a dia. A seguir, visitaremos as principais estruturas de dados da linguagem: 21 | * Strings; 22 | * Inteiros e Floats; 23 | * Listas e Tuplas; 24 | * Dicionários; 25 | 26 | Com também estruturas de controle de fluxo: 27 | * if, else, elif; 28 | * exceptions; 29 | * for e while; 30 | * funções; 31 | 32 | Por meio de exemplos didáticos e aplicáveis, vários scripts serão criados ao longo do curso, fazendo uso de todas as estruturas mencionadas. 33 | 34 | ## Sobre o instrutor 35 | 36 | [Téo Calvo](https://www.linkedin.com/in/teocalvo/) é especialista em Data Science & Big Data pela UFPR, bacharel em Estatística pela FCT-UNESP. Hoje atua como Coordenador de Customer Centric na Via Varejo SA. Já passou por empresas como Grupo Boticário e já atuou como consultor analítico no SAS Institute Brasil. Tem paixão por compartilhar seu conhecimento com os demais a partir de suas lives na [Twitch](https://www.twitch.tv/teomewhy/), o que tem feio desde Agosto de 2019. 37 | 38 | ## Recurso adicional para Subs da Twitch 39 | 40 | Caso você seja nosso sub, poderá fazer perguntas por meio do nosso canal de subs no [Discord](https://discord.gg/YUXQzBYQ). Durante toda transmissão o instrutor estará no canal de voz destinado aos subs, assim, nos momentos de perguntas e dúvidas, estes poderão realizá-las diretamente. 41 | 42 | Não é sub ainda e assina Amazon Prime? Vincule [aqui](https://twitch.amazon.com/tp) sua conta da Twitch com a da Amazon para virar um sub de forma gratuita. 43 | 44 | ## Links Úteis 45 | 46 | ### Contato & Redes Sociais 47 | 48 | * [Discord](https://discord.gg/YUXQzBYQ) 49 | * [Instagram](https://www.instagram.com/teo.calvo/) 50 | * [LinkedIn](https://www.linkedin.com/in/teocalvo/) 51 | * [Twitch](https://www.twitch.tv/teomewhy/) 52 | 53 | ### Software 54 | 55 | * [Anaconda](https://www.anaconda.com/products/individual) 56 | * [Git](https://git-scm.com/) 57 | * [Visual Studio Code](https://code.visualstudio.com/) 58 | 59 | ### Referências 60 | 61 | * [TeoMeRefs](https://github.com/TeoCalvo/teomerefs) --------------------------------------------------------------------------------