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 "## 3. Objetos Built-in (int, float,str,...) "
12 ]
13 },
14 {
15 "cell_type": "markdown",
16 "metadata": {
17 "slideshow": {
18 "slide_type": "slide"
19 }
20 },
21 "source": [
22 "### Booleanos\n",
23 "\n",
24 "En Python, los valores booleanos de verdadero y falso se referencian con `True` y `False` respectivamente.\n",
25 "\n",
26 "Operación | Resultado\n",
27 "----------|----------\n",
28 "`x` **and** `y` | si `x` es `False` entonces `x`, si no, `y`\n",
29 "`x` **or** `y` | si `x` es `True` entonces `x`, si no, `y`\n",
30 "**not** `x` | si `x` es `False` entonces `True`, si no, `False`\n"
31 ]
32 },
33 {
34 "cell_type": "markdown",
35 "metadata": {
36 "slideshow": {
37 "slide_type": "slide"
38 }
39 },
40 "source": [
41 "### Númericos\n",
42 "\n",
43 "Cualquier dígito, entero (`42`) o con decimales (`2.7182`) se consideran valores numéricos.\n",
44 "\n",
45 "Para aprender a usar el intérprete de Python, empezaremos usándolo como una calculadora."
46 ]
47 },
48 {
49 "cell_type": "markdown",
50 "metadata": {
51 "slideshow": {
52 "slide_type": "slide"
53 }
54 },
55 "source": [
56 "#### Operadores aritméticos\n",
57 "\n",
58 "Símbolo | Operación\n",
59 "---|------\n",
60 " + | suma\n",
61 " - | resta\n",
62 " / | división\n",
63 " // | división entera\n",
64 " * | producto\n",
65 " ** | potencia\n",
66 " % | módulo"
67 ]
68 },
69 {
70 "cell_type": "markdown",
71 "metadata": {
72 "slideshow": {
73 "slide_type": "slide"
74 }
75 },
76 "source": [
77 "#### Operadores de comparación\n",
78 "\n",
79 "Símbolo | Operación\n",
80 "---|------\n",
81 " < | menor que\n",
82 " > | mayor que\n",
83 " <= | menor o igual que\n",
84 " >= | mayor o igual que\n",
85 " == | igual a\n",
86 " != | no igual a\n"
87 ]
88 },
89 {
90 "cell_type": "markdown",
91 "metadata": {
92 "slideshow": {
93 "slide_type": "slide"
94 }
95 },
96 "source": [
97 "- Los número enteros (`2`, `4`, `20`) tienen tipo `int`. Los números con parte decimal (`5.0`, `1.6`) son de tipo `float`.\n",
98 "\n",
99 "- La operación de `/` entre `int` da un `float`. Para que el resultado\n",
100 "siga siendo `int`, usamos el operador `//`.\n",
101 "\n",
102 "- En el modo interactivo se puede usar `_` para hacer referencia al ultimo valor\n",
103 "que se ha obtenido."
104 ]
105 },
106 {
107 "cell_type": "code",
108 "execution_count": 1,
109 "metadata": {
110 "slideshow": {
111 "slide_type": "slide"
112 }
113 },
114 "outputs": [
115 {
116 "data": {
117 "text/plain": [
118 "21.105"
119 ]
120 },
121 "execution_count": 1,
122 "metadata": {},
123 "output_type": "execute_result"
124 }
125 ],
126 "source": [
127 "tax = 21.0 / 100\n",
128 "price = 100.5\n",
129 "price * tax\n",
130 "21.105"
131 ]
132 },
133 {
134 "cell_type": "code",
135 "execution_count": 3,
136 "metadata": {
137 "slideshow": {
138 "slide_type": "fragment"
139 }
140 },
141 "outputs": [
142 {
143 "data": {
144 "text/plain": [
145 "121.605"
146 ]
147 },
148 "execution_count": 3,
149 "metadata": {},
150 "output_type": "execute_result"
151 }
152 ],
153 "source": [
154 "price + _ + 11\n",
155 "121.605"
156 ]
157 },
158 {
159 "cell_type": "markdown",
160 "metadata": {
161 "slideshow": {
162 "slide_type": "slide"
163 }
164 },
165 "source": [
166 "### Variables, declaración de variables, tipado dinámico."
167 ]
168 },
169 {
170 "cell_type": "markdown",
171 "metadata": {
172 "slideshow": {
173 "slide_type": "fragment"
174 }
175 },
176 "source": [
177 "Las variables no se definen, se se les asigna un valor usando el operador `=`.\n",
178 "\n",
179 "Todo nombre de variable está asociada únicamente a un objeto. Nos referiremos a estas también como nombres, ya que, realmente lo que estamos haciendo es asignarle un nombre a un objeto determinado."
180 ]
181 },
182 {
183 "cell_type": "code",
184 "execution_count": 4,
185 "metadata": {
186 "slideshow": {
187 "slide_type": "slide"
188 }
189 },
190 "outputs": [
191 {
192 "data": {
193 "text/plain": [
194 "900"
195 ]
196 },
197 "execution_count": 4,
198 "metadata": {},
199 "output_type": "execute_result"
200 }
201 ],
202 "source": [
203 "width = 20\n",
204 "height = 5 * 9\n",
205 "width * height"
206 ]
207 },
208 {
209 "cell_type": "markdown",
210 "metadata": {
211 "slideshow": {
212 "slide_type": "slide"
213 }
214 },
215 "source": [
216 "- No se pueden crear variables con nombres de palabras reservadas del lenguaje.\n",
217 "- Las variables no pueden epezar por un número."
218 ]
219 },
220 {
221 "cell_type": "code",
222 "execution_count": 5,
223 "metadata": {
224 "slideshow": {
225 "slide_type": "fragment"
226 }
227 },
228 "outputs": [
229 {
230 "ename": "SyntaxError",
231 "evalue": "invalid syntax (<ipython-input-5-4c8ddce8d5a2>, line 1)",
232 "output_type": "error",
233 "traceback": [
234 "\u001b[0;36m File \u001b[0;32m\"<ipython-input-5-4c8ddce8d5a2>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m 2var = \"foo\"\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
235 ]
236 }
237 ],
238 "source": [
239 "2var = \"foo\""
240 ]
241 },
242 {
243 "cell_type": "code",
244 "execution_count": 6,
245 "metadata": {
246 "slideshow": {
247 "slide_type": "fragment"
248 }
249 },
250 "outputs": [
251 {
252 "ename": "SyntaxError",
253 "evalue": "invalid syntax (<ipython-input-6-34daa86cb8f6>, line 1)",
254 "output_type": "error",
255 "traceback": [
256 "\u001b[0;36m File \u001b[0;32m\"<ipython-input-6-34daa86cb8f6>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m break = 100\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
257 ]
258 }
259 ],
260 "source": [
261 "break = 100"
262 ]
263 },
264 {
265 "cell_type": "code",
266 "execution_count": 7,
267 "metadata": {
268 "slideshow": {
269 "slide_type": "slide"
270 }
271 },
272 "outputs": [
273 {
274 "name": "stdout",
275 "output_type": "stream",
276 "text": [
277 "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
278 ]
279 }
280 ],
281 "source": [
282 "import keyword\n",
283 "print(keyword.kwlist)"
284 ]
285 },
286 {
287 "cell_type": "markdown",
288 "metadata": {
289 "slideshow": {
290 "slide_type": "slide"
291 }
292 },
293 "source": [
294 "Python usa **duck typing**, que viene de la expresión de *\"si camina como un pato, y suena como un pato, debe de ser un pato\"*.\n",
295 "\n",
296 "Esto significa que en tiempo de ejecución se comprueba que una variable tiene ciertos atributos o métodos en vez de comprobar el tipo de la variable realmente."
297 ]
298 },
299 {
300 "cell_type": "code",
301 "execution_count": 8,
302 "metadata": {
303 "slideshow": {
304 "slide_type": "fragment"
305 }
306 },
307 "outputs": [
308 {
309 "name": "stdout",
310 "output_type": "stream",
311 "text": [
312 "<class 'int'>\n",
313 "<class 'float'>\n"
314 ]
315 }
316 ],
317 "source": [
318 "foo = 2 # foo contiene un dato tipo int\n",
319 "print(type(foo))\n",
320 "foo = 4.2 # foo contiene ahora un dato tipo float\n",
321 "print(type(foo))"
322 ]
323 },
324 {
325 "cell_type": "markdown",
326 "metadata": {
327 "slideshow": {
328 "slide_type": "slide"
329 }
330 },
331 "source": [
332 "Las variables funcionan como etiqutas, es decir, en realidad están apuntando a a una dirección en memoria que contiene el objeto.\n",
333 "\n",
334 "```python\n",
335 ">>> name = \"Antonio\"\n",
336 ">>> first = name\n",
337 "```\n",
338 "\n",
339 ""
340 ]
341 },
342 {
343 "cell_type": "markdown",
344 "metadata": {
345 "slideshow": {
346 "slide_type": "slide"
347 }
348 },
349 "source": [
350 "Los típos básicos de Python son **inmutables**, esto quiere decir que si son modificados, realmente se crea un **nuevo** objeto con esta modificación."
351 ]
352 },
353 {
354 "cell_type": "markdown",
355 "metadata": {
356 "slideshow": {
357 "slide_type": "slide"
358 }
359 },
360 "source": [
361 "```python\n",
362 "a = 1000\n",
363 "```\n",
364 "\n",
365 ""
366 ]
367 },
368 {
369 "cell_type": "markdown",
370 "metadata": {
371 "slideshow": {
372 "slide_type": "slide"
373 }
374 },
375 "source": [
376 "```python\n",
377 "a = a + 1\n",
378 "```\n",
379 "\n",
380 ""
381 ]
382 },
383 {
384 "cell_type": "markdown",
385 "metadata": {
386 "slideshow": {
387 "slide_type": "slide"
388 }
389 },
390 "source": [
391 "```python\n",
392 "a = a + 1\n",
393 "```\n",
394 "\n",
395 ""
396 ]
397 },
398 {
399 "cell_type": "markdown",
400 "metadata": {
401 "slideshow": {
402 "slide_type": "slide"
403 }
404 },
405 "source": [
406 "### Cadenas de texto, formato, encoding, métodos de cadenas."
407 ]
408 },
409 {
410 "cell_type": "markdown",
411 "metadata": {
412 "slideshow": {
413 "slide_type": "fragment"
414 }
415 },
416 "source": [
417 "- Se considera una cadena de texto cualquier sucesión de caracteres entre comillas dobles, `\"`, o comillas simples, `'`. \n",
418 "- Se puede usar `\\` para escapar las comillas.\n",
419 "- Se considera que una cadena es una secuencia, de caracteres, y por tanto se puede acceder a un caracter usando su índice, aunque es un tipo de datos **inmutable**, por lo que no puede ser modificado de esta forma."
420 ]
421 },
422 {
423 "cell_type": "code",
424 "execution_count": 9,
425 "metadata": {
426 "slideshow": {
427 "slide_type": "slide"
428 }
429 },
430 "outputs": [
431 {
432 "name": "stdout",
433 "output_type": "stream",
434 "text": [
435 "P\n",
436 "n\n"
437 ]
438 }
439 ],
440 "source": [
441 "word = 'Python'\n",
442 "print(word[0]) # caracter en posición 0\n",
443 "print(word[5]) # caracter en posición 5"
444 ]
445 },
446 {
447 "cell_type": "code",
448 "execution_count": 10,
449 "metadata": {
450 "slideshow": {
451 "slide_type": "fragment"
452 }
453 },
454 "outputs": [
455 {
456 "ename": "TypeError",
457 "evalue": "'str' object does not support item assignment",
458 "output_type": "error",
459 "traceback": [
460 "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
461 "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
462 "\u001b[0;32m<ipython-input-10-54675649332c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# no se puede modificar, da una excepción\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mword\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"a\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
463 "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
464 ]
465 }
466 ],
467 "source": [
468 "# no se puede modificar, da una excepción\n",
469 "word[4] = \"a\""
470 ]
471 },
472 {
473 "cell_type": "markdown",
474 "metadata": {
475 "slideshow": {
476 "slide_type": "fragment"
477 }
478 },
479 "source": [
480 "Por defecto, todas las cadenas de texto son de tipo `str` y se considera texto en UTF-8. "
481 ]
482 },
483 {
484 "cell_type": "markdown",
485 "metadata": {
486 "slideshow": {
487 "slide_type": "slide"
488 }
489 },
490 "source": [
491 "#### Operaciones sobre cadenas de texto"
492 ]
493 },
494 {
495 "cell_type": "markdown",
496 "metadata": {
497 "slideshow": {
498 "slide_type": "subslide"
499 }
500 },
501 "source": [
502 "`str.capitalize()`\n",
503 "\n",
504 "Devuelve una copia de la cadena con la primera letra en mayúscula y el resto en minúscula.\n",
505 "\n",
506 "`str.count(sub[, start[, end]])`\n",
507 "\n",
508 "Cuenta el número de veces que `sub` se encuentra en la cadena, desde `start` a `end`.\n",
509 "\n",
510 "`str.endswith(suffix[, start[, end]])`\n",
511 "\n",
512 "Devuelve si la cadena de texto termina con `suffix`.\n",
513 "\n",
514 "`str.isalnum()`\n",
515 "\n",
516 "Comprueba si la cadena de texto es alfanumérica.\n"
517 ]
518 },
519 {
520 "cell_type": "markdown",
521 "metadata": {
522 "slideshow": {
523 "slide_type": "subslide"
524 }
525 },
526 "source": [
527 "`str.isalpha()`\n",
528 "\n",
529 "Comprueba si la cadena de texto sólo tiene caracteres alfabéticos.\n",
530 "\n",
531 "`str.isdecimal()`\n",
532 "\n",
533 "Comprueba que todos los dígitos son decimales.\n",
534 "\n",
535 "`str.join(iterable)`\n",
536 "\n",
537 "Devuelve una cadena que es la concatenación de las cadenas en `iterable` usando la propia cadena como separador.\n",
538 "\n",
539 "`str.lower()`\n",
540 "\n",
541 "Devuelve una copia de la cadena con todos los caracteres en minúsculas."
542 ]
543 },
544 {
545 "cell_type": "markdown",
546 "metadata": {
547 "slideshow": {
548 "slide_type": "subslide"
549 }
550 },
551 "source": [
552 "`str.split(sep=None, maxsplit=-1)`\n",
553 "\n",
554 "Devuelve una lista resultado de dividir la cadena usando `sep` como separador.\n",
555 "\n",
556 "`str.splitlines([keepends])`\n",
557 "\n",
558 "Devuelve una lista resultado de dividir la cadena usando saltos de línea como separadores.\n",
559 "\n",
560 "`str.startswith(prefix[, start[, end]])`\n",
561 "\n",
562 "Devuelve si la cadena de texto empieza con `prefix`."
563 ]
564 },
565 {
566 "cell_type": "markdown",
567 "metadata": {
568 "slideshow": {
569 "slide_type": "subslide"
570 }
571 },
572 "source": [
573 "`str.strip([chars])`\n",
574 "\n",
575 "Devuelve una copia de la cadena eliminando del principio y del final los caracteres indicados en `char`. Si no se indican, se eliminan los espacios en blanco.\n",
576 "\n",
577 "`str.upper()`\n",
578 "\n",
579 "Devuelve una copia de la cadena con todos los caracteres en mayúsculas."
580 ]
581 },
582 {
583 "cell_type": "markdown",
584 "metadata": {
585 "slideshow": {
586 "slide_type": "slide"
587 }
588 },
589 "source": [
590 "#### Raw strings\n",
591 "\n",
592 "Los caracteres especiales, como saltos de línea, tabulaciones, etc. se introducen\n",
593 "de la forma habitual, `\\n`, `\\t`. Pero, si no se quiere que se tengan en cuenta,\n",
594 "se puede usar una *raw string*, añadiendo `r` delante de las comillas iniciales.\n"
595 ]
596 },
597 {
598 "cell_type": "code",
599 "execution_count": 11,
600 "metadata": {
601 "slideshow": {
602 "slide_type": "fragment"
603 }
604 },
605 "outputs": [
606 {
607 "name": "stdout",
608 "output_type": "stream",
609 "text": [
610 "C:\\some\n",
611 "ame\n",
612 "C:\\some\\name\n"
613 ]
614 }
615 ],
616 "source": [
617 "print('C:\\some\\name') # aquí \\n es un salto de línea\n",
618 "print(r'C:\\some\\name') # aquí no se considera un caracter especial"
619 ]
620 },
621 {
622 "cell_type": "markdown",
623 "metadata": {
624 "slideshow": {
625 "slide_type": "slide"
626 }
627 },
628 "source": [
629 "#### Strings multilíneas\n",
630 "\n",
631 "Podemo crear una cadena de texto que tenga más de una líena. Para ello, se declara el literal usando las triples comillas."
632 ]
633 },
634 {
635 "cell_type": "code",
636 "execution_count": 12,
637 "metadata": {
638 "slideshow": {
639 "slide_type": "fragment"
640 }
641 },
642 "outputs": [
643 {
644 "name": "stdout",
645 "output_type": "stream",
646 "text": [
647 "Usage: thingy [OPTIONS]\n",
648 " -h Display this usage message\n",
649 " -H hostname Hostname to connect to\n",
650 "\n"
651 ]
652 }
653 ],
654 "source": [
655 "print(\"\"\"\\\n",
656 "Usage: thingy [OPTIONS]\n",
657 " -h Display this usage message\n",
658 " -H hostname Hostname to connect to\n",
659 "\"\"\")"
660 ]
661 },
662 {
663 "cell_type": "markdown",
664 "metadata": {
665 "slideshow": {
666 "slide_type": "slide"
667 }
668 },
669 "source": [
670 "#### Format strings\n",
671 "\n",
672 "Para mostrar valores de variables en cadenas de texto podemos usar *format strings*. Estas se pueden definir usando `f` como prefijo del literal de cadena de texto o usando el método `format`.\n",
673 "\n",
674 "Las variables se sustituirán en los lugares que se indiquen entre llaves, `{}`."
675 ]
676 },
677 {
678 "cell_type": "code",
679 "execution_count": 13,
680 "metadata": {
681 "slideshow": {
682 "slide_type": "fragment"
683 }
684 },
685 "outputs": [
686 {
687 "name": "stdout",
688 "output_type": "stream",
689 "text": [
690 "Vamos a hablar sobre Antonio\n",
691 "Vamos a hablar sobre Antonio\n"
692 ]
693 }
694 ],
695 "source": [
696 "name = \"Antonio\"\n",
697 "print(f\"Vamos a hablar sobre {name}\")\n",
698 "print(\"Vamos a hablar sobre {}\".format(name))"
699 ]
700 },
701 {
702 "cell_type": "markdown",
703 "metadata": {
704 "slideshow": {
705 "slide_type": "slide"
706 }
707 },
708 "source": [
709 "Algunos ejemplos de como se pueden asociar valores a una cadena:\n",
710 "\n",
711 "```python\n",
712 "\"First, thou shalt count to {0}\" # Referencia al primer argumento posicional\n",
713 "\"Bring me a {}\" # Referencia al primer argumento posicional de forma implícita\n",
714 "\"From {} to {}\" # Lo mismo que \"From {0} to {1}\"\n",
715 "\"My quest is {name}\" # Referencia el argumento con nombre 'name'\n",
716 "\"Weight in tons {0.weight}\" # Referencia al atributo 'weight' del primer argumento posicional\n",
717 "\"Units destroyed: {players[0]}\" # Referencia al primer elemento del argumento con nombre 'players'\n",
718 "```"
719 ]
720 },
721 {
722 "cell_type": "markdown",
723 "metadata": {
724 "slideshow": {
725 "slide_type": "slide"
726 }
727 },
728 "source": [
729 "#### Concatenación de Cadenas\n",
730 "\n",
731 "Las cadenas de texto se pueden concatenar usando el operador `+`, y se pueden repetir usando el operador `*`."
732 ]
733 },
734 {
735 "cell_type": "code",
736 "execution_count": 14,
737 "metadata": {
738 "slideshow": {
739 "slide_type": "fragment"
740 }
741 },
742 "outputs": [
743 {
744 "data": {
745 "text/plain": [
746 "'unununium'"
747 ]
748 },
749 "execution_count": 14,
750 "metadata": {},
751 "output_type": "execute_result"
752 }
753 ],
754 "source": [
755 "# 3 veces 'un', seguido de un 'ium'\n",
756 "3 * 'un' + 'ium'"
757 ]
758 },
759 {
760 "cell_type": "markdown",
761 "metadata": {
762 "slideshow": {
763 "slide_type": "fragment"
764 }
765 },
766 "source": [
767 "Los literales de strings (las cadenas indicadas con comillas, no las variables) se pueden concatenar poniendo una detrás de otra."
768 ]
769 },
770 {
771 "cell_type": "code",
772 "execution_count": 15,
773 "metadata": {
774 "slideshow": {
775 "slide_type": "fragment"
776 }
777 },
778 "outputs": [
779 {
780 "data": {
781 "text/plain": [
782 "'Python'"
783 ]
784 },
785 "execution_count": 15,
786 "metadata": {},
787 "output_type": "execute_result"
788 }
789 ],
790 "source": [
791 "'Py' 'thon'"
792 ]
793 },
794 {
795 "cell_type": "markdown",
796 "metadata": {
797 "slideshow": {
798 "slide_type": "slide"
799 }
800 },
801 "source": [
802 "- Se considera una secuencia de bytes un literal declarado con `b''` o con `b\"\"`, igual que las cadenas de texto, pero usando `b` como prefijo.\n",
803 "- Sólo se aceptan caracteres ASCII.\n",
804 "- Son de tipo `bytes`"
805 ]
806 },
807 {
808 "cell_type": "code",
809 "execution_count": 19,
810 "metadata": {
811 "slideshow": {
812 "slide_type": "slide"
813 }
814 },
815 "outputs": [
816 {
817 "data": {
818 "text/plain": [
819 "b'De perdidos al rio'"
820 ]
821 },
822 "execution_count": 19,
823 "metadata": {},
824 "output_type": "execute_result"
825 }
826 ],
827 "source": [
828 "text = b'De perdidos al rio'\n",
829 "text"
830 ]
831 },
832 {
833 "cell_type": "code",
834 "execution_count": 21,
835 "metadata": {
836 "slideshow": {
837 "slide_type": "fragment"
838 }
839 },
840 "outputs": [
841 {
842 "data": {
843 "text/plain": [
844 "'De perdidos al rio'"
845 ]
846 },
847 "execution_count": 21,
848 "metadata": {},
849 "output_type": "execute_result"
850 }
851 ],
852 "source": [
853 "text.decode(\"utf-8\")"
854 ]
855 },
856 {
857 "cell_type": "code",
858 "execution_count": 22,
859 "metadata": {
860 "slideshow": {
861 "slide_type": "fragment"
862 }
863 },
864 "outputs": [
865 {
866 "data": {
867 "text/plain": [
868 "b'De perdidos al rio'"
869 ]
870 },
871 "execution_count": 22,
872 "metadata": {},
873 "output_type": "execute_result"
874 }
875 ],
876 "source": [
877 "\"De perdidos al rio\".encode(\"utf-8\")"
878 ]
879 }
880 ],
881 "metadata": {
882 "celltoolbar": "Slideshow",
883 "kernelspec": {
884 "display_name": "Python 3",
885 "language": "python",
886 "name": "python3"
887 },
888 "language_info": {
889 "codemirror_mode": {
890 "name": "ipython",
891 "version": 3
892 },
893 "file_extension": ".py",
894 "mimetype": "text/x-python",
895 "name": "python",
896 "nbconvert_exporter": "python",
897 "pygments_lexer": "ipython3",
898 "version": "3.7.1"
899 }
900 },
901 "nbformat": 4,
902 "nbformat_minor": 2
903}