Conceptos_de_Python_para_Backend_Carolina_Gomez.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conceptos de Python para Backend por Carolina Gómez"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gPJTJ7pLk2EW"
   },
   "source": [
    "# Decoradores\n",
    "\n",
    "Son un patrón de diseño en Python que permite agregar funcionalidades a un objeto existente (funciones) sin modificar su estructura."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting package metadata (current_repodata.json): done\n",
      "Solving environment: done\n",
      "\n",
      "## Package Plan ##\n",
      "\n",
      "  environment location: /Users/carolinagomez/miniforge3/envs/conceptos-python\n",
      "\n",
      "  added / updated specs:\n",
      "    - flask\n",
      "\n",
      "\n",
      "The following packages will be downloaded:\n",
      "\n",
      "    package                    |            build\n",
      "    ---------------------------|-----------------\n",
      "    openssl-3.0.7              |       h03a7124_0         2.3 MB  conda-forge\n",
      "    ------------------------------------------------------------\n",
      "                                           Total:         2.3 MB\n",
      "\n",
      "The following packages will be UPDATED:\n",
      "\n",
      "  openssl                                  3.0.5-h03a7124_2 --> 3.0.7-h03a7124_0 None\n",
      "\n",
      "\n",
      "\n",
      "Downloading and Extracting Packages\n",
      "openssl-3.0.7        | 2.3 MB    | ##################################### | 100% \n",
      "Preparing transaction: done\n",
      "Verifying transaction: done\n",
      "Executing transaction: done\n",
      "Retrieving notices: ...working... done\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "!conda install --yes --prefix {sys.prefix} flask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "my54FYW0k5g9"
   },
   "outputs": [],
   "source": [
    "from functools import wraps\n",
    "from flask import Flask, g, request, redirect, url_for\n",
    "import functools\n",
    "\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "\n",
    "# Decorador para requerir login\n",
    "def login_required(f):\n",
    "    @wraps(f)\n",
    "    def decorated_function(*args, **kwargs):\n",
    "        if g.user is None:\n",
    "            return redirect(url_for('login', next=request.url))\n",
    "        return f(*args, **kwargs)\n",
    "    return decorated_function\n",
    "\n",
    "\n",
    "@app.route(\"/secret\")\n",
    "@login_required\n",
    "def secret_page():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "whm9vmLUk1gc"
   },
   "source": [
    "# Funciones\n",
    "\n",
    "Las funciones son muy importantes en Python y estas retornan un valor de acuerdo a los argumentos que les pasamos:\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "PElmtE1El9_e"
   },
   "outputs": [],
   "source": [
    "def plus_one(number):\n",
    "    return number + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plus_one(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Asignando  funciones a variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plus_one(number):\n",
    "    return number + 1\n",
    "\n",
    "add_one = plus_one\n",
    "add_one(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definiendo funciones dentro de otras funciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ejecutando plus_one\n",
      "Ejecutando add_one\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plus_one(number):\n",
    "    def add_one(number):\n",
    "        print(\"Executing add_one\")\n",
    "        return number + 1\n",
    "\n",
    "    print(\"Executing plus_one\")\n",
    "    result = add_one(number)\n",
    "    return result\n",
    "\n",
    "plus_one(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pasando funciones como argumentos de otras funciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Executing function_call\n",
      "Executing plus_one\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plus_one(number):\n",
    "    print(\"Executing plus_one\")\n",
    "    return number + 1\n",
    "\n",
    "def function_call(function):\n",
    "    print(\"Executing function_call\")\n",
    "    number_to_add = 5\n",
    "    return function(number_to_add)\n",
    "\n",
    "function_call(plus_one)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones retornando otras funciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Executing hello_function\n",
      "Executing say_hi\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Hi'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def hello_function():\n",
    "    def say_hi():\n",
    "        print(\"Executing say_hi\")\n",
    "        return \"Hi\"\n",
    "    print(\"Executing hello_function\")\n",
    "    return say_hi\n",
    "\n",
    "hello = hello_function()\n",
    "hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Las funciones anidadas tienen acceso al las variables de la función envolvente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Some random message\n"
     ]
    }
   ],
   "source": [
    "def print_message(message):\n",
    "    \"Enclosong Function\"\n",
    "    def message_sender():\n",
    "        \"Nested Function\"\n",
    "        print(message)\n",
    "\n",
    "    message_sender()\n",
    "\n",
    "print_message(\"Some random message\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creando decoradores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Something is happening before the function is called.\n",
      "Whee!\n",
      "Something is happening after the function is called.\n"
     ]
    }
   ],
   "source": [
    "def my_decorator(func):\n",
    "    def wrapper():\n",
    "        print(\"Something is happening before the function is called.\")\n",
    "        func()\n",
    "        print(\"Something is happening after the function is called.\")\n",
    "    return wrapper\n",
    "\n",
    "def say_whee():\n",
    "    print(\"Whee!\")\n",
    "\n",
    "say_whee = my_decorator(say_whee)\n",
    "say_whee()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Something is happening before the function is called.\n",
      "Whee!\n",
      "Something is happening after the function is called.\n"
     ]
    }
   ],
   "source": [
    "def my_decorator(func):\n",
    "    def wrapper():\n",
    "        print(\"Something is happening before the function is called.\")\n",
    "        func()\n",
    "        print(\"Something is happening after the function is called.\")\n",
    "    return wrapper\n",
    "\n",
    "@my_decorator\n",
    "def say_whee():\n",
    "    print(\"Whee!\")\n",
    "    \n",
    "say_whee()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aplicando multiples decoradores a una misma función"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def uppercase_decorator(function):\n",
    "    def wrapper():\n",
    "        func = function()\n",
    "        make_uppercase = func.upper()\n",
    "        return make_uppercase\n",
    "\n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_string(function):\n",
    "    def wrapper():\n",
    "        func = function()\n",
    "        splitted_string = func.split()\n",
    "        return splitted_string\n",
    "\n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['HELLO', 'THERE']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@split_string\n",
    "@uppercase_decorator\n",
    "def say_hi():\n",
    "    return 'hello there'\n",
    "say_hi()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decorando funciones con argumentos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My arguments are: Pereira, Medellín\n",
      "Cities I love are Pereira and Medellín\n"
     ]
    }
   ],
   "source": [
    "def decorator_with_arguments(function):\n",
    "    def wrapper_accepting_arguments(arg1, arg2):\n",
    "        print(f\"My arguments are: {arg1}, {arg2}\")\n",
    "        function(arg1, arg2)\n",
    "    return wrapper_accepting_arguments\n",
    "\n",
    "\n",
    "@decorator_with_arguments\n",
    "def cities(city_one, city_two):\n",
    "    print(f\"Cities I love are {city_one} and {city_two}\")\n",
    "\n",
    "cities(\"Pereira\", \"Medellín\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Definiendo generadores de propósito general"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The positional arguments are (1, 2, 3)\n",
      "The keyword arguments are {}\n",
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "def a_decorator_passing_arbitrary_arguments(function_to_decorate):\n",
    "    def a_wrapper_accepting_arbitrary_arguments(*args,**kwargs):\n",
    "        print('The positional arguments are', args)\n",
    "        print('The keyword arguments are', kwargs)\n",
    "        function_to_decorate(*args, **kwargs)\n",
    "    return a_wrapper_accepting_arbitrary_arguments\n",
    "\n",
    "@a_decorator_passing_arbitrary_arguments\n",
    "def function_with_arguments(a, b, c):\n",
    "    print(a, b, c)\n",
    "\n",
    "function_with_arguments(1,2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The positional arguments are ()\n",
      "The keyword arguments are {'first_name': 'Derrick', 'last_name': 'Mwiti'}\n",
      "This has shown keyword arguments: \n",
      "first_name: Derrick\n",
      "last_name: Mwiti\n",
      "country: Colombia\n"
     ]
    }
   ],
   "source": [
    "@a_decorator_passing_arbitrary_arguments\n",
    "def function_with_keyword_arguments(first_name=\"\", last_name=\"\", country=\"Colombia\"):\n",
    "    print(f\"This has shown keyword arguments: \")\n",
    "    print(f\"first_name: {first_name}\")\n",
    "    print(f\"last_name: {last_name}\")\n",
    "    print(f\"country: {country}\")\n",
    "\n",
    "function_with_keyword_arguments(first_name=\"Derrick\", last_name=\"Mwiti\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pasando argumentos al decorador"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The wrapper can access all the variables\n",
      "\t- from the decorator maker: Pandas Numpy Scikit-learn\n",
      "\t- from the function call: Pandas Science Tools\n",
      "and pass them to the decorated function\n",
      "This is the decorated function and it only knows about its arguments: \n",
      "Pandas Science Tools\n"
     ]
    }
   ],
   "source": [
    "def decorator_maker_with_arguments(decorator_arg1, decorator_arg2, decorator_arg3):\n",
    "    def decorator(func):\n",
    "        def wrapper(function_arg1, function_arg2, function_arg3) :\n",
    "            \"This is the wrapper function\"\n",
    "            print(f\"The wrapper can access all the variables\\n\"\n",
    "                  f\"\\t- from the decorator maker: {decorator_arg1} {decorator_arg2} {decorator_arg3}\\n\"\n",
    "                  f\"\\t- from the function call: {function_arg1} {function_arg2} {function_arg3}\\n\"\n",
    "                  f\"and pass them to the decorated function\")\n",
    "            return func(function_arg1, function_arg2, function_arg3)\n",
    "\n",
    "        return wrapper\n",
    "\n",
    "    return decorator\n",
    "\n",
    "pandas = \"Pandas\"\n",
    "@decorator_maker_with_arguments(pandas, \"Numpy\",\"Scikit-learn\")\n",
    "def decorated_function_with_arguments(function_arg1, function_arg2, function_arg3):\n",
    "    print(\"This is the decorated function and it only knows about its arguments: \")\n",
    "    print(f\"{function_arg1} {function_arg2} {function_arg3}\")\n",
    "\n",
    "decorated_function_with_arguments(pandas, \"Science\", \"Tools\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Debugueando decoradores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'wrapper'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decorated_function_with_arguments.__name__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is the wrapper function'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decorated_function_with_arguments.__doc__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "\n",
    "def uppercase_decorator(func):\n",
    "    @functools.wraps(func)\n",
    "    def wrapper():\n",
    "        return func().upper()\n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO THERE'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@uppercase_decorator\n",
    "def say_hi():\n",
    "    \"This will say hi\"\n",
    "    return 'hello there'\n",
    "\n",
    "say_hi()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'say_hi'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "say_hi.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This will say hi'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "say_hi.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funciones Lambda\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "cuadrado = lambda x: x ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "print(cuadrado(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### map()\n",
    "La función map() en Python aplica una función a cada uno de los elementos de una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 16, 49]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 4, 16, 49]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "enteros = [1, 2, 4, 7]\n",
    "cuadrados = []\n",
    "for e in enteros:\n",
    "    cuadrados.append(e ** 2)\n",
    "     \n",
    "print(cuadrados)\n",
    "[1, 4, 16, 49]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 16, 49]\n"
     ]
    }
   ],
   "source": [
    "enteros = [1, 2, 4, 7]\n",
    "cuadrados = list(map(lambda x : x ** 2, enteros))\n",
    "print(cuadrados)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### filter()\n",
    "La función filter() filtra una lista de elementos para los que una función devuelve True.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pares->  [2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "valores = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "pares = []\n",
    "for valor in valores:\n",
    "    if valor % 2 == 0:\n",
    "        pares.append(valor)\n",
    "print(\"Pares-> \", pares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pares->  [2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "valores = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "pares = list(filter(lambda x : x % 2 == 0, valores))\n",
    "print(\"Pares-> \", pares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### reduce()\n",
    "Esta función se utiliza principalmente para llevar a cabo un cálculo acumulativo sobre una lista de valores y devolver el resultado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n"
     ]
    }
   ],
   "source": [
    "valores = [2, 4, 6, 5, 4]\n",
    "suma = 0\n",
    "for el in valores:\n",
    "    suma += el\n",
    "print(suma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "suma = reduce(lambda x, y: x + y, valores)\n",
    "print(suma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sorted()\n",
    "Esta función ordena una lista en forma lexicográfica."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['id1', 'id100', 'id2', 'id22', 'id3', 'id30']\n"
     ]
    }
   ],
   "source": [
    "ids = ['id1', 'id2', 'id30', 'id3', 'id22', 'id100']\n",
    "print(sorted(ids)) # Lexicographic sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['id1', 'id2', 'id3', 'id22', 'id30', 'id100']\n"
     ]
    }
   ],
   "source": [
    "sorted_ids = sorted(ids, key=lambda x: int(x[2:])) # Integer sort\n",
    "print(sorted_ids)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Properties\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x, y):\n",
    "        self._x = x\n",
    "        self._y = y\n",
    "\n",
    "    def get_x(self):\n",
    "        return self._x\n",
    "\n",
    "    def set_x(self, value):\n",
    "        self._x = value\n",
    "\n",
    "    def get_y(self):\n",
    "        return self._y\n",
    "\n",
    "    def set_y(self, value):\n",
    "        self._y = value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "point = Point(5, 9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "point.get_x()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "point.get_y()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "point.set_x(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "point.get_x()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "point._x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ¿Cómo crear properties?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Circle:\n",
    "    def __init__(self, radius):\n",
    "        self._radius = radius\n",
    "\n",
    "    def _get_radius(self):\n",
    "        print(\"Get radius\")\n",
    "        return self._radius\n",
    "\n",
    "    def _set_radius(self, value):\n",
    "        print(\"Set radius\")\n",
    "        self._radius = value\n",
    "\n",
    "    def _del_radius(self):\n",
    "        print(\"Delete radius\")\n",
    "        del self._radius\n",
    "\n",
    "    radius = property(\n",
    "        fget=_get_radius,\n",
    "        fset=_set_radius,\n",
    "        fdel=_del_radius,\n",
    "        doc=\"The radius property.\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "circle = Circle(42.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Get radius\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "42.0"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circle.radius"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set radius\n"
     ]
    }
   ],
   "source": [
    "circle.radius = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Get radius\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circle.radius"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Delete radius\n"
     ]
    }
   ],
   "source": [
    "del circle.radius"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'cicle' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [73], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mcicle\u001b[49m\u001b[38;5;241m.\u001b[39mradius\n",
      "\u001b[0;31mNameError\u001b[0m: name 'cicle' is not defined"
     ]
    }
   ],
   "source": [
    "cicle.radius"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Usando property() como decorador"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Circle:\n",
    "    def __init__(self, radius):\n",
    "        self._radius = radius\n",
    "\n",
    "    @property\n",
    "    def radius(self):\n",
    "        \"\"\"The radius property.\"\"\"\n",
    "        print(\"Get radius\")\n",
    "        return self._radius\n",
    "\n",
    "    @radius.setter\n",
    "    def radius(self, value):\n",
    "        print(\"Set radius\")\n",
    "        self._radius = value\n",
    "\n",
    "    @radius.deleter\n",
    "    def radius(self):\n",
    "        print(\"Delete radius\")\n",
    "        del self._radius"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "circle = Circle(42.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Get radius\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "42.0"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circle.radius"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set radius\n"
     ]
    }
   ],
   "source": [
    "circle.radius = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Get radius\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circle.radius"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Delete radius\n"
     ]
    }
   ],
   "source": [
    "del circle.radius"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'cicle' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [80], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mcicle\u001b[49m\u001b[38;5;241m.\u001b[39mradius\n",
      "\u001b[0;31mNameError\u001b[0m: name 'cicle' is not defined"
     ]
    }
   ],
   "source": [
    "cicle.radius"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creando atributos de solo lectura"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x, y):\n",
    "        self._x = x\n",
    "        self._y = y\n",
    "\n",
    "    @property\n",
    "    def x(self):\n",
    "        return self._x\n",
    "\n",
    "    @property\n",
    "    def y(self):\n",
    "        return self._y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "point = Point(12, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "point.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "point.y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "can't set attribute",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [85], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mpoint\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mx\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m10\u001b[39m\n",
      "\u001b[0;31mAttributeError\u001b[0m: can't set attribute"
     ]
    }
   ],
   "source": [
    "point.x = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creando atributos de solo escritura"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hashlib\n",
    "import os\n",
    "\n",
    "class User:\n",
    "    def __init__(self, name, password):\n",
    "        self.name = name\n",
    "        self.password = password\n",
    "\n",
    "    @property\n",
    "    def password(self):\n",
    "        raise AttributeError(\"Password is write-only\")\n",
    "\n",
    "    @password.setter\n",
    "    def password(self, plaintext):\n",
    "        salt = os.urandom(32)\n",
    "        self._hashed_password = hashlib.pbkdf2_hmac(\n",
    "            \"sha256\", plaintext.encode(\"utf-8\"), salt, 100_000\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "user = User(\"Carolina\", \"secure_password\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "Password is write-only",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [90], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43muser\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpassword\u001b[49m\n",
      "Cell \u001b[0;32mIn [88], line 11\u001b[0m, in \u001b[0;36mUser.password\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[38;5;129m@property\u001b[39m\n\u001b[1;32m     10\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mpassword\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m---> 11\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mAttributeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPassword is write-only\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[0;31mAttributeError\u001b[0m: Password is write-only"
     ]
    }
   ],
   "source": [
    "user.password"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "user.password = \"another_Secure_password\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algunos casos de uso de las properties"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validando atributos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    @property\n",
    "    def x(self):\n",
    "        return self._x\n",
    "\n",
    "    @x.setter\n",
    "    def x(self, value):\n",
    "        try:\n",
    "            self._x = float(value)\n",
    "            print(\"Validated!\")\n",
    "        except ValueError:\n",
    "            raise ValueError('\"x\" must be a number') from None\n",
    "\n",
    "    @property\n",
    "    def y(self):\n",
    "        return self._y\n",
    "\n",
    "    @y.setter\n",
    "    def y(self, value):\n",
    "        try:\n",
    "            self._y = float(value)\n",
    "            print(\"Validated!\")\n",
    "        except ValueError:\n",
    "            raise ValueError('\"y\" must be a number') from None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validated!\n",
      "Validated!\n"
     ]
    }
   ],
   "source": [
    "point = Point(2, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "\"x\" must be a number",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [100], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mpoint\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mx\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhola\u001b[39m\u001b[38;5;124m\"\u001b[39m\n",
      "Cell \u001b[0;32mIn [98], line 16\u001b[0m, in \u001b[0;36mPoint.x\u001b[0;34m(self, value)\u001b[0m\n\u001b[1;32m     14\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mValidated!\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m     15\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m:\n\u001b[0;32m---> 16\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mx\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m must be a number\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28mNone\u001b[39m\n",
      "\u001b[0;31mValueError\u001b[0m: \"x\" must be a number"
     ]
    }
   ],
   "source": [
    "point.x = \"hola\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Para agregar atributos que requieren algún calculo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "\n",
    "    @property\n",
    "    def area(self):\n",
    "        return self.width * self.height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "rectangle = Rectangle(30, 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1500"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rectangle.area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Métodos de instancia, métodos de clase y métodos estáticos\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def method(self):\n",
    "        \"\"\" Instance method \"\"\"\n",
    "        return 'instance method called', self\n",
    "\n",
    "    @classmethod\n",
    "    def class_method(cls):\n",
    "        \"\"\" Class method \"\"\"\n",
    "        return 'class method called', cls\n",
    "\n",
    "    @staticmethod\n",
    "    def static_method():\n",
    "        \"\"\" Static method \"\"\"\n",
    "        return 'static method called'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "obj = MyClass()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('instance method called', <__main__.MyClass at 0x10964c9a0>)"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj.method()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('instance method called', <__main__.MyClass at 0x1089358e0>)"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MyClass.method(obj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('class method called', __main__.MyClass)"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj.class_method()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'static method called'"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj.static_method()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ¿Qué pasa si accedemos a los metodos sin instanciar un objeto de la clase?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('class method called', __main__.MyClass)"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MyClass.class_method()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'static method called'"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MyClass.static_method()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "method() missing 1 required positional argument: 'self'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [112], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mMyClass\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: method() missing 1 required positional argument: 'self'"
     ]
    }
   ],
   "source": [
    "MyClass.method()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplos de uso"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pizza:\n",
    "    def __init__(self, ingredients):\n",
    "        self.ingredients = ingredients\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f'Pizza({self.ingredients})'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "margherita = Pizza(['mozzarella', 'tomatoes'])\n",
    "cheese = Pizza(['mozzarella', 'provolone', 'cheddar', 'Parmesan'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(['mozzarella', 'tomatoes'])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "margherita"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(['mozzarella', 'provolone', 'cheddar', 'Parmesan'])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cheese"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pizza:\n",
    "    def __init__(self, ingredients):\n",
    "        self.ingredients = ingredients\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f'Pizza({self.ingredients})'\n",
    "    \n",
    "    def create_custom_pizza(self, ingredients):\n",
    "        self.ingredients = ingredients\n",
    "        return self\n",
    "\n",
    "    @classmethod\n",
    "    def margherita(cls):\n",
    "        return cls(['mozzarella', 'tomatoes'])\n",
    "\n",
    "    @classmethod\n",
    "    def cheese(cls):\n",
    "        return cls(['mozzarella', 'provolone', 'cheddar', 'Parmesan'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(['mozzarella', 'tomatoes'])"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Pizza.margherita()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(['mozzarella', 'provolone', 'cheddar', 'Parmesan'])"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Pizza.cheese()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_pizza = Pizza([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_pizza.ingredients"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(['chicken', 'mozzarella'])"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_pizza.create_custom_pizza(['chicken', 'mozzarella'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(['mozzarella', 'tomatoes'])"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_pizza.margherita()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['chicken', 'mozzarella']"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_pizza.ingredients"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "class Pizza:\n",
    "    def __init__(self, radius, ingredients):\n",
    "        self.radius = radius\n",
    "        self.ingredients = ingredients\n",
    "\n",
    "    def __repr__(self):\n",
    "        return (f'Pizza({self.radius}, '\n",
    "                f'{self.ingredients})')\n",
    "\n",
    "    def area(self):\n",
    "        return self.circle_area(self.radius)\n",
    "\n",
    "    @staticmethod\n",
    "    def circle_area(r):\n",
    "        return r ** 2 * math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = Pizza(4, ['mozzarella', 'tomatoes'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50.26548245743669"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50.26548245743669"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Pizza.circle_area(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "78.53981633974483"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Pizza.circle_area(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50.26548245743669"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "provenance": []
  },
  "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}