{ "cells": [ { "attachments": { "logpyjn.png": { "image/png": "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" } }, "cell_type": "markdown", "metadata": {}, "source": [ "# *Fundamentos de Python 3 en Jupyter*\n", "![logpyjn.png](attachment:logpyjn.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "### El lenguaje de programación Python: Funciones" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "25\n" ] } ], "source": [ "x = 20 \n", "y = 5\n", "print(x+y) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "`add_numbers` es una función que toma dos números y los suma." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def add_numbers(x, y):\n", " return x + y\n", "\n", "add_numbers(1, 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "`add_numbers` puede actualizarse agregando un tercer parámetro. Usando `print` se pueden imprimir múltiples opciones en una sola celda de `Jupyter`." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3\n", "6\n" ] } ], "source": [ "def add_numbers(x,y,z=None):\n", " if (z==None):\n", " return x+y\n", " else:\n", " return x+y+z\n", "\n", "print(add_numbers(1, 2))\n", "print(add_numbers(1, 2, 3))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "A `add_numbers` también pordemos agregarle un parámetro opcional llamado `flag`." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "¡Flag es verdad, y es muy útil!\n", "23\n" ] } ], "source": [ "def add_numbers(x, y, z=None, flag=False):\n", " if (flag):\n", " print('¡Flag es verdad, y es muy útil!')\n", " if (z==None):\n", " return x + y\n", " else:\n", " return x + y + z\n", " \n", "print(add_numbers(1, 2, 20, flag=True))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Se puede también asignar la función `add_numbers` a una variable `a`." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-2" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def add_numbers(x,y,z):\n", " return x+y+z\n", "\n", "a = add_numbers\n", "a(1, 2, -5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "La función `min` devuelve el elemento más pequeño en un iterable o el más pequeño de dos o más argumentos." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-6\n" ] } ], "source": [ "x = (1,3,5, -6)\n", "minimum = min(x)\n", "print(minimum)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "La función `pow(x,y)` devuelve `x` a la potencia de `y`." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n" ] } ], "source": [ "p = pow(2,2)\n", "print(p)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "La función `x//y` devuelve la parte entera del cociente entre `x` y `y`." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2.5\n", "2\n" ] } ], "source": [ "div = 5/2\n", "print(div)\n", "divint = 5//2\n", "print(divint)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "La función `x%y` devuelve el resto de la división entre `x` y `y`." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n" ] } ], "source": [ "mod1 = 4%2\n", "print(mod1)\n", "mod2 = 5%2\n", "print(mod2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "### El lenguaje de programación Python: Tipos y Secuencias" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Use `type` para devolver el tipo del objeto." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "str" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type('Esto es una cadena de caracteres')" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "NoneType" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(None)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "int" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(10000)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "float" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(100000.0)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "function" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(add_numbers)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Una `tupla` es una estructura de dato inalterable. Las `tuplas` son secuencias, al igual que las `listas`. La diferencia entre las `tuplas` y las `listas` es que las `tuplas` no se pueden modificar a diferencia de las `listas`. Las `tuplas` usan paréntesis, mientras que las `listas` usan corchetes." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\n" ] } ], "source": [ "x = (1, 'b', 25, 'c')\n", "print(type(x))\n", "y = [1, 'b', 25, 'c']\n", "print(type(y))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Veamos algunas modificaciones en la estructura de datos `lista`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Usemos `append` para gregar un elemento a la `lista`." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 'b', 25, 'c', 2.5]\n" ] } ], "source": [ "y.append(2.5)\n", "print(y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Este es un ejemplo de cómo se puede hacer un ciclo para recorrer los elementos de la `lista`." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "b\n", "25\n", "c\n", "2.5\n" ] } ], "source": [ "for elemento in y:\n", " print(elemento)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "O podemos utilizar el operador de índices:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "b\n", "25\n", "c\n", "2.5\n" ] } ], "source": [ "i=0\n", "while( i != len(y) ):\n", " print(y[i])\n", " i = i + 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Use `+` para concatenar `listas`." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 25, 3, 'z']" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[1,25] + [3,'z']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Use `*` para repetir `listas`." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[3, 'z', 3, 'z', 3, 'z', 3, 'z']" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[3, 'z']*4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Use el operador `in` para chequear si algo está dentro de la `lista`." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'z' in [3,'z', 25]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Use la notación `bracket []` para picar o rebanar `listas` o `cadenas de caracteres`" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "c\n", "[2]\n", "[2, 'c']\n", "E\n", "E\n", "Es\n" ] } ], "source": [ "y =[2, 'c', 34, -2, 'f']\n", "print(y[1]) #primer elemento de la lista\n", "print(y[0:1]) #primer elemento devuelto como lista\n", "print(y[0:2]) #dos primeros elementos devueltos como lista\n", "\n", "x = 'Esto es una cadena de caracteres'\n", "print(x[0]) #primer caracter\n", "print(x[0:1]) #primer caracter, especificando último caracter\n", "print(x[0:2]) #dos primeros caracteres" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Esta instrucción devuelve el último elemento de la lista o de la cadena." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "f\n", "s\n" ] } ], "source": [ "print(y[-1])\n", "print(x[-1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Esta instrucción devuelve un pedazo de la `lista` o `cadena` empezando desde el cuarto elemento desde el final y deteniéndose antes del segundo elemento del final." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[2, 'c', 34, -2, 'f']\n", "['c', 34]\n", "Esto es una cadena de caracteres\n", "er\n" ] } ], "source": [ "print(y)\n", "print(y[-4:-2])\n", "print(x)\n", "print(x[-4:-2])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Este es un pedazo de la `lista` o `cadena` desde el inicio y se detiene antes del tercer elemento." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[2, 'c', 34, -2, 'f']\n", "[2, 'c', 34]\n", "Esto es una cadena de caracteres\n", "Est\n" ] } ], "source": [ "print(y)\n", "print(y[:3])\n", "print(x)\n", "print(x[:3])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Y este es un pedazo de la `lista` o `cadena` empezando desde el tercer elemento y siguiendo hasta el final." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[2, 'c', 34, -2, 'f']\n", "[-2, 'f']\n", "Esto es una cadena de caracteres\n", "o es una cadena de caracteres\n" ] } ], "source": [ "print(y)\n", "print(y[3:])\n", "print(x)\n", "print(x[3:])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "### Leer y escribir archivos CSV" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Vamos a importar un archivo `txt` como \n", "uno `CSV` que contiene como columnas las etiquetas:\n", "\n", "* Nombre,Departamento,Mes de Cumpleaños\n", "\n", "Y como filas:\n", "\n", "* Adelis Nieves, Matemáticas, Junio\n", "* Miguel Astor, Redes, Septiembre\n", "* Francisco Sans, Computación Gráfica, Diciembre\n", "* Antonio Escalante, Letras, Diciembre" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Los nombres de las columnas son: Nombre, Departamento, Mes de Cumpleaños\n", "\tAdelis Nieves trabaja en el departamento de Matemáticas, y nació en el mes de Junio.\n", "\tMiguel Astor trabaja en el departamento de Redes, y nació en el mes de Septiembre.\n", "\tFrancisco Sans trabaja en el departamento de Computación Gráfica, y nació en el mes de Diciembre.\n", "\tAntonio Escalante trabaja en el departamento de Letras, y nació en el mes de Diciembre.\n", "Líneas procesadas: 5.\n" ] } ], "source": [ "import csv\n", "\n", "with open('empleados_cumple.txt') as csv_file:\n", " csv_reader = csv.reader(csv_file, delimiter=',')\n", " line_count = 0\n", " for row in csv_reader:\n", " if line_count == 0:\n", " print(f'Los nombres de las columnas son: {\", \".join(row)}')\n", " line_count += 1\n", " else:\n", " print(f'\\t{row[0]} trabaja en el departamento de {row[1]}, y nació en el mes de {row[2]}.')\n", " line_count += 1\n", " print(f'Líneas procesadas: {line_count}.')" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "
\n", "### Lenguaje de programación Python: Python Numérico (NumPy)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Creando arreglos" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Podemos generar una `lista` y convertirla en un `arreglo NumPy`." ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 1, 25, 31, 5])" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "milista = [1, 25, 31, 5]\n", "x = np.array(milista)\n", "x" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "O simplemente podemos pasarle una lista directamente." ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 1, 25, 31, 5])" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y = np.array([1, 25, 31, 5])\n", "y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Podemos pasarle una `lista` de `listas` para crear un `arreglo multidimensional`." ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 1, 25, 31, 5],\n", " [10, 2, 11, 12],\n", " [ 5, 7, 0, 1]])" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "m = np.array([[1, 25, 31, 5], [10, 2, 11, 12], [5, 7, 0, 1]])\n", "m" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Usa el método `shape` para encontrar las dimensiones del arreglo. (filas, columnas)" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(3, 4)" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "m.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "`arange` devuelve valores espaciados uniformemente dentro de un intervalo dado." ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n = np.arange(0, 30, 2) # empieza en 0 cuenta de 2 en 2, se detiene antes de 30\n", "n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "`reshape` devuelve una matriz con los mismos datos con una nueva forma." ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 2, 4, 6, 8],\n", " [10, 12, 14, 16, 18],\n", " [20, 22, 24, 26, 28]])" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n = n.reshape(3, 5) #cambia la forma de manera que se obtenga una matriz 3x5\n", "n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Combinando arreglos" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 1, 1],\n", " [1, 1, 1]])" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "p = np.ones([2, 3], int)\n", "p" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Use `vstack` para apilar matrices en secuencia verticalmente (por fila)." ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 1, 1],\n", " [1, 1, 1],\n", " [2, 2, 2],\n", " [2, 2, 2]])" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.vstack([p, 2*p])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Use `hstack` para apilar arreglos en secuencia horizontalmente (por columna)." ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 1, 1, 2, 2, 2],\n", " [1, 1, 1, 2, 2, 2]])" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.hstack([p, 2*p])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Operaciones" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Use `+`, `-`, `*`, `/` and `**` para realizar operaciones de suma , resta, multiplicación, división y potencia elemento a elemento." ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 1 25 31 5]\n", "[ 1 25 31 5]\n", "[ 2 50 62 10]\n", "[0 0 0 0]\n" ] } ], "source": [ "print(x)\n", "print(y)\n", "print(x + y) # suma elemento a elemento [1 2 3] + [4 5 6] = [5 7 9]\n", "print(x - y) # resta elemento a elemento [1 2 3] - [4 5 6] = [-3 -3 -3]" ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 1 25 31 5]\n", "[ 1 25 31 5]\n", "[ 1 625 961 25]\n", "[1. 1. 1. 1.]\n" ] } ], "source": [ "print(x)\n", "print(y)\n", "print(x * y) # multiplicación elemento a elemento [1 2 3] * [4 5 6] = [4 10 18]\n", "print(x / y) # división elemento a elemento [1 2 3] / [4 5 6] = [0.25 0.4 0.5]" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 1 25 31 5]\n", "[ 1 625 961 25]\n" ] } ], "source": [ "print(x)\n", "print(x**2) # potencia elemento a elemento [1 2 3] ^2 = [1 4 9]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Producto punto o escalar:** \n", "\n", "$ \\begin{bmatrix}x_1 \\ x_2 \\ x_3\\end{bmatrix}\n", "\\cdot\n", "\\begin{bmatrix}y_1 \\\\ y_2 \\\\ y_3\\end{bmatrix}\n", "= x_1 y_1 + x_2 y_2 + x_3 y_3$" ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 1 25 31 5]\n", "[ 1 25 31 5]\n" ] }, { "data": { "text/plain": [ "1612" ] }, "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print(x)\n", "print(y)\n", "x.dot(y) #producto escalar " ] }, { "cell_type": "code", "execution_count": 61, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 1 25 31 5]\n", "[[ 1 25 31 5]\n", " [ 1 625 961 25]]\n", "2\n" ] } ], "source": [ "print(y)\n", "z = np.array([y, y**2])\n", "print(z)\n", "print(len(z)) #número de filas del arreglo" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Vamos a mirar la transposición de matrices. La transposición permuta las dimensiones de la matriz." ] }, { "cell_type": "code", "execution_count": 62, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 1, 1],\n", " [ 25, 625],\n", " [ 31, 961],\n", " [ 5, 25]])" ] }, "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "zt = np.transpose(z, axes=None)\n", "zt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Las dimensiones del arreglo `zt` son `(4,2)` después de la transposición." ] }, { "cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(4, 2)" ] }, "execution_count": 63, "metadata": {}, "output_type": "execute_result" } ], "source": [ "zt.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Se puede usar también `.T` para obtener la transpuesta de un arreglo." ] }, { "cell_type": "code", "execution_count": 65, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[ 1 1]\n", " [ 25 625]\n", " [ 31 961]\n", " [ 5 25]]\n" ] }, { "data": { "text/plain": [ "array([[ 1, 25, 31, 5],\n", " [ 1, 625, 961, 25]])" ] }, "execution_count": 65, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print(zt)\n", "zt.T" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Indexando/Rebanando" ] }, { "cell_type": "code", "execution_count": 66, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144])" ] }, "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s = np.arange(13)**2\n", "s" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Use la notación de `bracket []` para obtener valores en el índice indicado. Recuerde que la indexación comienza en 0." ] }, { "cell_type": "code", "execution_count": 67, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(0, 16, 144)" ] }, "execution_count": 67, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s[0], s[4], s[-1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Use `:` para indicar un rango. `array[empieza:termina]`\n", "\n", "\n", "Dejando `empieza` or `termina` vacío quedará predeterminado al principio / final de la matriz." ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 1, 4, 9, 16])" ] }, "execution_count": 69, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s[1:5]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Use contadores negativos desde el final." ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 81, 100, 121, 144])" ] }, "execution_count": 70, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s[-4:]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Se puede usar un segundo `:` para indicar el tamaño del paso. `array [empieza: termina: paso]`\n", "\n", "Aquí estamos comenzando el quinto elemento desde el final, y contando hacia atrás cada 2 hasta que se alcanza el comienzo de la matriz." ] }, { "cell_type": "code", "execution_count": 71, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([64, 36, 16, 4, 0])" ] }, "execution_count": 71, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s[-5::-2]" ] } ], "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 }