Aula_3_corr.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programação Funcional"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "quadrado = lambda num: num ** 2\n",
    "multiplicacao = lambda x,y: x*y\n",
    "\n",
    "print(quadrado(2))\n",
    "print(multiplicacao(2,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0, 2.0, 3.0, 4.0, 5.0]\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "lista1 = [1, 4, 9, 16, 25]\n",
    "lista2 = map(math.sqrt, lista1)\n",
    "print(list(lista2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0, 0.3010299956639812, 0.47712125471966244, 0.6020599913279624, 0.6989700043360189, 0.7781512503836436, 0.8450980400142568, 0.9030899869919435, 0.9542425094393249, 1.0, 1.0413926851582251, 1.0791812460476249]\n",
      "\n",
      "[0.3333333333333333, 0.6666666666666666, 1.0, 1.3333333333333333, 1.6666666666666667, 2.0, 2.3333333333333335, 2.6666666666666665, 3.0, 3.3333333333333335, 3.6666666666666665, 4.0]\n"
     ]
    }
   ],
   "source": [
    "nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n",
    "from math import log10\n",
    "print (list(map(log10, nums)))\n",
    "print()\n",
    "print (list(map(lambda x: x / 3, nums)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4950\n",
      "102\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "nums = range(100)\n",
    "print (reduce(lambda x, y: x + y, nums))\n",
    "\n",
    "f = lambda a,b: a if (a > b) else b\n",
    "print(reduce(f, [47,11,42,102,13]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7]\n",
      "[-5, -4, -3, -2, -1]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3,4,5,6,7]\n",
    "print (list(filter(lambda x: x % 2, x)))\n",
    "\n",
    "number_list = range(-5, 5)\n",
    "less_than_zero = list(filter(lambda x: x < 0, number_list))\n",
    "print(less_than_zero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transposição"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 4), (2, 5), (3, 6)]\n",
      "[(1, 4, 7), (2, 5, 8), (3, 6, 9)]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "y = [4, 5, 6,9,0]\n",
    "print (list(zip(x, y)))\n",
    "\n",
    "matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "print (list(zip(*matriz))) #Descompacta e depois faz a transposição"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]\n"
     ]
    }
   ],
   "source": [
    "S = [x*2 for x in range(0, 10)]\n",
    "print(S)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 25, 49, 81, 121]\n"
     ]
    }
   ],
   "source": [
    "nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n",
    "print ([ x**2 for x in nums if x % 2 ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['Um', 'UM', 2], ['Dois', 'DOIS', 4], ['Tres', 'TRES', 4]]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[[s.capitalize(), s.upper(), len(s)] for s in ['um', 'dois', 'tres']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## TODO Section"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1)\n",
    "A amplitude de um vetor 3D é dado pela seguinte fórmula: $\\sqrt{x^2 + y^2 + z^2}$\n",
    "\n",
    "Escreva uma função, usando lambda, que calcule a amplitude de qualquer vetor. Exemplo de entrada:\n",
    "\n",
    "    -> (1,1,1) \n",
    "    -> (3,4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A amplitude do vetor (1, 1, 1) é 1.73\n",
      "A amplitude do vetor (3, 4, 5) é 7.07\n"
     ]
    }
   ],
   "source": [
    "# resposta\n",
    "import math\n",
    "def amplitude(vetor):\n",
    "    return math.sqrt(sum([x**2 for x in vetor]))\n",
    "\n",
    "l = [(1,1,1),(3,4,5)]\n",
    "for v in l:\n",
    "    print('A amplitude do vetor %s é %.2f' % (str(v), amplitude(v)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7320508075688772"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Resposta lambda\n",
    "amplitude = lambda x,y,z:math.sqrt(x**2 + y**2 + z**2)\n",
    "amplitude(1,1,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2) \n",
    "Use reduce para criar uma função que calcule o fatorial de qualquer número n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Calcule o fatorial de :  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "# resposta\n",
    "from functools import reduce\n",
    "def fatorial(n):\n",
    "    return reduce(lambda x, y: x*y, range(2,n+1))\n",
    "\n",
    "#Uso\n",
    "n = int(input('Calcule o fatorial de : '))\n",
    "print(fatorial(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Orientação à Objetos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Abstração\n",
    "class SomeClass:    \n",
    "    def create_arr(self):\n",
    "        self.arr = []\n",
    "    \n",
    "    def insert_to_arr(self, value): \n",
    "        self.arr.append(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Instanciamento\n",
    "obj = SomeClass()\n",
    "obj.create_arr()\n",
    "obj.insert_to_arr(5)\n",
    "obj.arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set([1,1,2,2,3,3,4,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#definição da classe\n",
    "class Set:\n",
    "    # Funções membras\n",
    "    # self se refere ao objeto Set que está sendo usado\n",
    "    def __init__(self, values=None):\n",
    "        \"\"\"\n",
    "        Este é o construtor\n",
    "        Ele é chamado quando você cria um novo Set;\n",
    "        Deve ser usado da seguinte maneira:\n",
    "        s1 = Set() # set vazio\n",
    "        s2 = Set([1,2,2,3]) #inicializa com valores\n",
    "        \"\"\"\n",
    "\n",
    "        self.dict = {}  # cada instância de um Set possui seu próprio dicionário\n",
    "        # que será usado para rastrear membresia\n",
    "        if values is not None:\n",
    "            for value in values:\n",
    "                self.add(value)\n",
    "    def __repr__(self):\n",
    "        \"\"\"\n",
    "        Esta é a representação de um objeto Set por meio de uma string\n",
    "        \"\"\"\n",
    "        return \"Set: \" + str(self.dict.keys())\n",
    "    \n",
    "    # vamos representar membresia como sendo uma chave no self.dict com valor True\n",
    "    def add(self, value):\n",
    "        self.dict[value] = True\n",
    "    \n",
    "    # valor está no Set se ele é uma chave no dicionário\n",
    "    def contains(self, value):\n",
    "        return value in self.dict\n",
    "    \n",
    "    def remove(self, value):\n",
    "        del self.dict[value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Set: dict_keys([1, 2, 3])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = Set([1,2,3,2,3,1])\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "s.add(4)\n",
    "print (s.contains(4)) # True\n",
    "s.remove(3)\n",
    "print (s.contains(3)) # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, fname, lname):\n",
    "        self.firstname = fname\n",
    "        self.lastname = lname\n",
    "    \n",
    "    def printname(self):\n",
    "        print(self.firstname, self.lastname)\n",
    "\n",
    "class Student(Person):\n",
    "    def __init__(self, fname, lname, year):\n",
    "        super().__init__(fname, lname)\n",
    "        self.graduationyear = year\n",
    "\n",
    "    def welcome(self):\n",
    "        print(\"Bem-vindo\", self.firstname, self.lastname, \"à turma de\", self.graduationyear)\n",
    "\n",
    "x = Student(\"João\", \"Silva\", 2020)\n",
    "x.welcome()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TODO Section"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3)\n",
    "Crie uma classe que irá modelar características geométricas de um círculo. Deverá implementar os métodos:\n",
    "\n",
    "        -> Área \n",
    "        -> Perímetro\n",
    "        \n",
    "Utilize atributos de classe e de instância apropriados. Crie um inicializador e métodos.\n",
    "\n",
    "$area = \\pi*r^2$\n",
    "\n",
    "$perimetro = 2*\\pi*r$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# Resposta\n",
    "import math\n",
    "class Circle:\n",
    "    \n",
    "    def __init__(self, raio):\n",
    "        self.pi = math.pi\n",
    "        self.raio=raio\n",
    "    \n",
    "    def area(self):\n",
    "        return self.pi * self.raio**2\n",
    "    \n",
    "    def perimetro(self):\n",
    "        return 2 * self.pi * self.raio\n",
    "\n",
    "# Uso\n",
    "r = int(input('Circulo de raio : '))\n",
    "circulo = Circle(r)\n",
    "a = circulo.area()\n",
    "p = circulo.perimetro()\n",
    "print('  Área => %d \\n  Perimetro => %d ' % (a,p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}