{
"metadata": {
"name": ""
},
"nbformat": 3,
"nbformat_minor": 0,
"worksheets": [
{
"cells": [
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"3. Numpy."
]
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.1. Descripci\u00f3n."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Python tiene listas, enteros, punto flotante, etc. Para c\u00e1lculo num\u00e9rico necesitamos m\u00e1s... all\u00ed aparece Numpy.\n",
"* Numpy es un paquete que provee a Python con arreglos multidimensionales de alta eficiencia y dise\u00f1ados para c\u00e1lculo cient\u00edfico.\n",
"* Un array puede contener:\n",
" * tiempos discretos de un experimento o simulaci\u00f3n. \n",
" * se\u00f1ales grabadas por un instrumento de medida.\n",
" * pixeles de una imagen, etc."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%matplotlib inline"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 1
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import numpy as np"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 2
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.2. El objeto arreglo."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Los arreglos de NumPy son de tipado **est\u00e1tico** y **homog\u00e9neo**.\n",
"* Son m\u00e1s eficientes en el uso de la memoria.\n",
"* La funciones matem\u00e1ticas complejas y computacionalmente costosas (pj: la multiplicaci\u00f3n de matrices) son implementadas en lenguajes compilados como C o Fortran."
]
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.2.1. Creaci\u00f3n de arreglos unidimensionales."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A partir de una lista de Python:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"lista = [1, 2, 3, 4 , 5]"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 3
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"type(lista)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 4,
"text": [
"list"
]
}
],
"prompt_number": 4
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = np.array(lista)"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 5
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 6,
"text": [
"array([1, 2, 3, 4, 5])"
]
}
],
"prompt_number": 6
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"type(a)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 7,
"text": [
"numpy.ndarray"
]
}
],
"prompt_number": 7
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Podemos conocer el tipo de datos a trav\u00e9s de `dtype`:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a.dtype"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 8,
"text": [
"dtype('int64')"
]
}
],
"prompt_number": 8
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Incluso podemos definir el tipo de dato al momento de la creaci\u00f3n de arreglo:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a_complejo = np.array(lista, dtype=complex)"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 9
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a_complejo"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 10,
"text": [
"array([ 1.+0.j, 2.+0.j, 3.+0.j, 4.+0.j, 5.+0.j])"
]
}
],
"prompt_number": 10
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a_complejo.dtype"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 11,
"text": [
"dtype('complex128')"
]
}
],
"prompt_number": 11
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"o cambiar el tipo de dato:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a_no_mas_complejo = a_complejo.astype(np.int64)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stderr",
"text": [
"-c:1: ComplexWarning: Casting complex values to real discards the imaginary part\n"
]
}
],
"prompt_number": 12
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a_no_mas_complejo"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 13,
"text": [
"array([1, 2, 3, 4, 5])"
]
}
],
"prompt_number": 13
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Si queremos ver algunas caracter\u00edsticas del arreglo a:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a.ndim # dimensi\u00f3n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 14,
"text": [
"1"
]
}
],
"prompt_number": 14
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a.shape # 5 x 1"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 15,
"text": [
"(5,)"
]
}
],
"prompt_number": 15
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"len(a) # elementos en la primera dimension"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 16,
"text": [
"5"
]
}
],
"prompt_number": 16
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.2.2. Creaci\u00f3n de arreglos de 2 y 3 dimensiones."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"b = np.array([[0, 1, 2], [3, 4, 5]]) # arreglo 2 x 3"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 17
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 18,
"text": [
"array([[0, 1, 2],\n",
" [3, 4, 5]])"
]
}
],
"prompt_number": 18
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"b.ndim"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 19,
"text": [
"2"
]
}
],
"prompt_number": 19
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"b.shape"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 20,
"text": [
"(2, 3)"
]
}
],
"prompt_number": 20
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"len(b) # elementos en la primera dimensi\u00f3n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 21,
"text": [
"2"
]
}
],
"prompt_number": 21
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"c = np.array([[[1], [2]], [[3], [4]]])"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 22
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"c"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 23,
"text": [
"array([[[1],\n",
" [2]],\n",
"\n",
" [[3],\n",
" [4]]])"
]
}
],
"prompt_number": 23
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"c.shape"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 24,
"text": [
"(2, 2, 1)"
]
}
],
"prompt_number": 24
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.2.3. Indexado."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = np.arange(10) # otra forma de generar un arreglo: a trav\u00e9s de funciones espec\u00edficas de numpy"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 25
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 26,
"text": [
"array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
]
}
],
"prompt_number": 26
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a[0], a[2], a[-1]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 27,
"text": [
"(0, 2, 9)"
]
}
],
"prompt_number": 27
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"mis_indices = [0, 2, -1] # puedo listar \u00edndices"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 28
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a[mis_indices] # y luego indexar por esa lista (\"fancy indexing\")"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 29,
"text": [
"array([0, 2, 9])"
]
}
],
"prompt_number": 29
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.2.4. Cortes."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 30,
"text": [
"array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
]
}
],
"prompt_number": 30
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a[2:9] # corta en intervalos"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 31,
"text": [
"array([2, 3, 4, 5, 6, 7, 8])"
]
}
],
"prompt_number": 31
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a[2:9:3] # puedo especificar cada cu\u00e1nto cortar"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 32,
"text": [
"array([2, 5, 8])"
]
}
],
"prompt_number": 32
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a[::2]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 33,
"text": [
"array([0, 2, 4, 6, 8])"
]
}
],
"prompt_number": 33
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a[3::2]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 34,
"text": [
"array([3, 5, 7, 9])"
]
}
],
"prompt_number": 34
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a[-2:]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 35,
"text": [
"array([8, 9])"
]
}
],
"prompt_number": 35
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Un esquema siempre ayuda..."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"![](\"https://raw.github.com/damianavila/Python-Cientifico-HCC/master/images/numpy_indexing.png\")
\n",
""
]
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.2.5. Copias y Vistas."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Si copiamos una lista en Python... si modificamos la copia, no se modifica la lista originalmente copiada:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%python \n",
"# python cell magic, lindo... no?\n",
"a = [1, 2, 3]\n",
"b = a[:]\n",
"print b\n",
"b[0] = 100\n",
"print b\n",
"print a"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"[1, 2, 3]\n",
"[100, 2, 3]\n",
"[1, 2, 3]\n"
]
}
],
"prompt_number": 36
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Si trabajamos con arreglos de NumPy, el comportamiento es diferente (cuando copiamos, en realidad, estamos haciendo una *vista* al objeto original, *apuntamos* al mismo objeto):"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = np.array([1, 2, 3])\n",
"b = a[:]\n",
"print b\n",
"b[0] = 100\n",
"print b\n",
"print a"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"[1 2 3]\n",
"[100 2 3]\n",
"[100 2 3]\n"
]
}
],
"prompt_number": 37
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\u00bfC\u00f3mo resolvemos esta discrepancia?"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = np.array([1, 2, 3])\n",
"b = a[:].copy() # fuerzo la copia\n",
"print b\n",
"b[0] = 100\n",
"print b\n",
"print a"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"[1 2 3]\n",
"[100 2 3]\n",
"[1 2 3]\n"
]
}
],
"prompt_number": 38
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.3. Operaciones num\u00e9ricas sobre arreglos."
]
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.3.1. Operaciones por elementos."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Escalares:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = np.array([1, 2, 3, 4])"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 39
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a + 1"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 40,
"text": [
"array([2, 3, 4, 5])"
]
}
],
"prompt_number": 40
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"2**a"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 41,
"text": [
"array([ 2, 4, 8, 16])"
]
}
],
"prompt_number": 41
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Aritm\u00e9ticas:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"b = np.ones(4) # otra funci\u00f3n generadora de arreglos\n",
"b = b + 1\n",
"b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 42,
"text": [
"array([ 2., 2., 2., 2.])"
]
}
],
"prompt_number": 42
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"b - a"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 43,
"text": [
"array([ 1., 0., -1., -2.])"
]
}
],
"prompt_number": 43
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a * b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 44,
"text": [
"array([ 2., 4., 6., 8.])"
]
}
],
"prompt_number": 44
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"c = np.ones((3, 3))\n",
"c"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 45,
"text": [
"array([[ 1., 1., 1.],\n",
" [ 1., 1., 1.],\n",
" [ 1., 1., 1.]])"
]
}
],
"prompt_number": 45
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"c * c # ojo! esto es una multiplicaci\u00f3n elemento por elemento."
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 46,
"text": [
"array([[ 1., 1., 1.],\n",
" [ 1., 1., 1.],\n",
" [ 1., 1., 1.]])"
]
}
],
"prompt_number": 46
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"c.dot(c) # multiplicaci\u00f3n matricial"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 47,
"text": [
"array([[ 3., 3., 3.],\n",
" [ 3., 3., 3.],\n",
" [ 3., 3., 3.]])"
]
}
],
"prompt_number": 47
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"L\u00f3gicas:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = np.array([1, 2, 3, 4])\n",
"b = np.array([4, 2, 2, 4])"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 48
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a == b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 49,
"text": [
"array([False, True, False, True], dtype=bool)"
]
}
],
"prompt_number": 49
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a > b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 50,
"text": [
"array([False, False, True, False], dtype=bool)"
]
}
],
"prompt_number": 50
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Otras operaciones l\u00f3gicas:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = np.array([1, 1, 0, 0], dtype=bool)\n",
"b = np.array([1, 0, 1, 0], dtype=bool)"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 51
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a | b # or, np.logical_or"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 52,
"text": [
"array([ True, True, True, False], dtype=bool)"
]
}
],
"prompt_number": 52
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a & b # and, np.logical_and"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 53,
"text": [
"array([ True, False, False, False], dtype=bool)"
]
}
],
"prompt_number": 53
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a ^ b # xor, np.logical_xor"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 54,
"text": [
"array([False, True, True, False], dtype=bool)"
]
}
],
"prompt_number": 54
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"not_a = - a # not, np.logical_not\n",
"not_a"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 55,
"text": [
"array([False, False, True, True], dtype=bool)"
]
}
],
"prompt_number": 55
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.3.2. Reducciones b\u00e1sicas."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Calculando sumas:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = np.array([1, 2, 3, 4])"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 56
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x.sum() # np.sum(x) "
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 57,
"text": [
"10"
]
}
],
"prompt_number": 57
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"por filas y columnas:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = np.array([[1, 1], [2, 2]])"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 58
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x.sum(axis=0) # por columna"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 59,
"text": [
"array([3, 3])"
]
}
],
"prompt_number": 59
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[:,0].sum(), x[:,1].sum()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 60,
"text": [
"(3, 3)"
]
}
],
"prompt_number": 60
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x.sum(axis=1) # por filas"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 61,
"text": [
"array([2, 4])"
]
}
],
"prompt_number": 61
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[0,:].sum(), x[1,:].sum()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 62,
"text": [
"(2, 4)"
]
}
],
"prompt_number": 62
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Calculando estad\u00edsticos:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = np.array([1, 2, 3, 1])"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 63
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x.mean()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 64,
"text": [
"1.75"
]
}
],
"prompt_number": 64
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x.std()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 65,
"text": [
"0.82915619758884995"
]
}
],
"prompt_number": 65
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x.std(ddof=1) # con divisor n - 1"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 66,
"text": [
"0.9574271077563381"
]
}
],
"prompt_number": 66
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.median(x)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 67,
"text": [
"1.5"
]
}
],
"prompt_number": 67
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"y = np.array([[1, 2, 3], [5, 6, 1]])"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 68
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.median(y, axis=-1) # \u00faltimo eje: en este caso, filas"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 69,
"text": [
"array([ 2., 5.])"
]
}
],
"prompt_number": 69
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Encontrando extremos:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x.min()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 70,
"text": [
"1"
]
}
],
"prompt_number": 70
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.argmin(x) # \u00edndice del m\u00ednimo"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 71,
"text": [
"0"
]
}
],
"prompt_number": 71
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x.max()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 72,
"text": [
"3"
]
}
],
"prompt_number": 72
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.argmax(x) # \u00edndice del m\u00e1ximo"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 73,
"text": [
"2"
]
}
],
"prompt_number": 73
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"M\u00e1s operaciones l\u00f3gicas:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.all([True, True, False])"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 74,
"text": [
"False"
]
}
],
"prompt_number": 74
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.any([True, True, False])"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 75,
"text": [
"True"
]
}
],
"prompt_number": 75
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.3.3. Broadcasting."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En NumPy es posible hacer operaciones entre arreglos de diferente tama\u00f1o a trav\u00e9s del **`broadcasting`**.\n",
"\n",
"* NumPy transforma (*propaga*) los arreglos involucrados para que tengan el mismo tama\u00f1o y, por tanto, puedan someterse a las operaciones por elementos sin generar excepciones. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"![](\"https://raw.github.com/damianavila/Python-Cientifico-HCC/master/images/numpy_broadcasting.png\")
\n",
""
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = np.arange(0, 40, 10)\n",
"a.shape"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 76,
"text": [
"(4,)"
]
}
],
"prompt_number": 76
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = a[:, np.newaxis] # suma un nuevo eje (arreglo 2D)\n",
"a.shape\n",
"a"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 77,
"text": [
"array([[ 0],\n",
" [10],\n",
" [20],\n",
" [30]])"
]
}
],
"prompt_number": 77
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"b = np.array([0, 1, 2])\n",
"b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 78,
"text": [
"array([0, 1, 2])"
]
}
],
"prompt_number": 78
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a + b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 79,
"text": [
"array([[ 0, 1, 2],\n",
" [10, 11, 12],\n",
" [20, 21, 22],\n",
" [30, 31, 32]])"
]
}
],
"prompt_number": 79
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.3.4. \u00c1lgebra lineal b\u00e1sica."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Multiplicai\u00f3n de matrices:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = np.triu(np.ones((3, 3)), 1) # see help(np.triu)\n",
"a"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 80,
"text": [
"array([[ 0., 1., 1.],\n",
" [ 0., 0., 1.],\n",
" [ 0., 0., 0.]])"
]
}
],
"prompt_number": 80
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"b = np.diag([1, 2, 3])\n",
"b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 81,
"text": [
"array([[1, 0, 0],\n",
" [0, 2, 0],\n",
" [0, 0, 3]])"
]
}
],
"prompt_number": 81
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a.dot(b)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 82,
"text": [
"array([[ 0., 2., 3.],\n",
" [ 0., 0., 3.],\n",
" [ 0., 0., 0.]])"
]
}
],
"prompt_number": 82
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Trasposici\u00f3n:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a.T"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 83,
"text": [
"array([[ 0., 0., 0.],\n",
" [ 1., 0., 0.],\n",
" [ 1., 1., 0.]])"
]
}
],
"prompt_number": 83
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Inversi\u00f3n y resoluci\u00f3n de equaciones lineales:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"A = a + b\n",
"A"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 84,
"text": [
"array([[ 1., 1., 1.],\n",
" [ 0., 2., 1.],\n",
" [ 0., 0., 3.]])"
]
}
],
"prompt_number": 84
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"B = np.linalg.inv(A)\n",
"B"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 85,
"text": [
"array([[ 1. , -0.5 , -0.16666667],\n",
" [ 0. , 0.5 , -0.16666667],\n",
" [ 0. , 0. , 0.33333333]])"
]
}
],
"prompt_number": 85
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"B.dot(A)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 86,
"text": [
"array([[ 1., 0., 0.],\n",
" [ 0., 1., 0.],\n",
" [ 0., 0., 1.]])"
]
}
],
"prompt_number": 86
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = np.linalg.solve(A, [1, 2, 3])\n",
"x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 87,
"text": [
"array([-0.5, 0.5, 1. ])"
]
}
],
"prompt_number": 87
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"A.dot(x)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 88,
"text": [
"array([ 1., 2., 3.])"
]
}
],
"prompt_number": 88
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"C\u00e1lculo de autovalores:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.linalg.eigvals(A)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 89,
"text": [
"array([ 1., 2., 3.])"
]
}
],
"prompt_number": 89
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.4. Manipulaci\u00f3n de arreglos. "
]
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.4.1. Manipulaci\u00f3n de la forma de los arreglos."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\"Aplanado\":"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = np.array([[1, 2, 3], [4, 5, 6]])"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 90
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a.ravel()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 91,
"text": [
"array([1, 2, 3, 4, 5, 6])"
]
}
],
"prompt_number": 91
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a.T"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 92,
"text": [
"array([[1, 4],\n",
" [2, 5],\n",
" [3, 6]])"
]
}
],
"prompt_number": 92
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a.T.ravel()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 93,
"text": [
"array([1, 4, 2, 5, 3, 6])"
]
}
],
"prompt_number": 93
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Cambio de forma:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a.shape"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 94,
"text": [
"(2, 3)"
]
}
],
"prompt_number": 94
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"b = a.ravel()\n",
"b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 95,
"text": [
"array([1, 2, 3, 4, 5, 6])"
]
}
],
"prompt_number": 95
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"b.reshape((2,3))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 96,
"text": [
"array([[1, 2, 3],\n",
" [4, 5, 6]])"
]
}
],
"prompt_number": 96
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = np.arange(36)"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 97
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"b = a.reshape((6,6))\n",
"b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 98,
"text": [
"array([[ 0, 1, 2, 3, 4, 5],\n",
" [ 6, 7, 8, 9, 10, 11],\n",
" [12, 13, 14, 15, 16, 17],\n",
" [18, 19, 20, 21, 22, 23],\n",
" [24, 25, 26, 27, 28, 29],\n",
" [30, 31, 32, 33, 34, 35]])"
]
}
],
"prompt_number": 98
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"b = a.reshape((6, -1)) # -1: comod\u00edn, se infiere\n",
"b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 99,
"text": [
"array([[ 0, 1, 2, 3, 4, 5],\n",
" [ 6, 7, 8, 9, 10, 11],\n",
" [12, 13, 14, 15, 16, 17],\n",
" [18, 19, 20, 21, 22, 23],\n",
" [24, 25, 26, 27, 28, 29],\n",
" [30, 31, 32, 33, 34, 35]])"
]
}
],
"prompt_number": 99
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Cambio de tama\u00f1o:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = np.arange(4)\n",
"a.resize((8,))\n",
"a"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 100,
"text": [
"array([0, 1, 2, 3, 0, 0, 0, 0])"
]
}
],
"prompt_number": 100
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Agregado de nuevas dimensiones:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"vector = np.array([1,2,3])\n",
"vector"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 101,
"text": [
"array([1, 2, 3])"
]
}
],
"prompt_number": 101
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.shape(vector)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 102,
"text": [
"(3,)"
]
}
],
"prompt_number": 102
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"matrix_col = vector[:, np.newaxis] # lo convierto en matrix 3 x 1\n",
"matrix_col"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 103,
"text": [
"array([[1],\n",
" [2],\n",
" [3]])"
]
}
],
"prompt_number": 103
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.shape(matrix_col)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 104,
"text": [
"(3, 1)"
]
}
],
"prompt_number": 104
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"matrix_ver = vector[np.newaxis, :] # lo convierto en matrix 1 x 3\n",
"matrix_ver"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 105,
"text": [
"array([[1, 2, 3]])"
]
}
],
"prompt_number": 105
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.shape(matrix_ver)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 106,
"text": [
"(1, 3)"
]
}
],
"prompt_number": 106
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Repeticiones:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = np.array([[1, 2], [3, 4]])\n",
"a"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 107,
"text": [
"array([[1, 2],\n",
" [3, 4]])"
]
}
],
"prompt_number": 107
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.repeat(a, 3)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 108,
"text": [
"array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])"
]
}
],
"prompt_number": 108
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.tile(a, 3)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 109,
"text": [
"array([[1, 2, 1, 2, 1, 2],\n",
" [3, 4, 3, 4, 3, 4]])"
]
}
],
"prompt_number": 109
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Concatenaci\u00f3n:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"b = np.array([[5, 6]])"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 110
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.concatenate((a, b), axis=0)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 111,
"text": [
"array([[1, 2],\n",
" [3, 4],\n",
" [5, 6]])"
]
}
],
"prompt_number": 111
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.concatenate((a, b.T), axis=1)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 112,
"text": [
"array([[1, 2, 5],\n",
" [3, 4, 6]])"
]
}
],
"prompt_number": 112
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.vstack((a,b))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 113,
"text": [
"array([[1, 2],\n",
" [3, 4],\n",
" [5, 6]])"
]
}
],
"prompt_number": 113
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.hstack((a,b.T))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 114,
"text": [
"array([[1, 2, 5],\n",
" [3, 4, 6]])"
]
}
],
"prompt_number": 114
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.4.2. Funciones para tomar datos de los arreglos."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = np.array([1,0,1,0,0], dtype=bool)\n",
"b = np.where(a) # where\n",
"b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 115,
"text": [
"(array([0, 2]),)"
]
}
],
"prompt_number": 115
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
"a"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 116,
"text": [
"array([[1, 2, 3],\n",
" [4, 5, 6],\n",
" [7, 8, 9]])"
]
}
],
"prompt_number": 116
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.diag(a) # diag"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 117,
"text": [
"array([1, 5, 9])"
]
}
],
"prompt_number": 117
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = np.arange(10,16)\n",
"a"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 118,
"text": [
"array([10, 11, 12, 13, 14, 15])"
]
}
],
"prompt_number": 118
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"indices = [1, 3, 5]"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 119
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.take(a, indices)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 120,
"text": [
"array([11, 13, 15])"
]
}
],
"prompt_number": 120
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"which = [0, 0, 1, 0]\n",
"choices = [[-2, -3, -4, -5], [5, 6, 7, 8]]\n",
"np.choose(which, choices)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 121,
"text": [
"array([-2, -3, 7, -5])"
]
}
],
"prompt_number": 121
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.4.3. Funciones generadoras de arreglos."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = np.arange(0, 10, 1) # argumentos: inicio, fin, paso\n",
"x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 122,
"text": [
"array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
]
}
],
"prompt_number": 122
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.linspace(0, 10, 25) # incio, fin, n\u00b0 puntos intermedios"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 123,
"text": [
"array([ 0. , 0.41666667, 0.83333333, 1.25 ,\n",
" 1.66666667, 2.08333333, 2.5 , 2.91666667,\n",
" 3.33333333, 3.75 , 4.16666667, 4.58333333,\n",
" 5. , 5.41666667, 5.83333333, 6.25 ,\n",
" 6.66666667, 7.08333333, 7.5 , 7.91666667,\n",
" 8.33333333, 8.75 , 9.16666667, 9.58333333, 10. ])"
]
}
],
"prompt_number": 123
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.logspace(0, 10, 10, base=np.e)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 124,
"text": [
"array([ 1.00000000e+00, 3.03773178e+00, 9.22781435e+00,\n",
" 2.80316249e+01, 8.51525577e+01, 2.58670631e+02,\n",
" 7.85771994e+02, 2.38696456e+03, 7.25095809e+03,\n",
" 2.20264658e+04])"
]
}
],
"prompt_number": 124
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x, y = np.mgrid[0:5, 0:5] # similar al meshgrid de MATLAB"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 125
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 126,
"text": [
"array([[0, 0, 0, 0, 0],\n",
" [1, 1, 1, 1, 1],\n",
" [2, 2, 2, 2, 2],\n",
" [3, 3, 3, 3, 3],\n",
" [4, 4, 4, 4, 4]])"
]
}
],
"prompt_number": 126
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"y"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 127,
"text": [
"array([[0, 1, 2, 3, 4],\n",
" [0, 1, 2, 3, 4],\n",
" [0, 1, 2, 3, 4],\n",
" [0, 1, 2, 3, 4],\n",
" [0, 1, 2, 3, 4]])"
]
}
],
"prompt_number": 127
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.random.rand(5, 5) # n\u00fameros aleatorios uniformes [0,1]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 128,
"text": [
"array([[ 0.71993812, 0.05176951, 0.37876399, 0.71104661, 0.09103074],\n",
" [ 0.66332802, 0.56448753, 0.6795584 , 0.19281203, 0.62263155],\n",
" [ 0.96436095, 0.06478416, 0.05179043, 0.391897 , 0.96105272],\n",
" [ 0.05728427, 0.55147176, 0.3245483 , 0.25468026, 0.66221203],\n",
" [ 0.55938751, 0.5883277 , 0.9253775 , 0.27429514, 0.3440919 ]])"
]
}
],
"prompt_number": 128
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.random.randn(5,5) # n\u00fameros aleatorios normalmente distribuidos"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 129,
"text": [
"array([[-0.65733 , -0.39731405, 1.7341414 , 0.3567832 , 1.69461793],\n",
" [ 1.54425562, -1.82893025, -0.15648911, 0.66672057, 0.66853341],\n",
" [ 0.83117805, 1.17071038, -0.81596502, 0.5750493 , -0.63990098],\n",
" [-0.56259403, 0.45052975, -0.43402709, -0.40855709, -0.70216341],\n",
" [-0.58823829, -1.05708393, 1.21155867, 0.84643448, 2.0027709 ]])"
]
}
],
"prompt_number": 129
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.diag([1,2,3]) # matrix diagonal"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 130,
"text": [
"array([[1, 0, 0],\n",
" [0, 2, 0],\n",
" [0, 0, 3]])"
]
}
],
"prompt_number": 130
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.diag([1,2,3], k=1) # desplazamiento sobre la diagonal"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 131,
"text": [
"array([[0, 1, 0, 0],\n",
" [0, 0, 2, 0],\n",
" [0, 0, 0, 3],\n",
" [0, 0, 0, 0]])"
]
}
],
"prompt_number": 131
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.zeros((3,3))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 132,
"text": [
"array([[ 0., 0., 0.],\n",
" [ 0., 0., 0.],\n",
" [ 0., 0., 0.]])"
]
}
],
"prompt_number": 132
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.ones((3,3))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 133,
"text": [
"array([[ 1., 1., 1.],\n",
" [ 1., 1., 1.],\n",
" [ 1., 1., 1.]])"
]
}
],
"prompt_number": 133
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"3.4.4. Entrada/Salida"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Podemos leer archivos csv:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!head stockholm_td_adj.dat"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"1800 1 1 -6.1 -6.1 -6.1 1\r\n",
"1800 1 2 -15.4 -15.4 -15.4 1\r\n",
"1800 1 3 -15.0 -15.0 -15.0 1\r\n",
"1800 1 4 -19.3 -19.3 -19.3 1\r\n",
"1800 1 5 -16.8 -16.8 -16.8 1\r\n",
"1800 1 6 -11.4 -11.4 -11.4 1\r\n",
"1800 1 7 -7.6 -7.6 -7.6 1\r\n",
"1800 1 8 -7.1 -7.1 -7.1 1\r\n",
"1800 1 9 -10.1 -10.1 -10.1 1\r\n",
"1800 1 10 -9.5 -9.5 -9.5 1\r\n"
]
}
],
"prompt_number": 134
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"data = np.genfromtxt('stockholm_td_adj.dat')\n",
"data.shape"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 135,
"text": [
"(77431, 7)"
]
}
],
"prompt_number": 135
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"data"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 136,
"text": [
"array([[ 1.80000000e+03, 1.00000000e+00, 1.00000000e+00, ...,\n",
" -6.10000000e+00, -6.10000000e+00, 1.00000000e+00],\n",
" [ 1.80000000e+03, 1.00000000e+00, 2.00000000e+00, ...,\n",
" -1.54000000e+01, -1.54000000e+01, 1.00000000e+00],\n",
" [ 1.80000000e+03, 1.00000000e+00, 3.00000000e+00, ...,\n",
" -1.50000000e+01, -1.50000000e+01, 1.00000000e+00],\n",
" ..., \n",
" [ 2.01100000e+03, 1.20000000e+01, 2.90000000e+01, ...,\n",
" 4.20000000e+00, 4.20000000e+00, 1.00000000e+00],\n",
" [ 2.01100000e+03, 1.20000000e+01, 3.00000000e+01, ...,\n",
" -1.00000000e-01, -1.00000000e-01, 1.00000000e+00],\n",
" [ 2.01100000e+03, 1.20000000e+01, 3.10000000e+01, ...,\n",
" -3.30000000e+00, -3.30000000e+00, 1.00000000e+00]])"
]
}
],
"prompt_number": 136
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"pero tambi\u00e9n podemos escribirlos:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"M = np.random.rand(3,3)\n",
"M"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 137,
"text": [
"array([[ 0.12192489, 0.5600679 , 0.98467243],\n",
" [ 0.91231303, 0.75122357, 0.54310547],\n",
" [ 0.18771526, 0.33981397, 0.48772906]])"
]
}
],
"prompt_number": 137
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.savetxt(\"random-matrix.csv\", M)"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 138
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!cat random-matrix.csv"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"1.219248903542134999e-01 5.600678957725345741e-01 9.846724267415249976e-01\r\n",
"9.123130259426238675e-01 7.512235706886890574e-01 5.431054672782125170e-01\r\n",
"1.877152580076981714e-01 3.398139715902742664e-01 4.877290607674301670e-01\r\n"
]
}
],
"prompt_number": 139
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.savetxt(\"random-matrix.csv\", M, fmt='%.5f') # fmt especifica el formato a escribir"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 140
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!cat random-matrix.csv"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"0.12192 0.56007 0.98467\r\n",
"0.91231 0.75122 0.54311\r\n",
"0.18772 0.33981 0.48773\r\n"
]
}
],
"prompt_number": 141
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.save(\"random-matrix.npy\", M)\n",
"!file random-matrix.npy"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"random-matrix.npy: data\r\n"
]
}
],
"prompt_number": 142
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"np.load(\"random-matrix.npy\")"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 143,
"text": [
"array([[ 0.12192489, 0.5600679 , 0.98467243],\n",
" [ 0.91231303, 0.75122357, 0.54310547],\n",
" [ 0.18771526, 0.33981397, 0.48772906]])"
]
}
],
"prompt_number": 143
}
],
"metadata": {}
}
]
}