Cuadernos/0301_tipos_básicos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tema 3: objetos y métodos (I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tipos de objetos básicos\n",
    "Es hora de que conozcamos los distintos valores que podemos ir utilizando en Python. Estos valores o tipos de objetos parecen bastante sencillos, pero también son bastante poderosos y nos van a permitir representar todo lo que necesitaremos a lo largo del curso. \n",
    "\n",
    "Tanto para entregar datos a un programa como para poder manipularlos y obtener resultados de salida, necesitamos que el computador sea capaz de representar y de entender estos valores. Y ¿qué valores puede representar un ordenador? Al nivel más básico, únicamente funciona con impulsos eléctricos que pueden representar o bien un 1 o bien un 0. Entonces, ¿vamos a tener que trabajar siempre con unos y ceros? Por suerte, ¡no es necesariamente así! Los lenguajes de programación proveen representaciones para manejar distintos tipos de datos. Podríamos decir que, como los humanos utilizamos letras y números, estas representaciones básicas se corresponden con letras y números para que nos sea más natural operar con ellas.\n",
    "\n",
    "Por el momento vamos a hablar de cuatro tipos de datos básicos, que también se llaman _tipos primitivos_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### _Strings_ o cadenas de caracteres\n",
    "Las _strings_ se utilizan para representar secuencias o cadenas de caracteres. ¿Y qué caracteres pueden ser? Bueno, pueden ser espacios en blanco, números, letras, símbolos matemáticos, de puntuación, como se ve en los siguientes ejemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "esperpento\n",
      "    \n",
      "¿¿hhhaablllaaasss    bbbaallennnooo??   \n",
      "4\n",
      "3.1415\n",
      "3.1415 * 2\n"
     ]
    }
   ],
   "source": [
    "print(\"esperpento\")\n",
    "print(\"    \")\n",
    "print(\"¿¿hhhaablllaaasss    bbbaallennnooo??   \")\n",
    "print(\"4\")\n",
    "print(\"3.1415\")\n",
    "print(\"3.1415 * 2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es el tipo que usaremos queramos representar cualquier tipo de texto. Por ejemplo, como respuesta a las preguntas «¿cómo te llamas?» o «¿qué estás haciendo?». "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### _Integers_ o números enteros\n",
    "El _integer_ representa valores de números enteros. Por ejemplo, el 0, el 1, el 2 o cualquier número entero positivo o negativo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "17\n"
     ]
    }
   ],
   "source": [
    "print(4)\n",
    "print(9 + 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo vamos a usar cada vez que queramos responder a preguntas cuya respuesta siempre sea un número entero. Por ejemplo, «¿en qué año estamos?» o «¿cuántos habitantes tiene España?».\n",
    "\n",
    "Fíjate que el resultado de la primera línea es igual que el de la cuarta línea de la celda de código de las _strings_. Pero, ¿crees que se trata del mismo tipo de dato?\n",
    "\n",
    "El 4 es un número entero, pero si lo escribimos entre comillas, Python ya no lo trata como un número entero, sino como una cadena de caracteres que contiene el carácter 4. Esta expresión, entonces, no tiene valor númerico y no podemos sumar, restar, etc. con ella. Hay que tener cuidado con este tipo de casos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### _Floats_ o reales\n",
    "Los números reales o valores _float_ permiten representar números que tengan parte decimal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1415\n"
     ]
    }
   ],
   "source": [
    "print(3.1415)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo usaremos cuando vayamos a necesitar algunos decimales de precisión, o cuando no sepamos qué tipo de número nos van a contestar, ya que tanto los reales como los enteros se pueden representar como floats, pero no viceversa. Por ejemplo, si quiero preguntar «¿cuántos kilos de tomate hay que comprar?» o «¿en cuántos segundos corre Bolt los 200 metros planos?».\n",
    "\n",
    "Desde el punto de vista del lenguaje todo número que tenga un punto decimal pertenece al tipo float, aun cuando su valor matemático sea el que corresponda a un número entero. Es decir, `3` es un entero para Python, pero `3.0` es un número real, aunque matemáticamente tengan el mismo valor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Valores booleanos\n",
    "Por último, los valores _booleanos_ representan valores de la lógica binaria. Se llaman así en honor a George Boole, que fue quien desarrolló el álgebra booleana basada en dos valores de verdad: el valor verdadero, `True`, y el valor falso, `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(True)\n",
    "print(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usaremos los booleanos para responder preguntas cuyas respuestas puedan resumirse en un sí o un no: «¿somos amigos?» o «¿estás en casa?». \n",
    "\n",
    "Hay que poner atención a la hora de escribirlos. Recordemos que si escribimos cualquier cosa entre comillas Python la interpreta como una string. Por lo tanto, `\"True\"` será una string, mientras que **`True`** será un booleano.\n",
    "\n",
    "También tenemos que tener cuidado con las mayúsculas. Tanto `True` como `False` solo se comportan como booleanos si llevan la primera letra en mayúsculas, y `true` o `false` no son nada."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Resumen de tipos\n",
    "| Tipo de objeto | Descripción | Ejemplos | Abreviatura\n",
    "| -------------- | ----------- | -------- | -----------\n",
    "| _strings_ o cadenas de caracteres | Cualquier cosa que vaya entre comillas | 'rosa', 'rosa, rosae' | str\n",
    "| _integers_ o números enteros | Números enteros, sin expresión de la parte decimal | 1, 2, 10 | int\n",
    "| _floats_ o números reales | Cualquier número, con expresión de la parte decimal | 10.00, 9.8, 3.1415 | float\n",
    "| booleanos | Valores lógicos | True, False | bool"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Función `type()`\n",
    "Podemos averiguar el tipo de dato que estamos usando en todo momento usando `type()`, que toma como parámetro el valor del que queramos averiguar el tipo y devuelve la abreviatura del tipo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type('ocho')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(8.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(8 == 8.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicios\n",
    "### 030101\n",
    "¿Qué tipo de valor es `49`? ¿Y `49.00`?\n",
    "¿Qué tipo de valor es `12 + 5`? ¿Y `11.2 + 5.8`?"
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}