├── Lecturas
├── blank.txt
├── 08 - Archivos
│ ├── entrada.txt
│ └── 08 - Archivos.ipynb
├── 01_Introduccion_a_Python.ipynb
├── 06 - Funciones Nativas e Importadas.ipynb
└── 02_Strings.ipynb
└── readme.md
/Lecturas/blank.txt:
--------------------------------------------------------------------------------
1 | blankfile
2 |
--------------------------------------------------------------------------------
/Lecturas/08 - Archivos/entrada.txt:
--------------------------------------------------------------------------------
1 | HOLA
2 | Este es un texto de ejemplo
3 | Soy un archivo .txt, por lo que almaceno texto sin formato, y la única información que guardo es el texto mismo
4 |
5 | La cantidad de consonantes que hay en este documento es de65
6 |
--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
1 | ## 10110 - FUNDAMENTOS DE COMPUTACIÓN Y PROGRAMACIÓN
2 | ## 10145 - FUNDAMENTOS DE PROGRAMACIÓN PARA INGENIERÍA
3 |
4 | ---
5 |
6 | Repositorio de material de los cursos comunes de programación de la Universidad de Santiago de Chile (USACH)
7 | Segundo semestre de 2024
8 |
9 | ---
10 |
11 | # CONTENIDOS
12 |
13 | ## UNIDAD 1: FUNDAMENTOS DE PROGRAMACIÓN
14 | * Introducción a Python: Tipos de datos, variables, operadores y expresiones.
15 | * El tipo de dato String e I/O: Tipo de dato string y funciones de *input* y *ouput*.
16 | * Control de flujo: `if, if-else, if-elif-else.`
17 | * Iteración I: `while` y `for-in`.
18 | * Tipos de datos compuestos: Listas.
19 |
20 |
21 | ## UNIDAD 2: FUNCIONES Y ABSTRACCIÓN
22 | * Funciones nativas e importadas.
23 | * Funciones propias: sintaxis, invocación, *scope*.
24 | * Recursión.
25 |
26 |
27 | ## UNIDAD 3: PROGRAMACIÓN PARA INGENIERÍA
28 | * Tipos de datos compuestos: Archivos
29 |
30 |
31 | ---
32 |
33 | # CARPETAS
34 | * Lecturas: Notebooks de todas las clases del curso, consideren que estos archivos son mutables, por lo que podrían modificarse durante el semestre.
35 | * Material complementario: Tutoriales y otros recursos externos de interés.
36 |
37 | --
38 |
39 | ## CONSULTAS: programacion.diinf@usach.cl
40 |
--------------------------------------------------------------------------------
/Lecturas/08 - Archivos/08 - Archivos.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {
6 | "id": "eYakJtwBHqYG"
7 | },
8 | "source": [
9 | "![\"LogoUSACH\"](\"https://progra-fing-usach.github.io/IMGs/logo-fing.png\")
\n",
10 | "\n",
11 | "# Archivos"
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {
17 | "id": "GCLydi8DoJX7"
18 | },
19 | "source": [
20 | "## Definición"
21 | ]
22 | },
23 | {
24 | "cell_type": "code",
25 | "execution_count": null,
26 | "metadata": {
27 | "colab": {
28 | "base_uri": "https://localhost:8080/"
29 | },
30 | "executionInfo": {
31 | "elapsed": 2432,
32 | "status": "ok",
33 | "timestamp": 1654470530803,
34 | "user": {
35 | "displayName": "Alfredo Gonzalezf",
36 | "userId": "10271437243951850394"
37 | },
38 | "user_tz": 240
39 | },
40 | "id": "kLw3ek4dIEkJ",
41 | "outputId": "8e07535c-995e-4710-ffd6-61b45fcccc8a"
42 | },
43 | "outputs": [
44 | {
45 | "name": "stdout",
46 | "output_type": "stream",
47 | "text": [
48 | "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
49 | ]
50 | }
51 | ],
52 | "source": [
53 | "# Importación para cargar el propio directorio de Drive en Google Colab\n",
54 | "from google.colab import drive\n",
55 | "# La cuenta de Google Drive estará en la carpeta señalada\n",
56 | "drive.mount('/content/drive')"
57 | ]
58 | },
59 | {
60 | "cell_type": "markdown",
61 | "metadata": {
62 | "id": "HzduIbe63wDy"
63 | },
64 | "source": [
65 | "Hasta ahora solo se ha trabajado obteniendo información solicitándola al usuario mediante el uso del teclado (con ayuda de la función `input()`), pero existen otras fuentes de donde poder obtener datos para poder realizar los procesos solicitados. En esta unidad, se extraerá la información desde archivos (también conocidos como ficheros). Estos se caracterizan por tener una **ruta** o dirección, un **nombre** específico y un formato determinado. Esta información es de vital importancia al momento de querer generar una extracción de datos, puesto que, de no tenerla o escribirla de manea errada, puede ocasionar que Python no logre la comunicación con el documento y, por ende, falle la extracción de información.\n",
66 | "\n",
67 | "Considerando que este curso es una introducción a la programación, solo se trabajará con archivos de texto plano, los que pueden ser de solo texto (cuya extensión tradicional es `.txt`) y archivos de valores separados por coma (con extensión `.csv`, normalmente).\n",
68 | "\n",
69 | "Para lograr extraer la información desde el documento, se debe trabajar con un nuevo tipo de objeto, el cual se conoce como **`File`**, y entrega las herramientas necesarias (métodos) para poder interactuar con los archivos mencionados."
70 | ]
71 | },
72 | {
73 | "cell_type": "markdown",
74 | "metadata": {},
75 | "source": [
76 | "## Generalidades sobre archivos"
77 | ]
78 | },
79 | {
80 | "cell_type": "markdown",
81 | "metadata": {},
82 | "source": [
83 | "## Sistemas de Archivos"
84 | ]
85 | },
86 | {
87 | "cell_type": "markdown",
88 | "metadata": {},
89 | "source": [
90 | "En términos burdos, un **archivo** es un compartimiento de almacenamiento en el computador, que es manejado por el sistema operativo. Estos compartimientos corresponden a cadenas de datos (en forma de cadenas de bytes) que residene en algún sistema de almacenamiento, generalmente persistente (como un disco duro, uno de estado sólido, una memoria flash, etc.), es decir, que no se pierde cuando uno apaga el sistema (como es el caso de la memoria RAM: una vez apagamos el computador, todo lo que tenía esta, se pierde).\n",
91 | "\n",
92 | "Llamamos **sistema de archivos** a la forma en que se organizan los archivos y carpetas dentro de un sistema computacional. Un **directorio** o **carpeta** es una colección de archivos y otros directorios. Esto significa que hay una jerarquía de directorios: el más alto es la **raíz**, que viene de que tratamos la relación entre directorios como un árbol, donde los archivos son las \"hojas\" y los directorios, las \"ramas\".\n",
93 | "\n",
94 | "Dos de los modelos de sistema de archivos más importantes son los utilizados por sistemas Windows y por sistemas basados en Unix, como Linux o MacOS:\n",
95 | "- Windows utiliza una organización donde, por defecto, cada unidad de disco tiene su propia raíz. Por ejemplo, el disco donde normalmente está instalado el sistema en equipos nuevos es `C:` y el directorio con el sistema operativo es `C:\\Windows` y la que contiene a los usuarios, `C:\\Users`. Si tenemos el directorio de usuarios en otra unidad de disco, por ejemplo, `D:`, entonces la ubicación de esta sería `D:\\Users`. Si tenemos un usuario llamado \"Fulano\", sus archivos estarán en `D:\\Users\\Fulano`. Nota que el nombre de cada directorio se separa de su padre o su hijo con el caracter *backslash* (`\\`).\n",
96 | "\n",
97 | "\n",
98 | "
![](\"http://www.eprisner.de/CPT105/PicFiles/tree.gif\")
\n",
99 | "
\n",
106 | "
![](\"https://4.bp.blogspot.com/-iU-fdru9JEQ/XJVIJnSpGuI/AAAAAAAAA5Q/YmfPmTHXvAgvUbiAOiBJXC9hNnlYX1pigCLcBGAs/s1600/File_Tree.png\")
\n",
107 | "
![\"LogoUSACH\"](\"https://fing.usach.cl/sites/ingenieria/files/logo-fing.png\")
\n","\n","# INTRODUCCIÓN A PYTHON: TIPOS DE DATOS, VARIABLES, OPERADORES Y EXPRESIONES\n","\n","\n"]},{"cell_type":"markdown","metadata":{"id":"gemgYqGTq0hu"},"source":["## **Expresiones Matemáticas**\n","\n","Antes de comenzar a trabajar en Python a nivel general, es necesario aprender a realizar operaciones aritméticas básicas."]},{"cell_type":"markdown","metadata":{"id":"RHfD5TS8p-C2"},"source":["### Expresiones Binarias"]},{"cell_type":"markdown","metadata":{"id":"I7c0KNO9qIbn"},"source":["La notación para realizar operaciones aritméticas básicas **binarias** es la siguiente:\n","\n","**Número --> Operador --> Número**"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":385,"status":"ok","timestamp":1678661410694,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"FV9gHr_1IoAp","outputId":"b02c2578-1f2d-476d-c2c3-ee83245aca22"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["9"]},"metadata":{},"execution_count":2}],"source":["# Suma\n","5 + 4"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":63,"status":"ok","timestamp":1678661411345,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"Sddy-gmOV62u","outputId":"e07c1b5c-1f22-42c4-f2d0-abd1718c222b"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["11.0"]},"metadata":{},"execution_count":3}],"source":["# Suma\n","8.0 + 3"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":62,"status":"ok","timestamp":1678661411346,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"r3CCsb7fIp3i","outputId":"4672fab4-769d-48d6-fcf9-2d2d9232309d"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["-4"]},"metadata":{},"execution_count":4}],"source":["# Resta\n","3 - 7"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":61,"status":"ok","timestamp":1678661411347,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"H49TgHTEWCK6","outputId":"2d202236-f4f6-436d-ed28-ae959ef25944"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["4.6"]},"metadata":{},"execution_count":5}],"source":["# Resta\n","10 - 5.4"]},{"cell_type":"markdown","metadata":{"id":"driqRVEAL06W"},"source":["Los ejemplos anteriores se conocer como **notación infija**, y es la que\n","se debe utilizar cada vez que se escriban operaciones matemáticas.\n","\n","Hay que considerar que para realizar una `multiplicación` se debe utilizar el operador * (**asterisco**) y para realizar una `división` se debe utilizar el operador / (**slash**)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":59,"status":"ok","timestamp":1678661411348,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"e2LsoXEFLoIQ","outputId":"7dc2b6c1-c55d-4799-aef8-5d1417c65c04"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["8"]},"metadata":{},"execution_count":6}],"source":["# Multiplicación\n","2*4"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":56,"status":"ok","timestamp":1678661411348,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"zAVQqwN5WfE7","outputId":"baa06b10-4622-47e6-a736-ddd8d9445fc0"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["12.5"]},"metadata":{},"execution_count":7}],"source":["# Multiplicación\n","2.5*5"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":54,"status":"ok","timestamp":1678661411349,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"h8Xzd1FOLsY9","outputId":"e4f9a4ff-0574-4a1d-a4b8-c90b4f0148c0"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["2.0"]},"metadata":{},"execution_count":8}],"source":["# División\n","10/5"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":52,"status":"ok","timestamp":1678661411349,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"ju9x-7csWqJJ","outputId":"0effd9b7-a3de-4ad5-cc64-bd5d8a2deca2"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["1.5"]},"metadata":{},"execution_count":9}],"source":["# División\n","12/8"]},{"cell_type":"markdown","metadata":{"id":"yenD2HItkeTd"},"source":["Además de las 4 operaciones básicas, Python provee operaciones que pueden ser de utilidad:\n","\n","* **Potencia** (`**`)\n","* **Resto o módulo** (**`%`**)\n","* **División parte entera** (**`//`**)\n"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":49,"status":"ok","timestamp":1678661411349,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"zCzAbeOwlMHQ","outputId":"52875546-ea60-4927-ef24-573fc5d3d1b8"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["16"]},"metadata":{},"execution_count":10}],"source":["# Potencia\n","2**4"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":48,"status":"ok","timestamp":1678661411350,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"-itRGgahWycu","outputId":"0186717e-4571-4064-fa04-521fe013dc6e"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["9"]},"metadata":{},"execution_count":11}],"source":["# Potencia\n","3**2"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":45,"status":"ok","timestamp":1678661411350,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"b9rRPDm3k0mh","outputId":"1c922eb6-5597-4fb0-83a6-81da8cd5a2d4"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["1"]},"metadata":{},"execution_count":12}],"source":["# Resto o módulo\n","10%3"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":43,"status":"ok","timestamp":1678661411350,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"fGXmQqixW065","outputId":"05289933-575d-4652-ab8b-160c111f1d41"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["0"]},"metadata":{},"execution_count":13}],"source":["# Resto o módulo\n","24%6"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":42,"status":"ok","timestamp":1678661411351,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"2NdwcT4f0xkl","outputId":"a59c4def-0005-4a41-f916-43b36bc31da0"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["3"]},"metadata":{},"execution_count":14}],"source":["# División parte entera\n","10//3"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":39,"status":"ok","timestamp":1678661411351,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"2ErczKuRXBaz","outputId":"4ad25d76-3003-4497-cec1-61a42a2830df"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["0"]},"metadata":{},"execution_count":15}],"source":["# División parte entera\n","4//6"]},{"cell_type":"markdown","metadata":{"id":"yxWIf5M3lS8p"},"source":["### Expresiones Unarias\n","\n"]},{"cell_type":"markdown","metadata":{"id":"-4fW2XxGqTTl"},"source":["Por otra parte, también se pueden encontrar **operadores unarios**:\n","* **Identidad** (**`+`**)\n","* **Negación** (**`-`**)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":37,"status":"ok","timestamp":1678661411352,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"O3Vb9zzDlhTj","outputId":"6057af65-a2c5-4c61-c841-042dc9883895"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["4"]},"metadata":{},"execution_count":16}],"source":["# Identidad\n","+4"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":35,"status":"ok","timestamp":1678661411352,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"OtxdXlWVXPDA","outputId":"e8ea7971-05ed-4943-8d69-471ded0267bc"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["-23"]},"metadata":{},"execution_count":17}],"source":["# Identidad\n","+(-23)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":32,"status":"ok","timestamp":1678661411352,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"XeiWV_QElkwg","outputId":"2720be6a-ebe9-4161-999f-b7fd49467930"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["-6"]},"metadata":{},"execution_count":18}],"source":["# Negación\n","-6"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":31,"status":"ok","timestamp":1678661411353,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"9cjpq3c5XJj7","outputId":"439f7b9b-0b2c-425a-fea0-25fe45a57d94"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["5"]},"metadata":{},"execution_count":19}],"source":["# Negación\n","-(-5)"]},{"cell_type":"markdown","metadata":{"id":"QhGOMGInyX8t"},"source":["### Precedencia de Operadores\n"]},{"cell_type":"markdown","metadata":{"id":"PAlHP41JpwII"},"source":["La `precedencia de operadores` son reglas sencillas que permiten a Python \"ordenar\" la evaluación de expresiones. Se reconocen 3 tipos de operadores:\n","1. **Operadores aritméticos**: corresponden a los operadores que se han visto hasta el momento y sirven para realizar cálculos matemáticos sencillos.\n","2. **Operadores de comparación**: sirven para hacer evaluaciones que siempre resultan en valores de verdad. Estos serán revisados más adelante, cuando se quiera condicionar los programas.\n","3. **Operadores lógicos**: sirven para representar las combinaciones que pueden hacerse sobre valores de verdad y que también se verán más adelante.\n","\n","Para Python, siempre se verán primero los operadores `aritméticos`, luego los de `comparación` y `finalmente los lógicos`. Además, cada categoría tiene su propio orde de evaluación preestablecido.\n","\n","Python sigue las reglas de precedencia de signos, las cuales fueron vistas en la asignatura de matemáticas.\n","\n","Antes de continuar, resuelva en su cuaderno la siguiente expresión matemática:\n","\n","5 + 5 ** 3 / 5 * 4 - 10 * 3"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":29,"status":"ok","timestamp":1678661411353,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"-eCBw9T4Yzzr","outputId":"73fdab03-c624-4b84-98f4-18b75a998622"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["75.0"]},"metadata":{},"execution_count":20}],"source":["# Compare el resultado obtenido con lo que arroja Python\n","5+5**3/5*4-10*3"]},{"cell_type":"markdown","metadata":{"id":"O8lPGa3s5g-P"},"source":["Al realizar operaciones matemáticas, en el intérpete de Python, y de forma independiente los resutados pueden ser distintos lo cual puede ser por dos motivos:\n","\n","\n","* La precedencia de operadores\n","* El tipo de dato\n","\n"]},{"cell_type":"markdown","metadata":{"id":"nIq_Y6FnZPHg"},"source":["En los operadores aritméticos, el orden de prioridad, desde el operador más importante al de menor importancia, se presenta en la siguiente tabla:\n","\n"]},{"cell_type":"markdown","metadata":{"id":"KLhGm0X41Hx_"},"source":["\n","|Operación |Operador |Aridad |Asociatividad |Precedencia|\n","|:------------:|:------------:|:------------:|:------------:|:---------:|\n","|Exponenciación| `**` |Binaria |Derecha |1 |\n","|Identidad | `+` |Unaria |- |2 |\n","|Negación | `-` |Unaria |- |2 |\n","|Multiplicación| `*` |Binaria |Izquierda |3 |\n","|División | `/` |Binaria |Izquierda |3 |\n","|Módulo o resto | `%` |Binaria |Izquierda |3 |\n","|División parte entera| `//` |Binaria |Izquierda |3 |\n","|Suma| `+` |Binaria |Izquierda |4 |\n","|Resta| `-` |Binaria |Izquierda |4 |"]},{"cell_type":"markdown","metadata":{"id":"dQxVdeO06qfT"},"source":["Las reglas de precedencia pueden ser modificadas utilizando ( ) **paréntesis**.\n","\n","A modo de ejemplo, si se quisiera realizar el ejercicio anterior\n","\n","5 + 5 ** 3 / 5 * 4 - 10 * 3\n","\n","pero darle prioridad a la operación 5 + 5, se debe utilizar **paréntesis**\n","\n","(5 + 5) ** 3 / 5 * 4 - 10 * 3\n","\n"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":26,"status":"ok","timestamp":1678661411353,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"TXxn0i9I8mWJ","outputId":"a2a58a6e-edc4-4dee-99e8-81f184c12cb5"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["75.0"]},"metadata":{},"execution_count":21}],"source":["# Vuelva a desarrollar el ejercicio sin paréntesis\n","5 + 5 ** 3 / 5 * 4 - 10 * 3"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":26,"status":"ok","timestamp":1678661411355,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"r-kVY0XR8t1f","outputId":"4f02ceac-5e31-4ea5-a782-6a08b42a806f"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["770.0"]},"metadata":{},"execution_count":22}],"source":["# Desarrolle el ejercicio con paréntesis\n","(5 + 5) ** 3 / 5 * 4 - 10 * 3"]},{"cell_type":"markdown","metadata":{"id":"O5f-uE5s87-o"},"source":["Cuando se quiere modificar las reglas de precedecia pueden surgir los siguientes problemas:\n","\n","\n","* Los paréntesis que se abren deben cerrararse, vale decir, los paréntesis deben estar **balanceados**.\n","\n","* Solo se deben utilizar paréntesis redondos ( ). El uso de `corchetes` [ ] o `paréntesis de llaves` { } se utilizan para definir tipos de datos (**listas** y **diccionarios** respectivamente)\n","\n","\n","\n","Veamos el siguiente ejemplo"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":131},"executionInfo":{"elapsed":24,"status":"error","timestamp":1678661411355,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"50swnLb4-aa3","outputId":"f6ff61d3-1e51-4f49-c040-ea073fdf25df"},"outputs":[{"output_type":"error","ename":"SyntaxError","evalue":"ignored","traceback":["\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m (2+((3**2)/5*3)+3*2-(3*4)+5)+5)\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m unmatched ')'\n"]}],"source":["(2+((3**2)/5*3)+3*2-(3*4)+5)+5)"]},{"cell_type":"markdown","metadata":{"id":"9TmjF9wulP4C"},"source":["## **Tipos de datos**\n"]},{"cell_type":"markdown","metadata":{"id":"3bUu9r59xwZm"},"source":["En todos los lenguajes de programación existen distintos tipos de datos para facilitar el trabajo a realizar. Los tipos de datos son un conjunto determinado de valores con propiedades y características determinadas.\n","\n","Los 3 tipos principales de datos son:\n","\n","* Tipo numérico\n","* Tipo texto\n","* Tipo lógico\n","\n","Los tipos de datos texto y lógicos serán vistos con mayor detalle a medida que avance el curso, por el momento solo se dará una pequeña definición de ellos para comprender su importancia.\n"]},{"cell_type":"markdown","metadata":{"id":"4ezfg5ZqjXb0"},"source":["### Tipo numérico"]},{"cell_type":"markdown","metadata":{"id":"DPswRlUKs8C5"},"source":["En Python existen tres clases de números:\n","\n","* **Números enteros** (**`int`**): son una representación de los números enteros, tanto positivos como negativos.\n","\n","* **Números flotantes** (**`float`**): son una representación de los números reales, vale decir, son números que tienen una parte entera y una parte decimal. Se debe tener en cuenta que para separar la parte entera de la decimal se utiliza el punto (.), esto se debe a que Python fue escrito por angloparlantes. A los números flotantes se les denomina números de punto flotante.\n","\n","* **Números complejos** (**`complex`**): son una representación de conjunto matemático correspondiente a los números complejos. Lo anterior significa que el número está conformado por una parte real y otra imaginaria. Esta última es acompañada con la letta **`j`**"]},{"cell_type":"markdown","metadata":{"id":"xZO1QIiujR55"},"source":["Cabe señalar que los tipos de datos numéricos son solo aproximaciones de los conjuntos matemáticos que representan debido a que la cardinalidad de estos es infinita y los computadores tienen una cantidad de memoria finita"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":274,"status":"ok","timestamp":1678661421725,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"zqR36RIvj-LV","outputId":"5be132e9-fdea-4c17-c119-c9a0ee772135"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["(6+4j)"]},"metadata":{},"execution_count":24}],"source":["# Operación Números Complejos\n","(2+5j) + (4-1j)\n"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":440,"status":"ok","timestamp":1678661422426,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"GO99dSC5k-5S","outputId":"0ae4e39f-0d45-454f-c977-d17280405b6c"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["(11+1j)"]},"metadata":{},"execution_count":25}],"source":["# Operación Números Complejos\n","15 - (4-1j)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":24,"status":"ok","timestamp":1678661422426,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"cyBMqsxOkka3","outputId":"0857f981-d3d7-43e1-e196-699fc112bf81"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["13.0"]},"metadata":{},"execution_count":26}],"source":["# Operación Números Enteros y Flotantes\n","2 + 4 - 8 + 15.0\n"]},{"cell_type":"markdown","metadata":{"id":"ltGxeNTllTAF"},"source":["En el caso del último ejemplo, al desarrollar la expresión matemática entrega como resultado un número flotante. Esto se debe a que cuando se tengan operaciones que combinen distintos tipos de datos numéricos, Python **siempre mantendrá el resultado en el conjunto más general de los conjuntos numéricos**.\n","\n","Por ello, dado que en el ejercicio anterior se tienen datos de tipo `entero` y `flotante`, el resultado será `flotante`."]},{"cell_type":"markdown","metadata":{"id":"iRmpO-QtrEeV"},"source":["### Tipo texto"]},{"cell_type":"markdown","metadata":{"id":"6C5s_5bdrKGa"},"source":["Son conocidos como **strings** (**`str`**) y se utilizan par almacenar secuencias de cadenas de texto para la generación mensajes y archivos con información\n","\n","Los strings se identifican con la utilización de comillas simples (**'**) o comillas dobles (**\"**), las cuales delimitan el comienzo y fin de la secuencia de caracteres.\n","\n","Cabe señalar que, si el string se inicia con comillas simples, debe terminar con comillas simples. Si se inicia con comillas dobles, debe terminar con comillas dobles."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Qz48--7nvL0k","colab":{"base_uri":"https://localhost:8080/","height":35},"executionInfo":{"status":"ok","timestamp":1678661422427,"user_tz":180,"elapsed":24,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"cf747eb0-89d7-4e56-9bbf-857d844dba3f"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["'este es un string'"],"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"}},"metadata":{},"execution_count":27}],"source":["# Ejemplo string\n","\"este es un string\""]},{"cell_type":"code","execution_count":null,"metadata":{"id":"rXGttrHSvO6D","colab":{"base_uri":"https://localhost:8080/","height":35},"executionInfo":{"status":"ok","timestamp":1678661422427,"user_tz":180,"elapsed":23,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"10eba13d-603e-4b2f-b4ad-fb24a995e9c1"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["'este es un string'"],"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"}},"metadata":{},"execution_count":28}],"source":["# Ejemplo string\n","'este es un string'"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"TTgReeKfvaTz","colab":{"base_uri":"https://localhost:8080/","height":131},"executionInfo":{"status":"error","timestamp":1678661422428,"user_tz":180,"elapsed":23,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"5a69d4f0-b8b5-4edf-a541-5b438f3a0909"},"outputs":[{"output_type":"error","ename":"SyntaxError","evalue":"ignored","traceback":["\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m 'este es un mal ejempo de string\"\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m EOL while scanning string literal\n"]}],"source":["# Ejemplo string\"\n","'este es un mal ejempo de string\""]},{"cell_type":"markdown","metadata":{"id":"VT3nynjHvlT6"},"source":["### Tipo lógico\n"]},{"cell_type":"markdown","metadata":{"id":"MVLFugWzxgww"},"source":["También denominado booleano, es un tipo de dato que permite expresas 2 valores: Verdadero (***True***) y Falso (***False***)\n","\n","De manera interna, el valor **False** representa un **0** y el Valor **True** equivale a un **1**\n","\n","Cabe destacar que ambos valores se deben escribir capitalizados, vale decir, su primera letra debe ser mayúscula para que Python los reconozca como valores lógicos"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"9YRHietiw0sa","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1678661429474,"user_tz":180,"elapsed":254,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"5130dfe3-337b-495b-d5bc-27eaaab4ddde"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["True"]},"metadata":{},"execution_count":30}],"source":["# Ejemplo booleano\n","True"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"wEU2RQSJw8En","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1678661429837,"user_tz":180,"elapsed":4,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"322871f3-2c04-40ad-e90c-e403a68755ab"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["False"]},"metadata":{},"execution_count":31}],"source":["# Ejemplo booleano\n","False"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"e2YXiAJ4w-AK","colab":{"base_uri":"https://localhost:8080/","height":184},"executionInfo":{"status":"error","timestamp":1678661430281,"user_tz":180,"elapsed":447,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"3af768f2-1982-4f60-8566-a0ef212f1ebd"},"outputs":[{"output_type":"error","ename":"NameError","evalue":"ignored","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)","\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Ejemplo booleano\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mNameError\u001b[0m: name 'true' is not defined"]}],"source":["# Ejemplo booleano\n","true"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"dxvzNULBxAzb"},"outputs":[],"source":["# Ejemplo booleano\n","false"]},{"cell_type":"markdown","metadata":{"id":"GFuIJ9yGygug"},"source":["## **Conversión de Tipos**"]},{"cell_type":"markdown","metadata":{"id":"gTArAY_nylrh"},"source":["Como se vio anteriormete, Python reconoce el tipo de dato con el cual se quiere trabajar y en el caso del tipo de dato numérico, se pueden mezclar para generar nuevas expresiones aritméticas, permitiendo que Python se quede con el tipo de dato más general.\n","\n","No obstante, existe la posibilidad de poder indicar a Python qué tipo de dato se quiere obtener de manera directa. Para realizar dicho cometido, se utilizarán funciones nativas (más adelante se explicarán en detalle).\n","\n","Las funciones de cambio de tipo (*typecast*) a utilizar son las siguientes:\n","\n","\n","* Conversión a número entero ---> `int( )`\n","\n","* Conversión a número flotante ---> `float( )`\n","\n","* Conversión a número complejo ---> `complex( )`\n","\n","* Conversión a texto ---> `str( )`\n","\n","* Conversión a booleano ---> `bool( )`\n","\n"]},{"cell_type":"markdown","metadata":{"id":"rO3wsGF64cX9"},"source":["### Conversión a número entero"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"N4QoPN-A1HIx","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1678661441991,"user_tz":180,"elapsed":267,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"43f83540-dcc4-476d-89e4-b099fd567e41"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["3"]},"metadata":{},"execution_count":33}],"source":["# Conversión número flotante a entero\n","int(3.6)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Q-B2QLLk1SJQ","colab":{"base_uri":"https://localhost:8080/","height":184},"executionInfo":{"status":"error","timestamp":1678661442799,"user_tz":180,"elapsed":457,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"082a161f-60b2-46c8-88e6-5cd2267c72dc"},"outputs":[{"output_type":"error","ename":"TypeError","evalue":"ignored","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)","\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Conversión número complejo a entero\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m3j\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mTypeError\u001b[0m: can't convert complex to int"]}],"source":["# Conversión número complejo a entero\n","int(5-3j)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"lDLRrsRQ1eK1","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1678661452162,"user_tz":180,"elapsed":241,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"d2104e26-b885-4477-c942-3f50651d776c"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["5"]},"metadata":{},"execution_count":39}],"source":["# Conversión texto a número entero\n","int(\"5\")"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"h6OJk2RN35D5","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1678661452449,"user_tz":180,"elapsed":13,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"4aa86127-380c-4772-d3e5-ba1a903965d4"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["0"]},"metadata":{},"execution_count":40}],"source":["# Conversión booleano a entero\n","int(False)"]},{"cell_type":"markdown","metadata":{"id":"Y-MiotTj4ki_"},"source":["### Conversión a número flotante"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"IPHFTJiE4n-4","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1678661452450,"user_tz":180,"elapsed":12,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"87151e56-71bf-41fa-86a3-d8f66ad4478e"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["5.0"]},"metadata":{},"execution_count":41}],"source":["# Conversión número entero a flotante\n","float(5)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"sdRJ9hoR5Bwi","colab":{"base_uri":"https://localhost:8080/","height":184},"executionInfo":{"status":"error","timestamp":1678661452451,"user_tz":180,"elapsed":9,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"b61d5d5f-1d91-4b51-c1e9-64568f75085c"},"outputs":[{"output_type":"error","ename":"TypeError","evalue":"ignored","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)","\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Conversión número complejo a flotante\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5j\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mTypeError\u001b[0m: can't convert complex to float"]}],"source":["# Conversión número complejo a flotante\n","float(5j)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"ieCQ6Gmm5HGL","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1678661457271,"user_tz":180,"elapsed":231,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"8a36aa4e-7152-49f1-9b3f-90da87210597"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["4.2"]},"metadata":{},"execution_count":43}],"source":["# Conversión texto a número flotante\n","float(\"4.2\")"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"R5wrCEJp5PoQ","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1678661458012,"user_tz":180,"elapsed":483,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"3035efa2-3b81-4955-fbc2-a71791b368b9"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["1.0"]},"metadata":{},"execution_count":44}],"source":["# Conversión booleano a número flotante\n","float(True)"]},{"cell_type":"markdown","metadata":{"id":"amFc4u-d5lGj"},"source":["### Conversión a número complejo"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"paEMy2eu5uwP","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1678661458012,"user_tz":180,"elapsed":60,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"0576a325-e77c-4c4f-8127-478fbcb5b29c"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["(5+0j)"]},"metadata":{},"execution_count":45}],"source":["# Conversión número entero a complejo\n","complex(5)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"jdMAHc7D51cX","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1678661458013,"user_tz":180,"elapsed":59,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"2fe31218-e3af-4466-c234-be45effb58c7"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["(2.8+0j)"]},"metadata":{},"execution_count":46}],"source":["# Conversión número flotante a complejo\n","complex(2.8)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"jY1RGLL66Hpa","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1678661458014,"user_tz":180,"elapsed":57,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"d7e05f8f-be9d-4612-a7b8-526d2569cea6"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["(1.5-1j)"]},"metadata":{},"execution_count":47}],"source":["# Conversión texto a número complejo\n","complex(\"1.5-j\")"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":53,"status":"ok","timestamp":1678661458014,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"V8Jobd0j6OeG","outputId":"592b529e-63ca-4748-d58c-fab043e53d6e"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["(1+0j)"]},"metadata":{},"execution_count":48}],"source":["# Conversión booleano a número complejo\n","complex(True,False)"]},{"cell_type":"markdown","metadata":{"id":"vt815BHP6d7z"},"source":["### Conversión a texto"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"RiDmPUAL6iOp","colab":{"base_uri":"https://localhost:8080/","height":35},"executionInfo":{"status":"ok","timestamp":1678661458015,"user_tz":180,"elapsed":52,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"78de4c5f-9631-40c4-da76-599ee1cf07c5"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["'4'"],"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"}},"metadata":{},"execution_count":49}],"source":["# Conversión número entero a texto\n","str(4)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"9f-arn1v6pel","colab":{"base_uri":"https://localhost:8080/","height":35},"executionInfo":{"status":"ok","timestamp":1678661458015,"user_tz":180,"elapsed":50,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"d696c8e2-0300-4bc1-e92a-dc12c58b5685"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["'2.8'"],"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"}},"metadata":{},"execution_count":50}],"source":["# Conversión número flotante a texto\n","str(2.8)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"4URZGkO66sCX","colab":{"base_uri":"https://localhost:8080/","height":35},"executionInfo":{"status":"ok","timestamp":1678661458015,"user_tz":180,"elapsed":49,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"96d8b4f0-66d1-443c-ce75-d81b486be814"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["'(8.1+20j)'"],"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"}},"metadata":{},"execution_count":51}],"source":["# Conversión número complejo a texto\n","str(8.1+20j)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"a2eyVjl06wD-","colab":{"base_uri":"https://localhost:8080/","height":35},"executionInfo":{"status":"ok","timestamp":1678661458016,"user_tz":180,"elapsed":48,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"d5a17501-de89-43b6-9b3c-f5b36c4522d0"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["'True'"],"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"}},"metadata":{},"execution_count":52}],"source":["# Conversión booleano a texto\n","str(True)"]},{"cell_type":"markdown","metadata":{"id":"BbgBSPV964zw"},"source":["### Conversión a booleano"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"VYClU6Ul6_3v","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1678661458016,"user_tz":180,"elapsed":46,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"06fe5530-7b10-4660-857b-9fba8217ab0f"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["True"]},"metadata":{},"execution_count":53}],"source":["# Conversión número entero a booleano\n","bool(34)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"fTJJ9oNJ7JcP","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1678661458017,"user_tz":180,"elapsed":43,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"}},"outputId":"32e54c68-c65e-4b51-e723-45c283c213cf"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["True"]},"metadata":{},"execution_count":54}],"source":["# Conversión número flotante a booleano\n","bool(9.56)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":41,"status":"ok","timestamp":1678661458017,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"CQ3Zxy_x7NFz","outputId":"2e2b42f1-0211-4228-da2d-a58f0e235ce0"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["False"]},"metadata":{},"execution_count":55}],"source":["# Conversión número complejo a booleano\n","bool(0+0j)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":40,"status":"ok","timestamp":1678661458018,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"ACHME3qX7ZN6","outputId":"14d44a13-f0a5-4aa0-8029-9afcf213ba40"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["True"]},"metadata":{},"execution_count":56}],"source":["# Conversión número complejo a booleano\n","bool(1+1j)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":37,"status":"ok","timestamp":1678661458019,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"kdhi_nWI7VLp","outputId":"04bee048-b2d7-4833-ae71-f2893463c03e"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["True"]},"metadata":{},"execution_count":57}],"source":["# Conversión texto a booleano\n","bool(\"False\")"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":34,"status":"ok","timestamp":1678661458019,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"wT3Li4xE7cq5","outputId":"676279c9-fb2a-4a1b-aeaa-4732d103b3ba"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["True"]},"metadata":{},"execution_count":58}],"source":["# Conversión texto a booleano\n","bool(\"True\")"]},{"cell_type":"markdown","metadata":{"id":"mkcOk1o4DRh-"},"source":["## **Operador asignación**"]},{"cell_type":"markdown","metadata":{"id":"NjV27d3DDemb"},"source":["Además de los operadores mencionados anteriormente, Python posee un operador especial denominado asignación (**=**). Dicho operador permite **almacenar** un valor o resultado de una expresión con un **nombre determinado por el/la programador/a** para posteriormente usarlo.\n","\n","La estructura del operador asignación es la siguiente:\n","```\n"," = \n","```\n","Se debe tener en consideración que el símbolo de asignación (**=**) NO es una igualdad o equivalencia, sino que permite guardar un valor/expresión determinada.\n","\n","Conociendo el concepto del operador asignación, se pueden definir las **variables** y **constantes** para almacenar valores.\n"]},{"cell_type":"markdown","metadata":{"id":"w5FlUHDH8AAa"},"source":["### **Variables y Expresiones**"]},{"cell_type":"markdown","metadata":{"id":"CdJFIlDJ-aEN"},"source":["#### Reglas para identificadores"]},{"cell_type":"markdown","metadata":{"id":"o83BXdWo-3l-"},"source":["Las variables y constantes pueden tener cualquier nombre, siempre y cuando se cumplan algunas sencillas reglas:\n","\n","\n","1. Un identificador puede estar conformado por:\n","\n"," * **Letras**: minúsculas y/o mayúsculas\n"," * **Dígitos**: 0 - 9\n"," * Caracter de subrayado o **guión bajo**\n","\n","2. El **primer caracter** no puede ser un dígito\n","\n","3. No puede conincidir con una palabra reservada del lenguaje Python, las cuales son: **and**, **assert**, **break**, **class**, **continue**, **def**, **del**, **elif**, **else**, **except**, **exec**, **finally**, **for**, **from**, **global**, **if**, **import**, **in**, **is**, **lambda**, **not**, **or**, **pass**, **print**, **raise**, **return**, **try**, **while**, **yield**. Las palabras reservadas de Python son aquellas que el editor IDLE marca de color naranja.\n","\n","4. Debe ser representativo, ya que hace más entendible el programa. Por ejemplo, \"radio\", \"sumando\", \"nombre\", \"edad\".\n","\n","5. Para el caso de las **constantes**, sus nombres se escriben siempre con mayúscula y separando las palabras con el caracter de subrayado. Representan valores que el programa **NO DEBERÍA MODIFICAR**.\n","\n","6. Para el caso de las **variables**, sus nombres se escriben en minúscula y separando las palabras con el caracter de subrayado. Representan valores que **PUEDEN** cambiar o sobreescribirse en un programa."]},{"cell_type":"markdown","metadata":{"id":"mlcFL3Kp_bxp"},"source":["En la siguiente tabla se presentan nombres de variables y constantes adecuados y no adecuados para programas en Python:"]},{"cell_type":"markdown","metadata":{"id":"qEuFvItP_rXG"},"source":["#### Variables"]},{"cell_type":"markdown","metadata":{"id":"j6VKug1nMUdJ"},"source":["|Ejemplo |Correcto/Incorrecto |\n","|:--------------:|:--------------------------------------------------------:|\n","|resultado |Correcto |\n","| sumaAcumulada |Incorrecto: las palabras se deben separar por (**`_`**) |\n","| suma_parcial |Correcto |\n","| x1 |Incorrecto: nombre no representativo |\n","| cosa2 |Incorrecto: nombre no representativo |"]},{"cell_type":"markdown","metadata":{"id":"mjJTBJAMBcdf"},"source":["#### Constantes"]},{"cell_type":"markdown","metadata":{"id":"NWGW45cgMZPC"},"source":["|Ejemplo |Correcto/Incorrecto |\n","|:--------------:|:-----------------------------------:|\n","| PI |Correcto |\n","| NUMERO_E |Correcto |\n","| gravedad |Incorrecto: no usa mayúsculas |\n","| numeroPi |Incorrecto: no usa mayúsculas |"]},{"cell_type":"markdown","metadata":{"id":"HjAzaB77JNOO"},"source":["Para comprender, de mejor manera, se presenta el siguiente ejemplo donde se calcula el perímetro de una cirncunferencia:"]},{"cell_type":"markdown","metadata":{"id":"lsbpoTNHMiKZ"},"source":["#### Ejemplo Variables y Constantes"]},{"cell_type":"markdown","metadata":{"id":"NiwuzLUvfqfx"},"source":["A continuación se muestra un ejemplo donde se pretende obtener el perímetro de una circunferencia de radio 3"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":32,"status":"ok","timestamp":1678661458019,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"Ga258jzvJX2S","outputId":"62890808-0cd3-43d7-ee66-9f8db8820ad4"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["18.84"]},"metadata":{},"execution_count":59}],"source":["#Se definen las constantes y variables a utilizar\n","NUMERO_PI = 3.14\n","radio = 3\n","\n","#Se realiza los cálculos respectivos\n","perimetro_circunferencia = 2 * NUMERO_PI * radio\n","\n","#Se entrega el resultado\n","perimetro_circunferencia"]},{"cell_type":"markdown","metadata":{"id":"UAYRJFS_fz-X"},"source":["Del mismo modo, se presenta un nuevo ejemplo donde se desea calcular el perímetro de un rectángulo"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":29,"status":"ok","timestamp":1678661458020,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"lS7bhFI6f76T","outputId":"073d5941-5e48-432c-9d14-b9e7876f1456"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["14"]},"metadata":{},"execution_count":60}],"source":["#Se definen las variables a utilizar\n","lado_a = 3\n","lado_b = 4\n","\n","#Se realizan los cálculos respectivos\n","perimetro_rectangulo = 2*lado_a + 2*lado_b\n","\n","#Se entrega el resultado\n","perimetro_rectangulo"]},{"cell_type":"markdown","metadata":{"id":"TqH1u-Xp8fuF"},"source":["# Bibliografía\n","\n","## Sobre la notación infija\n","\n","Colaboradores de Wikipedia. (2019, 25 diciembre). *Notación de infijo*. Wikipedia, la enciclopedia libre. Recuperado 1 de agosto de 2022, de https://es.wikipedia.org/wiki/Notaci%C3%B3n_de_infijo\n","\n","## Sobre notación de punto flotante\n","\n","Borgwardt, M. (s. f.). *Números de punto flotante*. La Guía del Punto Flotante. Recuperado 1 de agosto de 2022, de http://puntoflotante.org/formats/fp/\n","\n","Colaboradores de Wikipedia. (2022, 10 mayo). *Coma flotante*. Wikipedia, la enciclopedia libre. Recuperado 1 de agosto de 2022, de https://es.wikipedia.org/wiki/Coma_flotante\n","\n","## Sobre tipos numéricos y operadores aritméticos\n","\n","Ceder, V. L., Harms, D. K., & McDonald, K. M. (2010). The Quick Python Book. En *Built-in data types* (2.a ed., p. 19). Manning.\n","\n","GeeksforGeeks. (2021, 1 octubre). *Python Data Types*. Recuperado 2 de agosto de 2022, de https://www.geeksforgeeks.org/python-data-types/\n","\n","GeeksforGeeks. (2020, 30 agosto). *Python Arithmetic Operators*. Recuperado 2 de agosto de 2022, de https://www.geeksforgeeks.org/python-arithmetic-operators/\n","\n","Python Software Foundation. (2022, 1 agosto). An Informal Introduction to Python. Python 3.10.5 documentation. Recuperado 1 de agosto de 2022, de https://docs.python.org/3/tutorial/introduction.html\n","\n","## Estándar de formato\n","El Libro De Python. (2022). *Python PEP8*. Recuperado 1 de agosto de 2022, de https://ellibrodepython.com/python-pep8#convenciones-al-nombrar-elementos-camelcase-y-snake_case\n","\n","Van Rossum, G., Warsaw, B., & Coghlan, N. (2001, 21 julio). *PEP 8 – Style Guide for Python Code*. Python Enhancement Proposals. Recuperado 1 de agosto de 2022, de https://peps.python.org/pep-0008/\n"]}],"metadata":{"colab":{"provenance":[],"toc_visible":true},"kernelspec":{"display_name":"Python 3.10.5 64-bit","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.10.5"},"vscode":{"interpreter":{"hash":"26de051ba29f2982a8de78e945f0abaf191376122a1563185a90213a26c5da77"}}},"nbformat":4,"nbformat_minor":0}
--------------------------------------------------------------------------------
/Lecturas/06 - Funciones Nativas e Importadas.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {
6 | "id": "eYakJtwBHqYG"
7 | },
8 | "source": [
9 | "
\n",
10 | "\n",
11 | "# Funciones nativas e importadas"
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {
17 | "id": "u72A6sXa88F7"
18 | },
19 | "source": [
20 | "Las funciones, en programación, corresponden a porciones de código aislado que realizan una determinada tarea. \n",
21 | "\n",
22 | "Esto implica que una función es una especie de *\"mini-programa\"*, el cual a partir de alguna(s) entradas, entrega una salida."
23 | ]
24 | },
25 | {
26 | "cell_type": "markdown",
27 | "metadata": {
28 | "id": "zAzwkeKw91U9"
29 | },
30 | "source": [
31 | "En Python existen una gran cantidad de funciones predefinidas y listas para usarse. Estas se llaman **funciones nativas**, dado que son propias del lenguaje de programación. En otras palabras, Python automáticamente entiende a qué nos referimos cuando usamos una de ellas, como por ejemplo, `print()`, `len()` o `input()`.\n",
32 | "\n",
33 | "En general, estas funciones resuelven problemas específicos y comunes a la hora de programar, como por ejemplo, determinar la cantidad de elementos en una lista o mostrar un mensaje en la pantalla del usuario. Sin embargo, las funciones nativas no bastan para por sí solas para dar soluciones a problemas específicos. En estos casos, tenemos dos opciones: \n",
34 | "* Importar funciones que alguien más haya creado, o bien,\n",
35 | "* Definir nuestras propias funciones.\n",
36 | "\n",
37 | "Una de las grandes ventajas de Python es que, dada su popularidad, distintos usuarios han desarrollado múltiples funciones para resolver problemas en particular. Normalmente cuando se crea un conjunto de funciones para resolver algún problema en particular, como por ejemplo, hacer un programa con conexión a internet, estas se empaquetan en una *biblioteca* o **módulo**, y luego se dejan disponibles para que la comunidad pueda usarlas.\n",
38 | "\n",
39 | "Existen algunos módulos que fueron creados por los mismos desarrolladores de Python, los cuales podemos **importar** directamente en nuestros programas. Pero también existen módulos desarrollados por otros usuarios y organizaciones (terceros, o *third-parties*) los que deben instalarse para poder usarse. Sin embargo, todas estas funciones se conocen como **funciones importadas**, pues debo \"importarlas\" o *\"traerlas\"* a mi código para poder usarlas.\n",
40 | "\n",
41 | "Tanto las funciones nativas como importadas trabajan bajo el concepto de **caja negra**, es decir, podemos usarlas solo conociendo:\n",
42 | "* El **nombre** que las identifica.\n",
43 | "* Los parámetros de **entrada** que necesita la función para poder operar (hay funciones que necesitan uno, otras ninguno y otras tienen múltiples parámetros).\n",
44 | "* La **salida** o el tipo de salida que generan.\n",
45 | "\n",
46 | "Conociendo esto, puedo **invocar** a la función, la cual ejecutará un **proceso** encapsulado, es decir, ejecutan una serie de instrucciones hasta obtener una **salida**.\n",
47 | "\n",
48 | "Dado que la función siempre ejecutará el proceso, no es necesariamente relevante poder saber **cómo** ejecuta el proceso, sino que solo basta saber **qué** es lo que hace. \n",
49 | "\n",
50 | "Por ejemplo: ¿vale la pena saber qué es lo que hace internamente un computador cuando uso un `input()`?\n",
51 | "\n",
52 | "* En general no, pues nos basta con saber *qué hace* la función y que la podemos usar. De hecho, la hemos usado todo el curso, sin saber cómo funciona internamente."
53 | ]
54 | },
55 | {
56 | "cell_type": "markdown",
57 | "metadata": {
58 | "id": "hKeWmS4pBUUr"
59 | },
60 | "source": [
61 | "## Funciones Nativas"
62 | ]
63 | },
64 | {
65 | "cell_type": "markdown",
66 | "metadata": {
67 | "id": "htcXvWK_BYos"
68 | },
69 | "source": [
70 | "Las **funciones nativas** (en inglés, *built-in functions*) corresponden a las funciones que están **por defecto en el lenguaje Python.**\n",
71 | "\n",
72 | "Estas funciones pueden ser invocadas de manera directa y usarse en el programa sin darles una definición previa.\n",
73 | "\n",
74 | "Durante el transcurso del curso, se han visto diversas funciones que ayudan al proceso de buscar la solución a un determinado problema. Existen funciones que sirven para temas generales y otras para operaciones más específicas.\n",
75 | "\n",
76 | "Un ejemplo de estas funciones es `len()`, cuyo nombre proviene del inglés \"*length*\". Esta es, precisamente, una **función nativa** que permite contar la cantidad de caracteres o elementos en determinado string o lista, es decir, su largo (\"*its length*\"). Cuando la usamos sobre estos tipos de datos, no necesitamos importar ni definir nada, tan solo llamarla: `len(lista)`."
77 | ]
78 | },
79 | {
80 | "cell_type": "markdown",
81 | "metadata": {
82 | "id": "7VMi2e-TC5oW"
83 | },
84 | "source": [
85 | "A continuación se presentan algunos ejemplos de funciones nativas:"
86 | ]
87 | },
88 | {
89 | "cell_type": "markdown",
90 | "metadata": {
91 | "id": "TxuWGj_kDM6e"
92 | },
93 | "source": [
94 | "\n",
95 | "|Nombre |Entrada | Salida | Proceso |\n",
96 | "|:------------:|:-----------------------|------------|----------------------| \n",
97 | "|`int(x)` |Un número o string numérico|Un número|Devuelve un número entero| \n",
98 | "|`float(x)` |Un número o string numérico|Un número|Devuelve un número flotante|\n",
99 | "|`bool(x)` |Un dato|Un booleano|Devuelve `False` si el dato es vacío, de lo contrario entrega `True`|\n",
100 | "|`list(x)` |Un tipo de dato iterable| Una lista|Convierte los datos iterables en elementos de la lista, o, si no hay datos, genera una lista vacía|\n",
101 | "|`str(x)` |Un dato|Un string|Convierte el dato en un string|\n",
102 | "|`abs(x)` |Un número|Un número|Devuelve el valor absoluto de un número|\n",
103 | "|`pow(x, y)` |Dos números|Un número|Equivale a realizar x**y|\n",
104 | "|`max(x)` |Un elemento iterable|Un elemento|Devuelve el elemento de mayor valor del elemento iterable|\n",
105 | "|`min(x)` |Un elemento iterable|Un elemento|Devuelve el elemento de menor valor del elemento iterable|\n",
106 | "|`round(x, y)` |Un flotante (x) y un entero (y)|Un flotante|Devuelve el número x redondeado a la cantidad de decimales indicada (y)"
107 | ]
108 | },
109 | {
110 | "cell_type": "code",
111 | "execution_count": null,
112 | "metadata": {
113 | "colab": {
114 | "base_uri": "https://localhost:8080/"
115 | },
116 | "executionInfo": {
117 | "elapsed": 221,
118 | "status": "ok",
119 | "timestamp": 1654405192487,
120 | "user": {
121 | "displayName": "Alfredo Gonzalezf",
122 | "userId": "10271437243951850394"
123 | },
124 | "user_tz": 240
125 | },
126 | "id": "eDcE7nReNxRV",
127 | "outputId": "989ffd17-7810-464e-98ac-e98e5847c0a1"
128 | },
129 | "outputs": [
130 | {
131 | "name": "stdout",
132 | "output_type": "stream",
133 | "text": [
134 | "número entero 45\n",
135 | "número flotante 45.0\n",
136 | "booleano True\n"
137 | ]
138 | }
139 | ],
140 | "source": [
141 | "# Entrada\n",
142 | "numero_string = \"45\"\n",
143 | "\n",
144 | "# Procesamiento\n",
145 | "numero_entero = int(numero_string)\n",
146 | "numero_flotante = float(numero_string)\n",
147 | "booleano = bool(numero_string)\n",
148 | "\n",
149 | "# Salida\n",
150 | "print(\"número entero\", numero_entero)\n",
151 | "print(\"número flotante\", numero_flotante)\n",
152 | "print(\"booleano\", booleano)"
153 | ]
154 | },
155 | {
156 | "cell_type": "code",
157 | "execution_count": 3,
158 | "metadata": {
159 | "colab": {
160 | "base_uri": "https://localhost:8080/"
161 | },
162 | "executionInfo": {
163 | "elapsed": 11,
164 | "status": "ok",
165 | "timestamp": 1684636014811,
166 | "user": {
167 | "displayName": "Luciano Hidalgo",
168 | "userId": "01581468828685444889"
169 | },
170 | "user_tz": 240
171 | },
172 | "id": "DwqYxkQZO-bZ",
173 | "outputId": "709390c6-db4c-424f-d74d-f8cd0bd9080c"
174 | },
175 | "outputs": [
176 | {
177 | "name": "stdout",
178 | "output_type": "stream",
179 | "text": [
180 | "número texto 123456789\n",
181 | "lista de números ['1', '2', '3', '4', '5', '6', '7', '8', '9']\n"
182 | ]
183 | }
184 | ],
185 | "source": [
186 | "# Entrada\n",
187 | "numero = 123456789\n",
188 | "\n",
189 | "# Procesamiento\n",
190 | "numero_texto = str(numero)\n",
191 | "# Nótese que esta función no se puede aplicar directamente sobre el número:\n",
192 | "numero_lista = list(numero_texto)\n",
193 | "\n",
194 | "# Salida\n",
195 | "print(\"número texto\", numero_texto)\n",
196 | "print(\"lista de números\", numero_lista)"
197 | ]
198 | },
199 | {
200 | "cell_type": "code",
201 | "execution_count": 4,
202 | "metadata": {
203 | "colab": {
204 | "base_uri": "https://localhost:8080/"
205 | },
206 | "executionInfo": {
207 | "elapsed": 5,
208 | "status": "ok",
209 | "timestamp": 1684636015760,
210 | "user": {
211 | "displayName": "Luciano Hidalgo",
212 | "userId": "01581468828685444889"
213 | },
214 | "user_tz": 240
215 | },
216 | "id": "sFlUDy5yPb_a",
217 | "outputId": "276e2edb-c13a-453d-98d5-bcba09016180"
218 | },
219 | "outputs": [
220 | {
221 | "name": "stdout",
222 | "output_type": "stream",
223 | "text": [
224 | "valor absoluto 5\n",
225 | "potencia 125\n"
226 | ]
227 | }
228 | ],
229 | "source": [
230 | "# Entrada\n",
231 | "numero = -5\n",
232 | "\n",
233 | "# Procesamiento\n",
234 | "numero_absoluto = abs(numero)\n",
235 | "exponente = pow(numero_absoluto, 3)\n",
236 | "\n",
237 | "# Salida\n",
238 | "print(\"valor absoluto\", numero_absoluto)\n",
239 | "print(\"potencia\", exponente)"
240 | ]
241 | },
242 | {
243 | "cell_type": "code",
244 | "execution_count": 5,
245 | "metadata": {
246 | "colab": {
247 | "base_uri": "https://localhost:8080/"
248 | },
249 | "executionInfo": {
250 | "elapsed": 6,
251 | "status": "ok",
252 | "timestamp": 1684636014049,
253 | "user": {
254 | "displayName": "Luciano Hidalgo",
255 | "userId": "01581468828685444889"
256 | },
257 | "user_tz": 240
258 | },
259 | "id": "JyfzDfxTP7S1",
260 | "outputId": "b39d214b-4cb3-4f58-a4df-d474a0cabaad"
261 | },
262 | "outputs": [
263 | {
264 | "name": "stdout",
265 | "output_type": "stream",
266 | "text": [
267 | "valor mínimo 2\n",
268 | "valor máximo 125\n"
269 | ]
270 | }
271 | ],
272 | "source": [
273 | "# Entrada\n",
274 | "lista_numeros = [4, 58, 6, 3, 125, 7, 5, 2, 8, 64, 65, 10]\n",
275 | "\n",
276 | "# Procesamiento\n",
277 | "elemento_minimo = min(lista_numeros)\n",
278 | "elemento_maximo = max(lista_numeros)\n",
279 | "\n",
280 | "# Salida\n",
281 | "print(\"valor mínimo\", elemento_minimo)\n",
282 | "print(\"valor máximo\", elemento_maximo)"
283 | ]
284 | },
285 | {
286 | "cell_type": "code",
287 | "execution_count": 6,
288 | "metadata": {
289 | "colab": {
290 | "base_uri": "https://localhost:8080/"
291 | },
292 | "executionInfo": {
293 | "elapsed": 6,
294 | "status": "ok",
295 | "timestamp": 1684636014050,
296 | "user": {
297 | "displayName": "Luciano Hidalgo",
298 | "userId": "01581468828685444889"
299 | },
300 | "user_tz": 240
301 | },
302 | "id": "1mTaHvhCQprc",
303 | "outputId": "6430d2f9-7060-4e93-bf56-4050e45b0a6e"
304 | },
305 | "outputs": [
306 | {
307 | "name": "stdout",
308 | "output_type": "stream",
309 | "text": [
310 | "número original 25.4627\n",
311 | "número redondeado 25.463\n",
312 | "número redondeado a entero 25\n"
313 | ]
314 | }
315 | ],
316 | "source": [
317 | "# Entrada\n",
318 | "numero = 25.4627\n",
319 | "\n",
320 | "# Procesamiento\n",
321 | "redondear = round(numero, 3)\n",
322 | "# Si no se da el segundo parámetro, redondea a entero\n",
323 | "numero_entero = round(numero)\n",
324 | "\n",
325 | "# Salida\n",
326 | "print(\"número original\", numero)\n",
327 | "print(\"número redondeado\", redondear)\n",
328 | "print(\"número redondeado a entero\", numero_entero)"
329 | ]
330 | },
331 | {
332 | "cell_type": "markdown",
333 | "metadata": {
334 | "id": "O2Yzqk3FH0Np"
335 | },
336 | "source": [
337 | "El cuadro anterior describe solo algunas de las funciones nativas que Python posee. Para poder conocer una mayor cantidad de este tipo de funciones, se recomienda visitar el siguiente enlace: [Funciones Nativas](https://docs.python.org/es/3.10/library/functions.html)"
338 | ]
339 | },
340 | {
341 | "cell_type": "markdown",
342 | "metadata": {
343 | "id": "Ryp1m8vRIUde"
344 | },
345 | "source": [
346 | "Para ilustrar la ventaja de usar algunas funciones nativas de Python, se presenta el siguiente ejercicio, el cual se resuelve de dos maneras: en primer lugar, usando iteración y luego aprovechando algunas funciones nativas."
347 | ]
348 | },
349 | {
350 | "cell_type": "markdown",
351 | "metadata": {
352 | "id": "zUftlji6IqB5"
353 | },
354 | "source": [
355 | "### Ejercicio"
356 | ]
357 | },
358 | {
359 | "cell_type": "markdown",
360 | "metadata": {
361 | "id": "JmkRxU2yItdi"
362 | },
363 | "source": [
364 | "Se solicita sumar la cantidad de números que se tienen en una lista"
365 | ]
366 | },
367 | {
368 | "cell_type": "code",
369 | "execution_count": 7,
370 | "metadata": {
371 | "colab": {
372 | "base_uri": "https://localhost:8080/"
373 | },
374 | "executionInfo": {
375 | "elapsed": 402,
376 | "status": "ok",
377 | "timestamp": 1684636108352,
378 | "user": {
379 | "displayName": "Luciano Hidalgo",
380 | "userId": "01581468828685444889"
381 | },
382 | "user_tz": 240
383 | },
384 | "id": "l2kyxxwdI2pX",
385 | "outputId": "041b4f2e-7f2d-4e07-bbd0-b4b0047be760"
386 | },
387 | "outputs": [
388 | {
389 | "name": "stdout",
390 | "output_type": "stream",
391 | "text": [
392 | "\n",
393 | "La suma de los números ingresados es 45\n"
394 | ]
395 | }
396 | ],
397 | "source": [
398 | "# Ejemplo_06: solución utilizando ciclos\n",
399 | "\n",
400 | "# Entrada\n",
401 | "lista_numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
402 | "\n",
403 | "# Procesamiento\n",
404 | "i = 0\n",
405 | "suma = 0\n",
406 | "\n",
407 | "while i < len(lista_numeros):\n",
408 | " suma = suma + lista_numeros[i]\n",
409 | " i = i + 1\n",
410 | "\n",
411 | "# Salida\n",
412 | "print(\"\\nLa suma de los números ingresados es\", suma)"
413 | ]
414 | },
415 | {
416 | "cell_type": "code",
417 | "execution_count": 8,
418 | "metadata": {
419 | "colab": {
420 | "base_uri": "https://localhost:8080/"
421 | },
422 | "executionInfo": {
423 | "elapsed": 6,
424 | "status": "ok",
425 | "timestamp": 1684636109902,
426 | "user": {
427 | "displayName": "Luciano Hidalgo",
428 | "userId": "01581468828685444889"
429 | },
430 | "user_tz": 240
431 | },
432 | "id": "yIy-DyEZJySY",
433 | "outputId": "58bd5db1-e330-4918-8b49-346b671e2394"
434 | },
435 | "outputs": [
436 | {
437 | "name": "stdout",
438 | "output_type": "stream",
439 | "text": [
440 | "\n",
441 | "La suma de los números ingresados es 45\n"
442 | ]
443 | }
444 | ],
445 | "source": [
446 | "# Ejemplo_07: solución utilizando funciones nativas\n",
447 | "\n",
448 | "# Entrada\n",
449 | "lista_numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
450 | "\n",
451 | "# Procesamiento\n",
452 | "suma = sum(lista_numeros)\n",
453 | "\n",
454 | "# Salida\n",
455 | "print(\"\\nLa suma de los números ingresados es\", suma)"
456 | ]
457 | },
458 | {
459 | "cell_type": "markdown",
460 | "metadata": {
461 | "id": "DS6_dVWvSU3q"
462 | },
463 | "source": [
464 | "## Funciones Importadas"
465 | ]
466 | },
467 | {
468 | "cell_type": "markdown",
469 | "metadata": {
470 | "id": "1uf0oyqxSWkm"
471 | },
472 | "source": [
473 | "Dado que las funciones nativas resuelven problemas más o menos generales, para problemas más específicos, es necesario saber cómo trabajar con **módulos**.\n",
474 | "\n",
475 | "Las funciones de estos módulos, si bien vienen instaladas junto a Python, no son reconocidas por este automáticamente para poder usarse, por lo que debemos acceder **explícitamente al módulo** para poder usarlas (esto es así, pues Python es un lenguaje de programación general, bien podríamos hacer un programa para calcular impuestos, como un videojuego: ¿qué sentido tiene tener cargados en la memoria elementos para interfaces gráficas y manejo de elementos 3D, si solo necesitamos operaciones matemáticas sencillas para el cálculo de los impuestos? Sería un desperdicio de recursos)."
476 | ]
477 | },
478 | {
479 | "cell_type": "markdown",
480 | "metadata": {
481 | "id": "I7UayYXFULhx"
482 | },
483 | "source": [
484 | "Un módulo indispensable para un estudiante de ingeniería es `math`, el cual contiene muchas de las funciones matemáticas y trigonométricas que se requieren usualmente.\n",
485 | "\n",
486 | "Algunas de las funciones que se pueden encontrar en el módulo `math` son la siguientes:"
487 | ]
488 | },
489 | {
490 | "cell_type": "markdown",
491 | "metadata": {
492 | "id": "3P5ECkbibsOW"
493 | },
494 | "source": [
495 | "|Nombre |Descripción |\n",
496 | "|:------------:|:-----------| \n",
497 | "|`sin(x)`|Obtiene el seno de un ángulo x expresado en radianes|\n",
498 | "|`cos(x)`|Obtiene el coseno de un ángulo x expresado en radianes|\n",
499 | "|`tan(x)`|Obtiene la tangente de un ángulo x expresado en radianes|\n",
500 | "|`exp(x)`|Obtiene el número e elevado a x|\n",
501 | "|`log(x)`|Obtiene el logaritmo natural (base $e$) de x|\n",
502 | "|`log10(x)`|Obtiene el logaritmo en base 10 de x|\n",
503 | "|`sqrt(x)`|Obtiene la raíz cuadrada de x|\n",
504 | "|`degrees(x)`|Convierte a grados un ángulo x expresado en radianes|\n",
505 | "|`radians(x)`|Convierte a radianes un ángulo x expresado en grados|"
506 | ]
507 | },
508 | {
509 | "cell_type": "markdown",
510 | "metadata": {
511 | "id": "0k4ZYJC1eWgn"
512 | },
513 | "source": [
514 | "A continuación, se presenta un ejemplo donde se calculará el coseno de un ángulo dado por el usuario:"
515 | ]
516 | },
517 | {
518 | "cell_type": "code",
519 | "execution_count": 9,
520 | "metadata": {
521 | "colab": {
522 | "base_uri": "https://localhost:8080/",
523 | "height": 253
524 | },
525 | "executionInfo": {
526 | "elapsed": 4242,
527 | "status": "error",
528 | "timestamp": 1684636432414,
529 | "user": {
530 | "displayName": "Luciano Hidalgo",
531 | "userId": "01581468828685444889"
532 | },
533 | "user_tz": 240
534 | },
535 | "id": "Qdt-i81mfOgH",
536 | "outputId": "5c59e0f7-16d7-4c28-eb0d-f38ccb5e3758"
537 | },
538 | "outputs": [
539 | {
540 | "ename": "NameError",
541 | "evalue": "name 'radians' is not defined",
542 | "output_type": "error",
543 | "traceback": [
544 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
545 | "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
546 | "Cell \u001b[0;32mIn[9], line 6\u001b[0m\n\u001b[1;32m 2\u001b[0m angulo \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(\u001b[38;5;28minput\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFavor ingresar ángulo en grados: \u001b[39m\u001b[38;5;124m\"\u001b[39m))\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# Procesamiento\u001b[39;00m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;66;03m# Se trasforman los grados a radianes\u001b[39;00m\n\u001b[0;32m----> 6\u001b[0m radianes \u001b[38;5;241m=\u001b[39m \u001b[43mradians\u001b[49m(angulo)\n\u001b[1;32m 8\u001b[0m \u001b[38;5;66;03m# calcular coseno del ángulo\u001b[39;00m\n\u001b[1;32m 9\u001b[0m coseno \u001b[38;5;241m=\u001b[39m cos(radianes)\n",
547 | "\u001b[0;31mNameError\u001b[0m: name 'radians' is not defined"
548 | ]
549 | }
550 | ],
551 | "source": [
552 | "# Entrada\n",
553 | "angulo = int(input(\"Favor ingresar ángulo en grados: \"))\n",
554 | "\n",
555 | "# Procesamiento\n",
556 | "# Se trasforman los grados a radianes\n",
557 | "radianes = radians(angulo)\n",
558 | "\n",
559 | "# calcular coseno del ángulo\n",
560 | "coseno = cos(radianes)\n",
561 | "\n",
562 | "# Salida\n",
563 | "print(\"El coseno del ángulo\", angulo, \"es de\", coseno)"
564 | ]
565 | },
566 | {
567 | "cell_type": "markdown",
568 | "metadata": {
569 | "id": "4hJnkJ3Og7Ix"
570 | },
571 | "source": [
572 | "El error del **Ejemplo** se genera producto de que no se ha indicado a Python que tanto la función `radians()` como la función `cos()` pertenecen al módulo `math`, el cual debe ser importado."
573 | ]
574 | },
575 | {
576 | "cell_type": "markdown",
577 | "metadata": {
578 | "id": "IknxrbHYhTMa"
579 | },
580 | "source": [
581 | "### Importar Funciones"
582 | ]
583 | },
584 | {
585 | "cell_type": "markdown",
586 | "metadata": {
587 | "id": "1Tcp2u1_hWUh"
588 | },
589 | "source": [
590 | "Para realizar la importanción de funciones se pueden utilizar 4 alternativas:\n",
591 | "\n",
592 | "1. Importar solo el módulo ✔️\n",
593 | "2. Importar el módulo con un alias ✔️\n",
594 | "3. Importar solo las funciones requeridas del módulo ✔️\n",
595 | "4. Importar todas las funciones del módulo ❌"
596 | ]
597 | },
598 | {
599 | "cell_type": "markdown",
600 | "metadata": {
601 | "id": "rBZuJKPQib3P"
602 | },
603 | "source": [
604 | "#### 1. Importar solo el módulo"
605 | ]
606 | },
607 | {
608 | "cell_type": "markdown",
609 | "metadata": {
610 | "id": "498hw_aWihv2"
611 | },
612 | "source": [
613 | "Al realizar la importación de esta manera, se pueden utilizar todas las funciones del módulo importado siempre que se haga referencia al módulo de origen al momento de utilizar la función. Esto se consigue mediante la utilización de la palabra reservada **`import`**.\n",
614 | "\n",
615 | "```python\n",
616 | "import \n",
617 | "\n",
618 | ".funcion()\n",
619 | "```\n",
620 | "\n",
621 | "Para ilustrar este uso, se corrige el programa del ejemplo anterior."
622 | ]
623 | },
624 | {
625 | "cell_type": "code",
626 | "execution_count": 11,
627 | "metadata": {
628 | "colab": {
629 | "base_uri": "https://localhost:8080/"
630 | },
631 | "executionInfo": {
632 | "elapsed": 24317,
633 | "status": "ok",
634 | "timestamp": 1684636428180,
635 | "user": {
636 | "displayName": "Luciano Hidalgo",
637 | "userId": "01581468828685444889"
638 | },
639 | "user_tz": 240
640 | },
641 | "id": "HGmBUI5LjERo",
642 | "outputId": "0d28bf1c-db49-4cd0-8dc6-3e9dd971b6b9"
643 | },
644 | "outputs": [
645 | {
646 | "name": "stdout",
647 | "output_type": "stream",
648 | "text": [
649 | "El coseno del ángulo 45 es de 0.7071067811865476\n"
650 | ]
651 | }
652 | ],
653 | "source": [
654 | "#Importación de Funciones\n",
655 | "import math\n",
656 | "\n",
657 | "# Entrada\n",
658 | "angulo = int(input(\"Favor ingresar ángulo en grados: \"))\n",
659 | "\n",
660 | "# Procesamiento\n",
661 | "# Se trasforman los grados a radianes\n",
662 | "radianes = math.radians(angulo)\n",
663 | "\n",
664 | "# Calcular coseno del ángulo\n",
665 | "coseno = math.cos(radianes)\n",
666 | "\n",
667 | "# Salida\n",
668 | "print(\"El coseno del ángulo\", angulo, \"es de\", coseno)"
669 | ]
670 | },
671 | {
672 | "cell_type": "markdown",
673 | "metadata": {
674 | "id": "GY26QlYcldNt"
675 | },
676 | "source": [
677 | "#### 2. Importar el módulo con un alias"
678 | ]
679 | },
680 | {
681 | "cell_type": "markdown",
682 | "metadata": {
683 | "id": "Zt0qLvqilvP2"
684 | },
685 | "source": [
686 | "En este tipo de importación, se utiliza un alias (\"sobrenombre\") para llamar al módulo importado. De esta manera, se pueden utilizar todas las funciones siempre y cuando, al momento de llamarlas, se anteponga el alias a cada función. Esto se consigue mediante la utilización de la palabra reservada **`import`** en combinación con **`as`**.\n",
687 | "\n",
688 | "```\n",
689 | "import as \n",
690 | "\n",
691 | ".funcion()\n",
692 | "```\n",
693 | "\n",
694 | "Usando el mismo ejemplo:"
695 | ]
696 | },
697 | {
698 | "cell_type": "code",
699 | "execution_count": 9,
700 | "metadata": {
701 | "colab": {
702 | "base_uri": "https://localhost:8080/"
703 | },
704 | "executionInfo": {
705 | "elapsed": 3320,
706 | "status": "ok",
707 | "timestamp": 1684636449603,
708 | "user": {
709 | "displayName": "Luciano Hidalgo",
710 | "userId": "01581468828685444889"
711 | },
712 | "user_tz": 240
713 | },
714 | "id": "8sLbnWVKm7li",
715 | "outputId": "582c7092-e892-4ed5-a279-26137cd856d4"
716 | },
717 | "outputs": [
718 | {
719 | "name": "stdout",
720 | "output_type": "stream",
721 | "text": [
722 | "Favor ingresar ángulo en grados: 45\n",
723 | "El coseno del ángulo 45 es de 0.7071067811865476\n"
724 | ]
725 | }
726 | ],
727 | "source": [
728 | "# Importación de Funciones\n",
729 | "import math as m\n",
730 | "\n",
731 | "# Entrada\n",
732 | "angulo = int(input(\"Favor ingresar ángulo en grados: \"))\n",
733 | "\n",
734 | "# Procesamiento\n",
735 | "# Se trasforman los grados a radianes\n",
736 | "radianes = m.radians(angulo)\n",
737 | "\n",
738 | "# Calcular coseno del ángulo\n",
739 | "coseno = m.cos(radianes)\n",
740 | "\n",
741 | "# Salida\n",
742 | "print(\"El coseno del ángulo\", angulo, \"es de\", coseno)"
743 | ]
744 | },
745 | {
746 | "cell_type": "markdown",
747 | "metadata": {},
748 | "source": [
749 | "Los alias sirven especialmente en ocasiones en las que el nombre de un módulo es muy grande, estamos importando un submódulo o hacemos referencia a algo de manera muy seguida. Es posible que algunas convenciones utilicen alias clásicos, como por ejemplo, es común (aunque no frecuente) encontrar el módulo `math` bajo el alias mostrado en el ejemplo, `m`; o el módulo para realizar gráficos, `matplotlib` (que no viene con Python y debe instalarse aparte), que tiene un submódulo llamado `pyplot` que define las principales interfaces y funciones para graficar, se suele abreviar con la línea:\n",
750 | "```python\n",
751 | "import matplotlib.pyplot as plt\n",
752 | "```"
753 | ]
754 | },
755 | {
756 | "cell_type": "markdown",
757 | "metadata": {
758 | "id": "Z8P1Nsj_nGR2"
759 | },
760 | "source": [
761 | "#### 3. Importar solo las funciones requeridas del módulo"
762 | ]
763 | },
764 | {
765 | "cell_type": "markdown",
766 | "metadata": {
767 | "id": "w5u4h2gAnMNg"
768 | },
769 | "source": [
770 | "Al realizar la importación de esta manera, no se requiere hacer mención al módulo de origen. No obstante, solo se pueden utilizar directamente las funciones indicadas al momento de realizar la importación. Esto se consigue mediante la utilización de las palabras reservadas **`from`** e **`import`**.\n",
771 | "\n",
772 | "```\n",
773 | "from import , , \n",
774 | "```\n",
775 | "\n",
776 | "En este caso, el ejemplo original quedaría como:"
777 | ]
778 | },
779 | {
780 | "cell_type": "code",
781 | "execution_count": 12,
782 | "metadata": {
783 | "colab": {
784 | "base_uri": "https://localhost:8080/"
785 | },
786 | "executionInfo": {
787 | "elapsed": 18915,
788 | "status": "ok",
789 | "timestamp": 1684636500749,
790 | "user": {
791 | "displayName": "Luciano Hidalgo",
792 | "userId": "01581468828685444889"
793 | },
794 | "user_tz": 240
795 | },
796 | "id": "BYM8_Rw7oCoY",
797 | "outputId": "39206376-a9ca-4470-8575-c0e5cc3332e8"
798 | },
799 | "outputs": [
800 | {
801 | "name": "stdout",
802 | "output_type": "stream",
803 | "text": [
804 | "El coseno del ángulo 45 es de 0.7071067811865476\n"
805 | ]
806 | }
807 | ],
808 | "source": [
809 | "# Importación de Funciones\n",
810 | "from math import radians, cos\n",
811 | "\n",
812 | "# Entrada\n",
813 | "angulo = int(input(\"Favor ingresar ángulo en grados: \"))\n",
814 | "\n",
815 | "# Procesamiento\n",
816 | "# Se trasforman los grados a radianes\n",
817 | "radianes = radians(angulo)\n",
818 | "\n",
819 | "# Calcular coseno del ángulo\n",
820 | "coseno = cos(radianes)\n",
821 | "\n",
822 | "# Salida\n",
823 | "print(\"El coseno del ángulo\", angulo, \"es de\", coseno)"
824 | ]
825 | },
826 | {
827 | "cell_type": "markdown",
828 | "metadata": {
829 | "id": "MEOFr4E_D0cw"
830 | },
831 | "source": [
832 | "Esta forma de importar debe ser utilizada con cuidado, pues, como se ve, las funciones son llamadas como si fuesen funciones nativas y si no tenemos cuidado, podemos reemplazar variables locales u otras importaciones."
833 | ]
834 | },
835 | {
836 | "cell_type": "markdown",
837 | "metadata": {
838 | "id": "d0_6LKaYolcT"
839 | },
840 | "source": [
841 | "#### 4. Importar todas las funciones del módulo"
842 | ]
843 | },
844 | {
845 | "cell_type": "markdown",
846 | "metadata": {
847 | "id": "bPTZ37GdoqgO"
848 | },
849 | "source": [
850 | "En este tipo de importación, no se requiere hacer referencias al módulo de origen y se pueden utilizar directamente todas las funciones del módulo importado. Esto se consigue mediante la utilización de las palabras reservadas **`from`** e **`import`** más un `*`.\n",
851 | "\n",
852 | "```\n",
853 | "from import *\n",
854 | "```"
855 | ]
856 | },
857 | {
858 | "cell_type": "code",
859 | "execution_count": 13,
860 | "metadata": {
861 | "colab": {
862 | "base_uri": "https://localhost:8080/"
863 | },
864 | "executionInfo": {
865 | "elapsed": 4100,
866 | "status": "ok",
867 | "timestamp": 1684636571290,
868 | "user": {
869 | "displayName": "Luciano Hidalgo",
870 | "userId": "01581468828685444889"
871 | },
872 | "user_tz": 240
873 | },
874 | "id": "vmdVH4WypVAU",
875 | "outputId": "cc7e929d-577a-4fed-d9b8-9dbcd03fa6cc"
876 | },
877 | "outputs": [
878 | {
879 | "name": "stdout",
880 | "output_type": "stream",
881 | "text": [
882 | "El coseno del ángulo 90 es de 6.123233995736766e-17\n"
883 | ]
884 | }
885 | ],
886 | "source": [
887 | "# Importación de Funciones\n",
888 | "from math import *\n",
889 | "\n",
890 | "# Entrada\n",
891 | "angulo = int(input(\"Favor ingresar ángulo en grados: \"))\n",
892 | "\n",
893 | "# Procesamiento\n",
894 | "# Se trasforman los grados a radianes\n",
895 | "radianes = radians(angulo)\n",
896 | "\n",
897 | "# calcular coseno del ángulo\n",
898 | "coseno = cos(radianes)\n",
899 | "\n",
900 | "# Salida\n",
901 | "print(\"El coseno del ángulo\", angulo, \"es de\", coseno)"
902 | ]
903 | },
904 | {
905 | "cell_type": "markdown",
906 | "metadata": {
907 | "id": "vWYxgyOlD0cy"
908 | },
909 | "source": [
910 | "Este mecanismo **debe evitarse**, pues genera problemas de alcance (o *scope*) pues, como normalmente los módulos poseen múltiples funciones, si importo con este método más de un módulo, podría encontrarme con dos funciones con el mismo nombre o también con módulos que tienen funciones o constantes con el mismo nombre que mis variables, y Python no podría resolver ese llamado correctamente. **En general este mecanismo existe pero se considera una mala práctica de programación, por lo que se recomienda no usarlo bajo ningún contexto.**"
911 | ]
912 | },
913 | {
914 | "cell_type": "markdown",
915 | "metadata": {
916 | "id": "fn-0UGNyD0cy"
917 | },
918 | "source": [
919 | "#### Módulo `random`"
920 | ]
921 | },
922 | {
923 | "cell_type": "markdown",
924 | "metadata": {
925 | "id": "6vdJqN09qwGq"
926 | },
927 | "source": [
928 | "Otro módulo útil que Python trae por defecto es **`random`**, el cual permite la generación de números pseudoaleatorios (es decir, que se genera con un método que *parece* aleatorio).\n",
929 | "\n",
930 | "Alguna de las funciones que podemos usar se presentan a continuación:"
931 | ]
932 | },
933 | {
934 | "cell_type": "markdown",
935 | "metadata": {
936 | "id": "zroIpyzLrx2p"
937 | },
938 | "source": [
939 | "|Nombre |Descripción |\n",
940 | "|:------------:|:-----------| \n",
941 | "|`randint(x, y)`|Devuelve un numero entero pseudoaleatorio entre los valores indicados (ambos valores inclusive)|\n",
942 | "|`choice(l)`|Obtiene un elemento pseudoaleatorio de un tipo de dato iterable|\n",
943 | "|`shuffle(l)`|Cambia el orden *in situ* de los elementos que conforman un tipo de dato iterable|\n",
944 | "|`random()`|Devuelve un número flotante pseudoaleatorio entre 0 y 1, sin incluir el 1 |"
945 | ]
946 | },
947 | {
948 | "cell_type": "code",
949 | "execution_count": 14,
950 | "metadata": {
951 | "colab": {
952 | "base_uri": "https://localhost:8080/"
953 | },
954 | "executionInfo": {
955 | "elapsed": 6,
956 | "status": "ok",
957 | "timestamp": 1684636970566,
958 | "user": {
959 | "displayName": "Luciano Hidalgo",
960 | "userId": "01581468828685444889"
961 | },
962 | "user_tz": 240
963 | },
964 | "id": "js7iFAEVs13y",
965 | "outputId": "95488440-524d-463b-e5e7-31dcd9824631"
966 | },
967 | "outputs": [
968 | {
969 | "name": "stdout",
970 | "output_type": "stream",
971 | "text": [
972 | "número pseudoaleatorio 9\n",
973 | "\n",
974 | "letra pseudoaleatoria o\n"
975 | ]
976 | }
977 | ],
978 | "source": [
979 | "# Importación de Funciones\n",
980 | "from random import randint, choice\n",
981 | "\n",
982 | "# Entrada\n",
983 | "numero_inicial = 3\n",
984 | "numero_final = 10\n",
985 | "letras = \"lgtiqbcgdio\"\n",
986 | "\n",
987 | "# Procesamiento\n",
988 | "numero_aleatorio = randint(numero_inicial, numero_final)\n",
989 | "letra_aleatoria = choice(letras)\n",
990 | "\n",
991 | "# Salida\n",
992 | "print(\"número pseudoaleatorio\", numero_aleatorio)\n",
993 | "print(\"\\nletra pseudoaleatoria\", letra_aleatoria)"
994 | ]
995 | },
996 | {
997 | "cell_type": "code",
998 | "execution_count": 15,
999 | "metadata": {
1000 | "colab": {
1001 | "base_uri": "https://localhost:8080/"
1002 | },
1003 | "executionInfo": {
1004 | "elapsed": 369,
1005 | "status": "ok",
1006 | "timestamp": 1684636967605,
1007 | "user": {
1008 | "displayName": "Luciano Hidalgo",
1009 | "userId": "01581468828685444889"
1010 | },
1011 | "user_tz": 240
1012 | },
1013 | "id": "a9NtyUfxvR_V",
1014 | "outputId": "6fd533f9-e973-4c5a-e534-2afd2745c9cb"
1015 | },
1016 | "outputs": [
1017 | {
1018 | "name": "stdout",
1019 | "output_type": "stream",
1020 | "text": [
1021 | "Lista vocales pseudoaleatorio ['e', 'i', 'o', 'a', 'u']\n",
1022 | "\n",
1023 | "Número pseudoaleatorio 0.541937815026746\n"
1024 | ]
1025 | }
1026 | ],
1027 | "source": [
1028 | "\n",
1029 | "# Importación de Funciones\n",
1030 | "from random import shuffle, random\n",
1031 | "\n",
1032 | "# Entrada\n",
1033 | "vocales = [\"a\", \"e\", \"i\", \"o\", \"u\"]\n",
1034 | "\n",
1035 | "# Procesamiento\n",
1036 | "# Nótese que shuffle no produce salida, sino que modifica la lista internamente\n",
1037 | "shuffle(vocales)\n",
1038 | "numero_aleatorio = random()\n",
1039 | "\n",
1040 | "# Salida\n",
1041 | "print(\"Lista vocales pseudoaleatorio\", vocales)\n",
1042 | "print(\"\\nNúmero pseudoaleatorio\", numero_aleatorio)"
1043 | ]
1044 | },
1045 | {
1046 | "cell_type": "markdown",
1047 | "metadata": {
1048 | "id": "Nmynv3p-MFP1"
1049 | },
1050 | "source": [
1051 | "Usamos el término *pseudoaleatorio* y no aleatorio, debido a que, cuando un computador ejecuta un proceso (aún el de escoger un número *al azar*), este comportamiento no puede ser aleatorio. Dado que los computadores son dispositivos determinísticos, es decir, su comportamiento es **completamente predecible**, en la práctica resulta extermadamente difícil que hagan una elección al azar.\n",
1052 | "\n",
1053 | "Por ello, los procesos que generan números pseudoaleatorios, en la práctica son algoritmos matemáticos cuyas salidas son *suficientemente difíciles* de predecir, pero que, si tenemos suficientes datos, podemos predecir con absoluta certeza. Como la aleatoreidad es muy importante, por ejemplo, en criptografía, siempre se están usando técnicas para aumentar la aleatoreidad de los valores, como por ejemplo, el mecanismo que utiliza [Cloudflare](https://www.cloudflare.com/es-es/learning/ssl/lava-lamp-encryption/)."
1054 | ]
1055 | },
1056 | {
1057 | "cell_type": "markdown",
1058 | "metadata": {
1059 | "id": "7BOOdsGzxtf9"
1060 | },
1061 | "source": [
1062 | "### Buenas Prácticas en Importaciones"
1063 | ]
1064 | },
1065 | {
1066 | "cell_type": "markdown",
1067 | "metadata": {
1068 | "id": "X0-LSDSBx3qk"
1069 | },
1070 | "source": [
1071 | "Se debe tener presente que, para efectos de este curso introductorio a la programación, se consideran válidas las opciones 1,2 y 3 de importación. \n",
1072 | "\n",
1073 | "Otra cosas a considerar son las siguientes:\n",
1074 | "* Las importaciones de módulos siempre deben ser las **primeras líneas del código funcionales del código** (después de los comentarios con la identificación del programa). Esto se debe a que cuando alguien quiera usar el programa debe ser capaz de identificar las dependencias que este pueda tener con otros **módulos**.\n",
1075 | "\n",
1076 | "* Si se importa más de un módulo, estas importaciones deben ser siempre iguales, vale decir, **deben importarse con la misma sintaxis**.\n",
1077 | "\n",
1078 | "* Cada módulo a importar debe ir en una **línea separada**.\n",
1079 | " ```python\n",
1080 | " import random\n",
1081 | " import math\n",
1082 | " ```\n",
1083 | "* Si se importan varias funciones de un mismo módulo, estas pueden ir separadas por comas.\n",
1084 | " ```python\n",
1085 | " from math import sin, cos, tan\n",
1086 | " ```"
1087 | ]
1088 | },
1089 | {
1090 | "cell_type": "markdown",
1091 | "metadata": {
1092 | "id": "pQxW4kYxzJqF"
1093 | },
1094 | "source": [
1095 | "### Módulos Externos"
1096 | ]
1097 | },
1098 | {
1099 | "cell_type": "markdown",
1100 | "metadata": {
1101 | "id": "kfadQ2HXzMk8"
1102 | },
1103 | "source": [
1104 | "Junto con Python, normalmente se instalan varios módulos pertenecientes a la **biblioteca estándar de Python**. No obstante, esos no son todos los módulos existentes, puesto que varios usuarios (y a veces organizaciones como Google o Facebook) han creado, y disponibilizado a la comunidad, sus propios módulos que facilitan la realización de algunas tareas en específico.\n",
1105 | "\n",
1106 | "Por lo anterior, estos módulos no vienen incorporados con el intérprete de Python y deben ser instalados de manera manual. Principalmente existen dos mecanismos para realizar la instalación: si el módulo ha sido compartido con un programa instalador, conviene seguir las instrucciones de este, pero, en general, los módulos pueden ser manejados con el programa `pip`."
1107 | ]
1108 | },
1109 | {
1110 | "cell_type": "markdown",
1111 | "metadata": {},
1112 | "source": [
1113 | "#### Instalación de Módulos con `pip`"
1114 | ]
1115 | },
1116 | {
1117 | "cell_type": "markdown",
1118 | "metadata": {},
1119 | "source": [
1120 | "El programa `pip` es el instalador de módulos preferido para Python y ha sido diseñado para utilizarse desde la línea de comandos del sistema (la \"consola del sistema\", como CMD o PowerShell, en Windows; bash, tsh, zsh, csh, etc., en Linux u otros sistemas basados en Unix, etc.). En Windows, la consola se puede acceder abriendo el menú inicio con el botón de Windows (el que tiene el logo del sistema) y escribiendo \"cmd\", o bien \"powershell\", según la preferencia, y ejecutando la opción que se despliega. Alternativamente, con la combinación de botones Windows + R, se abre el cuadro de diálogo de \"Ejecutar\" de Windows, donde podemos escribir directamente el nombre del programa cmd y ejecutarlo.\n",
1121 | "\n",
1122 | "Una vez en la consola del sistema, debemos ejecutar el comando con la siguiente sintaxis:\n",
1123 | "```cmd\n",
1124 | "C:\\> pip install \n",
1125 | "```\n",
1126 | "donde `` se reemplaza con el nombre del módulo a instalar. En el contexto de ejecutar instrucciones en un computador, cuando escribimos \"`C:\\>`\", nos referimos a comandos que van en la consola de Windows. El mensaje exacto que esta muestra puede variar, según el sistema en el que estemos o la carpeta seleccionada. Por ejemplo:\n",
1127 | "\n",
1128 | "```cmd\n",
1129 | "C:\\> pip install matplotlib\n",
1130 | "```\n",
1131 | "\n",
1132 | "Instalará la biblioteca [`matplotlib`](https://matplotlib.org/), una biblioteca de visualización de datos ampliamente usada por la comunidad científica e ingenieril. Esta biblioteca requiere de otras para funcionar: el mismo `pip` se encarga de buscar cuáles son, cuáles no están instaladas en nuestro sistema, e instalarlas, si hiciera falta. Una vez instalada la biblioteca, quedará disponible para acceder a ella como cualquier otra:\n",
1133 | "\n",
1134 | "```python\n",
1135 | "import matplotlib.pyplot as plt\n",
1136 | "```"
1137 | ]
1138 | },
1139 | {
1140 | "cell_type": "markdown",
1141 | "metadata": {},
1142 | "source": [
1143 | "#### Requisitos para utilizar `pip`"
1144 | ]
1145 | },
1146 | {
1147 | "cell_type": "markdown",
1148 | "metadata": {},
1149 | "source": [
1150 | "El programa `pip` se puede utilizar como hemos señalado acá si se cumplen tres condiciones:\n",
1151 | "1. Que esté instalado como parte de Python (el instalador tiene una opción que chequear para instalarlo, pero viene seleccionado en las opciones por defecto).\n",
1152 | "2. Que tengamos conexión a internet (pues busca los módulos *online*).\n",
1153 | "3. Que hayamos instalado Python agregándolo al `PATH` (también es de las opciones del instalador).\n",
1154 | "\n",
1155 | "Este último paso lo podemos confirmar directamente cuando chequeamos la casilla que dice \"Add Python to `PATH`\". Una vez cumplidos estos requisitos, podremos instalar los módulos que necesitemos.\n",
1156 | "\n",
1157 | "Si te preguntas qué es `PATH`, es una *variable de entorno*, variables que manejan los sistemas operativos para almacenar ciertos parámetros para ejecutar sus labores o los programas. En particular, la variable `PATH` contiene la lista de carpetas donde el sistema buscará los programas que ejecutemos en la consola."
1158 | ]
1159 | },
1160 | {
1161 | "cell_type": "markdown",
1162 | "metadata": {
1163 | "id": "suPN_vfmD0c4"
1164 | },
1165 | "source": [
1166 | "# Bibliografía\n",
1167 | "\n",
1168 | "## Funciones nativas\n",
1169 | "\n",
1170 | "Python Software Foundation. (2022a, 4 agosto). *Built-in Functions*. Python 3.10.6 documentation. Recuperado 4 de agosto de 2022, de https://docs.python.org/3/library/functions.html\n",
1171 | "\n",
1172 | "## Módulos\n",
1173 | "\n",
1174 | "Ceder, V. L. (2010). The import statement. En *The Quick Python Book* (2.a ed., p. 119). Manning Publications.\n",
1175 | "\n",
1176 | "GeeksforGeeks. (2022, 26 julio). *Import module in Python*. Recuperado 4 de agosto de 2022, de https://www.geeksforgeeks.org/import-module-python/\n",
1177 | "\n",
1178 | "Python Software Foundation. (2022b, agosto 4). *Modules*. Python 3.10.6 documentation. Recuperado 4 de agosto de 2022, de https://docs.python.org/3/tutorial/modules.html\n",
1179 | "\n",
1180 | "## Aleatoriedad y Pseudoaleatoriedad\n",
1181 | "Computer Hope (2020, diciembre 31). *Pseudorandom*. Dictionary. Recuperado el 16 de abril de 2023, de: https://www.computerhope.com/jargon/p/pseudo-random.htm.\n",
1182 | "\n",
1183 | "## Biblioteca estándar de Python\n",
1184 | "\n",
1185 | "Python Software Foundation. (2022c, agosto 4). *The Python Standard Library*. Python 3.10.6 documentation. Recuperado 4 de agosto de 2022, de https://docs.python.org/3/library/index.html\n",
1186 | "\n",
1187 | "## Formato y buenas prácticas\n",
1188 | "Van Rossum, G., Warsaw, B., & Coghlan, N. (2001, 21 julio). *PEP 8 – Style Guide for Python Code*. Python Enhancement Proposals. Recuperado 1 de agosto de 2022, de https://peps.python.org/pep-0008/#imports"
1189 | ]
1190 | }
1191 | ],
1192 | "metadata": {
1193 | "colab": {
1194 | "provenance": []
1195 | },
1196 | "kernelspec": {
1197 | "display_name": "Python 3",
1198 | "language": "python",
1199 | "name": "python3"
1200 | },
1201 | "language_info": {
1202 | "codemirror_mode": {
1203 | "name": "ipython",
1204 | "version": 3
1205 | },
1206 | "file_extension": ".py",
1207 | "mimetype": "text/x-python",
1208 | "name": "python",
1209 | "nbconvert_exporter": "python",
1210 | "pygments_lexer": "ipython3",
1211 | "version": "3.12.6"
1212 | }
1213 | },
1214 | "nbformat": 4,
1215 | "nbformat_minor": 0
1216 | }
1217 |
--------------------------------------------------------------------------------
/Lecturas/02_Strings.ipynb:
--------------------------------------------------------------------------------
1 | {"cells":[{"cell_type":"markdown","metadata":{"id":"eYakJtwBHqYG"},"source":["
\n","\n","# Input/Output y el tipo de dato String\n"]},{"cell_type":"markdown","metadata":{"id":"NFVGpeVOQ4sJ"},"source":["# Output"]},{"cell_type":"markdown","metadata":{"id":"gemgYqGTq0hu"},"source":["Ahora que se han visto los conceptos de **asignación** y **variables**, es indispensable entregar mayor información a los/as usuarios/as al momento de ejecutar un programa. Dicha información puede ser entregada de distintas formas, entre las cuales se pueden mencionar:\n","\n","* Generación de archivos\n","* Gráficos\n","* Base de datos\n","* Información mediante interfaz gráfica\n","* Información por pantalla\n","\n","Considerando que se están entregando contenidos básicos en la programación, se iniciará con la generación de salidas por pantalla. Para ello se utilizará una función nativa llamada **`print()`**."]},{"cell_type":"markdown","metadata":{"id":"I7c0KNO9qIbn"},"source":["Para poder entender la importancia de la función **`print()`** se utilizará el siguiente ejemplo, donde se pretende calcular el perímetro de una circunferencia de radio 3 cm.\n","\n","Este código consigue que Python entregue solo el resultado numérico, pero no indica ni la unidad de medida ni el cálculo que se realizó (obtención del perímetro). \n","\n","Lo anterior se solucionará mediante la utilizanción de la función nativa de Python **`print()`**"]},{"cell_type":"code","execution_count":5,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":251,"status":"ok","timestamp":1679088180931,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"FV9gHr_1IoAp","outputId":"4b48388f-c5bd-45ed-b88d-c2b14780427b"},"outputs":[{"name":"stdout","output_type":"stream","text":["El perímetro de la circunferencia, de radio 3 cm, es de 18.84 cm\n"]}],"source":["# Ejemplo 1\n","# Se definen las constantes y variables a utilizar\n","NUMERO_PI = 3.14\n","radio = 3\n","\n","# Se realiza los cálculos respectivos\n","perimetro_circunferencia = 2 * NUMERO_PI * radio\n","\n","# Se entrega el resultado\n","print(\"El perímetro de la circunferencia, de radio 3 cm, es de\", perimetro_circunferencia, \"cm\")"]},{"cell_type":"markdown","metadata":{"id":"uE8NdIfJyEJM"},"source":["Como se observa en el Ejemplo 1, la función **`print()`** permite entregar información detallada, mezclando mensajes (`strings`) y variables (definidas por el/la usuario/a u obtenidas durante la ejecución del programa).\n","\n","Para realizar lo anterior, dentro de la función **`print()`** se debe escribir lo que se desea informar al usuario/a, separando los mensajes de las variables con el uso de comas (**`,`**)\n","\n","```python\n","print(\"El perímetro de la circunferencia, de radio 3 cm, es de\",perimetro_circunferencia,\"cm\")\n","```\n","\n"]},{"cell_type":"markdown","metadata":{"id":"2YZIA4NvkGjv"},"source":["Del ejemplo anterior se puede observar que la salida generada tiene mayor información para el/la usuario/a.\n","\n","La función **`print()`** permite entregar información detallada de los cálculos realizados y, además, permite entregar más de una salida.\n","\n","Utilizando el ejemplo anterior, se calculará el perímetro y el área de una circunferencia."]},{"cell_type":"code","execution_count":6,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":21,"status":"ok","timestamp":1679088181196,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"BffSZZ-ElS9J","outputId":"188c9199-aa38-41e8-a33d-3c865197f6ec"},"outputs":[{"name":"stdout","output_type":"stream","text":["El perímetro de la circunferencia, de radio 3 cm, es de 18.84 cm\n","El área de la circunferencia, de radio 3 cm, es de 28.26 cm2\n"]}],"source":["# Ejemplo 2\n","# Se definen las constantes y variables a utilizar\n","NUMERO_PI = 3.14\n","radio = 3\n","\n","# Se realiza los cálculos respectivos\n","perimetro_circunferencia = 2 *NUMERO_PI * radio\n","area_circunferencia = NUMERO_PI * radio**2\n","\n","# Se entrega el resultado\n","print(\"El perímetro de la circunferencia, de radio 3 cm, es de\", perimetro_circunferencia, \"cm\")\n","print(\"El área de la circunferencia, de radio 3 cm, es de\", area_circunferencia, \"cm2\")"]},{"cell_type":"markdown","metadata":{"id":"clCPjVJJ6BnO"},"source":["Como se aprecia en el Ejemplo 2, cada vez que se utiliza la función `print()`, se inserta un salto de línea (`\\n`) después de que muestra los mensajes. Esto se debe a que esta función fue creada para que realice esa acción, a menos que se indique otra cosa.\n","\n","Para cambiar la opción anterior y modificar la acción que realiza la función `print()` al ser ejecutada es la siguiente:\n","\n","```python\n","print(, end=\" \")\n","```\n","\n","En este caso, le hemos dicho que coloque al final, en vez de un salto de línea, un espacio (`\" \"`)."]},{"cell_type":"code","execution_count":7,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":18,"status":"ok","timestamp":1679088181197,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"IPChQfid65Ak","outputId":"85aac566-ed44-413b-aff9-fa5eda5c2199"},"outputs":[{"name":"stdout","output_type":"stream","text":["El perímetro de la circunferencia, de radio 3 cm, es de 18.84 cm y el área de la circunferencia, de radio 3 cm, es de 28.26 cm2\n"]}],"source":["# Ejemplo 3\n","# Se definen las constantes y variables a utilizar\n","NUMERO_PI = 3.14\n","radio = 3\n","\n","# Se realiza los cálculos respectivos\n","perimetro_circunferencia = 2 * NUMERO_PI * radio\n","area_circunferencia = NUMERO_PI * radio**2\n","\n","# Se entrega el resultado\n","print(\"El perímetro de la circunferencia, de radio 3 cm, es de\", perimetro_circunferencia,\n"," \"cm y\", end = \" \")\n","print(\"el área de la circunferencia, de radio 3 cm, es de\", area_circunferencia, \"cm2\")"]},{"cell_type":"markdown","metadata":{"id":"mSU_Y4cZmDz4"},"source":["# Input"]},{"cell_type":"markdown","metadata":{"id":"XU8XYY8ymJH8"},"source":["Con lo visto anteriormente, ya se puede entregar información por pantalla, pero los programas son monótonos y, de seguir trabajando de esa manera, se tendría que hacer un programa para cada caso.\n","\n","Por ejemplo, se tendría que hacer un programa para determinar el área y perímetro de una circunferencia para cada valor del radio.\n","\n","Es por ello que los lenguajes de programación tienen la posibilidad de alimentar los programas con información. Esto se puede realizar principalmente mediante las siguientes posibilidades:\n","\n","* Lectura de archivos\n","* Ingreso de información por teclado\n","\n","Considerando que se están entregando contenidos básicos en la programación, se iniciará con la alimentación de información mediante el ingreso por teclado. Para ello, se utilizará una función nativa llamada **`input()`**.\n","\n","La función **`input()`** detiene la ejecución del programa y espera que el/la usuario/a ingrese datos por teclado y presione la tecla **enter** (⏎) para señalar que terminó de ingresarlos. Posteriormente, la función captura los datos ingresados por el usuario y los retorna como una cadena de texto (**`string`**). Una vez entregado el texto, el programa sigue su ejecución."]},{"cell_type":"markdown","metadata":{"id":"cSQ_VWBUq1Tp"},"source":["Para poder comprender el modo de operación de la función **`input()`**, se utilizará el Ejemplo 4, donde se solicita obtener el cálculo del perímetro y área de un rectángulo. En particular para este caso, se desea que el usuario pueda indicar los el valor de los lados, cada vez que ejecute el programa.\n"]},{"cell_type":"code","execution_count":8,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":270},"executionInfo":{"elapsed":11476,"status":"error","timestamp":1679088192665,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"FraMaZdhtK2-","outputId":"2ef461ce-d823-435a-8095-0001ca5a2d55"},"outputs":[{"name":"stdout","output_type":"stream","text":["3\n","4\n"]},{"ename":"TypeError","evalue":"ignored","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)","\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# Se realizan los cálculos respectivos\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0mperimetro_rectangulo\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mlado_a\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mlado_b\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0marea_rectangulo\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlado_a\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mlado_b\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;31m# Se entrega el resultado\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'str'"]}],"source":["# Ejemplo 4\n","# Se solicita la información al usuaio/a y se guarda en variables\n","lado_a = input()\n","lado_b = input()\n","\n","# Se realizan los cálculos respectivos\n","perimetro_rectangulo = 2*lado_a + 2*lado_b\n","area_rectangulo = lado_a*lado_b\n","\n","# Se entrega el resultado\n","print(\"El perímetro y área del rectángulo, de lados\", lado_a, \"cm y \", lado_b, \"cm es\",\n"," perimetro_rectangulo,\"cm y\",area_rectangulo,\"cm2 respectivamente\")"]},{"cell_type":"markdown","metadata":{"id":"OOANDDKnuEFW"},"source":["El programa anterior entrega un mensaje de error producto de que las entradas solicitadas al usuario/a fueron solicitadas con la función **`input()`**, la cual genera un tipo de dato `string`.\n","\n","Para poder realizar el cálculo del área y perímetro de manera correcta, es necesario realizar un cambio de *tipo de dato*:\n","\n","**string** --> **número**\n","\n","En este caso en particular, se utilizará la función **`float()`**, pues esta nos permite capturar tanto valores enteros como no enteros (Ejemplo 5)."]},{"cell_type":"code","execution_count":9,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":3578,"status":"ok","timestamp":1679088203133,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"BNIgDXgdu9wi","outputId":"38289ace-8d11-4a10-e983-f68d3448688b"},"outputs":[{"name":"stdout","output_type":"stream","text":["3\n","4\n","El perímetro y área del rectángulo, de lados 3.0 cm y 4.0 cm es 14.0 cm y 12.0 cm2 respectivamente\n"]}],"source":["# Ejemplo 5\n","# Se solicita la información al usuario/a y se guarda en variables\n","lado_a = input()\n","lado_b = input()\n","\n","# Se realiza el cambio de tipo de dato respectivo\n","lado_a = float(lado_a)\n","lado_b = float(lado_b)\n","\n","# Se realizan los cálculos respectivos\n","perimetro_rectangulo = 2*lado_a + 2*lado_b\n","area_rectangulo = lado_a*lado_b\n","\n","# Se entrega el resultado\n","print(\"El perímetro y área del rectángulo, de lados\", lado_a, \"cm y \", lado_b, \"cm es\",\n"," perimetro_rectangulo, \"cm y\", area_rectangulo, \"cm2 respectivamente\")"]},{"cell_type":"markdown","metadata":{"id":"LZYrtbvdvNv4"},"source":["Otra característica que posee la función **`input()`** es que permite agregar información (entrada) al usuario/a para que pueda saber con exactitud lo que se está solicitando. Para ello, se debe escribir el mensaje que se desea entregar al usuario/a dentro del paréntesis como cadena de texto (entre comillas).\n","\n","Básicamente podemos entregarle cualquier string a la función **`input()`** y este será mostrado al usuario al momento de pedirle que ingrese los datos (Ejemplo 6)."]},{"cell_type":"code","execution_count":10,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":3333,"status":"ok","timestamp":1679088209662,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"1eRjYAatv_5D","outputId":"8fc58c08-9997-4c13-9361-a8d85647da06"},"outputs":[{"name":"stdout","output_type":"stream","text":["Favor ingresar la medida del primer lado del rectángulo: 3\n","Favor ingresar la medida del segundo lado del rectángulo: 4\n","El perímetro y área del rectángulo, de lados 3.0 cm y 4.0 cm es 14.0 cm y 12.0 cm2 respectivamente\n"]}],"source":["# Ejemplo 6\n","# Se solicita la información al usuaio/a y se guarda en variables\n","lado_a = input(\"Favor ingresar la medida del primer lado del rectángulo: \")\n","lado_b = input(\"Favor ingresar la medida del segundo lado del rectángulo: \")\n","\n","# Se realiza el cambio de tipo de dato respectivo\n","lado_a = float(lado_a)\n","lado_b = float(lado_b)\n","\n","# Se realizan los cálculos respectivos\n","perimetro_rectangulo = 2*lado_a + 2*lado_b\n","area_rectangulo = lado_a*lado_b\n","\n","# Se entrega el resultado\n","print(\"El perímetro y área del rectángulo, de lados\", lado_a, \"cm y \", lado_b, \"cm es\",\n"," perimetro_rectangulo, \"cm y\", area_rectangulo, \"cm2 respectivamente\")"]},{"cell_type":"markdown","metadata":{"id":"YP9M4SMPwben"},"source":["Existe la posibilidad de poder simplificar el código anterior utilizando **funciones anidadas**. Esto se traduce en llamar una función dentro de otra:\n","\n","```python\n","lado_a = float(input(\"Favor ingresar la medida del primer lado del rectángulo: \"))\n","```\n","\n","Recordemos que, de acuerdo con la precedencia de operadores, los paréntesis se resuelven primero, entonces lo que ocurre aquí es que el valor entregado por `input` es el que se le entrega a la función de *typecasting* `float`.\n","\n","Realizando el cambio en el código (Ejemplo 7), este queda de la siguiente manera:\n"]},{"cell_type":"code","execution_count":11,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":4117,"status":"ok","timestamp":1679088221294,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"76B5NL6nxMps","outputId":"bb2b96f2-2574-4bdb-e725-14b99c05b927"},"outputs":[{"name":"stdout","output_type":"stream","text":["Favor ingresar la medida del primer lado del rectángulo: 3\n","Favor ingresar la medida del segundo lado del rectángulo: 4\n","El perímetro y área del rectángulo, de lados 3.0 cm y 4.0 cm es 14.0 cm y 12.0 cm2 respectivamente\n"]}],"source":["# Ejemplo 7\n","# Se solicita la información al usuaio/a, se realiza el cambio de tipo de dato y se guarda en variables\n","lado_a = float(input(\"Favor ingresar la medida del primer lado del rectángulo: \"))\n","lado_b = float(input(\"Favor ingresar la medida del segundo lado del rectángulo: \"))\n","\n","# Se realizan los cálculos respectivos\n","perimetro_rectangulo = 2*lado_a + 2*lado_b\n","area_rectangulo = lado_a*lado_b\n","\n","# Se entrega el resultado\n","print(\"El perímetro y área del rectángulo, de lados\", lado_a, \"cm y \", lado_b, \"cm es\",\n"," perimetro_rectangulo, \"cm y\", area_rectangulo, \"cm2 respectivamente\")"]},{"cell_type":"markdown","metadata":{"id":"PTzLbEThRVLh"},"source":["**NOTA:** Pese a que la segunda versión del código posee menos líneas que el código anterior, se recomienda no abusar de las funciones anidadas. Como regla para este curso, siempre se recomienda privilegiar la *legibilidad* (es decir, que el código sea entendible), por sobre la *reducción* de las líneas del código."]},{"cell_type":"markdown","metadata":{"id":"YZUGTH-bzhMo"},"source":["# Abstracción de procesos"]},{"cell_type":"markdown","metadata":{"id":"QDtzgmcyzmim"},"source":["Una forma de ayudarnos a entender como organizar un programa es entendiendo que este básicamente solo es un proceso de transformación de entradas en una (o varias) salida en particular. La forma más sencilla de enfrentarse a un problema de programación y entender qué es lo que debo hacer, es organizar el código en 3 bloques:\n","* Entrada: Correspondiente a los valores que me entregarán para operar.\n","* Procesamiento: Correspondiente a las operaciones que debo hacer para generar la(s) salida(s).\n","* Salida: Donde informo al usuario del resultado del proceso.\n","\n","Una formá básica de estructurarlo, considerando además la posibilidad de valores definidos previamente, es la siguiente:\n","\n","```python\n","# CONSTANTES\n","\n","# ENTRADAS\n","\n","# PROCESAMIENTO\n","\n","# SALIDA\n","```\n","\n","Revisemos como esto organizaría el ejemplo anterior:\n"]},{"cell_type":"code","execution_count":12,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":4211,"status":"ok","timestamp":1679088229324,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"CyKynlcJ1Dd1","outputId":"cd1ce0aa-20e6-4d5c-ec59-e0fedd290926"},"outputs":[{"name":"stdout","output_type":"stream","text":["Favor ingresar la medida del primer lado del rectángulo: 10\n","Favor ingresar la medida del segundo lado del rectángulo: 30\n","El perímetro y área del rectángulo, de lados 10.0 cm y 30.0 cm es 80.0 cm y 300.0 cm2 respectivamente\n"]}],"source":["# ENTRADAS\n","# Se solicita la información al usuaio/a, se realiza el cambio de tipo de dato y se guarda en variables\n","lado_a = float(input(\"Favor ingresar la medida del primer lado del rectángulo: \"))\n","lado_b = float(input(\"Favor ingresar la medida del segundo lado del rectángulo: \"))\n","\n","# PROCESAMIENTO\n","# Se realizan los cálculos respectivos\n","perimetro_rectangulo = 2*lado_a + 2*lado_b\n","area_rectangulo = lado_a*lado_b\n","\n","# SALIDA\n","# Se entrega el resultado\n","print(\"El perímetro y área del rectángulo, de lados\", lado_a, \"cm y \", lado_b, \"cm es\",\n"," perimetro_rectangulo, \"cm y\", area_rectangulo, \"cm2 respectivamente\")"]},{"cell_type":"markdown","metadata":{"id":"YKsSelqASvI7"},"source":["En este caso, como no tenemos constantes, tenemos solo 3 bloques, las instrucciones donde se piden los lados (entradas), el proceso de cálculo de perímetro y área (procesamiento) y la sección donde se informa al usuario del resultado (salida)."]},{"cell_type":"markdown","metadata":{"id":"u3ty4ysi3lHg"},"source":["Uno de los principales problemas que se tienen al momento de querer plantear una solución en un lenguaje de programación es que es muy complejo pensar simultáneamente en la solución de un problema y en cómo plantearla en Python (u otro lenguaje). Para facilitar esa tarea, se utiliza un razonamiento estructurado llamado **abstracción de procesos**, el cual consta de una serie de pasos:\n","\n","1. Identificar las entradas del problema\n","2. Identificar las transformaciones que el programa debe hacer usando los datos de entrada\n","3. Identificar las salidas a entregar, que son el resultado de las transformaciones anteriores.\n","\n","La abstracción es la habilidad **más importante** al momento de programar, e incluso, de resolver cualquier problema complejo. Es la herramienta que permite responder a las preguntas claves que están presentes al momento de proponer una solución:\n","\n","1. ¿**Qué** se quiere hacer? - corresponde a saber cuál es el problema\n","2. ¿**Con qué** se cuenta? - apunta a conocer las entradas del problema\n","3. ¿**Cómo** se hace? - se centra en saber qué hay que hacer con las entradas para lograr el objetivo\n","4. ¿**Para qué** se hace? - corresponde a identificar el resultado que se quiere obtener, es decir, las salidas que entraga la solución\n","\n","Si se domina correctamente esta técnica, serán capaces de aplicarla incluso para problemas muy complejos, descomponiendo un enunciado en fragmentos más pequeños. Se puede resolver cada uno de los fragmentos o sub-problemas utilizando soluciones ya conocidas y luego combinar las soluciones parciales para resolver el problema completo.\n","\n","La única forma de desarrollar esta habilidad es ejercitándola constantemente y desafiándose a uno mismo a ser creativo e ingenioso.\n","\n","Es importante tener en cuenta que, en ocasiones, se tendrán que usar los conocimientos de otras áreas para poder reunir toda la información que se necesite para resolver un problema."]},{"cell_type":"markdown","metadata":{"id":"D4X_ejSV1a4V"},"source":["## Ejemplo de aplicación"]},{"cell_type":"markdown","metadata":{"id":"PgWRBlqZ1gS8"},"source":["Considerando que ya se han visto los conceptos básicos para realizar un programa en Python, se plantea un enunciado para poder practicar lo aprendido hasta el momento:\n","\n","Un tren parte desde la estación Los Domínicos en dirección hacia San Pablo, situada a 17.7 km de distancia, con una rapidez promedio de 60 km/h. Simultáneamente, otro tren parte en sentido contrario desde la estación San Pablo con una rapidez media de 75 km/h. ¿A qué distancia de la estación Los Domínicos se cruzan ambos trenes y a cuántos minutos de la partida? "]},{"cell_type":"markdown","metadata":{"id":"h-hWl5kp8JSc"},"source":["Lo primero es realizar la **abstracción de procesos**:\n","\n","**Entradas**\n","\n","* Distancia entre ambos puntos ($d$): 17.7 km\n","* Rapidez del primer tren ($v_1$): 60 km/h\n","* Rapidez del segundo tren ($v_2$): 75 km/h\n","\n","**Procesamiento**:\n","Por física se sabe que:\n","$$d = v\\cdot t$$\n","\n","Además, se sabe que la distancia total se obtiene como:\n","$$d = v_1\\cdot t + v_2\\cdot t = (v_1 + v_2)t$$\n","\n","De lo anterior, se puede conocer el timepo (en horas) que tarda los trenes en encontrarse:\n","$$t = \\frac{d}{v_1 + v_2}$$\n","\n","Se sabe que una hora tiene 60 minutos, por lo que el tiempo en minutos está dado por:\n","$$t_m = t\\cdot 60$$\n","\n","Finalmente, se puede determinar a qué distancia de la estación Los Domínicos se cruzan los trenes de la siguiente manera:\n","$$dc = v_1\\cdot t$$\n","\n","**Salidas**:\n","* Distancia de la estación Los Domínicos en que se cruzan los trenes ($dc$)\n","* Tiempo, en minutos, transcurrido desde la partida hasta el cruce ($t_m$)"]},{"cell_type":"markdown","metadata":{"id":"yFbdPt1k-wAW"},"source":["En el ejercicio anterior se utilizó la abstracción de procesos para obtener la idea de solución de un problema. El siguiente paso es tomar esa idea y convertirla en un programa ordenado y fácil de leer. Para eso se utilizará lo que se ha aprendido de Python hasta ahora e incorporar las buenas prácticas de programación.\n","\n","La transformación de la idea en un programa consta de los siguientes pasos:\n","\n","1. Escribir las entradas que se identificaron como variables, con nombres representativos.\n","2. Escribir las transformaciones identificadas como sentencias de Python, almacenando los valores intermedios en nuevas variables\n","3. Mostrar las salidas identificadas, al usaurio/a, utilizando la función **`print()`** y un mensaje de texto que indique al usuario/a qué es la información que está recibiendo.\n","\n","Dicho lo anterior, se tiene el siguiente código:"]},{"cell_type":"code","execution_count":13,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":292,"status":"ok","timestamp":1679088234626,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"DMlGI-esCZHJ","outputId":"2603546b-d61f-484d-f65f-9f3dc53e4f23"},"outputs":[{"name":"stdout","output_type":"stream","text":["Los trenes se cruzan a 7.866666666666665 km de la estación Los Domínicos a 7.866666666666665 minutos de la partida\n"]}],"source":["# ENTRADAS\n","distancia_total = 17.7\n","rapidez_tren_1 = 60\n","rapidez_tren_2 = 75\n","\n","# PROCESAMIENTO\n","tiempo_horas = distancia_total / (rapidez_tren_1 + rapidez_tren_2)\n","tiempo_minutos = tiempo_horas * 60\n","distancia_cruce = rapidez_tren_1 * tiempo_horas\n","\n","# SALIDA\n","print(\"Los trenes se cruzan a\", distancia_cruce, \"km de la estación Los Domínicos a\",\n"," tiempo_minutos, \"minutos de la partida\")"]},{"cell_type":"markdown","metadata":{"id":"DW6KYwKcCgY_"},"source":["Si bien el programa resuelve correctamente el problema, hay algunas cosas que podrían no quedar claras a otras personas que lean el programa. Por ello, siempre es importante ayudar a un posible lector con un poco de información adicional que le ayude a entender la estructura del programa y las tareas que realiza. La herramienta que se tiene para este fin son los comentarios, líneas del programa escritas y que no son tomadas en cuenta por el interprete de Python al momento de ejecutar el programa.\n","\n","Para escribir un comentario, basta con incluir el símbolo gato/numeral/almohadilla (**`#`**) al comienzo de una línea. Con eso, el intérprete omitirá la línea completa, por lo que no se debe incluir sentencias que se ejecuten en una línea que tenga un comentario.\n","\n","También existe formas de escribir comentarios que abarquen varías líneas a la vez, esto se logra utilizando triple comillas, ya sean comillas simples o dobles.\n","\n","```\n","\"\"\"\n","esto es un ejemplo de un\n","comentario multilínea\n","\"\"\"\n","```\n","\n","Otro aspecto importante es que se escriben con mayúsculas aquellos comentarios que identifiquen distintas secciones de un programa, mientras que los que explican lo que hace el programa se escriben con minúscula.\n","\n","El desarrollo del ejercicio anterior quedaría de la siguiente manera:"]},{"cell_type":"code","execution_count":14,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":269,"status":"ok","timestamp":1679088238129,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"JIq034jIA0_6","outputId":"b036b307-6c3c-4e62-b202-86c37f1c7a11"},"outputs":[{"name":"stdout","output_type":"stream","text":["Los trenes se cruzan a 7.866666666666665 km de la estación Los Domínicos a 7.866666666666665 minutos de la partida\n"]}],"source":["# ENTRADAS\n","distancia_total = 17.7\n","rapidez_tren_1 = 60\n","rapidez_tren_2 = 75\n","\n","# PROCESAMIENTO\n","# Se calcula el tiempo total, en horas\n","tiempo_horas = distancia_total/(rapidez_tren_1 + rapidez_tren_2)\n","\n","# Se calcula el tiempo en minutos\n","tiempo_minutos = tiempo_horas * 60\n","\n","# Se calcula la distancia de cruce\n","distancia_cruce = rapidez_tren_1 * tiempo_horas\n","\n","# SALIDA\n","# Se entrega la distancia (en km) desde la estación Los Domínicos a la que se cruzan los trenes \n","# y el tiempo (en minutos) transcurridos desde su partida\n","print(\"Los trenes se cruzan a\", distancia_cruce, \"km de la estación Los Domínicos a\",\n"," tiempo_minutos,\"minutos de la partida\")"]},{"cell_type":"markdown","metadata":{"id":"6vq18zBNTQLl"},"source":["# String"]},{"cell_type":"markdown","metadata":{"id":"GCLydi8DoJX7"},"source":["Los **`strings`** son un tipo de dato que permite almacenar textos. En particular, a diferencia de los tipos de datos numéricos, el string es un tipo de dato *compuesto*, es decir, se puede descomponer en partes. Sus partes fundamentales son los **caracteres**, que son una forma de representar grafemas (como letras, números y signos de puntuación). Por ejemplo, \"a\" es un grafema, o \"!\", o incluso el espacio entre caracteres, \" \".\n","\n","Para que el programa entienda algo como string, es necesario definirlos con comillas, ya sean 'simples' o \"dobles\", siempre siendo consistentes entre las comillas de apertura y las de cierre."]},{"cell_type":"code","execution_count":15,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":265,"status":"ok","timestamp":1679088240482,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"Lwvhh2ZLBx14","outputId":"57a50d35-6826-4cc6-ce88-487ef869c406"},"outputs":[{"name":"stdout","output_type":"stream","text":["hola mundo\n","Hoy hay que estudiar\n"]}],"source":["# Ejemplo 8: Se definirá un string con comillas simples y luego con comillas dobles\n","print('hola mundo')\n","print(\"Hoy hay que estudiar\")"]},{"cell_type":"markdown","metadata":{"id":"orbY1ygXCKjr"},"source":["Lo que se ilustró en el **Ejemplo 8** fue la impresión por pantalla de dos strings definidos, tanto con comillas simples, como con comillas dobles."]},{"cell_type":"markdown","metadata":{"id":"Dh1qSyvsCXnK"},"source":["Si se quiere definir un **`string`** mezclando ambas comillas, arrojará un mensaje de error como lo muestran los **Ejemplos 9** y **10**:"]},{"cell_type":"code","execution_count":16,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":131},"executionInfo":{"elapsed":8,"status":"error","timestamp":1679088243699,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"oUMb_eqKCgUf","outputId":"f5057d75-189a-4faf-bb0c-f68a03a88847"},"outputs":[{"ename":"SyntaxError","evalue":"ignored","output_type":"error","traceback":["\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m print('hola mundo\")\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m EOL while scanning string literal\n"]}],"source":["# Ejemplo 9: Se definirá un string que inicialmente comienza con comillas simples y\n","# termina con comillas dobles \n","print('hola mundo\")"]},{"cell_type":"code","execution_count":17,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":131},"executionInfo":{"elapsed":5,"status":"error","timestamp":1679088246454,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"r_aYeKBZDCB8","outputId":"4fe52063-348d-472d-8d3b-b0b644f120d2"},"outputs":[{"ename":"SyntaxError","evalue":"ignored","output_type":"error","traceback":["\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m print(\"hola mundo')\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m EOL while scanning string literal\n"]}],"source":["# Ejemplo 10: Se definirá un string que inicialmente comienza con comillas dobles y\n","# termina con comillas simples\n","print(\"hola mundo')"]},{"cell_type":"markdown","metadata":{"id":"HCy4VQ1YeoKX"},"source":["Además de las comillas simples y dobles, Python ofrece otra forma de poder definir `string` de gran tamaño, llamados `docstring`. El uso que se le da a estas cadenas de texto son, principalmente, para documentar secciones del código.\n","\n","Este tipo de string se define con triple comillas.\n","\n","El uso de un `docstring`se puede ver en el **Ejemplo 11**:"]},{"cell_type":"code","execution_count":18,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":266,"status":"ok","timestamp":1679088248746,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"feDe9ttYgABG","outputId":"d11aa834-2484-4181-d164-27e6fbb61c5f"},"outputs":[{"name":"stdout","output_type":"stream","text":["La idea de este tipo de strings es generar\n","documentación para que otros usuarios pueden entender\n","lo que se está haciendo en este código\n"]}],"source":["# Ejemplo 11: Creación de un string multilínea o docstring\n","texto = \"\"\"La idea de este tipo de strings es generar\n","documentación para que otros programadores pueden entender\n","lo que se está haciendo en este código\"\"\"\n","\n","print(texto)"]},{"cell_type":"markdown","metadata":{"id":"-69EnZHxD5A1"},"source":["## Uso de Variables"]},{"cell_type":"markdown","metadata":{"id":"OQD03WewD_hm"},"source":["Los `strings`, al igual que los otros tipos de datos vistos se pueden asignar a variables para su posterior uso.\n","\n","Para lograr esto, se define una variable a la que será asignado un determinado string (Ejemplo 12):"]},{"cell_type":"code","execution_count":19,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":258,"status":"ok","timestamp":1679088251119,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"CwLSwQh-ETiS","outputId":"c245b7f5-2797-41d9-a7ad-bc70ba3f154c"},"outputs":[{"name":"stdout","output_type":"stream","text":["hola mundo\n"]}],"source":["# Ejemplo 12: se definirá un string en una variable para, posteriormente, ser mostrada por pantalla\n","texto = \"hola mundo\"\n","\n","print(texto)"]},{"cell_type":"markdown","metadata":{"id":"HoKHN28eEl2-"},"source":["Es importante recordar que, **por convención**, las variables creadas deben estar escritas en **minúsculas** y, si son varias palabras, se deben separar con **guiones bajos**:"]},{"cell_type":"code","execution_count":20,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":7,"status":"ok","timestamp":1679088254157,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"RwfN-Ya9Ey2c","outputId":"3737ed9f-fcea-4b1e-f201-5f39b444fa40"},"outputs":[{"name":"stdout","output_type":"stream","text":["hola mundo\n","hola mundo_2\n"]}],"source":["# Ejemplo 13: definición de un string utilizando buenas prácticas\n","\n","mensaje_correcto = \"hola mundo\"\n","\n","mensajeMalEscrito = \"hola mundo_2\"\n","\n","print(mensaje_correcto)\n","print(mensajeMalEscrito)"]},{"cell_type":"markdown","metadata":{"id":"R0t59DxZGrLq"},"source":["Como se aprecia en el **Ejemplo 13**, las buenas prácticas no afecta el funcionamiento del código, no obstante, el código no solo debe ser entendible por Python, sino también por otros programadores. Por eso es necesario respetar las convenciones de nombres."]},{"cell_type":"markdown","metadata":{"id":"3HsWj2hIH8H8"},"source":["Python permite hacer uso de comillas dentro de un `string`, si estas difieren con las utilizadas para definirlo. Lo anterior se refiere a que, si el string fue definido con comillas dobles, el texto que se quiere resaltar debe estar con comillas simples y viceversa."]},{"cell_type":"code","execution_count":21,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":281,"status":"ok","timestamp":1679088256501,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"uduUvpotHFmD","outputId":"7e7cfcdc-3cc2-43da-9c6b-cb5d3fa8d442"},"outputs":[{"name":"stdout","output_type":"stream","text":["Este es un cuadernillo de 'Google Colab'\n","Se imprime un ejemplo para 'comprender mejor'\n"]}],"source":["# Ejemplo 14: Imprimir mensajes que incorporen comillas\n","mensaje_1 = \"Este es un cuadernillo de 'Google Colab'\"\n","mensaje_2 = 'Se imprime un ejemplo para \"comprender mejor\"'\n","\n","print(mensaje_1)\n","print(mensaje_2)"]},{"cell_type":"markdown","metadata":{"id":"pVnD53PtXYAK"},"source":["Del mismo modo, si quisiera usar las mismas comillas dentro del string y para definirlo, puedo hacerlo usando el **caracter de escape**, que corresponde a *backslash* (`\\`), como se presenta en el Ejemplo 15."]},{"cell_type":"code","execution_count":22,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":9,"status":"ok","timestamp":1679088259471,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"8Ja_kBzBXrPx","outputId":"cb8d5185-b2b0-4dcb-87ec-e6fae25430dd"},"outputs":[{"name":"stdout","output_type":"stream","text":["Este es un cuadernillo de \"Google Colab\"\n","Se imprime un ejemplo para 'comprender mejor'\n"]}],"source":["# Ejemplo 15: Imprimir mensajes que incorporen comillas\n","mensaje_1 = \"Este es un cuadernillo de \\\"Google Colab\\\"\"\n","mensaje_2 = 'Se imprime un ejemplo para \\'comprender mejor\\''\n","\n","print(mensaje_1)\n","print(mensaje_2)"]},{"cell_type":"markdown","metadata":{"id":"1zWikujwWvP1"},"source":["## Operadores y Operaciones sobre Strings"]},{"cell_type":"markdown","metadata":{"id":"Vib8f1W7WytA"},"source":["Al igual que con los tipos de datos numéricos, en Python también existen **operadores** para trabajar con strings.\n","\n","Estos operadores son utilizados al realizar cálculos matemáticos sencillos y sus símbolos son **`+`** y **`*`**, los cuales representan a la suma y multiplicación de números respectivamente.\n","\n","Sin embargo,cuándo estos se usan para los strings, pasan a realizar operaciones de concatenación (\"pegar\" strings) y repetición (crear copias del string concatenadas), respectivamente."]},{"cell_type":"markdown","metadata":{"id":"H6OkmCcfYOL4"},"source":["### Concatenación\n","\n","Esta operación consiste en **unir** dos o más cadenas de `strings` para formar una nueva cadena\n","```\n","string_1 + string_2 -> string_1string_2\n","```\n","\n","El **Ejemplo 16** muestra lo indicado anteriormente:"]},{"cell_type":"code","execution_count":23,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":324,"status":"ok","timestamp":1679088262866,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"5DboJKb3Y-hp","outputId":"ad3de3d4-02f5-4c4f-8bde-00e66e3addbf"},"outputs":[{"name":"stdout","output_type":"stream","text":["holamundo\n","hola mundo\n"]}],"source":["# Ejemplo 16: concatenación de dos strings\n","\n","texto_1 = \"hola\"\n","texto_2 = \"mundo\"\n","\n","nuevo_texto = texto_1 + texto_2\n","nuevo_texto_2 = texto_1 + \" \" + texto_2\n","\n","print(nuevo_texto)\n","print(nuevo_texto_2)"]},{"cell_type":"markdown","metadata":{"id":"9d8IxJOBYPJo"},"source":["Vale la pena destacar que la concatenación funciona únicamente si **ambos elementos** son del tipo string. Si intento unir con otro tipo de dato, como por ejemplo `int` o `float`, Python entregará un error. \n","\n","El que será distinto según el tipo de dato del primer operador de la operación (Ejemplos 17 y 18)\n","\n","\n","\n"]},{"cell_type":"code","execution_count":24,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":183},"executionInfo":{"elapsed":387,"status":"error","timestamp":1679088265953,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"Rhh-ZZdgYs7C","outputId":"b092b8d3-fc50-4186-b201-2e83f036ed16"},"outputs":[{"ename":"TypeError","evalue":"ignored","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)","\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Ejemplo 17\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;34m'hola'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"]}],"source":["# Ejemplo 17\n","'hola' + 3"]},{"cell_type":"code","execution_count":25,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":183},"executionInfo":{"elapsed":7,"status":"error","timestamp":1679088268226,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"OeQZyFBqYuu8","outputId":"3a32a1c2-e71c-4fec-a21e-36d36e6e57bc"},"outputs":[{"ename":"TypeError","evalue":"ignored","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)","\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Ejemplo 18\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;36m3\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'hola'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"]}],"source":["# Ejemplo 18\n","3 + 'hola'"]},{"cell_type":"markdown","metadata":{"id":"avRg1XwiZfgJ"},"source":["### Repetición"]},{"cell_type":"markdown","metadata":{"id":"kI6ne0ifZhFj"},"source":["Esta operación se realiza teniendo como primer operador un string y como segundo operador un número entero. Consiste en **repetir** un `string` tantas veces como indique el número por el cual esté siendo multiplicado:\n","\n","```python\n","string_1 * 3 -> string_1string_1string_1\n","```\n","\n","El **Ejemplo 19** muestra lo indicado anteriormente:"]},{"cell_type":"code","execution_count":26,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":4,"status":"ok","timestamp":1679088270975,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"y47xFBrpZ_Nh","outputId":"90dd77f1-b8f0-49ea-80f3-f3b725c757f6"},"outputs":[{"name":"stdout","output_type":"stream","text":["holaholahola\n","holaholahola\n"]}],"source":["# Ejemplo 19: repetición de un string\n","texto_1 = \"hola\"\n","\n","nuevo_texto = texto_1 * 3\n","nuevo_texto_2 = 3 * texto_1\n","\n","print(nuevo_texto)\n","print(nuevo_texto_2)"]},{"cell_type":"markdown","metadata":{"id":"s_M-xTw2aM3I"},"source":["Adicionalmente, Python ofrece diversas funciones nativas que se pueden realizar con el tipo de dato `string`. Entre ellas vale destacar:\n","* **`len()`**: devuelve la cantidad de caracteres del string\n","* **`str()`**: devuelve la expresión ingresada en formato string\n","\n","El **Ejemplo 20** ilustra lo mencionado anteriormente:"]},{"cell_type":"code","execution_count":27,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":292,"status":"ok","timestamp":1679088273262,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"Kpk_LE5Vc47j","outputId":"90c8c3f4-023f-48f5-b6e0-7342193de744"},"outputs":[{"name":"stdout","output_type":"stream","text":["41\n","132\n","6666\n"]}],"source":["# Ejemplo 20: uso de funciones de strings\n","\n","oracion = \"este es un ejemplo para calcular el largo\"\n","\n","largo = len(oracion)\n","\n","numero = 66\n","texto_numero = str(numero)\n","\n","numero_nuevo = numero*2\n","repeticion_numero = texto_numero*2\n","\n","print(largo)\n","print(numero_nuevo)\n","print(repeticion_numero)"]},{"cell_type":"markdown","metadata":{"id":"wi9TC_f4dd4-"},"source":["En el ejemplo anterior se calculó el largo o la cantidad de caracteres que componían el string **`oracion`**.\n","\n","Posterior a ello, se transformó el número 66 a `string` y se realizó una comparación entre dos operaciones: multiplicación del número 66 por 2 y la multiplicación del número transformado a strings por 2 (repetición)."]},{"cell_type":"markdown","metadata":{"id":"sdlvpEv0gnQq"},"source":["## Indexación"]},{"cell_type":"markdown","metadata":{"id":"UOqmI3ojgtmv"},"source":["Del mismo modo que hay operadores para concatenar y repetir, existe una manera de acceder a los caracteres contenidos en el `string` de manera **individual**. \n","\n","Para lograr lo anterior, se tiene que llamar a la variable que contiene el `string` y acompañarlo de corchetes (`[ ]`) e indicar, dentro de estos, la posición numérica (contando de izquierda a derecha) de dicho caracter.\n","\n","**Es importante tener en cuenta que el primer caracter siempre estará en la posición `0`, el segundo en la posición `1` y así sucesivamente.**\n","\n","Tampoco olvidar que los espacios **también son considerados** al momento de recorrer un `string`, pues estos también son caracteres."]},{"cell_type":"code","execution_count":28,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":3,"status":"ok","timestamp":1679088276359,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"5Jw0oHgvhJw5","outputId":"5dc4de2e-2f37-4f94-dc51-9db6af5f1a01"},"outputs":[{"name":"stdout","output_type":"stream","text":["M\n"]}],"source":["# Ejemplo 21: Encontrar un caracter mediante su posición\n","palabra = \"Hola Mundo\"\n","\n","# Se quiere mostar por pantalla la letra \"M\", por lo que tendremos que indicar su posición\n","caracter = palabra[5]\n","\n","print(caracter)"]},{"cell_type":"markdown","metadata":{"id":"1mQRgTesh2Ex"},"source":["**IMPORTANTE:** Nunca se debe olvidar que el primer caracter se encuentra en la posición **0** y el último caracter se encuentra en la posición **largo - 1** o, en otras palabras, **`len() - 1`**.\n","\n","Dicho esto, se puede acceder a cualquier posición existente dentro del 0 y el largo - 1. Si se accede a una posición fuera de esos rangos, Python entrega el error `IndexError: string index out of range`, el cual es uno de los más comunes que comenten los programadores novatos."]},{"cell_type":"code","execution_count":29,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":235},"executionInfo":{"elapsed":242,"status":"error","timestamp":1679088278175,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"AFsRJMSeijO6","outputId":"94189a81-7f4b-4ca5-98fb-031326fd6b1c"},"outputs":[{"ename":"IndexError","evalue":"ignored","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)","\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# Se quiere mostar por pantalla la letra \"M\", por lo que tendremos que indicar su posición\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mcaracter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpalabra\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m25\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcaracter\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mIndexError\u001b[0m: string index out of range"]}],"source":["# Ejemplo 22: encontrar un caracter mediante su posición\n","palabra = \"Hola Mundo\"\n","\n","# Se quiere mostar por pantalla la letra \"M\", por lo que tendremos que indicar su posición\n","caracter = palabra[25]\n","\n","print(caracter)\n"]},{"cell_type":"markdown","metadata":{"id":"tB95-L-Eisw6"},"source":["Además de acceder a posiciones determinadas, es posible acceder a determinadas zonas o partes de un `string`. Para ello, existe el operador *slice* (pues \"corta\" parte del string)\n","\n","Este operador, utiliza la misma sintaxis de corchetes de la indexación, pero recibe dos parámetros separados por el cáracter dos puntos, `:`.\n","```python\n","string[x:y]\n","```\n","* `x`: corresponde a la primera posición que se quiere acceder.\n","* `y`: corresponde a la posición posterior a la última que se quiere acceder (esta posición no es guardada)."]},{"cell_type":"code","execution_count":30,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":240,"status":"ok","timestamp":1679088282304,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"TOkXnpoejadF","outputId":"823cd93a-52b3-4e92-bdc4-b2bfcd736f3a"},"outputs":[{"name":"stdout","output_type":"stream","text":["la Mun\n"]}],"source":["# Ejemplo 23: encontrar una cadena de caracteres mediante su posición\n","palabra = \"Hola Mundo\"\n","\n","# Se accede a las posiciones 2 a 7 (no incluye la última)\n","cadena = palabra[2:8]\n","\n","print(cadena)\n"]},{"cell_type":"markdown","metadata":{"id":"J_H11GhqjpDj"},"source":["## Métodos"]},{"cell_type":"markdown","metadata":{"id":"uO8aZ1bMklpc"},"source":["Los strings, como todo tipo de dato en Python son **objetos**, que, en palabras simples, significa que poseen características y acciones propias que ningún otro tipo de dato puede realizar. Estas acciones se denominan **métodos** y realizan operaciones que para otros tipos de datos no tienen sentido.\n","\n","Por ejemplo, nos podría interesar cambiar un string de mayúsculas a minúsculas, pero eso no tiene mucho sentido sobre un `int`, `float` o `boolean`."]},{"cell_type":"markdown","metadata":{"id":"L_b-si16mF7K"},"source":["Algunos métodos interesantes de los string que podemos usar son (en esta notación, cuando decimos ``, queremos decir que desde `<` hasta `>` se debe reemplazar por el dato a utilizar):\n","\n","* `.lower()`: retorna una copia del string donde todas sus letras son minúsculas.\n","* `.upper()`: retorna una copia del string donde todas sus letras son mayúsculas.\n","* `.title()`: retorna una copia del string donde la primera letra de cada palabra de un string está en mayúscula.\n","* `.swapcase()`: retorna una copia del string donde cada minúscula es convertida a mayúscula y viceversa.\n","* `.islower()`: retorna `True` si los caracteres del strings son solo letras minúsculas.\n","* `.isupper()`: retorna `True` si los caracteres del strings son solo letras mayúsculas.\n","* `.isdigit()`: retorna `True` si los caracteres del strings son solo numéricos.\n","* `.isalpha()`: retorna `True` si los caracteres del strings son solo letras.\n","\n","**MANOS A LA OBRA:** \n","* Revisa qué ocurre con `.isdigit()` si el string representa un número negativo, como por ejemplo `-32`, o un número flotante como `3.1456`.\n","* Revisa qué ocurre con `.isalpha()` si el string tiene tildes."]},{"cell_type":"code","execution_count":31,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":540,"status":"ok","timestamp":1679088284727,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"xNYQSIHJncIu","outputId":"91bc6a25-e5f2-4e28-c541-a31becfd2ad2"},"outputs":[{"name":"stdout","output_type":"stream","text":["hola mundo\n","HOLA MUNDO\n","Hola Mundo\n"]}],"source":["# Ejemplo 24: método .lower() y .upper()\n","palabra = \"Hola Mundo\"\n","\n","palabra_minuscula = palabra.lower()\n","palabra_mayuscula = palabra.upper()\n","\n","print(palabra_minuscula)\n","print(palabra_mayuscula)\n","print(palabra)"]},{"cell_type":"markdown","metadata":{"id":"efrtGSW4caCI"},"source":["Vale la pena notar que al usar métodos en los string, estos normalmente entregan **copias** de este con la transformación solicitada, sin embargo, el string original no es cambiado por estos métodos.\n","\n","Del Ejemplo 24, podemos ver que tenemos tres variables, cada una con una copia distinta del string. Del mismo modo, el Ejemplo 25 ilustra como podríamos usar la capacidad de las variables de ser reutilizadas, para aplicar transformaciones sucesivas a un string."]},{"cell_type":"code","execution_count":32,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":273,"status":"ok","timestamp":1679088286807,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"g0Bzf0iWoLiX","outputId":"c0dffb70-8cfe-4ff8-f0d5-2980714e4666"},"outputs":[{"name":"stdout","output_type":"stream","text":["Hola Mundo\n","hOLA mUNDO\n"]}],"source":["# Ejemplo 25: método .title() y .swapcase()\n","palabra = \"hola mundo\"\n","\n","palabra_titulo = palabra.title()\n","palabra_cambiada = palabra_titulo.swapcase()\n","\n","print(palabra_titulo)\n","print(palabra_cambiada)"]},{"cell_type":"code","execution_count":33,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":3,"status":"ok","timestamp":1679088288218,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"YaOoPaZHpFgV","outputId":"72cb8ad3-624a-4304-e354-51bd46f6d09a"},"outputs":[{"name":"stdout","output_type":"stream","text":["False\n","True\n","False\n","True\n"]}],"source":["# Ejemplo 26: Método .islower() e isupper()\n","palabra = \"Hola Mundo\"\n","palabra_2 = \"HOLA MUNDO\"\n","palabra_3 = \"hola mundo\"\n","\n","palabra_minuscula = palabra.islower()\n","palabra_minuscula_2 = palabra_3.islower()\n","\n","palabra_mayuscula = palabra.isupper()\n","palabra_mayuscula_2 = palabra_2.isupper()\n","\n","print(palabra_minuscula)\n","print(palabra_minuscula_2)\n","\n","print(palabra_mayuscula)\n","print(palabra_mayuscula_2)"]},{"cell_type":"code","execution_count":34,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":390,"status":"ok","timestamp":1679088290237,"user":{"displayName":"Luciano Hidalgo","userId":"01581468828685444889"},"user_tz":180},"id":"j-1ZX11Up1Sh","outputId":"56c88cad-3d6f-4dce-ef44-022cd52d6fc2"},"outputs":[{"name":"stdout","output_type":"stream","text":["True\n","False\n","False\n","True\n"]}],"source":["#Ejemplo 27: Método is.alpha() y is.digit()\n","palabra = \"HolaMundo\"\n","palabra_2 = \"espero que pronto sea 31 de diciembre\"\n","palabra_3 = \"15842\"\n","\n","palabra_letra = palabra.isalpha()\n","palabra_letra_2 = palabra_2.isalpha()\n","\n","palabra_numero = palabra_2.isdigit()\n","palabra_numero_2 = palabra_3.isdigit()\n","\n","print(palabra_letra)\n","print(palabra_letra_2)\n","\n","print(palabra_numero)\n","print(palabra_numero_2)"]},{"cell_type":"markdown","metadata":{"id":"31VHOgX9Pme9"},"source":["# Bibliografía\n","\n","## Abstracción\n","\n","Beecher, K. (2017). Problem-Solving and Decomposition. En *Computational Thinking* (p. 39). BCS.\n","\n","## Comentarios\n","\n","Beecher, K. (2017). Tutorial for Python Beginners. En *Computational Thinking* (p. 109). BCS.\n","\n","GeeksforGeeks. (2022, 11 abril). *Python Comments*. Recuperado 2 de agosto de 2022, de https://www.geeksforgeeks.org/python-comments/\n","\n","Van Rossum, G., Warsaw, B., & Coghlan, N. (2001, 21 julio). *PEP 8 – Style Guide for Python Code*. Python Enhancement Proposals. Recuperado 1 de agosto de 2022, de https://peps.python.org/pep-0008/\n","\n","Shaw, Z. (2017). Comments and Pound Characters. En *Learn Python 3 the Hard Way* (p. 14). Addison-Wesley.\n","\n","## Funciones nativas de Python\n","\n","GeeksforGeeks. (2021, octubre 29). *Output using print() function*. Recuperado 2 de agosto de 2022, de https://www.geeksforgeeks.org/python-output-using-print-function/\n","\n","Python Software Foundation. (2022, agosto 2). *Built-in Functions*. Python Documentation. Recuperado 2 de agosto de 2022, de https://docs.python.org/3/library/functions.html\n","\n","Shaw, Z. (2017). Prompting People. En *Learn Python 3 the Hard Way* (p. 40). Addison-Wesley.\n","\n","## Formato y buenas prácticas\n","Van Rossum, G., Warsaw, B., & Coghlan, N. (2001, 21 julio). *PEP 8 – Style Guide for Python Code*. Python Enhancement Proposals. Recuperado 1 de agosto de 2022, de https://peps.python.org/pep-0008/\n","\n","## Strings\n","GeeksforGeeks. (2022, 28 julio). Python String. Recuperado 4 de agosto de 2022, de https://www.geeksforgeeks.org/python-string/\n","\n","Python Software Foundation. (2022a, agosto 4). *An Informal Introduction to Python*. Python 3.10.6 documentation. Recuperado 4 de agosto de 2022, de https://docs.python.org/3/tutorial/introduction.html#strings\n","\n","Python Software Foundation. (2022b, agosto 4). *Built-in Types*. Python 3.10.6 documentation. Recuperado 4 de agosto de 2022, de https://docs.python.org/3/library/stdtypes.html#textseq\n"]}],"metadata":{"colab":{"provenance":[]},"kernelspec":{"display_name":"Python 3.10.5 64-bit","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.10.5"},"vscode":{"interpreter":{"hash":"26de051ba29f2982a8de78e945f0abaf191376122a1563185a90213a26c5da77"}}},"nbformat":4,"nbformat_minor":0}
2 |
--------------------------------------------------------------------------------