lecturas/t3l1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tipos de datos (parte 1)\n",
    "\n",
    "Para poder hacer un uso más eficiente de los lenguajes y entender también lo que podemos manipular, conviene distinguir los tipos de datos que podemos encontrar en python. En otros lenguajes esta información es usada para hacer un uso óptimo de la memoria.  \n",
    "\n",
    "A continuación, los tipos de datos que podemos distinguir:  \n",
    "\n",
    "+   Numéricos: Estan incluidos los números enteros, flotantes (equivalentes de los reales) y complejos.  \n",
    "+   Valores lógicos: Corresponden a los valores lógicos de verdadero y falso.  \n",
    "+   Cadenas de carácteres: Son los carácteres simples o conjuntos de carácteres (o sea, texto).  \n",
    "+   Agrupaciones: Son estructuras que permiten reunir varios datos en uno, así no sean del mismo tipo.  \n",
    "    +   Listas: Son colecciones de datos ordenadas que pueden modificarse.  \n",
    "    +   Tuples: A diferencia de las listas, no pueden modificarse una vez se asignan.  \n",
    "    +   Diccionarios: Son colecciones no ordenadas que asocian una clave a los valores almacenados.  \n",
    "    +   Conjuntos: Son colecciones no ordenadas y que no permiten repetición de elementos.  \n",
    "\n",
    "A continuación, trabajaremos un poco con ellos para comprenderlos y saber que operaciones se pueden usar.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Datos numéricos\n",
    "\n",
    "En los datos numéricos asociados los conjuntos de los números enteros, flotantes y complejos. Es necesario entender que estos no se corresponden de manera exacta a los conjuntos numéricos matemáticos. Esto lo profundizaremos con ejemplos.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Números enteros\n",
    "\n",
    "Los números enteros en python 3 no se diferencian por su tamaño como sucede en otros lenguajes o en su versión anterior (python 2). Esto permite trabajar con los números enteros sin mayor dificultad al no tener que hacer consideraciones iniciales sobre la magnitud de estos.  \n",
    "\n",
    "Una ventaja adicional de python 3 respecto a su versión anterior es que no existe el concepto de un entero máximo, de manera que en este caso el conjunto de los números enteros si es correspondiente entre python y el matemático, formando números tan grandes como queramos.  \n",
    "\n",
    "A continuación, asignaremos en variables números enteros, probaremos valores grandes, pequeños y de diferente signo, y operaremos con ellos.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-35 es un número negativo y 15 es un número positivo.Podemos tener números pequeños como 0 pero también grandes como 999999999999999999999999999999999999999999999999999999999999999999999999999999999999.Podemos crear valores con notación científica como -5e+70\n"
     ]
    }
   ],
   "source": [
    "numero_positivo = 15\n",
    "numero_negativo = -35\n",
    "numero_pequeño = 0\n",
    "numero_grande = 999999999999999999999999999999999999999999999999999999999999999999999999999999999999\n",
    "numero_grande_cientifico = -5e70\n",
    "print('{} es un número negativo y {} es un número positivo.'.format(numero_negativo, numero_positivo) + \\\n",
    "      'Podemos tener números pequeños como {} pero también grandes como {}.'.format(numero_pequeño, numero_grande) + \\\n",
    "      'Podemos crear valores con notación científica como {}'.format(numero_grande_cientifico))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(numero_negativo) # Valor absoluto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Al comparar `numero_positivo` con `numero_negativo`, el menor de ellos es -35 y el mayor es 15\n"
     ]
    }
   ],
   "source": [
    "print('Al comparar `numero_positivo` con `numero_negativo`, ' + \\\n",
    "     'el menor de ellos es {} y el mayor es {}'.format(min(numero_negativo, numero_positivo), \\\n",
    "                                                       max(numero_negativo, numero_positivo)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40.00124947938359"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5*8+3/(2-9)**4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El módulo 5 de 12 es 2\n"
     ]
    }
   ],
   "source": [
    "valor_1 = 12\n",
    "valor_2 = 5\n",
    "modulo_ejemplo = valor_1%valor_2\n",
    "print('El módulo {} de {} es {}'.format(valor_2, valor_1, modulo_ejemplo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cuenta la leyenda, que quien invento el ajedrez cobro por las 64 casillas un total de 18446744073709551615 granos de arroz\n"
     ]
    }
   ],
   "source": [
    "casillas = 64\n",
    "granos_arroz = 2**casillas - 1\n",
    "print('Cuenta la leyenda, que quien invento el ajedrez cobro por las ' + \\\n",
    "      '{0} casillas un total de {1} granos de arroz'.format(casillas, granos_arroz))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Números flotantes\n",
    "\n",
    "Los números flotantes son el equivalente en una máquina de los números reales, sin embargo no son exactamente iguales. En el caso de los números reales sabemos que existen infinitos y que además la cantidad de números reales entre dos reales cualesquiera también es infinita. En los flotantes, debido a la limitación de memoria de la máquina esto resulta imposible de manejar (existen trucos para manejarlos sin problema a costa de mayor procesamiento y memoria, así como sucede con los enteros de python 3) y por ende son finitos y es posible saber cual es el flotante siguiente a otro (así como el más grande y el más pequeño).  \n",
    "\n",
    "Esto es importante aclararlo porque cuando operamos con flotantes sus resultados no coincidirán con los esperados de la matemática. Aún más, si operamos con cantidades que difieren enormemente en magnitud puede llevarnos a errores muy grandes (por ejemplo, cuando dividimos por números cercanos a cero).  \n",
    "\n",
    "Notemos algunas características con ejemplos.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 < 3.5 # Se pueden comparar enteros con flotantes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.7e-10\n"
     ]
    }
   ],
   "source": [
    "a = 5.7e-10 # Número en notación científica. Equivale a 5.7 x 10^(-10) = 0.00000000057\n",
    "print('{}'.format(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El valor de la aceleración gravitacional sobre la superficie terrestre es 9.82 m/s² aproximadamente\n"
     ]
    }
   ],
   "source": [
    "M = 5.972e24 # Masa de la Tierra en kilogramos\n",
    "R = 6371e3 # Radio de la Tierra en metros\n",
    "G = 6.674e-11 # Valor de la constante gravitacional (de Cavendish) en sistema internacional\n",
    "gT = G*M/R**2\n",
    "print('El valor de la aceleración gravitacional sobre la superficie terrestre es {:0.2f} m/s² aproximadamente'.format(gT))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dado el número 3.5, su parte entera es 3.\n"
     ]
    }
   ],
   "source": [
    "flotante = 3.5\n",
    "entero = int(flotante)\n",
    "print('Dado el número {:0.1f}, su parte entera es {}.'.format(flotante, entero))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "¿El número guardado en *a* es identico a 0? True\n"
     ]
    }
   ],
   "source": [
    "a = 2e-600\n",
    "print(a)\n",
    "# Este número matemáticamente es distinto de cero pero para python lo es.\n",
    "print('¿El número guardado en *a* es identico a 0? {}'.format(0==a)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inf\n"
     ]
    }
   ],
   "source": [
    "b = 2e9999\n",
    "print(b) # Este número es grande pero no infinito, pero para python es equivalente al infinito."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "¿3=1+1+1? True\n",
      "¿0.3=0.1+0.1+0.1? False\n"
     ]
    }
   ],
   "source": [
    "print('¿3=1+1+1? {}'.format(3==1+1+1)) # Los enteros se operan tal cual en matemáticas\n",
    "print('¿0.3=0.1+0.1+0.1? {}'.format(0.3==0.1+0.1+0.1)) # Pero los resultados de los reales difieren de los flotantes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Números complejos\n",
    "\n",
    "En este caso, los números complejos son una extensión a los dos conjuntos anteriores añadiendo el símbolo de número imaginario a su lado. Tenga en cuenta que se usará `j` y no `i`. El comportamiento respecto a las operaciones y lo que puede representar depende del número que acompaña a la parte imaginaria.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1e-15+8000000000000005j)\n",
      "4.75j\n",
      "42.16277979450596\n"
     ]
    }
   ],
   "source": [
    "imaginario_1 = 5j\n",
    "imaginario_2 = -2.5e-1j\n",
    "complejo_1 = 2.3+42.1j\n",
    "complejo_2 = 1e-15 + 8e15j\n",
    "print(imaginario_1 + complejo_2) # Operación con complejos\n",
    "print(imaginario_1 + imaginario_2) # Operación de imaginarios\n",
    "print(abs(complejo_1)) # Módulo/magnitud del número complejo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Valores lógicos\n",
    "\n",
    "Los valores lógicos en python se representan como `True` para el valor verdadero y `False` para el valor de falso. Aún así, es posible extender su uso a través de representaciones numéricas, usando el cero para representar el valor falso y el uno para el valor verdadero. Ahora veamos ejemplos.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "valor_v = True\n",
    "valor_f = False\n",
    "valor_operacion = not(valor_v and (valor_v or valor_f))\n",
    "print(valor_operacion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "¿0 es falso? True\n",
      "¿1 es verdadero? True\n",
      "¿2 es verdadero? False\n"
     ]
    }
   ],
   "source": [
    "print('¿0 es falso? {}'.format(0==False)) # Cero equivalente a falso\n",
    "print('¿1 es verdadero? {}'.format(1==True)) # 1 equivalente a verdadero\n",
    "print('¿2 es verdadero? {}'.format(2==True)) # Números distintos no sirven para equivalencias lógicas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numero_5 = 5\n",
    "5 <= numero_5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Actividad\n",
    "\n",
    "Puedes realizar la actividad respectiva a partir de los enunciados descritos en [t3a1q](../actividades/t3a1q.ipynb).  "
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}