linguagem-de-programacao.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aula 01 - Jupyter notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introdução"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "O juptyer notebook é uma ferramenta que permite a criação de documentos que misturam texto, código e visualizações. Ele é muito utilizado em ciência de dados e machine learning, pois permite a criação de relatórios e análises de dados de forma interativa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# O velho Hello, World!\n",
    "print('Hello, World')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interatividade"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize a variável x\n",
    "x = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Execute esta célula quantas vezes quiser (ctrl + enter)\n",
    "x += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Veja o valor de x\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Código em Python (sem interatividade)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "x += 1   # Não conseguimos repetir a célula sem executar a linha x = 1\n",
    "print(x) # O valor de x é sempre 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Exemplo: Problema de Matemática"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Inicialize a variável x\n",
    "x = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Decremente a variável x até que o valor da equação seja 0\n",
    "x -= 1\n",
    "\n",
    "# Calcule o valor da equação\n",
    "eq = x**2 + 2*x + 1\n",
    "\n",
    "# Veja valor de x e da equação (eq)\n",
    "print('x = ', x)\n",
    "print('Equação = ', eq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aula 01 e Revisão para Aula 02"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Como representar uma estrutura estudante?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opção 01 - Várias variáveis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pessoa 1\n",
    "nome1 = 'Bernardo'\n",
    "idade1 = 35\n",
    "profissao1 = 'Professor'\n",
    "\n",
    "# Pessoa 2\n",
    "nome2 = 'Juan'\n",
    "idade2 = 16\n",
    "profissao2 = 'Estudante'\n",
    "\n",
    "# Pessoa 3\n",
    "nome3 = 'Rita'\n",
    "idade3 = 15\n",
    "profissao3 = 'Estudante'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Problema: para cada novo estudante, precisamos criar novas variáveis, desconexas entre si."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opção 02 - Listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Nesta primeira lista, o primeiro elemento é o nome, que podemos acessar com o índice 0\n",
    "l1 = ['Bernardo', 35, 'Professor']\n",
    "\n",
    "# Não há legibilidade já que o índice 0 não nos dá pistas sobre o que é o elemento\n",
    "nome_retornado = l1[0] # Erro!\n",
    "print(nome_retornado)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Já nesta segunda lista, o primeiro elemento é a idade\n",
    "# Se esperarmos retornar o nome, teremos um erro\n",
    "l2 = [35, 'Bernardo', 'Professor']\n",
    "\n",
    "nome_retornado = l2[0] # Erro!\n",
    "print(nome_retornado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Problema: E se esquecermos a ordem de cada atributo? E a legibilidade?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opção 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Envolve umas coisas chamadas classes e objetos (Programação Orientada a Objetos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Código Novo (Ignoremos por enquanto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Código \"obscuro\"/\"horroroso\" ####\n",
    "class Pessoa:\n",
    "    def __init__(self, nome, idade, profissao):\n",
    "        self.nome = nome\n",
    "        self.idade = idade\n",
    "        self.profissao = profissao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = Pessoa('Bernardo', 35, 'Professor')\n",
    "\n",
    "# Os atributos da classe Pessoa são acessados com o ponto\n",
    "print('Nome:      ', p.nome)\n",
    "print('Idade:     ', p.idade)\n",
    "print('Profissao: ', p.profissao)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As variáveis agora estão dentro de uma mesma estrutura, que é a estrutura Pessoa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aula 02"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Entendo o código \"obscuro/horroroso\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Classe Pessoa\n",
    "# É convenção que o nome da classe comece com letra maiúscula\n",
    "class Pessoa:\n",
    "\n",
    "    # Construtor\n",
    "    def __init__(self, nome, idade, profissao):\n",
    "\n",
    "        # Atributos\n",
    "        self.nome = nome\n",
    "        self.idade = idade\n",
    "        self.profissao = profissao"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instanciando a classe Pessoa (novamente)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = Pessoa('Bernardo', 35, 'Professor')\n",
    "\n",
    "print('Nome:      ', p.nome)\n",
    "print('Idade:     ', p.idade)\n",
    "print('Profissao: ', p.profissao)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Criar uma nova classe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Computador:\n",
    "\n",
    "    # O construtor sempre é chamado quando instanciamos um objeto\n",
    "    # Seu código começa com as palavras reservadas \"def\" e \"__init__\"\n",
    "    def __init__(self, memoria, marca, preco):\n",
    "\n",
    "        self.memoria = memoria\n",
    "        self.marca = marca.upper()\n",
    "        self.preco = preco"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = Computador(8, 'dElL', 4000)\n",
    "print('Memória: ', c.memoria)\n",
    "print('Marca:   ', c.marca)\n",
    "print('Preço:   ', c.preco)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Criar uma nova classe\n",
    "- Exemplificando a não redundância"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    def __init__(self, idade, especie, habitat):\n",
    "        \n",
    "        self.especie = especie\n",
    "        self.habitat = habitat\n",
    "        # self.velho = False\n",
    "        # if idade > 10:\n",
    "        #     self.velho = True\n",
    "        self.velho = idade > 10            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = Animal(6, \"Gato\", \"Domestico\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Especie:\", a.especie)\n",
    "print(\"Habitat:\", a.habitat)\n",
    "print(\"É velho:\", a.velho)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## Sintaxe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exemplos dos estudantes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Aluna:\n",
    "    def __init__(self, nome, idade, participativa):\n",
    "        self.nome = nome\n",
    "        self.idade = idade\n",
    "        self.participativa = participativa\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Livro:\n",
    "    def __init__(self, nome, genero, num_paginas):\n",
    "        self.nome = nome\n",
    "        self.genero = genero\n",
    "        self.num_paginas = num_paginas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Execução de códido dentro do construtor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Livro:\n",
    "    # Construtor\n",
    "    def __init__(self, nome, genero, num_paginas):\n",
    "\n",
    "        ### Código: esta parte é executada quando instanciamos um objeto ###\n",
    "        print('Este é o construtor da classe Livro')\n",
    "        print('Estou instanciando um objeto da classe Livro')\n",
    "        \n",
    "        self.nome = nome\n",
    "        self.genero = genero\n",
    "        self.num_paginas = num_paginas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = Livro('Harry Potter', 'Fantasia', 300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aula 03"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exemplo e classe (sugestão da estudante)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dinheiro:\n",
    "    def __init__(self, moeda, quantidade, pais):\n",
    "        self.moeda = moeda\n",
    "        self.quantidade = quantidade\n",
    "        self.pais = pais"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chamada/instanciação da classe Dinheiro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uma instância de dinheiro \n",
    "d = Dinheiro(\"Dolar\", 1000, \"EUA\")\n",
    "\n",
    "# Outra instânciade dinheiro\n",
    "e = Dinheiro(\"Euro\", 560, \"Espanha\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Novo atributo na classe Dinheiro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dinheiro:\n",
    "\n",
    "    # Construtor\n",
    "    def __init__(self, moeda, quantidade, pais):\n",
    "        self.moeda = moeda\n",
    "        self.quantidade = quantidade\n",
    "        self.pais = pais\n",
    "\n",
    "        # Novo atributo (valor em reais)\n",
    "        self.real = 0\n",
    "\n",
    "        if moeda == 'Euro':\n",
    "            # Valor do Euro (5.5 reais)\n",
    "            self.real = 5.5*quantidade\n",
    "        elif moeda == 'Dolar':\n",
    "            # Valor do Dolar (5 reais)\n",
    "            self.real = 5*quantidade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instanciando novamente a classe Dinheiro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = Dinheiro('dolar', 100, 'EUA')\n",
    "print('Valor em real é', d.real) # Erro! Deveria ser 500, não?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Problema: a string (texto delimitado por aspas) 'dolar' é diferente de 'Dolar' (com D maiúsculo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparação de strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# retorna \"Falses\"\n",
    "moeda1 = 'Dolar'\n",
    "moeda2 = 'dolar'\n",
    "print(moeda1 == moeda2, 'Dolar' == 'dolar')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Queremos que retorne verdadeiro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Possível solução: métodos upper case ou lower case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "moeda1 = 'Dolar'.upper() # pode ser lower()\n",
    "moeda2 = 'dolar'.upper() # pode ser lower()\n",
    "\n",
    "print('Moeda 1 é', moeda1)\n",
    "print('Moeda 2 é', moeda2)\n",
    "\n",
    "print('Moeda 1 é igual a moeda 2?', moeda1 == moeda2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Correção da classe Dinheiro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dinheiro:\n",
    "\n",
    "    # Construtor\n",
    "    def __init__(self, moeda, quantidade, pais):\n",
    "        self.moeda = moeda\n",
    "        self.quantidade = quantidade\n",
    "        self.pais = pais\n",
    "\n",
    "        # Novo atributo (valor em reais)\n",
    "        self.real = 0\n",
    "\n",
    "        if moeda.upper() == 'Euro'.upper():\n",
    "            # Valor do Euro (5.5 reais)\n",
    "            self.real = 5.5 * quantidade\n",
    "        elif moeda.upper() == 'Dolar'.upper():\n",
    "            # Valor do Dolar (5 reais)\n",
    "            self.real = 5 * quantidade\n",
    "        else:\n",
    "            # Se a moeda não for nem Euro nem Dolar,\n",
    "            # não fazemos a conversão\n",
    "            print('Não foi possível fazer a conversão para Real')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exemplos Estudantes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Friends:\n",
    "    def __init__(self, personagem, profissao, genero):\n",
    "        self.personagem = personagem\n",
    "        self.profissao = profissao\n",
    "        self.genero = genero\n",
    "        \n",
    "        if personagem == \"Ross\":\n",
    "            print(\"Traiu ou não traiu?\")\n",
    "        elif personagem == \"Rachel\": \n",
    "            print(\"Estavam dando um tempo?\")\n",
    "        else:\n",
    "            print(\"sim\")\n",
    "f = Friends(\"Ross\", \"Paleontologo\", \"Masculino\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Objetos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Com Dólar há conversão\n",
    "d = Dinheiro('DoLaR', 100, 'EUA')\n",
    "print(d.real)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Com peso não\n",
    "p = Dinheiro('Peso', 100, 'Argentina')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aula 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Revisão de Classe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Carro:\n",
    "    def __init__(self, modelo, vel_max, cor):\n",
    "        self.modelo = modelo\n",
    "        self.vel_max = vel_max\n",
    "        self.cor = cor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = Carro('HB20', 150, 'branco')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Revisão de função"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nome_da_funcao():\n",
    "    '''\n",
    "    Este é um comentário de múltiplas linhas\n",
    "    Esta função imprime algo na tela\n",
    "    '''\n",
    "    print('Imprime algo')\n",
    "\n",
    "nome_da_funcao()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def soma_e_imprime(a, b):\n",
    "    # Esta função soma e imprime dois números\n",
    "    soma = a + b\n",
    "    print(f'A soma de', a, 'e', b, 'é', soma)\n",
    "\n",
    "soma_e_imprime(2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def imprime_modelo(c):\n",
    "    print('O carro é do modelo', c.modelo)\n",
    "\n",
    "imprime_modelo(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def comparar_velocidades(c1, c2):\n",
    "    '''\n",
    "    Compara as velocidades de dois carros e imprime o resultado\n",
    "    '''\n",
    "    if c1.vel_max > c2.vel_max:\n",
    "        print('O carro', c1.modelo, 'é mais rápido')\n",
    "    elif c1.vel_max == c2.vel_max:\n",
    "        print('Os carros', c1.modelo, 'e', c2.modelo, 'são igualmente rápidos')\n",
    "    else:\n",
    "        print('O carro', c2.modelo, 'é mais rápido')\n",
    "\n",
    "c1 = Carro('HB20', 150, 'branco')\n",
    "c2 = Carro('Gol', 140, 'preto')\n",
    "c3 = Carro('Uno de Escada', 455, 'prata')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "comparar_velocidades(c1, c2)\n",
    "comparar_velocidades(c1, c3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aula 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operador 'ponto' ou operador de acesso a membro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Turma:\n",
    "    def __init__(self, nome, num_alunos, ano):\n",
    "        self.num_alunos = num_alunos\n",
    "        self.nome = nome\n",
    "        self.ano = ano"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instancia um objeto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = Turma('623', 22, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imprime atributos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(t.nome, t.num_alunos, t.ano)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uso do operador ponto para atribuição"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t.ano = 2024"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Novo valor de ano"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(t.ano)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uso de atributos em uma frase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('A turma', t.nome, 'do ano', t.ano, 'tem', t.num_alunos, 'alunos')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Função"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def imprime_turma(turma):\n",
    "    print('A turma', turma.nome, 'do ano', turma.ano, 'tem', turma.num_alunos, 'alunos')\n",
    "imprime_turma(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introdução a métodos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Turma():\n",
    "    def __init__(self, nome, num_alunos, ano):\n",
    "        self.nome = nome\n",
    "        self.num_alunos = num_alunos\n",
    "        self.ano = ano\n",
    "\n",
    "    # método:\n",
    "    def imprimir(self):\n",
    "        print('O nome da turma é:', self.nome)\n",
    "\n",
    "t = Turma('623', 22, 2)\n",
    "t.imprimir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aula 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classe com métodos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Carro:\n",
    "\n",
    "    def __init__(self, modelo, ano, cor):\n",
    "        self.modelo = modelo\n",
    "        self.ano = ano\n",
    "        self.cor = cor\n",
    "\n",
    "    # Primeiro método\n",
    "    def imprimir(self):\n",
    "        print('O carro do modelo', self.modelo, 'do ano', self.ano, 'tem cor', self.cor)\n",
    "\n",
    "    # Segundo método\n",
    "    def carro_velho(self):\n",
    "        if self.ano < 2015:\n",
    "            print('Este carro é velho')\n",
    "            return True\n",
    "        else:\n",
    "            print('Este carro não é velho')\n",
    "            return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Função"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def imprimir_carro(c):\n",
    "    print('O carro do modelo', c.modelo, 'do ano', c.ano, 'tem cor', c.cor)\n",
    "\n",
    "carro = Carro('Aircross', 2013, 'branca')\n",
    "\n",
    "imprimir_carro(carro)\n",
    "carro.imprimir()\n",
    "_ = carro.carro_velho()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Revisão (Sugestão das Estudantes')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Mammamia:\n",
    "\n",
    "    def __init__(self, personagem, musica, carac):\n",
    "        self.personagem = personagem\n",
    "        self.musica = musica\n",
    "        self.carac = carac\n",
    "\n",
    "    def imprimir_mammamia(self):\n",
    "        print(\"Personagem\", self.personagem, \"canta a música\", self.musica, \"e é\", self.carac)\n",
    "\n",
    "M = Mammamia(\"Donna Sheridan\", \"SOS\", \"a principal\")\n",
    "M.imprimir_mammamia()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Revisão 02"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Classe Carro\n",
    "class Carro:\n",
    "    def __init__(self, modelo, ano, cor):\n",
    "        self.modelo = modelo\n",
    "        self.ano = ano\n",
    "        self.cor = cor\n",
    "\n",
    "    # Método\n",
    "    def imprimir_carro(self):\n",
    "        print('O carro', self.modelo, 'é do ano', self.ano, 'e da cor', self.cor)\n",
    "\n",
    "# Função para imprimir as informações do carro\n",
    "def imprimir_carro(CARRO):\n",
    "    # CARRO ou carro podem ser utilizados como parâmetros\n",
    "    print('O carro', CARRO.modelo, 'é do ano', CARRO.ano, 'e da cor', CARRO.cor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instancia objeto, chama método e função"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = Carro('Corsa', 2011, 'prata')\n",
    "\n",
    "imprimir_carro(c)\n",
    "c.imprimir_carro()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Herança"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Motivação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    def __init__ (self,raca,altura):\n",
    "        self.raca = raca\n",
    "        self.altura = altura"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = Animal(\"homo sapiens\", 1.67)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cachorro:\n",
    "    def __init__(self, raca, altura, largura, nome):\n",
    "        self.raca = raca\n",
    "        self.altura = altura\n",
    "        self.largura = largura\n",
    "        self.nome = nome"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = Cachorro('Poodle', 0.5, 0.3, 'Costelinha')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Herança"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classe mãe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    def __init__(self, raca, peso, altura, largura):\n",
    "        self.raca = raca\n",
    "        self.peso = peso\n",
    "        self.altura = altura\n",
    "        self.largura = largura\n",
    "\n",
    "a = Animal('Gato Tricolor', 6, 4, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classe sem herança"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Gato:\n",
    "    def __init__(self, raca, peso, altura, largura, nome, dono):\n",
    "        self.raca = raca\n",
    "        self.peso = peso\n",
    "        self.altura = altura\n",
    "        self.largura = largura\n",
    "        self.nome = nome\n",
    "        self.dono = dono\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g1 = Gato('Gato Tricolor', 6, 4, 3, 'Bel', 'Bernardo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classe com Herança"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Gato(Animal):\n",
    "    def __init__(self, raca, peso, altura, largura, nome, dono):\n",
    "        super().__init__(raca, peso, altura, largura)\n",
    "        self.nome = nome\n",
    "        self.dono = dono\n",
    "\n",
    "g1 = Gato('Gato Tricolor', 6, 4, 3, 'Bel', 'Bernardo')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Exemplos dos alunos\n",
    "\n",
    "class Cachorro(Animal):\n",
    "    def __init__(self, raca, peso, altura, largura, cor, nome):\n",
    "        super().__init__(raca, peso, altura, largura)\n",
    "        self.cor = cor\n",
    "        self.nome = nome\n",
    "c = Cachorro(\"Vira-lata\", 9,0.70, 0.30,\"caramelo\",\"Elizo\")\n",
    "print(c.nome,\"é\", c.raca)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}