1.introducao_python.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introdução ao Python"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O Python pode ser utilizado de divrsas formas. As duas mais comuns são : \n",
    "- `Python Shell` : ele é acessado pelo **Prompt de Comando** digitando `python`;\n",
    "- `Script Python` : arquivo com extensão `.py`;"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os comandos passados no `Python Shell` tem por característica serem executados logo que acionamos o **Enter**.<br>\n",
    "Quando acionamos o `Python Shell` com o comando **python**, somos apresentado à seguinte interface :\n",
    "\n",
    "```shell\n",
    "Python 3.11.1 (tags/v3.11.1:a7a450f, Dec  6 2022, 19:58:39) [MSC v.1934 64 bit (AMD64)] on win32\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>> _\n",
    "```\n",
    "\n",
    "Os `>>>` indica onde os comandos são entrados."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando usamos o arquivo Python (chamados de script), os comandos colocados lá são executado apenas quando chamamos o python no **Prompt de Comando**, conforme o exemplo abaixo :<br>\n",
    "`C:\\python>python arquivo.py`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ao usarmos o Python no Jupyter Notebook, teremos dois tipos de célular. Uma para o texto formatado, chamado de `Markdown` e outra para o nosso código python.\n",
    "\n",
    "Para mais informações sobre como usar o Jupyter Notebook, veja o link abaixo :\n",
    "- https://medium.com/@pedrofullstack/introdu%C3%A7%C3%A3o-ao-jupyter-notebook-para-python-b2cf79cea31d"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Comentários"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comentários em Python começam com o caractere `#` e se extende até o final da linha. Pode começar no começo da linha, ou seguido de espaços em branco ou código, mas não em uma string literal.<br>\n",
    "Comentários são usados para documentar e ajudar outras pessoas sobre o que o código irá fazer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# este é o primeiro comentário\n",
    "numero = 42 # e este é o segundo comentário\n",
    "            # ... e agora o terceiro.\n",
    "texto = '# isto não é um comentário, pois está entre aspas'"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Números"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O Python funciona como uma simples calculadora. Você pode digitar uma expressão e ela será calculada. Os operadores são os mesmos usados na matemática : `+ - * /`. Parêntesis podem ser usados para agrupar.<br>\n",
    "Para começar, vamos digitar alguns comandos na função `print()`, que é usada para mostrar o resultado da execução e das variáveis no `Prompt de Comando`, ou abaixo da célula, no cado do Jupyter Notebook.\n",
    "\n",
    "Link :\n",
    "- https://docs.python.org/3/library/functions.html#print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(2 + 2)\n",
    "print(50 - 5 * 6)\n",
    "print((50 - 5 * 6) / 4)\n",
    "# a divisão sempre retorna um número de ponto flutuante\n",
    "print(8 / 5)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os números inteiros (ex: 2, 4, 42) são do tipo `int`. Os núemros com a parte fracional (aqueles com o **ponto** como separador), são do tipo `float`. Logo veremos mais sobre os tipos numéricos.<br>\n",
    "A divisão (`/`) **sempre** retorna um `float`. Para fazer uma divisão que retorne apenas o quociente da divisão, desprezando o resto, usamos o operador `//`, também chamado de `floor division`. Para calcular o resto da divisão e desprezar o quociente, usamos o operador `%`.<br>\n",
    "\n",
    "Links :\n",
    "- https://docs.python.org/3/glossary.html#term-floor-division\n",
    "- https://peps.python.org/pep-0238/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(17 / 3) # divisão clássica retorna um float\n",
    "print(17 // 3) # a floor division descarta a parte fracional\n",
    "print(17 % 3) # o operador % retorna o resto da divisão\n",
    "print(5 * 3 + 2) # quociente * divisor + resto"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com Python, é possível usar o operador `**` para calcular potências."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5 ** 2) # quadrado de 5\n",
    "print(2 ** 7) # 2 elevado à potência 7"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O sinal de igual `=` é usado para associar um valor a uma variável."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "largura = 20\n",
    "altura = 5 * 9\n",
    "print(largura * altura)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se uma variável não é definida (não tiver um valor associado a ela), tentar usar vai levar a um erro."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(n)\n",
    "# NameError: name 'n' is not defined"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operações com números mixos (`int` e `float`) são convertidos para `float`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(4 * 3.75 - 1)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Junto com `int` e `float`, Python também tem suporte a outros tipos de números, como `Decimal` e `Fraction`. Python também tem suporte **built-in** a números complexo e usa o sufixo `j` ou `J` para indicar a parte imaginária (ex: `3 + 5j`).\n",
    "\n",
    "- **built-in** : usamos essa expressão para dizer que a funcionalidade não necessita de nenhuma biblioteca, módulo, etc;\n",
    "\n",
    "Links :\n",
    "- https://docs.python.org/3/library/decimal.html#decimal.Decimal\n",
    "- https://docs.python.org/3/library/fractions.html#fractions.Fraction\n",
    "- https://docs.python.org/3/library/stdtypes.html#typesnumeric"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Strings"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1. Básico"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Além de números, Python também pode manipular `strings`, que podem ser expressadas de diversas formas. Elas podem ser colocadas entre **aspas simples** (`'...'`) ou **aspas duplas** (`\"...\"`) com o mesmo resultado. A `contra-barra` pode ser usada para escapar as aspas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('pão e ovos') # aspas simples\n",
    "print('pão d\\'água') # use \\' para escapar a aspas simples...\n",
    "print(\"pão d'água\") # ... ou use aspas duplas no lugar\n",
    "print('\"Sim\", ele disse.')\n",
    "print(\"\\\"Sim\\\", ele disse.\")\n",
    "print('\"Pão d\\'água\", ele disse.')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando usamos `strings`, há um caractere especial que, combinado com outros caracteres, produze algumas ações específicas.<br>\n",
    "Alguns deles são `\\n` que cria uma nova linha; o `\\t`, que adiciona uma identação ao texto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "texto = 'Primeira linha.\\nSegunda linha.'\n",
    "print(texto)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se você não quer que o **contra-barra** seja interpretado como um caractere especial, pode usar a string crua (`raw string`) adicionando um `r` antes da primeira aspa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('C:\\meu\\nome')\n",
    "print(r'C:\\meu\\nome')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Só há um porém, uma `raw string` não pode terminar uma com uma quantidade ímpar de carácter `\\`.\n",
    "\n",
    "Links :\n",
    "- Para contonar, leia : https://docs.python.org/3/faq/programming.html#faq-programming-raw-string-backslash"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Strings` literais podem se espalhar por múltiplas linhas. Uma forma é usar aspas triplas : `'''...'''` ou `\"\"\"...\"\"\"`. Os finais de linha são automaticamente incluídos na `string`, mas é possível previnir isso adicionando um `\\` ao final da linha."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"\"\"\\\n",
    "Uso : coiso [opcional]\n",
    "    -h                  Mostra esta mensagem\n",
    "    -H hospedeiro       Mostra o hospedeiro\n",
    "\"\"\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Strings` podem ser concatenadas com o operador `+` e repetidas com o operador `*`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3 vezes 'un' seguido de 'ium'\n",
    "print(3 * 'un' + 'ium')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Duas ou mais `strings` literias (aquelas colocadas entre aspas) colocadas lado a lado são automaticamente concatenadas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Py' 'thon')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isso é particularmente útil quando você quer repartir uma string muito longa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "texto = ('Coloque várias strings dentro de parênteses '\n",
    "         'para juntar elas em uma só.')\n",
    "print(texto)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isso só funciona com `strings` literais, não com variáveis ou expressões."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prefixo = 'Py'\n",
    "print(prefixo 'thon')\n",
    "# SyntaxError: invalid syntax"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se você quer concatenar as variáveis ou uma variável e uma string literal, use `+`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prefixo = 'Py'\n",
    "print(prefixo + 'thon')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings podem ser indexadas, com o primeiro caractere tendo como índice o `0`. O Python não tem um tipo char (para indicar strings de um caractere). Um caractere é simplesmente uma string de tamanho um."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palavra = 'Python'\n",
    "print(palavra[0]) # caratere na posição 0\n",
    "print(palavra[5]) # caratere na posição 5"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Índices também podem ser negativos, para começar a contar da direita para a esquerda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palavra = 'Python'\n",
    "print(palavra[-1]) # último caractere\n",
    "print(palavra[-2]) # penúltimo caractere\n",
    "print(palavra[-6]) # primeiro caractere"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que como `-0` é o mesmo que `0`, o índice negativo começa em `-1`.\n",
    "\n",
    "Junto com a indexação, a repartição é suportada também. Enquanto a indexação é usada para obter apenas um caractere, a repartição permite obter uma substring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palavra = 'Python'\n",
    "print(palavra[0:2]) # caracteres da posição 0 (incluído) até 2 (excluído) [0,2)\n",
    "print(palavra[2:5]) # caracteres da posição 2 (incluído) até 5 (excluído) [2,5)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A omissão do primeiro índice deixa como padrão o `0`. A omissão do segundo índice deixa como padrão o tamanho da string que será repartida."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palavra = 'Python'\n",
    "print(palavra[:2]) # caracteres do começo até 2 (excluído)\n",
    "print(palavra[4:]) # caracteres da posição 4 (incluído) até o final\n",
    "print(palavra[-2:]) # caracteres da penúltima posição (incluído) até o final"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repare que o começo é sempre incluído e o final é sempre excluído. Isso faz com que a `palavra[:i] + palavra[i:]` é sempre igual a `palavra`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palavra = 'Python'\n",
    "print(palavra[:2] + palavra[2:])\n",
    "print(palavra[:4] + palavra[4:])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma forma de lembrar como a repartição funciona é pensar nos índices como pontos **entre** os caracteres, com a margem esquerda do primeiro caractere numerada com 0. Então, a margem direita do último caractere da string de `N` caracteres tem o índice `N`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  +---+---+---+---+---+---+\n",
    "#  | P | y | t | h | o | n |\n",
    "#  +---+---+---+---+---+---+\n",
    "#  0   1   2   3   4   5   6\n",
    "# -6  -5  -4  -3  -2  -1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A primeira linha de números indica a posição dos índices 0...6 da string. A segunda linha de números indica o índice correspondente negativo. A repartição do `i` ao `j` consiste em todos os caracteres entre as margens nomeadas `i` e `j`, respectivamente.\n",
    "\n",
    "Para índices não negativos, o tamanho de uma repartição é a diferença dos índices, se ambos estiverem dentro dos limites. Por exemplo : o tamanho da `palavra[1:3]` é `2`."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tentar usar um índice maior que o a string vai resultar em um erro."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palavra = 'Python'\n",
    "print(palavra[42])\n",
    "# IndexError: string index out of range"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Contudo, repartir strings fora dos limites dela não vai gerar erros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palavra = 'Python'\n",
    "print(palavra[4:42])\n",
    "print(palavra[42:])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings em Python não podem ser alteradas, elas são imutáveis. Logo, associar valores a uma posição indexada da string resulta em erro.\n",
    "\n",
    "Links :\n",
    "- https://docs.python.org/3/glossary.html#term-immutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palavra = 'Python'\n",
    "palavra[0] = 'J'\n",
    "# TypeError: 'str' object does not support item assignment\n",
    "\n",
    "palavra[2:] = 'py'\n",
    "# TypeError: 'str' object does not support item assignment"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se você precisar de uma string diferente, você deve criar uma nova :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palavra = 'Python'\n",
    "print('J' + palavra[1:])\n",
    "print(palavra[:2] + 'py')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função **built-in** `len()` retorna o tamanho da string.\n",
    "\n",
    "Link :\n",
    "- https://docs.python.org/3/library/functions.html#len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palavrao = 'supercalifragilisticexpialidocious'\n",
    "print(len(palavrao))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2. Métodos"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As strings em Python tem diversos métodos **built-in**. Vamos passar pelos mais usados."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### str.capitalize()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Retorna** uma cópia da string com a primeira letra em caixa alta e o resto em caixa baixa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aneis = 'Três Anéis para os Reis-Elfos sob este céu;'\n",
    "print(aneis.capitalize())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### str.center(width[, fillchar])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Retorna** uma string centralizada de acordo com o tamanho passado em `width` (**obrigatório**). Se o parâmetro `fillchar` (**opcional**) for passado, prenche com a string em vez de espaços (**padrão**);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aneis = 'Três Anéis para os Reis-Elfos sob este céu;'\n",
    "print('-' + aneis + '-')\n",
    "print('-' + aneis.center(1) + '-')\n",
    "print('-' + aneis.center(75) + '-')\n",
    "print('-' + aneis.center(100,'.') + '-')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### str.count(sub[, start[, end]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Retorna** o número de ocorrências da substring `sub` (**obrigatório**) no limite `[start, end]`. Os argumentos **opcionais** `start` e `end` são interpretados como a notação de repartição.\n",
    "\n",
    "Se `sub` for vazio (`''`), retorna o número de strings vazia entre os caracteres, que é o tamanho da string mais um."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aneis = 'Três Anéis para os Reis-Elfos sob este céu;'\n",
    "print('-' + aneis + '-')\n",
    "\n",
    "print(len(aneis))\n",
    "print(aneis.count(''))\n",
    "print(aneis.count('o'))\n",
    "\n",
    "print(aneis[20:])\n",
    "print(aneis.count('o', 20))\n",
    "\n",
    "print(aneis[20:30])\n",
    "print(aneis.count('o', 20, 30))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### str.endswith(suffix[, start[, end]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Retorna** `True` se a string termina com o `suffix` especificado, senão retorna `False`. `suffix` também pode ser uma tupla (`tuple`) de suffixos a serem procuradas.<br>\n",
    "Veja a documentação (link no final) do método para mais informações sobre os argumentos `start` e `end`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aneis = 'Três Anéis para os Reis-Elfos sob este céu;'\n",
    "print(aneis.endswith(';'))\n",
    "print(aneis.endswith('u'))\n",
    "print(aneis.endswith(('u', ';')))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### str.find(sub[, start[, end]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Retorna** o índice mais baixo (primeira ocorrência) da string onde a substring `sub` foi encontrada. Se não encontrar, retorna `-1`.\n",
    "<br>\n",
    "Veja a documentação (link no final) do método para mais informações sobre os argumentos `start` e `end`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aneis = 'Três Anéis para os Reis-Elfos sob este céu;'\n",
    "\n",
    "print(aneis.find(' '))\n",
    "print(aneis.find('a'))\n",
    "print(aneis.find('sob'))\n",
    "print(aneis.find('anão'))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### str.index(sub[, start[, end]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funciona como o `find()`, mas gera o erro `ValueError` quando a substring não é encontrada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aneis = 'Três Anéis para os Reis-Elfos sob este céu;'\n",
    "\n",
    "print(aneis.index(' '))\n",
    "print(aneis.index('a'))\n",
    "print(aneis.index('sob'))\n",
    "# ValueError: substring not found\n",
    "print(aneis.index('anão'))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### str.isalpha()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Retorna** `True` se todos os caracteres na string são alfabéticos e há ao menos **um** caractere, senão retorna `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aneis = 'Três Anéis para os Reis-Elfos sob este céu;'\n",
    "print(aneis.isalpha()) # encontrou -, ; e espaços em branco\n",
    "\n",
    "palavrao = 'supercalifragilisticexpialidocious'\n",
    "print(palavrao.isalpha())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### str.islower()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Retorna** `True` se todos os caracteres na string estiverem em caixa baixa, senão retorna `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aneis = 'Três Anéis para os Reis-Elfos sob este céu;'\n",
    "print(aneis.islower())\n",
    "\n",
    "palavrao = 'supercalifragilisticexpialidocious'\n",
    "print(palavrao.islower())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### str.isnumeric()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Retorna** `True` se todos os caracteres na string são dígitos e há ao menos **um** caractere, senão retorna `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aneis = 'Três Anéis para os Reis-Elfos sob este céu;'\n",
    "print(aneis.isnumeric())\n",
    "\n",
    "numero = '42'\n",
    "print(numero.isnumeric())\n",
    "numero = '3.14'\n",
    "print(numero.isnumeric())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3. Links"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- https://docs.python.org/3/library/stdtypes.html#textseq\n",
    "- https://docs.python.org/3/library/stdtypes.html#string-methods\n",
    "- https://docs.python.org/3/reference/lexical_analysis.html#f-strings\n",
    "- https://docs.python.org/3/library/string.html#formatstrings\n",
    "- https://docs.python.org/3/library/stdtypes.html#old-string-formatting"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Listas - Parte 1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python conhece um número de tipos de dados compostos, usado para agrupar outros valores. A mais versátil é a lista (`list`), que pode ser escrita com uma vírgula separando os valores (itens) entre conchetes. Listas podem conter itens de diferentes tipos, mas geralmente são do mesmo tipo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quadrados = [1, 4, 9, 16, 25]\n",
    "print(quadrados)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim como `strings` (e todas as outras [sequências](https://docs.python.org/3/glossary.html#term-sequence) **built-in**), listas podem ser indexadas e repartidas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quadrados = [1, 4, 9, 16, 25]\n",
    "print(quadrados[0]) # o índice retorna o item da lista\n",
    "print(quadrados[-1])\n",
    "print(quadrados[-3:]) # repartindo retorna uma nova lista"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Todos os operadores de repartição retornam uma nova lista com os elementos buscados. Isto significa que a repartição retorna uma cópia rasa ([shallow copy](https://docs.python.org/3/library/copy.html#shallow-vs-deep-copy)) da lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quadrados = [1, 4, 9, 16, 25]\n",
    "print(quadrados[:])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listas também suportam operações de concatenação."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quadrados = [1, 4, 9, 16, 25]\n",
    "print(quadrados + [36, 49, 64, 81, 100])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diferente das strings que são [imutáveis](https://docs.python.org/3/glossary.html#term-immutable), as listas são do tipo [mutáveis](https://docs.python.org/3/glossary.html#term-mutable), isto é, é possível alterar seu conteúdo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cubos = [1, 8, 27, 65, 125] # tem algo de errado aqui\n",
    "print(4 ** 3) # o cubo de 4 é 64 e não 65!\n",
    "cubos[3] = 64\n",
    "print(cubos)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Você também pode adicionar novos itens no final da lista, pelo uso do método `append()` (veremos mais sobre isso adiante)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cubos = [1, 8, 27, 64, 125]\n",
    "cubos.append(216) # adicionando o cubo de 6\n",
    "cubos.append(7 ** 3) # e o cubo de 7\n",
    "print(cubos)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Passar valor por repartições também é possível, e isto pode até mudar o tamanho da lista ou limpar ela toda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "letras = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n",
    "print(letras)\n",
    "\n",
    "# substituindo alguns valores\n",
    "letras[2:5] = ['C', 'D', 'E']\n",
    "print(letras)\n",
    "\n",
    "# agora removendo eles\n",
    "letras[2:5] = []\n",
    "print(letras)\n",
    "\n",
    "# limpar a lista ao substituir todos os elementos com uma lista vazia\n",
    "letras[:] = []\n",
    "print(letras)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funções **built-in** como `len()` também se aplicam às listas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "letras = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n",
    "print(len(letras))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é possível criar listas aninhadas (listas dentro de listas)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "letras = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n",
    "numeros = [1, 2, 3, 4, 5]\n",
    "\n",
    "duas_listas = [letras, numeros]\n",
    "print(duas_listas)\n",
    "print(duas_listas[0])\n",
    "print(duas_listas[0][1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Primeiros Passos em Direção à Programação"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É claso, nós podemos usar o Python para tarefas mais complicadas do que somar dois mais dois. For exemplo, nós podemos escrever uma sub-sequência inicial da [Série de Fibonacci](https://en.wikipedia.org/wiki/Fibonacci_number)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Série de Fibonacci\n",
    "# a soma de dois elementos define o próximo\n",
    "a, b = 0, 1\n",
    "\n",
    "while a < 10:\n",
    "    print(a)\n",
    "    a, b = b, a + b"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neste exemplo podemos ver várias funcionalidades novas."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A primeira linha tem a `associação múltipla` : as variáveis `a` e `a` recebem simultaneamente os novos valores 0 e 1. Isso também é usado na última linha de novo, demonstrando que as expressões do lado direito são calculadas antes que qualquer associação seja feita. As expressões do lado direito são calculadas da esquerda para a direita."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A repetição [while](https://docs.python.org/3/reference/compound_stmts.html#while) executa enquanto a condição (aqui `a < 10`) continuar sendo verdadeira. Em Python, assim como em C, todo valor inteiro diferente de zero é verdadeiro, zero é falso. A condição pode também ser uma string ou uma lista de valores, na verdade, pode ser qualquer sequência. Qualquer coisa com um tamanho diferente de zero é verdadeira, enquanto sequência vazia são falsas. O teste usado no exemplo é uma simples comparação. Os operadores de comparação padrão são escritos como na linguagem C :\n",
    "- `<` : menor que\n",
    "- `>` : maior que\n",
    "- `==` : igual a\n",
    "- `<=` : menor ou igual a\n",
    "- `>=` : maior ou igual a\n",
    "- `!=` : diferente de"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O corpo da repetição é `indentada` : identação é a maneira que o Python usa para agrupar as declarações. No prompt interativo ou no arquivo, você precisa usar a tabulação ou espaços para cada linha de indentação. Os editores de código mais modernos tem uma função de auto-indentação, facilitando o desenvolvimento. Quando uma declaração composta é finalizada, deve vir seguida de uma linha em branco para indicar a finalização. Veja que cada linha dentro do mesmo bloco **deve** ser indentada na mesma quantidade."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função [print()](https://docs.python.org/3/library/functions.html#print) escreve os valores dos argumentos que é dado. Strings são mostradas sem aspas e espaços são inseridos entre os itens, então você pode formatar as saídas lindamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 256 * 256\n",
    "print('O valor de i é : ', i)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O argumento de palavra chave (`keyword argument`) `end` pode ser usado para evitar uma nova linha depois de cada execução, ou finalizar a execução com uma diferente string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Série de Fibonacci\n",
    "# a soma de dois elementos define o próximo\n",
    "a, b = 0, 1\n",
    "\n",
    "while a < 1000:\n",
    "    print(a, end=',')\n",
    "    a, b = b, a + b"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.1 (tags/v3.11.1:a7a450f, Dec  6 2022, 19:58:39) [MSC v.1934 64 bit (AMD64)]"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "68f6cf9ddf20b8330c35f9eb8d38bef7105e3b161f09b6b7e5f8b2d3944d5325"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}