Content for Decem's Python course.
1{
2 "cells": [
3 {
4 "cell_type": "markdown",
5 "metadata": {
6 "slideshow": {
7 "slide_type": "slide"
8 }
9 },
10 "source": [
11 "## 10. Librería Numpy"
12 ]
13 },
14 {
15 "cell_type": "markdown",
16 "metadata": {
17 "slideshow": {
18 "slide_type": "slide"
19 }
20 },
21 "source": [
22 "**NumPy** es la librería fundamental para la computación científica usando Python. Contiene entre otras cosas:\n",
23 "\n",
24 "- Un objeto que permite representar matrices n-dimensionales.\n",
25 "- Funciones para paralelizar el cálculo matricial.\n",
26 "- Herramientas para la integración con C/C++ y Fortran.\n",
27 "- Soporte para álgebra lineal, transoformaciones de Fourier y números aleatorios."
28 ]
29 },
30 {
31 "cell_type": "markdown",
32 "metadata": {
33 "slideshow": {
34 "slide_type": "slide"
35 }
36 },
37 "source": [
38 "Se puede instalar en nuestro entorno virtual con el siguiente comando:\n",
39 "\n",
40 "```\n",
41 "pipenv install numpy\n",
42 "```"
43 ]
44 },
45 {
46 "cell_type": "code",
47 "execution_count": 1,
48 "metadata": {
49 "slideshow": {
50 "slide_type": "fragment"
51 }
52 },
53 "outputs": [],
54 "source": [
55 "import numpy as np"
56 ]
57 },
58 {
59 "cell_type": "markdown",
60 "metadata": {
61 "slideshow": {
62 "slide_type": "fragment"
63 }
64 },
65 "source": [
66 "Se utiliza el alias `np` como estándar de facto par el uso de **NumPy**."
67 ]
68 },
69 {
70 "cell_type": "markdown",
71 "metadata": {
72 "slideshow": {
73 "slide_type": "slide"
74 }
75 },
76 "source": [
77 "### El objeto `ndarray`\n",
78 "\n",
79 "El objeto principal de NumPy es una matriz multidimensional homogénea. Es una tabla de elementos (normalmente números), todos del mismo tipo, indexado por una tupla de enteros positivos.\n",
80 "\n",
81 "En NumPy se las dimensiones se llaman `axis`.\n",
82 "\n"
83 ]
84 },
85 {
86 "cell_type": "markdown",
87 "metadata": {
88 "slideshow": {
89 "slide_type": "slide"
90 }
91 },
92 "source": [
93 ""
94 ]
95 },
96 {
97 "cell_type": "markdown",
98 "metadata": {
99 "slideshow": {
100 "slide_type": "slide"
101 }
102 },
103 "source": [
104 "Por ejemplo, las coordenadas de un punto en un espacio tridimensional `[1, 2, 1]` tienen un `axis`. Este tiene tres elementos en él, por lo que decimos que tiene una longitud de `3`. \n",
105 "\n",
106 "En el ejemplo siguiente, la matriz tiene dos dimensiones, el primero tiene una longitud de 2 y el segundo de 3:\n",
107 "\n",
108 "```\n",
109 "[[ 1., 0.]\n",
110 " [ 0., 1., 2.]]\n",
111 "```\n"
112 ]
113 },
114 {
115 "cell_type": "code",
116 "execution_count": 9,
117 "metadata": {
118 "slideshow": {
119 "slide_type": "slide"
120 }
121 },
122 "outputs": [
123 {
124 "name": "stdout",
125 "output_type": "stream",
126 "text": [
127 "[[1. 2.]\n",
128 " [3. 4.]]\n",
129 "[[5. 6.]\n",
130 " [7. 8.]]\n"
131 ]
132 }
133 ],
134 "source": [
135 "import numpy as np\n",
136 "\n",
137 "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
138 "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
139 "\n",
140 "print(x)\n",
141 "print(y)\n"
142 ]
143 },
144 {
145 "cell_type": "markdown",
146 "metadata": {
147 "slideshow": {
148 "slide_type": "slide"
149 }
150 },
151 "source": [
152 "La clase de NumPy que representa la matriz se llama `ndarray`. También tiene el alias `array`.\n",
153 "\n",
154 "Los atributos más importantes de esta clase son:"
155 ]
156 },
157 {
158 "cell_type": "markdown",
159 "metadata": {
160 "slideshow": {
161 "slide_type": "subslide"
162 }
163 },
164 "source": [
165 "`ndarray.ndim`\n",
166 "\n",
167 "El número de `axex`(dimensiones) de la matriz.\n",
168 "\n",
169 "`ndarray.shape`\n",
170 "\n",
171 "Las dimensiones de la matriz. Es una tupla de enteros, indicando el tamaño de cada dimensión.\n",
172 "\n",
173 "`ndarray.size`\n",
174 "\n",
175 "El número total de elementos de la matriz.\n",
176 "\n",
177 "`ndarray.dtype`\n",
178 "\n",
179 "Un objeto que describe el tipo de elemenos de la matriz. Se pueden crear matrices con los tipos estándares de Python, pero NumPy también aporta tipos propios, como por ejemplo `numpy.int32`, `numpy.int16`, y `numpy.float64`.\n",
180 "\n",
181 "`ndarray.itemsize`\n",
182 "\n",
183 "El tamaño en bytes de cada elemento de la matriz.\n",
184 "\n",
185 "`ndarray.data`\n",
186 "\n",
187 "El buffer que contiene los elementos de la matriz."
188 ]
189 },
190 {
191 "cell_type": "code",
192 "execution_count": null,
193 "metadata": {
194 "slideshow": {
195 "slide_type": "slide"
196 }
197 },
198 "outputs": [],
199 "source": [
200 "a = np.arange(15).reshape(3, 5)\n",
201 "a"
202 ]
203 },
204 {
205 "cell_type": "code",
206 "execution_count": null,
207 "metadata": {
208 "slideshow": {
209 "slide_type": "fragment"
210 }
211 },
212 "outputs": [],
213 "source": [
214 "a.shape"
215 ]
216 },
217 {
218 "cell_type": "code",
219 "execution_count": null,
220 "metadata": {
221 "slideshow": {
222 "slide_type": "slide"
223 }
224 },
225 "outputs": [],
226 "source": [
227 "a.ndim"
228 ]
229 },
230 {
231 "cell_type": "code",
232 "execution_count": null,
233 "metadata": {
234 "slideshow": {
235 "slide_type": "fragment"
236 }
237 },
238 "outputs": [],
239 "source": [
240 "a.dtype.name"
241 ]
242 },
243 {
244 "cell_type": "code",
245 "execution_count": null,
246 "metadata": {
247 "slideshow": {
248 "slide_type": "slide"
249 }
250 },
251 "outputs": [],
252 "source": [
253 "a.itemsize"
254 ]
255 },
256 {
257 "cell_type": "code",
258 "execution_count": null,
259 "metadata": {
260 "slideshow": {
261 "slide_type": "fragment"
262 }
263 },
264 "outputs": [],
265 "source": [
266 "a.size"
267 ]
268 },
269 {
270 "cell_type": "code",
271 "execution_count": null,
272 "metadata": {
273 "slideshow": {
274 "slide_type": "slide"
275 }
276 },
277 "outputs": [],
278 "source": [
279 "b = np.array([6, 7, 8])\n",
280 "print(type(a))\n",
281 "print(type(b))"
282 ]
283 },
284 {
285 "cell_type": "markdown",
286 "metadata": {
287 "slideshow": {
288 "slide_type": "slide"
289 }
290 },
291 "source": [
292 "### Creación de `arrays`\n",
293 "\n",
294 "Hay diferentes formas de crear un `array`:\n",
295 "\n",
296 "- Usando una tupla o lista de Python\n",
297 "- Usando funciones de inicialización de NumPy"
298 ]
299 },
300 {
301 "cell_type": "code",
302 "execution_count": 2,
303 "metadata": {
304 "slideshow": {
305 "slide_type": "slide"
306 }
307 },
308 "outputs": [
309 {
310 "name": "stdout",
311 "output_type": "stream",
312 "text": [
313 "[2 3 4]\n",
314 "[[1.5 2. 3. ]\n",
315 " [4. 5. 6. ]]\n",
316 "[[1.+0.j 2.+0.j]\n",
317 " [3.+0.j 4.+0.j]]\n"
318 ]
319 }
320 ],
321 "source": [
322 "a = np.array([2,3,4])\n",
323 "print(a)\n",
324 "\n",
325 "b = np.array([(1.5,2,3), (4,5,6)])\n",
326 "print(b)\n",
327 "\n",
328 "c = np.array( [ [1,2], [3,4] ], dtype=complex )\n",
329 "print(c)"
330 ]
331 },
332 {
333 "cell_type": "markdown",
334 "metadata": {
335 "slideshow": {
336 "slide_type": "slide"
337 }
338 },
339 "source": [
340 "Con la función `zeros` inicializamos el array con ceros."
341 ]
342 },
343 {
344 "cell_type": "code",
345 "execution_count": 3,
346 "metadata": {
347 "slideshow": {
348 "slide_type": "fragment"
349 }
350 },
351 "outputs": [
352 {
353 "data": {
354 "text/plain": [
355 "array([[0., 0., 0., 0.],\n",
356 " [0., 0., 0., 0.],\n",
357 " [0., 0., 0., 0.]])"
358 ]
359 },
360 "execution_count": 3,
361 "metadata": {},
362 "output_type": "execute_result"
363 }
364 ],
365 "source": [
366 "np.zeros( (3,4) )"
367 ]
368 },
369 {
370 "cell_type": "markdown",
371 "metadata": {
372 "slideshow": {
373 "slide_type": "slide"
374 }
375 },
376 "source": [
377 "Con la función `ones` inicializamos el array con unos."
378 ]
379 },
380 {
381 "cell_type": "code",
382 "execution_count": 4,
383 "metadata": {
384 "slideshow": {
385 "slide_type": "fragment"
386 }
387 },
388 "outputs": [
389 {
390 "data": {
391 "text/plain": [
392 "array([[[1, 1, 1, 1],\n",
393 " [1, 1, 1, 1],\n",
394 " [1, 1, 1, 1]],\n",
395 "\n",
396 " [[1, 1, 1, 1],\n",
397 " [1, 1, 1, 1],\n",
398 " [1, 1, 1, 1]]], dtype=int16)"
399 ]
400 },
401 "execution_count": 4,
402 "metadata": {},
403 "output_type": "execute_result"
404 }
405 ],
406 "source": [
407 "np.ones( (2,3,4), dtype=np.int16 ) "
408 ]
409 },
410 {
411 "cell_type": "markdown",
412 "metadata": {
413 "slideshow": {
414 "slide_type": "slide"
415 }
416 },
417 "source": [
418 "Con la función `empty` inicializamos el array con valores aleatorios que dependen del estado de la memoria."
419 ]
420 },
421 {
422 "cell_type": "code",
423 "execution_count": 6,
424 "metadata": {
425 "slideshow": {
426 "slide_type": "fragment"
427 }
428 },
429 "outputs": [
430 {
431 "data": {
432 "text/plain": [
433 "array([[1.5, 2. , 3. ],\n",
434 " [4. , 5. , 6. ]])"
435 ]
436 },
437 "execution_count": 6,
438 "metadata": {},
439 "output_type": "execute_result"
440 }
441 ],
442 "source": [
443 "np.empty( (2,3) )"
444 ]
445 },
446 {
447 "cell_type": "markdown",
448 "metadata": {
449 "slideshow": {
450 "slide_type": "slide"
451 }
452 },
453 "source": [
454 "Para cerar secuencias de números, NumPy proporciona una función análoga a `range` llamada `arange` que genera un `array` en vez de una lista"
455 ]
456 },
457 {
458 "cell_type": "code",
459 "execution_count": 7,
460 "metadata": {
461 "slideshow": {
462 "slide_type": "fragment"
463 }
464 },
465 "outputs": [
466 {
467 "data": {
468 "text/plain": [
469 "array([10, 15, 20, 25])"
470 ]
471 },
472 "execution_count": 7,
473 "metadata": {},
474 "output_type": "execute_result"
475 }
476 ],
477 "source": [
478 "np.arange( 10, 30, 5 )"
479 ]
480 },
481 {
482 "cell_type": "markdown",
483 "metadata": {
484 "slideshow": {
485 "slide_type": "slide"
486 }
487 },
488 "source": [
489 "### Operaciones con `arrays`\n",
490 "\n",
491 "`numpy` implementa operaciones básicas con los objetos `array` calculadas elemento a elemento."
492 ]
493 },
494 {
495 "cell_type": "markdown",
496 "metadata": {
497 "slideshow": {
498 "slide_type": "slide"
499 }
500 },
501 "source": [
502 "#### Suma "
503 ]
504 },
505 {
506 "cell_type": "code",
507 "execution_count": 11,
508 "metadata": {
509 "slideshow": {
510 "slide_type": "fragment"
511 }
512 },
513 "outputs": [
514 {
515 "name": "stdout",
516 "output_type": "stream",
517 "text": [
518 "[[ 6. 8.]\n",
519 " [10. 12.]]\n",
520 "[[ 6. 8.]\n",
521 " [10. 12.]]\n"
522 ]
523 }
524 ],
525 "source": [
526 "print(x + y)\n",
527 "print(np.add(x, y))\n"
528 ]
529 },
530 {
531 "cell_type": "markdown",
532 "metadata": {
533 "slideshow": {
534 "slide_type": "slide"
535 }
536 },
537 "source": [
538 "#### Resta"
539 ]
540 },
541 {
542 "cell_type": "code",
543 "execution_count": 12,
544 "metadata": {
545 "slideshow": {
546 "slide_type": "fragment"
547 }
548 },
549 "outputs": [
550 {
551 "name": "stdout",
552 "output_type": "stream",
553 "text": [
554 "[[-4. -4.]\n",
555 " [-4. -4.]]\n",
556 "[[-4. -4.]\n",
557 " [-4. -4.]]\n"
558 ]
559 }
560 ],
561 "source": [
562 "print(x - y)\n",
563 "print(np.subtract(x, y))"
564 ]
565 },
566 {
567 "cell_type": "markdown",
568 "metadata": {
569 "slideshow": {
570 "slide_type": "slide"
571 }
572 },
573 "source": [
574 "#### Producto"
575 ]
576 },
577 {
578 "cell_type": "code",
579 "execution_count": 13,
580 "metadata": {
581 "slideshow": {
582 "slide_type": "fragment"
583 }
584 },
585 "outputs": [
586 {
587 "name": "stdout",
588 "output_type": "stream",
589 "text": [
590 "[[ 5. 12.]\n",
591 " [21. 32.]]\n",
592 "[[ 5. 12.]\n",
593 " [21. 32.]]\n"
594 ]
595 }
596 ],
597 "source": [
598 "print(x * y)\n",
599 "print(np.multiply(x, y))"
600 ]
601 },
602 {
603 "cell_type": "markdown",
604 "metadata": {
605 "slideshow": {
606 "slide_type": "slide"
607 }
608 },
609 "source": [
610 "#### División"
611 ]
612 },
613 {
614 "cell_type": "code",
615 "execution_count": 14,
616 "metadata": {
617 "slideshow": {
618 "slide_type": "fragment"
619 }
620 },
621 "outputs": [
622 {
623 "name": "stdout",
624 "output_type": "stream",
625 "text": [
626 "[[0.2 0.33333333]\n",
627 " [0.42857143 0.5 ]]\n",
628 "[[0.2 0.33333333]\n",
629 " [0.42857143 0.5 ]]\n"
630 ]
631 }
632 ],
633 "source": [
634 "print(x / y)\n",
635 "print(np.divide(x, y))"
636 ]
637 },
638 {
639 "cell_type": "markdown",
640 "metadata": {
641 "slideshow": {
642 "slide_type": "slide"
643 }
644 },
645 "source": [
646 "#### Raiz cuadrada"
647 ]
648 },
649 {
650 "cell_type": "code",
651 "execution_count": 15,
652 "metadata": {
653 "slideshow": {
654 "slide_type": "fragment"
655 }
656 },
657 "outputs": [
658 {
659 "name": "stdout",
660 "output_type": "stream",
661 "text": [
662 "[[1. 1.41421356]\n",
663 " [1.73205081 2. ]]\n"
664 ]
665 }
666 ],
667 "source": [
668 "print(np.sqrt(x))"
669 ]
670 },
671 {
672 "cell_type": "markdown",
673 "metadata": {
674 "slideshow": {
675 "slide_type": "slide"
676 }
677 },
678 "source": [
679 "### Operaciones matriciales\n",
680 "\n",
681 "A diferencia de otros entornos de cálculo númerico, con `numpy` el operador `*` realiza la multiplicación elemento a elemento, no la multiplicación matricial."
682 ]
683 },
684 {
685 "cell_type": "markdown",
686 "metadata": {
687 "slideshow": {
688 "slide_type": "fragment"
689 }
690 },
691 "source": [
692 "Para realizar la multiplicación matricial se utiliza la función `dot`."
693 ]
694 },
695 {
696 "cell_type": "code",
697 "execution_count": 16,
698 "metadata": {
699 "slideshow": {
700 "slide_type": "slide"
701 }
702 },
703 "outputs": [],
704 "source": [
705 "x = np.array([[1,2],[3,4]])\n",
706 "y = np.array([[5,6],[7,8]])\n",
707 "\n",
708 "v = np.array([9,10])\n",
709 "w = np.array([11, 12])"
710 ]
711 },
712 {
713 "cell_type": "code",
714 "execution_count": 17,
715 "metadata": {
716 "slideshow": {
717 "slide_type": "slide"
718 }
719 },
720 "outputs": [
721 {
722 "name": "stdout",
723 "output_type": "stream",
724 "text": [
725 "219\n",
726 "219\n"
727 ]
728 }
729 ],
730 "source": [
731 "# Producto de vectores\n",
732 "print(v.dot(w))\n",
733 "print(np.dot(v, w))"
734 ]
735 },
736 {
737 "cell_type": "code",
738 "execution_count": 18,
739 "metadata": {
740 "slideshow": {
741 "slide_type": "slide"
742 }
743 },
744 "outputs": [
745 {
746 "name": "stdout",
747 "output_type": "stream",
748 "text": [
749 "[29 67]\n",
750 "[29 67]\n"
751 ]
752 }
753 ],
754 "source": [
755 "# Producto de matriz y vector\n",
756 "print(x.dot(v))\n",
757 "print(np.dot(x, v))"
758 ]
759 },
760 {
761 "cell_type": "code",
762 "execution_count": 19,
763 "metadata": {
764 "slideshow": {
765 "slide_type": "slide"
766 }
767 },
768 "outputs": [
769 {
770 "name": "stdout",
771 "output_type": "stream",
772 "text": [
773 "[[19 22]\n",
774 " [43 50]]\n",
775 "[[19 22]\n",
776 " [43 50]]\n"
777 ]
778 }
779 ],
780 "source": [
781 "# Producto de matrices\n",
782 "print(x.dot(y))\n",
783 "print(np.dot(x, y))"
784 ]
785 },
786 {
787 "cell_type": "markdown",
788 "metadata": {
789 "slideshow": {
790 "slide_type": "slide"
791 }
792 },
793 "source": [
794 "Además de estas funciones, `numpy` proporciona otras que son de utilidad para operar con matrices, por ejemplo `sum`."
795 ]
796 },
797 {
798 "cell_type": "code",
799 "execution_count": 20,
800 "metadata": {
801 "slideshow": {
802 "slide_type": "fragment"
803 }
804 },
805 "outputs": [
806 {
807 "name": "stdout",
808 "output_type": "stream",
809 "text": [
810 "10\n",
811 "[4 6]\n",
812 "[3 7]\n"
813 ]
814 }
815 ],
816 "source": [
817 "x = np.array([[1,2],[3,4]])\n",
818 "\n",
819 "print(np.sum(x)) # Calcula la suma de todos los elementos\n",
820 "print(np.sum(x, axis=0)) # Calcula la suma para cada columna\n",
821 "print(np.sum(x, axis=1)) # Calcula la suma para cada fila"
822 ]
823 },
824 {
825 "cell_type": "markdown",
826 "metadata": {
827 "slideshow": {
828 "slide_type": "slide"
829 }
830 },
831 "source": [
832 "Otras funciones de utilidad son `min` y `max`, que pueden calcular el valor mínimo y máximo del array, o aplicar la operación por alguna de las dimensiones,"
833 ]
834 },
835 {
836 "cell_type": "code",
837 "execution_count": 21,
838 "metadata": {
839 "slideshow": {
840 "slide_type": "fragment"
841 }
842 },
843 "outputs": [
844 {
845 "name": "stdout",
846 "output_type": "stream",
847 "text": [
848 "0.04329492611551744\n",
849 "0.9711252229239533\n",
850 "[0.82846602 0.97112522]\n",
851 "[0.91695312 0.91763796 0.97112522]\n"
852 ]
853 }
854 ],
855 "source": [
856 "a = np.random.random((2,3))\n",
857 "print(a.min())\n",
858 "print(a.max())\n",
859 "print(a.max(axis=1))\n",
860 "print(a.max(axis=0))"
861 ]
862 },
863 {
864 "cell_type": "markdown",
865 "metadata": {
866 "slideshow": {
867 "slide_type": "slide"
868 }
869 },
870 "source": [
871 "Otra función interesante es `cumsum`, que calcula la suma acumulativa de los elementos del array, o por alguna de sus dimensiones."
872 ]
873 },
874 {
875 "cell_type": "code",
876 "execution_count": 22,
877 "metadata": {
878 "slideshow": {
879 "slide_type": "fragment"
880 }
881 },
882 "outputs": [
883 {
884 "data": {
885 "text/plain": [
886 "array([[ 0, 1, 2, 3],\n",
887 " [ 4, 5, 6, 7],\n",
888 " [ 8, 9, 10, 11]])"
889 ]
890 },
891 "execution_count": 22,
892 "metadata": {},
893 "output_type": "execute_result"
894 }
895 ],
896 "source": [
897 "a = np.arange(12).reshape(3,4)\n",
898 "a"
899 ]
900 },
901 {
902 "cell_type": "code",
903 "execution_count": 23,
904 "metadata": {
905 "slideshow": {
906 "slide_type": "slide"
907 }
908 },
909 "outputs": [
910 {
911 "data": {
912 "text/plain": [
913 "array([ 0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66])"
914 ]
915 },
916 "execution_count": 23,
917 "metadata": {},
918 "output_type": "execute_result"
919 }
920 ],
921 "source": [
922 "a.cumsum()"
923 ]
924 },
925 {
926 "cell_type": "code",
927 "execution_count": 25,
928 "metadata": {
929 "slideshow": {
930 "slide_type": "fragment"
931 }
932 },
933 "outputs": [
934 {
935 "data": {
936 "text/plain": [
937 "array([[ 0, 1, 2, 3],\n",
938 " [ 4, 6, 8, 10],\n",
939 " [12, 15, 18, 21]])"
940 ]
941 },
942 "execution_count": 25,
943 "metadata": {},
944 "output_type": "execute_result"
945 }
946 ],
947 "source": [
948 "a.cumsum(axis=0)"
949 ]
950 },
951 {
952 "cell_type": "markdown",
953 "metadata": {
954 "slideshow": {
955 "slide_type": "slide"
956 }
957 },
958 "source": [
959 "### Acceso a elementos, partición e iteración\n",
960 "\n",
961 "Los arrays de una dimensión pueden ser accedidos y particionados igual que otras secuencias de Python.\n"
962 ]
963 },
964 {
965 "cell_type": "code",
966 "execution_count": 32,
967 "metadata": {
968 "slideshow": {
969 "slide_type": "slide"
970 }
971 },
972 "outputs": [
973 {
974 "data": {
975 "text/plain": [
976 "array([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729])"
977 ]
978 },
979 "execution_count": 32,
980 "metadata": {},
981 "output_type": "execute_result"
982 }
983 ],
984 "source": [
985 "a = np.arange(10)**3\n",
986 "a"
987 ]
988 },
989 {
990 "cell_type": "code",
991 "execution_count": 27,
992 "metadata": {
993 "slideshow": {
994 "slide_type": "fragment"
995 }
996 },
997 "outputs": [
998 {
999 "data": {
1000 "text/plain": [
1001 "8"
1002 ]
1003 },
1004 "execution_count": 27,
1005 "metadata": {},
1006 "output_type": "execute_result"
1007 }
1008 ],
1009 "source": [
1010 "a[2]"
1011 ]
1012 },
1013 {
1014 "cell_type": "code",
1015 "execution_count": 28,
1016 "metadata": {
1017 "slideshow": {
1018 "slide_type": "fragment"
1019 }
1020 },
1021 "outputs": [
1022 {
1023 "data": {
1024 "text/plain": [
1025 "array([ 8, 27, 64])"
1026 ]
1027 },
1028 "execution_count": 28,
1029 "metadata": {},
1030 "output_type": "execute_result"
1031 }
1032 ],
1033 "source": [
1034 "a[2:5]"
1035 ]
1036 },
1037 {
1038 "cell_type": "code",
1039 "execution_count": 33,
1040 "metadata": {
1041 "slideshow": {
1042 "slide_type": "slide"
1043 }
1044 },
1045 "outputs": [
1046 {
1047 "data": {
1048 "text/plain": [
1049 "array([-1000, 1, -1000, 27, -1000, 125, 216, 343, 512,\n",
1050 " 729])"
1051 ]
1052 },
1053 "execution_count": 33,
1054 "metadata": {},
1055 "output_type": "execute_result"
1056 }
1057 ],
1058 "source": [
1059 "a[:6:2] = -1000\n",
1060 "a"
1061 ]
1062 },
1063 {
1064 "cell_type": "markdown",
1065 "metadata": {
1066 "slideshow": {
1067 "slide_type": "slide"
1068 }
1069 },
1070 "source": [
1071 " Los array que son multidimensionales tienen un índice por cada dimensión, y se accede a cada uno de ellos sepandando por `,` dentro del operador `[]`."
1072 ]
1073 },
1074 {
1075 "cell_type": "code",
1076 "execution_count": 34,
1077 "metadata": {
1078 "slideshow": {
1079 "slide_type": "slide"
1080 }
1081 },
1082 "outputs": [
1083 {
1084 "data": {
1085 "text/plain": [
1086 "array([[ 0, 1, 2, 3],\n",
1087 " [10, 11, 12, 13],\n",
1088 " [20, 21, 22, 23],\n",
1089 " [30, 31, 32, 33],\n",
1090 " [40, 41, 42, 43]])"
1091 ]
1092 },
1093 "execution_count": 34,
1094 "metadata": {},
1095 "output_type": "execute_result"
1096 }
1097 ],
1098 "source": [
1099 "b = np.fromfunction(lambda x, y: 10 * x + y, (5,4),dtype=int)\n",
1100 "b"
1101 ]
1102 },
1103 {
1104 "cell_type": "code",
1105 "execution_count": 35,
1106 "metadata": {
1107 "slideshow": {
1108 "slide_type": "fragment"
1109 }
1110 },
1111 "outputs": [
1112 {
1113 "data": {
1114 "text/plain": [
1115 "23"
1116 ]
1117 },
1118 "execution_count": 35,
1119 "metadata": {},
1120 "output_type": "execute_result"
1121 }
1122 ],
1123 "source": [
1124 " b[2,3]"
1125 ]
1126 },
1127 {
1128 "cell_type": "code",
1129 "execution_count": 37,
1130 "metadata": {
1131 "slideshow": {
1132 "slide_type": "slide"
1133 }
1134 },
1135 "outputs": [
1136 {
1137 "data": {
1138 "text/plain": [
1139 "array([11, 12, 13])"
1140 ]
1141 },
1142 "execution_count": 37,
1143 "metadata": {},
1144 "output_type": "execute_result"
1145 }
1146 ],
1147 "source": [
1148 "b[1, 1:4] "
1149 ]
1150 },
1151 {
1152 "cell_type": "code",
1153 "execution_count": 39,
1154 "metadata": {
1155 "slideshow": {
1156 "slide_type": "fragment"
1157 }
1158 },
1159 "outputs": [
1160 {
1161 "data": {
1162 "text/plain": [
1163 "array([ 1, 11, 21, 31, 41])"
1164 ]
1165 },
1166 "execution_count": 39,
1167 "metadata": {},
1168 "output_type": "execute_result"
1169 }
1170 ],
1171 "source": [
1172 "x = 1\n",
1173 "b[ : ,x]"
1174 ]
1175 },
1176 {
1177 "cell_type": "code",
1178 "execution_count": 40,
1179 "metadata": {
1180 "slideshow": {
1181 "slide_type": "fragment"
1182 }
1183 },
1184 "outputs": [
1185 {
1186 "data": {
1187 "text/plain": [
1188 "array([[10, 11, 12, 13],\n",
1189 " [20, 21, 22, 23]])"
1190 ]
1191 },
1192 "execution_count": 40,
1193 "metadata": {},
1194 "output_type": "execute_result"
1195 }
1196 ],
1197 "source": [
1198 "b[1:3, : ]"
1199 ]
1200 },
1201 {
1202 "cell_type": "markdown",
1203 "metadata": {
1204 "slideshow": {
1205 "slide_type": "slide"
1206 }
1207 },
1208 "source": [
1209 "La expresión `b[i]` se trata como si `i` estuviera seguida de tantos `:` como fueran necesarios para representar las dimensiones restantes.\n",
1210 "\n",
1211 "NumPy también permite usar `...` para representar este concepto.\n",
1212 "\n",
1213 "Por ejemplo, si `x` es un array de 5 dimensiones:\n",
1214 "\n",
1215 "- `x[1,2,...]` es equivalente a `x[1,2,:,:,:]`,\n",
1216 "- `x[...,3]` a `x[:,:,:,:,3]` y\n",
1217 "- `x[4,...,5,:]`a `x[4,:,:,5,:]`."
1218 ]
1219 },
1220 {
1221 "cell_type": "code",
1222 "execution_count": 45,
1223 "metadata": {
1224 "slideshow": {
1225 "slide_type": "slide"
1226 }
1227 },
1228 "outputs": [
1229 {
1230 "data": {
1231 "text/plain": [
1232 "array([[[12, 13],\n",
1233 " [14, 15],\n",
1234 " [16, 17]],\n",
1235 "\n",
1236 " [[18, 19],\n",
1237 " [20, 21],\n",
1238 " [22, 23]]])"
1239 ]
1240 },
1241 "execution_count": 45,
1242 "metadata": {},
1243 "output_type": "execute_result"
1244 }
1245 ],
1246 "source": [
1247 "c = np.arange(24).reshape(2,2,3,2)\n",
1248 "c[1,...]"
1249 ]
1250 },
1251 {
1252 "cell_type": "code",
1253 "execution_count": 47,
1254 "metadata": {
1255 "slideshow": {
1256 "slide_type": "fragment"
1257 }
1258 },
1259 "outputs": [
1260 {
1261 "data": {
1262 "text/plain": [
1263 "array([[[ 1, 3, 5],\n",
1264 " [ 7, 9, 11]],\n",
1265 "\n",
1266 " [[13, 15, 17],\n",
1267 " [19, 21, 23]]])"
1268 ]
1269 },
1270 "execution_count": 47,
1271 "metadata": {},
1272 "output_type": "execute_result"
1273 }
1274 ],
1275 "source": [
1276 " c[...,1]"
1277 ]
1278 },
1279 {
1280 "cell_type": "markdown",
1281 "metadata": {
1282 "slideshow": {
1283 "slide_type": "slide"
1284 }
1285 },
1286 "source": [
1287 "#### Iteraciones\n",
1288 "\n",
1289 "La iteración sobre arrays multidimensionales se realiza con respecto a la primera dimensión:"
1290 ]
1291 },
1292 {
1293 "cell_type": "code",
1294 "execution_count": 49,
1295 "metadata": {
1296 "slideshow": {
1297 "slide_type": "slide"
1298 }
1299 },
1300 "outputs": [
1301 {
1302 "name": "stdout",
1303 "output_type": "stream",
1304 "text": [
1305 "[0 1 2 3]\n",
1306 "[10 11 12 13]\n",
1307 "[20 21 22 23]\n",
1308 "[30 31 32 33]\n",
1309 "[40 41 42 43]\n"
1310 ]
1311 }
1312 ],
1313 "source": [
1314 "for row in b:\n",
1315 " print(row)"
1316 ]
1317 },
1318 {
1319 "cell_type": "markdown",
1320 "metadata": {
1321 "slideshow": {
1322 "slide_type": "slide"
1323 }
1324 },
1325 "source": [
1326 "Se puede realizar la operación elemento a elemento del array, usando `flat`, que devuelve un iterador sobre todos los elementos del array"
1327 ]
1328 },
1329 {
1330 "cell_type": "code",
1331 "execution_count": 50,
1332 "metadata": {
1333 "slideshow": {
1334 "slide_type": "fragment"
1335 }
1336 },
1337 "outputs": [
1338 {
1339 "name": "stdout",
1340 "output_type": "stream",
1341 "text": [
1342 "0\n",
1343 "1\n",
1344 "2\n",
1345 "3\n",
1346 "10\n",
1347 "11\n",
1348 "12\n",
1349 "13\n",
1350 "20\n",
1351 "21\n",
1352 "22\n",
1353 "23\n",
1354 "30\n",
1355 "31\n",
1356 "32\n",
1357 "33\n",
1358 "40\n",
1359 "41\n",
1360 "42\n",
1361 "43\n"
1362 ]
1363 }
1364 ],
1365 "source": [
1366 "for element in b.flat:\n",
1367 " print(element)"
1368 ]
1369 },
1370 {
1371 "cell_type": "markdown",
1372 "metadata": {
1373 "slideshow": {
1374 "slide_type": "slide"
1375 }
1376 },
1377 "source": [
1378 "### Broadcasting\n",
1379 "\n",
1380 "En `numpy` el **broadcasting** es una herramienta que permite a la librería trabajar con matrices de diferentes tamaños cuando se realizan operaciones aritméticas.\n",
1381 "\n",
1382 "Normalmente, hay una matriz pequeña y una más grande, y se usa la matriz pequeña varias veces para ralizar alguna operación con la más grande."
1383 ]
1384 },
1385 {
1386 "cell_type": "code",
1387 "execution_count": 51,
1388 "metadata": {
1389 "slideshow": {
1390 "slide_type": "slide"
1391 }
1392 },
1393 "outputs": [
1394 {
1395 "data": {
1396 "text/plain": [
1397 "array([2., 4., 6.])"
1398 ]
1399 },
1400 "execution_count": 51,
1401 "metadata": {},
1402 "output_type": "execute_result"
1403 }
1404 ],
1405 "source": [
1406 "a = np.array([1.0, 2.0, 3.0])\n",
1407 "b = np.array([2.0, 2.0, 2.0])\n",
1408 "a * b"
1409 ]
1410 },
1411 {
1412 "cell_type": "code",
1413 "execution_count": 52,
1414 "metadata": {
1415 "slideshow": {
1416 "slide_type": "slide"
1417 }
1418 },
1419 "outputs": [
1420 {
1421 "data": {
1422 "text/plain": [
1423 "array([2., 4., 6.])"
1424 ]
1425 },
1426 "execution_count": 52,
1427 "metadata": {},
1428 "output_type": "execute_result"
1429 }
1430 ],
1431 "source": [
1432 "a = np.array([1.0, 2.0, 3.0])\n",
1433 "b = 2.0\n",
1434 "a * b"
1435 ]
1436 },
1437 {
1438 "cell_type": "markdown",
1439 "metadata": {
1440 "slideshow": {
1441 "slide_type": "slide"
1442 }
1443 },
1444 "source": [
1445 "El código que usa el *broadcasting* es más eficiente porque mueve menos memoria durante la operación de multiplicación."
1446 ]
1447 },
1448 {
1449 "cell_type": "markdown",
1450 "metadata": {
1451 "slideshow": {
1452 "slide_type": "slide"
1453 }
1454 },
1455 "source": [
1456 "Cuando NumPy opera con dos arrays, compara sus `shapes` elemento a elemento, empezando *por la dimensión del final* hasta la primera. Dos dimensiones son compatibles cuando:\n",
1457 "\n",
1458 "- Son iguales, o\n",
1459 "- Una de ellas es 1"
1460 ]
1461 },
1462 {
1463 "cell_type": "markdown",
1464 "metadata": {
1465 "slideshow": {
1466 "slide_type": "fragment"
1467 }
1468 },
1469 "source": [
1470 "Cuando una de las dimensiones comparada es uno, se usa la otra. Es decir, la dimensión de valor 1 se copia para igualar a la otra.\n",
1471 "\n",
1472 "```\n",
1473 "A (4d array): 8 x 1 x 6 x 1\n",
1474 "B (3d array): 7 x 1 x 5\n",
1475 "Resultado (4d array): 8 x 7 x 6 x 5\n",
1476 "```"
1477 ]
1478 }
1479 ],
1480 "metadata": {
1481 "celltoolbar": "Slideshow",
1482 "kernelspec": {
1483 "display_name": "Python 3",
1484 "language": "python",
1485 "name": "python3"
1486 },
1487 "language_info": {
1488 "codemirror_mode": {
1489 "name": "ipython",
1490 "version": 3
1491 },
1492 "file_extension": ".py",
1493 "mimetype": "text/x-python",
1494 "name": "python",
1495 "nbconvert_exporter": "python",
1496 "pygments_lexer": "ipython3",
1497 "version": "3.7.1"
1498 }
1499 },
1500 "nbformat": 4,
1501 "nbformat_minor": 2
1502}