{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Introducción a la sintaxis de Python I: tipos de datos"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"_En esta clase haremos una rápida introducción a la sintaxis de Python. Veremos cuáles son los tipos numéricos básicos, cómo se comportan al operar con ellos, cómo almacenarlos en variables, y tendremos nuestro primer contacto con contenedores de datos como son las listas y las tuplas._\n",
"\n",
"Objetivos:\n",
"\n",
"* Conocer los distintos tipos de datos numéricos básicos\n",
"* Aprender a operar con ellos\n",
"* Aprender a definir variables\n",
"* Primer contacto con listas y tuplas\n",
"\n",
"---"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Tipos numéricos"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Python dispone de los tipos numéricos y las operaciones más habituales:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"7.0"
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2 * 4 - (7 - 1) / 3 + 1.0"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Las divisiones por cero lanzan un error:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"ename": "ZeroDivisionError",
"evalue": "division by zero",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mZeroDivisionError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m1\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
]
}
],
"source": [
"1 / 0 "
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"ename": "ZeroDivisionError",
"evalue": "float division by zero",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mZeroDivisionError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m1.0\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m0.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mZeroDivisionError\u001b[0m: float division by zero"
]
}
],
"source": [
"1.0 / 0.0"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
Más adelante veremos cómo tratar estos errores. Por otro lado, cuando usemos NumPy esta operación devolverá `NaN`.
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La división entre enteros en Python 3 devuelve un número real, al contrario que en Python 2 donde devuelve la parte entera."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2.3333333333333335"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"7 / 3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Se puede forzar que la división sea entera en Python 3 con el operador `//`: "
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"7 // 3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Se puede elevar un número a otro con el operador `**`:"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"65536"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2 ** 16"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Otro tipo que nos resultará muy útil son los complejos:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(2+3j)"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2 + 3j"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1j"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"1j"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3.605551275463989"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Valor absoluto\n",
"abs(2 + 3j)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
Tip de IPython: podemos recuperar resultados pasados usando `_`. Por ejemplo, para recuperar el resultado correspondiente a `Out [7]`, usaríamos `_7`. Esta variable guarda ese valor para toda la sesión.
La función print es la que se usa para imprimir resultados por pantalla. Por si lo ves en algún sitio, en Python 2 era una sentencia y funcionaba de manera distinta, sin paréntesis y sin posibilidad de pasar argumentos adicionales.
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Asignación y operadores de comparación"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La asignación se realiza con el operador `=`. Los nombres de las variables en Python pueden contener caracteres alfanuméricos (empezando con una letra) a-z, A-Z, 0-9 y otros símbolos como la \\_. \n",
"\n",
"Por cuestiones de estilo, las variables suelen empezar con minúscula, reservando la mayúcula para clases. \n",
"\n",
"Algunos nombres no pueden ser usados porque son usados por python:\n",
"\n",
" and, as, assert, break, class, continue, def, del, elif, else, except, exec, finally, for, from, global, if, import, in, is, lambda, not, or, pass, print, raise, return, try, while, with, yield"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [],
"source": [
"a = 1 + 2j"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En Python __la asignación no imprime el resultado por pantalla__, al contrario de como sucede en MATLAB y Octave (salvo que se incluya el punto y coma al final). La mejor manera de visualizar la variable que acabamos de asignar es esta:"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3.14159"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"b = 3.14159\n",
"b"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En una celda __podemos escribir código que ocupe varias líneas__. Si la última de ellas devuelve un resultado, este se imprimirá."
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(1, 2)"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x, y = 1, 2\n",
"x, y"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
Podemos realizar **asignación múltiple**, que hemos hecho en la celda anterior con las variables `x` e `y` para intercambiar valores de manera intuitiva:
"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(2, 1)"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x, y = y, x\n",
"x, y"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Los operadores de comparación son:\n",
"\n",
"* `==` igual a\n",
"* `!=` distinto de \n",
"* `<` menor que\n",
"* `<=` menor o igual que\n",
"\n",
"Devolverán un booleano: `True` o `False`"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x == y"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"print(x != y)"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n",
"False\n",
"True\n",
"True\n"
]
}
],
"source": [
"print(x < y)\n",
"print(x <= y)\n",
"print(x > y)\n",
"print(x >= y)"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# incluso:\n",
"x = 5.\n",
"6. < x < 8."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Si la ordenación no tiene sentido nos devolverá un error:"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"ename": "TypeError",
"evalue": "'<' not supported between instances of 'complex' and 'complex'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m1\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1j\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1j\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'complex' and 'complex'"
]
}
],
"source": [
"1 + 1j < 0 + 1j"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# En las cadenas de texto sí existe un orden\n",
"'aaab' > 'ba'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Booleanos"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"True and False"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"not False"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"True or False"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"20"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Una curiosidad:\n",
"(True + True) * 10 "
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 35,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# La razón...\n",
"isinstance(True, int)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Otros tipos de datos: listas y tuplas"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Otro tipo de datos muy importante que vamos a usar son las secuencias: las tuplas y las listas. Ambos son conjuntos ordenados de elementos: las tuplas se demarcan con paréntesis y las listas con corchetes."
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, 2, 3.0, (4+0j), '5']\n",
"(1, 2, 3.0, (4+0j), '5')\n",
"False\n"
]
}
],
"source": [
"una_lista = [1, 2, 3.0, 4 + 0j, \"5\"]\n",
"una_tupla = (1, 2, 3.0, 4 + 0j, \"5\")\n",
"print(una_lista)\n",
"print(una_tupla)\n",
"print(una_lista == una_tupla)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Para las tuplas, podemos incluso obviar los paréntesis:"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tuple"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"tupla_sin_parentesis = 2,5,6,9,7\n",
"type(tupla_sin_parentesis)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En los dos tipos podemos:\n",
"\n",
"* Comprobar si un elemento está en la secuencia con el operador `in`:"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2 in una_lista"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2 in una_tupla"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Saber cuandos elementos tienen con la función `len`:"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 40,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"len(una_lista)"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"len(una_tupla)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Podemos *indexar* las secuencias, utilizando la sintaxis `[::]`:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"![indexing](../images/indexing.png)"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"[1, 2]\n",
"(1, 2, 3.0)\n",
"5\n",
"(1, 2, 3.0, (4+0j), '5')\n",
"[1, 3.0, '5']\n"
]
}
],
"source": [
"print(una_lista[0]) # Primer elemento, 1\n",
"print(una_tupla[1]) # Segundo elemento, 2\n",
"print(una_lista[0:2]) # Desde el primero hasta el tercero, excluyendo este: 1, 2\n",
"print(una_tupla[:3]) # Desde el primero hasta el cuarto, excluyendo este: 1, 2, 3.0\n",
"print(una_lista[-1]) # El último: 4 + 0j\n",
"print(una_tupla[:]) # Desde el primero hasta el último\n",
"print(una_lista[::2]) # Desde el primero hasta el último, saltando 2: 1, 3.0"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Veremos más cosas acerca de indexación en NumPy, así que de momento no te preocupes. Sólo __recuerda una cosa:__"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### ¡En Python, la indexación empieza por CERO!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"** Al finalizar esta lección deberías conocer los tipo básicos de datos numéricos y booleanos, saber cómo comprobar su tipo, operar con ellos y definir variables. Además hemos hecho una primera toma de contacto con contenedores de datos como son las listas y las tuplas.**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"###### Juan Luis Cano, Mabel Delgado, Alejandro Sáez"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"_Las siguientes celdas contienen configuración del Notebook_\n",
"\n",
"_Para visualizar y utlizar los enlaces a Twitter el notebook debe ejecutarse como [seguro](http://ipython.org/ipython-doc/dev/notebook/security.html)_\n",
"\n",
" File > Trusted Notebook"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"/* This template is inspired in the one used by Lorena Barba\n",
"in the numerical-mooc repository: https://github.com/numerical-mooc/numerical-mooc\n",
"We thank her work and hope you also enjoy the look of the notobooks with this style */\n",
"\n",
"\n",
"\n",
"El estilo se ha aplicado =)\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# preserve\n",
"# Esta celda da el estilo al notebook\n",
"from IPython.core.display import HTML\n",
"css_file = '../styles/aeropython.css'\n",
"HTML(open(css_file, \"r\").read())"
]
}
],
"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.6.4"
}
},
"nbformat": 4,
"nbformat_minor": 1
}