From 405acdeb8aae0549f48ebc9b0bee7f02abf91395 Mon Sep 17 00:00:00 2001 From: Santiago Rua Perez Date: Wed, 9 Sep 2020 14:58:42 -0500 Subject: [PATCH] Se agrego explicacion sobre la asignacion de la variable print --- .../Sesion_01_Introduccion-checkpoint.ipynb | 1397 +++++++++++++++++ Sesion_01_Introduccion.ipynb | 33 +- 2 files changed, 1422 insertions(+), 8 deletions(-) create mode 100644 .ipynb_checkpoints/Sesion_01_Introduccion-checkpoint.ipynb diff --git a/.ipynb_checkpoints/Sesion_01_Introduccion-checkpoint.ipynb b/.ipynb_checkpoints/Sesion_01_Introduccion-checkpoint.ipynb new file mode 100644 index 0000000..24409d0 --- /dev/null +++ b/.ipynb_checkpoints/Sesion_01_Introduccion-checkpoint.ipynb @@ -0,0 +1,1397 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "![Logo_unad](https://upload.wikimedia.org/wikipedia/commons/5/5f/Logo_unad.png)\n", + "\n", + "\n", + "

Escuela de Ciencias Básicas, Tecnología e Ingeniería

\n", + "\n", + "\n", + "\n", + "

ECBTI

\n", + "\n", + "\n", + "\n", + "

Curso:

\n", + "\n", + "\n", + "\n", + "

Introducción al lenguaje de programación Python

\n", + "\n", + "\n", + "\n", + "

Febrero de 2020

\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "

Sesión 01 - Presentación del Curso - Introducción

" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "**Lenguaje:** Python 3.8\n", + "\n", + "**Desarrollado en:** Notebook Jupyter\n", + "\n", + "**Versión:** 1.0\n", + "\n", + "**Fecha:** febrero de 2020\n", + "\n", + "**Tutor:** Carlos Alberto Álvarez Henao, DSc. I.C\n", + "\n", + "Medellín, diciembre de 2020" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# TODOS DEBERÍAMOS SABER PROGRAMAR... TODOS!" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "data": { + "image/jpeg": "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\n", + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import YouTubeVideo, HTML, IFrame\n", + "YouTubeVideo('Y1HHBXDL9bg')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Docente\n", + "\n", + "### Carlos Alberto Álvarez Henao\n", + "\n", + "\n", + "- **Ingeniero Civil, Universidad Nacional de Colombia - Medellín**\n", + "\n", + "- **M.Sc. y D.Sc. Mecánica Computacional - UFRJ/Brasil**\n", + "\n", + "- **Correo: carlos.alvarez@unad.edu.co**\n", + "\n", + "\"description\n", + "\n", + "\n", + "- Docente ocasional de tiempo completo. Escuela de Ciencias Básicas Tecnología e Ingenierías - ECBTI - [Universidad Nacional Abierta y a Distancia - UNAD](https://www.unad.edu.co/ \"UNAD\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Lenguajes de Programación\n", + "\n", + "![Imagen](https://github.com/carlosalvarezh/FundamentosProgramacion_U_EAFIT/blob/master/images/LenguajesProgramacion.jpg?raw=true \"\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Por qué usar Python?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "# Justificación\n", + "\n", + "`Python` es un lenguaje de programación multiplataforma, algunas de sus ventajas son: ayuda a mejorar la productividad ya que permite trabajar mucho más rápido que cualquier otro lenguaje, es versátil y soporta programación orientada a objetos, cuenta con una gran extensión de bibliotecas para un mejor uso, es un lenguaje de programación sostenible lo cual permite leer y modificar de una manera fácil los programas." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Con Python se pueden hacer:\n", + "\n", + "- Aplicaciones Web.\n", + "\n", + "- Análisis de Datos.\n", + "\n", + "- Aprendizajes de Maquina.\n", + "\n", + "- Visión Artificial.\n", + "\n", + "- Robótica, programar \"pequeñas\" computadoras(Raspberry Pi).\n", + "\n", + "- Juegos.\n", + "\n", + "- Web Scraping.\n", + "\n", + "- Automatizar(Scripts)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Algunas Empresas que usan Python:\n", + "\n", + "![Imagen](https://github.com/carlosalvarezh/FundamentosProgramacion_U_EAFIT/blob/master/images/PythonUsage.png?raw=true \"\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Lenguajes de Programación más usados a nivel mundial:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "display(IFrame('https://www.tiobe.com/tiobe-index/', '100%', '600px'))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Objetivo General:\n", + "\n", + "- Manejar conceptos básicos de programación Python orientando al participante en el conocimiento de la sintaxis y creación de programas funcionales." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "## Competencias:\n", + "\n", + "Tras participar del proceso cognoscitivo y práctico, se espera que el alumno este en capacidad de:\n", + "Entender la sintaxis de lenguaje `Python` al leer fuentes de otros programadores.\n", + "Crear(Escribir) Scripts en `Python`, para crear diferentes tipos de aplicaciones como tipo consola(terminal),`TUI`, `GUI` y páginas Web básicas." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "## Público Objetivo:\n", + "\n", + "Todas las personas que deseen aprender un lenguaje de programación, múltiples propósitos y diferentes tipos de aplicaciones." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Programa" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "|**Sesión** | **Fecha** |**Contenido** |\n", + "|:---------:|:-----------------:|--------------|\n", + "|01|Vi - 11/10/19|Introducción, Lenguajes compilados vs interpredos, IDEs, Tipos de datos y variables|\n", + "|02|Mi - 16/10/19|Expresiones, Secuencias, Strings, I/O 1|\n", + "|03|Vi - 18/10/19|Condicionales, Ciclos y Rangos|\n", + "|04|Lu - 21/10/19|Funciones|\n", + "|05|Mi - 23/10/19|Listas|\n", + "|06|Lu - 28/10/19|Diccionarios|\n", + "|07|Mi - 30/10/19|I/O 2 - Manejo de Archivos|\n", + "|08|Vi - 01/11/19|Manipulación de archivos JSon|\n", + "|09|Mi - 06/11/19|Algoritmos Básicos|\n", + "|10|Vi - 08/11/19|Ordenamiento y Búsqueda|\n", + "|11|Mi - 13/11/19|POO|\n", + "|12|Vi - 15/11/19|Visualización de Información|\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Por dónde empiezo? \n", + "\n", + "Lo primero es elegir una herramienta de trabajo sobre la cual realizar el código. A continuación me permito compartirles solo algunas herramientas de esas que he tenido la oportunidad de revisar y me parecen apropiadas para un curso de este nivel. No son las únicas, por el contrario, existen muchas otras más, quizás mejores, dependiendo del interés particular de desarrollo de cada quién. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Editores, IDE's, Notebooks\n", + "\n", + "**IDE** (*Integrated Development Environment*) o *Entorno de Desarrollo Integrado*, es una aplicación informática que permite la integración de varios servicios que permiten el desarrollo de un software o programa de computador. \n", + "\n", + "Normalmente consiste de:\n", + "\n", + "- Editor de Código fuente\n", + "\n", + "- Depurador\n", + "\n", + "Algunos Aplicativos usados para programar, enfoncándonos luego en `Python`, son:\n", + "\n", + "- **[PSeInt](http://pseint.sourceforge.net/ \"PSeInt\"):** \"*PSeInt es una herramienta para asistir a un estudiante en sus primeros pasos en programación. Mediante un simple e intuitivo pseudolenguaje en español (complementado con un editor de diagramas de flujo), le permite centrar su atención en los conceptos fundamentales de la algoritmia computacional, minimizando las dificultades propias de un lenguaje y proporcionando un entorno de trabajo con numerosas ayudas y recursos didácticos*\".\n", + "\n", + "\n", + "- **[Anaconda](https://www.anaconda.com/ \"Anaconda\")**: suite de trabajo para desarrollo de programas en [Python](https://www.python.org/ \"Python.org\") o [R](https://www.r-project.org/ \"R\") para proyectos de computación científica, que incluye el Notebook [Jupyter](http://jupyter.org/ \"Jupyter\"), plataforma en la que están hechas estas notas del curso, y el IDE [Spyder](https://www.spyder-ide.org/ \"Spyder\"), entre otras herramientas.\n", + "\n", + "\n", + "- **[PyCharm](https://www.jetbrains.com/pycharm-edu/ \"PyCharm\"):** es un entorno de desarrollo integrado (*IDE*) utilizado en la programación de computadoras, específicamente para el lenguaje `Python`. Es desarrollado por la compañía checa [JetBrains](https://www.jetbrains.com/ \"JetBrains\"). Proporciona análisis de código, un depurador gráfico, un probador de unidad integrado, integración con sistemas de control de versiones (*VCS*) y admite el desarrollo web con *Django*, así como Data Science con *Anaconda*.\n", + "\n", + "\n", + "- **[repl.it](https://www.repl.it \"repl.it\"):** es una start-up basada en San Francisco y un *IDE* en línea. Su nombre proviene de \"[read – eval – print loop](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop \"repl\")\". Es compatible [*+50* lenguajes de programación](https://repl.it/languages \"repl.it languages\"): *JavaScript*, *Python*, *PHP*, *C/C++*, *Fortran* o incluso *QBasic*, entre muchos otros, así como de frameworks populares como Django, Ruby on Rails y Sinatra. Y si quieres lastimarte y escribir en Brainfuck, también puedes hacerlo.\n", + "\n", + "\n", + "- **[Notepad++](http://notepad-plus-plus.org/ \"Notepad\"):** es un editor de código fuente (ojo, no ejecuta!!! solo edita!!!). Presenta resaltado de sintaxis, plegado de código y autocompletado limitado para lenguajes de programación, scripting y marcado, pero no terminación de código inteligente o verificación de sintaxis. Como tal, puede resaltar correctamente el código escrito en un esquema compatible, pero no se puede verificar si la sintaxis es internamente sólida o compilable. A partir de la versión 7.6.3, *Notepad++* puede resaltar los elementos sintácticos de *+70 lenguajes de programación*. Solo se cuenta para trabajar en el SO *Windows*.\n", + "\n", + "\n", + "- **[Google Colab](https://colab.research.google.com/ \"Google Colaboratory\"):** *Colaboratory* (también conocido como *Colab*) es un entorno de *notebook Jupyter* gratuito que se ejecuta en la nube y almacena sus notebooks en *Google Drive*. *Colab* fue originalmente un proyecto interno de *Google* y a partir de octubre de 2019 *Colab* solo le permite crear notebooks con núcleos `Python 2` y `Python 3`; sin embargo, si tiene una computadora portátil con kernels `ir` o `swift`, funcionará, ya que tanto `R` como `Swift` están instalados en el contenedor. Otros núcleos como `Julia` aún no son compatibles." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## De dónde obtengo información para aprender a programar?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Algoritmos\n", + "\n", + "Algunos libros introductorios en [Algoritmia](https://es.wikiversity.org/wiki/Algoritmia_y_programaci%C3%B3n_b%C3%A1sica/Aspectos_introductorios \"Algoritmia\"), que no emplean ningún lenguaje en particular \n", + "\n", + "- [Farrell, Joyce](http://latinoamerica.cengage.com/ls/introduccion-a-la-programacion-logica-y-diseno-7a-ed/ \"Farrell, Joyce. Introducción a la programación Lógica y Diseño\"). Introducción a la programación Lógica y Diseño (en físico, $$).\n", + "\n", + "\n", + "- [Pinales y Velázquez](http://www.uaa.mx/direcciones/dgdv/editorial/docs/algoritmos.pdf \"Pinales y Velázquez. Algoritmos Resueltos con Diagramas de Flujo y Pseudocódigo\"). Algoritmos Resueltos con Diagramas de Flujo y Pseudocódigo (en pdf, libre descarga)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Python como lenguaje de programación (uno entre muchos)\n", + "\n", + "- [Python.org](https://www.python.org/ \"Python.org\"): Página oficial del lenguaje de programación Python (inglés)\n", + "\n", + "\n", + "- [Downey, Allen B. Think Python. 2a Ed. Green Tea Press.](http://greenteapress.com/wp/think-python-2e/ \"Downey, Allen B. Think Python\"): Libro en PDF de libre descarga (inglés). " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### MooCs\n", + "\n", + "**MooC** es la abreviatura de **Curso masivo abierto en línea** (*Massive open online Course*, en inglés) . En términos simples, es un curso de estudio puesto a disposición por Internet para una gran cantidad de personas. Algunas de las compañías de cursos en línea más comunes que compiten por este nuevo negocio educativo son: [Udemy](https://www.udemy.com/ \"Udemy\"), [Edx](https://www.edx.org/ \"Edx\"), [Coursera](https://www.coursera.org/ \"Coursera\") y [DataCamp](https://www.datacamp.com/ \"DataCamp\"), entre muchos otros.\n", + "\n", + "Los *MooC* generalmente tienen fechas específicas de inicio y finalización. Los interesados miran conferencias de video en línea, completan las tareas y reciben la calificación de inmediato la mayor parte del tiempo. Con el auge de la globalización y la tecnología, la accesibilidad a la educación superior ha aumentado dramáticamente.\n", + "\n", + "Los MooC son generalmente gratuitos, y los cursos ofrecidos en línea a menudo provienen de algunas de las universidades más prestigiosas como *Harvard*, *MIT* y *Stanford*. Cada año, los *MooC* se vuelven más populares. Hay más cursos disponibles y la calidad de la educación en línea aumenta. Los MooC se caracterizan por su masividad, apertura y conectividad. Utilizan estrategias similares a las redes sociales, conectando a las masas con los beneficios del aprendizaje.\n", + "\n", + "Pero... cuál de todos escoger? en [este enlace](https://coolcollegehelpers.com/udemy-vs-edx-coursera-udacity/ \"Udemy vs Edx vs Coursera vs Udacity\") pueden encontrar una excelente descripción de cada uno de ellos y encontrar cuál se adapta más a sus necesidades de capacitación, o en [este](https://medium.com/@adiyagil/udemy-vs-coursera-vs-lynda-the-ultimate-comparison-70586665dca5 \"Ultimate comparison\") también, y [aquí](https://www.thecrowder.com/online-courses-sites?utm_source=me&utm_medium=organic&utm_campaign=education&utm_content=Udemy-VS-Coursera-VS-Lynda&ref=me-organic-education-Udemy-VS-Coursera-VS-Lynda \"Online Courses Sites\") encontrará un cuadro comparativo y acceso directo a algunas de esas plataformas. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Tutoriales on-line:\n", + "\n", + "Algunas páginas que ofrecen cursos on-line en diferentes áreas de las *TICs* (inglés/español). Algunos son libres (\"grátis\") pero si necesita certificado debes pagar.\n", + "\n", + "- **[Python Course](https://www.python-course.eu/index.php):** Excelente página para aprender `Python`a nivel básico, intermedio y/o avanzado (inglés)\n", + "\n", + "\n", + "- **[SocraticaStudios](https://www.youtube.com/user/SocraticaStudios \"Socratica\")** Canal de [Youtube](https://www.youtube.com/ \"Youtube\") con algunos recursos en español." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Apps para Smartphones y Tablets\n", + "\n", + "\n", + "- **[Sololearn](https://www.sololearn.com/Course/Python/)**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Repositorios\n", + "\n", + "En los repositorios de software encontrarán abundante información de códigos ya creados que les permitirán avanzar en el conocimiento de los diferentes esquemas de programación, así como ver cómo es que otros programan y tienen (posiblemente) buenas prácticas de programación que te servirán para tener unos códigos muy eficientes y límpios.\n", + "\n", + "- **[Github](https://github.com/ \"Github\")**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Por qué Python?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Lenguaje de programación de alto nivel creado por [Guido van Rossum](https://gvanrossum.github.io/ \"Guido van Rossum's home page\") a finales de los 80's. \n", + "\n", + "\n", + "- Actualmente ocupa el tercer lugar como uno de los lenguajes de programación más ampliamente difundidos a nivel mundial. [TIOBE index noviembre/2019](https://www.tiobe.com/tiobe-index/ \"tiobe.com\")\n", + "\n", + "\n", + "- Una de las mayores ventajas es su \"simplicidad\": En general, se requiere de muchas menos líneas de programación para ejecutar una determinada tarea que en otros lenguajes (`C/C++`, `java`, $\\ldots$.).\n", + "\n", + "\n", + "- Viene con una amplica colección de bibliotecas que permiten extender las capacidades del lenguaje.\n", + "\n", + "\n", + "- [Este](https://www.youtube.com/watch?v=Og847HVwRSI&feature=emb_logo \"Most popular programming languges 1965 - 2019\") es un video muy interesante que muestra la evolución de los lenguajes de programación más usados a nivel mundial desde 1965 y hasta 2019. Ampliamente recomndable su visualización:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "YouTubeVideo('Og847HVwRSI')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "- Es un lenguaje de plataforma transversal, es decir, el código escrito en Windows trabajará bien en Linux o Mac OS sin la necesidad de realizar ningún tipo de cambios en el código.\n", + "\n", + "\n", + "- Actualmente (***diciembre/2019***) el interprete se encuentra en la versión `3.8`, pero la mayoría de bibliotecas y códigos más usados aún se encuentran en las versiones `2.X`. La información oficila la podrán encontrar en la página de [Python.org](https://www.python.org \"Python's homepage\").\n", + "\n", + "\n", + "- La diferencia entre ambas versiones no sobrepasa el 10%, por lo que se puede usar una u otra sin problemas para la mayoría de aplicaciones." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ejecución desde Consola (Windows)\n", + "\n", + "![Imagen](https://github.com/carlosalvarezh/FundamentosProgramacion_U_EAFIT/blob/master/images/ConsolaW.PNG?raw=true \"\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Mi primer Programa en Python" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"Este es mi primer programa en Python!!!\")\n", + "print(\"Hola Mundo en Python 3!\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(3+4)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Variables Expresiones y Sentencias" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Valores y Tipos" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Un valor es una de las cosas básicas con las que un programa trabaja.\n", + "\n", + "- Los valores pueden ser Números (punto flotante, enteros, complejos...) Caracteres o Cadenas de Caracteres (strings)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "type(c)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "type(\"Hola Mundo!\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "type(17)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "type(17.)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "type(3+2j)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "type(\"17.0\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "type('string')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "z = 1,000,0000,000,00 #Producirá un error de semántica\n", + "print(type(z))\n", + "print(z)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "1.000.000.000 #Producirá un error de sintáxis" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "1000000000000.8678568" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Variables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Una variable es un nombre que hace referencia a un valor.\n", + "\n", + "- Una sentencia de asignación crea nuevas variables y valores dados." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "mensaje = \"Este es un mensaje\"\n", + "n = 17\n", + "pi = 3.14159265" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "- Este ejemplo realiza tres asignaciones." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "type(mensaje)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "type(n)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "type(pi)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "x = n * pi\n", + "print(type(x))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "z = n*mensaje\n", + "print(z)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p = pi * mensaje\n", + "print(p)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Nombre de Variables y Palabras Claves (keywords)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "b = \"Hola\"\n", + "B = 5\n", + "v = B * b\n", + "print(v)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Nombres de variables pueden tener un tamaño arbitrariamente de caracteres.\n", + "\n", + "\n", + "- Pueden contener letras y números, pero SIEMPRE deben empezar por una letra.\n", + "\n", + "\n", + "- Es **\"Kool\"** usar letras en mayúscula, pero es una buena práctica empezar los nombres de variables en minúscula.\n", + "\n", + "\n", + "- El carácter \"guión bajo\" (*underscore*), `_` , puede aparecer en el nombre de una variable. Usado frecuentemente en variables cuyo nombre está compuesto por diferentes palabras.\n", + "\n", + "\n", + "- Si da a una variable un nombre ilegal, obtendrá un error de sintaxis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "este_puede_ser_el_nombre_valido_de_una_variable = 1\n", + "print(este_puede_ser_el_nombre_valido_de_una_variable)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "estaEsUnaVariable = 3\n", + "print(estaEsUnaVariable)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "mamá = 3\n", + "print(mamá)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "76Pesos = 76\n", + "print(76Pesos)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "P3s0s 76 = 76\n", + "print(P3s0s76)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "mas@ = 5.3 " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "esta variable = 2.5" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "print = \"Avanzado\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'class1' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mclass1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mNameError\u001b[0m: name 'class1' is not defined" + ] + } + ], + "source": [ + "print(class1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notese que la funcion print fue sobreescrita por el string \"Avanzado\". A partir de este momento print sera una cadena y no una funcion interna de python." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Palabras Clave (keywords) y funciones integradas (builtins)\n", + "\n", + "El archivo `keyword.py` se distribuye junto con la librería estándar de `Python`. Es generado automáticamente a partir del archivo `graminit.c`, perteneciente al código fuente del intérprete. Incorpora una lista que contiene el conjunto de palabras resevadas, y una simple función que determina la existencia de un `keyword` a partir de una cadena." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [], + "source": [ + "# Palabras clave\n", + "\n", + "import keyword\n", + "listkw = keyword.kwlist\n", + "print(listkw)\n", + "print(len(listkw))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Funciones integradas\n", + "\n", + "import builtins\n", + "list_bins = dir(builtins)\n", + "print(list_bins)\n", + "print(len(list_bins))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ayuda (documentación)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "help(\"and\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Asignación Múltiple" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "-" + } + }, + "source": [ + "- Otra de las ventajas que *Python* nos provee, es la de poder asignar en una sola instrucción, múltiples variables." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "a, b, c, d = \"class\", 15, True, 3.8" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "type(c)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Operadores y Operandos" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Los operadores son símbolos especiales que representan cálculos: \n", + " - Suma: `+`\n", + " - Resta: `-`\n", + " - Multiplicación: `*`\n", + " - División: `/`\n", + " - Potenciación: `**`\n", + " - División entera: `//`\n", + " - Módulo: `%`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "r = 3 + 2\n", + "print(r)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "r = 1 - 4\n", + "print(r)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "r = 3 ** 5\n", + "print(r)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "r = 5 / 3\n", + "print(r)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "r = 5 // 3\n", + "print(r)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "r = 40 % 4\n", + "print(r)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "#### Observaciones!\n", + "\n", + "- En *Python* el operador \" `^` \" representa el operador bit a bit `XOR`.\n", + "\n", + "\n", + "- En *Python 2.x*, el operador división puede no hacer lo que usted esperaría que hiciera:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "minuto = 59\n", + "minuto/60" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "7/2." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "- En *Python 2.x* el operador `/` realiza la operación \"*floor division*\". Cuando los operandos son enteros, el resultado es la parte entera.\n", + "\n", + "\n", + "- En *Python 3.x*, el resultado es un número de punto flotante." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Operadores a nivel de bit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Operador `&` (*and*): devuelve $1$ si el primer bit operando es $1$ y el segundo bit operando es $1$. Se devuelve $0$ en caso contrario.\n", + "\n", + "\n", + "- Operador `|` (*or*): devuelve $1$ si el primer operando es $1$ o el segundo operandos $1$. Para el resto de casos se devuelve $0$.\n", + "\n", + "\n", + "- Operador `^` (*xor*): devuelve $1$ si uno de los operandos es $1$ y el otro no lo es.\n", + "\n", + "\n", + "- Operador `~` (*not*): sirve para negar uno a uno cada bit; es decir, si el operando es $0$, cambia a $1$ y si es $1$, cambia a $0$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "outputs": [], + "source": [ + "from IPython.core.display import HTML\n", + "def css_styling():\n", + " styles = open(\"custom.css\", \"r\").read()\n", + " return HTML(styles)\n", + "css_styling()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "kernelspec": { + "display_name": "Python 3", + "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.8.3" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": true, + "user_envs_cfg": true + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Sesion_01_Introduccion.ipynb b/Sesion_01_Introduccion.ipynb index 51c4e29..24409d0 100644 --- a/Sesion_01_Introduccion.ipynb +++ b/Sesion_01_Introduccion.ipynb @@ -550,9 +550,7 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": true - }, + "metadata": {}, "source": [ "## Ejecución desde Consola (Windows)\n", "\n", @@ -987,7 +985,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "slideshow": { "slide_type": "subslide" @@ -1000,13 +998,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'class1' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mclass1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mNameError\u001b[0m: name 'class1' is not defined" + ] + } + ], "source": [ "print(class1)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notese que la funcion print fue sobreescrita por el string \"Avanzado\". A partir de este momento print sera una cadena y no una funcion interna de python." + ] + }, { "cell_type": "markdown", "metadata": { @@ -1355,7 +1372,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.8.3" }, "latex_envs": { "LaTeX_envs_menu_present": true, @@ -1376,5 +1393,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 }