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 "## 4. Estructuras de datos básica (listas, tuplas, diccionarios y operaciones)"
12 ]
13 },
14 {
15 "cell_type": "markdown",
16 "metadata": {
17 "slideshow": {
18 "slide_type": "fragment"
19 }
20 },
21 "source": [
22 "Python incluye varios tipos de datos usados para agrupar valores."
23 ]
24 },
25 {
26 "cell_type": "markdown",
27 "metadata": {
28 "slideshow": {
29 "slide_type": "slide"
30 }
31 },
32 "source": [
33 "### Listas\n",
34 "\n",
35 "Una lista es una estructura de datos mutable compuesta por varios elementos que pueden ser de diferentes tipos. Se escribe con sus elementos separados por comas, y entre corchetes."
36 ]
37 },
38 {
39 "cell_type": "code",
40 "execution_count": null,
41 "metadata": {
42 "slideshow": {
43 "slide_type": "fragment"
44 }
45 },
46 "outputs": [],
47 "source": [
48 "squares = [1, 4, 9, 16, 25]\n",
49 "squares"
50 ]
51 },
52 {
53 "cell_type": "markdown",
54 "metadata": {
55 "slideshow": {
56 "slide_type": "slide"
57 }
58 },
59 "source": [
60 "También se puede declarar usando la palabra reservada `list`."
61 ]
62 },
63 {
64 "cell_type": "code",
65 "execution_count": null,
66 "metadata": {
67 "slideshow": {
68 "slide_type": "fragment"
69 }
70 },
71 "outputs": [],
72 "source": [
73 "squares = list(1)\n",
74 "squares"
75 ]
76 },
77 {
78 "cell_type": "markdown",
79 "metadata": {
80 "slideshow": {
81 "slide_type": "slide"
82 }
83 },
84 "source": [
85 "#### Operaciones sobre listas\n",
86 "\n",
87 "Un objeto de tipo lista soporta el acceso a cada uno de sus elementos mediante el operador `[]`, indicando la posición del elemento, teniendo en cuenta que empezamos en la posición 0. "
88 ]
89 },
90 {
91 "cell_type": "code",
92 "execution_count": null,
93 "metadata": {
94 "slideshow": {
95 "slide_type": "fragment"
96 }
97 },
98 "outputs": [],
99 "source": [
100 "squares = [1, 4, 9, 16, 25]\n",
101 "squares[0]"
102 ]
103 },
104 {
105 "cell_type": "markdown",
106 "metadata": {
107 "slideshow": {
108 "slide_type": "slide"
109 }
110 },
111 "source": [
112 "A su vez, el operador `[]` permite acceder a porciones de una lista usando el operador `:`, indicando a la izquierda la posición inicial y a la derecha la posición final. A su vez, también soporta el uso de índices negativos, para hacer referencia a las posiciones desde el final de la lista."
113 ]
114 },
115 {
116 "cell_type": "code",
117 "execution_count": null,
118 "metadata": {
119 "slideshow": {
120 "slide_type": "fragment"
121 }
122 },
123 "outputs": [],
124 "source": [
125 "print(squares[:1:-1]) # el primer elemento\n",
126 "print(squares[:-1]) # todos menos el último elemento\n",
127 "print(squares[1:-1]) # todos menos el primero y el último elemento"
128 ]
129 },
130 {
131 "cell_type": "markdown",
132 "metadata": {
133 "slideshow": {
134 "slide_type": "slide"
135 }
136 },
137 "source": [
138 "Podemos obtener el tamaño de una lista usando la función `len()`."
139 ]
140 },
141 {
142 "cell_type": "code",
143 "execution_count": null,
144 "metadata": {
145 "slideshow": {
146 "slide_type": "fragment"
147 }
148 },
149 "outputs": [],
150 "source": [
151 "len(squares)"
152 ]
153 },
154 {
155 "cell_type": "markdown",
156 "metadata": {
157 "slideshow": {
158 "slide_type": "slide"
159 }
160 },
161 "source": [
162 "Se puede comprobar si un elemento aparece en una lista usando el operador `in`."
163 ]
164 },
165 {
166 "cell_type": "code",
167 "execution_count": null,
168 "metadata": {
169 "slideshow": {
170 "slide_type": "fragment"
171 }
172 },
173 "outputs": [],
174 "source": [
175 "16 in squares"
176 ]
177 },
178 {
179 "cell_type": "markdown",
180 "metadata": {
181 "slideshow": {
182 "slide_type": "slide"
183 }
184 },
185 "source": [
186 "#### Métodos de listas"
187 ]
188 },
189 {
190 "cell_type": "markdown",
191 "metadata": {
192 "slideshow": {
193 "slide_type": "subslide"
194 }
195 },
196 "source": [
197 "`list.append(x)`\n",
198 "\n",
199 "Añade un elemento al final de la lista. Es equivalente a `a[len(a):] = [x]`.\n",
200 "\n",
201 "`list.extend(iterable)`\n",
202 "\n",
203 "Extiende la lista añadiendo todos los elementos del argumento. Es equivalente a `a[len(a):] = iterable`.\n",
204 "\n",
205 "`list.insert(i, x)`\n",
206 "\n",
207 "Inserta un elemento en la posición indicada. El primer argumento es el índice del elemento antes del cual se va a insertar, por lo tanto `a.insert(0, x)` inserta en principio de la lista, y `a.insert(len(a), x)` es equivalente a `a.append(x)`."
208 ]
209 },
210 {
211 "cell_type": "markdown",
212 "metadata": {
213 "slideshow": {
214 "slide_type": "subslide"
215 }
216 },
217 "source": [
218 "\n",
219 "`list.remove(x)`\n",
220 "\n",
221 "Elimina el primer elemento de lista cuyo valor sea `x`. Da un error si no existe el elemento.\n",
222 "\n",
223 "`list.pop([i])`\n",
224 "\n",
225 "Elimina el elemento en la posición dada y lo devuelve. Si no se especifica un índice, `a.pop()` elimina y devuelve el último elemento de la lista.\n",
226 "\n",
227 "`list.clear()`\n",
228 "\n",
229 "Elimina todos los elementos de la lista. Es equivalente a `del a[:]`."
230 ]
231 },
232 {
233 "cell_type": "markdown",
234 "metadata": {
235 "slideshow": {
236 "slide_type": "subslide"
237 }
238 },
239 "source": [
240 "`list.index(x[, start[, end]])`\n",
241 "\n",
242 "\n",
243 "Devuelve el índice en la lista del primer elemento cuyo valor es `x`. Los argumentos opcionales `start` y `end` se usan para buscar solo en el segmento de la lista limitado por ellos, y en caso de usarlos, el índice devuelto es relativo a la lista entera, no al segmento.\n",
244 "\n",
245 "\n",
246 "`list.count(x)`\n",
247 "\n",
248 "Devuelve el número de veces que `x` aparece en la lista"
249 ]
250 },
251 {
252 "cell_type": "markdown",
253 "metadata": {
254 "slideshow": {
255 "slide_type": "subslide"
256 }
257 },
258 "source": [
259 "`list.sort(key=None, reverse=False)`\n",
260 "\n",
261 "Ordena los elementos de la lista.\n",
262 "\n",
263 "`list.reverse()`\n",
264 "\n",
265 "Da la vuelta a la lista.\n",
266 "\n",
267 "`list.copy()`\n",
268 "\n",
269 "Devuelve una copia de la lista. Es equivalente a `a[:]`."
270 ]
271 },
272 {
273 "cell_type": "code",
274 "execution_count": null,
275 "metadata": {
276 "slideshow": {
277 "slide_type": "slide"
278 }
279 },
280 "outputs": [],
281 "source": [
282 "fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']\n",
283 "print(fruits.count('apple'))\n",
284 "print(fruits.count('tangerine'))\n",
285 "print(fruits.index('banana'))\n",
286 "print(fruits.index('banana', 4))\n",
287 "\n",
288 "fruits.reverse()\n",
289 "print(fruits)\n",
290 "\n",
291 "fruits.append('grape')\n",
292 "print(fruits)\n",
293 "\n",
294 "fruits.sort()\n",
295 "print(fruits)\n",
296 "\n",
297 "print(fruits.pop())"
298 ]
299 },
300 {
301 "cell_type": "markdown",
302 "metadata": {
303 "slideshow": {
304 "slide_type": "slide"
305 }
306 },
307 "source": [
308 "### Tuplas\n",
309 "\n",
310 "Las tuplas funcionan de la misma forma que las listas, pero son estructuras de datos **inmutables**, es decir, una vez declarada una tupla, no se puede modificar su contenido. Se declara separando los valores con comas.\n"
311 ]
312 },
313 {
314 "cell_type": "code",
315 "execution_count": null,
316 "metadata": {
317 "slideshow": {
318 "slide_type": "slide"
319 }
320 },
321 "outputs": [],
322 "source": [
323 "squares = 1, 4, 9, 16, 25\n",
324 "empty = ()\n",
325 "one = ('lonely',)\n",
326 "\n",
327 "print(squares)\n",
328 "print(empty)\n",
329 "print(one)"
330 ]
331 },
332 {
333 "cell_type": "code",
334 "execution_count": null,
335 "metadata": {
336 "slideshow": {
337 "slide_type": "fragment"
338 }
339 },
340 "outputs": [],
341 "source": [
342 "squares [0] = 2"
343 ]
344 },
345 {
346 "cell_type": "markdown",
347 "metadata": {
348 "slideshow": {
349 "slide_type": "slide"
350 }
351 },
352 "source": [
353 "Una tupla también puede ser desempaquetada usando la notación para declararla al revés."
354 ]
355 },
356 {
357 "cell_type": "code",
358 "execution_count": null,
359 "metadata": {
360 "slideshow": {
361 "slide_type": "fragment"
362 }
363 },
364 "outputs": [],
365 "source": [
366 "t = \"apple\", \"bannana\", \"orange\"\n",
367 "x, y, z = t\n",
368 "print(x, y, z)"
369 ]
370 },
371 {
372 "cell_type": "markdown",
373 "metadata": {
374 "slideshow": {
375 "slide_type": "slide"
376 }
377 },
378 "source": [
379 "### Sets\n",
380 "\n",
381 "Los sets funcionan como las listas, solo que ésta estructura de datos se asegura de que no hayan valores repetidos. El set es una colección de elementos **no ordenada**. Existen dos versiones de set, la mutable, `set` y la no mutable, `frozenset`. \n",
382 "\n",
383 "Se crea usando las llaves, `{}`."
384 ]
385 },
386 {
387 "cell_type": "code",
388 "execution_count": null,
389 "metadata": {
390 "slideshow": {
391 "slide_type": "slide"
392 }
393 },
394 "outputs": [],
395 "source": [
396 "squares = {1, 4, 9, 16, 25}\n",
397 "print(squares)\n",
398 "\n",
399 "squares.add(1)\n",
400 "print(squares)\n",
401 "\n",
402 "squares.add(36)\n",
403 "print(squares)"
404 ]
405 },
406 {
407 "cell_type": "markdown",
408 "metadata": {
409 "slideshow": {
410 "slide_type": "slide"
411 }
412 },
413 "source": [
414 "#### Operaciones con sets\n",
415 "\n",
416 "Estas operaciones son compatibles con los `set` y los `frozenset`."
417 ]
418 },
419 {
420 "cell_type": "markdown",
421 "metadata": {
422 "slideshow": {
423 "slide_type": "subslide"
424 }
425 },
426 "source": [
427 "`isdisjoint(other)`\n",
428 "\n",
429 "Devuelve `True` si el set no tiene elementos en común con el otro.\n",
430 "\n",
431 "`issubset(other)`, `set <= other`, `set < other`\n",
432 "\n",
433 "Comprueba si todos los elementos del set están en el otro.\n",
434 " is, set <= other and set != other.\n",
435 "\n",
436 "`issuperset(other)`, `set >= other`, `set > other`\n",
437 "\n",
438 "Comprueba si todos los elementos del otro están el set.\n",
439 "\n",
440 "`union(*others)` , `set | other | ...`\n",
441 "\n",
442 "Devuelve un nuevo set con los elementos del set y de los otros."
443 ]
444 },
445 {
446 "cell_type": "markdown",
447 "metadata": {
448 "slideshow": {
449 "slide_type": "subslide"
450 }
451 },
452 "source": [
453 "`intersection(*others)`, `set & other & ...`\n",
454 "\n",
455 "Devuelve un nuevo set con todos los elementos en común con el set y los otros.\n",
456 "\n",
457 "`difference(*others)`, `set - other - ...`\n",
458 "\n",
459 "Devuelve un nuevo set con los elementos del set que no están en los otros.\n",
460 "\n",
461 "`symmetric_difference(other)`, `set ^ other`\n",
462 "\n",
463 "Devuelve un nuevo set con los elementos que están en un set o en otro, pero no en los dos.\n",
464 "\n",
465 "`copy()`\n",
466 "\n",
467 "Devuelve una copia del set."
468 ]
469 },
470 {
471 "cell_type": "markdown",
472 "metadata": {
473 "slideshow": {
474 "slide_type": "slide"
475 }
476 },
477 "source": [
478 "**Las siguientes operaciones solo son compatibles con los `set`.**\n",
479 "\n",
480 "`add(elem)`\n",
481 "\n",
482 "Añade un elemento.\n",
483 "\n",
484 "`remove(elem)`\n",
485 "\n",
486 "Borra el elemento, y da un error si no existe.\n",
487 "\n",
488 "`discard(elem)`\n",
489 "\n",
490 "Borra el elemento si existe.\n",
491 "\n",
492 "`pop()`\n",
493 "\n",
494 "Borra un elemento aleatorio del set, y da error si está vacío.\n",
495 "\n",
496 "`clear()`\n",
497 "\n",
498 "Borra los elementos de un set.\n"
499 ]
500 },
501 {
502 "cell_type": "code",
503 "execution_count": null,
504 "metadata": {
505 "slideshow": {
506 "slide_type": "slide"
507 }
508 },
509 "outputs": [],
510 "source": [
511 "fib1 = {1 , 2 , 3 , 5 , 8 , 13 , 21 , 34 , 55}\n",
512 "fib2 = {1 , 2 , 3 , 5 , 8}\n",
513 "even = {2, 4, 6, 8, 10, 12, 14, 16}\n",
514 "\n",
515 "print(fib1.isdisjoint(even))\n",
516 "\n",
517 "print(fib1 < even)\n",
518 "print(fib2 < fib1)\n",
519 "\n",
520 "print(fib1.issuperset(even))\n",
521 "print(fib1 > even)\n",
522 "\n",
523 "print(fib1 | even)\n",
524 "\n",
525 "print(fib1 & even)\n",
526 "\n",
527 "print(fib1 - even)\n"
528 ]
529 },
530 {
531 "cell_type": "markdown",
532 "metadata": {
533 "slideshow": {
534 "slide_type": "slide"
535 }
536 },
537 "source": [
538 "### Diccionarios\n",
539 "\n",
540 "Los diccionarios son una estructura de datos **mutable** que permiten almacenar datos de una forma parecida a las listas, pero en vez de usar un número, el índice, para referenciar el dato, se puede usar prácticamente cualquier cosa. Es como una base de datos para guardar y organizar información.\n",
541 "\n",
542 "Se pueden crear declarando una lista de elementos `key: value` separados por comas y rodeados de `{}`. También se puede usar `dict()` para crear el diccionario."
543 ]
544 },
545 {
546 "cell_type": "code",
547 "execution_count": null,
548 "metadata": {
549 "slideshow": {
550 "slide_type": "slide"
551 }
552 },
553 "outputs": [],
554 "source": [
555 "person = {'name': 'Antonio', 'age': 42}\n",
556 "print(person['name'])"
557 ]
558 },
559 {
560 "cell_type": "code",
561 "execution_count": null,
562 "metadata": {
563 "slideshow": {
564 "slide_type": "fragment"
565 }
566 },
567 "outputs": [],
568 "source": [
569 "person['last_name'] = 'Smith'\n",
570 "print(person)"
571 ]
572 },
573 {
574 "cell_type": "markdown",
575 "metadata": {
576 "slideshow": {
577 "slide_type": "slide"
578 }
579 },
580 "source": [
581 "#### Operaciones sobre diccionarios"
582 ]
583 },
584 {
585 "cell_type": "markdown",
586 "metadata": {
587 "slideshow": {
588 "slide_type": "subslide"
589 }
590 },
591 "source": [
592 "`d[key]`\n",
593 "\n",
594 "Accede al elemento con clave `key` del diccionario `d`. Lanza un error si `key` no existe en el diccionario.\n",
595 "\n",
596 "`d[key] = value`\n",
597 "\n",
598 "Guarda `value` en la clave `key` del diccionario `d`.\n",
599 "\n",
600 "`del d[key]`\n",
601 "\n",
602 "Borra `d[key]` del diccionario.\n",
603 "\n",
604 "`key in d`\n",
605 "\n",
606 "Comprueba si `d` tiene la clave `key`.\n"
607 ]
608 },
609 {
610 "cell_type": "markdown",
611 "metadata": {
612 "slideshow": {
613 "slide_type": "subslide"
614 }
615 },
616 "source": [
617 "`key not in d`\n",
618 "\n",
619 "Comprueba si `d` no tiene la clave `key`.\n",
620 "\n",
621 "`iter(d)`\n",
622 "\n",
623 "Devuelve un iterador sobre las claves del diccionario.\n",
624 "\n",
625 "`d.clear()`\n",
626 "\n",
627 "Borra todos los elementos del diccionario.\n",
628 "\n",
629 "`d.copy()`\n",
630 "\n",
631 "Copia el diccionario."
632 ]
633 },
634 {
635 "cell_type": "markdown",
636 "metadata": {
637 "slideshow": {
638 "slide_type": "subslide"
639 }
640 },
641 "source": [
642 "`d.get(key[, default])`\n",
643 "\n",
644 "Devuelve el contenido de `d[key]` en caso de que `key` esté en el diccionario, y en caso contrario, devuelve el valor de `default`, o `None` si no se ha concretado.\n",
645 "\n",
646 "`d.items()`\n",
647 "\n",
648 "Devuelve una el diccionario como una lista de tuplas `(key, value)`.\n",
649 "\n",
650 "`d.keys()`\n",
651 "\n",
652 "Devuelve una lista con las claves del diccionario.\n",
653 "\n",
654 "`pop(key[, default])`\n",
655 " \n",
656 "Si la clave está en el diccionario, la elimina y devuelve su valor, si no, devuelve el valor de `defaul`.\n"
657 ]
658 },
659 {
660 "cell_type": "markdown",
661 "metadata": {
662 "slideshow": {
663 "slide_type": "slide"
664 }
665 },
666 "source": [
667 "`popitem()`\n",
668 "\n",
669 "Elimina y devuelve un elemento aleatorio `(key, value)` del diccionario.\n",
670 "\n",
671 "`setdefault(key[, default])`\n",
672 "\n",
673 "Si la clave está en el diccionario, devuelve el valor, si no, inserta en la clave el valor dado en `default`, o None si no se ha dado ningún valor.\n",
674 "\n",
675 "`update([other])`\n",
676 "\n",
677 "\n",
678 "Actualiza el diccionario con las claves y valores del otro diccionario dado, sobreescribiendo las existentes.\n",
679 "\n",
680 "`values()`\n",
681 "\n",
682 "Devuelve una lista de los valores del diccionario.\n"
683 ]
684 },
685 {
686 "cell_type": "markdown",
687 "metadata": {
688 "slideshow": {
689 "slide_type": "slide"
690 }
691 },
692 "source": [
693 "### Collections\n",
694 "\n",
695 "El módulo `collections` implementa contenedores especializados para ser usados como alternativas a los contenedores multipropósito que ofrece Python, como `dict`, `list`, `set` y `tuple` que hemos visto anteriormente."
696 ]
697 },
698 {
699 "cell_type": "markdown",
700 "metadata": {
701 "slideshow": {
702 "slide_type": "slide"
703 }
704 },
705 "source": [
706 "#### Objetos `Counter`\n",
707 "\n",
708 "Un objeto `Counter` es una subclase de `dict` para contar objetos. Es una colección no ordenada donde los elementos son almacenados como claves de diccionario y sus cuentas como los valores de esas claves.\n"
709 ]
710 },
711 {
712 "cell_type": "code",
713 "execution_count": null,
714 "metadata": {
715 "slideshow": {
716 "slide_type": "slide"
717 }
718 },
719 "outputs": [],
720 "source": [
721 "import collections\n",
722 "\n",
723 "c = collections.Counter()\n",
724 "print(c)\n",
725 "c = collections.Counter(\"gandalf\")\n",
726 "print(c)\n",
727 "c = collections.Counter({'red': 4, 'blue': 2})\n",
728 "print(c)\n",
729 "c = collections.Counter([\"cats\"] * 4 + [\"dogs\"] * 8)\n",
730 "print(c)"
731 ]
732 },
733 {
734 "cell_type": "markdown",
735 "metadata": {
736 "slideshow": {
737 "slide_type": "slide"
738 }
739 },
740 "source": [
741 "Se puede acceder a la cuenta como si se tratara de un diccionario, pero en vez de dar una excepción cuando no existe un elemento, devuelve 0."
742 ]
743 },
744 {
745 "cell_type": "code",
746 "execution_count": null,
747 "metadata": {
748 "slideshow": {
749 "slide_type": "fragment"
750 }
751 },
752 "outputs": [],
753 "source": [
754 "print(\"Gatos:\", c['cats'])\n",
755 "print(\"Hamsters:\", c['hamsters'])"
756 ]
757 },
758 {
759 "cell_type": "markdown",
760 "metadata": {
761 "slideshow": {
762 "slide_type": "slide"
763 }
764 },
765 "source": [
766 "##### Métodos\n",
767 "\n",
768 "A los métodos que tiene `dict`, `Counter` añade los siguientes.\n",
769 "\n",
770 "`elements()`\n",
771 "\n",
772 "Devuelve un iterador sobre los elementos, repetidos tantas veces como su cuenta. Los elementos se devuelven en un orden arbitrario, y si su cuenta es menor que 1, se ingora.\n",
773 "\n",
774 "`most_common([n])`\n",
775 "\n",
776 "Devuelve la lista de los *n* elementos más comunes y sus cuentas. Si se omite el parámetro *n* se muestran todos los elementos.\n",
777 "\n",
778 "` subtract([iterable-or-mapping])`\n",
779 "\n",
780 "Elimina de las cuentas `Counter` tantos elementos como aparezcan en el iterable pasado por parámetro."
781 ]
782 },
783 {
784 "cell_type": "markdown",
785 "metadata": {
786 "slideshow": {
787 "slide_type": "slide"
788 }
789 },
790 "source": [
791 "#### Objetos `deque`\n",
792 "\n",
793 "Un objeto `deque` es una generalización de pilas y colas, y soportan operaciones de inserción y de eliminación eficientes y seguras desde cualquier lado de la cola.\n",
794 "\n",
795 "La lista soporta operaciones similares, pero por ejemplo, el coste de insertar un elemento en el principio es de *O(n)*, mientras que en un objeto de `deque` es aproximadamente de *O(1)*."
796 ]
797 },
798 {
799 "cell_type": "code",
800 "execution_count": null,
801 "metadata": {
802 "slideshow": {
803 "slide_type": "slide"
804 }
805 },
806 "outputs": [],
807 "source": [
808 "import collections\n",
809 "\n",
810 "d = collections.deque('bcd')\n",
811 "for elem in d:\n",
812 " print(elem)"
813 ]
814 },
815 {
816 "cell_type": "markdown",
817 "metadata": {
818 "slideshow": {
819 "slide_type": "slide"
820 }
821 },
822 "source": [
823 "##### Métodos\n",
824 "\n",
825 "`append(x)`\n",
826 "\n",
827 "Añade `x` al lado derecho del `deque`.\n",
828 "\n",
829 "`appendleft(x)`\n",
830 "\n",
831 "Añade `x` al lado izquierdo del `deque`.\n",
832 "\n",
833 "`clear()`\n",
834 "\n",
835 "Borra todos los elementos.\n",
836 "\n",
837 "`copy()`\n",
838 "\n",
839 "Crea una copia.\n",
840 "\n",
841 "`count(x)`\n",
842 "\n",
843 "Cuenta los elementos que sean igual a `x`.\n"
844 ]
845 },
846 {
847 "cell_type": "markdown",
848 "metadata": {
849 "slideshow": {
850 "slide_type": "subslide"
851 }
852 },
853 "source": [
854 "`extend(iterable)`\n",
855 "\n",
856 "Extiende por el lado derecho añadiendo los elementos del iterable pasado por argumento.\n",
857 "\n",
858 "`extendleft(iterable)`\n",
859 "\n",
860 "Extiende por el lado izquierdo añadiendo los elementos del iterable pasado por argumento.\n",
861 "\n",
862 "`index(x[, start[, stop]])`\n",
863 "\n",
864 "Devuelve la posicion del primer elemento `x` que encuentre.\n",
865 "\n",
866 "`insert(i, x)`\n",
867 "\n",
868 "Inserta `x` en la posición `i`.\n",
869 "\n",
870 "`pop()`\n",
871 "\n",
872 "Elimina y devuelve el primer lemento del lado derecho.\n",
873 "\n",
874 "`popleft()`\n",
875 "\n",
876 "Elimina y devuelve el primer lemento del lado izquierdo."
877 ]
878 },
879 {
880 "cell_type": "markdown",
881 "metadata": {
882 "slideshow": {
883 "slide_type": "subslide"
884 }
885 },
886 "source": [
887 "`remove(x)`\n",
888 "\n",
889 "Borra el primer elemento que sea igual a `x`.\n",
890 "\n",
891 "`reverse()`\n",
892 "\n",
893 "Da la vuelta al orden de los elementos.\n",
894 "\n",
895 "`rotate(n=1)`\n",
896 "\n",
897 "Rota los elementos `n` pasos a la derecha. Si `n` es negativo, rota a la izquierda.\n",
898 "\n"
899 ]
900 },
901 {
902 "cell_type": "code",
903 "execution_count": null,
904 "metadata": {
905 "slideshow": {
906 "slide_type": "slide"
907 }
908 },
909 "outputs": [],
910 "source": [
911 "d.append('e')\n",
912 "d.appendleft('a')\n",
913 "print(d)\n",
914 "\n",
915 "d.rotate(1)\n",
916 "print(d)\n",
917 "\n",
918 "d.rotate(-1)\n",
919 "print(d)"
920 ]
921 },
922 {
923 "cell_type": "markdown",
924 "metadata": {
925 "slideshow": {
926 "slide_type": "slide"
927 }
928 },
929 "source": [
930 "#### Objetos `defaultdict`\n",
931 "\n",
932 "Un objeto `defaultdict` es una subclase de `dict`, con la diferencia de que en el constructot se le puede pasar un objeto clase que será utilizado para inicializar el diccionario en caso de que se trate de acceder a una clave que no exista en ese momento."
933 ]
934 },
935 {
936 "cell_type": "code",
937 "execution_count": null,
938 "metadata": {
939 "slideshow": {
940 "slide_type": "slide"
941 }
942 },
943 "outputs": [],
944 "source": [
945 "import collections\n",
946 "\n",
947 "sample = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]\n",
948 "d = collections.defaultdict(list)\n",
949 "\n",
950 "for key, value in sample:\n",
951 " d[key].append(value)\n",
952 " print(d)\n",
953 " \n",
954 "print(d)"
955 ]
956 },
957 {
958 "cell_type": "markdown",
959 "metadata": {
960 "slideshow": {
961 "slide_type": "slide"
962 }
963 },
964 "source": [
965 "#### Objetos `OrderedDict`\n",
966 "\n",
967 "Los objetos `OrderedDict` son como los diccionarios normales pero conservando el orden en el que los elementos fueron añadidos al diccionarios. Cuando se itera sobre un diccionario ordenado, los elementos se devuelven en el orden que fueron añadidos."
968 ]
969 },
970 {
971 "cell_type": "code",
972 "execution_count": null,
973 "metadata": {
974 "slideshow": {
975 "slide_type": "slide"
976 }
977 },
978 "outputs": [],
979 "source": [
980 "import collections\n",
981 "\n",
982 "\n",
983 "d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}\n",
984 "\n",
985 "od = collections.OrderedDict(sorted(d.items(), key=lambda t: t[0]))\n",
986 "print(od)\n",
987 "\n",
988 "od = collections.OrderedDict(sorted(d.items(), key=lambda t: t[1]))\n",
989 "print(od)\n",
990 "\n",
991 "od = collections.OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))\n",
992 "print(od)\n"
993 ]
994 },
995 {
996 "cell_type": "markdown",
997 "metadata": {
998 "slideshow": {
999 "slide_type": "slide"
1000 }
1001 },
1002 "source": [
1003 "#### Objetos `namedtuple`\n",
1004 "\n",
1005 "El objeto `namedtuple` es una factoría que devuelve una subclase de `tuple`, con el nombre que se le indica por parámetro. La nueva subclase tiene campos que son accesibles como si fueran atributos de una clase.\n"
1006 ]
1007 },
1008 {
1009 "cell_type": "code",
1010 "execution_count": null,
1011 "metadata": {
1012 "slideshow": {
1013 "slide_type": "slide"
1014 }
1015 },
1016 "outputs": [],
1017 "source": [
1018 "import collections\n",
1019 "\n",
1020 "\n",
1021 "Point = collections.namedtuple('Point', ['x', 'y'])\n",
1022 "p = Point(11, y=22) \n",
1023 "print(p[0] + p[1])\n",
1024 "\n",
1025 "x, y = p\n",
1026 "print(x, y)\n",
1027 "\n",
1028 "print(p.x + p.y )\n",
1029 "\n",
1030 "print(p)"
1031 ]
1032 }
1033 ],
1034 "metadata": {
1035 "celltoolbar": "Slideshow",
1036 "kernelspec": {
1037 "display_name": "Python 3",
1038 "language": "python",
1039 "name": "python3"
1040 },
1041 "language_info": {
1042 "codemirror_mode": {
1043 "name": "ipython",
1044 "version": 3
1045 },
1046 "file_extension": ".py",
1047 "mimetype": "text/x-python",
1048 "name": "python",
1049 "nbconvert_exporter": "python",
1050 "pygments_lexer": "ipython3",
1051 "version": "3.7.1"
1052 }
1053 },
1054 "nbformat": 4,
1055 "nbformat_minor": 2
1056}