From 342d84b7c40d021ad2cf7aa95643ed145e135b8a Mon Sep 17 00:00:00 2001
From: Jorge Cordova <55065873+jcordovaj@users.noreply.github.com>
Date: Sun, 22 Jan 2023 02:01:29 -0300
Subject: [PATCH 01/16] Creado con Colaboratory
---
...B\303\241sico_Interactivo_de_Python.ipynb" | 982 ++++++++++++++++++
1 file changed, 982 insertions(+)
create mode 100644 "Copia_de_Tutorial_B\303\241sico_Interactivo_de_Python.ipynb"
diff --git "a/Copia_de_Tutorial_B\303\241sico_Interactivo_de_Python.ipynb" "b/Copia_de_Tutorial_B\303\241sico_Interactivo_de_Python.ipynb"
new file mode 100644
index 000000000..8a4ee6328
--- /dev/null
+++ "b/Copia_de_Tutorial_B\303\241sico_Interactivo_de_Python.ipynb"
@@ -0,0 +1,982 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "provenance": [],
+ "private_outputs": true,
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ },
+ "gpuClass": "standard"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# Tutorial Básico Interactivo de Python de Código Pitón\n",
+ "\n",
+ "\n",
+ "\n",
+ "¡Hola! **Bienvenido al Tutorial Básico Interactivo de Python de [Código Pitón](https://www.codigopiton.com/)**.\n",
+ "\n",
+ "Este tutorial recoge una guía básica de los fundamentos de Python en forma de cuaderno de Jupyter alojado en Google Colab (Colaboratory).\n",
+ "\n",
+ "Está estrechamente ligado a la [Hoja de Referencia de Python de Código Pitón](https://www.codigopiton.com/la-hoja-de-referencia-de-python/) que recibiste cuando te suscribiste a la lista de correo de Código Pitón.\n",
+ "\n",
+ "Si no tienes la Hoja de Referencia (por ejemplo, porque alguien te compartió este tutorial) puedes [conseguirla de manera gratuita al susbscribirte a Código Pitón](https://www.codigopiton.com/la-hoja-de-referencia-de-python/) y te llegará inmediatamente por correo electrónico.\n",
+ "\n",
+ "La **idea principal de este tutorial** es que tengas una guía interactiva para complementar perfectamente a la Hoja de Referencia y a la que puedas recurrir durante tu aprendizaje si te surge alguna duda. Espero que te sea de mucha utilidad.\n",
+ "\n",
+ "El tutorial tiene 15 apartados, exactamente igual que la Hoja de Referencia, y en el mismo orden, para que no te pierdas en ningún momento. Además, les he puesto el mismo nombre para que no quede lugar a ningún tipo de duda.\n",
+ "\n",
+ "¡Vamos allá!\n",
+ "\n",
+ "## Antes de empezar\n",
+ "\n",
+ "Si no estás muy familiarizado con los cuadernos de Jupyter, ¡no te preocupes! Aquí es todo muy fácil. Todo se organiza en celdas. Podrás ver celdas de texto explicativo (como este) y celdas con fragmentos de código Python ejecutable, como el siguiente:\n"
+ ],
+ "metadata": {
+ "id": "EZslL1PpIsde"
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "9NrJqYoyINXn"
+ },
+ "outputs": [],
+ "source": [
+ "print('¡Hola desde el Tutorial Básico Interactivo de Código Pitón! 😊') "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Siéntete libre de ejecutar los fragmentos de código que quieras y de modificarlos a tu gusto para experimentar y aprender, ¡ese es el objetivo de este tutorial interactivo!\n",
+ "\n",
+ "Para ejecutar un fragmento de código basta con que hagas click en el icono de ejecutar a la izquierda de cada celda. También puedes ejecutarlos con la combinación de teclas Ctrl + Enter y verás el resultado justo debajo.\n",
+ "\n",
+ "Y ahora sí, vamos con el tutorial.\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "Los contenidos son los siguientes:\n",
+ "\n",
+ "\n",
+ "1. Asignación de variables\n",
+ "2. Acceso a valor de variables\n",
+ "3. Aritmética básica\n",
+ "4. Importación de módulos\n",
+ "5. Gestión de excepciones\n",
+ "6. Salida y formato de texto\n",
+ "7. Listas\n",
+ "8. Condicionales\n",
+ "9. Booleanos y comparaciones\n",
+ "10. Comprensión de listas\n",
+ "11. Comentarios\n",
+ "12. Funciones\n",
+ "13. Bucles\n",
+ "14. Notación de porciones\n",
+ "15. Entrada por teclado\n",
+ "\n",
+ "\n",
+ "\n"
+ ],
+ "metadata": {
+ "id": "IAHwNotEQtNy"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 1. Asignación de variables\n",
+ "\n",
+ "Los principales tipos de datos son números enteros (int), números decimales (float), cadenas de texto (str) y valores booleanos (verdadero o falso, te cuento más sobre esto más adelante).\n",
+ "\n",
+ "Para realizar asignaciones utiliza nombres de variables identificativos, el símbolo = y el valor que quieras asociar a la variable."
+ ],
+ "metadata": {
+ "id": "qhinAwWbPwsG"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "x = 10 # enteros\n",
+ "y = 0.5 # decimales\n",
+ "z = 'hola' # texto\n",
+ "b = True # booleanos\n",
+ "print(x)\n",
+ "print(y)\n",
+ "print(z)\n",
+ "print(b)"
+ ],
+ "metadata": {
+ "id": "bl-PHta-TM7D"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Las principales colecciones de datos son las listas (modificables), las tuplas (no modificables), los conjuntos (que no admiten repetidos) y los diccionarios (que guardan pares clave-valor)."
+ ],
+ "metadata": {
+ "id": "ltpQ4vgOTgx6"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "tupla = (1, 2, 3)\n",
+ "lista = [4, 5.5, 'a6']\n",
+ "conjunto = ('a', 'b', 'c')\n",
+ "\n",
+ "print(tupla)\n",
+ "print(lista)\n",
+ "print(conjunto)\n",
+ "\n",
+ "diccionario = {10: 1.1, 20: 1.0, 30: 1.3}\n",
+ "diccionario[40] = 1.5 # asignando un valor (1.5) a una nueva clave (40)\n",
+ "print(diccionario)\n",
+ "\n",
+ "x, y, z = 1, 2, 3 # asignación múltiple\n",
+ "print('Tras la asignación múltiple: ')\n",
+ "print(x)\n",
+ "print(y)\n",
+ "print(z)\n",
+ "\n",
+ "print('Tras intercambiar valores: ')\n",
+ "x, y = y, x # intercambio de valores\n",
+ "print(x)\n",
+ "print(y)\n",
+ "\n",
+ "print('Tras desempaquetar una tupla en variables: ')\n",
+ "x, y, z = (10, 20, 30)\n",
+ "print(x)\n",
+ "print(y)\n",
+ "print(z)\n"
+ ],
+ "metadata": {
+ "id": "mBTQ6WUbTmSX"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 2. Acceso a valor de variables\n",
+ "\n",
+ "Cuando ya hemos hecho asignaciones y tenemos variables con valores, podemos acceder a esos valores utilizando el nombre de las variables en otras expresiones.\n",
+ "\n",
+ "Además, podemos acceder a los elementos de una lista o una tupla a través de su índice (número de posición, comenzando en 0) indicándolo entre corchetes \\[ y \\].\n",
+ "\n",
+ "Para acceder a los valores de un diccionario utilizaremos la clave asociada a cada valor, de nuevo entre corchetes.\n",
+ "\n",
+ "También podemos acceder a los atributos de una clase utilizando el nombre de la clase, un punto y a continuación el nombre del atributo. De igual manera, podemos acceder a los atributos de un objeto o instancia utilizando el nombre del objeto, un punto y a continuación el nombre del atributo.\n"
+ ],
+ "metadata": {
+ "id": "xUu-z6MPQTn8"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "lista = [10, 20, 30, 40, 50]\n",
+ "valor = lista[2]\n",
+ "print(valor)\n",
+ "\n",
+ "diccionario = {10: 5, 20: 7, 30: 9}\n",
+ "valor = diccionario[20]\n",
+ "print(valor)\n",
+ "valor = diccionario.get(40, '0') # valor por defecto 0 si clave (40) no existe\n",
+ "\n",
+ "class Clase:\n",
+ "\n",
+ " atributo_de_clase = 10\n",
+ "\n",
+ " def __init__(self):\n",
+ " self.atributo_de_instancia = 20\n",
+ "\n",
+ "\n",
+ "print(Clase.atributo_de_clase)\n",
+ "\n",
+ "instancia = Clase()\n",
+ "print(instancia.atributo_de_instancia)"
+ ],
+ "metadata": {
+ "id": "Dv3EgoExVqhr"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Más información sobre variables: https://www.codigopiton.com/variables-locales-y-globales-en-python/"
+ ],
+ "metadata": {
+ "id": "hllJO5IAMPS1"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 3. Aritmética básica\n",
+ "\n",
+ "Podemos realizar operaciones matemáticas aritméticas básicas utilizando los símbolos +, -, * (multiplicación), / (división), // (división entera), % (resto de la división entera o módulo) y \\*\\* (potencia).\n"
+ ],
+ "metadata": {
+ "id": "GXjjRcl4QzB8"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "print(3 + 5)\n",
+ "print(5 - 3)\n",
+ "print(5 * 3)\n",
+ "print(5 / 3)\n",
+ "print(5 // 3)\n",
+ "print(5 % 3)\n",
+ "print(5 ** 3)"
+ ],
+ "metadata": {
+ "id": "SSDZqkv8XRer"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 4. Importación de módulos\n",
+ "\n",
+ "Si necesitas utilizar una librería (tanto de Python como externa) tendrás que importar el módulo correspondiente con import. \n",
+ "\n",
+ "Podrás darle un alias al módulo si utilizas as.\n",
+ "\n",
+ "También puedes importar un componente concreto de un módulo a través de from."
+ ],
+ "metadata": {
+ "id": "WItnb6q8Q-fp"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import datetime\n",
+ "\n",
+ "print(datetime.datetime.now())"
+ ],
+ "metadata": {
+ "id": "aVd-5GYuYY8f"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import datetime as dt\n",
+ "\n",
+ "print(dt.datetime.now())"
+ ],
+ "metadata": {
+ "id": "pmez2i-FYx0G"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "from datetime import datetime as dt\n",
+ "\n",
+ "print(dt.now())"
+ ],
+ "metadata": {
+ "id": "u52AMnEFY3Cf"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 5. Gestión de excepciones\n",
+ "\n",
+ "Para manejar errores y excepciones tienes que usar la construcción try - except - finally. De no hacerlo, el código interrumpe su ejecución en caso de surgir algún error.\n",
+ "\n",
+ "Algunos de los errores más comunes son los siguientes:\n",
+ "* SyntaxError: sintaxis incorrecta\n",
+ "* ValueError: valor argumento no válido\n",
+ "* ZeroDivisionError: división por cero\n",
+ "* NameError: variable no definida\n",
+ "* ModuleNotFoundError: modulo no existe\n",
+ "* FileNotFoundError: fichero no existe\n",
+ "* IndexError: índice no existe\n",
+ "* KeyError: clave no existe\n",
+ "\n",
+ "\n",
+ "\n"
+ ],
+ "metadata": {
+ "id": "j_bTR38XRB1Y"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# El siguiente código genera un error\n",
+ "\n",
+ "a = 10\n",
+ "b = 0\n",
+ "\n",
+ "print(a/b) # no se puede dividir por cero"
+ ],
+ "metadata": {
+ "id": "-XPkB0XRbR88"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Vamos a controlar el error para que no se interrumpa la ejecución\n",
+ "\n",
+ "a = 10\n",
+ "b = 0\n",
+ "\n",
+ "try:\n",
+ " print(a/b)\n",
+ "except ZeroDivisionError:\n",
+ " print('Lo siento, no puedo dividir por cero.')\n",
+ "finally:\n",
+ " print('Bloque try-except finalizado') # esto, que es opcional, se ejecuta siempre, haya error o no\n",
+ " "
+ ],
+ "metadata": {
+ "id": "fp6wj4dybZI4"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 6. Salida y formato de texto\n",
+ "\n",
+ "Ya has visto que la función *print* se utiliza para mostrar información por pantalla.\n",
+ "\n",
+ "Podemos personalizar la manera en que se muestra esa información de múltiples maneras. Algunas formas sencillas y básicas son la siguientes:"
+ ],
+ "metadata": {
+ "id": "e-4K3kjIRIee"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "a = 10\n",
+ "b = 20\n",
+ "c = 30.158\n",
+ "print(a)\n",
+ "print('b=' + str(b)) # convertimos un numero a string con str\n",
+ "\n",
+ "print('a=%i' % a) # usamos una máscara de número entero (%i) dentro de la cadena de texto\n",
+ "print('a=%i, b=%i' % (a, b))\n",
+ "\n",
+ "print('a={}, b={}'.format(a, b))\n",
+ "print('c={:.2f}'.format(c)) # puedes indicar se se usen solo dos decimales para un float\n",
+ "\n",
+ "print(f'a={a}, b={b}') # usamos f-strings, la forma preferida\n"
+ ],
+ "metadata": {
+ "id": "soEeTeTKcHDu"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 7. Listas\n",
+ "\n",
+ "Podemos hacer muchas cosas con las listas, pues son secuencias muy potentes. Veamos algunas:"
+ ],
+ "metadata": {
+ "id": "OowBr9SiOINH"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "lista = [5, 6, 7]\n",
+ "\n",
+ "lista.append(8) # añadimos un elemento al final\n",
+ "print(lista)\n",
+ "\n",
+ "lista.insert(1, 10) # insertamos un elemento en la posición que queramos\n",
+ "print(lista)\n",
+ "\n",
+ "lista.remove(6) # eliminamos un elemento\n",
+ "del lista[0] # eliminamos una posición\n",
+ "print(lista)\n",
+ "\n",
+ "lista.clear() # vacíamos la lista\n",
+ "print(lista)\n",
+ "\n",
+ "lista = [5, 6, 7]\n",
+ "elementos = [8, 9]\n",
+ "\n",
+ "lista.extend(elementos) # añadimos al final los elementos de otra lista\n",
+ "print(lista)\n",
+ "\n",
+ "lista.reverse() # invertimos la lista (le damos la vuelta)\n",
+ "print(lista)\n",
+ "\n",
+ "print(len(lista)) # obtenemos el número de elementos (o longitud) de una lista\n",
+ "\n",
+ "print(lista.index(7)) # obtenemos el índice de un elemento\n",
+ "\n"
+ ],
+ "metadata": {
+ "id": "ahagt7kyeE5J"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Aquí tienes más información sobre cómo obtener la posición o índice de un elemento en una lista: https://www.codigopiton.com/encontrar-indice-de-elemento-en-lista-en-python/"
+ ],
+ "metadata": {
+ "id": "nyQRye6VfOcC"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 8. Condicionales\n",
+ "\n",
+ "Las condicionales nos permiten ejecutar un determinado fragmento de código si se cumple una determinada condición (rama if).\n",
+ "\n",
+ "Además, podemos indicar que, si no se cumple dicha condición, se ejecute otro código (rama else).\n",
+ "\n",
+ "Finalmente, se permite encadenar varias ramas ifs con distintas condiciones (elif) y una rama else si no se cumple ninguna de las condiciones indicadas. Las ramas aquí son excluyentes."
+ ],
+ "metadata": {
+ "id": "ju3H-DAjOId7"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "a = 10\n",
+ "b = 20\n",
+ "\n",
+ "if a < 15:\n",
+ " print('a es menor que 15') # esto se ejecutará ya que se cumple la condición\n",
+ "\n",
+ "\n",
+ "if a > 15:\n",
+ " print('a es mayor que 15') # esto no se ejecutará ya que no se cumple la condición\n",
+ "\n",
+ "if a > 30:\n",
+ " print('a es mayor que 30') # esto no se ejecutará ya que no se cumple la condición\n",
+ "else:\n",
+ " print('a no es mayor que 30') # esto sí se ejecutará ya que no se cumple la condición\n",
+ "\n",
+ "\n",
+ "if b > 10:\n",
+ " print('b es mayor que 10') # esto se ejecutará ya que se cumple la condición\n",
+ "else:\n",
+ " print('b no es mayor que 10') # esto no se ejecutará ya que se cumple la condición\n",
+ "\n",
+ "\n",
+ "# a continuación se comprobaran las condiciones secuencialmente y se ejecutara \n",
+ "# solo el fragmento de código de la condición que se cumpla (condiciones excluyentes)\n",
+ "\n",
+ "if a < 10:\n",
+ " print('a es menor que 10')\n",
+ "elif a > 12:\n",
+ " print('a es mayor que 12')\n",
+ "elif b > 15:\n",
+ " print('b es mayor que 15') # esta es la rama que se ejecuta\n",
+ "elif b == 20:\n",
+ " print('b es igual a 20') # aunque la condición de esta rama es cierta no se ejcuta\n",
+ " # pues ya se ejecutó otra rama antes\n",
+ "else:\n",
+ " print('no se ha cumplido ninguna de las condiciones anteriores')"
+ ],
+ "metadata": {
+ "id": "JV2mITN3a2TG"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Más información sobre condicionales: https://www.codigopiton.com/condicionales-en-python-mucho-mas-que-if-else/\n",
+ "\n",
+ "La estrucutura de control switch no existe en Python. Más información sobre cómo hacer switch en Python: https://www.codigopiton.com/como-hacer-switch-case-en-python/\n",
+ "\n",
+ "En Python existe, además, un operador ternario condicional: https://www.codigopiton.com/el-operador-ternario-condicional-en-python/\n",
+ "\n",
+ "Aunque desde la versión 3.10 de Python existe un mecanismo de \"pattern matching\" que se puede utilizar para emular un switch. Más información: https://peps.python.org/pep-0636/"
+ ],
+ "metadata": {
+ "id": "EPh-Axa2cc1L"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 9. Booleanos y comparaciones\n",
+ "\n",
+ "Ahora que ya sabes cómo hacer condicionales, vamos a revisar los valores booleanos y las principales posibles comparaciones y comprobaciones que se pueden hacer en Python que devuelven valores booleanos.\n",
+ "\n",
+ "Los valores booleanos, son True y False (escritos con inicial mayúscula) y cuyo significado es \"cierto\" y \"falso\" respectivamente.\n",
+ "\n",
+ "Comparaciones y comprobaciones principales:\n",
+ "* Mayor: >\n",
+ "* Mayor o igual: >=\n",
+ "* Menor: <\n",
+ "* Menor o igual: <=\n",
+ "* Igual: ==\n",
+ "* Diferente: !=\n",
+ "* Pertenencia: in\n",
+ "\n",
+ "Puedes negar un valor booleano o condición para obtener el valor contrario con la palabra reservada \"not\"."
+ ],
+ "metadata": {
+ "id": "rQKB2F9AOIr2"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "a = 2\n",
+ "b = 3\n",
+ "\n",
+ "print('Comparaciones simples:')\n",
+ "print(a > b)\n",
+ "print(a >= b)\n",
+ "print(a < b)\n",
+ "print(a <= b)\n",
+ "print(a == b)\n",
+ "print(a != b)\n",
+ "\n",
+ "print('Comprobación de pertenencia:')\n",
+ "lista = [1, 3, 5]\n",
+ "print(a in lista)\n",
+ "print(b in lista)\n",
+ "\n",
+ "print('Negación con not')\n",
+ "print(not True)\n",
+ "print(not False)\n",
+ "print(not a > b)\n",
+ "print(not a == b)\n"
+ ],
+ "metadata": {
+ "id": "aBjkpZRyd8V9"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Más información sobre booleanos, comparaciones, condicionales, etc.: https://www.codigopiton.com/condicionales-en-python-mucho-mas-que-if-else/"
+ ],
+ "metadata": {
+ "id": "ZZKF7GPaeoZO"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Puedes combinar distintas comparaciones para crear una más compleja con las palabras reservadas \"and\" y \"or\".\n",
+ "\n",
+ "Cuando usas and entre dos comparaciones o condiciones, ambas deben ser True para que la condición combinada sea True.\n",
+ "\n",
+ "Cuando usas or entre dos comparaciones o condiciones, al menos una de ellas tiene que ser True para que la condición combinada sea True."
+ ],
+ "metadata": {
+ "id": "2tzz0ZRjwqHo"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "a = 2\n",
+ "b = 3\n",
+ "print(b >= 3 and a == 2)\n",
+ "print(a < 10 and b < 2)\n",
+ "print(a == 2 or b == 0)\n",
+ "print(a < 0 or b < 0)"
+ ],
+ "metadata": {
+ "id": "Mu96IFV6xECQ"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 10. Comprensión de listas\n",
+ "\n",
+ "En Python podemos generar listas \"al vuelo\" utilizando un bucle for que devuelva un elemento e en cada iteración, aplicando un cálculo o expresión sobre e y encerrándolo todo entre [corchetes](https://www.codigopiton.com/parentesis-corchetes-llaves-en-python/). \n",
+ "\n",
+ "De esta manera se genera una lista con todos los elementos generados a partir de e.\n",
+ "\n",
+ "Ejemplos:"
+ ],
+ "metadata": {
+ "id": "MVkNPcwDOI6A"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "lista = [10, 20, 30]\n",
+ "\n",
+ "lista_negada = [ -e for e in lista ]\n",
+ "lista_doble = [ e*2 for e in lista]\n",
+ "\n",
+ "print(lista_negada)\n",
+ "print(lista_doble)"
+ ],
+ "metadata": {
+ "id": "gEhGP1_bfcp2"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 11. Comentarios\n",
+ "\n",
+ "En el código que escribas puedes (y debes) incluir comentarios explicativos.\n",
+ "\n",
+ "Los comentarios no son interpretados por el interprete de Python y no afectan al código ni a su ejecución.\n",
+ "\n",
+ "Puedes usar el símbolo \\# para añadir un comentario al principio o al final de una línea (como ya has visto en este tutorial).\n",
+ "\n",
+ "Además, si necesitas hacer un comentario de varias líneas basta con que lo encierres en triples comillas ' ' ' o \" \" \".\n",
+ "\n",
+ "Ejemplos:\n"
+ ],
+ "metadata": {
+ "id": "NZjQEM3MOJGX"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# inicialización de variables (este es un comentario de una línea)\n",
+ "a = 10\n",
+ "b = 20\n",
+ "\n",
+ "''' En este comentario de varias líneas\n",
+ "voy a explicar lo que hago a continuación:\n",
+ "sumaré los valores de a y b y si suman más de 25\n",
+ "mostraré un mensaje de éxito por pantalla '''\n",
+ "\n",
+ "if a + b > 25:\n",
+ " print('¡Éxito!') # este será mi mensaje de éxito"
+ ],
+ "metadata": {
+ "id": "HtJvtFjbgbMA"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 12. Funciones\n",
+ "\n",
+ "Tanto para estructurar nuestro código así como para favorecer la reutilización del mismo se utilizan funciones.\n",
+ "\n",
+ "Las funciones nos permiten encapsular un fragmento de código y darle un nombre.\n",
+ "\n",
+ "Para definir una función usamos la palabra reservada \"def\" a continuación el nombre de la función y los parámetros que necesitemos entre paréntesis. La función puede devolver uno o varios valores si lo necesita (o ninguno).\n",
+ "\n",
+ "Después se puede invocar una función creada a través de su nombre."
+ ],
+ "metadata": {
+ "id": "QWnzNyKROJSs"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "def suma(a, b):\n",
+ " return a + b\n",
+ "\n",
+ "\n",
+ "# min y max son funciones integradas en Python que nos devuelven\n",
+ "# los valores mínimo y máximo de un iterable (como las listas o las tuplas)\n",
+ "def min_y_max(lista):\n",
+ " return min(lista), max(lista)\n",
+ "\n",
+ "\n",
+ "# ahora vamos a usar estas funciones\n",
+ "valor = suma(10, 15)\n",
+ "print(valor)\n",
+ "\n",
+ "minimo, maximo = min_y_max([30, 10, 50, 40, 20])\n",
+ "print(f'min y max son {minimo} y {maximo}')\n"
+ ],
+ "metadata": {
+ "id": "DD5-_oeLsiNX"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 13. Bucles\n",
+ "\n",
+ "Los bucles son un mecanismo de control de flujo que nos permite repetir un fragmento de código un número determinado de veces.\n",
+ "\n",
+ "Hay dos tipos:\n",
+ "\n",
+ "\n",
+ "1. while, que nos permite controlar mediante una condición el número de repeticiones.\n",
+ "2. for, que nos permite iterar por los elementos de una colección de manera sencilla y cómoda.\n",
+ "\n",
+ "El código que queremos repetir, también llamado \"cuerpo del bucle\" debe indentarse tras el for o el while.\n",
+ "\n"
+ ],
+ "metadata": {
+ "id": "yJaf1DpiOJeh"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# ejemplo de while\n",
+ "a = 0\n",
+ "\n",
+ "while (a < 10): # mientras a sea < 10 el cuerpo del bucle se repetirá\n",
+ " print(a)\n",
+ " a = a + 1 # sumamos 1 a la variable a para asegurarnos de que la condición del bucle será False en algún momento\n",
+ "\n",
+ "# ejemplo de for\n",
+ "lista = [10, 20, 30, 40]\n",
+ "\n",
+ "for elemento in lista:\n",
+ " print(elemento)\n",
+ "\n"
+ ],
+ "metadata": {
+ "id": "lIfvC-pN_QhY"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Dentro de los bucles puedes utilizar las sentencias de control break y continue:\n",
+ "* break termina anticipadamente el bucle\n",
+ "* continue interrumpe la vuelta actual del bucle y continúa con la siguiente."
+ ],
+ "metadata": {
+ "id": "6_U1A3i9AEdq"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 14. Notación de porciones\n",
+ "\n",
+ "Cuando tenemos una colección de elementos indexados por posición (como una lista o una tupla), podemos acceder a una porción concreta utilizando la notación de porciones.\n",
+ "\n",
+ "Se utilizan los corchetes entre los que indicamos tres números separados por el carácter ':'. De esta manera\n",
+ "\n",
+ "lista\\[ini:fin:paso\\]\n",
+ "\n",
+ "Donde:\n",
+ "* ini es la posición del elemento primero en nuestra porción.\n",
+ "* fin es la posición del elemeto último (no incluido) de nuestra porción (el último incluido será el correspondiente a la posición fin -1).\n",
+ "* paso (optativo) indica la manera en la que tomaremos la porción: si es un número positivo tomaremos los elementos en el orden en el que aparecen, si es negativo los tomaremos en orden inverso (fin tiene que ser anterior a ini). Si la magnitud es 1, tomaremos todos los elementos, si es 2, tomaremos uno y saltaremos otro, si es 3, tomaremos uno y saltaremos 2, etc.\n",
+ "\n",
+ "Si dejamos ini o fin sin indicar se interpreta que la porción se toma desde el comienzo o el final respectivamente.\n",
+ "\n",
+ "Veamos algunos ejemplos:\n"
+ ],
+ "metadata": {
+ "id": "WQw19GRlOJrp"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "lista = [10, 20, 30, 40, 50, 60]\n",
+ "\n",
+ "print(lista[2:5]) # tomamos del 2 al 5 (sin incluir el 5)\n",
+ "print(lista[4:]) # tomamos del 4 hasta el final\n",
+ "print(lista[:2]) # tomamos desde el principio hasta el 2 (sin incluir)\n",
+ "print(lista[1:6:2]) # tomamos 1 de cada 2 elementos desde el 1 hasta el 6 (sin incluir)\n",
+ "print(lista[4:1:-1]) # tomamos en orden inverso desde el 4 al 1 (sin incluir)\n",
+ "print(lista[:]) # tomamos desde el principio hasta el final (es como hacer una copia de la lista)\n",
+ "print(lista[::-1]) # tomamos desde el final hasta el principip (orden inverso) "
+ ],
+ "metadata": {
+ "id": "rxqQW9h2Hvja"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 15. Entrada por teclado\n",
+ "\n",
+ "Si necesitamos hacer un programa o script interactivo, a menudo necesitaremos pedir algún valor al usuario por teclado.\n",
+ "\n",
+ "Python nos proporciona la función integrada \"input\" que nos sirve precisamente para eso. Al ejecutarse \"input\" el programa se queda esperando a que el usuario introduzca un valor y pulse intro. Posteriormente ese valor se guarda en la variable que queramos en formato string.\n",
+ "\n",
+ "Podemos hacer la conversión a un tipo numérico si así lo deseamos llamando a las funciones int o float."
+ ],
+ "metadata": {
+ "id": "BBXUukIZOJ3n"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "entrada = input('Dame tu nombre, por favor: ')\n",
+ "print(f'¡Hola, {entrada}!')\n",
+ "entrada = input('Dame un número entero, por favor: ')\n",
+ "numero = int(entrada) # convertimos entrada a int\n",
+ "print(f'El número es {numero}')"
+ ],
+ "metadata": {
+ "id": "RnvW1ddeJU-1"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# Ejercicio final: juego de adivinar un número entre 1 y 10\n",
+ "\n",
+ "Para finalizar este tutorial, voy a realizar un pequeño juego en el que el usuario tiene que adivinar un número generado al azar entre 1 y 10 y en el que solo tendrá 3 intentos para hacerlo.\n",
+ "\n",
+ "Para esto voy a utilizar muchas de las cosas contadas arriba. Además, comentaré el código para que todo quede perfectamente claro. Léelo con calma intentando comprender cada línea.\n",
+ "\n",
+ "Y, por supuesto, ¡puedes ejecutarlo para jugar tú!\n"
+ ],
+ "metadata": {
+ "id": "XCN38-bphFTC"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import random # necesitamos esta librería para poder generar un número al azar\n",
+ "\n",
+ "numero_secreto = random.randint(1, 10) # esto nos genera un número aleatorio entre 1 y 10\n",
+ "oportunidades = 3 # el número de oportunidades que nos quedan\n",
+ "acertado = False # esta variable nos servirá para saber si el usuario ha acertado\n",
+ "\n",
+ "print('* Bienvenido a nuestro pequeño juego del Tutorial Básico Interactivo de Código Pitón')\n",
+ "print() # imprimimos por pantalla una línea en blanco\n",
+ "print('Acabo de pensar un número secreto entre 1 y 10. Tienes tres oportunidades para')\n",
+ "print('adivinarlo. Te iré guiando un poco hacia la solución. ¡Suerte!')\n",
+ "print()\n",
+ "\n",
+ "# Hacemos un bucle mientras queden oportunidades y mientras no se haya acertado el número secreto\n",
+ "while oportunidades > 0 and not acertado:\n",
+ " \n",
+ " # Pedimos un número al usuario (y transformamos lo que escriba a entero mediante la función int)\n",
+ " # ¡Cuidado! Si lo que escribe el usuario no es un entero el programa generará un error\n",
+ " # El error puede ser controlado con try-except como vimos más arriba\n",
+ " numero = int(input('Dime un número entre 1 y 10: '))\n",
+ "\n",
+ " # Ahora vamos a hacer la comprobación\n",
+ " # e indicamos al usuario si el número secreto es mayor, menor o si lo ha averiguado\n",
+ " if numero < numero_secreto:\n",
+ " print('Te has quedado corto, el número secreto es más grande.')\n",
+ " elif numero > numero_secreto:\n",
+ " print('Te has pasado, el número secreto es más pequeño.')\n",
+ " else:\n",
+ " print(f'¡Enhorabuena! Has acertado en el intento {4-oportunidades}.')\n",
+ " acertado = True # ponemos acertado a cierto para que se detenga el bucle\n",
+ "\n",
+ " if not acertado: # si no ha acertado indicamos las oprtunidades que le quedan\n",
+ " oportunidades = oportunidades - 1 # restamos 1 a las oportunidades\n",
+ " print(f'Te quedan {oportunidades} oportunidades.')\n",
+ "\n",
+ " print()\n",
+ "\n",
+ "# cuando termine el bucle de juego mostramos el número de adinivinar\n",
+ "# y nos despedimos del usuario\n",
+ "\n",
+ "if not acertado: # si no se acierta el número se muestra por pantalla\n",
+ " print(f'* El número secreto era {numero_secreto}.')\n",
+ "\n",
+ "print('* ¡Gracias por jugar! ¡Hasta pronto!') \n",
+ "\n"
+ ],
+ "metadata": {
+ "id": "8hziKM46ho_K"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "**¡Muchas gracias por haber usado este tutorial!**\n",
+ "\n",
+ "Recurre a él todas las veces que te haga falta hasta que te queden claros sus conceptos.\n",
+ "\n",
+ "Y no dejes de visitar [Código Pitón](https://www.codigopiton.com/).\n",
+ "\n",
+ "Un saludo,\n",
+ " \n",
+ "Juan.-\n",
+ "\n",
+ "P.S. ¿Te atreves a modificar el juego que hemos visto para que al terminar el juego el programa le pregunte al usuario si quiere volver a jugar? Si el usuario dice que sí, se vuelve a \"pensar\" un número secreto y se juega de nuevo. Si el usuario dice que no, se termina el programa."
+ ],
+ "metadata": {
+ "id": "0MrEzDjjnuD8"
+ }
+ }
+ ]
+}
\ No newline at end of file
From 6ae55380ac4331d6dc8b6325fc27c3bc6381a3d9 Mon Sep 17 00:00:00 2001
From: Jorge Cordova <55065873+jcordovaj@users.noreply.github.com>
Date: Sun, 22 Jan 2023 02:36:24 -0300
Subject: [PATCH 02/16] =?UTF-8?q?Actualizaci=C3=B3n=20220123?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
Workbench/Taller/Apuntes01.ipynb | 80 ++++
Workbench/Taller/EstructurasControl.py | 1 +
Workbench/Taller/Funciones | 33 ++
Workbench/Taller/Hello-world.py | 2 +
Workbench/Taller/Mix_ejercicios.py | 634 +++++++++++++++++++++++++
Workbench/Taller/aritmetica.py | 22 +
Workbench/Taller/comment.py | 16 +
Workbench/Taller/datatypes.py | 51 ++
Workbench/Taller/listas.py | 77 +++
Workbench/Taller/variables.py | 11 +
10 files changed, 927 insertions(+)
create mode 100644 Workbench/Taller/Apuntes01.ipynb
create mode 100644 Workbench/Taller/EstructurasControl.py
create mode 100644 Workbench/Taller/Funciones
create mode 100644 Workbench/Taller/Hello-world.py
create mode 100644 Workbench/Taller/Mix_ejercicios.py
create mode 100644 Workbench/Taller/aritmetica.py
create mode 100644 Workbench/Taller/comment.py
create mode 100644 Workbench/Taller/datatypes.py
create mode 100644 Workbench/Taller/listas.py
create mode 100644 Workbench/Taller/variables.py
diff --git a/Workbench/Taller/Apuntes01.ipynb b/Workbench/Taller/Apuntes01.ipynb
new file mode 100644
index 000000000..a07c97eb9
--- /dev/null
+++ b/Workbench/Taller/Apuntes01.ipynb
@@ -0,0 +1,80 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hello World\n"
+ ]
+ }
+ ],
+ "source": [
+ "print (\"Hello World\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "página1\n",
+ "página2\n",
+ "página3\n",
+ "página4\n"
+ ]
+ }
+ ],
+ "source": [
+ "libro = ['página1', 'página2', 'página3', 'página4']\n",
+ "marcapaginas = iter(libro)\n",
+ "print(next(marcapaginas))\n",
+ "print(next(marcapaginas))\n",
+ "print(next(marcapaginas))\n",
+ "print(next(marcapaginas))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "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.10.6"
+ },
+ "orig_nbformat": 4,
+ "vscode": {
+ "interpreter": {
+ "hash": "d3777ed8f5fe800f0d3d1926318eb186c93d9a88e13881725c87e5bdd2f1dd1d"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Workbench/Taller/EstructurasControl.py b/Workbench/Taller/EstructurasControl.py
new file mode 100644
index 000000000..36623ca54
--- /dev/null
+++ b/Workbench/Taller/EstructurasControl.py
@@ -0,0 +1 @@
+# Uso de IF/ELIF/ELSE, FOR, WHILE, otros ciclos
diff --git a/Workbench/Taller/Funciones b/Workbench/Taller/Funciones
new file mode 100644
index 000000000..41dcd2983
--- /dev/null
+++ b/Workbench/Taller/Funciones
@@ -0,0 +1,33 @@
+
+def misuma (a,b):
+ return a+b
+
+res= misuma (2,3)
+print (res)
+
+def suma(a, b):
+ return a + b
+
+
+
+# min y max son funciones integradas en Python que nos devuelven
+# los valores mínimo y máximo de un iterable (como las listas o las tuplas)
+def min_y_max(lista):
+ return min(lista), max(lista)
+
+
+# ahora vamos a usar estas funciones
+valor = suma(10, 15)
+print(valor)
+
+minimo, maximo = min_y_max([30, 10, 50, 40, 20])
+print(f'min y max son {minimo} y {maximo}')
+
+"""
+def test_OrdenarDiccionario_03(self):
+ dicc = {'clave1':['c','a','b'], 'clave2':['casa','auto','barco'], 'clave3':[3,1,2]}
+ valor_test = ch.OrdenarDiccionario(dicc, 'clave3', False)
+ valor_esperado = {'clave1':['b','a','c'], 'clave2':['barco','auto','casa'], 'clave3':[3,2,1]}
+ """
+
+"""
\ No newline at end of file
diff --git a/Workbench/Taller/Hello-world.py b/Workbench/Taller/Hello-world.py
new file mode 100644
index 000000000..c7a3e0986
--- /dev/null
+++ b/Workbench/Taller/Hello-world.py
@@ -0,0 +1,2 @@
+print ("Hello World")
+print ("hello", "world", 2023)
diff --git a/Workbench/Taller/Mix_ejercicios.py b/Workbench/Taller/Mix_ejercicios.py
new file mode 100644
index 000000000..c7df605fb
--- /dev/null
+++ b/Workbench/Taller/Mix_ejercicios.py
@@ -0,0 +1,634 @@
+Variables
+a = 'Hola '
+b = 'Mundo !'
+print(a + b)
+# Hola Mundo !
+x = 3
+y = 12
+print(x + y)
+15
+print(a + x)
+"""
+"---------------------------------------------------------------------------"
+
+TypeError Traceback (most recent call last)
+~\AppData\Local\Temp/ipykernel_18232/136165486.py in
+----> 1 print(a + x)
+
+TypeError: can only concatenate str (not "int") to str
+"""
+# Dividir "y" entre "x"
+y = 9
+x = 3
+print(y/x)
+3.0
+# Potencia de "y" elevado a la "x"
+y = 2
+x = 4
+print(y**x)
+16
+# Devolver el resto de la división
+y = 13
+x = 3
+print(y%x)
+1
+# Ciclo IF/ELIF/ELSE
+valor = 0
+if (valor < 0):
+ print('El número es negativo')
+elif (valor > 0):
+ print('El número es positivo')
+else:
+ print('El número es igual a cero')
+# El número es igual a cero
+
+# Ciclo FOR - Caso 1
+for n in range(1,10): #Incluye el primero y excluye el último
+ print(n, end(", "))
+
+# Ciclo WHILE
+n = 1
+while (n < 10):
+ print(n)
+ n = n + 1
+"""
+1
+2
+3
+4
+5
+6
+7
+8
+9
+"""
+# Lista
+
+# Caso 1 - Inicializa una lista y muestra la cantidad de elementos
+
+edad = (3,1,0.2,8,7) #Declara un objeto lista y le asigna elementos
+print (len(edad)) #Imprime la cantidad de elementos de la lista usando la función LEN
+#5 # La función retorno 5
+
+# Caso 2 - Identificar el tipo de variable usando la función TYPE, retorno el tipo de dato
+mi_lista = ['Rojo','Azul','Amarillo','Naranja','Violeta','Verde']
+type(mi_lista)
+# list
+print(mi_lista)
+['Rojo', 'Azul', 'Amarillo', 'Negro', 'Naranja', 'Violeta', 'Verde']
+print(mi_lista[0:2])
+['Rojo', 'Azul']
+print(mi_lista[:2])
+['Rojo', 'Azul']
+print(mi_lista[1:])
+['Azul', 'Amarillo']
+mi_lista.insert(3,'Negro')
+print(mi_lista.index('Azul'))
+# 1
+mi_lista.insert(3,'Negro')
+mi_lista.extend(['Marrón','Gris'])
+print(['a','b','c'] * 3)
+# ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
+print(mi_lista.index('Azul'))
+# 1
+mi_lista.remove('Blanco')
+
+"""
+---------------------------------------------------------------------------
+ValueError Traceback (most recent call last)
+~\AppData\Local\Temp/ipykernel_10044/2480624766.py in
+----> 1 mi_lista.remove('Blanco')
+
+ValueError: list.remove(x): x not in list
+mi_lista.remove('Negro')
+---------------------------------------------------------------------------
+ValueError Traceback (most recent call last)
+~\AppData\Local\Temp/ipykernel_10044/298389232.py in
+----> 1 mi_lista.remove('Negro')
+
+ValueError: list.remove(x): x not in list
+"""
+ultimo = mi_lista.pop()
+ultimo = mi_lista.pop()
+print(ultimo)
+# Gris
+ultimo = mi_lista.pop()
+ultimo
+# 'Amarillo'
+mi_tupla=tuple(mi_lista)
+print(mi_tupla[1])
+# Azul
+'Rojo' in mi_tupla
+# True
+mi_tupla.count('Rojo')
+# 1
+print(mi_lista[:] * 3)
+# ['Rojo', 'Azul', 'Amarillo', 'Negro', 'Marrón', 'Gris', 'Rojo', 'Azul', 'Amarillo', 'Negro', 'Marrón', 'Gris', 'Rojo', 'Azul', 'Amarillo', 'Negro', 'Marrón', 'Gris']
+mi_tupla.count('Rojo')
+# 1
+mi_tupla='Gaspar', 5, 8, 1999
+nombre, dia, mes, año = mi_tupla
+print("Nombre: ", nombre, " - Dia:", dia, " - Mes: ", mes, " - Año: ", año)
+# Nombre: Gaspar - Dia: 5 - Mes: 8 - Año: 1999
+nombre = 'Darío'
+edad = 39
+print(nombre, edad)
+print("Mi nombre es", nombre, ". Mi edad es", edad, "años")
+print("Mi nombre es {}. Mi edad es {} años". format(nombre, edad))
+# Darío 39
+# Mi nombre es Darío . Mi edad es 39 años
+# Mi nombre es Darío. Mi edad es 39 años
+
+mi_diccionario = { 'Colores Primarios': ['Rojo','Azul','Amarillo'],
+ 'Colores secundarios': ['Naranja','Violeta','Verde'],
+ 'Clave3': 10,
+ 'Clave4': False}
+print(mi_diccionario['Colores secundarios'])
+# ['Naranja', 'Violeta', 'Verde']
+
+mi_diccionario={'Clave1':'Valor1', 'Clave2':{'numeros':[1,2,3,4,5]}}
+print(mi_diccionario.keys())
+# dict_keys(['Clave1', 'Clave2'])
+print(mi_diccionario.values())
+# dict_values(['Valor1', {'numeros': [1, 2, 3, 4, 5]}])
+len (mi_diccionario)
+# 2
+
+edad = 60
+edad_compa = 50
+if (edad < edad_compa):
+ print(edad)
+ if (edad < 100):
+ print(edad + 100)
+ else:
+ print(edad - 100)
+else:
+ print(edad_compa)
+# 50
+
+primeros_10 = [0,1,2,3,4,5,6,7,8,9]
+print(primeros_10)
+# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+for n in primeros_10:
+ if (n%2 == 0):
+ print(n)
+ primeros_10[n]=0
+print("\va de nuevo....\n")
+"""
+0
+2
+4
+6
+8
+# va de nuevo....
+"""
+
+print(primeros_10)
+# [0, 1, 0, 3, 0, 5, 0, 7, 0, 9]
+
+for n in primeros_10:
+ print(primeros_10[n])
+print("\va de nuevo....\n")
+"""
+0
+1
+0
+3
+0
+5
+0
+7
+0
+9
+va de nuevo....
+"""
+
+print(primeros_10[9])
+# 9
+primeros_10 = ['a','b','c','d']
+primeros_10[4]
+"""
+---------------------------------------------------------------------------
+IndexError Traceback (most recent call last)
+ in
+----> 1 primeros_10[4]
+
+IndexError: list index out of range
+"""
+n = 40
+sequence = [0,1]
+for i in range(2,n):
+ sequence.append(sequence[i-1]+sequence[i-2])
+print (sequence)
+# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181,
+# 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269,
+# 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986]
+
+mi_diccionario = { 'Colores Primarios': ['Rojo','Azul','Amarillo'],
+ 'Colores secundarios': ['Naranja','Violeta','Verde'],
+ 'Clave3': 10,
+ 'Clave4': False}
+print(mi_diccionario['Colores secundarios'])
+# ['Naranja', 'Violeta', 'Verde']
+
+mi_diccionario['Clave3']=2
+
+mi_diccionario
+{'Argentina': 'Buenos Aires', 'Italia': 'Roma', 'Inglaterra': 'Londres'}
+mi_diccionario['Clave5']='Otro ejemplo'
+mi_tupla=("Argentina", "Italia", "Inglaterra")
+mi_diccionario={mi_tupla[0]:"Buenos Aires", mi_tupla[1]:"Roma", mi_tupla[2]:"Londres"}
+mi_diccionario={'Clave1':'Valor1', 'Clave2':(1,2,3,4,5)}
+type(mi_diccionario['Clave2'])
+# tuple
+mi_diccionario={'Clave1':'Valor1', 'Clave2':{'numeros':[1,2,3,4,5]}}
+type(mi_diccionario['Clave2'])
+# dict
+mi_diccionario={'Clave1':'Valor1', 'Clave2':[1,2,3,4,5]}
+type(mi_diccionario['Clave2'])
+# list
+print(mi_diccionario.keys())
+# dict_keys(['Clave1', 'Clave2'])
+print(mi_diccionario.values())
+# dict_values(['Valor1', [1, 2, 3, 4, 5]])
+len(mi_tupla)
+# 3
+
+def imprimir_valor_variable(var):
+ print('El valor de la variable es' + str(var))
+imprimir_valor_variable(mi_lista)
+# El valor de la variable es['Rojo', 'Azul', 'Amarillo', 'Negro', 'Marrón', 'Gris']
+
+def ordenar_dos_numeros(num1, num2):
+ if (num1 > num2):
+ return num2, num1
+ else:
+ return num1, num2
+
+ordenar_dos_numeros(8,1)
+# (1, 8)
+
+def factorial(numero):
+# Devuelve el factorial
+ if (numero > 1):
+ numero = numero * factorial(numero - 1)
+ return numero
+
+factorial(3)
+# 6
+#help(factorial)
+#Help on function factorial in module __main__:
+
+#factorial(numero)
+# Devuelve el factorial
+
+def dividir(dividendo, divisor = 1):
+ if (divisor == 0):
+ return 'No se puede dividir por cero'
+ else:
+ return dividendo / divisor
+print(dividir(10))
+# 10.0
+print(divisor)
+"""
+---------------------------------------------------------------------------
+NameError Traceback (most recent call last)
+~\AppData\Local\Temp/ipykernel_10044/1862935505.py in
+----> 1 print(divisor)
+
+NameError: name 'divisor' is not defined
+"""
+
+divisor = 5
+def dividir(dividendo):
+ if (divisor == 0):
+ return 'No se puede dividir por cero'
+ else:
+ return dividendo / divisor
+print(dividir(10))
+# 2.0
+print(divisor)
+# 5
+
+divisor = 5
+
+def dividir(dividendo, divisor = 1):
+ if (divisor == 0):
+ return 'No se puede dividir por cero'
+ else:
+ return dividendo / divisor
+
+print(dividir(10))
+# 10.0
+
+print(divisor)
+# 5
+
+lambda_producto = lambda x, y: x * y
+lambda_producto(3, 4)
+# 12
+
+class Animal:
+ '''
+ En esta clase se crean los animales
+ '''
+ def __init__(self, especie, edad, color):
+ self.especie = especie
+ self.edad = edad
+ self.color = color
+ def mePresento(self):
+ print('Hola, soy ', self.especie, ', de color', self.color, ' y tengo ', self.edad, ' años')
+ def cumplirAños(self):
+ self.edad = self.edad + 1
+
+a1 = Animal('Ratón', 2, 'Marrón')
+
+print(a1.especie)
+print(a1.edad)
+
+a2 = Animal('Liebre', 3, 'Gris')
+print(a2.especie)
+print(a2.edad)
+# Ratón
+# 2
+# Liebre
+# 3
+
+a1.mePresento()
+# Hola, soy Ratón , de color Marrón y tengo 2 años
+a2.mePresento()
+# Hola, soy Liebre , de color Gris y tengo 3 años
+a1.cumplirAños()
+a1.mePresento()
+# Hola, soy Ratón , de color Marrón y tengo 3 años
+
+# Caja Negra
+import unittest
+def suma(num_1, num_2):
+ return num_1 + num_2
+class CajaNegraTest(unittest.TestCase):
+
+ def test_suma_dos_positivos(self):
+ num_1 = 10
+ num_2 = 5
+
+ resultado = suma(num_1, num_2)
+
+ self.assertEqual(resultado, 15)
+
+ def test_suma_dos_negativos(self):
+ num_1 = -10
+ num_2 = -7
+
+ resultado = suma(num_1, num_2)
+
+ self.assertEqual(resultado, -17)
+
+unittest.main(argv=[''], verbosity=2, exit=False)
+
+"""
+" test_suma_dos_negativos (__main__.CajaNegraTest) ... ok
+" test_suma_dos_positivos (__main__.CajaNegraTest) ... ok
+
+----------------------------------------------------------------------
+Ran 2 tests in 0.004s
+
+OK
+
+if __name__ == '__main__':
+ unittest.main()
+"""
+#Caja de Cristal
+
+import unittest
+
+def es_mayor_de_edad(edad):
+ if edad >= 18:
+ return True
+ else:
+ return False
+
+class PruebaDeCristalTest(unittest.TestCase):
+
+ def test_es_mayor_de_edad(self):
+ edad = 20
+
+ resultado = es_mayor_de_edad(edad)
+
+ self.assertEqual(resultado, True)
+
+ def test_es_menor_de_edad(self):
+ edad = 15
+
+ resultado = es_mayor_de_edad(edad)
+
+ self.assertEqual(resultado, False)
+
+unittest.main(argv=[''], verbosity=2, exit=False)
+
+"""
+test_suma_dos_negativos (__main__.CajaNegraTest) ... ok
+test_suma_dos_positivos (__main__.CajaNegraTest) ... ok
+test_es_mayor_de_edad (__main__.PruebaDeCristalTest) ... ok
+test_es_menor_de_edad (__main__.PruebaDeCristalTest) ... ok
+
+----------------------------------------------------------------------
+Ran 4 tests in 0.006s
+
+OK
+
+if __name__ == '__main__':
+ unittest.main()
+"""
+
+# Python
+
+def busca_pais(paises, pais):
+# Paises es un diccionario. Pais es la llave.
+# Codigo con el principio EAFP (Easier to Ask Forgiveness than Permission/Mejor pedir perdón que pedir permiso)
+# Otro LBYL (Look Before You Leap/Piensa antes de actuar 🤐).
+
+ try:
+ return paises[pais]
+ except KeyError:
+ return None
+
+def divide_elementos_de_lista(lista, divisor):
+
+ '''
+ Cada elemento de una lista es dividida por un divisor definido.
+ En caso de error de tipo ZeroDivisionError que
+ significa error al dividir en cero
+ la función devuelve la lista inicial
+ '''
+ try:
+ return [i / divisor for i in lista]
+
+ except ZeroDivisionError as e:
+ print(e)
+ return lista
+
+lista = list(range(10))
+divisor = 0
+
+print(divide_elementos_de_lista(lista, divisor))
+# division by zero
+# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+divisor = 3
+print(divide_elementos_de_lista(lista, divisor))
+# [0.0, 0.3333333333333333, 0.6666666666666666, 1.0, 1.3333333333333333,
+# 1.6666666666666667, 2.0, 2.3333333333333335, 2.6666666666666665, 3.0]
+
+lista = [5, 4, 9, 2]
+i = 0
+while i < len(lista):
+ elemento = lista[i]
+ print(elemento)
+ i += 1
+
+"""
+5
+4
+9
+2
+"""
+
+lista = [5, 4, 9, 2]
+for elemento in lista:
+ print(elemento)
+
+"""
+5
+4
+9
+2
+"""
+from collections import Iterable
+cadena = "Hola"
+numero = 3
+print("cadena", isinstance(cadena, Iterable))
+print("numero", isinstance(numero, Iterable))
+
+"""
+cadena True
+numero False
+C:\Users\lopez\AppData\Local\Temp/ipykernel_10044/1562366592.py:1: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated since Python 3.3, and in 3.10 it will stop working
+ from collections import Iterable
+"""
+
+print(list("Hola"))
+# ['H', 'o', 'l', 'a']
+print(sum([1, 2, 3]))
+# 6
+print("-".join("Hola"))
+# H-o-l-a
+
+mi_dict = {'a':1, 'b':2, 'c':3}
+for i in mi_dict:
+ print(i)
+"""
+a
+b
+c
+"""
+
+libro = ['página1', 'página2', 'página3', 'página4']
+marcapaginas = iter(libro)
+print(next(marcapaginas))
+print(next(marcapaginas))
+print(next(marcapaginas))
+print(next(marcapaginas))
+"""
+página1
+página2
+página3
+página4
+print(next(marcapaginas))
+---------------------------------------------------------------------------
+StopIteration Traceback (most recent call last)
+~\AppData\Local\Temp/ipykernel_10044/1391636315.py in
+----> 1 print(next(marcapaginas))
+
+StopIteration:
+14 % 3
+2
+14 // 3
+4
+"""
+a = [1,2]
+b = a.copy()
+b.append(3)
+print(a)
+# [1, 2]
+
+print(b)
+# [1, 2, 3]
+b.append(4)
+print(a)
+# [1, 2, 3]
+print(b)
+# [1, 2, 3, 4]
+x = 7
+# 7 & 7
+# 2
+print(x)
+# 2
+a = [1, 2]
+b = ["Uno", "Dos"]
+c = zip(a, b)
+type(c)
+# zip
+list(c)
+[(1, 'Uno'), (2, 'Dos')]
+frase = "El perro de san roque no tiene rabo"
+errores = [i for i in frase if i == 'r']
+print(errores)
+# ['r', 'r', 'r', 'r']
+n = 40
+sequence = [0,1]
+for i in range(2,n):
+ sequence.append(sequence[i-1]+sequence[i-2])
+ print (sequence)
+
+"""2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+4 << 1
+8"""
\ No newline at end of file
diff --git a/Workbench/Taller/aritmetica.py b/Workbench/Taller/aritmetica.py
new file mode 100644
index 000000000..7fd04e8f3
--- /dev/null
+++ b/Workbench/Taller/aritmetica.py
@@ -0,0 +1,22 @@
+#print (3.5 // 4)
+#print ("7"+"0")
+#print (int("7"+"0")/2) #Este es un ejemplo de casteo
+#print ( 2**1 / 12)
+#print (4*9)
+#Intersante como se pueden declarar variables
+"""
+a, b, c, d = 26, 11.3, 5, 3.5
+print (a)
+print (c)
+print (b)
+print (d)
+print (type (a))
+print (type (b))
+print (type (d))
+"""
+#print (4*9)
+#print (2+4)
+print (30%10)
+i = 5
+i -= 1
+print(i) # 4
\ No newline at end of file
diff --git a/Workbench/Taller/comment.py b/Workbench/Taller/comment.py
new file mode 100644
index 000000000..e26328386
--- /dev/null
+++ b/Workbench/Taller/comment.py
@@ -0,0 +1,16 @@
+# Este es un comentario en Python
+print ("This is an example of comments")
+print ("also, this is an other example of comments")
+print ("comments are preceded by a hash symbol #")
+print ("and other way to do this it's preceeding a paragraph")
+print ("by 3 dots at the beginig, and 3 at the end")
+
+"""este es un ejemplo de comentarios en varias líneas
+es otra forma para organizar textos largos..."""
+'''
+otro
+ejemplo
+de lineas
+múltiple
+'''
+print ("fin de los comments")
\ No newline at end of file
diff --git a/Workbench/Taller/datatypes.py b/Workbench/Taller/datatypes.py
new file mode 100644
index 000000000..41f532a07
--- /dev/null
+++ b/Workbench/Taller/datatypes.py
@@ -0,0 +1,51 @@
+#On this file we going to learn about different data types
+#Boolean, int, float, cmplex mumbers
+#Boolean true or false
+#String, list (dictionary
+current_year=2023
+print (current_year)
+next_year=current_year+1
+print (next_year)
+print (type (current_year))
+print(type (3.14))
+print (type (1+2j))
+print (type (9.81))
+#a = input ("Ingresa un texto")
+#print ("El texto ingresado es", a)
+#converting data type e.g int to float o vs
+print (int(9.81))
+print (round (9.81))
+#BOOLEAN CASES
+enjoying_lesson=True
+is_light_on=True
+is_single=False
+value = 3 < 2 #almacena el valor lógico de la expresión
+print (value)
+#STRINGS ==> Son datos almacenados del tipo cadena de texto
+#Concatenación se suman las variables de texto
+firstname = "Jota"
+print (firstname)
+lastname="Cordova"
+print (lastname)
+print (firstname+" "+ lastname)
+country = "Finland"
+print (country)
+#Recordar
+fullname = firstname + " "+lastname
+print (fullname,", aquí usamos la variable concatenada")
+print (type (firstname))
+print (country.upper()) #métodos de la clase print
+print (fullname.title())
+#LIST ==> It's a list of something, could be task, groceries
+empty_list1 = list() #dos formas de inicializar listas
+empty_list2 = [] #la nombro y luego declaro como list()
+# la nombre y asigno una lista vacia con corchetes []
+print (empty_list1, "esta es la lista 1")
+print (empty_list2, "esta es la lista 2")
+numbers = [1,2,3,4,5,6]
+groceries = ["tomato", "carrot", "letuce"]
+print (groceries [0]) #el puntero va con corchete y parte de 0
+print (numbers [3]) #es una COLECCION
+print (len(groceries)) #conocer el largo de la la lista con len
+mix_of_data_types_list = [1, "Jota", lastname, 2+5, 1-3j, 3.14]
+#podemos almacenar un mix de datos
diff --git a/Workbench/Taller/listas.py b/Workbench/Taller/listas.py
new file mode 100644
index 000000000..731dbf055
--- /dev/null
+++ b/Workbench/Taller/listas.py
@@ -0,0 +1,77 @@
+#Ejericio 1
+
+listadeletras = [] # Crea un objeto list llamado lista
+for unaletra in "paralelepipedo": # Define una variable car para recorrer el string "casa"
+ listadeletras.append(unaletra) # Agrega cada caracter del string en la lista
+print(listadeletras) # Imprime los valores de la lista que son los caracteres de la palabra casa o pera, lo que sea
+ # Salida esperada ['c', 'a', 's', 'a']
+
+"""
+#Ejercicio 2
+# Lista de 4 elementos y para cada elemento calcularle la potencia de 2, usando el método tradicional, eso seria así:
+#Alternativa 1
+
+lista_potencias = [] #Crea una lista llamada "lista_potencias"
+for i in range(4): #ciclo for para recorrer lista de 4 elementos, va de 0 a 3, el índice lo llamamos "i"
+ lista_potencias.append(i**2) #a la lista "lista_potencias", la voy poblando con el dato calculado.
+print(lista_potencias) #Imprime los 4 valores almacendaos en la lista #Obs: como no cambié el nombre, concatenó los valores de la lista al final
+# [0, 1, 4, 9]
+
+#Alternativa 2
+# Entonces el ejemplo anterior usando listas de comprensión, eso seria así:
+lista_potencias2 = [i**2 for i in range(4)]
+print ("Esta es la lista de potencias Nr2", lista_potencias2)
+# [0, 1, 4, 9]
+
+#Ejercicio 3
+#Lista con las potencias de 2 de los primeros 10 números, método tradicional:
+"""
+"""
+Método 3-1
+lista1_pot10_2 = [] #Creamos un objeto lista vacio []
+for num in range (0, 11): #incluye el primero y no el últimmo. Usando un ciclo FOR usando la var "num" en el tramo de 0-10, ambos incluidos
+ lista1_pot10_2.append (num**2) #Llenamos la lista con potencias PARTIENDO DE 0, a 10 (11-1)
+print(lista1_pot10_2)
+
+#[4, 9, 16]
+#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
+#Método 3-2
+#Entonces el ejemplo anterior usando listas de comprensión, eso seria así:
+#lista2_pot10_2 = [num2**2 for num2 in range(0, 11)] #Creamos la lista con los valores según condición
+#print("Este es el método 3-2, para crear la lista de 10 números y sus potencias",lista2_pot10_2)
+#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
+#De este código anterior usted puede aprender que es posible modificar al vuelo los elementos los cuales van a formar la lista.
+
+# Ej
+# Con este ejemplo se ve como funciona el conteo de posiciones en una lista (cada elemento es una posX)
+lista = ["pos0", "pos1", "pos2", "pos3", "pos4", "pos5"]
+print("Esta es la lista:\n", lista, "\n")
+print("1° Mostrar 'lista[2:5]', significa la pos2, pero excluye la 5, ojo!\n", lista[2:5]) # tomamos del 2 al 5 (sin incluir el 5)
+print("2° Mostrar 'lista[4:]', significa desde la pos4 hasta la última\n",lista[4:]) # tomamos del 4 hasta el final
+print("3° Mostrar 'lista[:2]', significa desde el BOF hasta la pos2, excluye la pos2\n", lista[:2]) # tomamos desde el principio hasta el 2 (sin incluir)
+print("4° Mostrar 'lista[1:6:2]', significa 1 por medio, desde la pos1, incluye la 5\n", lista[1:6:2]) # tomamos 1 de cada 2 elementos desde el 1 hasta el 6 (sin incluir)
+print("5° Mostrar 'lista[4:1:-1]', significa orden desc de la pos4 a la 2, excluye la pos1",lista[4:1:-1])
+print("6° Mostrar 'lista[:]', significa mostrar todos los elementos de la lista\n",lista[:]) # tomamos desde el principio hasta el final (es como hacer una copia de la lista)
+print("7° Mostrar 'lista[::-1]', significa mostrar todos los elementos de la lista en orden inverso\n",lista[::-1]) # tomamos desde el final hasta el principip (orden inverso)
+"""
+# EJ 5
+# Con este ejemplo usamos un truco para controlar la salida, un método de print llamado end
+#
+for i in range (15):
+ if i < 14:
+ print (i, end=", ")
+ else:
+ print (i)
+
+"""
+# Ej 6
+# Mismo ejemplo sin controlar la salida, cada linea se ejecuta y se apilan.
+#for i in range (15):
+# print (i)
+"""
+"""
+# Revisar formas de ordenar listas
+lista_desordenada = (5,7,2,8,3,6)
+print (lista_desordenada)
+print (lista_desordenada.sort())
+"""
\ No newline at end of file
diff --git a/Workbench/Taller/variables.py b/Workbench/Taller/variables.py
new file mode 100644
index 000000000..cb71de421
--- /dev/null
+++ b/Workbench/Taller/variables.py
@@ -0,0 +1,11 @@
+#Variables
+#It's memory location to assign data to store and use ir later
+a=10
+b=3
+print (a)
+
+print ("what's the value of a", a)
+print ("what's the value of b", b)
+print (a+b)
+total =2+4
+print (total)
\ No newline at end of file
From 4bf5e17acc8ca378c99d3b28df2f1ef6367a0ab1 Mon Sep 17 00:00:00 2001
From: Jorge Cordova <55065873+jcordovaj@users.noreply.github.com>
Date: Sun, 22 Jan 2023 20:48:44 -0300
Subject: [PATCH 03/16] 220123...tratando de avanzar
---
...urse_Homework_03-Resuelto-checkpoint.ipynb | 12 +-
...ep_Course_Homework_03-Resuelto Clase.ipynb | 16 +-
.../Prep_Course_Homework_03-Resuelto.ipynb | 12 +-
Workbench/Taller/Apuntes01.ipynb | 2 +-
Workbench/Taller/Ciclos.py | 26 +++
.../Taller/{comment.py => ComoComentar.py} | 0
Workbench/Taller/CrearMenu.py | 105 ++++++++++
Workbench/Taller/Diccionarios.py | 139 +++++++++++++
Workbench/Taller/Funciones | 59 +++---
Workbench/Taller/Matrices.py | 27 +++
Workbench/Taller/datatypes.py | 31 +--
Workbench/Taller/listas.py | 184 +++++++++++++-----
Workbench/Taller/variables.py | 4 +-
13 files changed, 505 insertions(+), 112 deletions(-)
create mode 100644 Workbench/Taller/Ciclos.py
rename Workbench/Taller/{comment.py => ComoComentar.py} (100%)
create mode 100644 Workbench/Taller/CrearMenu.py
create mode 100644 Workbench/Taller/Diccionarios.py
create mode 100644 Workbench/Taller/Matrices.py
diff --git a/03 - Flujos de Control/.ipynb_checkpoints/Prep_Course_Homework_03-Resuelto-checkpoint.ipynb b/03 - Flujos de Control/.ipynb_checkpoints/Prep_Course_Homework_03-Resuelto-checkpoint.ipynb
index 8b24b6405..24c961bd1 100644
--- a/03 - Flujos de Control/.ipynb_checkpoints/Prep_Course_Homework_03-Resuelto-checkpoint.ipynb
+++ b/03 - Flujos de Control/.ipynb_checkpoints/Prep_Course_Homework_03-Resuelto-checkpoint.ipynb
@@ -716,11 +716,8 @@
}
],
"metadata": {
- "interpreter": {
- "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01"
- },
"kernelspec": {
- "display_name": "Python 3.9.7 64-bit ('henry': conda)",
+ "display_name": "Python 3",
"language": "python",
"name": "python3"
},
@@ -734,7 +731,12 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.9.7"
+ "version": "3.10.6 (tags/v3.10.6:9c7b4bd, Aug 1 2022, 21:53:49) [MSC v.1932 64 bit (AMD64)]"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "d3777ed8f5fe800f0d3d1926318eb186c93d9a88e13881725c87e5bdd2f1dd1d"
+ }
}
},
"nbformat": 4,
diff --git a/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto Clase.ipynb b/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto Clase.ipynb
index ce4105c8d..e031e08b2 100644
--- a/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto Clase.ipynb
+++ b/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto Clase.ipynb
@@ -443,8 +443,8 @@
" num2 = num * num2\n",
" num = num - 1\n",
" print(num2) \n",
- " else:\n",
- " print('el número {num} es menor que 0') \n"
+ "else:\n",
+ " print('el número {num} es menor que 0') \n"
]
},
{
@@ -34589,11 +34589,8 @@
}
],
"metadata": {
- "interpreter": {
- "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01"
- },
"kernelspec": {
- "display_name": "Python 3 (ipykernel)",
+ "display_name": "Python 3",
"language": "python",
"name": "python3"
},
@@ -34607,7 +34604,12 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.9.7"
+ "version": "3.10.6 (tags/v3.10.6:9c7b4bd, Aug 1 2022, 21:53:49) [MSC v.1932 64 bit (AMD64)]"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "d3777ed8f5fe800f0d3d1926318eb186c93d9a88e13881725c87e5bdd2f1dd1d"
+ }
}
},
"nbformat": 4,
diff --git a/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto.ipynb b/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto.ipynb
index 39f94f511..f2e303cbf 100644
--- a/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto.ipynb
+++ b/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto.ipynb
@@ -716,11 +716,8 @@
}
],
"metadata": {
- "interpreter": {
- "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01"
- },
"kernelspec": {
- "display_name": "Python 3 (ipykernel)",
+ "display_name": "Python 3",
"language": "python",
"name": "python3"
},
@@ -734,7 +731,12 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.9.7"
+ "version": "3.10.6 (tags/v3.10.6:9c7b4bd, Aug 1 2022, 21:53:49) [MSC v.1932 64 bit (AMD64)]"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "d3777ed8f5fe800f0d3d1926318eb186c93d9a88e13881725c87e5bdd2f1dd1d"
+ }
}
},
"nbformat": 4,
diff --git a/Workbench/Taller/Apuntes01.ipynb b/Workbench/Taller/Apuntes01.ipynb
index a07c97eb9..7b28b9a52 100644
--- a/Workbench/Taller/Apuntes01.ipynb
+++ b/Workbench/Taller/Apuntes01.ipynb
@@ -66,7 +66,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.10.6"
+ "version": "3.10.6 (tags/v3.10.6:9c7b4bd, Aug 1 2022, 21:53:49) [MSC v.1932 64 bit (AMD64)]"
},
"orig_nbformat": 4,
"vscode": {
diff --git a/Workbench/Taller/Ciclos.py b/Workbench/Taller/Ciclos.py
new file mode 100644
index 000000000..bf1ab9a44
--- /dev/null
+++ b/Workbench/Taller/Ciclos.py
@@ -0,0 +1,26 @@
+print ("Inicio de números pares")
+lista_p=[] # Creo lista pares, para poder imprimirlos hor.
+lista_i=[] # Creo lista impares, para poder imprmirlos ver.
+for par in range(0, 21, 2): # En el rango 0-20, cada 2, partiendo de 0
+ lista_p.append(par)
+ print (par)
+print(lista_p) # Escribe la lista vertical
+print ("Fin de números pares") # Escribe la lista horizontal
+print ("Inicio de números impares")
+for impar in range(1, 21, 2): # En el rango 1-20, cada 2, partiendo de 1
+ lista_i.append(impar)
+ print (impar) # Escrbe la lista vertical
+ # Escribe la lista horizontal
+print(lista_i)
+print ("Fin de números impares")
+"""
+"""# Dado un valor entero, ejecutar el mismo número de ciclos con un while
+a= 5
+num=1
+while num < a+1:
+ #print ("a vale ", a)
+ #print ("num vale ", num)
+ print ("Este es el ciclo", num)
+ num=num+1
+
+
diff --git a/Workbench/Taller/comment.py b/Workbench/Taller/ComoComentar.py
similarity index 100%
rename from Workbench/Taller/comment.py
rename to Workbench/Taller/ComoComentar.py
diff --git a/Workbench/Taller/CrearMenu.py b/Workbench/Taller/CrearMenu.py
new file mode 100644
index 000000000..ebe1a4193
--- /dev/null
+++ b/Workbench/Taller/CrearMenu.py
@@ -0,0 +1,105 @@
+
+"""
+def accion1():
+ print('Has elegido la opción 1')
+
+
+def accion2():
+ print('Has elegido la opción 2')
+
+
+def accion3():
+ print('Has elegido la opción 3')
+
+
+def salir():
+ print('Saliendo')
+
+#Guardamos en en un diccionario de tuplas, la opción y la acción
+opciones = {
+ '1': ('Opción 1', accion1),
+ '2': ('Opción 2', accion2),
+ '3': ('Opción 3', accion3),
+ '4': ('Salir', salir)
+}
+
+def generar_menu(opciones, opcion_salida):
+ opcion = None
+ while opcion != opcion_salida:
+ mostrar_menu(opciones)
+ opcion = leer_opcion(opciones)
+ ejecutar_opcion(opcion, opciones)
+ print() # se imprime una línea en blanco para clarificar la salida por pantalla
+
+def mostrar_menu(opciones):
+ print('Seleccione una opción:')
+ for clave in sorted(opciones):
+ print(f' {clave}) {opciones[clave][0]}')
+
+def leer_opcion(opciones):
+ while (a := input('Opción: ')) not in opciones:
+ print('Opción incorrecta, vuelva a intentarlo.')
+ return a
+
+def ejecutar_opcion(opcion, opciones):
+ opciones[opcion][1]()
+
+def menu_principal():
+ opciones = {
+ '1': ('Opción 1', accion1),
+ '2': ('Opción 2', accion2),
+ '3': ('Opción 3', accion3),
+ '4': ('Salir', salir)
+ }
+generar_menu(opciones, '4')"""
+
+# Creamos funciones asociadas a cada acción del menú
+# Tercer paso es unir la lógica y para ellos crearemos con tres objetivos:
+# 1) Mostrar el menú al usuario
+# 2) Pedir una opción al usuario y leer esa opción por teclado.
+# 3) Ejecutar la opción correspondiente.
+
+def mostrar_menu(opciones):
+ print('Seleccione una opción:')
+ for clave in sorted(opciones):
+ print(f' {clave}) {opciones[clave][0]}')
+
+def leer_opcion(opciones):
+ while (a := input('Opción: ')) not in opciones:
+ print('Opción incorrecta, vuelva a intentarlo.')
+ return a
+
+def ejecutar_opcion(opcion, opciones):
+ opciones[opcion][1]()
+
+def generar_menu(opciones, opcion_salida):
+ opcion = None
+ while opcion != opcion_salida:
+ mostrar_menu(opciones)
+ opcion = leer_opcion(opciones)
+ ejecutar_opcion(opcion, opciones)
+ print()
+
+def menu_principal():
+ opciones = {
+ '1': ('Opción 1', accion1),
+ '2': ('Opción 2', accion2),
+ '3': ('Opción 3', accion3),
+ '4': ('Salir', salir)
+ }
+ generar_menu(opciones, '4')
+
+def accion1():
+ print('Has elegido la opción 1')
+
+def accion2():
+ print('Has elegido la opción 2')
+
+def accion3():
+ print('Has elegido la opción 3')
+
+def salir():
+ print('Saliendo')
+
+if __name__ == '__main__':
+ menu_principal()
\ No newline at end of file
diff --git a/Workbench/Taller/Diccionarios.py b/Workbench/Taller/Diccionarios.py
new file mode 100644
index 000000000..3479a15af
--- /dev/null
+++ b/Workbench/Taller/Diccionarios.py
@@ -0,0 +1,139 @@
+#*******************************************************************
+#* *
+#* TEORIA DICCIONARIOS *
+#* *
+#*******************************************************************
+# Un dict es una colección de pares, no ordenados, compuestos por una KEY y un VALUE (valor)
+# La KEY debe ser HASHEABLE, INMUTABLE, ÚNICA, NO REPETIBLE, los valores pueden ser cualquier cosa MUTABLE.
+# Un VALUE puede ser otro DICCIONARIO, TUPLA, LISTA, más los tipos clásicos, como BOOLEAN, etc.
+# Otras caracteristicas: Similar al tipo MAPA en otros lenguajes, no confundir con función map(),
+# aunque retorna un DICT. La funicón map() es para objetos iterables como listas.
+# Método keys() => nom_dic.keys() retorna una clase especial llamada dict_keys, sólo nombra las keys,
+# Para acceder a las KEYS, se debe pasar a LISTA ==> nom_var = list(nom_dic.keys())
+# para poder iterar sobre cada LLAVE
+# Método clear() => Borra todos los elementos del diccionario mi_dic.clear(), retorna {}
+# Método del(key) => Elimina un elemento con su clave, le paso la clave como parámetro
+# Método values() => devuelve todos los VALORES
+# Método dict.items()=> Retorna tuplas (clave, valor), también se pasa a list siguen siendo TUPLAS.
+# Función in retorna bool si encuentra valor de una clave "mi_key" in "mi_dic"
+# Sólo sirve para claves, y es un booleano, TRUE o FALSE, si quiero preguntar po un valor, agregro
+# VALUE de esta forma "mi_valor" in "mi_dic.value".
+# Recorridos en diccionarios
+
+
+
+# Inicialización de DICCIONARIOS (dict)
+# El constructor dict y argumentos. Ej: dict(color='Azul', num=4)
+# Constructor dict y pares de valores. Ej: dict([('color', 'Azul'), ('num', 4)])
+# Usando un literal de pares separados por ':' y rodeado por {}. Ej: {'color': 'Azul', 'num': 4}
+#
+
+# Ejemplo 1
+# Este es un dic de 4 elementos o pares cualquiera str, int, str y str.
+# Obtenemos sus claves y las pasamos a una lista
+d = {1: 'str cualquiera', 89: 'soy un valor', 'clave a': 'b', 'clave c': 27} # Inicializa el dict
+listkey_d = list(d.keys()) # Hay que convertirlo a lista para acceder a las keys como índice
+print (listkey_d) # Ahora veo los índices y los puedo trabajar como LISTA
+print ("'D' es del tipo ", type (d)) # Retorna
+print ("'listkey_d' es del tipo ", type (listkey_d)) # Retorna , se ve la diferencia
+print ("El nombre de la clave en la posición 1 es ", listkey_d [1], " y es de tipo", type(listkey_d [1]))
+print ("El nombre de la clave en la posición 3 es ", listkey_d [3], " y es de tipo", type(listkey_d [3]))
+print ("")
+
+# Ejemplo 2
+# Crea un diccionario con 4 pares lógicos, colores primarios, colores secundarios, clave 3 y clave 4
+
+mi_dic = {'Colores Primarios': ['Rojo','Azul','Amarillo'],
+ 'Colores secundarios': ['Naranja','Violeta','Verde'],
+ 'Clave3': 10,
+ 'Clave4': False}
+mi_dic_keys = list (mi_dic.keys()) # Obtenemos las keys y las pasamos a una list "mi_dic_keys"
+print (mi_dic_keys) # Imprime la lista
+print (type (mi_dic_keys)) # Imprime el tipo de la variable mi_dic_keys, retorna
+print ("Los colores de la clave ", mi_dic_keys [1], "son ", mi_dic['Colores secundarios'])
+print ("")
+print (mi_dic.keys())
+
+print ("Los colores de la clave ", mi_dic_keys [0], "son ", mi_dic['Colores Primarios'])
+print ("El valor de la clave 3", mi_dic_keys [2], "es ", mi_dic['Clave3'])
+print ("El valor de la clave 4", mi_dic_keys [3], "son ", mi_dic['Clave4'])
+
+# Ejemplo 3
+dd2 = dict (width=4, members=['1', False], name='Pepe') # 3 elementos, 1 int, 1 dict, un str
+print ("El contenido de 'dd2' es ", dd2) # # Retorna {'width': 4, 'members': ['1', False], 'name': 'Pepe'}
+print (dd2.values()) # Retorna 4, ['1', False], "Pepe"
+
+
+# Ejemplo 4
+print("")
+dict2 = {} # Inicializa un diccionario vacío
+print ("El contenido de 'dict2' debe ser vacío ", dict2) # Mostrará {}
+# El contenido de 'dict2' debe ser {}
+
+# Ejemplo 5
+print ("")
+# Observar varias formas de declarar diccionarios
+{'1': 'primero', '2': 'segundo', 'tercero': 4 * 5 * 6} # Tres pares, str-str, str-str y str-int
+{'1': 'primero', '2': 'segundo', 'tercero': 120} # Igual que el anterior, pero el último no es una operación
+{str(x): x + 1 for x in range(5)} # Clave es un str x, el valor de x+1 en el rango 0-5
+{'0': 1, '1': 2, '2': 3, '3': 4, '4': 5} # 4 pare, str-int, str-int, str-int, str-int
+dict(enumerate(range(5), start=10))
+{10: 0, 11: 1, 12: 2, 13: 3, 14: 4}
+[(x, chr(x)) for x, idx in enumerate(range(5), start=65)]
+[(65, 'A'), (66, 'B'), (67, 'C'), (68, 'D'), (69, 'E')]
+#Este ejemplo crea un diccionario compuesto por un int (start=65), y el valor es un str que se calcula
+# usando la función chr(), al pasarle el valor de x, retornará 5 letras sucesivas entre 65 y 69 (5 valores)
+letters = [(x, chr(x)) for x, idx in enumerate(range(5), start=65)]
+dict(letters)
+print (letters)
+{65: 'A', 66: 'B', 67: 'C', 68: 'D', 69: 'E'}
+
+# Ejemplo 6
+# Este es un diccionario
+# Se define como nombre_dic = dict(pos=valor, key=valor, valor=valor), hay otras formas
+#
+miprimer_dic = dict(tipo='Moto', marca='Honda', power=599)
+print(list(enumerate(miprimer_dic))) #convertimos el dict en lista.
+#[(0, 'tipo'), (1, 'marca'), (2, 'power')]
+print("")
+print ("Inicio del ciclo for")
+# En este ejemplo iteramos los elementos de un diccionario y me muestran los pares según posición
+# Usamos el método "enumerate" que pertenece al tipo list, para recorrer el dict convertido en lista
+#
+print ("caso con f")
+for idx, key in enumerate(miprimer_dic): # El enumerador de la forma ind, key, recorre el diccionario
+ print(f'Pos: {idx} - dict_key {key} - value {miprimer_dic[key]}')
+ #print('Pos: {idx} - dict_key {key} - value {miprimer_dic[key]}')
+print("")
+print ("caso sin f")
+for idx, key in enumerate(miprimer_dic): # El enumerador de la forma ind, key, recorre el diccionario
+ #print(f'Pos: {idx} - dict_key {key} - value {miprimer_dic[key]}')
+ print('Pos: {idx} - dict_key {key} - value {miprimer_dic[key]}')
+
+#Pos: 0 - dict_key tipo - value Moto
+#Pos: 1 - dict_key marca - value Honda
+#Pos: 2 - dict_key power - value 599
+
+# Ejemplo 7
+# Consultar a un dicc, si una clase existe => retorna un booleano TRUE o FALSE
+# Ojo si preguntas por un valor, puede existir, pero retornará FALSE
+# Si quiero preguntar por un valor, agrego el método .value()
+
+print ("")
+letters2 = [(x, chr(x)) for x, idx in enumerate(range(5), start=65)]
+dd = dict(letters2)
+print ("Este es el diccionario dd", dd)
+mi_key1=65
+print (type(letters2))
+if mi_key1 in dd:
+ print ("La clave ", mi_key1," existe")
+else:
+ print ("La clave ", mi_key1, ". No existe")
+print ("")
+
+restaurant = {"Hamburguesa": 100, "Pizza": 50, "Jugo": 30}
+if "Hamburguesa" in restaurant:
+ print ("SI está")
+else:
+ print ("NO está")
+print (restaurant)
\ No newline at end of file
diff --git a/Workbench/Taller/Funciones b/Workbench/Taller/Funciones
index 41dcd2983..cdcc063de 100644
--- a/Workbench/Taller/Funciones
+++ b/Workbench/Taller/Funciones
@@ -1,33 +1,38 @@
-
-def misuma (a,b):
- return a+b
-
-res= misuma (2,3)
-print (res)
-
-def suma(a, b):
- return a + b
-
-
-
+#*******************************************************************
+#* *
+#* B I E N V E N I D O A F U N C I O N E S *
+#* *
+#*******************************************************************
+# Una función es una operación o procedimiento que retorna un valor o acción
+# Se declaran con la palabra reservada 'def' y se cierra con ':', debe incluir 'return' y la logica
+# del cálculo o lo que hace la función.
+# Operaciones o métodos habituales como insert, append, sort...son funciones, porque hacen o retornan cosas.
+# Para usar la función, le paso los parámetros definidos, ojo con los tipos y el control de las excepciones
+
+# Ejemplo 1
+def misuma (a,b): # Esta es una función, toma dos enteros a,b y los suma
+ return a+b # El calculo viene después de la palabra return
+
+res= misuma (2,3) # Uso la función, le paso los parámetros 2,3 y, el resultado lo almaceno en la variable res
+print ("Resultado de sumar 2 y 3, es ", res) # Puedo ver su contenido con un print
+
+# Ejemplo 2
# min y max son funciones integradas en Python que nos devuelven
# los valores mínimo y máximo de un iterable (como las listas o las tuplas)
-def min_y_max(lista):
- return min(lista), max(lista)
-
+def min_y_max(lista): # Declaro la función y le digo que le pasaré un argumento de tipo lista
+ return min(lista), max(lista) # Usando la funciones min y max que pertenecen a objetos iterables
+ # obtengo los valores y los devuelvo
# ahora vamos a usar estas funciones
-valor = suma(10, 15)
-print(valor)
+valor = misuma(10, 15)
+print("Usando la función 'misuma', el resultado de sumar 10 y 15 es ", valor)
minimo, maximo = min_y_max([30, 10, 50, 40, 20])
-print(f'min y max son {minimo} y {maximo}')
-
-"""
-def test_OrdenarDiccionario_03(self):
- dicc = {'clave1':['c','a','b'], 'clave2':['casa','auto','barco'], 'clave3':[3,1,2]}
- valor_test = ch.OrdenarDiccionario(dicc, 'clave3', False)
- valor_esperado = {'clave1':['b','a','c'], 'clave2':['barco','auto','casa'], 'clave3':[3,2,1]}
- """
-
-"""
\ No newline at end of file
+print("Para el vector 30,10,50,40 y 20, los ",f'min y max son {minimo} y {maximo}')
+
+# Ejemplo 3 #Lo veremos más adelante
+# En este ejemplo, creamos una función que realiza un test unitario
+#def test_OrdenarDiccionario_03(self):
+# dicc = {'clave1':['c','a','b'], 'clave2':['casa','auto','barco'], 'clave3':[3,1,2]}
+# valor_test = ch.OrdenarDiccionario(dicc, 'clave3', False)
+# valor_esperado = {'clave1':['b','a','c'], 'clave2':['barco','auto','casa'], 'clave3':[3,2,1]}
\ No newline at end of file
diff --git a/Workbench/Taller/Matrices.py b/Workbench/Taller/Matrices.py
new file mode 100644
index 000000000..ed2f911ab
--- /dev/null
+++ b/Workbench/Taller/Matrices.py
@@ -0,0 +1,27 @@
+# Ejemplo 1
+# Uso de 'enumerate' para recorrer matrices
+m = [['enteros', 1, 2, 3, 4], #Define una matriz 'm'
+ ['complex', 1j, 2j, 3j, 4j],
+ ['float', 1.0, 2.0, 3.0, 4.0]]
+# [['enteros', 1, 2, 3, 4], ['complex', 1j, 2j, 3j, 4j], ['float', 1.0, 2.0, 3.0, 4.0]]
+for i, elems in enumerate(m):
+ for j, jelem in enumerate(elems):
+ print(f'row {i} - column {j}: {jelem}')
+
+"""
+row 0 - column 0: enteros
+row 0 - column 1: 1
+row 0 - column 2: 2
+row 0 - column 3: 3
+row 0 - column 4: 4
+row 1 - column 0: complex
+row 1 - column 1: 1j
+row 1 - column 2: 2j
+row 1 - column 3: 3j
+row 1 - column 4: 4j
+row 2 - column 0: float
+row 2 - column 1: 1.0
+row 2 - column 2: 2.0
+row 2 - column 3: 3.0
+row 2 - column 4: 4.0
+"""
\ No newline at end of file
diff --git a/Workbench/Taller/datatypes.py b/Workbench/Taller/datatypes.py
index 41f532a07..642414419 100644
--- a/Workbench/Taller/datatypes.py
+++ b/Workbench/Taller/datatypes.py
@@ -1,7 +1,9 @@
-#On this file we going to learn about different data types
-#Boolean, int, float, cmplex mumbers
-#Boolean true or false
-#String, list (dictionary
+
+# On this file we going to learn about different data types
+# Boolean, int, float, complex mumbers
+# Boolean true or false
+# String, list (dictionary)
+
current_year=2023
print (current_year)
next_year=current_year+1
@@ -10,9 +12,9 @@
print(type (3.14))
print (type (1+2j))
print (type (9.81))
-#a = input ("Ingresa un texto")
-#print ("El texto ingresado es", a)
-#converting data type e.g int to float o vs
+a = input ("Ingresa un texto")
+print ("El texto ingresado es", a)
+# Convertir data type e.g int to float o viceversa
print (int(9.81))
print (round (9.81))
#BOOLEAN CASES
@@ -35,17 +37,4 @@
print (fullname,", aquí usamos la variable concatenada")
print (type (firstname))
print (country.upper()) #métodos de la clase print
-print (fullname.title())
-#LIST ==> It's a list of something, could be task, groceries
-empty_list1 = list() #dos formas de inicializar listas
-empty_list2 = [] #la nombro y luego declaro como list()
-# la nombre y asigno una lista vacia con corchetes []
-print (empty_list1, "esta es la lista 1")
-print (empty_list2, "esta es la lista 2")
-numbers = [1,2,3,4,5,6]
-groceries = ["tomato", "carrot", "letuce"]
-print (groceries [0]) #el puntero va con corchete y parte de 0
-print (numbers [3]) #es una COLECCION
-print (len(groceries)) #conocer el largo de la la lista con len
-mix_of_data_types_list = [1, "Jota", lastname, 2+5, 1-3j, 3.14]
-#podemos almacenar un mix de datos
+print (fullname.title())
\ No newline at end of file
diff --git a/Workbench/Taller/listas.py b/Workbench/Taller/listas.py
index 731dbf055..704f13cbe 100644
--- a/Workbench/Taller/listas.py
+++ b/Workbench/Taller/listas.py
@@ -1,49 +1,79 @@
-#Ejericio 1
+#*******************************************************************
+#* *
+#* TEORIA LISTAS *
+#* *
+#*******************************************************************
-listadeletras = [] # Crea un objeto list llamado lista
-for unaletra in "paralelepipedo": # Define una variable car para recorrer el string "casa"
- listadeletras.append(unaletra) # Agrega cada caracter del string en la lista
-print(listadeletras) # Imprime los valores de la lista que son los caracteres de la palabra casa o pera, lo que sea
- # Salida esperada ['c', 'a', 's', 'a']
+# Una LIST, es un objeto, es una colección de cosas, pueden ser tareas,
+# vegetales, nombres
+# mercaderías, cualquier cosa.
-"""
-#Ejercicio 2
-# Lista de 4 elementos y para cada elemento calcularle la potencia de 2, usando el método tradicional, eso seria así:
-#Alternativa 1
+# Dos formas paa declararlas e iniciaizarlas
+
+# 1) Defino una variable y le asigno un tipo lista VACÍO con paréntesis
+empty_list1 = list() # Note que se debe indicar el tipo lista o lo considerará una TUPLA
+print (empty_list1, "esta es la lista 1 con '()'")
+print (type(empty_list1))
+
+# 2) Defino una variable y sé que es del tipo lista por los corchetes '[]'
+empty_list2 = [] # A la variable se le asigna una lista vacía con CORCHETES
+print (empty_list2, "esta es la lista 2")
+print (type (empty_list2))
+
+# Ejemplo 1
+numbers = [1,2,3,4,5,6] # Lista de números
+print("'numbers' es del tipo ", type(numbers)) # De devolver el texto+ type 'list'
+
+# Ejemplo 2
+groceries = ["tomato", "carrot", "letuce"] # Una lista con 3 strings de 'vegentales'
+print (groceries [0]) # El puntero va con corchetes y parte de 0, imprime "tomato"
+print (numbers [3]) # Es una COLECCION, imprime todos los elementos
+print (len(groceries)) # Conocer el largo de la la lista con len, devuelve 3
+
+# Ejemplo 3
+lastname = "cordova" # Variable de tipo string, contiene "cordova"
+mix_of_data_types_list = [1, "Jota", lastname, 2+5, 1-3j, 3.14] # Lista con distintos tipos de var
+print ("'mix_of_data_types_list' es del tipo-", type(mix_of_data_types_list)) #devuelve 'list'
+#podemos almacenar un mix de datos
+
+# Ejemplo 4
+listadeletras = [] # Crea un objeto list llamado listadeletras
+for unaletra in "paralelepipedo": # Define una variable 'unaletra' y recorre el string "paralelepípedo"
+ listadeletras.append(unaletra)# Agrega cada caracter del string a 'listadeletras' usando el método 'append'
+print (listadeletras) # Imprime los valores de la lista que son los caracteres de la palabra 'paralelepípedo'', lo que sea
+ # Salida esperada ['p', 'a', 'r', 'a', 'l', 'e', 'l', 'e', 'p', 'i', 'p', 'e', 'd', 'o']
-lista_potencias = [] #Crea una lista llamada "lista_potencias"
-for i in range(4): #ciclo for para recorrer lista de 4 elementos, va de 0 a 3, el índice lo llamamos "i"
- lista_potencias.append(i**2) #a la lista "lista_potencias", la voy poblando con el dato calculado.
-print(lista_potencias) #Imprime los 4 valores almacendaos en la lista #Obs: como no cambié el nombre, concatenó los valores de la lista al final
-# [0, 1, 4, 9]
+# Ejemplo 5
+# Crear una lista de 4 elementos y, para cada elemento, calcularle la potencia de 2, usando
+# el método tradicional, eso seria así:
+# Alternativa 1
+lista_potencias = [] # Crea una lista llamada "lista_potencias"
+for i in range(4): # Ciclo for para recorrer lista de 4 elementos, va de 0 a 3, el índice lo llamamos "i"
+ lista_potencias.append(i**2)# La lista "lista_potencias", la voy poblando con el dato calculado.
+print(lista_potencias) # Imprime los 4 valores almacendaos en la lista [0, 1, 4, 9]
-#Alternativa 2
+# Ejemplo 6
# Entonces el ejemplo anterior usando listas de comprensión, eso seria así:
-lista_potencias2 = [i**2 for i in range(4)]
-print ("Esta es la lista de potencias Nr2", lista_potencias2)
-# [0, 1, 4, 9]
+lista_potencias2 = [i**2 for i in range(4)] # Usa un for
+print ("Esta es la lista de potencias Nr2", lista_potencias2) # Imprime [0, 1, 4, 9]
-#Ejercicio 3
-#Lista con las potencias de 2 de los primeros 10 números, método tradicional:
-"""
-"""
-Método 3-1
-lista1_pot10_2 = [] #Creamos un objeto lista vacio []
-for num in range (0, 11): #incluye el primero y no el últimmo. Usando un ciclo FOR usando la var "num" en el tramo de 0-10, ambos incluidos
- lista1_pot10_2.append (num**2) #Llenamos la lista con potencias PARTIENDO DE 0, a 10 (11-1)
-print(lista1_pot10_2)
+# Ejemplo 7
+# Lista con las potencias de 2 de los primeros 10 números, método tradicional:
+# Alternativa 1
+lista1_pot10_2 = [] # Creamos un objeto lista vacio []
+for num in range (0, 11): # Incluye el primero y no el últimmo. Usando un ciclo FOR usando la var "num" en el tramo de 0-10, ambos incluidos
+ lista1_pot10_2.append (num**2) # Llenamos la lista con potencias PARTIENDO DE 0, a 10 (11-1)
+print(lista1_pot10_2) # Salida por pantalla [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
-#[4, 9, 16]
-#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
-#Método 3-2
+# Alternativa 2
#Entonces el ejemplo anterior usando listas de comprensión, eso seria así:
#lista2_pot10_2 = [num2**2 for num2 in range(0, 11)] #Creamos la lista con los valores según condición
#print("Este es el método 3-2, para crear la lista de 10 números y sus potencias",lista2_pot10_2)
#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
#De este código anterior usted puede aprender que es posible modificar al vuelo los elementos los cuales van a formar la lista.
-# Ej
-# Con este ejemplo se ve como funciona el conteo de posiciones en una lista (cada elemento es una posX)
+# Ejemplo 8
+# Este ejemplo muestra como operan las posiciones en una lista (cada elemento es una posX)
lista = ["pos0", "pos1", "pos2", "pos3", "pos4", "pos5"]
print("Esta es la lista:\n", lista, "\n")
print("1° Mostrar 'lista[2:5]', significa la pos2, pero excluye la 5, ojo!\n", lista[2:5]) # tomamos del 2 al 5 (sin incluir el 5)
@@ -53,8 +83,8 @@
print("5° Mostrar 'lista[4:1:-1]', significa orden desc de la pos4 a la 2, excluye la pos1",lista[4:1:-1])
print("6° Mostrar 'lista[:]', significa mostrar todos los elementos de la lista\n",lista[:]) # tomamos desde el principio hasta el final (es como hacer una copia de la lista)
print("7° Mostrar 'lista[::-1]', significa mostrar todos los elementos de la lista en orden inverso\n",lista[::-1]) # tomamos desde el final hasta el principip (orden inverso)
-"""
-# EJ 5
+
+# Ejemplo 9
# Con este ejemplo usamos un truco para controlar la salida, un método de print llamado end
#
for i in range (15):
@@ -63,15 +93,81 @@
else:
print (i)
-"""
-# Ej 6
+# Ejemplo 10
# Mismo ejemplo sin controlar la salida, cada linea se ejecuta y se apilan.
-#for i in range (15):
-# print (i)
+for i in range (15):
+ print (i)
+
+# Ejemplo 11
+# Revisar otra formas de ordenar listas
+lista_desordenada = [5,7,2,8,3,6]
+lista_desordenada.sort()
+print ("Resultado esperado 2,3,5,6,7,8, lista generada :", lista_desordenada)
+print (type(lista_desordenada))
+
+# Ejemplo 12
+# Lista negada = los inversos y lista doble = multiplicadas por algo
+lista = [10, 20, 30]
+lista_negada = [ -e for e in lista ] # Los inversos de los elementos
+lista_doble = [ e*2 for e in lista] # Los elementos multiplicados por 2
+print(lista_negada)
+print(lista_doble)
+
+# Ejemplo 13
+# Una lista de valores float, no se pueden negar strings
+lista2 = [True, True, False, 5, 2-3j]
+lista_negada2 = [ -e for e in lista2] # Los inversos de los elementos numéricos
+lista_doble2 = [ e*2 for e in lista2] # Los elementos multiplicados por 2
+print(lista_negada2) # Nótese la salida [-1, -1, 0, -5, (-2+3j)], los booleanos los tomo como 1 y 0
+print(lista_doble2) # Nótese la salida [2, 2, 0, 10, (4-6j)], fijarse en los booleanos
+
+# Ejemplo 14
+# Con un ciclo for, alimenta dos listas dependiendo de una condición y muestra la información horizontal.
+lista_i = []
+lista_p = []
+for i in range (1,21):
+ n=(i%2)
+ if n==1:
+ lista_i.append (i)
+ elif n==0:
+ lista_p.append (i)
+print ("Los números impares entre 1 y 20 son ", lista_i)
+print ("Los números pares entre 1 y 20 son ", lista_p)
+
+# Ejemplo 15
+# Usos de 'enumerate' en listas, tuplas, diccionarios, cadenas
+for i, val in enumerate(['A', 'B', 'C']):
+ print(i, val)
"""
+0 A
+1 B
+2 C
"""
-# Revisar formas de ordenar listas
-lista_desordenada = (5,7,2,8,3,6)
-print (lista_desordenada)
-print (lista_desordenada.sort())
-"""
\ No newline at end of file
+
+# En este caso imprime la posición o puntero, y e contenido de la posición, vertical
+
+# Ejemplo 16
+
+for i, val in enumerate(['A', 'B', 'C'], start=5): # Mismo anterior, pero cambia el valor del puntero que parte en 5
+ print(i, val)
+"""
+5 A
+6 B
+7 C
+"""
+# La salida va de 5 a 7
+
+# Ejemplo 17
+# En este caso va de 5 a 14, se salta 3, y el puntero inicia en 1
+for i, val in enumerate(range(5, 15, 3), start=1):
+ print(f'Pos: {i} -> {val}')
+"""
+Pos: 1 -> 5
+Pos: 2 -> 8
+Pos: 3 -> 11
+Pos: 4 -> 14
+"""
+# La salida va con los textos 'Pos: ' y '->'
+print ("")
+
+# Ejemplo
\ No newline at end of file
diff --git a/Workbench/Taller/variables.py b/Workbench/Taller/variables.py
index cb71de421..bfd2c9c5b 100644
--- a/Workbench/Taller/variables.py
+++ b/Workbench/Taller/variables.py
@@ -1,5 +1,5 @@
#Variables
-#It's memory location to assign data to store and use ir later
+#It's a memory location to assign data to store and use it later
a=10
b=3
print (a)
@@ -8,4 +8,4 @@
print ("what's the value of b", b)
print (a+b)
total =2+4
-print (total)
\ No newline at end of file
+print (total)
From c1ca111b4efb2652840a75f3cd79264f12371132 Mon Sep 17 00:00:00 2001
From: Jorge Cordova <55065873+jcordovaj@users.noreply.github.com>
Date: Mon, 23 Jan 2023 04:26:48 -0300
Subject: [PATCH 04/16] 230123-0432 Atualizacion
---
...B\303\241sico_Interactivo_de_Python.ipynb" | 982 ------------------
Workbench/Taller/listas.py | 2 +-
2 files changed, 1 insertion(+), 983 deletions(-)
delete mode 100644 "Copia_de_Tutorial_B\303\241sico_Interactivo_de_Python.ipynb"
diff --git "a/Copia_de_Tutorial_B\303\241sico_Interactivo_de_Python.ipynb" "b/Copia_de_Tutorial_B\303\241sico_Interactivo_de_Python.ipynb"
deleted file mode 100644
index 8a4ee6328..000000000
--- "a/Copia_de_Tutorial_B\303\241sico_Interactivo_de_Python.ipynb"
+++ /dev/null
@@ -1,982 +0,0 @@
-{
- "nbformat": 4,
- "nbformat_minor": 0,
- "metadata": {
- "colab": {
- "provenance": [],
- "private_outputs": true,
- "include_colab_link": true
- },
- "kernelspec": {
- "name": "python3",
- "display_name": "Python 3"
- },
- "language_info": {
- "name": "python"
- },
- "gpuClass": "standard"
- },
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "view-in-github",
- "colab_type": "text"
- },
- "source": [
- ""
- ]
- },
- {
- "cell_type": "markdown",
- "source": [
- "# Tutorial Básico Interactivo de Python de Código Pitón\n",
- "\n",
- "\n",
- "\n",
- "¡Hola! **Bienvenido al Tutorial Básico Interactivo de Python de [Código Pitón](https://www.codigopiton.com/)**.\n",
- "\n",
- "Este tutorial recoge una guía básica de los fundamentos de Python en forma de cuaderno de Jupyter alojado en Google Colab (Colaboratory).\n",
- "\n",
- "Está estrechamente ligado a la [Hoja de Referencia de Python de Código Pitón](https://www.codigopiton.com/la-hoja-de-referencia-de-python/) que recibiste cuando te suscribiste a la lista de correo de Código Pitón.\n",
- "\n",
- "Si no tienes la Hoja de Referencia (por ejemplo, porque alguien te compartió este tutorial) puedes [conseguirla de manera gratuita al susbscribirte a Código Pitón](https://www.codigopiton.com/la-hoja-de-referencia-de-python/) y te llegará inmediatamente por correo electrónico.\n",
- "\n",
- "La **idea principal de este tutorial** es que tengas una guía interactiva para complementar perfectamente a la Hoja de Referencia y a la que puedas recurrir durante tu aprendizaje si te surge alguna duda. Espero que te sea de mucha utilidad.\n",
- "\n",
- "El tutorial tiene 15 apartados, exactamente igual que la Hoja de Referencia, y en el mismo orden, para que no te pierdas en ningún momento. Además, les he puesto el mismo nombre para que no quede lugar a ningún tipo de duda.\n",
- "\n",
- "¡Vamos allá!\n",
- "\n",
- "## Antes de empezar\n",
- "\n",
- "Si no estás muy familiarizado con los cuadernos de Jupyter, ¡no te preocupes! Aquí es todo muy fácil. Todo se organiza en celdas. Podrás ver celdas de texto explicativo (como este) y celdas con fragmentos de código Python ejecutable, como el siguiente:\n"
- ],
- "metadata": {
- "id": "EZslL1PpIsde"
- }
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "9NrJqYoyINXn"
- },
- "outputs": [],
- "source": [
- "print('¡Hola desde el Tutorial Básico Interactivo de Código Pitón! 😊') "
- ]
- },
- {
- "cell_type": "markdown",
- "source": [
- "Siéntete libre de ejecutar los fragmentos de código que quieras y de modificarlos a tu gusto para experimentar y aprender, ¡ese es el objetivo de este tutorial interactivo!\n",
- "\n",
- "Para ejecutar un fragmento de código basta con que hagas click en el icono de ejecutar a la izquierda de cada celda. También puedes ejecutarlos con la combinación de teclas Ctrl + Enter y verás el resultado justo debajo.\n",
- "\n",
- "Y ahora sí, vamos con el tutorial.\n",
- "\n",
- "\n",
- "\n",
- "\n",
- "\n",
- "Los contenidos son los siguientes:\n",
- "\n",
- "\n",
- "1. Asignación de variables\n",
- "2. Acceso a valor de variables\n",
- "3. Aritmética básica\n",
- "4. Importación de módulos\n",
- "5. Gestión de excepciones\n",
- "6. Salida y formato de texto\n",
- "7. Listas\n",
- "8. Condicionales\n",
- "9. Booleanos y comparaciones\n",
- "10. Comprensión de listas\n",
- "11. Comentarios\n",
- "12. Funciones\n",
- "13. Bucles\n",
- "14. Notación de porciones\n",
- "15. Entrada por teclado\n",
- "\n",
- "\n",
- "\n"
- ],
- "metadata": {
- "id": "IAHwNotEQtNy"
- }
- },
- {
- "cell_type": "markdown",
- "source": [
- "# 1. Asignación de variables\n",
- "\n",
- "Los principales tipos de datos son números enteros (int), números decimales (float), cadenas de texto (str) y valores booleanos (verdadero o falso, te cuento más sobre esto más adelante).\n",
- "\n",
- "Para realizar asignaciones utiliza nombres de variables identificativos, el símbolo = y el valor que quieras asociar a la variable."
- ],
- "metadata": {
- "id": "qhinAwWbPwsG"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "x = 10 # enteros\n",
- "y = 0.5 # decimales\n",
- "z = 'hola' # texto\n",
- "b = True # booleanos\n",
- "print(x)\n",
- "print(y)\n",
- "print(z)\n",
- "print(b)"
- ],
- "metadata": {
- "id": "bl-PHta-TM7D"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "Las principales colecciones de datos son las listas (modificables), las tuplas (no modificables), los conjuntos (que no admiten repetidos) y los diccionarios (que guardan pares clave-valor)."
- ],
- "metadata": {
- "id": "ltpQ4vgOTgx6"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "tupla = (1, 2, 3)\n",
- "lista = [4, 5.5, 'a6']\n",
- "conjunto = ('a', 'b', 'c')\n",
- "\n",
- "print(tupla)\n",
- "print(lista)\n",
- "print(conjunto)\n",
- "\n",
- "diccionario = {10: 1.1, 20: 1.0, 30: 1.3}\n",
- "diccionario[40] = 1.5 # asignando un valor (1.5) a una nueva clave (40)\n",
- "print(diccionario)\n",
- "\n",
- "x, y, z = 1, 2, 3 # asignación múltiple\n",
- "print('Tras la asignación múltiple: ')\n",
- "print(x)\n",
- "print(y)\n",
- "print(z)\n",
- "\n",
- "print('Tras intercambiar valores: ')\n",
- "x, y = y, x # intercambio de valores\n",
- "print(x)\n",
- "print(y)\n",
- "\n",
- "print('Tras desempaquetar una tupla en variables: ')\n",
- "x, y, z = (10, 20, 30)\n",
- "print(x)\n",
- "print(y)\n",
- "print(z)\n"
- ],
- "metadata": {
- "id": "mBTQ6WUbTmSX"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "# 2. Acceso a valor de variables\n",
- "\n",
- "Cuando ya hemos hecho asignaciones y tenemos variables con valores, podemos acceder a esos valores utilizando el nombre de las variables en otras expresiones.\n",
- "\n",
- "Además, podemos acceder a los elementos de una lista o una tupla a través de su índice (número de posición, comenzando en 0) indicándolo entre corchetes \\[ y \\].\n",
- "\n",
- "Para acceder a los valores de un diccionario utilizaremos la clave asociada a cada valor, de nuevo entre corchetes.\n",
- "\n",
- "También podemos acceder a los atributos de una clase utilizando el nombre de la clase, un punto y a continuación el nombre del atributo. De igual manera, podemos acceder a los atributos de un objeto o instancia utilizando el nombre del objeto, un punto y a continuación el nombre del atributo.\n"
- ],
- "metadata": {
- "id": "xUu-z6MPQTn8"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "lista = [10, 20, 30, 40, 50]\n",
- "valor = lista[2]\n",
- "print(valor)\n",
- "\n",
- "diccionario = {10: 5, 20: 7, 30: 9}\n",
- "valor = diccionario[20]\n",
- "print(valor)\n",
- "valor = diccionario.get(40, '0') # valor por defecto 0 si clave (40) no existe\n",
- "\n",
- "class Clase:\n",
- "\n",
- " atributo_de_clase = 10\n",
- "\n",
- " def __init__(self):\n",
- " self.atributo_de_instancia = 20\n",
- "\n",
- "\n",
- "print(Clase.atributo_de_clase)\n",
- "\n",
- "instancia = Clase()\n",
- "print(instancia.atributo_de_instancia)"
- ],
- "metadata": {
- "id": "Dv3EgoExVqhr"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "Más información sobre variables: https://www.codigopiton.com/variables-locales-y-globales-en-python/"
- ],
- "metadata": {
- "id": "hllJO5IAMPS1"
- }
- },
- {
- "cell_type": "markdown",
- "source": [
- "# 3. Aritmética básica\n",
- "\n",
- "Podemos realizar operaciones matemáticas aritméticas básicas utilizando los símbolos +, -, * (multiplicación), / (división), // (división entera), % (resto de la división entera o módulo) y \\*\\* (potencia).\n"
- ],
- "metadata": {
- "id": "GXjjRcl4QzB8"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "print(3 + 5)\n",
- "print(5 - 3)\n",
- "print(5 * 3)\n",
- "print(5 / 3)\n",
- "print(5 // 3)\n",
- "print(5 % 3)\n",
- "print(5 ** 3)"
- ],
- "metadata": {
- "id": "SSDZqkv8XRer"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "# 4. Importación de módulos\n",
- "\n",
- "Si necesitas utilizar una librería (tanto de Python como externa) tendrás que importar el módulo correspondiente con import. \n",
- "\n",
- "Podrás darle un alias al módulo si utilizas as.\n",
- "\n",
- "También puedes importar un componente concreto de un módulo a través de from."
- ],
- "metadata": {
- "id": "WItnb6q8Q-fp"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "import datetime\n",
- "\n",
- "print(datetime.datetime.now())"
- ],
- "metadata": {
- "id": "aVd-5GYuYY8f"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "code",
- "source": [
- "import datetime as dt\n",
- "\n",
- "print(dt.datetime.now())"
- ],
- "metadata": {
- "id": "pmez2i-FYx0G"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "code",
- "source": [
- "from datetime import datetime as dt\n",
- "\n",
- "print(dt.now())"
- ],
- "metadata": {
- "id": "u52AMnEFY3Cf"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "# 5. Gestión de excepciones\n",
- "\n",
- "Para manejar errores y excepciones tienes que usar la construcción try - except - finally. De no hacerlo, el código interrumpe su ejecución en caso de surgir algún error.\n",
- "\n",
- "Algunos de los errores más comunes son los siguientes:\n",
- "* SyntaxError: sintaxis incorrecta\n",
- "* ValueError: valor argumento no válido\n",
- "* ZeroDivisionError: división por cero\n",
- "* NameError: variable no definida\n",
- "* ModuleNotFoundError: modulo no existe\n",
- "* FileNotFoundError: fichero no existe\n",
- "* IndexError: índice no existe\n",
- "* KeyError: clave no existe\n",
- "\n",
- "\n",
- "\n"
- ],
- "metadata": {
- "id": "j_bTR38XRB1Y"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "# El siguiente código genera un error\n",
- "\n",
- "a = 10\n",
- "b = 0\n",
- "\n",
- "print(a/b) # no se puede dividir por cero"
- ],
- "metadata": {
- "id": "-XPkB0XRbR88"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "code",
- "source": [
- "# Vamos a controlar el error para que no se interrumpa la ejecución\n",
- "\n",
- "a = 10\n",
- "b = 0\n",
- "\n",
- "try:\n",
- " print(a/b)\n",
- "except ZeroDivisionError:\n",
- " print('Lo siento, no puedo dividir por cero.')\n",
- "finally:\n",
- " print('Bloque try-except finalizado') # esto, que es opcional, se ejecuta siempre, haya error o no\n",
- " "
- ],
- "metadata": {
- "id": "fp6wj4dybZI4"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "# 6. Salida y formato de texto\n",
- "\n",
- "Ya has visto que la función *print* se utiliza para mostrar información por pantalla.\n",
- "\n",
- "Podemos personalizar la manera en que se muestra esa información de múltiples maneras. Algunas formas sencillas y básicas son la siguientes:"
- ],
- "metadata": {
- "id": "e-4K3kjIRIee"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "a = 10\n",
- "b = 20\n",
- "c = 30.158\n",
- "print(a)\n",
- "print('b=' + str(b)) # convertimos un numero a string con str\n",
- "\n",
- "print('a=%i' % a) # usamos una máscara de número entero (%i) dentro de la cadena de texto\n",
- "print('a=%i, b=%i' % (a, b))\n",
- "\n",
- "print('a={}, b={}'.format(a, b))\n",
- "print('c={:.2f}'.format(c)) # puedes indicar se se usen solo dos decimales para un float\n",
- "\n",
- "print(f'a={a}, b={b}') # usamos f-strings, la forma preferida\n"
- ],
- "metadata": {
- "id": "soEeTeTKcHDu"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "# 7. Listas\n",
- "\n",
- "Podemos hacer muchas cosas con las listas, pues son secuencias muy potentes. Veamos algunas:"
- ],
- "metadata": {
- "id": "OowBr9SiOINH"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "lista = [5, 6, 7]\n",
- "\n",
- "lista.append(8) # añadimos un elemento al final\n",
- "print(lista)\n",
- "\n",
- "lista.insert(1, 10) # insertamos un elemento en la posición que queramos\n",
- "print(lista)\n",
- "\n",
- "lista.remove(6) # eliminamos un elemento\n",
- "del lista[0] # eliminamos una posición\n",
- "print(lista)\n",
- "\n",
- "lista.clear() # vacíamos la lista\n",
- "print(lista)\n",
- "\n",
- "lista = [5, 6, 7]\n",
- "elementos = [8, 9]\n",
- "\n",
- "lista.extend(elementos) # añadimos al final los elementos de otra lista\n",
- "print(lista)\n",
- "\n",
- "lista.reverse() # invertimos la lista (le damos la vuelta)\n",
- "print(lista)\n",
- "\n",
- "print(len(lista)) # obtenemos el número de elementos (o longitud) de una lista\n",
- "\n",
- "print(lista.index(7)) # obtenemos el índice de un elemento\n",
- "\n"
- ],
- "metadata": {
- "id": "ahagt7kyeE5J"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "Aquí tienes más información sobre cómo obtener la posición o índice de un elemento en una lista: https://www.codigopiton.com/encontrar-indice-de-elemento-en-lista-en-python/"
- ],
- "metadata": {
- "id": "nyQRye6VfOcC"
- }
- },
- {
- "cell_type": "markdown",
- "source": [
- "# 8. Condicionales\n",
- "\n",
- "Las condicionales nos permiten ejecutar un determinado fragmento de código si se cumple una determinada condición (rama if).\n",
- "\n",
- "Además, podemos indicar que, si no se cumple dicha condición, se ejecute otro código (rama else).\n",
- "\n",
- "Finalmente, se permite encadenar varias ramas ifs con distintas condiciones (elif) y una rama else si no se cumple ninguna de las condiciones indicadas. Las ramas aquí son excluyentes."
- ],
- "metadata": {
- "id": "ju3H-DAjOId7"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "a = 10\n",
- "b = 20\n",
- "\n",
- "if a < 15:\n",
- " print('a es menor que 15') # esto se ejecutará ya que se cumple la condición\n",
- "\n",
- "\n",
- "if a > 15:\n",
- " print('a es mayor que 15') # esto no se ejecutará ya que no se cumple la condición\n",
- "\n",
- "if a > 30:\n",
- " print('a es mayor que 30') # esto no se ejecutará ya que no se cumple la condición\n",
- "else:\n",
- " print('a no es mayor que 30') # esto sí se ejecutará ya que no se cumple la condición\n",
- "\n",
- "\n",
- "if b > 10:\n",
- " print('b es mayor que 10') # esto se ejecutará ya que se cumple la condición\n",
- "else:\n",
- " print('b no es mayor que 10') # esto no se ejecutará ya que se cumple la condición\n",
- "\n",
- "\n",
- "# a continuación se comprobaran las condiciones secuencialmente y se ejecutara \n",
- "# solo el fragmento de código de la condición que se cumpla (condiciones excluyentes)\n",
- "\n",
- "if a < 10:\n",
- " print('a es menor que 10')\n",
- "elif a > 12:\n",
- " print('a es mayor que 12')\n",
- "elif b > 15:\n",
- " print('b es mayor que 15') # esta es la rama que se ejecuta\n",
- "elif b == 20:\n",
- " print('b es igual a 20') # aunque la condición de esta rama es cierta no se ejcuta\n",
- " # pues ya se ejecutó otra rama antes\n",
- "else:\n",
- " print('no se ha cumplido ninguna de las condiciones anteriores')"
- ],
- "metadata": {
- "id": "JV2mITN3a2TG"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "Más información sobre condicionales: https://www.codigopiton.com/condicionales-en-python-mucho-mas-que-if-else/\n",
- "\n",
- "La estrucutura de control switch no existe en Python. Más información sobre cómo hacer switch en Python: https://www.codigopiton.com/como-hacer-switch-case-en-python/\n",
- "\n",
- "En Python existe, además, un operador ternario condicional: https://www.codigopiton.com/el-operador-ternario-condicional-en-python/\n",
- "\n",
- "Aunque desde la versión 3.10 de Python existe un mecanismo de \"pattern matching\" que se puede utilizar para emular un switch. Más información: https://peps.python.org/pep-0636/"
- ],
- "metadata": {
- "id": "EPh-Axa2cc1L"
- }
- },
- {
- "cell_type": "markdown",
- "source": [
- "# 9. Booleanos y comparaciones\n",
- "\n",
- "Ahora que ya sabes cómo hacer condicionales, vamos a revisar los valores booleanos y las principales posibles comparaciones y comprobaciones que se pueden hacer en Python que devuelven valores booleanos.\n",
- "\n",
- "Los valores booleanos, son True y False (escritos con inicial mayúscula) y cuyo significado es \"cierto\" y \"falso\" respectivamente.\n",
- "\n",
- "Comparaciones y comprobaciones principales:\n",
- "* Mayor: >\n",
- "* Mayor o igual: >=\n",
- "* Menor: <\n",
- "* Menor o igual: <=\n",
- "* Igual: ==\n",
- "* Diferente: !=\n",
- "* Pertenencia: in\n",
- "\n",
- "Puedes negar un valor booleano o condición para obtener el valor contrario con la palabra reservada \"not\"."
- ],
- "metadata": {
- "id": "rQKB2F9AOIr2"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "a = 2\n",
- "b = 3\n",
- "\n",
- "print('Comparaciones simples:')\n",
- "print(a > b)\n",
- "print(a >= b)\n",
- "print(a < b)\n",
- "print(a <= b)\n",
- "print(a == b)\n",
- "print(a != b)\n",
- "\n",
- "print('Comprobación de pertenencia:')\n",
- "lista = [1, 3, 5]\n",
- "print(a in lista)\n",
- "print(b in lista)\n",
- "\n",
- "print('Negación con not')\n",
- "print(not True)\n",
- "print(not False)\n",
- "print(not a > b)\n",
- "print(not a == b)\n"
- ],
- "metadata": {
- "id": "aBjkpZRyd8V9"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "Más información sobre booleanos, comparaciones, condicionales, etc.: https://www.codigopiton.com/condicionales-en-python-mucho-mas-que-if-else/"
- ],
- "metadata": {
- "id": "ZZKF7GPaeoZO"
- }
- },
- {
- "cell_type": "markdown",
- "source": [
- "Puedes combinar distintas comparaciones para crear una más compleja con las palabras reservadas \"and\" y \"or\".\n",
- "\n",
- "Cuando usas and entre dos comparaciones o condiciones, ambas deben ser True para que la condición combinada sea True.\n",
- "\n",
- "Cuando usas or entre dos comparaciones o condiciones, al menos una de ellas tiene que ser True para que la condición combinada sea True."
- ],
- "metadata": {
- "id": "2tzz0ZRjwqHo"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "a = 2\n",
- "b = 3\n",
- "print(b >= 3 and a == 2)\n",
- "print(a < 10 and b < 2)\n",
- "print(a == 2 or b == 0)\n",
- "print(a < 0 or b < 0)"
- ],
- "metadata": {
- "id": "Mu96IFV6xECQ"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "# 10. Comprensión de listas\n",
- "\n",
- "En Python podemos generar listas \"al vuelo\" utilizando un bucle for que devuelva un elemento e en cada iteración, aplicando un cálculo o expresión sobre e y encerrándolo todo entre [corchetes](https://www.codigopiton.com/parentesis-corchetes-llaves-en-python/). \n",
- "\n",
- "De esta manera se genera una lista con todos los elementos generados a partir de e.\n",
- "\n",
- "Ejemplos:"
- ],
- "metadata": {
- "id": "MVkNPcwDOI6A"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "lista = [10, 20, 30]\n",
- "\n",
- "lista_negada = [ -e for e in lista ]\n",
- "lista_doble = [ e*2 for e in lista]\n",
- "\n",
- "print(lista_negada)\n",
- "print(lista_doble)"
- ],
- "metadata": {
- "id": "gEhGP1_bfcp2"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "# 11. Comentarios\n",
- "\n",
- "En el código que escribas puedes (y debes) incluir comentarios explicativos.\n",
- "\n",
- "Los comentarios no son interpretados por el interprete de Python y no afectan al código ni a su ejecución.\n",
- "\n",
- "Puedes usar el símbolo \\# para añadir un comentario al principio o al final de una línea (como ya has visto en este tutorial).\n",
- "\n",
- "Además, si necesitas hacer un comentario de varias líneas basta con que lo encierres en triples comillas ' ' ' o \" \" \".\n",
- "\n",
- "Ejemplos:\n"
- ],
- "metadata": {
- "id": "NZjQEM3MOJGX"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "# inicialización de variables (este es un comentario de una línea)\n",
- "a = 10\n",
- "b = 20\n",
- "\n",
- "''' En este comentario de varias líneas\n",
- "voy a explicar lo que hago a continuación:\n",
- "sumaré los valores de a y b y si suman más de 25\n",
- "mostraré un mensaje de éxito por pantalla '''\n",
- "\n",
- "if a + b > 25:\n",
- " print('¡Éxito!') # este será mi mensaje de éxito"
- ],
- "metadata": {
- "id": "HtJvtFjbgbMA"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "# 12. Funciones\n",
- "\n",
- "Tanto para estructurar nuestro código así como para favorecer la reutilización del mismo se utilizan funciones.\n",
- "\n",
- "Las funciones nos permiten encapsular un fragmento de código y darle un nombre.\n",
- "\n",
- "Para definir una función usamos la palabra reservada \"def\" a continuación el nombre de la función y los parámetros que necesitemos entre paréntesis. La función puede devolver uno o varios valores si lo necesita (o ninguno).\n",
- "\n",
- "Después se puede invocar una función creada a través de su nombre."
- ],
- "metadata": {
- "id": "QWnzNyKROJSs"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "def suma(a, b):\n",
- " return a + b\n",
- "\n",
- "\n",
- "# min y max son funciones integradas en Python que nos devuelven\n",
- "# los valores mínimo y máximo de un iterable (como las listas o las tuplas)\n",
- "def min_y_max(lista):\n",
- " return min(lista), max(lista)\n",
- "\n",
- "\n",
- "# ahora vamos a usar estas funciones\n",
- "valor = suma(10, 15)\n",
- "print(valor)\n",
- "\n",
- "minimo, maximo = min_y_max([30, 10, 50, 40, 20])\n",
- "print(f'min y max son {minimo} y {maximo}')\n"
- ],
- "metadata": {
- "id": "DD5-_oeLsiNX"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "# 13. Bucles\n",
- "\n",
- "Los bucles son un mecanismo de control de flujo que nos permite repetir un fragmento de código un número determinado de veces.\n",
- "\n",
- "Hay dos tipos:\n",
- "\n",
- "\n",
- "1. while, que nos permite controlar mediante una condición el número de repeticiones.\n",
- "2. for, que nos permite iterar por los elementos de una colección de manera sencilla y cómoda.\n",
- "\n",
- "El código que queremos repetir, también llamado \"cuerpo del bucle\" debe indentarse tras el for o el while.\n",
- "\n"
- ],
- "metadata": {
- "id": "yJaf1DpiOJeh"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "# ejemplo de while\n",
- "a = 0\n",
- "\n",
- "while (a < 10): # mientras a sea < 10 el cuerpo del bucle se repetirá\n",
- " print(a)\n",
- " a = a + 1 # sumamos 1 a la variable a para asegurarnos de que la condición del bucle será False en algún momento\n",
- "\n",
- "# ejemplo de for\n",
- "lista = [10, 20, 30, 40]\n",
- "\n",
- "for elemento in lista:\n",
- " print(elemento)\n",
- "\n"
- ],
- "metadata": {
- "id": "lIfvC-pN_QhY"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "Dentro de los bucles puedes utilizar las sentencias de control break y continue:\n",
- "* break termina anticipadamente el bucle\n",
- "* continue interrumpe la vuelta actual del bucle y continúa con la siguiente."
- ],
- "metadata": {
- "id": "6_U1A3i9AEdq"
- }
- },
- {
- "cell_type": "markdown",
- "source": [
- "# 14. Notación de porciones\n",
- "\n",
- "Cuando tenemos una colección de elementos indexados por posición (como una lista o una tupla), podemos acceder a una porción concreta utilizando la notación de porciones.\n",
- "\n",
- "Se utilizan los corchetes entre los que indicamos tres números separados por el carácter ':'. De esta manera\n",
- "\n",
- "lista\\[ini:fin:paso\\]\n",
- "\n",
- "Donde:\n",
- "* ini es la posición del elemento primero en nuestra porción.\n",
- "* fin es la posición del elemeto último (no incluido) de nuestra porción (el último incluido será el correspondiente a la posición fin -1).\n",
- "* paso (optativo) indica la manera en la que tomaremos la porción: si es un número positivo tomaremos los elementos en el orden en el que aparecen, si es negativo los tomaremos en orden inverso (fin tiene que ser anterior a ini). Si la magnitud es 1, tomaremos todos los elementos, si es 2, tomaremos uno y saltaremos otro, si es 3, tomaremos uno y saltaremos 2, etc.\n",
- "\n",
- "Si dejamos ini o fin sin indicar se interpreta que la porción se toma desde el comienzo o el final respectivamente.\n",
- "\n",
- "Veamos algunos ejemplos:\n"
- ],
- "metadata": {
- "id": "WQw19GRlOJrp"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "lista = [10, 20, 30, 40, 50, 60]\n",
- "\n",
- "print(lista[2:5]) # tomamos del 2 al 5 (sin incluir el 5)\n",
- "print(lista[4:]) # tomamos del 4 hasta el final\n",
- "print(lista[:2]) # tomamos desde el principio hasta el 2 (sin incluir)\n",
- "print(lista[1:6:2]) # tomamos 1 de cada 2 elementos desde el 1 hasta el 6 (sin incluir)\n",
- "print(lista[4:1:-1]) # tomamos en orden inverso desde el 4 al 1 (sin incluir)\n",
- "print(lista[:]) # tomamos desde el principio hasta el final (es como hacer una copia de la lista)\n",
- "print(lista[::-1]) # tomamos desde el final hasta el principip (orden inverso) "
- ],
- "metadata": {
- "id": "rxqQW9h2Hvja"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "# 15. Entrada por teclado\n",
- "\n",
- "Si necesitamos hacer un programa o script interactivo, a menudo necesitaremos pedir algún valor al usuario por teclado.\n",
- "\n",
- "Python nos proporciona la función integrada \"input\" que nos sirve precisamente para eso. Al ejecutarse \"input\" el programa se queda esperando a que el usuario introduzca un valor y pulse intro. Posteriormente ese valor se guarda en la variable que queramos en formato string.\n",
- "\n",
- "Podemos hacer la conversión a un tipo numérico si así lo deseamos llamando a las funciones int o float."
- ],
- "metadata": {
- "id": "BBXUukIZOJ3n"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "entrada = input('Dame tu nombre, por favor: ')\n",
- "print(f'¡Hola, {entrada}!')\n",
- "entrada = input('Dame un número entero, por favor: ')\n",
- "numero = int(entrada) # convertimos entrada a int\n",
- "print(f'El número es {numero}')"
- ],
- "metadata": {
- "id": "RnvW1ddeJU-1"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "# Ejercicio final: juego de adivinar un número entre 1 y 10\n",
- "\n",
- "Para finalizar este tutorial, voy a realizar un pequeño juego en el que el usuario tiene que adivinar un número generado al azar entre 1 y 10 y en el que solo tendrá 3 intentos para hacerlo.\n",
- "\n",
- "Para esto voy a utilizar muchas de las cosas contadas arriba. Además, comentaré el código para que todo quede perfectamente claro. Léelo con calma intentando comprender cada línea.\n",
- "\n",
- "Y, por supuesto, ¡puedes ejecutarlo para jugar tú!\n"
- ],
- "metadata": {
- "id": "XCN38-bphFTC"
- }
- },
- {
- "cell_type": "code",
- "source": [
- "import random # necesitamos esta librería para poder generar un número al azar\n",
- "\n",
- "numero_secreto = random.randint(1, 10) # esto nos genera un número aleatorio entre 1 y 10\n",
- "oportunidades = 3 # el número de oportunidades que nos quedan\n",
- "acertado = False # esta variable nos servirá para saber si el usuario ha acertado\n",
- "\n",
- "print('* Bienvenido a nuestro pequeño juego del Tutorial Básico Interactivo de Código Pitón')\n",
- "print() # imprimimos por pantalla una línea en blanco\n",
- "print('Acabo de pensar un número secreto entre 1 y 10. Tienes tres oportunidades para')\n",
- "print('adivinarlo. Te iré guiando un poco hacia la solución. ¡Suerte!')\n",
- "print()\n",
- "\n",
- "# Hacemos un bucle mientras queden oportunidades y mientras no se haya acertado el número secreto\n",
- "while oportunidades > 0 and not acertado:\n",
- " \n",
- " # Pedimos un número al usuario (y transformamos lo que escriba a entero mediante la función int)\n",
- " # ¡Cuidado! Si lo que escribe el usuario no es un entero el programa generará un error\n",
- " # El error puede ser controlado con try-except como vimos más arriba\n",
- " numero = int(input('Dime un número entre 1 y 10: '))\n",
- "\n",
- " # Ahora vamos a hacer la comprobación\n",
- " # e indicamos al usuario si el número secreto es mayor, menor o si lo ha averiguado\n",
- " if numero < numero_secreto:\n",
- " print('Te has quedado corto, el número secreto es más grande.')\n",
- " elif numero > numero_secreto:\n",
- " print('Te has pasado, el número secreto es más pequeño.')\n",
- " else:\n",
- " print(f'¡Enhorabuena! Has acertado en el intento {4-oportunidades}.')\n",
- " acertado = True # ponemos acertado a cierto para que se detenga el bucle\n",
- "\n",
- " if not acertado: # si no ha acertado indicamos las oprtunidades que le quedan\n",
- " oportunidades = oportunidades - 1 # restamos 1 a las oportunidades\n",
- " print(f'Te quedan {oportunidades} oportunidades.')\n",
- "\n",
- " print()\n",
- "\n",
- "# cuando termine el bucle de juego mostramos el número de adinivinar\n",
- "# y nos despedimos del usuario\n",
- "\n",
- "if not acertado: # si no se acierta el número se muestra por pantalla\n",
- " print(f'* El número secreto era {numero_secreto}.')\n",
- "\n",
- "print('* ¡Gracias por jugar! ¡Hasta pronto!') \n",
- "\n"
- ],
- "metadata": {
- "id": "8hziKM46ho_K"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "source": [
- "**¡Muchas gracias por haber usado este tutorial!**\n",
- "\n",
- "Recurre a él todas las veces que te haga falta hasta que te queden claros sus conceptos.\n",
- "\n",
- "Y no dejes de visitar [Código Pitón](https://www.codigopiton.com/).\n",
- "\n",
- "Un saludo,\n",
- " \n",
- "Juan.-\n",
- "\n",
- "P.S. ¿Te atreves a modificar el juego que hemos visto para que al terminar el juego el programa le pregunte al usuario si quiere volver a jugar? Si el usuario dice que sí, se vuelve a \"pensar\" un número secreto y se juega de nuevo. Si el usuario dice que no, se termina el programa."
- ],
- "metadata": {
- "id": "0MrEzDjjnuD8"
- }
- }
- ]
-}
\ No newline at end of file
diff --git a/Workbench/Taller/listas.py b/Workbench/Taller/listas.py
index 704f13cbe..fc5b6cc56 100644
--- a/Workbench/Taller/listas.py
+++ b/Workbench/Taller/listas.py
@@ -144,7 +144,7 @@
2 C
"""
-# En este caso imprime la posición o puntero, y e contenido de la posición, vertical
+# En este caso imprime la posición o puntero, y el contenido de la posición, vertical
# Ejemplo 16
From eb3f44e7d3c39f1e96f185c2a7c1ee4dc48a0c82 Mon Sep 17 00:00:00 2001
From: Jorge Cordova <55065873+jcordovaj@users.noreply.github.com>
Date: Mon, 23 Jan 2023 04:38:09 -0300
Subject: [PATCH 05/16] =?UTF-8?q?230123=5F0437=20Actualizaci=C3=B3n=20Root?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
From 7f0397d2f4b817d811aede3f42de0a412322a3d0 Mon Sep 17 00:00:00 2001
From: Jorge Cordova <55065873+jcordovaj@users.noreply.github.com>
Date: Mon, 23 Jan 2023 04:50:38 -0300
Subject: [PATCH 06/16] Actualizar
From 572d2aabfe8739774def48a43088b973e25f76d0 Mon Sep 17 00:00:00 2001
From: Jorge Cordova <55065873+jcordovaj@users.noreply.github.com>
Date: Mon, 23 Jan 2023 08:44:25 -0300
Subject: [PATCH 07/16] 230123-0843 Mover Apuntes01.ipynb y cambio extension py
---
Workbench/Taller/Apuntes01.ipynb | 80 --------------------
Workbench/Taller/{Funciones => Funciones.py} | 0
2 files changed, 80 deletions(-)
delete mode 100644 Workbench/Taller/Apuntes01.ipynb
rename Workbench/Taller/{Funciones => Funciones.py} (100%)
diff --git a/Workbench/Taller/Apuntes01.ipynb b/Workbench/Taller/Apuntes01.ipynb
deleted file mode 100644
index 7b28b9a52..000000000
--- a/Workbench/Taller/Apuntes01.ipynb
+++ /dev/null
@@ -1,80 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hello World\n"
- ]
- }
- ],
- "source": [
- "print (\"Hello World\")"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "página1\n",
- "página2\n",
- "página3\n",
- "página4\n"
- ]
- }
- ],
- "source": [
- "libro = ['página1', 'página2', 'página3', 'página4']\n",
- "marcapaginas = iter(libro)\n",
- "print(next(marcapaginas))\n",
- "print(next(marcapaginas))\n",
- "print(next(marcapaginas))\n",
- "print(next(marcapaginas))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- }
- ],
- "metadata": {
- "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.10.6 (tags/v3.10.6:9c7b4bd, Aug 1 2022, 21:53:49) [MSC v.1932 64 bit (AMD64)]"
- },
- "orig_nbformat": 4,
- "vscode": {
- "interpreter": {
- "hash": "d3777ed8f5fe800f0d3d1926318eb186c93d9a88e13881725c87e5bdd2f1dd1d"
- }
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/Workbench/Taller/Funciones b/Workbench/Taller/Funciones.py
similarity index 100%
rename from Workbench/Taller/Funciones
rename to Workbench/Taller/Funciones.py
From edef9841cba5a460194bdeaec337c040d143457b Mon Sep 17 00:00:00 2001
From: Jorge Cordova <55065873+jcordovaj@users.noreply.github.com>
Date: Mon, 23 Jan 2023 09:00:41 -0300
Subject: [PATCH 08/16] 230123-0900 Creacion Archivo txt, simula prueba
---
Estaesunaprueba.txt | 1 +
1 file changed, 1 insertion(+)
create mode 100644 Estaesunaprueba.txt
diff --git a/Estaesunaprueba.txt b/Estaesunaprueba.txt
new file mode 100644
index 000000000..fd5fe2a25
--- /dev/null
+++ b/Estaesunaprueba.txt
@@ -0,0 +1 @@
+Subir prueba
\ No newline at end of file
From 08633da0897604297cefba45bba26a987a08ecdc Mon Sep 17 00:00:00 2001
From: Jorge Cordova <55065873+jcordovaj@users.noreply.github.com>
Date: Wed, 25 Jan 2023 05:51:06 -0300
Subject: [PATCH 09/16] 2501230549 Sync
---
Workbench/Substrings.py | 29 +++++++++++++++++++++++++++
Workbench/Taller/Clases.py | 34 ++++++++++++++++++++++++++++++++
Workbench/Taller/Funciones.py | 7 ++++++-
Workbench/Taller/Prueba240123.py | 0
4 files changed, 69 insertions(+), 1 deletion(-)
create mode 100644 Workbench/Substrings.py
create mode 100644 Workbench/Taller/Clases.py
create mode 100644 Workbench/Taller/Prueba240123.py
diff --git a/Workbench/Substrings.py b/Workbench/Substrings.py
new file mode 100644
index 000000000..40ea5c555
--- /dev/null
+++ b/Workbench/Substrings.py
@@ -0,0 +1,29 @@
+# Buscar una subcadena con index
+import re
+obj_iter="palabra"
+varany = int
+pos_ini = int
+pos_fin = int
+obj_iter.sub[varany, pos_ini, pos_fin])
+#es similar a find() pero en caso de que no se encuentre la subcadena sub lanza la excepción ValueError.
+cadena = 'me gusta la mermelada'
+cadena.index('lo')
+#La cadena 'lo' no existe, por lo que provocará un error
+# Traceback (most recent call last):
+# File "", line 1, in
+# ValueError: substring not found
+
+cadena.index('la')
+9
+# Encontrar la última posición de una subcadena con RFIND
+cadena = 'me gusta la mermelada'
+cadena.rfind('la')
+print (cadena.rfind('la'))
+# 17
+print (cadena.rfind('lo'))
+# -1
+# Encontrar la última posición de una subcadena con RINDEX
+print (cadena.rindex('la'))
+# 17
+# print (cadena.rindex('lo'))
+# Debe arrojar un error porque no existe la cadena (ValueError: substring not found)
diff --git a/Workbench/Taller/Clases.py b/Workbench/Taller/Clases.py
new file mode 100644
index 000000000..f37c01c35
--- /dev/null
+++ b/Workbench/Taller/Clases.py
@@ -0,0 +1,34 @@
+class Car1:
+ def __init__(self, color, aceleracion):
+ self.color = color
+ self.aceleracion = aceleracion
+ self.velocidad = 0
+ self.ruedas = 4
+ self.direccion = 90
+ def Acelera(self):
+ self.acelera = self.aceleracion + self.velocidad
+ def frena(self):
+ v.frena = self.aceleracion - self.velocidad
+ if v < 0:
+ v = 0
+ self.velocidad = 0
+
+
+class Perro ():
+ # El método __init__ es llamado al crear el objeto
+ def __init__(self, nombre, raza):
+ print(f"Creando perro {nombre}, {raza}")
+ # Atributos de instancia
+ self.nombre = nombre
+ self.raza = raza
+
+c1 = Car1('rojo', 20)
+print (c1.color)
+# rojo
+print (c1.ruedas)
+# 4
+c2 = Car1('azul', 30)
+print(c2.color)
+# azul
+print(c2.ruedas)
+# 4
\ No newline at end of file
diff --git a/Workbench/Taller/Funciones.py b/Workbench/Taller/Funciones.py
index cdcc063de..82282c2f9 100644
--- a/Workbench/Taller/Funciones.py
+++ b/Workbench/Taller/Funciones.py
@@ -11,7 +11,12 @@
# Ejemplo 1
def misuma (a,b): # Esta es una función, toma dos enteros a,b y los suma
- return a+b # El calculo viene después de la palabra return
+ """
+ Los valores deben ser números
+ """
+ suma =a+b
+ return suma # El calculo viene después de la palabra return
+print (misuma(5,6))
res= misuma (2,3) # Uso la función, le paso los parámetros 2,3 y, el resultado lo almaceno en la variable res
print ("Resultado de sumar 2 y 3, es ", res) # Puedo ver su contenido con un print
diff --git a/Workbench/Taller/Prueba240123.py b/Workbench/Taller/Prueba240123.py
new file mode 100644
index 000000000..e69de29bb
From 00e22c49bcc2c31b8d3031dc2c3290d835aaaf6d Mon Sep 17 00:00:00 2001
From: Jorge Cordova <55065873+jcordovaj@users.noreply.github.com>
Date: Thu, 26 Jan 2023 16:47:23 -0300
Subject: [PATCH 10/16] 26011646 Up
---
.../Preliminares - 01-checkpoint.ipynb" | 29 +-
.../Preliminares - 01.ipynb" | 9 +-
Workbench/Substrings.py | 72 ++-
Workbench/Taller/Clases.py | 177 +++++-
Workbench/Taller/HW08_POO_Sol.py | 352 +++++++++++
Workbench/Taller/Herramientas.py | 0
Workbench/Taller/LibroAlumnos.py | 76 +++
Workbench/Taller/Mix_ejercicios.py | 302 ++++-----
Workbench/Taller/Problemasumas.py | 36 ++
Workbench/Taller/TodasLasOperaciones.py | 27 +
Workbench/Taller/listas.py | 367 ++++++++---
Workbench/Taller/pruebaerror.ipynb | 586 ++++++++++++++++++
12 files changed, 1745 insertions(+), 288 deletions(-)
create mode 100644 Workbench/Taller/HW08_POO_Sol.py
create mode 100644 Workbench/Taller/Herramientas.py
create mode 100644 Workbench/Taller/LibroAlumnos.py
create mode 100644 Workbench/Taller/Problemasumas.py
create mode 100644 Workbench/Taller/TodasLasOperaciones.py
create mode 100644 Workbench/Taller/pruebaerror.ipynb
diff --git "a/01 - Introducci\303\263n a la Programaci\303\263n/.ipynb_checkpoints/Preliminares - 01-checkpoint.ipynb" "b/01 - Introducci\303\263n a la Programaci\303\263n/.ipynb_checkpoints/Preliminares - 01-checkpoint.ipynb"
index a62bcd0ee..b91bde2df 100644
--- "a/01 - Introducci\303\263n a la Programaci\303\263n/.ipynb_checkpoints/Preliminares - 01-checkpoint.ipynb"
+++ "b/01 - Introducci\303\263n a la Programaci\303\263n/.ipynb_checkpoints/Preliminares - 01-checkpoint.ipynb"
@@ -564,7 +564,7 @@
}
],
"source": [
- " mi_tupla.count('Rojo')"
+ "mi_tupla.count('Rojo')"
]
},
{
@@ -1308,23 +1308,11 @@
},
{
"cell_type": "code",
- "execution_count": 14,
+ "execution_count": 1,
"metadata": {},
- "outputs": [
- {
- "ename": "NameError",
- "evalue": "name 'divisor' 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~\\AppData\\Local\\Temp/ipykernel_10044/1862935505.py\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[0mdivisor\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 'divisor' is not defined"
- ]
- }
- ],
+ "outputs": [],
"source": [
- "print(divisor)"
+ "# print(divisor)"
]
},
{
@@ -2322,7 +2310,7 @@
],
"metadata": {
"kernelspec": {
- "display_name": "Python 3 (ipykernel)",
+ "display_name": "Python 3",
"language": "python",
"name": "python3"
},
@@ -2336,7 +2324,12 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.9.7"
+ "version": "3.10.6"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "d3777ed8f5fe800f0d3d1926318eb186c93d9a88e13881725c87e5bdd2f1dd1d"
+ }
}
},
"nbformat": 4,
diff --git "a/01 - Introducci\303\263n a la Programaci\303\263n/Preliminares - 01.ipynb" "b/01 - Introducci\303\263n a la Programaci\303\263n/Preliminares - 01.ipynb"
index a0181f9c0..325046170 100644
--- "a/01 - Introducci\303\263n a la Programaci\303\263n/Preliminares - 01.ipynb"
+++ "b/01 - Introducci\303\263n a la Programaci\303\263n/Preliminares - 01.ipynb"
@@ -2342,7 +2342,7 @@
],
"metadata": {
"kernelspec": {
- "display_name": "Python 3 (ipykernel)",
+ "display_name": "Python 3",
"language": "python",
"name": "python3"
},
@@ -2356,7 +2356,12 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.9.7"
+ "version": "3.10.6 (tags/v3.10.6:9c7b4bd, Aug 1 2022, 21:53:49) [MSC v.1932 64 bit (AMD64)]"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "d3777ed8f5fe800f0d3d1926318eb186c93d9a88e13881725c87e5bdd2f1dd1d"
+ }
}
},
"nbformat": 4,
diff --git a/Workbench/Substrings.py b/Workbench/Substrings.py
index 40ea5c555..0c47a6cad 100644
--- a/Workbench/Substrings.py
+++ b/Workbench/Substrings.py
@@ -4,21 +4,67 @@
varany = int
pos_ini = int
pos_fin = int
-obj_iter.sub[varany, pos_ini, pos_fin])
-#es similar a find() pero en caso de que no se encuentre la subcadena sub lanza la excepción ValueError.
-cadena = 'me gusta la mermelada'
-cadena.index('lo')
-#La cadena 'lo' no existe, por lo que provocará un error
+# obj_iter.sub[varany, pos_ini, pos_fin])
+# es similar a find() pero en caso de que no se encuentre la subcadena sub lanza la excepción ValueError.
+# TypeError : Ocurre cuando se aplica una operación o función a un dato del tipo inapropiado.
+# ZeroDivisionError : Ocurre cuando se itenta dividir por cero.
+# OverflowError : Ocurre cuando un cálculo excede el límite para un tipo de dato numérico.
+# IndexError : Ocurre cuando se intenta acceder a una secuencia con un índice que no existe.
+# KeyError : Ocurre cuando se intenta acceder a un diccionario con una clave que no existe.
+# FileNotFoundError : Ocurre cuando se intenta acceder a un fichero que no existe en la ruta indicada.
+# ImportError : Ocurre c
+# Manejo de excepciones con TRY y EXCEPT
+# try:
+ # Codigo a ejecutar
+ # Pero podria haber errores en este bloque
+#
+# except :
+ # Haz esto para manejar la excepcion
+ # El bloque except se ejecutara si el bloque try lanza un error
+#
+# else:
+ # Esto se ejecutara si el bloque try se ejecuta sin errores
+#
+# finally:
+ # Este bloque se ejecutara siempre
+print ("")
+frase = 'me gusta la mermelada'
+busca = "lo"
+try:
+ cadena = frase
+ print (cadena.index(busca))
+ # La cadena 'lo' no existe, por lo que provocará un error
+except ValueError:
+ print ("En el texto ", "'",cadena,"'", "no existe la cadena", busca)
+
+# Otro ejemplo, creamos una función "dividir" que divide dos números
+num = 10
+div = 0
+def dividir(num,div):
+ try:
+ res = dividir(num, div)
+ print(res)
+ except ZeroDivisionError:
+ print("Trataste de dividir entre cero :( ")
+ return num/div
+#Sin embargo no controla la división por 0, que no esta definida y devolverá un error
+#Aquí usamos el control de errores con try y except
+
# Traceback (most recent call last):
-# File "", line 1, in
+# File "", line 1, in
# ValueError: substring not found
-cadena.index('la')
-9
-# Encontrar la última posición de una subcadena con RFIND
+# Ejemplo
+# Buscar la posición de una cadena, en el ejemplo "la"
+# Debe retornar la pos anterior a dónde incia la cadena, en este caso 9
+print ("La posición anterior a iniciar la primera cadena 'la' que encuentra, es la pos ", cadena.index('la'))
+print ("")
+
+# Ejemplo
+# Encontrar la última posición de una subcadena con RFIND, la busca todas y devuelve la ÚLTIMA
cadena = 'me gusta la mermelada'
-cadena.rfind('la')
-print (cadena.rfind('la'))
+cadena.rfind('la') # ocupan las pos 18 y 19
+print ("La última posición anterior, a iniciar la cadena 'la', es la pos ", cadena.rfind('la'))
# 17
print (cadena.rfind('lo'))
# -1
@@ -27,3 +73,7 @@
# 17
# print (cadena.rindex('lo'))
# Debe arrojar un error porque no existe la cadena (ValueError: substring not found)
+import re
+texto = "tres tristes tigres comen trigo en un trigal"
+busqueda = re.sub(" ", "-", texto)
+print(busqueda)
\ No newline at end of file
diff --git a/Workbench/Taller/Clases.py b/Workbench/Taller/Clases.py
index f37c01c35..d071497fb 100644
--- a/Workbench/Taller/Clases.py
+++ b/Workbench/Taller/Clases.py
@@ -1,3 +1,40 @@
+#*******************************************************************
+#* *
+#* TALLLER CLASES y OBJETOS *
+#* *
+#*******************************************************************
+# En Python todo son clases, porque es un lenguaje flexible
+# Una clase es la abstracción de un objeto, un molde para crear entidades similares.
+# Una clase consta de ATRIBUTOS y MÉTODOS
+# Con los atributos o CONSTRUCTOR se instancia (crea) el objeto, es una copia
+# Con los métodos se manipula, se hacen cálculos, se accede al objeto.
+# Un ATRIBUTO es una carcterística, cuantificable o no, que define al objeto, ej, su color, número de patas
+# Como ATRIBUTO, a un objeto le puedo definir cualquuier cosa ej diccionario, listas, tuplas
+# Agregamos los atributos que necesitemos y si es numérico se inicializan con algún valor, ej velocidad=0.
+# Los ATRIBUTOS o se deben acceder desde fuera de la clase(ej print(a1.color), a1 es un objeto animal,
+# con un atributo llamado color, en principio, la sentencia devolvería el color de a1, con el que fue
+# creado, pero la buena práctica dice que debemos crear un método para acceder a su color y luego podemos
+# imprimir lo que retorna el método.
+# Para proteger un ATRIBUTO, se le agregan dos lineas bajas o underscore al INICIO del atributo.
+# Luego creo los métodos o funciones asociados a él o los ATRIBUTOS, similar a los geters y seters.
+# Este es un ejemplo de ENCAPSULACIÓN
+# Un MÉTODO, básicamente, es una FUNCIóN, usada para ejecutar procedimientos u operaciones sobre la CLASE
+# con los ATRIBUTOS de la CLASE. Por ejemplo, un objeto auto, tiene un atributo velocidad, por lo que puede acelerar o frenar.
+# Qué es ABSTRACCIÓN => Separar los datos
+# Qué es ENCAPSULAMIENTO => Proteger el objeto (lo accedo o conozco a través de sus métodos)
+# Qué es HERENCIA => Permite crear nuevas clases heredando sus atributos,métodos y agregando nuevos,
+# ej. Animales=>Humano
+# Qué es POLIMORFISMO => Mismo nombre pero distinto comportamiento
+# Se usa la palabara reservada class, seguida de __INIT__, y detro de los paréntesis (), la primera palabra
+# DEBE ser self, seguido de sus atributos. A esto se denomina el método CONSTRUCTOR de la clase.
+# SELF es una palabra reservada que le dice a Python que lo que viene son atributos y no genere conflictos.
+# Para que la ayuda o help(), despliegue un mensaje de qué hace una CLASE o FUNCIÓN, se abren
+# tres comillas dobles, se agrega una breve descripción con los tipos de varibles o sintaxis, y se vuelve
+# a cerrar con tres comillas dobles.
+#
+
+# Ej 1) Crear una clase que cree objetos del tipo automóvil con los atributos color y aceleración
+
class Car1:
def __init__(self, color, aceleracion):
self.color = color
@@ -31,4 +68,142 @@ def __init__(self, nombre, raza):
print(c2.color)
# azul
print(c2.ruedas)
-# 4
\ No newline at end of file
+# 4
+
+# Ej 5 Crear una función que cree la clase Emprendedor
+# El constructor de la clase Emprenddedor recibe los valores
+# nombre (str), apellido (str), libros (array), mascotas (array de str)
+# Inicializar las propiedades de la clase Emprendedor con los valores recibidos
+class Emprendedor:
+ """
+ recibe los valores nombre (str), apellido (str), libros (array),
+ mascotas (array de str)
+ """
+ def __init__(self, nombre, apellido, libros, mascotas):
+ self.nombre = nombre
+ self. apellido = apellido #Este es el constructor de la clase
+ self.libros = libros
+ self. mascotas = mascotas
+
+# Estos los métodos de la clase Emprendedor
+ def getNombre (self):
+ pass
+ def getApellido (self):
+ pass
+ def getLibros (self):
+ pass
+ def getMascotas (self):
+ pass
+ def setNombre (self):
+ pass
+ def setApellido (self):
+ pass
+ def setLibros (self):
+ pass
+ def setMascotas (self):
+ pass
+
+# Ej 6 Creamos el objeto emp1 con el constructor Emprendedor
+emp1 = Emprendedor ("Lionel", "Cordova", ["Dos palmeras", 1917, 'abc123'], ('Perro', 'Gato'))
+print ("")
+print (type(emp1)) # Debe retornar
+print (type(emp1.nombre)) # Debe retornar
+print (type(emp1.apellido)) # Debe retornar
+print (type(emp1.libros)) # Debe retornar
+print (type(emp1.mascotas)) # Debe retornar
+print("")
+
+# Ej 8 ENCAPSULAMIENTO
+# Encapsular, consiste en hacer que los atributos o métodos internos a una clase no se puedan
+# acceder ni modificar desde fuera, sino que tan solo el propio objeto pueda acceder a ellos.
+# Python por defecto NO OCULTA los atributos y métodos de una clase al exterior.
+#
+class miSaludo:
+ atributo_clase = "Hola"
+ def __init__(self, atributo_instancia):
+ self.atributo_instancia = atributo_instancia
+# Mira lo que pasa
+prueba_mi_clase = miSaludo("Que tal") #Instancio el objeto con el parámetro 'Que tal'=atributo_instancia
+print (prueba_mi_clase.atributo_clase) # Le he pasado el valor de la variable
+print (prueba_mi_clase.atributo_instancia) # Le he pasado el parámetro de la instancición de la clase
+
+# 'Hola'
+# 'Que tal'
+
+# Primera reflexión: Ambos atributos son perfectamente accesibles desde el exterior!, va contra las buenas prácticas.
+# Hay métodos o atributos que queremos que pertenezcan sólo a la clase o al objeto, y que sólo puedan ser accedidos
+# por los mismos. Para ello podemos usar la doble __ (underscore) para ocultar un atributo o método.
+# Esto hará que Python los interprete como “privados”, y ya no podrán ser accedidos desde el exterior.
+# Eso es "ENCAPSULAMIENTO"
+# Volvamos a revisar el ejemplo
+class Clase:
+ atributo_clase = "Hola" # Es accesible desde el exterior
+ __atributo_clase = "Hola" # No es accesible desde el exterior de la clase
+ # Acá protegemos el método, ahora no es accesible desde el exterior
+ def __mi_metodo(self):
+ print("Este es un ejemplo de ENCAPSULAMIENTO")
+ self.__variable = 0 # La variable, también la hacemos privada
+
+ # Este método lo exponemos para acceder a la clase, debe ser accesible desde el exterior
+ def metodo_normal(self):
+ # El método si es accesible desde el interior
+ self.__mi_metodo()
+
+mi_clase = Clase()
+#mi_clase.__atributo_clase # Error! El atributo no es accesible
+#mi_clase.__mi_metodo() # Error! El método no es accesible
+mi_clase.atributo_clase # Ok!
+mi_clase.metodo_normal() # Ok!
+# Podemos hacer uso de 'dir' para ver el listado de métodos y atributos de nuestra clase que son PUBLICOS.
+# Al hacer 'privados' el '_atributo_clase' y '_mi_metodo', no los podremos encontrar en la lista.
+print(dir(mi_clase))
+#['_Clase__atributo_clase', '_Clase__mi_metodo', '_Clase__variable',
+#'__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
+#'__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__',
+#'__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
+#'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
+#'__str__', '__subclasshook__', '__weakref__', 'atributo_clase', 'metodo_normal']
+
+# Se puede acceder a los atribtos y métodos ocultos de una clase, como '__atributo_clase' y a '__mi_metodo',
+# haciendo un poco de trampa.
+# Python los guarda con un nombre distinto para ocultarlos (encapsularlos) y evitar su uso indebido.
+# Podemos llamarlos con un 'truco sucio' de la siguiente manera aunque, por buenas prácticas, no es recomendable.
+print("")
+a = mi_clase._Clase__atributo_clase
+print ("Escribiendo 'la ruta completa' del atributo oculto")
+print ("de esta forma: 'mi_clase._Clase__atributo_clase', retornará su contenido")
+print ("en este caso ", a)
+# 'Hola'
+print ("Caso 2, al escribir 'la ruta completa' del método así 'mi_clase._Clase__mi_metodo', retorna su contenido.")
+print ("en este caso ", mi_clase._Clase__mi_metodo())
+# Conclusión, hay una precedencia en las operaciones...la función primero que el
+# print, y se repite porque imprime la función y lo que retorna que es none.
+# Por esa razón, a veces parece que se imprime en otra parte.
+
+
+# Ej 7 POLIMORFISMO
+# Suponga que tiene una clase ANIMAL, que tiene un atributo HABLAR
+print("")
+class Animal: # Creamos la clase con 1 atributo hablar
+ def hablar(self):
+ pass
+# Por otro lado, creamos dos clases: Perro y Gato, que heredan de la anterior.
+# Además, implementan el método hablar() de formas distintas.
+# Entonces:
+print ("")
+class Perro(Animal): # Nótese que en este caso se le pasa como parámetro, la otra
+ def hablar(self): # clase entre paréntesis.
+ print("Guau!")
+
+class Gato(Animal):
+ def hablar(self):
+ print("Miau!")
+
+# Ahora creamos un objeto de cada clase y llamamos al método hablar().
+# Podemos observar que cada animal se comporta de manera distinta al usar hablar().
+
+for sonidos in Perro(), Gato():
+ sonidos.hablar()
+# Guau!
+# Miau!
+
diff --git a/Workbench/Taller/HW08_POO_Sol.py b/Workbench/Taller/HW08_POO_Sol.py
new file mode 100644
index 000000000..b411e5ab9
--- /dev/null
+++ b/Workbench/Taller/HW08_POO_Sol.py
@@ -0,0 +1,352 @@
+
+# 1) Crear la clase vehículo que contenga los atributos:
+# 'Color'
+# 'Tipo' (Si es moto, auto, camioneta ó camión)
+# 'Cilindrada' (en decimal, e.g. 1200cc = 1.2 cc de motor)
+
+class Vehiculo:
+ def __init__(self, color, tipo, cilindrada):
+ self.color = color
+ self.tipo = tipo
+ self.cilindrada = cilindrada
+
+# 2) A la clase Vehiculo creada en el punto 1, agregar los siguientes métodos:
+# Acelerar => El ejercicio no lo dice, pero necesito crear lo atributos que usaré
+# Frenar para mostrar que mi objeto vehículo acelera y frena.
+# Doblar Las acciones requieren de respectivo atributo, si doblo (acción),
+# necesito que se refiera a un atributo de la clase, en este caso
+# la 'dirección' o rumbo que lleva el móvil.
+
+class Vehiculo:
+ def __init__(self, color, tipo, cilindrada):
+ self.color = color
+ self.tipo = tipo
+ self.cilindrada = cilindrada
+ self.velocidad = 0 # Aquí creamos el atributo velocidad, no se requieren 2
+ self.direccion = 0 # Aquí creamos el atributo velocidad
+
+ def Acelerar(self, vel): # Recibe un parámetro velocidad
+ self.velocidad += vel # Este es método que modifica el atributo velocidad
+
+ def Frenar(self, vel): # Recibe un parámetro velocidad, es sólo un valor
+ self.velocidad -= vel # Calcula la nueva velocidad
+
+ def Doblar(self, grados): # Recibe la cantidad de grados del giro (0-360)
+ self.direccion += grados # Calcula la nueva dirección
+
+# 3) Instanciar 3 objetos de la clase vehículo y ejecutar sus métodos, probar luego el resultado
+
+a1 = Vehiculo ('rojo', 'auto', 2)
+a2 = Vehiculo ('blanco', 'camioneta', 3.6)
+a3 = Vehiculo ('negro', 'moto', 1)
+
+a1.Acelerar(40) # Si se hace un print se verá que el contenido de los atributos
+a2.Acelerar(60) # velocidad y dirección, han cambiado
+a3.Acelerar(30) # Para mostrar el contenido del atributo usar la sentencia
+a1.Doblar(30)
+a3.Doblar(-30)
+a2.Frenar(-50)
+
+# 4) Agregar a la clase Vehiculo, un método que muestre su estado, es decir, a que velocidad se encuentra y su dirección. Y otro método que muestre color, tipo y cilindrada
+
+class Vehiculo:
+ def __init__(self, color, tipo, cilindrada):
+ self.color = color
+ self.tipo = tipo
+ self.cilindrada = cilindrada
+ self.velocidad = 0
+ self.direccion = 0
+
+ def Acelerar(self, vel):
+ self.velocidad += vel
+
+ def Frenar(self, vel):
+ self.velocidad -= vel
+
+ def Doblar(self, grados):
+ self.direccion += grados
+
+ def Estado(self):
+ print('La velocidad actual es :', self.velocidad, '- y su rumbo actual es:', self.direccion, 'grados')
+
+ def Detalle(self):
+ print('Soy del tipo ', self.tipo, 'de color', self.color, 'y mi cilindrada es de', self.cilindrada, 'litros')
+
+a1 = Vehiculo('rojo', 'auto', 2)
+a1.Detalle()
+
+a1.Estado()
+a1.Acelerar(30)
+a1.Estado()
+
+
+# 5) Crear una clase que permita utilizar las funciones creadas en la práctica del módulo 6
+# Verificar Primo
+# Valor modal
+# Conversión grados
+# Factorial
+
+# In[33]:
+
+
+class Herramientas:
+ def __init__(self) -> None:
+ pass
+
+ def verifica_primo(self, nro):
+ es_primo = True
+ for i in range(2, nro):
+ if nro % i == 0:
+ es_primo = False
+ break
+ return es_primo
+
+ def valor_modal(self, lista, menor):
+ lista_unicos = []
+ lista_repeticiones = []
+ if len(lista) == 0:
+ return None
+ if (menor):
+ lista.sort()
+ else:
+ lista.sort(reverse=True)
+ for elemento in lista:
+ if elemento in lista_unicos:
+ i = lista_unicos.index(elemento)
+ lista_repeticiones[i] += 1
+ else:
+ lista_unicos.append(elemento)
+ lista_repeticiones.append(1)
+ moda = lista_unicos[0]
+ maximo = lista_repeticiones[0]
+ for i, elemento in enumerate(lista_unicos):
+ if lista_repeticiones[i] > maximo:
+ moda = lista_unicos[i]
+ maximo = lista_repeticiones[i]
+ return moda, maximo
+
+ def conversion_grados(self, valor, origen, destino):
+ valor_destino = None
+ if (origen == 'celsius'):
+ if (destino == 'celsius'):
+ valor_destino = valor
+ elif (destino == 'farenheit'):
+ valor_destino = (valor * 9 / 5) + 32
+ elif (destino == 'kelvin'):
+ valor_destino = valor + 273.15
+ else:
+ print('Parámetro de Destino incorrecto')
+ elif (origen == 'farenheit'):
+ if (destino == 'celsius'):
+ valor_destino = (valor - 32) * 5 / 9
+ elif (destino == 'farenheit'):
+ valor_destino = valor
+ elif (destino == 'kelvin'):
+ valor_destino = ((valor - 32) * 5 / 9) + 273.15
+ else:
+ print('Parámetro de Destino incorrecto')
+ elif (origen == 'kelvin'):
+ if (destino == 'celsius'):
+ valor_destino = valor - 273.15
+ elif (destino == 'farenheit'):
+ valor_destino = ((valor - 273.15) * 9 / 5) + 32
+ elif (destino == 'kelvin'):
+ valor_destino = valor
+ else:
+ print('Parámetro de Destino incorrecto')
+ else:
+ print('Parámetro de Origen incorrecto')
+ return valor_destino
+
+ def factorial(self, numero):
+ if(type(numero) != int):
+ return 'El numero debe ser un entero'
+ if(numero < 0):
+ return 'El numero debe ser pisitivo'
+ if (numero > 1):
+ numero = numero * self.factorial(numero - 1)
+ return numero
+
+
+# In[34]:
+
+
+h = Herramientas()
+
+
+# 6) Probar las funciones incorporadas en la clase del punto 5
+
+# In[28]:
+
+
+h.verifica_primo(7)
+
+
+# In[29]:
+
+
+listado = [1,8,2,5,4,8,10,7]
+moda, repe = h.valor_modal(listado, True)
+print('El valor modal es', moda, 'y se reptie', repe, 'veces')
+
+
+# In[31]:
+
+
+h.conversion_grados(10, 'celsius', 'kelvin')
+
+
+# In[35]:
+
+
+h.factorial(6)
+
+
+# 7) Es necesario que la clase creada en el punto 5 contenga una lista, sobre la cual se aplquen las funciones incorporadas
+
+# In[55]:
+
+
+class Herramientas:
+ def __init__(self, lista_numeros):
+ self.lista = lista_numeros
+
+ def verifica_primo(self):
+ for i in self.lista:
+ if (self.__verifica_primo(i)):
+ print('El elemento', i, 'SI es un numero primo')
+ else:
+ print('El elemento', i, 'NO es un numero primo')
+
+ def conversion_grados(self, origen, destino):
+ for i in self.lista:
+ print(i, 'grados', origen, 'son', self.__conversion_grados(i, origen, destino),'grados',destino)
+
+ def factorial(self):
+ for i in self.lista:
+ print('El factorial de ', i, 'es', self.__factorial(i))
+
+ def __verifica_primo(self, nro):
+ es_primo = True
+ for i in range(2, nro):
+ if nro % i == 0:
+ es_primo = False
+ break
+ return es_primo
+
+ def valor_modal(self, menor):
+ lista_unicos = []
+ lista_repeticiones = []
+ if len(self.lista) == 0:
+ return None
+ if (menor):
+ self.lista.sort()
+ else:
+ self.lista.sort(reverse=True)
+ for elemento in self.lista:
+ if elemento in lista_unicos:
+ i = lista_unicos.index(elemento)
+ lista_repeticiones[i] += 1
+ else:
+ lista_unicos.append(elemento)
+ lista_repeticiones.append(1)
+ moda = lista_unicos[0]
+ maximo = lista_repeticiones[0]
+ for i, elemento in enumerate(lista_unicos):
+ if lista_repeticiones[i] > maximo:
+ moda = lista_unicos[i]
+ maximo = lista_repeticiones[i]
+ return moda, maximo
+
+ def __conversion_grados(self, valor, origen, destino):
+ valor_destino = None
+ if (origen == 'celsius'):
+ if (destino == 'celsius'):
+ valor_destino = valor
+ elif (destino == 'farenheit'):
+ valor_destino = (valor * 9 / 5) + 32
+ elif (destino == 'kelvin'):
+ valor_destino = valor + 273.15
+ else:
+ print('Parámetro de Destino incorrecto')
+ elif (origen == 'farenheit'):
+ if (destino == 'celsius'):
+ valor_destino = (valor - 32) * 5 / 9
+ elif (destino == 'farenheit'):
+ valor_destino = valor
+ elif (destino == 'kelvin'):
+ valor_destino = ((valor - 32) * 5 / 9) + 273.15
+ else:
+ print('Parámetro de Destino incorrecto')
+ elif (origen == 'kelvin'):
+ if (destino == 'celsius'):
+ valor_destino = valor - 273.15
+ elif (destino == 'farenheit'):
+ valor_destino = ((valor - 273.15) * 9 / 5) + 32
+ elif (destino == 'kelvin'):
+ valor_destino = valor
+ else:
+ print('Parámetro de Destino incorrecto')
+ else:
+ print('Parámetro de Origen incorrecto')
+ return valor_destino
+
+ def __factorial(self, numero):
+ if(type(numero) != int):
+ return 'El numero debe ser un entero'
+ if(numero < 0):
+ return 'El numero debe ser pisitivo'
+ if (numero > 1):
+ numero = numero * self.__factorial(numero - 1)
+ return numero
+
+
+# In[56]:
+
+
+h = Herramientas([1,1,2,5,8,8,9,11,15,16,16,16,18,20])
+
+
+# In[57]:
+
+
+h.conversion_grados('celsius','farenheit')
+
+
+# In[58]:
+
+
+h.verifica_primo()
+
+
+# In[59]:
+
+
+moda, repe = h.valor_modal(False)
+print('El valor modal es', moda, 'y se reptie', repe, 'veces')
+
+
+# In[60]:
+
+
+h.factorial()
+
+
+# 8) Crear un archivo .py aparte y ubicar allí la clase generada en el punto anterior. Luego realizar la importación del módulo y probar alguna de sus funciones
+
+# In[1]:
+
+
+from herramientas import *
+
+
+# In[2]:
+
+
+h2 = Herramientas([1,1,2,3,5,6,8,8])
+
+
+# In[3]:
+
+
+h2.verifica_primo()
\ No newline at end of file
diff --git a/Workbench/Taller/Herramientas.py b/Workbench/Taller/Herramientas.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/Workbench/Taller/LibroAlumnos.py b/Workbench/Taller/LibroAlumnos.py
new file mode 100644
index 000000000..dc300f7d8
--- /dev/null
+++ b/Workbench/Taller/LibroAlumnos.py
@@ -0,0 +1,76 @@
+
+class Alumnos:
+
+ def __init__(self):
+ self.nombres=[]
+ self.notas=[]
+
+# El método menu muestra una serie de opciones y solicita al usuario que
+# elija una de ellas, según cual de ellas selecciona procede a llamar al método respectivo:
+ def menu(self):
+ opcion=0
+ while opcion!=4:
+ print("1- Cargar alumnos")
+ print("2- Listar alumnos")
+ print("3- Listado de alumnos con notas mayores o iguales a 7")
+ print("4- Finalizar programa")
+ opcion=int(input("Ingrese su opcion:"))
+ if opcion==1:
+ self.cargar()
+ elif opcion==2:
+ self.listar()
+ elif opcion==3:
+ self.notas_altas()
+# Algo que no utilizamos hasta ahora del lenguaje Python, es una forma
+# simplificada de if anidados con la sentencia elif:
+ if opcion==1:
+ self.cargar()
+ elif opcion==2:
+ self.listar()
+ elif opcion==3:
+ self.notas_altas()
+# Nosotros, hasta ahora, lo resolvíamos y podemos sin problema seguir utilizando
+# la sintaxis::
+ if opcion==1:
+ self.cargar()
+ else:
+ if opcion==2:
+ self.listar()
+ else:
+ if opcion==3:
+ self.notas_altas()
+# Pero podemos comprobar que, si hay muchos if anidados la nueva sintaxis es más
+# clara.
+# Un ciclo WHILE, repite el método menu, mientras no se ingrese como opción en la
+# variable local, el valor 4.
+
+# El método cargar, se llama desde el método menu, en el mismo procedemos a cargar
+# las dos listas paralelas, con los nombres de alumnos y sus notas:
+
+ def cargar(self):
+ for x in range(5):
+ nom=input("Ingrese nombre del alumno:")
+ self.nombres.append(nom)
+ no=int(input("Nota del alumno:"))
+ self.notas.append(no)
+
+# El método listar muestra las dos listas paralelas por completo e imprime una línea separadora para que se vea in forma más clara:
+
+ def listar(self):
+ print("Listado completo de alumnos")
+ for x in range(5):
+ print(self.nombres[x],self.notas[x])
+ print("_____________________")
+# Finalmente el método notas_altas muestra solo los elementos de las listas cuyas
+# notas sean igual o superior a 7:
+
+ def notas_altas(self):
+ print("Alumnos con notas superiores o iguales a 7")
+ for x in range(5):
+ if self.notas[x]>=7:
+ print(self.nombres[x],self.notas[x])
+ print("_____________________")
+# bloque principal
+
+alumnos=Alumnos()
+alumnos.menu()
diff --git a/Workbench/Taller/Mix_ejercicios.py b/Workbench/Taller/Mix_ejercicios.py
index c7df605fb..56a8fa9d0 100644
--- a/Workbench/Taller/Mix_ejercicios.py
+++ b/Workbench/Taller/Mix_ejercicios.py
@@ -1,221 +1,153 @@
-Variables
+# Variables
+
+# Ej 1) Cocatenar cadenas de caracteres, deben ser del mismo tipo (str+str)
+
a = 'Hola '
b = 'Mundo !'
+# Ej 2) Sumar dos enteros, puedo imprimir directo el resultado
+
print(a + b)
-# Hola Mundo !
+
+# Ej 3) Mismo ejemplo, almaceno en variable
x = 3
y = 12
-print(x + y)
-15
-print(a + x)
-"""
-"---------------------------------------------------------------------------"
+print(x + y) # 15
-TypeError Traceback (most recent call last)
-~\AppData\Local\Temp/ipykernel_18232/136165486.py in
-----> 1 print(a + x)
+# Ej 4) Manejo de errores por tipo, no sumar tipos distintos.
+# print(a + x)==> Da un error porque son de distinto tipo, concatencación
+# a= string Para que funcione, puedo cambiar el tipo a str(3)
+# x= int quedaría como 'Hola 3'
-TypeError: can only concatenate str (not "int") to str
-"""
-# Dividir "y" entre "x"
+# Ej 5) Dividir "y" entre "x"
y = 9
x = 3
-print(y/x)
-3.0
-# Potencia de "y" elevado a la "x"
+print(y/x) # => 3.0
+
+# Ej 6) Potencia de "y" elevado a la "x"
y = 2
x = 4
-print(y**x)
-16
-# Devolver el resto de la división
+print(y**x) # si elevo a 0.5, Python entiende que es raíz cuadrada igual que 1/2
+# R=> 16
+
+# Ej 7) Devolver el resto de la división
y = 13
x = 3
-print(y%x)
-1
-# Ciclo IF/ELIF/ELSE
-valor = 0
+print(y%x) # Sirve para todas las operaciones en que deba detectar pares, impares, primos
+
+# Ej 8) Ciclo IF/ELIF/ELSE
+valor = 0 # Inicializo un contador para entrar al ciclo
if (valor < 0):
print('El número es negativo')
elif (valor > 0):
print('El número es positivo')
else:
- print('El número es igual a cero')
-# El número es igual a cero
-
-# Ciclo FOR - Caso 1
-for n in range(1,10): #Incluye el primero y excluye el último
- print(n, end(", "))
-
-# Ciclo WHILE
-n = 1
-while (n < 10):
- print(n)
- n = n + 1
-"""
-1
-2
-3
-4
-5
-6
-7
-8
-9
-"""
-# Lista
-
-# Caso 1 - Inicializa una lista y muestra la cantidad de elementos
-
-edad = (3,1,0.2,8,7) #Declara un objeto lista y le asigna elementos
-print (len(edad)) #Imprime la cantidad de elementos de la lista usando la función LEN
-#5 # La función retorno 5
-
-# Caso 2 - Identificar el tipo de variable usando la función TYPE, retorno el tipo de dato
-mi_lista = ['Rojo','Azul','Amarillo','Naranja','Violeta','Verde']
-type(mi_lista)
-# list
-print(mi_lista)
-['Rojo', 'Azul', 'Amarillo', 'Negro', 'Naranja', 'Violeta', 'Verde']
-print(mi_lista[0:2])
-['Rojo', 'Azul']
-print(mi_lista[:2])
-['Rojo', 'Azul']
-print(mi_lista[1:])
-['Azul', 'Amarillo']
-mi_lista.insert(3,'Negro')
-print(mi_lista.index('Azul'))
-# 1
-mi_lista.insert(3,'Negro')
-mi_lista.extend(['Marrón','Gris'])
-print(['a','b','c'] * 3)
-# ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
-print(mi_lista.index('Azul'))
-# 1
-mi_lista.remove('Blanco')
-
-"""
----------------------------------------------------------------------------
-ValueError Traceback (most recent call last)
-~\AppData\Local\Temp/ipykernel_10044/2480624766.py in
-----> 1 mi_lista.remove('Blanco')
-
-ValueError: list.remove(x): x not in list
-mi_lista.remove('Negro')
----------------------------------------------------------------------------
-ValueError Traceback (most recent call last)
-~\AppData\Local\Temp/ipykernel_10044/298389232.py in
-----> 1 mi_lista.remove('Negro')
-
-ValueError: list.remove(x): x not in list
-"""
-ultimo = mi_lista.pop()
-ultimo = mi_lista.pop()
-print(ultimo)
-# Gris
-ultimo = mi_lista.pop()
-ultimo
-# 'Amarillo'
-mi_tupla=tuple(mi_lista)
-print(mi_tupla[1])
-# Azul
-'Rojo' in mi_tupla
-# True
-mi_tupla.count('Rojo')
-# 1
-print(mi_lista[:] * 3)
-# ['Rojo', 'Azul', 'Amarillo', 'Negro', 'Marrón', 'Gris', 'Rojo', 'Azul', 'Amarillo', 'Negro', 'Marrón', 'Gris', 'Rojo', 'Azul', 'Amarillo', 'Negro', 'Marrón', 'Gris']
-mi_tupla.count('Rojo')
-# 1
-mi_tupla='Gaspar', 5, 8, 1999
-nombre, dia, mes, año = mi_tupla
-print("Nombre: ", nombre, " - Dia:", dia, " - Mes: ", mes, " - Año: ", año)
-# Nombre: Gaspar - Dia: 5 - Mes: 8 - Año: 1999
-nombre = 'Darío'
-edad = 39
-print(nombre, edad)
-print("Mi nombre es", nombre, ". Mi edad es", edad, "años")
-print("Mi nombre es {}. Mi edad es {} años". format(nombre, edad))
-# Darío 39
-# Mi nombre es Darío . Mi edad es 39 años
-# Mi nombre es Darío. Mi edad es 39 años
-
-mi_diccionario = { 'Colores Primarios': ['Rojo','Azul','Amarillo'],
- 'Colores secundarios': ['Naranja','Violeta','Verde'],
- 'Clave3': 10,
+ print('El número es igual a cero') # R=> El número es igual a cero
+
+# Ej 9) Ciclo FOR - Simple (ver ciclos listas dobles)
+for n in range(1,11): #Incluye el primero y excluye el último
+ print(n,(')'))
+
+# Ej 10) Ciclo WHILE - Simple con un contador
+n = 1 # Contador definido en 0
+while (n < 10): # Mientras n sea menor que 10, haga lo que está dentro
+ print(n) # Imprimir el contenido de la variable en cada ciclo
+ n = n + 1 # El contador es la condición de termino. Al llegar a 11, no entra el nuevo ciclo.
+
+# Ej 11) Lista Simple - Inicializa una lista y obtener la cantidad de elementos con LEN
+
+edad = (3,1,0.2,8,7) # Declara un objeto lista y le asigna elementos, la lista es mutable, no ordenada
+print (len(edad)) # Imprime la cantidad de elementos de la lista usando la función LEN
+#5 # La función retornó 5
+
+# Ej 12) Lista - Retornar tipo de variable usando TYPE, isertar con INSERT, pegar dos listas con EXTEND,
+# eliminar un elemento con REMOVE, retornar un elemento usando su índice con INDEX[]y modificadores en la salida
+
+mi_lista = ['Rojo','Azul','Amarillo','Naranja','Violeta','Verde'] # Lista de 6 elementos
+type(mi_lista) # la lista, como objeto es de tipo list, pero sus objetos no, pueden ser de cualquier tipo.
+# R => list
+print(mi_lista) # Imprime los elementos de la lista, en el orden que están...se pueden ordenar
+# R=> ['Rojo', 'Azul', 'Amarillo', 'Negro', 'Naranja', 'Violeta', 'Verde']
+print(mi_lista[0:2]) # Imprimo la lista desde el índice 0, al 2, es decir el 0 y el 1, excluye el 2
+# R=> ['Rojo', 'Azul']
+print(mi_lista[:2]) # Imprime la lista desde el inicio, hasta el indice, desde el 0 al 1, excluye el 2
+# R=> ['Rojo', 'Azul']
+print(mi_lista[1:]) # Imprime la lista desde la posición 1, hasta el final, excluye la posición 0.
+# R=> ['Azul', 'Amarillo', 'Naranja', 'Violeta', 'Verde']
+mi_lista.insert(3,'Negro') # INSERT, inserta un elemento en la posición del índice dado.
+print(mi_lista.index('Azul')) #Retorna el valor (int) del índice cuando halla la coincidencia, este caso=1.
+print(mi_lista [1]) # => Azul, retorna el valor del elemento en el indice, en este caso [1]= Azul
+mi_lista.insert(3,'Negro') # Inserta el elemento 'Negro', en la posición 3.
+mi_lista.extend(['Marrón','Gris']) # EXTEND, 'pega' la lista ('Marrón','Gris'), al final de mi_lista
+print(['a','b','c'] * 3 ) # Igual que la concatenación, puedo 'multiplizar str =>['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
+mi_lista.remove('Blanco') # Recorre la lista, si existe el elemento, lo borra 1 vez, si no, da ERROR (not in list).
+ultimo = mi_lista.pop() # Remueve el último elemento de la lista
+print(ultimo) # Conserva el último elemento eliminado con POP, si ejecuto otra vez, elimina el anterior.
+
+# Ej 13) Tuplas - Operaciones de cambio de tipo, recorrer la tupla, contar elementos, imprimir, asignar
+mi_tupla=tuple(mi_lista) # La lista fue 'casteada?, se le ambio el tipo a TUPLE (lista INMUTABLE)
+print(mi_tupla[1]) # Se accede a sus elementos igual que la lista, NO SE PUEDE ORDENAR R=> Index 1 = Azul
+'Rojo' in mi_tupla # Puedo hacer evaluaciones BOOLEANAS (T/F), está el elemento en la tupla, retorna T/F =>T
+mi_tupla.count('Rojo') # Puedo contar los elementos que coinciden con un valor, retorna 1 entero
+print(mi_lista[:] * 3) # Concatena la lista veces, igual que los strings.
+# R=> ['Rojo', 'Azul', 'Amarillo', 'Negro', 'Marrón', 'Gris', 'Rojo', 'Azul', 'Amarillo', 'Negro', 'Marrón', 'Gris', 'Rojo', 'Azul', 'Amarillo', 'Negro', 'Marrón', 'Gris']
+mi_tupla='Gaspar', 5, 8, 1999 # Crea una tupla a partir asignarle elementos
+nombre, dia, mes, año = mi_tupla # Asigna los valores de la tupla a variables
+print("Nombre: ", nombre, " - Dia:", dia, " - Mes: ", mes, " - Año: ", año) # Imprime el contenido de las variables
+# R=> Nombre: Gaspar - Dia: 5 - Mes: 8 - Año: 1999
+
+# Ej 14) Formateo de impresión - 3 casos (sólo variables, con texto y con formato)
+nombre = 'Darío' # Inicializo var nombre con el str 'Darío'
+edad = 39 # Inicializo var edad con el int 39
+print(nombre, edad) # Caso 1) Imprimo el contenido de las variables. Puede ser cualquier variable.
+print("Mi nombre es", nombre, ". Mi edad es", edad, "años") # Caso 2) Impresión tradicional con variables.
+print("Mi nombre es {}. Mi edad es {} años". format(nombre, edad)) # Caso 3) Impresión con FORMATO
+# Caso 1) Darío 39
+# Caso 2) Mi nombre es Darío . Mi edad es 39 años
+# Casi 3) Mi nombre es Darío. Mi edad es 39 años
+
+# Ej 15) Diccionarios - Creación y operaciones (pares de elementos, {key:elemento})
+mi_diccionario = { 'Colores Primarios': ['Rojo','Azul','Amarillo'], # Crear con {key:Elm, key:Elm...}
+ 'Colores secundarios': ['Naranja','Violeta','Verde'], # Elm= Cualquier cosa, mutable
+ 'Clave3': 10, # Key= Hasheable, inmutable
'Clave4': False}
-print(mi_diccionario['Colores secundarios'])
-# ['Naranja', 'Violeta', 'Verde']
+print (mi_diccionario['Colores secundarios']) # Lo puedo acceder por sus claves o índices y retorna los VALORES
+# R=> ['Naranja', 'Violeta', 'Verde'] # Para la clave dad, retorno los elementos respectivos
-mi_diccionario={'Clave1':'Valor1', 'Clave2':{'numeros':[1,2,3,4,5]}}
-print(mi_diccionario.keys())
-# dict_keys(['Clave1', 'Clave2'])
-print(mi_diccionario.values())
-# dict_values(['Valor1', {'numeros': [1, 2, 3, 4, 5]}])
-len (mi_diccionario)
-# 2
+mi_diccionario = {'Clave1':'Valor1', 'Clave2':{'numeros':[1,2,3,4,5]}} # Dic key1=str y val1=str, key2=str, val2=lista
+print (mi_diccionario.keys()) # Retorna R=> dict_keys(['Clave1', 'Clave2'])
+print(mi_diccionario.values()) # Retorna R=> dict_values(['Valor1', {'numeros': [1, 2, 3, 4, 5]}])
+len (mi_diccionario) # R=> 2, la función LEN es útil cuando se debe recorrer el DICT
+
+# Ej 16) Ciclo IF/ELIF/ELSE
edad = 60
edad_compa = 50
-if (edad < edad_compa):
+if (edad < edad_compa): # Compara dos números, y establece dos condiciones
print(edad)
if (edad < 100):
print(edad + 100)
else:
- print(edad - 100)
+ print(edad - 100)
else:
- print(edad_compa)
-# 50
+ print(edad_compa) # No cumple ninguna e imprime el contenido de la var edd_compa R=> 50
-primeros_10 = [0,1,2,3,4,5,6,7,8,9]
-print(primeros_10)
-# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+# Ej 17) Recorre una lista con un ciclo FOR y extrae los PARES
-for n in primeros_10:
- if (n%2 == 0):
- print(n)
- primeros_10[n]=0
-print("\va de nuevo....\n")
-"""
-0
-2
-4
-6
-8
-# va de nuevo....
-"""
+primeros_10 = [0,1,2,3,4,5,6,7,8,9]
+print(primeros_10) # R=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+outlist = [] # Esta lista acumula los valores encontrados
+for n in primeros_10: # For 'var' in 'lista/tupla/dict'
+ if (n%2 == 0): # Uso la función resto para reconocer los PARES
+ outlist.append(n) # Los guardo en una lista para poder mostrarlos horizontalmente
+print ('Los pares son', outlist) # R=> Los pares son [0, 2, 4, 6, 8]
-print(primeros_10)
-# [0, 1, 0, 3, 0, 5, 0, 7, 0, 9]
+# Ej 18) Recorrer una lista con su índice y ver error fuera de rango
-for n in primeros_10:
- print(primeros_10[n])
-print("\va de nuevo....\n")
-"""
-0
-1
-0
-3
-0
-5
-0
-7
-0
-9
-va de nuevo....
-"""
+print(primeros_10[9]) # R=> 9, el valor existe dentro del rango
+primeros_10 = ['a','b','c','d'] # Esta lista de str, tiene 4 elm, índices del 0 al 3.
+primeros_10[4] # Al intentar accesar a una posición que NO existe, retornará un error (out of range)
-print(primeros_10[9])
-# 9
-primeros_10 = ['a','b','c','d']
-primeros_10[4]
-"""
----------------------------------------------------------------------------
-IndexError Traceback (most recent call last)
- in
-----> 1 primeros_10[4]
-
-IndexError: list index out of range
-"""
+# Ej 19) Uso de la función SEQUENCE - Recorre un rango
n = 40
sequence = [0,1]
for i in range(2,n):
diff --git a/Workbench/Taller/Problemasumas.py b/Workbench/Taller/Problemasumas.py
new file mode 100644
index 000000000..93d84b855
--- /dev/null
+++ b/Workbench/Taller/Problemasumas.py
@@ -0,0 +1,36 @@
+# Crear una clase Operación que solicite en el método __init__
+# la carga de dos enteros e inmediatamente muestre
+# su suma, resta, multiplicación y división.
+# Hacer cada operación en otro método de la clase Operación y llamarlos
+# desde el mismo método __init__
+
+class Operacion:
+
+ def __init__(self):
+ self.valor1=int(input("Ingrese primer valor:"))
+ self.valor2=int(input("Ingrese segundo valor:"))
+ self.sumar()
+ self.restar()
+ self.multiplicar()
+ self.dividir()
+
+ def sumar(self):
+ suma=self.valor1+self.valor2
+ print("La suma es",suma)
+
+ def restar(self):
+ resta=self.valor1-self.valor2
+ print("La resta es",resta)
+
+ def multiplicar(self):
+ multi=self.valor1*self.valor2
+ print("El producto es",multi)
+
+ def dividir(self):
+ divi=self.valor1/self.valor2
+ print("La division es",divi)
+
+
+# bloque principal
+
+operacion1=Operacion()
\ No newline at end of file
diff --git a/Workbench/Taller/TodasLasOperaciones.py b/Workbench/Taller/TodasLasOperaciones.py
new file mode 100644
index 000000000..1b7ae6522
--- /dev/null
+++ b/Workbench/Taller/TodasLasOperaciones.py
@@ -0,0 +1,27 @@
+class Operacion:
+
+ def __init__(self):
+ self.valor1=int(input("Ingrese primer valor:"))
+ self.valor2=int(input("Ingrese segundo valor:"))
+ self.sumar()
+ self.restar()
+ self.multiplicar()
+ self.dividir()
+
+ def sumar(self):
+ suma=self.valor1+self.valor2
+ print("La suma es",suma)
+
+ def restar(self):
+ resta=self.valor1-self.valor2
+ print("La resta es",resta)
+
+ def multiplicar(self):
+ multi=self.valor1*self.valor2
+ print("El producto es",multi)
+
+ def dividir(self):
+ divi=self.valor1/self.valor2
+ print("La division es",divi)
+
+operacion1=Operacion()
\ No newline at end of file
diff --git a/Workbench/Taller/listas.py b/Workbench/Taller/listas.py
index fc5b6cc56..964da9bd3 100644
--- a/Workbench/Taller/listas.py
+++ b/Workbench/Taller/listas.py
@@ -1,51 +1,51 @@
#*******************************************************************
#* *
-#* TEORIA LISTAS *
-#* *
+#* TEORIA LISTAS - TUPLAS - DICCIONARIOS - ETC *
+#* C O L E C C I O N E S Y MUCHO MAAASSSS *
#*******************************************************************
# Una LIST, es un objeto, es una colección de cosas, pueden ser tareas,
-# vegetales, nombres
-# mercaderías, cualquier cosa.
+# vegetales, nombres, mercaderías, cualquier cosa.
-# Dos formas paa declararlas e iniciaizarlas
+# Dos formas para declararlas o iniciaizarlas, aunque hay otras.
# 1) Defino una variable y le asigno un tipo lista VACÍO con paréntesis
-empty_list1 = list() # Note que se debe indicar el tipo lista o lo considerará una TUPLA
-print (empty_list1, "esta es la lista 1 con '()'")
+empty_list1 = list() # Note que se debe indicar el tipo lista o lo
+print (empty_list1, "esta es la lista 1 con '()'") # considerará una TUPLA
print (type(empty_list1))
# 2) Defino una variable y sé que es del tipo lista por los corchetes '[]'
-empty_list2 = [] # A la variable se le asigna una lista vacía con CORCHETES
-print (empty_list2, "esta es la lista 2")
+empty_list2 = [] # A la variable se le asigna una lista vacía con
+print (empty_list2, "esta es la lista 2") # CORCHETES
print (type (empty_list2))
# Ejemplo 1
numbers = [1,2,3,4,5,6] # Lista de números
-print("'numbers' es del tipo ", type(numbers)) # De devolver el texto+ type 'list'
+print("'numbers' es del tipo ", type(numbers)) # Imprime un texto + su 'type'
# Ejemplo 2
-groceries = ["tomato", "carrot", "letuce"] # Una lista con 3 strings de 'vegentales'
-print (groceries [0]) # El puntero va con corchetes y parte de 0, imprime "tomato"
-print (numbers [3]) # Es una COLECCION, imprime todos los elementos
-print (len(groceries)) # Conocer el largo de la la lista con len, devuelve 3
+groceries = ["tomato", "carrot", "letuce"] # Una lista con 3 str de 'vegetales'
+print (groceries [0]) # El índice va con [] y parte en 0, imprime "tomato"
+print (numbers [3]) # Es 'la' COLECCION, imprime todos sus elementos
+print (len(groceries)) # LEN devuelve el largo de la lista con len, retorna 3
# Ejemplo 3
-lastname = "cordova" # Variable de tipo string, contiene "cordova"
-mix_of_data_types_list = [1, "Jota", lastname, 2+5, 1-3j, 3.14] # Lista con distintos tipos de var
-print ("'mix_of_data_types_list' es del tipo-", type(mix_of_data_types_list)) #devuelve 'list'
-#podemos almacenar un mix de datos
+lastname = "Cordova" # Variable de tipo string, contiene "Cordova"
+mix_of_data_types_list = [1, "Jota", lastname, 2+5, 1-3j, 3.14] # Lista con distintos tipos de var
+print ("'mix_of_data_types_list' es del tipo-", type(mix_of_data_types_list)) # devuelve un 'list'
+
+# Podemos almacenar cualquier 'mix' de datos u objetos, en Python TODO es un objeto
# Ejemplo 4
-listadeletras = [] # Crea un objeto list llamado listadeletras
-for unaletra in "paralelepipedo": # Define una variable 'unaletra' y recorre el string "paralelepípedo"
+listadeletras = [] # Crea un objeto list llamado listadeletras vacío
+for unaletra in "paralelepipedo": # Define una var 'unaletra' y recorre el string "paralelepípedo"
listadeletras.append(unaletra)# Agrega cada caracter del string a 'listadeletras' usando el método 'append'
print (listadeletras) # Imprime los valores de la lista que son los caracteres de la palabra 'paralelepípedo'', lo que sea
- # Salida esperada ['p', 'a', 'r', 'a', 'l', 'e', 'l', 'e', 'p', 'i', 'p', 'e', 'd', 'o']
+ # Salida esperada ['p', 'a', 'r', 'a', 'l', 'e', 'l', 'e', 'p', 'í', 'p', 'e', 'd', 'o']
# Ejemplo 5
-# Crear una lista de 4 elementos y, para cada elemento, calcularle la potencia de 2, usando
-# el método tradicional, eso seria así:
+# Crear una lista de 4 elementos y, para cada elemento, calcularle su potencia de 2, usando
+# el método tradicional, eso seria así, luego veremos con expresiones o por comprensión:
# Alternativa 1
lista_potencias = [] # Crea una lista llamada "lista_potencias"
for i in range(4): # Ciclo for para recorrer lista de 4 elementos, va de 0 a 3, el índice lo llamamos "i"
@@ -53,24 +53,24 @@
print(lista_potencias) # Imprime los 4 valores almacendaos en la lista [0, 1, 4, 9]
# Ejemplo 6
-# Entonces el ejemplo anterior usando listas de comprensión, eso seria así:
-lista_potencias2 = [i**2 for i in range(4)] # Usa un for
+# El ejemplo 5, usando listas por comprensión (es decir, fórmulas o expresiones), seria así:
+lista_potencias2 = [i**2 for i in range(4)] # Usa un FOR
print ("Esta es la lista de potencias Nr2", lista_potencias2) # Imprime [0, 1, 4, 9]
# Ejemplo 7
# Lista con las potencias de 2 de los primeros 10 números, método tradicional:
# Alternativa 1
lista1_pot10_2 = [] # Creamos un objeto lista vacio []
-for num in range (0, 11): # Incluye el primero y no el últimmo. Usando un ciclo FOR usando la var "num" en el tramo de 0-10, ambos incluidos
+for num in range (0, 11): # Incluye el 1ro, pero no el últimmo. Recorremos el rangoUsando un ciclo FOR usando la var "num" en el tramo de 0-10, ambos incluidos
lista1_pot10_2.append (num**2) # Llenamos la lista con potencias PARTIENDO DE 0, a 10 (11-1)
print(lista1_pot10_2) # Salida por pantalla [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# Alternativa 2
-#Entonces el ejemplo anterior usando listas de comprensión, eso seria así:
-#lista2_pot10_2 = [num2**2 for num2 in range(0, 11)] #Creamos la lista con los valores según condición
-#print("Este es el método 3-2, para crear la lista de 10 números y sus potencias",lista2_pot10_2)
-#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
-#De este código anterior usted puede aprender que es posible modificar al vuelo los elementos los cuales van a formar la lista.
+# Usando listas por comprensión, seria así:
+lista2_pot10_2 = [num2**2 for num2 in range(0, 11)] #Creamos la lista con los valores según condición
+print("Aquí usamos una expresión para crear la lista de 10 nros. y sus potencias",lista2_pot10_2)
+# R=> Aquí usamos una expresión para crear la lista de 10 nros. y sus potencias [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
+# Con este método, es más simple modificar los elementos que van a la lista.
# Ejemplo 8
# Este ejemplo muestra como operan las posiciones en una lista (cada elemento es una posX)
@@ -85,7 +85,7 @@
print("7° Mostrar 'lista[::-1]', significa mostrar todos los elementos de la lista en orden inverso\n",lista[::-1]) # tomamos desde el final hasta el principip (orden inverso)
# Ejemplo 9
-# Con este ejemplo usamos un truco para controlar la salida, un método de print llamado end
+# Usamos un truco para controlar la salida, un método de print llamado end
#
for i in range (15):
if i < 14:
@@ -94,80 +94,305 @@
print (i)
# Ejemplo 10
-# Mismo ejemplo sin controlar la salida, cada linea se ejecuta y se apilan.
+# Mismo ejemplo sin controlar la salida, cada linea se ejecuta y se apila.
for i in range (15):
- print (i)
+ print (i) # No agregué el print por espacio ...se ve muy feo
# Ejemplo 11
-# Revisar otra formas de ordenar listas
+# Revisar otra formas de ordenar listas (pero en este archivo van muchas)
lista_desordenada = [5,7,2,8,3,6]
-lista_desordenada.sort()
+lista_desordenada.sort() # Usamos el método SORT
print ("Resultado esperado 2,3,5,6,7,8, lista generada :", lista_desordenada)
-print (type(lista_desordenada))
+print (type(lista_desordenada)) # Verifico, como medida extra, el tipo de dato generado
# Ejemplo 12
# Lista negada = los inversos y lista doble = multiplicadas por algo
+# Hay que acostumbrarse a usar 'trucos' para resolver la lógica de los problemas
lista = [10, 20, 30]
-lista_negada = [ -e for e in lista ] # Los inversos de los elementos
-lista_doble = [ e*2 for e in lista] # Los elementos multiplicados por 2
-print(lista_negada)
-print(lista_doble)
+lista_negada = [ -e for e in lista ] # Es por comprensión. Genera los inversos de los elementos
+lista_doble = [ e*2 for e in lista] # Esta genera los elementos multiplicados por 2
+print(lista_negada) # Todos negativos
+print(lista_doble) # Todos x 2
# Ejemplo 13
-# Una lista de valores float, no se pueden negar strings
-lista2 = [True, True, False, 5, 2-3j]
-lista_negada2 = [ -e for e in lista2] # Los inversos de los elementos numéricos
-lista_doble2 = [ e*2 for e in lista2] # Los elementos multiplicados por 2
+# Ojo!! No se pueden negar valores float o strings.
+lista2 = [True, True, False, 5, 2-3j] # Ojo con los BOOLEANOS
+lista_negada2 = [ -e for e in lista2] # Los inversos de los elementos numéricos
+lista_doble2 = [ e*2 for e in lista2] # Los elementos multiplicados por 2
print(lista_negada2) # Nótese la salida [-1, -1, 0, -5, (-2+3j)], los booleanos los tomo como 1 y 0
print(lista_doble2) # Nótese la salida [2, 2, 0, 10, (4-6j)], fijarse en los booleanos
# Ejemplo 14
-# Con un ciclo for, alimenta dos listas dependiendo de una condición y muestra la información horizontal.
+# Usando 1 ciclo FOR, poblar 2 listas dependiendo de una condición y mostrar la información horizontal.
lista_i = []
lista_p = []
-for i in range (1,21):
+for i in range (1,11):
n=(i%2)
if n==1:
lista_i.append (i)
elif n==0:
lista_p.append (i)
-print ("Los números impares entre 1 y 20 son ", lista_i)
-print ("Los números pares entre 1 y 20 son ", lista_p)
+print ("Los números impares entre 1 y 10 son ", lista_i)
+print ("Los números pares entre 1 y 10 son ", lista_p)
# Ejemplo 15
# Usos de 'enumerate' en listas, tuplas, diccionarios, cadenas
-for i, val in enumerate(['A', 'B', 'C']):
+for i, val in enumerate(['A', 'B', 'C']): # ENUMERATE recorre la lista y su ÍNDICE
print(i, val)
-"""
-0 A
-1 B
-2 C
-"""
-
-# En este caso imprime la posición o puntero, y el contenido de la posición, vertical
+# 0 A
+# 1 B
+# 2 C
+# En este caso imprime la posición, índice, o puntero, y el contenido de la posición, verticamente
+# Cómo o haría para mostrarlo horizontalmente?
+#
# Ejemplo 16
for i, val in enumerate(['A', 'B', 'C'], start=5): # Mismo anterior, pero cambia el valor del puntero que parte en 5
print(i, val)
-"""
-5 A
-6 B
-7 C
-"""
-# La salida va de 5 a 7
+# 5 A
+# 6 B
+# 7 C La salida va de 5 a 7
+
# Ejemplo 17
-# En este caso va de 5 a 14, se salta 3, y el puntero inicia en 1
+# En este caso va de 5 a 14, se salta de a 3, y el puntero inicia en 1
for i, val in enumerate(range(5, 15, 3), start=1):
print(f'Pos: {i} -> {val}')
-"""
-Pos: 1 -> 5
-Pos: 2 -> 8
-Pos: 3 -> 11
-Pos: 4 -> 14
-"""
# La salida va con los textos 'Pos: ' y '->'
+# Pos: 1 -> 5
+# Pos: 2 -> 8
+# Pos: 3 -> 11
+# Pos: 4 -> 14
print ("")
-# Ejemplo
\ No newline at end of file
+# Ejemplo 18
+# Iterar 2 listas usando un FOR y ZIP
+a = [1, 2]
+b = ["Uno", "Dos"]
+c = zip(a, b)
+for numero, texto in zip(a, b):
+ print("Número", numero, "Letra", texto)
+ print(type(numero), type(texto))
+# Número 1 Letra Uno
+#
+# Número 2 Letra Dos
+#
+
+# Ejemplo 19) zip() con n argumentos - Ejemplo con varias listas
+# Como ZIP está definida como, zip(*iterables) o cualquier iterable,
+# es posible pasar un número arbitrario de iterables como entrada.
+# Es importante notar, que todas tienen la misma longitud, dos.
+# Es necesario experimentar para tener una 'idea' cuando toque
+
+numeros = [1, 2]
+espanol = ["Uno", "Dos"]
+ingles = ["One", "Two"]
+frances = ["Un", "Deux"]
+c = zip(numeros, espanol, ingles, frances)
+for n, e, i, f in zip(numeros, espanol, ingles, frances):
+ print(n, e, i, f)
+# Note la forma en que organiza la salida de los datos en pares
+# 1 Uno One Un
+# 2 Dos Two Deux
+
+# Ejemplo 20 - Caso: Hacer zip() con listas de diferentes longitudes
+# Podemos usar zip con iterables de diferentes longitudes.
+# En este caso, el iterador se detiene, cuando la lista más pequeña se acaba.
+
+numeros = [1, 2, 3, 4, 5]
+espanol = ["Uno", "Dos"]
+for n, e in zip(numeros, espanol):
+ print(n, e)
+# Ojo!, sólo completa los dos primeros pares
+# 1 Uno
+# 2 Dos
+
+# Ejemplo 21 - Caso: zip() con un argumento
+# Por definición, se puede hacer, porque ZIP está definido para un 'n' arbitrario
+# de listas, ergo, también es posible usar un único valor.
+# El resultado son tuplas de un elemento...raras, pero se puede.
+
+numeros = [1, 2, 3, 4, 5]
+zz = zip(numeros) # ZIP de si mismo
+print (list(zz)) # R=> [(1,), (2,), (3,), (4,), (5,)]
+
+# Ejemplo 22 - Caso: zip() con diccionarios
+# Lo común es usar ZIP con listas, pero al estar definida para cualquier clase iterable.
+# Podemos usarla con DICCIONARIOS.
+
+# Por ejemplo, si (a,b) toman los valores de las key del diccionario, no parece muy interesante.
+
+esp = {'1': 'Uno', '2': 'Dos', '3': 'Tres'}
+eng = {'1': 'One', '2': 'Two', '3': 'Three'}
+
+for a, b in zip(esp, eng):
+ print(a, b)
+# 1 1
+# 2 2
+# 3 3
+
+# Sin embargo, si usamos la función items del tipo DICT, podemos acceder
+# al key y al value de cada elemento.
+# Se puede facilitar para modificar valores usando, e.g casteo de dict a list y viceversa
+esp = {'1': 'Uno', '2': 'Dos', '3': 'Tres'}
+eng = {'1': 'One', '2': 'Two', '3': 'Three'}
+
+for (k1, v1), (k2, v2) in zip(esp.items(), eng.items()):
+ print(k1, v1, v2)
+# Nótese que en este caso ambas key k1 y k2 son iguales.
+# 1 Uno One
+# 2 Dos Two
+# 3 Tres Three
+
+# Ejemplo 23 - Caso: Deshacer el zip()
+# Es posible deshacer un zip, en una sola línea de código.
+# Supongamos que hemos usado zip para obtener 'c'.
+
+a = [1, 2, 3]
+b = ["One", "Two", "Three"]
+c = zip(a, b)
+
+print (list(c)) # R=> [(1, 'One'), (2, 'Two'), (3, 'Three')]
+# ¿Es posible obtener a y b desde c? Sí, tan sencillo como:
+c = [(1, 'One'), (2, 'Two'), (3, 'Three')]
+a, b = zip(*c)
+print(a) # (1, 2, 3)
+print(b) # ('One', 'Two', 'Three')
+
+# Uso de STRIP Ejemplo 24 - STRIP eliminar espacios, cadenas de texto, incluso comparar
+# Este ejemplo es como un "A inter B"
+colores = ['yellow', 'wine', 'blue', 'green', 'red', 'brown', 'red']
+sec_colr = ['blue', 'green', 'red']
+
+strColores = str(colores).strip("[]")
+strSec_colr = str(sec_colr).strip("[]")
+
+if strSec_colr in strColores:
+ print("Si")
+else:
+ print("No")
+
+# Ejemplo 24 - Usar listas como PILAS
+# Los métodos de lista, facilitan usar una lista como una pila (stack), donde el
+# último elemento añadido es el primer elemento retirado (LIFO). Para agregar un
+# elemento a la cima de la pila, utilizamos APPEND(). Para retirar un elemento de la
+# cima de la pila, se utiliza POP() sin un índice explícito. Por ejemplo:
+
+mi_pila = [3, 4, 5]
+mi_pila.append(6)
+mi_pila.append(7)
+print (mi_pila) # R=> [3, 4, 5, 6, 7]
+mi_pila.pop() # R=> Elimina el 7, y lo guarda en memoria hasta que lo ocupe otro
+print (mi_pila) # Chequeamos si está el 7 y no está en la lista R=> [3, 4, 5, 6]
+mi_pila.pop() # El siguiente elemento eliminado será el 6. R=> 6
+mi_pila.pop() # Ahora elimina el 5, R=> 5
+print (mi_pila) # verificamos y vemos que se han borrado los elementos. R=> [3, 4]
+
+# Ejemplo 25 - Usar listas como COLAS
+# También es posible usar una lista como una cola, donde el primer elemento añadido
+# es el primer elemento retirado (FIFO); sin embargo, las listas no son eficientes
+# para este propósito. Agregar y sacar del final de la lista es rápido, pero
+# insertar o sacar del comienzo de una lista es lento (porque todos los otros
+# elementos tienen que ser desplazados en uno).
+# Para implementar una cola, utiliza 'COLLECTIONS.DEQUE', el cual fue diseñado para
+# añadir y quitar de ambas puntas de forma rápida. Por ejemplo:
+
+from collections import deque
+
+mi_Cola = deque(["Pedro", "Juan", "Diego"]) # Están Pedro, Juan y Diego en la cola
+mi_Cola.append("Luis") # Llega Luis
+print (mi_Cola) # R=> (['Pedro', 'Juan', 'Diego', 'Luis'])
+mi_Cola.append("Jorge") # Llega Jorge
+print (mi_Cola) # R=> (['Pedro', 'Juan', 'Diego', 'Luis', 'Jorge'])
+print(mi_Cola.popleft()) # El primero en llegar se va => Pedro
+print(mi_Cola) # R=> ('Juan', 'Diego', 'Luis', 'Jorge'])
+print(mi_Cola.popleft()) # Ahora se va el segundo en llegar R=> Juan
+print(mi_Cola) # R=> ('Diego', 'Luis', 'Jorge'])
+ # La lista restante en orden de llegada
+
+# Ejemplo 26 - Comprensión de listas . MUY IMPORTANTE ENTENDERLO BIEN !!
+# Permite usar expresiones y condiciones para poblar una lista.
+# Sus usos comunes son para hacer nuevas colecciones donde cada elemento es el resultado
+# de algunas operaciones aplicadas a cada miembro de otra secuencia o iterable, o
+# para crear un segmento de la secuencia de esos elementos para satisfacer una
+# condición determinada ==> Es muy parecido a EXRESIONES REGULARES (import re),
+# que son fundamentales en ciencia de datos.
+
+# Por ejemplo, queremos crear una lista de cuadrados, como:
+
+cuadrados1 = []
+for x in range(10):
+ cuadrados1.append(x**2) # Agrega los cuadrados en el rango 0-10, a lista cuadrados
+print (cuadrados1) # => [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
+
+# Nótese que esto crea (o sobreescribe) una variable llamada x que sigue existiendo
+# luego de que el bucle haya terminado. sin embargo, podemos aplicar listas por
+# COMPRENSIÓN, poblando la lista de cuadrados sin efecto secundario haciendo:
+
+cuadrados2 = list(map(lambda x: x**2, range(10))) # Usamos una función lambda y map
+cuadrados3 = [x**2 for x in range(10)] # otra expresión equivalente sería:
+ # lo cual es más conciso y legible.
+
+# Una lista por comprensión, consta de corchetes rodeando una expresión seguida de la
+# declaración FOR, y luego 0 o más declaraciones FOR o IF. El resultado será una
+# nueva lista que sale de evaluar la expresión, en el contexto de los FOR o IF que le
+# siguen. Por ejemplo, esta lista de comprensión combina los elementos de 2 listas
+# si no son iguales:
+
+# Ejemplo 27 Lista Distintos
+#
+[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y] # R=> [(1, 3), (1, 4), (2, 3),
+ # (2, 1), (2, 4), (3, 1), (3, 4)]
+
+# y es equivalente a:
+
+combinar_listaDistintos = []
+for x in [1,2,3]:
+ for y in [3,1,4]:
+ if x != y:
+ combinar_listaDistintos.append((x, y))
+print (combinar_listaDistintos) # R=> [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1),
+ # (3, 4)]
+# Nótese como el orden de los for e if es el mismo en ambos pedacitos de código.
+# Si la expresión es una tupla (como el (x, y) en el ejemplo anterior), debe estar entre paréntesis.
+
+# Ejemplo 28 - Operaciones con vectores
+vector1 = [-4, -2, 0, 2, 4] # Crear un nueva lista con los valores *2
+vector2 = [x*2 for x in vector1] # Llenamos la lista, usando una expresión que calcula x^2
+print ("La lista de los x^2, del Vector 1 es ", vector2) # Comprobamos el resultado imprimiento la lista, OK! R=> [-8, -4, 0, 4, 8]
+# Filtrar la lista para excluir los valores negativos
+vector3 = [x for x in vector2 if x >= 0] # Esta expresión, llena la lista, separando positivos de negativos.
+print (vector3) # Comprobamos el resultado imprimiento la lista, OK! R=> [0, 2, 4]
+# Creamos una nueva lista, aplicado una función de valor absoluto (abs) a todos los elementos del vector1
+vector4 = [abs(x) for x in vector1] # Llenamos vector 4 con el resultado
+print (vector4) # Comprobamos el resultado imprimiento la lista, OK! R=> [4, 2, 0, 2, 4]
+
+# Ejemplo 29 Limpiar datos usando STRIP
+# También usamos expresiones para tareas repetitivas.
+# En este ejemplo se usa la función STRIP para recortar los espacios en blanco
+
+fruta_fresca = [' banana', ' mora ', 'kiwi '] # Nótese que el 'raw data', viene con espacios a ambos lados del str
+[cortar_espacios.strip() for cortar_espacios in fruta_fresca] # Al aplicar la función STRIP, se recortan los espacios
+# La lista resultante queda R=> ['banana', 'mora', 'kiwi']
+
+# Ejemplo 30 - Crear una lista de 2 tuplas como (número, su_cuadrado)
+#
+lista_cuad = [(x, x**2) for x in range(6)] # Recordar, va de 0 a 5, excluye el lim_sup del intervalo
+print ('La lista de pares (x, x^2), es ', lista_cuad)
+# La lista de pares (x, x^2), es [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
+# La expresión a comparar (x, x**2), debe estar entre paréntesis, de lo contrario se genera un error
+
+# Ejemplo 31 - Aplanar una lista usando listas compuestas (listcomp) con dos 'FOR'
+
+vec = [[1,2,3], [4,5,6], [7,8,9]] # vec es un arreglo de listas y queremos ponerlas en una sola lista
+flat_vec= [num for elem in vec for num in elem] # Nótese que en este caso no uso paréntesis, no es comparación o formula
+print ("La lista 'aplanada' es ", flat_vec) # La lista esperada R=>[1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+# Ejemplo 32 - Listas anidades con expresiones complejas
+# Las listas por comprensión pueden contener expresiones complejas y funciones anidadas:
+
+from math import pi # Importamos una librería "MATH" que nos permite hacer cálculos científicos y usar constantes
+pi_evol= [str(round(pi, i)) for i in range(1, 6)] # Creamos una lista con incrementales de pi
+print ('Los valores incrementales de pi, son ', pi_evol)
+# R=> Los valores incrementales de pi, son ['3.1', '3.14', '3.142', '3.1416', '3.14159']
\ No newline at end of file
diff --git a/Workbench/Taller/pruebaerror.ipynb b/Workbench/Taller/pruebaerror.ipynb
new file mode 100644
index 000000000..a4c670a96
--- /dev/null
+++ b/Workbench/Taller/pruebaerror.ipynb
@@ -0,0 +1,586 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Clase:\n",
+ " atributo_clase = \"Hola\" # Accesible desde el exterior\n",
+ " __atributo_clase = \"Hola\" # No accesible\n",
+ "\n",
+ " # No accesible desde el exterior usando guión bajo\n",
+ " def __mi_metodo(self):\n",
+ " print(\"Haz algo\")\n",
+ " self.__variable = 0\n",
+ "\n",
+ " # Este código es accesible desde el exterior\n",
+ " def metodo_normal(self):\n",
+ " # El método si es accesible desde el interior\n",
+ " self.__mi_metodo()\n",
+ "\n",
+ "mi_clase = Clase()\n",
+ "#mi_clase.__atributo_clase # Error! El atributo no es accesible\n",
+ "#mi_clase.__mi_metodo() # Error! El método no es accesible\n",
+ "mi_clase.atributo_clase # Ok!\n",
+ "mi_clase.metodo_normal() # Ok!\n",
+ "print (mi_clase._Clase__atributo_clase)\n",
+ "# 'Hola'\n",
+ "mi_clase._Clase__mi_metodo()\n",
+ "# 'Haz algo'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Vehiculo:\n",
+ " def __init__(self, color, tipo, cilindrada):\n",
+ " self.color = color\n",
+ " self.tipo = tipo\n",
+ " self.cilindrada = cilindrada\n",
+ " self.velocidad = 0 # Aquí creamos el atributo velocidad, no se requieren 2\n",
+ " self.direccion = 0 # Aquí creamos el atributo velocidad\n",
+ "\n",
+ " def Acelerar(self, vel): # Recibe un parámetro velocidad\n",
+ " self.velocidad += vel # Este es método que modifica el atributo velocidad\n",
+ "\n",
+ " def Frenar(self, vel): # Recibe un parámetro velocidad, es sólo un valor\n",
+ " self.velocidad -= vel # Calcula la nueva velocidad\n",
+ " \n",
+ " def Doblar(self, grados): # Recibe la cantidad de grados de l giro (0-360)\n",
+ " self.direccion += grados # Calcula la nueva dirección\n",
+ " \n",
+ " def Estado(self):\n",
+ " print('La velocidad actual es :', self.velocidad, '- y su rumbo es:', self.direccion, 'grados')\n",
+ "\n",
+ " def Detalle(self):\n",
+ " print('Soy del tipo ', self.tipo, 'de color', self.color, 'y mi cilindrada es de', self.cilindrada, 'litros')\n",
+ "\n",
+ "# 3) Instanciar 3 objetos de la clase vehículo y ejecutar sus métodos, probar luego\n",
+ "# el resultado\n",
+ "\n",
+ "a1 = Vehiculo ('rojo', 'auto', 2)\n",
+ "a2 = Vehiculo ('blanco', 'camioneta', 3.6)\n",
+ "a3 = Vehiculo ('negro', 'moto', 1)\n",
+ "\n",
+ "#a1.Acelerar(40)\n",
+ "a2.Acelerar(60)\n",
+ "a3.Acelerar(30)\n",
+ "#a1.Doblar(30)\n",
+ "a3.Doblar(30)\n",
+ "a2.Frenar(50)\n",
+ "a1.Doblar(100)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "blanco 10 3.6\n",
+ "Soy del tipo auto de color rojo y mi cilindrada es de 2 litros\n",
+ "La velocidad actual es : 0 - y su rumbo es: 0 grados\n"
+ ]
+ }
+ ],
+ "source": [
+ "print (a2. color, a2.velocidad, a2.cilindrada)\n",
+ "a1 = Vehiculo('rojo', 'auto', 2)\n",
+ "a1.Detalle()\n",
+ "a1.Estado()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print (a1.velocidad) # Tenía 0, le sume 40, queda en 40\n",
+ "print (a2.velocidad) # Tenía 0, le sume 40, queda en 60\n",
+ "print (a3.velocidad) # Tenía 0, le sume 40, queda en 30\n",
+ "print (a1.direccion) # Tenía 0 grados, queda en 30\n",
+ "print (a3.direccion) # Tenía 0 grados, queda en -30\n",
+ "print (a2.velocidad) # Frena y DISMINUYE (resta -50), debe quedar en 10"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Operacion:\n",
+ "\n",
+ " def __init__(self):\n",
+ " self.valor1=int(input(\"Ingrese primer valor:\"))\n",
+ " self.valor2=int(input(\"Ingrese segundo valor:\"))\n",
+ " self.sumar()\n",
+ " self.restar()\n",
+ " self.multiplicar()\n",
+ " self.dividir()\n",
+ "\n",
+ " def sumar(self):\n",
+ " suma=self.valor1+self.valor2\n",
+ " print(\"La suma es\",suma)\n",
+ "\n",
+ " def restar(self):\n",
+ " resta=self.valor1-self.valor2\n",
+ " print(\"La rersta es\",resta)\n",
+ "\n",
+ " def multiplicar(self):\n",
+ " multi=self.valor1*self.valor2\n",
+ " print(\"El producto es\",multi)\n",
+ "\n",
+ " def dividir(self):\n",
+ " divi=self.valor1/self.valor2\n",
+ " print(\"La division es\",divi)\n",
+ "\n",
+ "\n",
+ "# bloque principal\n",
+ "\n",
+ "#operacion1=Operacion5\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n",
+ "for n in range(1,11): #Incluye el primero y excluye el último\n",
+ " print(n,(')'))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "n = 1\n",
+ "while (n < 11):\n",
+ " print(n)\n",
+ " n = n + 1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "['Azul', 'Amarillo', 'Naranja', 'Violeta', 'Verde']\n"
+ ]
+ }
+ ],
+ "source": [
+ "mi_lista = ['Rojo','Azul','Amarillo','Naranja','Violeta','Verde'] # Lista de 6 elementos\n",
+ "\n",
+ "print(mi_lista[1:]) # Imprime la lista desde la posición 1, hasta el final, \n",
+ "#"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "['Rojo', 'Azul', 'Amarillo', 'Negro', 'Naranja', 'Violeta', 'Verde']\n"
+ ]
+ }
+ ],
+ "source": [
+ "#mi_lista.insert(3,'Negro')\n",
+ "print(mi_lista)\n",
+ "#print(type(mi_lista.index('Azul')))\n",
+ "#print(mi_lista[1])\n",
+ "#mi_lista.insert(3,'Negro')\n",
+ "\n",
+ "#n = 1\n",
+ "#while (n < 11):\n",
+ "# mi_lista.remove('Negro')\n",
+ "# n = n + 1\n",
+ "#mi_lista.remove('Blanco')\n",
+ " \n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# ultimo = mi_lista.pop() # Remueve el último elemento de la lista,\n",
+ "# print (mi_lista) # Falta el 'Verde'\n",
+ "#ultimo = mi_lista.pop()\n",
+ "#print(ultimo) #Conserva el último elemento eliminado con POP, si ejecuto otra vez, elimina violeta."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mi_tupla = ('Rojo','Azul','Amarillo','Naranja','Rojo','Violeta','Rojo','Verde')\n",
+ "mi_tupla.count('Rojo')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mi_tupla='Gaspar', 5, 8, 1999\n",
+ "#print (type(mi_tupla[3]))\n",
+ "nombre, dia, mes, año = mi_tupla\n",
+ "print (mi_tupla)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "nombre = 'Darío' # Inicializo var nombre con el str 'Darío'\n",
+ "edad = 39 # Inicilizo var edad con el int 39\n",
+ "print(nombre, edad) # Imprimo el contenido de las variables.\n",
+ "print(\"Mi nombre es\", nombre, \". Mi edad es\", edad, \"años\")\n",
+ "print(\"Mi nombre es {}. Mi edad es {} años\". format(nombre, edad))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mi_diccionario = { 'Colores Primarios': ['Rojo','Azul','Amarillo'], # Crear con {key:Elm, key:Elm...}\n",
+ " 'Colores secundarios': ['Naranja','Violeta','Verde'], # Elm= Cualquier cosa, mutable\n",
+ " 'Clave3': 10, # Key= Hasheable, inmutable\n",
+ " 'Clave4': False}\n",
+ "#print (mi_diccionario['Colores secundarios']) # Lo puedo acceder por sus claves o índices y retorna los VALORES\n",
+ "# R=> ['Naranja', 'Violeta', 'Verde'] # Para la clave dad, retorno los elementos respectivos\n",
+ "\n",
+ "mi_diccionario2 = {'Clave1':'Valor1', 'Clave2':{'numeros':[1,2,3,4,5]}} # Dic key1=str y val1=str, key2=str, val2=lista\n",
+ "print (mi_diccionario2.keys()) # Retorna R=> dict_keys(['Clave1', 'Clave2'])\n",
+ "print(mi_diccionario2.values()) # Retorna R=> dict_values(['Valor1', {'numeros': [1, 2, 3, 4, 5]}])\n",
+ "len (mi_diccionario) # Retorna el número de pares R=>2\n",
+ "print(mi_diccionario2)\n",
+ "print(type(mi_diccionario2.keys[1]))\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edad = 60\n",
+ "edad_compa = 50\n",
+ "if (edad < edad_compa):\n",
+ " print(edad)\n",
+ " if (edad < 100):\n",
+ " print(edad + 100)\n",
+ " else:\n",
+ " print(edad - 100)\n",
+ "else:\n",
+ " print(edad_compa)\n",
+ "# 50\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "primeros_10 = [0,1,2,3,4,5,6,7,8,9]\n",
+ "# print(primeros_10) # R=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
+ "outlist = []\n",
+ "for n in primeros_10: # For 'var' in 'lista/tupla/dict'\n",
+ " if (n%2 == 0): # Uso la función resto para reconocer los PARES \n",
+ " outlist.append(n)\n",
+ " #primeros_10[n]=0\n",
+ "print ('Los pares son', outlist)\n",
+ "#print(\"\\va de nuevo....\\n\")\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "outlist = []\n",
+ "for n in primeros_10: # For 'var' in 'lista/tupla/dict'\n",
+ " if (n%2 == 0): # Uso la función resto para reconocer los PARES \n",
+ " outlist.append(n) # Los guardo en una lista para poder mostrarlos horizontalmente \n",
+ "print ('Los pares son', outlist) "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "n = 40\n",
+ "sequence = [0,1]\n",
+ "for i in range(2,n):\n",
+ " sequence.append(sequence[i-1]+sequence[i-2])\n",
+ "print (sequence)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "a = [1, 2]\n",
+ "b = [\"Uno\", \"Dos\"]\n",
+ "c = zip(a, b)\n",
+ "for numero, texto in zip(a, b):\n",
+ " print(\"Número\", numero, \"Letra\", texto)\n",
+ " print(type(numero), type(texto))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "colores = ['yellow', 'wine', 'blue', 'green', 'red', 'brown', 'red']\n",
+ "sec_colr = ['blue', 'green', 'red']\n",
+ "\n",
+ "\n",
+ "strColores = str(colores).strip(\"[]\")\n",
+ "strSec_colr = str(sec_colr).strip(\"[]\")\n",
+ "\n",
+ "if strSec_colr in strColores:\n",
+ " print(\"Si\")\n",
+ "else:\n",
+ " print(\"No\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hola = ' \\t\\t\\n\\tHola \\n '\n",
+ "print(hola)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hola_limpio = hola.strip()\n",
+ "print(type(hola_limpio))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "texto = ' hola mundo hola \\ni'\n",
+ "print(texto.strip(' oahl'))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "colores = ['yellow', 'wine', 'blue', 'green', 'red', 'brown', 'red']\n",
+ "sec_colr = ['blue', 'green', 'red']\n",
+ "\n",
+ "strColores = str(colores).strip(\"[]\")\n",
+ "strSec_colr = str(sec_colr).strip(\"[]\")\n",
+ "\n",
+ "if strSec_colr in strColores:\n",
+ " print(\"Si\")\n",
+ "else:\n",
+ " print(\"No\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from collections import deque\n",
+ "\n",
+ "mi_Cola = deque([\"Pedro\", \"Juan\", \"Diego\"]) # Están Pedro, Juan y Diego en la cola\n",
+ "mi_Cola.append(\"Luis\") # Llega Luis\n",
+ "print (mi_Cola) # R=> (['Pedro', 'Juan', 'Diego', 'Luis'])\n",
+ "mi_Cola.append(\"Jorge\") # Llega Jorge\n",
+ "print (mi_Cola) # R=> (['Pedro', 'Juan', 'Diego', 'Luis', 'Jorge'])\n",
+ "print(mi_Cola.popleft()) # El primero en llegar se va => Pedro\n",
+ "print(mi_Cola) # R=> ('Juan', 'Diego', 'Luis', 'Jorge'])\n",
+ "print(mi_Cola.popleft()) # Ahora se va el segundo en llegar R=> Juan\n",
+ "print(mi_Cola) # R=> ('Diego', 'Luis', 'Jorge'])\n",
+ " # La lista restante en orden de llegada"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from collections import deque\n",
+ "\n",
+ "queue = deque([\"Eric\", \"John\", \"Michael\"])\n",
+ "queue.append(\"Terry\") # Terry arrives\n",
+ "print (queue) # (['Eric', 'John', 'Michael', 'Terry'])\n",
+ "queue.append(\"Graham\") # Graham arrives\n",
+ "print (queue) # (['Eric', 'John', 'Michael', 'Terry', 'Graham'])\n",
+ "print(queue.popleft()) # The first to arrive now leaves\n",
+ "#print(queue.popleft()) # 'Eric'\n",
+ "print (queue) # (['John', 'Michael', 'Terry', 'Graham'])\n",
+ "print(queue.popleft()) # The second to arrive now leaves\n",
+ "print(queue.popleft()) #'John'\n",
+ "queue # Remaining queue in order of arrival\n",
+ "deque(['Michael', 'Terry', 'Graham'])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "n = 40\n",
+ "sequence = [0,1]\n",
+ "for i in range(2,n):\n",
+ " sequence.append(sequence[i-1]+sequence[i-2])\n",
+ "print (sequence)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cuadrados1 = []\n",
+ "for x in range(10):\n",
+ " cuadrados1.append(x**2) # Agrega los cuadrados en el rango 0-10, a lista cuadrados\n",
+ "print (cuadrados1) # => [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] \n",
+ "\n",
+ "# Nótese que esto crea (o sobreescribe) una variable llamada x que sigue existiendo \n",
+ "# luego de que el bucle haya terminado. sin embargo, podemos aplicar listas por \n",
+ "# COMPRENSIÓN, poblando la lista de cuadrados sin efecto secundario haciendo:\n",
+ "\n",
+ "cuadrados2 = list(map(lambda x: x**2, range(10))) # Usamos una función lambda y map\n",
+ "print (cuadrados1)\n",
+ "cuadrados3 = [x**2 for x in range(10)] # otra equivalente sería:\n",
+ "print (cuadrados1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n",
+ "lista_cuad = [(x, x**2) for x in range(6)]\n",
+ "print ('La lista de pares (x, x^2), es ', lista_cuad)\n",
+ "#[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Ejemplo - aplanar una lista usando un listas compuestas (listcomp) con dos 'FOR'\n",
+ "\n",
+ "vec = [[1,2,3], [4,5,6], [7,8,9]] # vec es un arreglo de listas\n",
+ "flat_vec= [num for elem in vec for num in elem] # Nótese que en este caso no uso paréntesis, no es comparación o formula\n",
+ "\n",
+ "print (\"La lista 'aplanada' es \", flat_vec) # La lista esperada R=>[1, 2, 3, 4, 5, 6, 7, 8, 9]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 148,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Los valores incrementales de pi, son ['3.1', '3.14', '3.142', '3.1416', '3.14159']\n"
+ ]
+ }
+ ],
+ "source": [
+ "from math import pi # Importamos una librería \"MATH\" que nos permite hacer cálculos científicos y usar constantes \n",
+ "pi_evol= [str(round(pi, i)) for i in range(1, 6)] # Creamos una lista con incrementales de pi\n",
+ "print ('Los valores incrementales de pi, son ', pi_evol)\n",
+ "# R=> Los valores incrementales de pi, son ['3.1', '3.14', '3.142', '3.1416', '3.14159']"
+ ]
+ }
+ ],
+ "metadata": {
+ "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.10.6"
+ },
+ "orig_nbformat": 4,
+ "vscode": {
+ "interpreter": {
+ "hash": "d3777ed8f5fe800f0d3d1926318eb186c93d9a88e13881725c87e5bdd2f1dd1d"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
From 1b3d34584484f53e76c21e2c0f88502976483b2a Mon Sep 17 00:00:00 2001
From: Jorge Cordova <55065873+jcordovaj@users.noreply.github.com>
Date: Sat, 28 Jan 2023 03:44:20 -0300
Subject: [PATCH 11/16] 2801230343 Up ejercicios de todo tipo
---
Workbench/OrdenaTuplas.py | 19 +
Workbench/Taller/AgregarElementosaObj.py | 30 +
Workbench/Taller/Clases.py | 57 ++
Workbench/Taller/DesafioProgra.py | 335 +++++++++
Workbench/Taller/Diccionarios.py | 42 +-
Workbench/Taller/EjerciciosVarios.py | 50 ++
Workbench/Taller/FuncionFactorial.py | 22 +
Workbench/Taller/ListaEnteros.py | 34 +
Workbench/Taller/Mix_ejercicios.py | 17 +-
Workbench/Taller/NumeroCapicua.py | 36 +
Workbench/Taller/OrdenaDic | 55 ++
Workbench/Taller/aritmetica.py | 2 +-
Workbench/Taller/listas.py | 12 +-
Workbench/Taller/pruebaerror.ipynb | 911 ++++++++++++++++++++++-
Workbench/Taller/variables.py | 23 +
15 files changed, 1620 insertions(+), 25 deletions(-)
create mode 100644 Workbench/OrdenaTuplas.py
create mode 100644 Workbench/Taller/AgregarElementosaObj.py
create mode 100644 Workbench/Taller/DesafioProgra.py
create mode 100644 Workbench/Taller/EjerciciosVarios.py
create mode 100644 Workbench/Taller/FuncionFactorial.py
create mode 100644 Workbench/Taller/ListaEnteros.py
create mode 100644 Workbench/Taller/NumeroCapicua.py
create mode 100644 Workbench/Taller/OrdenaDic
diff --git a/Workbench/OrdenaTuplas.py b/Workbench/OrdenaTuplas.py
new file mode 100644
index 000000000..34db83f4f
--- /dev/null
+++ b/Workbench/OrdenaTuplas.py
@@ -0,0 +1,19 @@
+#
+# Ordenar una lista de coches almacenados como tuplas
+#
+tuplas_coches = [('Rojo', '4859-A', 'A'), ('Azul', '2901-Z', 'M'), ('Gris', '1892-B', 'M')
+ ]
+# Ordenar los coches por matrícula
+ordenados = sorted(tuplas_coches, key=lambda coche : coche[1])
+print (ordenados)
+#[('Gris', '1892-B', 'M'), ('Azul', '2901-Z', 'M'), ('Rojo', '4859-A', 'A')]
+# Ordenar una lista de coches almacenados como diccionarios
+diccionarios_coches = [
+ {'color': 'Rojo', 'matricula': '4859-A', 'cambio': 'A'},
+ {'color': 'Azul', 'matricula': '2901-Z', 'cambio': 'M'},
+ {'color': 'Gris', 'matricula': '1892-B', 'cambio': 'M'}
+]
+ordenados = sorted(diccionarios_coches, key=lambda coche : coche['matricula'])
+print (ordenados)
+
+#[{'color': 'Gris', 'matricula': '1892-B', 'cambio': 'M'}, {'color': 'Azul', 'matricula': '2901-Z', 'cambio': 'M'}, {'color': 'Rojo', 'matricula': '4859-A', 'cambio': 'A'}]
\ No newline at end of file
diff --git a/Workbench/Taller/AgregarElementosaObj.py b/Workbench/Taller/AgregarElementosaObj.py
new file mode 100644
index 000000000..7765b0f21
--- /dev/null
+++ b/Workbench/Taller/AgregarElementosaObj.py
@@ -0,0 +1,30 @@
+# Ejercicio 442: Agregar elementos a un objeto conjunto con el método de instancia add().
+
+lenguajes = set()
+
+print(len(lenguajes))
+print(lenguajes)
+
+print()
+
+lenguajes.add('Python')
+print(len(lenguajes))
+print(lenguajes)
+
+print()
+
+lenguajes.add('Java')
+print(len(lenguajes))
+print(lenguajes)
+
+print()
+
+lenguajes.add('Java')
+print(len(lenguajes))
+print(lenguajes)
+
+print()
+
+lenguajes.add('java')
+print(len(lenguajes))
+print(lenguajes)
\ No newline at end of file
diff --git a/Workbench/Taller/Clases.py b/Workbench/Taller/Clases.py
index d071497fb..1bf3669b9 100644
--- a/Workbench/Taller/Clases.py
+++ b/Workbench/Taller/Clases.py
@@ -207,3 +207,60 @@ def hablar(self):
# Guau!
# Miau!
+# Ejercicio 8 - Crear clase Persona
+
+class Persona():
+
+ def __init__(self,nombre="",edad=0,dni=""):
+ self.nombre=nombre
+ self.edad=edad
+ self.dni=dni
+
+ @property
+ def nombre(self):
+ return self.__nombre
+
+ @property
+ def edad(self):
+ return self.__edad
+
+ @property
+ def dni(self):
+ return self.__dni
+
+ @nombre.setter
+ def nombre(self,nombre):
+ self.__nombre=nombre
+
+ def validar_dni(self):
+ letras = "TRWAGMYFPDXBNJZSQVHLCKE"
+ if len(self.__dni)!=9:
+ print("DNI incorrecto")
+ self.__dni = ""
+ else:
+ letra = self.__dni[8]
+ num = int(self.__dni[:8])
+ if letra.upper() != letras[num % 23]:
+ print("DNI incorrecto")
+ self.__dni = ""
+
+ @dni.setter
+ def dni(self,dni):
+ self.__dni=dni
+ self.validar_dni()
+
+ @edad.setter
+ def edad(self,edad):
+ if edad < 0:
+ print("Edad incorrecta")
+ self.__edad=0
+ else:
+ self.__edad=edad
+
+
+ def mostrar(self):
+ return "Nombre:"+self.nombre+" - Edad:"+str(self.edad)+" - DNI:"+self.dni
+
+ def esMayorDeEdad(self):
+ return self.edad>=18
+
diff --git a/Workbench/Taller/DesafioProgra.py b/Workbench/Taller/DesafioProgra.py
new file mode 100644
index 000000000..80a644552
--- /dev/null
+++ b/Workbench/Taller/DesafioProgra.py
@@ -0,0 +1,335 @@
+#*******************************************************************
+#* *
+#* SIMULACRO HENRY CHALLENGE *
+#* *
+#*******************************************************************
+
+def ListaDivisibles(numero, tope):
+ '''
+ Esta función devuelve una lista ordenada de menor a mayor con los números divisibles
+ por el parámetro número entre uno (1) y el valor del parámetro "tope"
+ Recibe dos argumentos:
+ numero: Numero entero divisor
+ tope: Máximo valor a evaluar a partir de uno (1)
+ Ej:
+ ListaDivisibles(6,30) debe retornar [6,12,18,24]
+ ListaDivisibles(10,5) debe retornar []
+ ListaDivisibles(7,50) debe retornar [7,14,21,28,35,42,49]
+ '''
+ #Tu código aca:
+ lista=[]
+ for i in range((tope)):
+ if (i+1)%numero==0:
+ lista.append(i+1)
+
+ return lista
+
+def Exponente(numero, exponente):
+ '''
+ Esta función devuelve el resultado de elevar el parámetro "numero" al parámetro "exponente"
+ Recibe dos argumentos:
+ numero: El número base en la operación exponencial
+ exponente: El número exponente en la operación exponencial
+ Ej:
+ Exponente(10,3) debe retornar 1000
+ '''
+ #Tu código aca:
+ exp=numero**exponente
+ return exp
+
+def ListaDeListas(lista):
+ '''
+ Esta función recibe una lista, que puede contener elementos que a su vez sean listas y
+ devuelve esos elementos por separado en una lista única.
+ En caso de que el parámetro no sea de tipo lista, debe retornar nulo.
+ Recibe un argumento:
+ lista: La lista que puede contener otras listas y se convierte a una
+ lista de elementos únicos o no iterables.
+ Ej:
+ ListaDeListas([1,2,['a','b'],[10]]) debe retornar [1,2,'a','b',10]
+ ListaDeListas(108) debe retornar el valor nulo.
+ ListaDeListas([[1,2,[3]],[4]]) debe retornar [1,2,3,4]
+ '''
+ #Tu código aca:
+ if type(lista) != list:
+ return None
+ else:
+ lista_final=[]
+ for elem in lista:
+ if isinstance(elem, list):
+ lista_final.extend(ListaDeListas(elem))
+ else:
+ lista_final.append(elem)
+ return lista_final
+
+
+
+ #return 'Funcion incompleta'
+
+def Factorial(numero):
+ '''
+ Esta función devuelve el factorial del número pasado como parámetro.
+ En caso de que no sea de tipo entero y/o sea menor que 0, debe retornar nulo.
+ Recibe un argumento:
+ numero: Será el número con el que se calcule el factorial
+ Ej:
+ Factorial(4) debe retornar 24
+ Factorial(-2) debe retornar nulo
+ Factorial(0) debe retornar 1
+ '''
+ #Tu código aca:
+ if (type(numero) != int):
+ return None
+ if (numero < 0):
+ return None
+ factorial = 1
+ for n in range(1, (numero)+1):
+ factorial = factorial * n
+ return factorial
+ #return 'Funcion incompleta'
+
+def ListaPrimos(desde, hasta):
+ '''
+ Esta función devuelve una lista con los números primos entre los valores "desde" y "hasta"
+ pasados como parámetro, siendo ambos inclusivos.
+ En caso de que alguno de los parámetros no sea de tipo entero y/o no sea mayor a cero, debe retornar nulo.
+ En caso de que el segundo parámetro sea mayor al primero, pero ambos mayores que cero,
+ debe retornar una lista vacía.
+ Recibe un argumento:
+ desde: Será el número a partir del cual se toma el rango
+ hasta: Será el número hasta el cual se tome el rango
+ Ej:
+ ListaPrimos(7,15) debe retornar [7,11,13]
+ ListaPrimos(100,99) debe retornar []
+ ListaPrimos(1,7) debe retonan [1,2,3,5,7]
+ '''
+ #Tu código aca:
+ lista=[]
+ if (type(desde) != int or type(hasta) != int):
+ return None
+ if (desde < 0 or hasta < 0):
+ return None
+ if (desde > hasta):
+ return lista
+ def esPrimo(num):
+ if num==2:
+ return True
+ for n in range (2,num):
+ if(num%n!=0):
+ continue
+ else:
+ return False
+ return True
+ for i in range(desde,(hasta+1)):
+ if esPrimo(i):
+ lista.append(i)
+
+ return lista
+
+
+def ListaRepetidos(lista):
+ '''
+ Esta función recibe como parámetro una lista y devuelve una lista de tuplas donde cada
+ tupla contiene un valor de la lista original y las veces que se repite. Los valores
+ de la lista original no deben estar repetidos.
+ Debe respetarse el orden original en el que aparecen los elementos.
+ En caso de que el parámetro no sea de tipo lista debe retornar nulo.
+ Recibe un argumento:
+ lista: Será la lista que se va a evaluar.
+ Ej:
+ ListaRepetidos([]) debe retornar []
+ ListaRepetidos(['hola', 'mundo', 'hola', 13, 14])
+ debe retornar [('hola',2),('mundo',1),(13,1),(14,1)]
+ ListaRepetidos([1,2,2,4]) debe retornar [(1,1),(2,1),(4,1)]
+ '''
+ #Tu código aca:
+ l=[]
+ if type(lista) != list:
+ return None
+ while len(lista)>0:
+ elemento=lista[0]
+ cuenta=lista.count(lista[0])
+ l.append((elemento,cuenta))
+ for i in range(lista.count(lista[0])):
+ lista.remove(elemento)
+ continue
+ return l
+
+def ClaseVehiculo(tipo, color):
+ '''
+ Esta función devuelve un objeto instanciado de la clase Vehiculo,
+ la cual debe tener los siguientes atributos:
+ Tipo: Un valor dentro de los valores posibles: ['auto','camioneta','moto']
+ Color: Un valor de tipo de dato string.
+ Velocidad: Un valor de tipo de dato float, que debe inicializarse en cero.
+ y debe tener el siguiente método:
+ Acelerar(): Este método recibe un parámetro con el valor que debe incrementar a la
+ propiedad Velocidad y luego retornarla.
+ Si la propiedad Velocidad cobra un valor menor a cero, debe quedar en cero.
+ Si la propiedad Velocidad cobra un valor mayor a cien, debe quedar en cien.
+ Recibe dos argumento:
+ tipo: Dato que se asignará al atributo Tipo del objeto de la clase Vehiculo
+ color: Dato que se asignará al atributo Color del objeto de la clase Vehiculo
+ Ej:
+ a = ClaseVehículo('auto','gris')
+ a.Acelerar(10) -> debe devolver 10
+ a.Acelerar(15) -> debe devolver 25
+ a.Acelerar(-10) -> debe devolver 15
+ '''
+ #Tu código aca:
+ class Vehiculo:
+ def __init__(self, tipo, color):
+ if (tipo=='auto' or tipo =='camioneta' or tipo=='moto'):
+ self.Tipo = tipo
+ else:
+ raise TypeError ('el tipo de vehículo tiene que ser auto, camioneta o moto')
+ self.Color = color
+ self.Velocidad = 0
+
+ def Acelerar(self, acel):
+ self.Velocidad += acel
+ if self.Velocidad < 0:
+ self.Velocidad=0
+ if self.Velocidad>100:
+ self.Velocidad=100
+ return self.Velocidad
+
+ a = Vehiculo(tipo, color)
+ return a
+
+
+def OrdenarDiccionario(diccionario_par, clave, descendente=True):
+ '''
+ Esta función recibe como parámetro un diccionario, cuyas listas de valores tienen el mismo
+ tamaño y sus elementos enésimos están asociados. Y otros dos parámetros que indican
+ la clave por la cual debe ordenarse y si es descendente o ascendente.
+ La función debe devolver el diccionario ordenado, teniendo en cuenta de no perder la
+ relación entre los elementos enésimos.
+ Recibe tres argumentos:
+ diccionario: Diccionario a ordenar.
+ clave: Clave del diccionario recibido, por la cual ordenar.
+ descendente: Un valor booleano, que al ser verdadero indica ordenamiento descendente y
+ ascendente si es falso.
+ Debe tratarse de un parámetro por defecto en True.
+ Si el parámetro diccionario no es un tipo de dato diccionario ó el parámetro clave no
+ se encuentra dentro de las claves del diccionario, debe devolver nulo.
+ Ej:
+ dicc = {'clave1':['c','a','b'],
+ 'clave2':['casa','auto','barco'],
+ 'clave3':[3,1,2]}
+ OrdenarDiccionario(dicc, 'clave1') debe retornar {'clave1':['a','b','c'],
+ 'clave2':['auto','barco','casa'],
+ 'clave3':[1,2,3]}
+ OrdenarDiccionario(dicc, 'clave3', False) debe retornar {'clave1':['c','b','a'],
+ 'clave2':['casa','barco','auto'],
+ 'clave3':[3,2,1]}
+ '''
+ #Tu código aca:
+ if type(diccionario_par) != dict:
+ return None
+ diccion_lista=[]
+ diccion_lista=list(diccionario_par.keys())
+ if clave not in diccion_lista:
+ return None
+ for key, value in diccionario_par.items():
+ value.sort(reverse=descendente)
+
+ return diccionario_par
+
+def Factorial(numero):
+ '''
+ Esta función devuelve el factorial del número pasado como parámetro.
+ En caso de que no sea de tipo entero y/o sea menor que 1, debe retornar nulo.
+ Recibe un argumento:
+ numero: Será el número con el que se calcule el factorial
+ Ej:
+ Factorial(4) debe retornar 24
+ Factorial(-2) debe retornar nulo
+ '''
+ #Tu código aca:
+ if (type(numero) != int):
+ return None
+ if (numero < 1):
+ return None
+ factorial = 1
+ while(numero > 1):
+ factorial = factorial * numero
+ numero -= 1
+ return factorial
+
+def EsPrimo(valor):
+ '''
+ Esta función devuelve el valor booleano True si el número reibido como parámetro es primo, de lo
+ contrario devuelve False..
+ En caso de que el parámetro no sea de tipo entero debe retornar nulo.
+ Recibe un argumento:
+ valor: Será el número a evaluar
+ Ej:
+ EsPrimo(7) debe retornar True
+ EsPrimo(8) debe retornar False
+ '''
+ #Tu código aca:
+ if (type(valor) != int):
+ return None
+ for i in range(2, (int(valor / 2) + 1)):
+ if valor % i == 0:
+ return False
+ return True
+
+def ClaseAnimal(especie, color):
+ '''
+ Esta función devuelve un objeto instanciado de la clase Animal,
+ la cual debe tener los siguientes atributos:
+ Edad (Un valor de tipo de dato entero, que debe inicializarse en cero)
+ Especie (Un valor de tipo de dato string)
+ Color (Un valor de tipo de dato string)
+ y debe tener el siguiente método:
+ CumplirAnios (este método debe sumar uno al atributo Edad y debe devolver ese valor)
+ Recibe dos argumento:
+ especie: Dato que se asignará al atributo Especie del objeto de la clase Animal
+ color: Dato que se asignará al atributo Color del objeto de la clase Animal
+ Ej:
+ a = ClaseAnimal('perro','blanco')
+ a.CumpliAnios() -> debe devolver 1
+ a.CumpliAnios() -> debe devolver 2
+ a.CumpliAnios() -> debe devolver 3
+ '''
+ #Tu código aca:
+ class Animal:
+ def __init__(self, especie, color):
+ self.Especie = especie
+ self.Color = color
+ self.Edad = 0
+
+ def CumplirAnios(self):
+ self.Edad += 1
+ return self.Edad
+
+ a = Animal(especie, color)
+ return a
+
+
+# Caso 1
+# El constructor de la clase Emprendedor recibe nombre (str), apellido (str),
+# libros (lista), mascotas (lista).
+
+# a) Inicializar la clase con sus atributos
+
+class Emprendedor:
+ """En esta clase se crean emprenderes"""
+ mascotas = [] # Acumulará las mascotas del Emprendedor
+ libros = [] # Es una lista de libros del Emprendedor
+ def __init__(self, nombre, apellido, libros, mascotas):
+ self.nombre = nombre
+ self.apellido = apellido
+ self.libros = libros
+ self.mascotas = mascotas
+
+# b) Crear un Método que agregue una mascota (mascota) a la lista, no debe
+# retornar nada. Mascotas es una lista
+#
+
+ def addMascotas (self, newPet):
+ self.mascotas.add()
+
+
\ No newline at end of file
diff --git a/Workbench/Taller/Diccionarios.py b/Workbench/Taller/Diccionarios.py
index 3479a15af..54d32aecc 100644
--- a/Workbench/Taller/Diccionarios.py
+++ b/Workbench/Taller/Diccionarios.py
@@ -116,7 +116,7 @@
# Ejemplo 7
# Consultar a un dicc, si una clase existe => retorna un booleano TRUE o FALSE
-# Ojo si preguntas por un valor, puede existir, pero retornará FALSE
+# Ojo si preguntas por un VALUE, puede que existe la KEY, pero retornará FALSE
# Si quiero preguntar por un valor, agrego el método .value()
print ("")
@@ -134,6 +134,44 @@
restaurant = {"Hamburguesa": 100, "Pizza": 50, "Jugo": 30}
if "Hamburguesa" in restaurant:
print ("SI está")
+ print()
else:
print ("NO está")
-print (restaurant)
\ No newline at end of file
+ print()
+print (restaurant)
+print()
+
+# Ejemplo 8 - Unir dos diccionarios
+
+def unirDics (dic1, dic2):
+ temp=dic1.copy()
+ temp.update(dic2)
+ return temp
+miDic1={'manzana':10.50, 'pera':12.8}
+miDic2={'durazno':11.10, 'ciruela':23.8}
+
+dicUni2= unirDics (miDic1, miDic2)
+print (dicUni2)
+print()
+
+# Ejemplo 9 - Unir dos diccionarios
+# Unir dos LISTAS y crear un Diccionario
+# necesitamos una lsta que provea las llaves y otra que provea los values
+
+def lisADicc (liskey, lisval):
+ return dict(zip(liskey, lisval))
+newkeys = ['enero', 'febrero', 'marzo', 'abril']
+newval = [10, 50,12, 9, 11, 10, 23, 8]
+
+d=lisADicc (newkeys, newval)
+print (d)
+#print()
+
+# Ejemplo 9 - Encontrar el elemento más frecuente de una lista o MODA
+#
+def moda (lista):
+ return print (max(lista, key= lista.count))
+print()
+lista = [3,1,3,2,1,5,2,3,2,1,5,4,3,3,3]
+moda (lista)
+
diff --git a/Workbench/Taller/EjerciciosVarios.py b/Workbench/Taller/EjerciciosVarios.py
new file mode 100644
index 000000000..c7d89db4a
--- /dev/null
+++ b/Workbench/Taller/EjerciciosVarios.py
@@ -0,0 +1,50 @@
+# Ejercicio 1 - Obtener la inversa de un string
+# Invertir cualquier cadena de caracteres
+
+cadena1 = "cebolla" # R=> allobec
+cadena2 = "somos" # R=> 'somos', es palíndroma
+
+for i in range(len(cadena1) -1, -1, -1):
+ print (cadena1[i], end="")
+
+print()
+
+# Ejercicio 2 - Palabra inversa, caso PALÍNDROMO (se lee igual al revés)
+# Detectar si es palíndromo y mandar un mensaje
+
+cadena3 = "coco" # R=> ococ
+cadena4 = "reconocer" # R=> 'reconocer', es palíndroma
+pali = []
+pali2 = []
+for i in range(len(cadena3) -1, -1, -1):
+ pali.append(cadena3[i])
+for j in range(len(pali)-1, -1, -1):
+ pali2.append(pali[j])
+#print (pali) # Se puede eliminar, es sólo para controlar la salida y sirven de manejo de errores
+#print (pali2) # Se puede eliminar, es sólo para controlar la salida y sirven de manejo de errores
+if (pali == pali2):
+ print ("Felicitaciones", cadena3, "es un palíndromo", end="")
+else:
+ print ("La palabra","'", cadena3,"'", "no es palíndroma e invertida, es", pali, end="")
+print()
+
+# Ejercicio 3 - Palabra inversa usando propiedades del método print - SLICING
+print ('')
+cadena= 'Pepino'
+print (cadena[::-1]) # '::' Indica de 0 hasta el último de los caracteres,
+ # para variantes, funciona igual que los indices separados
+ # por ':', con un desde y hasta, finalmente el '-1', le
+ # indica al método que es en orden inverso.
+
+# Ejercicio 4 - Ordenar una lista de cadenas de caracteres según el último carácter con la
+# función sorted()
+#
+
+# Creamos un diccionario dic_cadenas y que almacena 8 str (ciudades)
+#
+
+dic_cadenas = ['Talca', 'París', 'Londres', 'Bogotá', 'San José', 'Santiago', 'Lima', 'Sao Paulo']
+print (dic_cadenas)
+
+print()
+
diff --git a/Workbench/Taller/FuncionFactorial.py b/Workbench/Taller/FuncionFactorial.py
new file mode 100644
index 000000000..c004bb55e
--- /dev/null
+++ b/Workbench/Taller/FuncionFactorial.py
@@ -0,0 +1,22 @@
+#def factorizar_numero(numero):
+# if (type(numero) != int):
+# return None
+# if (numero < 0):
+# return None
+# factorial = 1
+# for n in range(1, (numero)+1):
+# factorial = factorial * n
+# return factorial
+
+#factorizar_numero()
+def factorial(n):
+ if (n <1):
+ return None
+ if n==0 or n==1:
+ resultado=1
+ elif n>1:
+ resultado=n*factorial(n-1)
+ return resultado
+
+fact=factorial(5)
+print (fact)
\ No newline at end of file
diff --git a/Workbench/Taller/ListaEnteros.py b/Workbench/Taller/ListaEnteros.py
new file mode 100644
index 000000000..297be6e85
--- /dev/null
+++ b/Workbench/Taller/ListaEnteros.py
@@ -0,0 +1,34 @@
+""" def test_ListaEnteros_01(self):
+ lista_test = ch.ListaEnteros(1, 10)
+ lista_esperada = [1,2,3,4,5,6,7,8,9,10]
+ self.assertEqual(lista_test, lista_esperada)
+
+ def test_ListaEnteros_02(self):
+ lista_test = ch.ListaEnteros(3, 7)
+ lista_esperada = [3,4,5,6,7,8,9,10]
+ self.assertEqual(lista_test, lista_esperada)
+
+ def test_ListaEnteros_03(self):
+ lista_test = ch.ListaEnteros(-2, 4)
+ lista_esperada = [-2,-1,0,1]
+ self.assertEqual(lista_test, lista_esperada)
+
+Esta función devuelve una lista de números enteros
+Recibe dos argumentos:
+ inicio: Numero entero donde inicia la lista
+ tamanio: Cantidad de números enteros consecutivos
+ Ej:
+ ListaEnteros(10,5) debe retornar [10,11,12,13,14]
+
+"""
+
+def ListaEnteros (inicio, tamanio):
+ lista = []
+ for i in range(inicio, inicio + tamanio):
+ lista.append(i)
+ return lista
+
+print (ListaEnteros (10,5))
+print (ListaEnteros (1,10))
+print (ListaEnteros (3,7))
+print (ListaEnteros (-2,4))
\ No newline at end of file
diff --git a/Workbench/Taller/Mix_ejercicios.py b/Workbench/Taller/Mix_ejercicios.py
index 56a8fa9d0..0c0ebdef6 100644
--- a/Workbench/Taller/Mix_ejercicios.py
+++ b/Workbench/Taller/Mix_ejercicios.py
@@ -1,5 +1,9 @@
-# Variables
-
+#*******************************************************************
+#* *
+#* MIX DE EJERCICIOS Y REVISIÓN DE EJEMPLOS *
+#* CON COMENTARIOS Y CITAS *
+#*******************************************************************
+#
# Ej 1) Cocatenar cadenas de caracteres, deben ser del mismo tipo (str+str)
a = 'Hola '
@@ -334,29 +338,20 @@ def test_suma_dos_negativos(self):
#Caja de Cristal
import unittest
-
def es_mayor_de_edad(edad):
if edad >= 18:
return True
else:
return False
-
class PruebaDeCristalTest(unittest.TestCase):
-
def test_es_mayor_de_edad(self):
edad = 20
-
resultado = es_mayor_de_edad(edad)
-
self.assertEqual(resultado, True)
-
def test_es_menor_de_edad(self):
edad = 15
-
resultado = es_mayor_de_edad(edad)
-
self.assertEqual(resultado, False)
-
unittest.main(argv=[''], verbosity=2, exit=False)
"""
diff --git a/Workbench/Taller/NumeroCapicua.py b/Workbench/Taller/NumeroCapicua.py
new file mode 100644
index 000000000..112932398
--- /dev/null
+++ b/Workbench/Taller/NumeroCapicua.py
@@ -0,0 +1,36 @@
+def NumeroCapicua(numero):
+ '''
+ En matemáticas, la palabra capicúa (del catalán cap i cua, 'cabeza y cola')
+ se refiere a cualquier número que se lee igual de izquierda a derecha que
+ de derecha a izquierda. Se denominan también números palíndromos.
+ Esta función devuelve el valor booleano True si el número es capicúa, de lo contrario
+ devuelve el valor booleano False
+ En caso de que el parámetro no sea de tipo entero, debe retornar nulo.
+ Recibe un argumento:
+ numero: Será el número sobre el que se evaluará si es capicúa o no lo es.
+ Ej:
+ NumeroCapicua(787) debe retornar True
+ NumeroCapicua(108) debe retornar False
+ '''
+ cadena3 = str(numero)
+ pali = []
+ pali2 = []
+ if type(numero) == int:
+ for i in range(len(cadena3) -1, -1, -1):
+ pali.append(cadena3[i])
+ for j in range(len(pali)-1, -1, -1):
+ pali2.append(pali[j])
+ if (pali == pali2):
+ return True
+ else:
+ return False
+ else:
+ return None
+
+
+# Probar
+numeros = [11, 20, 123, 9889, 2811, 1801, 777, 12321, ]
+
+for num in numeros:
+ es_capicua = NumeroCapicua(num)
+ print(f"El número {num} es capicúa? {es_capicua}")
\ No newline at end of file
diff --git a/Workbench/Taller/OrdenaDic b/Workbench/Taller/OrdenaDic
new file mode 100644
index 000000000..06e30b663
--- /dev/null
+++ b/Workbench/Taller/OrdenaDic
@@ -0,0 +1,55 @@
+dicc ={
+'clave1':['c', 'a', 'b'],
+'clave2':['casa', 'auto', 'barco'],
+'clave3':[3,2,1]}
+# 1) Convertir este dic de listas en una lista de dicts
+# 2) verificar que no pasan datos nulos o que no cumplen las condciones a) calaves no vacías y que el dic, sea un DICT
+# No se puede perder la hilación, or eso tarbajamos con listas.
+# Crequear condiciones
+clave='clave1'
+
+# def ordenaDic (dicc_rec, clave):
+newArr=[] # Va a recibir mi lista de diccionarios originales convertidos a listas
+newArrSorted=[] # Va a recibir los diccionarios ordenados por la clave ingresada
+res = []
+cantidadValores = 0
+numKeys = 0 # Recibe la cantidad de elementos del tipo llave que tiene el diccionario DICC, para ejecutar los ciclos.
+if not (type(dicc) is dict): #dict_rec= Debería ser el DICC recibido
+ pass #return 'Null' #None
+if not (clave in dicc.keys()): #clave=clave del parámetro
+ pass #return 'Null'
+ # definir variables a usar, incluye nuevas listas
+ # Convertimos el dicc de list a list de dict
+ # print (len(dicc_rec[list(dicc_par.keys())[0]]))
+ # chequeamos qué valor estamos reciendo
+ # print()
+print (len(dicc[list(dicc.keys())[0]]))
+if len(dicc[list(dicc.keys())[0]])>0: # convertimos el diccionario de listas, a una lista de diccionarios:
+ cantidadValores = len(dicc[list(dicc.keys())[0]])
+ print (cantidadValores)
+ for i in range(0, cantidadValores):
+ newObj={}
+ for key in dicc:
+ newObj[key]=dicc[key][i]
+ newArr.append(newObj) #print(newArr) #aquí se generó una lista de diccionarios
+ newArrSorted = sorted(newArr, key=lambda d: d[clave], reverse=not) # (descendente) Ahora ordenemos
+ #print (newArrSorted) #verificar contenido del nuevo arreglo
+ # Convertimos la lista de diccionarios, en un diccionario de listas:
+ for key in dicc:
+ newArr2 = []
+ for i in range(0, cantidadValores):
+ newArr2.append(newArrSorted[i][key])
+ res[key] = newArr2
+ #Si no tienen valores devolvemos el mismo diccionario:
+else:
+ #return dicc_par
+ print (dicc)
+ print (res)
+
+#dicc ={
+#'clave1':['c', 'a', 'b'],
+#'clave2':['casa', 'auto', 'barco'],
+#'clave3':[3,2,1]}
+# print (OrdenarDiccionario(dicc,"clave3",false))
+
+# ordenaDic (dicc, 'clave1')
\ No newline at end of file
diff --git a/Workbench/Taller/aritmetica.py b/Workbench/Taller/aritmetica.py
index 7fd04e8f3..ef449849a 100644
--- a/Workbench/Taller/aritmetica.py
+++ b/Workbench/Taller/aritmetica.py
@@ -1,4 +1,4 @@
-#print (3.5 // 4)
+print (3.5 // 3)
#print ("7"+"0")
#print (int("7"+"0")/2) #Este es un ejemplo de casteo
#print ( 2**1 / 12)
diff --git a/Workbench/Taller/listas.py b/Workbench/Taller/listas.py
index 964da9bd3..c50e047bf 100644
--- a/Workbench/Taller/listas.py
+++ b/Workbench/Taller/listas.py
@@ -209,8 +209,8 @@
# 2 Dos
# Ejemplo 21 - Caso: zip() con un argumento
-# Por definición, se puede hacer, porque ZIP está definido para un 'n' arbitrario
-# de listas, ergo, también es posible usar un único valor.
+# Por definición, se puede hacer, porque ZIP está definido para un 'n'
+# arbitrario de listas, ergo, también es posible usar un único valor.
# El resultado son tuplas de un elemento...raras, pero se puede.
numeros = [1, 2, 3, 4, 5]
@@ -218,10 +218,12 @@
print (list(zz)) # R=> [(1,), (2,), (3,), (4,), (5,)]
# Ejemplo 22 - Caso: zip() con diccionarios
-# Lo común es usar ZIP con listas, pero al estar definida para cualquier clase iterable.
+# Lo común es usar ZIP con listas, pero al estar definida para cualquier
+# clase iterable.
# Podemos usarla con DICCIONARIOS.
-# Por ejemplo, si (a,b) toman los valores de las key del diccionario, no parece muy interesante.
+# Por ejemplo, si (a,b) toman los valores de las key del diccionario, no parece
+# muy interesante.
esp = {'1': 'Uno', '2': 'Dos', '3': 'Tres'}
eng = {'1': 'One', '2': 'Two', '3': 'Three'}
@@ -311,7 +313,7 @@
print(mi_Cola) # R=> ('Diego', 'Luis', 'Jorge'])
# La lista restante en orden de llegada
-# Ejemplo 26 - Comprensión de listas . MUY IMPORTANTE ENTENDERLO BIEN !!
+# Ejemplo 26 - Listas por Comprensión . MUY IMPORTANTE ENTENDERLO BIEN !!
# Permite usar expresiones y condiciones para poblar una lista.
# Sus usos comunes son para hacer nuevas colecciones donde cada elemento es el resultado
# de algunas operaciones aplicadas a cada miembro de otra secuencia o iterable, o
diff --git a/Workbench/Taller/pruebaerror.ipynb b/Workbench/Taller/pruebaerror.ipynb
index a4c670a96..3c875a91e 100644
--- a/Workbench/Taller/pruebaerror.ipynb
+++ b/Workbench/Taller/pruebaerror.ipynb
@@ -537,22 +537,921 @@
},
{
"cell_type": "code",
- "execution_count": 148,
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from math import pi # Importamos una librería \"MATH\" que nos permite hacer cálculos científicos y usar constantes \n",
+ "pi_evol= [str(round(pi, i)) for i in range(1, 6)] # Creamos una lista con incrementales de pi\n",
+ "print ('Los valores incrementales de pi, son ', pi_evol)\n",
+ "# R=> Los valores incrementales de pi, son ['3.1', '3.14', '3.142', '3.1416', '3.14159']"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 149,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Persona():\n",
+ "\n",
+ " def __init__(self,nombre=\"\",edad=0,dni=\"\"):\n",
+ " self.nombre=nombre\n",
+ " self.edad=edad\n",
+ " self.dni=dni\n",
+ " \n",
+ " @property\n",
+ " def nombre(self):\n",
+ " return self.__nombre\n",
+ "\n",
+ " @property\n",
+ " def edad(self):\n",
+ " return self.__edad\n",
+ "\n",
+ " @property\n",
+ " def dni(self):\n",
+ " return self.__dni\n",
+ " \n",
+ " @nombre.setter\n",
+ " def nombre(self,nombre):\n",
+ " self.__nombre=nombre\n",
+ "\n",
+ " def validar_dni(self):\n",
+ " letras = \"TRWAGMYFPDXBNJZSQVHLCKE\"\n",
+ " if len(self.__dni)!=9:\n",
+ " print(\"DNI incorrecto\")\n",
+ " self.__dni = \"\"\n",
+ " else:\n",
+ " letra = self.__dni[8]\n",
+ " num = int(self.__dni[:8])\n",
+ " if letra.upper() != letras[num % 23]:\n",
+ " print(\"DNI incorrecto\")\n",
+ " self.__dni = \"\"\n",
+ "\n",
+ " @dni.setter\n",
+ " def dni(self,dni):\n",
+ " self.__dni=dni\n",
+ " self.validar_dni()\n",
+ " \n",
+ " @edad.setter\n",
+ " def edad(self,edad):\n",
+ " if edad < 0:\n",
+ " print(\"Edad incorrecta\")\n",
+ " self.__edad=0\n",
+ " else:\n",
+ " self.__edad=edad\n",
+ " \n",
+ " \n",
+ " def mostrar(self):\n",
+ " return \"Nombre:\"+self.nombre+\" - Edad:\"+str(self.edad)+\" - DNI:\"+self.dni\n",
+ "\n",
+ " def esMayorDeEdad(self):\n",
+ " return self.edad>=18\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def swap(a,b):\n",
+ " c=a\n",
+ " a=b\n",
+ " b=c\n",
+ " return (a,b)\n",
+ "\n",
+ "x = ['ab', 'cd','ef',5]\n",
+ "y = 4\n",
+ "print (x,y)\n",
+ "x,y= swap(x,y)\n",
+ "print (x,y)\n",
+ "print ()\n",
+ "\n",
+ "# caso 2) Directo y,x = x,y, propiedades de Python\n",
+ "# \n",
+ "x= 'diez'\n",
+ "y= True\n",
+ "print (x,y)\n",
+ "x,y=y,x\n",
+ "print (x,y)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Complex:\n",
+ " def __init__(self, realpart, imagpart):\n",
+ " self.r = realpart\n",
+ " self.i = imagpart\n",
+ "\n",
+ "x = Complex(3.0, -4.5)\n",
+ "x.r, x.i\n",
+ "print (type (x.r))\n",
+ "3.0, -4.5"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 171,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Emprendedor:\n",
+ " \"\"\"En esta clase se crean emprendedores\n",
+ " Recibe: str (nombre), str (apellido), list (libros), list (mascotas) \n",
+ " \"\"\"\n",
+ " mascotas = [] # Lista que acumulará las mascotas del Emprendedor\n",
+ " libros = [] # Lista que colectará los libros del Emprendedor\n",
+ " \n",
+ " def __init__(self, nombre, apellido, libros, mascotas):\n",
+ " self.nombre = nombre\n",
+ " self.apellido = apellido\n",
+ " self.libros = libros\n",
+ " self.mascotas = mascotas\n",
+ "\n",
+ "# b) Crear un Método que agregue una mascota (mascota) a la lista, no debe \n",
+ "# retornar nada. Mascotas es una lista\n",
+ "# \n",
+ "\n",
+ " def addMascotas (self, newPet): # Si el Empredendor tiene perro y gato, agregué una tortuga\n",
+ " self.mascotas.append(newPet) #\n",
+ "\n",
+ " def getmascotas (self): #\n",
+ " pass #\n",
+ "\n",
+ " def addBook (self, book, newautor): # El método addBook, recibe un str (book) y un str (autor)\n",
+ " self.libros.append(book) # Debe agregar un objeto DICT que recibe y guarda los parámetros\n",
+ " pass # dic = {nombre:book, autor:autor} \n",
+ " # No retorna nada\n",
+ "\n",
+ " def getCase (self): # Retorna qtty de mascotas que tiene el emprendedor\n",
+ " pass # Ej. Si tiene 2 mascotas, debe retornar 2\n",
+ " # Como es una lista, puedo hacer list.len(self.mascotas)\n",
+ "\n",
+ " def getBooks (self): # Debe retornar sólo los nombres de los libros\n",
+ " pass # Debería devolver ['El Señor de las Moscas', 'Fundación']\n",
+ "\n",
+ " \n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 401,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "Los valores incrementales de pi, son ['3.1', '3.14', '3.142', '3.1416', '3.14159']\n"
+ "la lista de primos es [5, 7, 11, 13]\n"
]
}
],
"source": [
- "from math import pi # Importamos una librería \"MATH\" que nos permite hacer cálculos científicos y usar constantes \n",
- "pi_evol= [str(round(pi, i)) for i in range(1, 6)] # Creamos una lista con incrementales de pi\n",
- "print ('Los valores incrementales de pi, son ', pi_evol)\n",
- "# R=> Los valores incrementales de pi, son ['3.1', '3.14', '3.142', '3.1416', '3.14159']"
+ "# LISTA PRIMOS\n",
+ "\n",
+ "def ListaPrimos(desde, hasta):\n",
+ " List_pri=[]\n",
+ " tope=hasta\n",
+ " n=desde\n",
+ " primo = True\n",
+ " if(type(n) != int):\n",
+ " return None\n",
+ " if(type(tope)!= int):\n",
+ " return None\n",
+ " while (n<=tope):\n",
+ " for div in range(2,n):\n",
+ " if(n%div==0):\n",
+ " primo=False\n",
+ " if (primo):\n",
+ " List_pri.insert(n-1,n)\n",
+ " else:\n",
+ " primo = True\n",
+ " n +=1\n",
+ " return List_pri\n",
+ "\n",
+ "imprime=ListaPrimos (5, 15)\n",
+ "print ('la lista de primos es',imprime)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 252,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'clave1': ['c', 'b', 'a'],\n",
+ " 'clave2': ['casa', 'barco', 'auto'],\n",
+ " 'clave3': [3, 2, 1]}"
+ ]
+ },
+ "execution_count": 252,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\n",
+ "# Esta función recibe como parámetro un diccionario, cuyas listas de valores tienen el mismo\n",
+ "# tamaño y sus elementos enésimos están asociados. Y otros dos parámetros que indican\n",
+ "# la clave por la cual debe ordenarse y si es descendente o ascendente.\n",
+ "# La función debe devolver el diccionario ordenado, teniendo en cuenta de no perder la\n",
+ "# relación entre los elementos enésimos.\n",
+ "# Recibe tres argumentos:\n",
+ "#\n",
+ "# diccionario: Diccionario a ordenar.\n",
+ "# clave: Clave del diccionario recibido, por la cual ordenar.\n",
+ "# descendente: Un valor booleano, que al ser verdadero indica ordenamiento ascendente y \n",
+ "# descendente si es falso. \n",
+ "# Debe tratarse de un parámetro por defecto en True.\n",
+ "# Si el parámetro diccionario no es un tipo de dato diccionario ó el parámetro clave no \n",
+ "# se encuentra dentro de las claves del diccionario, debe devolver nulo.\n",
+ "# Ej:\n",
+ "# dicc = {'clave1':['c','a','b'],\n",
+ "# 'clave2':['casa','auto','barco'],\n",
+ "# 'clave3':[1,2,3]}\n",
+ "#\n",
+ "# OrdenarDiccionario(dicc, 'clave1') debe retornar {'clave1':['a','b','c'],\n",
+ "# 'clave2':['auto','barco','casa'],\n",
+ "# 'clave3':[2,3,1]}\n",
+ "# OrdenarDiccionario(dicc, 'clave3', False) debe retornar {'clave1':['b','a','c'],\n",
+ "# 'clave2':['barco','auto','casa'],\n",
+ "# 'clave3':[3,2,1]}\n",
+ "#debe retornar\n",
+ "\n",
+ "# {'clave1':['b','a','c'], 'clave2':['barco','auto','casa'],'clave3':[3,2,1]}\n",
+ "# \n",
+ "dicc = {'clave1':['c','a','b'],\n",
+ " 'clave2':['casa','auto','barco'],\n",
+ " 'clave3':[1,2,3]}\n",
+ "\n",
+ "def OrdenarDiccionario(diccionario_par, clave, descendente=True):\n",
+ " listet = list(diccionario_par.keys())\n",
+ " #print = (listet)\n",
+ " for i in diccionario_par:\n",
+ " if i == clave:\n",
+ " for j in diccionario_par:\n",
+ " diccionario_par[j].sort()\n",
+ " if descendente == True:\n",
+ " diccionario_par[j].reverse()\n",
+ " \n",
+ " return diccionario_par\n",
+ " #return(print (listet))\n",
+ "\n",
+ "# print (dicc)\n",
+ "OrdenarDiccionario(dicc, 'clave1') \n",
+ "\n",
+ "#OrdenarDiccionario(dicc, 'clave3', False)\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Sin embargo, si usamos la función items del tipo DICT, podemos acceder\n",
+ "# al key y al value de cada elemento.\n",
+ "# Se puede facilitar para modificar valores usando, e.g casteo de dict a list y viceversa\n",
+ "#esp = {'1': 'Uno', '2': 'Dos', '3': 'Tres'}\n",
+ "#eng = {'1': 'One', '2': 'Two', '3': 'Three'}\n",
+ "\n",
+ "#for (k1, v1), (k2, v2) in zip(esp.items(), eng.items()):\n",
+ "# print(k1, v1, v2)\n",
+ "# Nótese que en este caso ambas key k1 y k2 son iguales.\n",
+ "# 1 Uno One\n",
+ "# 2 Dos Two\n",
+ "# 3 Tres Three\n",
+ "dicc = {'clave1':['c','a','b'],\n",
+ " 'clave2':['casa','auto','barco'],\n",
+ " 'clave3':[1,2,3]}\n",
+ "dicc_list = dicc.items()\n",
+ "dicc_list = list (dicc_list)\n",
+ "#print (dicc_items[1:3]) \n",
+ "k0 = ['clave1', 'clave2', 'clave3']\n",
+ "v1 = ['c', 'b', 'a']\n",
+ "v2 = ['casa', 'barco', 'auto']\n",
+ "v3 = [3, 2, 1]\n",
+ "i=1\n",
+ "#print(k0[0], v1[0], v2[0], v3[0])\n",
+ "#keyword=\n",
+ "#for i (k[i], v1), (k[i], v2), (k[i],v3) in dicc.items():\n",
+ "for i in dicc_list:\n",
+ " print(dicc_list(i), dicc_items.values(i), dicc_items.values(i), dicc_items.values(3))\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "valor=777\n",
+ "print (valor)\n",
+ "print ()\n",
+ "cadena=str(valor)\n",
+ "indice=-1\n",
+ "iguales=0\n",
+ "for x in range(0,len(cadena)/2):\n",
+ " if cadena[x]==cadena[indice]:\n",
+ " iguales=iguales+1\n",
+ " indice=indice-1\n",
+ "if iguales==(len(cadena)/2):\n",
+ " print ('Es capicua')\n",
+ "else:\n",
+ " print ('No es capicua')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "'''\n",
+ " En matemáticas, la palabra capicúa (del catalán cap i cua, 'cabeza y cola') \n",
+ " se refiere a cualquier número que se lee igual de izquierda a derecha que \n",
+ " de derecha a izquierda. Se denominan también números palíndromos.\n",
+ " Esta función devuelve el valor booleano True si el número es capicúa, de lo contrario\n",
+ " devuelve el valor booleano False \n",
+ " En caso de que el parámetro no sea de tipo entero, debe retornar nulo.\n",
+ " Recibe un argumento:\n",
+ " numero: Será el número sobre el que se evaluará si es capicúa o no lo es.\n",
+ " Ej:\n",
+ " NumeroCapicua(787) debe retornar True\n",
+ " NumeroCapicua(108) debe retornar False\n",
+ "'''\n",
+ "def NumeroCapicua(numero):\n",
+ " cadena3 = str(numero)\n",
+ " pali = []\n",
+ " pali2 = []\n",
+ " if type(numero) == int:\n",
+ " for i in range(len(cadena3) -1, -1, -1):\n",
+ " pali.append(cadena3[i])\n",
+ " for j in range(len(pali)-1, -1, -1):\n",
+ " pali2.append(pali[j])\n",
+ " if (pali == pali2):\n",
+ " return True\n",
+ " else:\n",
+ " return False\n",
+ " else:\n",
+ " return None\n",
+ " \n",
+ " \n",
+ "print (NumeroCapicua(92529))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# factorizar_numero(5)\n",
+ "# valor_esperado = [[5],[1]]\n",
+ "# \n",
+ "# factorizar_numero(1428)\n",
+ "# valor_esperado = [[2,3,7,17], [2,1,1,1]]\n",
+ "# \n",
+ "# factorizar_numero('cinco')\n",
+ "# valor_esperado = None\n",
+ "# \n",
+ "\n",
+ "def factorizar_numero(numero):\n",
+ " '''\n",
+ " Esta función recibe como parámetro un número entero mayor a cero y devuelva dos listas, \n",
+ " una con cada factor común y otra con su exponente, \n",
+ " esas dos listas tienen que estar contenidas en otra lista.\n",
+ " En caso de que el parámetro no sea de tipo entero y/ó mayor a cero debe retornar nulo.\n",
+ " Recibe un argumento:\n",
+ " numero: Será el número sobre el que se hará la factorización.\n",
+ " Ej:\n",
+ "\n",
+ " factorizar_numero(12) debe retornar [[2,3],[2,1]]\n",
+ " factorizar_numero(13) debe retornar [[13],[1]]\n",
+ " factorizar_numero(14) debe retornar [[2,7],[1,1]]\n",
+ " '''\n",
+ " lista_factores = []\n",
+ " lista_exponentes = []\n",
+ " if type(numero) == int:\n",
+ " #i= \n",
+ " while numero%2 != 1:\n",
+ " n=(i%2)\n",
+ " if n==1:\n",
+ " lista_i.append (i)\n",
+ " elif n==0:\n",
+ " lista_p.append (i)\n",
+ " print (\"Los números impares entre 1 y 10 son \", lista_i)\n",
+ " print (\"Los números pares entre 1 y 10 son \", lista_p)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def factoriza(n):\n",
+ " l = []\n",
+ " i = 2\n",
+ " while (i * i) <= n:\n",
+ " while (n % i) == 0:\n",
+ " l.append(i)\n",
+ " n = n / i\n",
+ " i = i + 1\n",
+ " if n != 1:\n",
+ " l.append(n)\n",
+ " return l\n",
+ "factoriza (10)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 414,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2\n"
+ ]
+ }
+ ],
+ "source": [
+ "print (27%5)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 406,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1\n",
+ "3\n",
+ "17\n",
+ "51\n"
+ ]
+ }
+ ],
+ "source": [
+ "#def divisores ():\n",
+ "num = int (input ('Escribe un entero'))\n",
+ "listaFC = []\n",
+ "i=1\n",
+ "while i<=num:\n",
+ " if num%i==0:\n",
+ " listaFC.append(num//i)\n",
+ " listaFC.sort()\n",
+ " i+=1\n",
+ "for f in listaFC:\n",
+ " print (f)\n",
+ " #, end=',')\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 376,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "La palabra ' 777 ' no es palíndroma e invertida, es []\n"
+ ]
+ }
+ ],
+ "source": [
+ "num = input ('Ingrese número _')\n",
+ "cadena3 = str(num)\n",
+ "cadena4 = \"reconocer\" # R=> 'reconocer', es palíndroma\n",
+ "pali = []\n",
+ "pali2 = []\n",
+ "if (num!=int):\n",
+ " print (\"La palabra\",\"'\", cadena3,\"'\", \"no es palíndroma e invertida, es\", pali, end=\"\") \n",
+ " \n",
+ "elif (nun>0):\n",
+ " for i in range(len(cadena3) -1, -1, -1):\n",
+ " pali.append(cadena3[i])\n",
+ " for j in range(len(pali)-1, -1, -1):\n",
+ " pali2.append(pali[j])\n",
+ " if (pali == pali2):\n",
+ " #return True\n",
+ " print(\"es palíndromo\")\n",
+ "else:\n",
+ " #return False\n",
+ " print (\"La palabra\",\"'\", cadena3,\"'\", \"no es palíndroma e invertida, es\", pali, end=\"\")\n",
+ "print()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 353,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[('Rojo', '4859-A', 'A'), ('Gris', '1892-B', 'M'), ('Azul', '2901-Z', 'M')]"
+ ]
+ },
+ "execution_count": 353,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "tuplas_coches = [\n",
+ " ('Rojo', '4859-A', 'A'),\n",
+ " ('Azul', '2901-Z', 'M'),\n",
+ " ('Gris', '1892-B', 'M')\n",
+ "]\n",
+ "ordenarpor='0'\n",
+ "\n",
+ "if ordenarpor == 0:\n",
+ "\n",
+ "sorted(tuplas_coches, key=itemgetter(2, 1))\n",
+ "#[('Rojo', '4859-A', 'A'), ('Gris', '1892-B', 'M'), ('Azul', '2901-Z', 'M')]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 335,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "['c', 'a', 'b']\n"
+ ]
+ }
+ ],
+ "source": [
+ "from operator import itemgetter\n",
+ "def OrdenarDiccionario(diccionario_par, clave, descendente=True):\n",
+ " dicc = {'clave1':['c','a','b'], 'clave2':['casa','auto','barco'], 'clave3':[1,2,3]}\n",
+ "\n",
+ " for n in sorted(dicc), str(\"clave1\"):\n",
+ " return n\n",
+ "\n",
+ "def ordenardiccionario2(self):\n",
+ " dicc = ['c','a','b']\n",
+ " for x in sorted(dicc, str(\"clave1\"), True):\n",
+ " return None\n",
+ " \n",
+ "def ordenardiccionario3(self): \n",
+ " dicc = {'clave1':['c','a','b'], 'clave2':['casa','auto','barco'], 'clave3':[3,1,2]}\n",
+ " for j in sorted(dicc, str(\"clave3\"), False):\n",
+ " return j\n",
+ "\n",
+ "OrdenarDiccionario(dicc, 'clave3') \n",
+ "print(dicc.get('clave1')) #Sara"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dicc = {\n",
+ " 'clave1':['c','a','b'],\n",
+ " 'clave2':['casa','auto','barco'],\n",
+ " 'clave3':[1,2,3]\n",
+ " }\n",
+ "bykey=dicc.keys () # Guardo las llaves en una var\n",
+ "keyord='clave1' # Guardo la la clave por la que quiero ordenar\n",
+ "# sorted_bykey={}\n",
+ "# print (bykey)\n",
+ "# sorted_bykey=sorted(bykey)\n",
+ "# print (sorted_bykey)\n",
+ "# sorted_bykey={}\n",
+ "#for\n",
+ "dic_ord_by_key = sorted(dicc, key=keyord)\n",
+ "print (\"Ordenada por calificación ascendente: \")\n",
+ "for algo in dic_ord_by_key:\n",
+ " print (keyword)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 275,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "{'clave1': ['c', 'a', 'b'], 'clave2': ['casa', 'auto', 'barco'], 'clave3': [1, 2, 3]}\n"
+ ]
+ }
+ ],
+ "source": [
+ "dicc = {\n",
+ " 'clave1':['c','a','b'],\n",
+ " 'clave2':['casa','auto','barco'],\n",
+ " 'clave3':[1,2,3]\n",
+ " }\n",
+ "\n",
+ "#for x in dicc:\n",
+ "# print(dicc[x])\n",
+ "# ['c', 'a', 'b']\n",
+ "# ['casa', 'auto', 'barco']\n",
+ "# [1, 2, 3]\n",
+ "print(dicc)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 325,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "{'clave1': ['c', 'a', 'b'], 'clave2': ['casa', 'auto', 'barco'], 'clave3': [1, 2, 3]}\n"
+ ]
+ }
+ ],
+ "source": [
+ "key_list = ['clave1', 'clave2', 'clave3']\n",
+ "value_list1 = [['c', 'a', 'b'], ['casa', 'auto', 'barco'], [1, 2, 3]]\n",
+ "\n",
+ "# ['c', 'a', 'b']\n",
+ "# ['casa', 'auto', 'barco']\n",
+ "# [1, 2, 3]\n",
+ "dict_from_list = dict(zip(key_list, value_list1))\n",
+ "print(dict_from_list)\n",
+ "# {'clave1':['b','a','c'], 'clave2':['barco','auto','casa'],'clave3':[3,2,1]}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 330,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "{'nombre': 'Juan', 'edad': '27', 'ciudad': 'Nueva York'}\n"
+ ]
+ }
+ ],
+ "source": [
+ "key_list = ['clave1', 'clave2', 'clave3']\n",
+ "value_list = ['Juan', '27', 'Nueva York']\n",
+ "\n",
+ "dict_from_list = {k: v for k, v in zip(key_list, value_list)}\n",
+ "print(dict_from_list)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def sum (a,b):\n",
+ " return 'Null'\n",
+ " \n",
+ "sum (2,3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n",
+ "dicc = {\n",
+ " 'clave1':['c','a','b'],\n",
+ " 'clave2':['casa','auto','barco'],\n",
+ " 'clave3':[1,2,3]\n",
+ " }\n",
+ "varkeys=len()\n",
+ "\n",
+ "if len(varkeys[list(dicc.keys()]>0) \n",
+ "\tvalores=len(dicc_par[list(dicc_par.keys())[0]])\n",
+ "# convertimos el diccionario de listas, a una lista de diccionarios:\t\n",
+ "\tfor i in range(0, valores):\n",
+ "\t\tnewObj[key] = dicc_par[key][i]\n",
+ "\tnewArr.append(newObj)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dicc ={\n",
+ "'clave1':['c', 'a', 'b'],\n",
+ "'clave2':['casa', 'auto', 'barco'],\n",
+ "'clave3':[3,2,1]}\n",
+ "dicc_swp= {} # Recibe dic transitorios no ordenados, ver si es lista o no\n",
+ "dicc_ord= {} # Recibe el nuevo dic ordenado \n",
+ "listkeys =list(dicc.keys())\n",
+ "listvalues = list(dicc.values())\n",
+ "print (listvalues)\n",
+ "print (type(listkeys))\n",
+ "print (len(listkeys)) # List horz de las keys\n",
+ "print (listkeys) # Ahora sabemos cuantos elementos tiene\n",
+ "for k in listkeys:\n",
+ " print (k)\n",
+ "for v in listvalues:\n",
+ " print (v)\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 324,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Ord1= [('Gris', '1892-B', 'M'), ('Azul', '2901-Z', 'M'), ('Rojo', '4859-A', 'A')]\n",
+ "Ord2= [{'color': 'Gris', 'matricula': '1892-B', 'cambio': 'M'}, {'color': 'Azul', 'matricula': '2901-Z', 'cambio': 'M'}, {'color': 'Rojo', 'matricula': '4859-A', 'cambio': 'A'}]\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Ordenar una lista de coches almacenados como tuplas\n",
+ "tuplas_coches = [\n",
+ " ('Rojo', '4859-A', 'A'),\n",
+ " ('Azul', '2901-Z', 'M'),\n",
+ " ('Gris', '1892-B', 'M')\n",
+ " ]\n",
+ "\n",
+ "# Ordenar los coches por matrícula\n",
+ "ordenados1 = sorted(tuplas_coches, key=lambda coche : coche[1])\n",
+ "print ('Ord1=', ordenados1)\n",
+ "# [('Gris', '1892-B', 'M'), ('Azul', '2901-Z', 'M'), ('Rojo', '4859-A', 'A')]\n",
+ "\n",
+ "# Ordenar una lista de coches almacenados como diccionarios\n",
+ "diccionarios_coches = [\n",
+ " {'color': 'Rojo', 'matricula': '4859-A', 'cambio': 'A'},\n",
+ " {'color': 'Azul', 'matricula': '2901-Z', 'cambio': 'M'},\n",
+ " {'color': 'Gris', 'matricula': '1892-B', 'cambio': 'M'}\n",
+ "]\n",
+ "ordenados2 = sorted (diccionarios_coches, key=lambda coche : coche['matricula'])\n",
+ "print ('Ord2=', ordenados2)\n",
+ "# [{'color': 'Gris', 'matricula': '1892-B', 'cambio': 'M'}, \n",
+ "# {'color': 'Azul', 'matricula': '2901-Z', 'cambio': 'M'}, \n",
+ "# {'color': 'Rojo', 'matricula': '4859-A', 'cambio': 'A'}]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 281,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "este es el dicc ordenado por la clave X {'clave1': ['b', 'a', 'c'], 'clave2': ['barco', 'auto', 'casa'], 'clave3': [3, 2, 1]}\n"
+ ]
+ }
+ ],
+ "source": [
+ "dicc={'midic':('a',b'')}\n",
+ "if type(diccionario_pa) != dict:\n",
+ " if type(get)\n",
+ " return None\n",
+ "dicc2={'clave1':['b','a','c'], 'clave2':['barco','auto','casa'],'clave3':[3,2,1]}\n",
+ "print ('este es el dicc ordenado por la clave X', dicc2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "juegos = [\n",
+ " {\n",
+ " \"nombre\": \"Resident Evil 2\",\n",
+ " \"calificacion\": 99,\n",
+ " },\n",
+ " {\n",
+ " \"nombre\": \"Crash Bandicoot N. Sane Trilogy\",\n",
+ " \"calificacion\": 76,\n",
+ " },\n",
+ "\n",
+ " {\n",
+ " \"nombre\": \"Cuphead\",\n",
+ " \"calificacion\": 100,\n",
+ " },\n",
+ " {\n",
+ " \"nombre\": \"Minecraft\",\n",
+ " \"calificacion\": 80,\n",
+ " },\n",
+ " {\n",
+ " \"nombre\": \"Bioshock\",\n",
+ " \"calificacion\": 95,\n",
+ " },\n",
+ "]\n",
+ "def funcion_que_devuelve_clave(juego):\n",
+ " # Vamos a ordenar basándonos en su calificación, y como se nos\n",
+ " # va a pasar un diccionario, devolvemos el elemento \"calificacion\"\n",
+ " return juego[\"calificacion\"]\n",
+ "\n",
+ "# La ordenamos\n",
+ "juegos_ordenados = sorted(juegos, key=funcion_que_devuelve_clave)\n",
+ "print(\"Ordenada por calificación ascendente: \")\n",
+ "for juego in juegos_ordenados:\n",
+ " print(juego)\n",
+ "# También se puede en orden inverso\n",
+ "juegos_ordenados = sorted(juegos, key=funcion_que_devuelve_clave, reverse=True)\n",
+ "print(\"Ordenada por calificación descendente: \")\n",
+ "\n",
+ "for juego in juegos_ordenados:\n",
+ " print(juego)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 250,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "nuemero e claves 6\n",
+ "{'clave1': 1.97, 'clave2': 8.49, 'clave3': 9.79, 'clave4': 1.2, 'clave5': 0.43, 'clave6': ['a', 'b', 'c']}\n"
+ ]
+ }
+ ],
+ "source": [
+ "clients = {'clave1': 1.97,\n",
+ " 'clave2': 8.49,\n",
+ " 'clave3': 9.79,\n",
+ " 'clave4': 8.53,\n",
+ " 'clave5': 0.43}\n",
+ "\n",
+ "dicc = {'clave1':['c','a','b'],\n",
+ " 'clave2':['casa','auto','barco'],\n",
+ " 'clave3':[1,2,3]}\n",
+ "\n",
+ "clients ['clave1']\n",
+ "clients ['clave4'] = 1.20\n",
+ "clients ['clave6'] = ['a', 'b', 'c']\n",
+ "# print (clients)\n",
+ "#for idx in enumerate (clients): # Creo una variable cualquiera\n",
+ "# print (idx[0], 'ha gastado', clients[idx[1]]) # \"algo\" para recorrer clients\n",
+ "#clients_sort=sorted(clients)\n",
+ "orden = len (clients.keys())\n",
+ "print ('nuemero e claves', orden)\n",
+ "print (clients) #\n",
+ " \n",
+ " \n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 232,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "{'clave1': 1.97, 'clave2': 8.49, 'clave3': 9.79, 'clave4': 8.53, 'clave5': 0.43}\n",
+ "{'clave1': 1.97, 'clave2': 8.49, 'clave3': 9.79, 'clave4': 8.53, 'clave5': 0.43, 'clave6': ['a', 'b', 'c']}\n"
+ ]
+ }
+ ],
+ "source": [
+ "clients = {'clave1': 1.97,\n",
+ " 'clave2': 8.49,\n",
+ " 'clave3': 9.79,\n",
+ " 'clave4': 8.53,\n",
+ " 'clave5': 0.43}\n",
+ "print (clients)\n",
+ "clients ['clave6']= ['a','b','c']\n",
+ "print (clients)\n"
]
}
],
diff --git a/Workbench/Taller/variables.py b/Workbench/Taller/variables.py
index bfd2c9c5b..feb9d0f3f 100644
--- a/Workbench/Taller/variables.py
+++ b/Workbench/Taller/variables.py
@@ -9,3 +9,26 @@
print (a+b)
total =2+4
print (total)
+# Ejemplo 10 - SWAP de variable - Deben ser del mismo tipo (INT)
+# caso 1) Creamos una Función
+
+def swap(a,b):
+ c=a
+ a=b
+ b=c
+ return a,b
+
+x = 5
+y = 4
+print (x,y)
+x,y= swap(x,y)
+print (x,y)
+print ()
+
+# caso 2) Directo y,x = x,y, propiedades de Python
+#
+x=10
+y=20
+print (x,y)
+x,y=y,x
+print (x,y)
\ No newline at end of file
From 02a9c8789d6da70f66a8ab6384442057d8757728 Mon Sep 17 00:00:00 2001
From: Jorge Cordova <55065873+jcordovaj@users.noreply.github.com>
Date: Sat, 28 Jan 2023 13:58:51 -0300
Subject: [PATCH 12/16] 28011358-Prueba Sync
---
Workbench/Taller/EjMix_DicLis.py | 446 +++++++++++++++++++++++++++++
Workbench/Taller/HC280123.ipynb | 302 +++++++++++++++++++
Workbench/Taller/pruebaerror.ipynb | 291 ++++++++-----------
3 files changed, 872 insertions(+), 167 deletions(-)
create mode 100644 Workbench/Taller/EjMix_DicLis.py
create mode 100644 Workbench/Taller/HC280123.ipynb
diff --git a/Workbench/Taller/EjMix_DicLis.py b/Workbench/Taller/EjMix_DicLis.py
new file mode 100644
index 000000000..e3ff8a747
--- /dev/null
+++ b/Workbench/Taller/EjMix_DicLis.py
@@ -0,0 +1,446 @@
+# Importante: No modificar ni el nombre ni los argumetos que reciben las funciones, sólo deben escribir
+# código dentro de las funciones ya definidas.
+
+def ListaDivisibles(numero, tope):
+ '''
+ Esta función devuelve una lista ordenada de menor a mayor con los números divisibles
+ por el parámetro número entre uno (1) y el valor del parámetro "tope"
+ Recibe dos argumentos:
+ numero: Numero entero divisor
+ tope: Máximo valor a evaluar a partir de uno (1)
+ Ej:
+ ListaDivisibles(6,30) debe retornar [6,12,18,24,30]
+ ListaDivisibles(10,5) debe retornar []
+ ListaDivisibles(7,50) debe retornar [7,14,21,28,35,42,49]
+ '''
+ #Tu código aca:
+ lista_rango = list(range(numero,tope+1))
+ lista_num_divisibles = []
+
+ if numero > tope:
+ print(lista_num_divisibles)
+ return lista_num_divisibles
+ if numero <= 0:
+ print(str(numero) + ', que corresponde a ser el divisor, NO puede ser = 0.')
+ return None
+
+ for i in lista_rango:
+ if (i % numero) == 0:
+ lista_num_divisibles.append(i)
+ lista_num_divisibles.sort(reverse=False)
+ print(lista_num_divisibles)
+ return lista_num_divisibles
+
+#ListaDivisibles(6,30)
+#ListaDivisibles(10,5)
+#ListaDivisibles(7,50)
+
+#O.K. - Revisado y testeado!
+
+
+def Exponente(numero, exponente):
+ '''
+ Esta función devuelve el resultado de elevar el parámetro "numero" al parámetro "exponente"
+ Recibe dos argumentos:
+ numero: El número base en la operación exponencial
+ exponente: El número exponente en la operación exponencial
+ Ej:
+ Exponente(10,3) debe retornar 1000
+ '''
+ #Tu código aca:
+ exponente = numero**exponente
+ print(exponente)
+ return exponente
+
+#Exponente(10,3)
+
+#O.K. - Revisado y testeado!
+
+
+def ListaDeListas(lista):
+ '''
+ Esta función recibe una lista, que puede contener elementos que a su vez sean listas y
+ devuelve esos elementos por separado en una lista única.
+ En caso de que el parámetro no sea de tipo lista, debe retornar nulo. Listo!
+ Recibe un argumento:
+ lista: La lista que puede contener otras listas y se convierte a una
+ lista de elementos únicos o no iterables.
+ Ej:
+ ListaDeListas([1,2,['a','b'],[10]]) debe retornar [1,2,'a','b',10]
+ ListaDeListas(108) debe retornar el valor nulo.
+ ListaDeListas([[1,2,[3]],[4]]) debe retornar [1,2,3,4]
+ '''
+ #Tu código aca:
+ listaplana = list()
+
+ if type(lista) != list:
+ print('No es una lista.')
+ return None
+
+ for elemento in lista:
+ if type(elemento) != list:
+ listaplana.append(elemento)
+ if type(elemento) == list:
+ for elemento2 in list(elemento):
+ if type(elemento2) != list:
+ listaplana.append(elemento2)
+ if type(elemento2) == list:
+ listaplana.extend(ListaDeListas(elemento2))
+
+
+
+ print(listaplana)
+ return listaplana
+
+
+#ListaDeListas([1,2,['a','b'],[10]])
+#ListaDeListas(108)
+#ListaDeListas([[1,2,[3]],[4]])
+#ListaDeListas([[1,2,[3,[6,6,6,[7,[['iri'],8,9,[11]],],6,6]]],[4]]) #extra prueba
+
+
+def Factorial(numero):
+ '''
+ Esta función devuelve el factorial del número pasado como parámetro.
+ En caso de que no sea de tipo entero y/o sea menor que 0, debe retornar nulo. ok
+ Recibe un argumento:
+ numero: Será el número con el que se calcule el factorial
+ Ej:
+ Factorial(4) debe retornar 24
+ Factorial(-2) debe retornar nulo
+ Factorial(0) debe retornar 1
+ '''
+ #Tu código aca:
+ if (type(numero) != int) or (numero < 0):
+ print('El numero no pertence a los enteros positivos.')
+ return None
+
+ import math
+
+ factorial = math.factorial(numero)
+ print(factorial)
+ return factorial
+
+#Factorial(9)
+#Factorial(4)
+#Factorial(-2)
+#Factorial(0)
+
+# O.K. tested & ok
+
+
+def ListaPrimos(desde, hasta):
+ '''
+ Esta función devuelve una lista con los números primos entre los valores "desde" y "hasta"
+ pasados como parámetro, siendo ambos inclusivos.
+
+ En caso de que alguno de los parámetros no sea de tipo entero y/o no sea mayor a cero,
+ debe retornar nulo. ok
+
+ En caso de que el segundo parámetro sea mayor al primero, pero ambos mayores que cero,
+ debe retornar una lista vacía. ok
+
+ Recibe un argumento:
+ desde: Será el número a partir del cual se toma el rango
+ hasta: Será el número hasta el cual se tome el rango
+
+ Ej:
+ ListaPrimos(7,15) debe retornar [7,11,13]
+ ListaPrimos(100,99) debe retornar []
+ ListaPrimos(1,7) debe retonan [1,2,3,5,7]
+ '''
+ #Tu código aca:
+
+ # 1. En caso de que alguno de los parámetros no sea de tipo entero y/o no sea mayor a cero,
+ # debe retornar nulo.
+
+ if(type(desde or hasta) != int) or ((desde or hasta) < 0):
+ print('Valores no son enteros reales positivos.')
+ return None
+
+ # 2. En caso de que el segundo parámetro sea mayor al primero, pero ambos mayores que cero,
+ # debe retornar una lista vacía.
+ # entiendo que hay un error en la consigna, si no deberíamos utilizar valores absolutos ya que la cuenta seria regresiva en -1, -2, -3 etc
+ # y supongo que lo que no quiere es que hagamos esto. obtener un desplazamiento negatico coodenada final(hasta) menos inicial(desde)..
+
+ if desde > hasta:
+ print('Parametros incorrectos.El valor "desde" debe ser menor que "hasta".')
+ return []
+
+
+ # 3. Esta función devuelve una lista con los números primos entre los valores "desde" y "hasta"
+ # pasados como parámetro, siendo ambos inclusivos.
+
+ # 3.1 Desde" y "hasta" pasados como parámetro, siendo ambos inclusivos.
+
+ lista_a_analizar = range(desde,hasta+1)
+ lista_ya_analizados = []
+ es_primo = True
+ lista_primos = []
+ import math
+
+ for elemento in lista_a_analizar:
+ for i in range(2,elemento):
+ if (elemento % i == 0):
+ es_primo = False
+ break
+ else:
+ es_primo = True
+ lista_primos.append(elemento)
+ break
+
+ print(lista_primos)
+ return lista_primos
+
+#ListaPrimos(7,15)
+#ListaPrimos(100,99)
+#ListaPrimos(1,7)
+#ListaPrimos(4,150) #prueba extra
+
+# O.K. tested & Chequed!
+
+
+
+
+
+def ListaRepetidos(lista):
+ '''
+ Esta función recibe como parámetro una lista y devuelve una lista de tuplas donde cada
+ tupla contiene un valor de la lista original y las veces que se repite. Los valores
+ de la lista original no deben estar repetidos.
+ Debe respetarse el orden original en el que aparecen los elementos.
+
+ En caso de que el parámetro no sea de tipo lista debe retornar nulo. ok
+
+ Recibe un argumento:
+ lista: Será la lista que se va a evaluar.
+ Ej:
+ ListaRepetidos([]) debe retornar []
+ ListaRepetidos(['hola', 'mundo', 'hola', 13, 14])
+ debe retornar [('hola',2),('mundo',1),(13,1),(14,1)]
+ ListaRepetidos([1,2,2,4]) debe retornar [(1,1),(2,2),(4,1)]
+ '''
+ #Tu código aca:
+
+ # 1. Esta función recibe como parámetro una lista ; En caso de que el parámetro no sea de tipo lista debe retornar nulo. ok
+ if type(lista) != list:
+ print('El parámetro ingresado no es una Lista.')
+ return None
+
+ # 2. Devuelve una lista de tuplas donde cada
+ # tupla contiene un valor de la lista original y las veces que se repite.
+ # Los valores de la lista original no deben estar repetidos.
+ # Debe respetarse el orden original en el que aparecen los elementos.
+ lista_ya_analizados = list()
+ for elemento in lista:
+ if (type(elemento) != list):
+
+ if (elemento not in lista_ya_analizados):
+ lista_ya_analizados.append(elemento)
+ else:
+ pass
+
+ if type(elemento) == list:
+ ListaRepetidos(elemento)
+ print('Lista de elementos unicos encontrados:')
+ print(lista_ya_analizados)
+
+ lista_cant_de_repeticiones = []
+
+ for elemento2 in lista_ya_analizados:
+ cantidad_de_repes_del_elemento2 = lista.count(elemento2)
+ lista_cant_de_repeticiones.append(cantidad_de_repes_del_elemento2)
+
+ print(lista_cant_de_repeticiones)
+
+ #conversion a tupla
+ respuesta = list(zip (lista_ya_analizados,lista_cant_de_repeticiones))
+ print(respuesta)
+ return respuesta
+
+
+#ListaRepetidos([])
+#ListaRepetidos(['hola', 'mundo', 'hola', 13, 14])
+#ListaRepetidos([1,2,2,4])
+#ListaRepetidos(ListaDeListas([1,[2,3,4,2,['l','k','j'],1,'q','w',],2,2,4,])) #extra prueba
+
+# O.K. Tested ok chequed
+
+
+
+def ClaseVehiculo(tipo, color):
+ '''
+ Esta función devuelve un objeto instanciado de la clase Vehiculo,
+ la cual debe tener los siguientes atributos:
+
+ Tipo: Un valor dentro de los valores posibles: ['auto','camioneta','moto']
+ Color: Un valor de tipo de dato string.
+ Velocidad: Un valor de tipo de dato float, que debe inicializarse en cero.
+
+ y debe tener el siguiente método:
+
+ Acelerar(): Este método recibe un parámetro con el valor que debe incrementar a la
+ propiedad Velocidad y luego retornarla.
+ Si la propiedad Velocidad cobra un valor menor a cero, debe quedar en cero.
+ Si la propiedad Velocidad cobra un valor mayor a cien, debe quedar en cien.
+
+ Recibe dos argumento:
+ tipo: Dato que se asignará al atributo Tipo del objeto de la clase Vehiculo
+ color: Dato que se asignará al atributo Color del objeto de la clase Vehiculo
+
+ Ej:
+ a = ClaseVehículo('auto','gris')
+ a.Acelerar(10) -> debe devolver 10
+ a.Acelerar(15) -> debe devolver 25
+ a.Acelerar(-10) -> debe devolver 15
+ '''
+ #Tu código aca:
+ lista_tipos_permitidos = ['auto','camioneta','moto']
+
+ # Validaciones al crear la CLASE:
+
+ if tipo not in lista_tipos_permitidos:
+ print('Error al crear la clase, este tipo de vehiculo no se permite crear, solo estos se pueden: ("auto", "camioneta", "moto").')
+ print('Error al crear vehiculo.')
+ return None
+
+ if type(color) != str:
+ print('El dato "color" no es un str.')
+ print('Error al crear vehiculo.')
+ return None
+
+ tipo = tipo
+ color = color
+
+ # Creando un vehiculo
+ # Para ello debe existir primero la clase dentro de la funcion.
+ # de manera que siempre exista dentro del paquete de la funcion si esta se exporta.
+ class Vehicle:
+ '''
+ Clase Veiculos dentro de funcion crear vehiculo.
+ '''
+ def __init__(self,tipo,color,velocidad = float(0)):
+
+ self.tipo = tipo
+ self.color = color
+ self.velocidad = float()
+ self.incremento_velocidad = float(0)
+
+ def Acelerar(self,incremento_velocidad = float(0)):
+ """
+ Este método recibe un parámetro con el valor que debe incrementar a la
+ propiedad Velocidad y luego retornarla.
+
+ Si la propiedad Velocidad cobra un valor menor a cero, debe quedar en cero.
+
+ Si la propiedad Velocidad cobra un valor mayor a cien, debe quedar en cien.
+ """
+ velocidad_inicial = self.velocidad
+ velocidad_final = velocidad_inicial + incremento_velocidad
+
+ if velocidad_final > 100:
+ velocidad_final = 100
+ self.velocidad = velocidad_final
+ return self.velocidad
+ elif velocidad_final < 0:
+ velocidad_final = 0
+ self.velocidad = velocidad_final
+ return self.velocidad
+ else:
+ self.velocidad = velocidad_final
+ return self.velocidad
+
+ def PropiedadesDelVehiculo(self,tipo,color,velocidad):
+ print(tipo)
+ print(color)
+ print(velocidad)
+ return tipo , color, velocidad
+
+ vehiculo_creado = Vehicle(tipo,color)
+ return vehiculo_creado
+
+#a = ClaseVehiculo('auto','gris')
+#print(a)
+#print(a.Acelerar(10))
+#print(a.Acelerar(15))
+#print(a.Acelerar(-10))
+
+# O.K. tested ok checked
+
+
+
+def OrdenarDiccionario(diccionario_par, clave, descendente=bool(True)):
+ '''
+ Esta función recibe como parámetro un diccionario,
+ cuyas listas de valores tienen el mismo tamaño y
+ sus elementos enésimos están asociados.
+
+ Y otros dos parámetros que indicanla clave por la cual debe ordenarse y si es descendente o ascendente.
+
+ La función debe devolver el diccionario ordenado, teniendo en cuenta de no perder la
+ relación entre los elementos enésimos.
+
+ Recibe tres argumentos:
+ diccionario: Diccionario a ordenar.
+ clave: Clave del diccionario recibido, por la cual ordenar.
+ descendente: Un valor booleano, que al ser verdadero indica ordenamiento ascendente y
+ descendente si es falso.
+ Debe tratarse de un parámetro por defecto en True.
+
+ Si el parámetro diccionario no es un tipo de dato diccionario ok
+ ó el parámetro clave no se encuentra dentro de las claves del diccionario, debe devolver nulo. ok
+
+ Ej:
+
+ dicc = {'clave1':['c','a','b'],
+ 'clave2':['casa','auto','barco'],
+ 'clave3':[1,2,3]}
+ OrdenarDiccionario(dicc, 'clave1') debe retornar {'clave1':['a','b','c'],
+ 'clave2':['auto','barco','casa'],
+ 'clave3':[2,3,1]}
+ OrdenarDiccionario(dicc, 'clave3', False) debe retornar {'clave1':['b','a','c'],
+ 'clave2':['barco','auto','casa'],
+ 'clave3':[3,2,1]}
+ '''
+ #Tu código aca:
+
+
+ # Si el parámetro diccionario no es un tipo de dato diccionario
+ # ó el parámetro clave no se encuentra dentro de las claves del diccionario, debe devolver nulo.
+
+ if (type(diccionario_par) != dict) | (clave not in diccionario_par):
+ print('El parámetro recibido como diccionario, no lo es en cuanto a tipo de dato.')
+ print('O la clave ingresada no se encuentra dentro de las claves posivbles del diccionario.')
+ return None
+
+ # valido longitud en ambas deirecciones de la matriz diccionario:
+ #cantidadd de claves como de elementos, a su vez, dentro de las claves.')
+
+ """
+ dicc = { 'clave1': ['c','a','b'],
+ 'clave2': ['casa','auto','barco'],
+ 'clave3': [1,2,3]}
+
+ OrdenarDiccionario(dicc, 'clave1')
+ """
+
+
+ for i in diccionario_par:
+ if i == clave:
+ for j in diccionario_par:
+ if descendente == False:
+ diccionario_par[j].sort()
+ if descendente == True:
+ diccionario_par[j].sort(reverse=True)
+
+
+ print(diccionario_par)
+ return diccionario_par
+
+
+# OrdenarDiccionario(dicc, 'clave3',True)
+# OrdenarDiccionario(dicc, 'clave3',False)
+# OrdenarDiccionario(dicc, 'clave1',True)
+#OrdenarDiccionario(dicc, 'clave4',False)
+
+#checked OK. tested OK.
\ No newline at end of file
diff --git a/Workbench/Taller/HC280123.ipynb b/Workbench/Taller/HC280123.ipynb
new file mode 100644
index 000000000..552712320
--- /dev/null
+++ b/Workbench/Taller/HC280123.ipynb
@@ -0,0 +1,302 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[3, 6, 9]\n"
+ ]
+ }
+ ],
+ "source": [
+ "# LISTA DIVISIBLES\n",
+ "\n",
+ "# ListaDivisibles(12, 10)\n",
+ "# lista_esperada = []\n",
+ "\n",
+ "# ListaDivisibles(12, 100)\n",
+ "# lista_esperada = [12,24,36,48,60,72,84,96]\n",
+ "\n",
+ "# ListaDivisibles(3, 9)\n",
+ "# lista_esperada = [3,6,9]\n",
+ "\n",
+ "def ListaDivisibles(numero, tope):\n",
+ " '''\n",
+ " Esta función devuelve una lista ordenada de menor a mayor con los números divisibles \n",
+ " por el parámetro número entre uno (1) y el valor del parámetro \"tope\"\n",
+ " Recibe dos argumentos:\n",
+ " numero: Numero entero divisor\n",
+ " tope: Máximo valor a evaluar a partir de uno (1)\n",
+ " Ej:\n",
+ " ListaDivisibles(6,30) debe retornar [6,12,18,24,30]\n",
+ " ListaDivisibles(10,5) debe retornar []\n",
+ " ListaDivisibles(7,50) debe retornar [7,14,21,28,35,42,49]\n",
+ " '''\n",
+ " #Tu código aca:\n",
+ " lint = list(range(numero,tope+1))\n",
+ " ldiv = []\n",
+ " \n",
+ " if numero > tope:\n",
+ " print(ldiv)\n",
+ " return ldiv\n",
+ " if numero <= 0:\n",
+ " print(str(numero) + ', que corresponde a ser el divisor, NO puede ser = 0.')\n",
+ " return None\n",
+ " for i in lint:\n",
+ " if (i % numero) == 0:\n",
+ " ldiv.append(i)\n",
+ " ldiv.sort(reverse=False)\n",
+ " print(ldiv) \n",
+ " return ldiv\n",
+ " \n",
+ "lista_divisible=ListaDivisibles(3, 9)\n",
+ " # 12, 10 []\n",
+ " # 12. 100 [12,24,36,48,60,72,84,96]\n",
+ " # 3, 9 [3,6,9]\n",
+ "\n",
+ "# Test OK!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1000"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Exponente(10, 2)\n",
+ "# valor_esperado = 100\n",
+ "# Exponente(49, 0.5)\n",
+ "# valor_esperado = 7\n",
+ "# Exponente(3, 0)\n",
+ "# valor_esperado = 1\n",
+ " \n",
+ "def Exponente(numero, exponente):\n",
+ " '''\n",
+ " Esta función devuelve el resultado de elevar el parámetro \"numero\" al parámetro \"exponente\"\n",
+ " Recibe dos argumentos:\n",
+ " numero: El número base en la operación exponencial\n",
+ " exponente: El número exponente en la operación exponencial\n",
+ " Ej:\n",
+ " Exponente(10,3) debe retornar 1000\n",
+ " '''\n",
+ " #Tu código aca:\n",
+ " res=numero**exponente\n",
+ " return res\n",
+ "Exponente(10,3)\n",
+ "\n",
+ "# Test OK!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[1, 2, 3]"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "#\n",
+ "def ListaDeListas(lista):\n",
+ " '''\n",
+ " Esta función recibe una lista, que puede contener elementos que a su vez sean listas y\n",
+ " devuelve esos elementos por separado en una lista única. \n",
+ " En caso de que el parámetro no sea de tipo lista, debe retornar nulo.\n",
+ " Recibe un argumento:\n",
+ " lista: La lista que puede contener otras listas y se convierte a una \n",
+ " lista de elementos únicos o no iterables.\n",
+ " Ej:\n",
+ " ListaDeListas([1,2,['a','b'],[10]]) debe retornar [1,2,'a','b',10]\n",
+ " ListaDeListas(108) debe retornar el valor nulo.\n",
+ " ListaDeListas([[1,2,[3]],[4]]) debe retornar [1,2,3,4]\n",
+ " '''\n",
+ " #Tu código aca:\n",
+ " if type(lista) != list:\n",
+ " return None\n",
+ " else:\n",
+ " lista_final=[]\n",
+ " for elem in lista:\n",
+ " if isinstance(elem, list):\n",
+ " lista_final.extend(ListaDeListas(elem))\n",
+ " else:\n",
+ " lista_final.append(elem)\n",
+ " return lista_final\n",
+ "ListaDeListas ([[[1]],2,[[[[3]]]]])\n",
+ "# ListaDeListas(100)\n",
+ "# lista_esperada = None\n",
+ "# # ListaDeListas([1,[2,3],[[4,5],6],[[7]]])\n",
+ "# lista_esperada = [1,2,3,4,5,6,7]\n",
+ "# # ListaDeListas(['a','b',1,2,['a1','b3'],[['a'],2]])\n",
+ "# lista_esperada = ['a','b',1,2,'a1','b3','a',2]\n",
+ "# # ListaDeListas([[[1]],2,[[[[3]]]]])\n",
+ "# lista_esperada = [1,2,3] \n",
+ "# Test OK!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "362880"
+ ]
+ },
+ "execution_count": 22,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "def Factorial(numero):\n",
+ " '''\n",
+ " Esta función devuelve el factorial del número pasado como parámetro.\n",
+ " En caso de que no sea de tipo entero y/o sea menor que 0, debe retornar nulo.\n",
+ " Recibe un argumento:\n",
+ " numero: Será el número con el que se calcule el factorial\n",
+ " Ej:\n",
+ " Factorial(4) debe retornar 24\n",
+ " Factorial(-2) debe retornar nulo\n",
+ " Factorial(0) debe retornar 1\n",
+ " '''\n",
+ " #Tu código aca:\n",
+ " if (numero <1):\n",
+ " return None\n",
+ " if numero==0 or numero==1:\n",
+ " resultado=1\n",
+ " elif numero>1:\n",
+ " resultado=numero*Factorial(numero-1)\n",
+ " return resultado\n",
+ "\n",
+ "Factorial(9)\n",
+ "# Test 1 Factorial(5) OK\n",
+ "# valor_esperado = 120\n",
+ "# Test 2 Factorial(1) OK\n",
+ "# valor_esperado = 1 \n",
+ "# Test 3 Factorial(0) OK\n",
+ "# valor_esperado = 1\n",
+ "# Test 4 Factorial(9) OK\n",
+ "# valor_esperado = 362880"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[67, 71, 73]"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "def ListaPrimos(desde, hasta):\n",
+ " '''\n",
+ " Esta función devuelve una lista con los números primos entre los valores \"desde\" y \"hasta\"\n",
+ " pasados como parámetro, siendo ambos inclusivos.\n",
+ " En caso de que alguno de los parámetros no sea de tipo entero y/o no sea mayor a cero, debe retornar nulo.\n",
+ " En caso de que el segundo parámetro sea menor al primero, pero ambos mayores que cero,\n",
+ " debe retornar una lista vacía.\n",
+ " Recibe un argumento:\n",
+ " desde: Será el número a partir del cual se toma el rango\n",
+ " hasta: Será el número hasta el cual se tome el rango\n",
+ " Ej:\n",
+ " ListaPrimos(7,15) debe retornar [7,11,13]\n",
+ " ListaPrimos(100,99) debe retornar []\n",
+ " ListaPrimos(1,7) debe retonan [1,2,3,5,7]\n",
+ " '''\n",
+ " #Tu código aca:\n",
+ " lp=[]\n",
+ " # Ciclos 'if' Validar las variables de entrada\n",
+ " if (type(desde) != int or type(hasta) != int):\n",
+ " return None\n",
+ " if (desde < 0 or hasta < 0):\n",
+ " return None\n",
+ " if (desde > hasta):\n",
+ " return lp \n",
+ " def calculaPrimo(num):\n",
+ " if num==2:\n",
+ " return True\n",
+ " for n in range (2,num):\n",
+ " if(num%n!=0):\n",
+ " continue\n",
+ " else:\n",
+ " return False\n",
+ " return True\n",
+ " for i in range(desde,(hasta+1)):\n",
+ " if calculaPrimo(i):\n",
+ " lp.append(i)\n",
+ " return lp\n",
+ "\n",
+ "ListaPrimos(66,77)\n",
+ "# Test_01 ListaPrimos(1,11)\n",
+ "# Lista_esperada = [1,2,3,5,7,11] OK!\n",
+ "# Test_02 ListaPrimos('0',0)\n",
+ "# Lista_esperada = None OK!\n",
+ "# Test_03 ListaPrimos(66,77)\n",
+ "# Lista_esperada = [67, 71, 73] OK!\n",
+ "# Test__04 ListaPrimos(0,'66')\n",
+ "# Lista_esperada = None\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "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.10.6"
+ },
+ "orig_nbformat": 4,
+ "vscode": {
+ "interpreter": {
+ "hash": "d3777ed8f5fe800f0d3d1926318eb186c93d9a88e13881725c87e5bdd2f1dd1d"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Workbench/Taller/pruebaerror.ipynb b/Workbench/Taller/pruebaerror.ipynb
index 3c875a91e..635127dd4 100644
--- a/Workbench/Taller/pruebaerror.ipynb
+++ b/Workbench/Taller/pruebaerror.ipynb
@@ -76,6 +76,66 @@
"a1.Doblar(100)"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[3, 6, 9]\n"
+ ]
+ }
+ ],
+ "source": [
+ "# LISTA DIVISIBLES\n",
+ "\n",
+ "# ListaDivisibles(12, 10)\n",
+ "# lista_esperada = []\n",
+ "\n",
+ "# ListaDivisibles(12, 100)\n",
+ "# lista_esperada = [12,24,36,48,60,72,84,96]\n",
+ "\n",
+ "# ListaDivisibles(3, 9)\n",
+ "# lista_esperada = [3,6,9]\n",
+ "\n",
+ "def ListaDivisibles(numero, tope):\n",
+ " '''\n",
+ " Esta función devuelve una lista ordenada de menor a mayor con los números divisibles \n",
+ " por el parámetro número entre uno (1) y el valor del parámetro \"tope\"\n",
+ " Recibe dos argumentos:\n",
+ " numero: Numero entero divisor\n",
+ " tope: Máximo valor a evaluar a partir de uno (1)\n",
+ " Ej:\n",
+ " ListaDivisibles(6,30) debe retornar [6,12,18,24,30]\n",
+ " ListaDivisibles(10,5) debe retornar []\n",
+ " ListaDivisibles(7,50) debe retornar [7,14,21,28,35,42,49]\n",
+ " '''\n",
+ " #Tu código aca:\n",
+ " lint = list(range(numero,tope+1))\n",
+ " ldiv = []\n",
+ " \n",
+ " if numero > tope:\n",
+ " print(ldiv)\n",
+ " return ldiv\n",
+ " if numero <= 0:\n",
+ " print(str(numero) + ', que corresponde a ser el divisor, NO puede ser = 0.')\n",
+ " return None\n",
+ " for i in lint:\n",
+ " if (i % numero) == 0:\n",
+ " ldiv.append(i)\n",
+ " ldiv.sort(reverse=False)\n",
+ " print(ldiv) \n",
+ " return ldiv\n",
+ " \n",
+ "lista_divisible=ListaDivisibles(3, 9)\n",
+ " # 12, 10 []\n",
+ " # 12. 100 [12,24,36,48,60,72,84,96]\n",
+ " # 3, 9 [3,6,9]"
+ ]
+ },
{
"cell_type": "code",
"execution_count": 8,
@@ -850,31 +910,17 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 4,
"metadata": {},
- "outputs": [],
- "source": [
- "valor=777\n",
- "print (valor)\n",
- "print ()\n",
- "cadena=str(valor)\n",
- "indice=-1\n",
- "iguales=0\n",
- "for x in range(0,len(cadena)/2):\n",
- " if cadena[x]==cadena[indice]:\n",
- " iguales=iguales+1\n",
- " indice=indice-1\n",
- "if iguales==(len(cadena)/2):\n",
- " print ('Es capicua')\n",
- "else:\n",
- " print ('No es capicua')"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
"source": [
"'''\n",
" En matemáticas, la palabra capicúa (del catalán cap i cua, 'cabeza y cola') \n",
@@ -975,43 +1021,15 @@
},
{
"cell_type": "code",
- "execution_count": 414,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "2\n"
- ]
- }
- ],
- "source": [
- "print (27%5)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 406,
+ "execution_count": 415,
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1\n",
- "3\n",
- "17\n",
- "51\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"#def divisores ():\n",
- "num = int (input ('Escribe un entero'))\n",
+ "num = 10 #int (input ('Escribe un entero'))\n",
"listaFC = []\n",
- "i=1\n",
- "while i<=num:\n",
+ "i=2\n",
+ "while num/c) !=1:\n",
" if num%i==0:\n",
" listaFC.append(num//i)\n",
" listaFC.sort()\n",
@@ -1090,17 +1108,9 @@
},
{
"cell_type": "code",
- "execution_count": 335,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "['c', 'a', 'b']\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"from operator import itemgetter\n",
"def OrdenarDiccionario(diccionario_par, clave, descendente=True):\n",
@@ -1150,17 +1160,9 @@
},
{
"cell_type": "code",
- "execution_count": 275,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "{'clave1': ['c', 'a', 'b'], 'clave2': ['casa', 'auto', 'barco'], 'clave3': [1, 2, 3]}\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"dicc = {\n",
" 'clave1':['c','a','b'],\n",
@@ -1178,17 +1180,9 @@
},
{
"cell_type": "code",
- "execution_count": 325,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "{'clave1': ['c', 'a', 'b'], 'clave2': ['casa', 'auto', 'barco'], 'clave3': [1, 2, 3]}\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"key_list = ['clave1', 'clave2', 'clave3']\n",
"value_list1 = [['c', 'a', 'b'], ['casa', 'auto', 'barco'], [1, 2, 3]]\n",
@@ -1203,18 +1197,19 @@
},
{
"cell_type": "code",
- "execution_count": 330,
+ "execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "{'nombre': 'Juan', 'edad': '27', 'ciudad': 'Nueva York'}\n"
+ "{'clave1': 'Juan', 'clave2': '27', 'clave3': 'Nueva York'}\n"
]
}
],
"source": [
+ "# Une dos listas en un dict\n",
"key_list = ['clave1', 'clave2', 'clave3']\n",
"value_list = ['Juan', '27', 'Nueva York']\n",
"\n",
@@ -1222,18 +1217,6 @@
"print(dict_from_list)"
]
},
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def sum (a,b):\n",
- " return 'Null'\n",
- " \n",
- "sum (2,3)"
- ]
- },
{
"cell_type": "code",
"execution_count": null,
@@ -1283,18 +1266,9 @@
},
{
"cell_type": "code",
- "execution_count": 324,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Ord1= [('Gris', '1892-B', 'M'), ('Azul', '2901-Z', 'M'), ('Rojo', '4859-A', 'A')]\n",
- "Ord2= [{'color': 'Gris', 'matricula': '1892-B', 'cambio': 'M'}, {'color': 'Azul', 'matricula': '2901-Z', 'cambio': 'M'}, {'color': 'Rojo', 'matricula': '4859-A', 'cambio': 'A'}]\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"# Ordenar una lista de coches almacenados como tuplas\n",
"tuplas_coches = [\n",
@@ -1323,7 +1297,7 @@
},
{
"cell_type": "code",
- "execution_count": 281,
+ "execution_count": 11,
"metadata": {},
"outputs": [
{
@@ -1335,10 +1309,10 @@
}
],
"source": [
- "dicc={'midic':('a',b'')}\n",
- "if type(diccionario_pa) != dict:\n",
- " if type(get)\n",
- " return None\n",
+ "dicc={'midic':('a','b')}\n",
+ "if type(dicc) != dict:\n",
+ " if type(getattr(dicc)!= False):\n",
+ " pass #return None\n",
"dicc2={'clave1':['b','a','c'], 'clave2':['barco','auto','casa'],'clave3':[3,2,1]}\n",
"print ('este es el dicc ordenado por la clave X', dicc2)"
]
@@ -1349,34 +1323,22 @@
"metadata": {},
"outputs": [],
"source": [
+ "dicc ={\n",
+ "'clave1':['c', 'a', 'b'],\n",
+ "'clave2':['casa', 'auto', 'barco'],\n",
+ "'clave3':[3,2,1]}\n",
+ "\n",
"juegos = [\n",
- " {\n",
- " \"nombre\": \"Resident Evil 2\",\n",
- " \"calificacion\": 99,\n",
- " },\n",
- " {\n",
- " \"nombre\": \"Crash Bandicoot N. Sane Trilogy\",\n",
- " \"calificacion\": 76,\n",
- " },\n",
- "\n",
- " {\n",
- " \"nombre\": \"Cuphead\",\n",
- " \"calificacion\": 100,\n",
- " },\n",
- " {\n",
- " \"nombre\": \"Minecraft\",\n",
- " \"calificacion\": 80,\n",
- " },\n",
- " {\n",
- " \"nombre\": \"Bioshock\",\n",
- " \"calificacion\": 95,\n",
- " },\n",
- "]\n",
+ "{\"nombre\": \"Resident Evil 2\", \"calificacion\": 99,},\n",
+ "{\"nombre\": \"Crash Bandicoot\", \"calificacion\": 76,},\n",
+ "{\"nombre\": \"Cuphead\", \"calificacion\": 100,},\n",
+ "{\"nombre\": \"Minecraft\", \"calificacion\": 80,},\n",
+ "{\"nombre\": \"Bioshock\", \"calificacion\": 95,},]\n",
+ "\n",
"def funcion_que_devuelve_clave(juego):\n",
" # Vamos a ordenar basándonos en su calificación, y como se nos\n",
" # va a pasar un diccionario, devolvemos el elemento \"calificacion\"\n",
- " return juego[\"calificacion\"]\n",
- "\n",
+ " return juego[\"nombre\"]\n",
"# La ordenamos\n",
"juegos_ordenados = sorted(juegos, key=funcion_que_devuelve_clave)\n",
"print(\"Ordenada por calificación ascendente: \")\n",
@@ -1385,25 +1347,15 @@
"# También se puede en orden inverso\n",
"juegos_ordenados = sorted(juegos, key=funcion_que_devuelve_clave, reverse=True)\n",
"print(\"Ordenada por calificación descendente: \")\n",
- "\n",
"for juego in juegos_ordenados:\n",
" print(juego)"
]
},
{
"cell_type": "code",
- "execution_count": 250,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "nuemero e claves 6\n",
- "{'clave1': 1.97, 'clave2': 8.49, 'clave3': 9.79, 'clave4': 1.2, 'clave5': 0.43, 'clave6': ['a', 'b', 'c']}\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"clients = {'clave1': 1.97,\n",
" 'clave2': 8.49,\n",
@@ -1423,26 +1375,16 @@
"# print (idx[0], 'ha gastado', clients[idx[1]]) # \"algo\" para recorrer clients\n",
"#clients_sort=sorted(clients)\n",
"orden = len (clients.keys())\n",
- "print ('nuemero e claves', orden)\n",
- "print (clients) #\n",
- " \n",
+ "print ('Número de claves', orden)\n",
+ "print (clients) \n",
" \n"
]
},
{
"cell_type": "code",
- "execution_count": 232,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "{'clave1': 1.97, 'clave2': 8.49, 'clave3': 9.79, 'clave4': 8.53, 'clave5': 0.43}\n",
- "{'clave1': 1.97, 'clave2': 8.49, 'clave3': 9.79, 'clave4': 8.53, 'clave5': 0.43, 'clave6': ['a', 'b', 'c']}\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"clients = {'clave1': 1.97,\n",
" 'clave2': 8.49,\n",
@@ -1453,6 +1395,21 @@
"clients ['clave6']= ['a','b','c']\n",
"print (clients)\n"
]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "lisdic=[]\n",
+ "for i in range (3):\n",
+ " for j in range (3):\n",
+ " for k in range (3):\n",
+ " lisdic=print(i,j,k)\n",
+ "\n",
+ "print (lisdic, end=\", \")"
+ ]
}
],
"metadata": {
From 95a65e6bafc5cbb921dccc53b557228523dd9fac Mon Sep 17 00:00:00 2001
From: Jorge Cordova <55065873+jcordovaj@users.noreply.github.com>
Date: Sat, 28 Jan 2023 14:58:15 -0300
Subject: [PATCH 13/16] Up 1457
---
Workbench/Taller/HC280123.ipynb | 66 ++++++++++++++++++++++++++++++---
1 file changed, 60 insertions(+), 6 deletions(-)
diff --git a/Workbench/Taller/HC280123.ipynb b/Workbench/Taller/HC280123.ipynb
index 552712320..eb07e7368 100644
--- a/Workbench/Taller/HC280123.ipynb
+++ b/Workbench/Taller/HC280123.ipynb
@@ -105,7 +105,7 @@
},
{
"cell_type": "code",
- "execution_count": 15,
+ "execution_count": 30,
"metadata": {},
"outputs": [
{
@@ -114,7 +114,7 @@
"[1, 2, 3]"
]
},
- "execution_count": 15,
+ "execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
@@ -138,13 +138,13 @@
" if type(lista) != list:\n",
" return None\n",
" else:\n",
- " lista_final=[]\n",
+ " guardaLdeL=[]\n",
" for elem in lista:\n",
" if isinstance(elem, list):\n",
- " lista_final.extend(ListaDeListas(elem))\n",
+ " guardaLdeL.extend(ListaDeListas(elem))\n",
" else:\n",
- " lista_final.append(elem)\n",
- " return lista_final\n",
+ " guardaLdeL.append(elem)\n",
+ " return guardaLdeL\n",
"ListaDeListas ([[[1]],2,[[[[3]]]]])\n",
"# ListaDeListas(100)\n",
"# lista_esperada = None\n",
@@ -270,6 +270,60 @@
"# Test__04 ListaPrimos(0,'66')\n",
"# Lista_esperada = None\n"
]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[('hola', 2), ('mundo', 1)]"
+ ]
+ },
+ "execution_count": 38,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "def ListaRepetidos(lista):\n",
+ " '''\n",
+ " Esta función recibe como parámetro una lista y devuelve una lista de tuplas donde cada \n",
+ " tupla contiene un valor de la lista original y las veces que se repite. Los valores \n",
+ " de la lista original no deben estar repetidos. \n",
+ " Debe respetarse el orden original en el que aparecen los elementos.\n",
+ " En caso de que el parámetro no sea de tipo lista debe retornar nulo.\n",
+ " Recibe un argumento:\n",
+ " lista: Será la lista que se va a evaluar.\n",
+ " Ej:\n",
+ " ListaRepetidos([]) debe retornar []\n",
+ " ListaRepetidos(['hola', 'mundo', 'hola', 13, 14]) \n",
+ " debe retornar [('hola',2),('mundo',1),(13,1),(14,1)]\n",
+ " ListaRepetidos([1,2,2,4]) debe retornar [(1,1),(2,1),(4,1)]\n",
+ " '''\n",
+ " #Tu código aca:\n",
+ " swap=[]\n",
+ " if type(lista) != list:\n",
+ " return None\n",
+ " while len(lista)>0:\n",
+ " eleTup=lista[0]\n",
+ " contador=lista.count(lista[0])\n",
+ " swap.append((eleTup,contador))\n",
+ " for i in range(lista.count(lista[0])):\n",
+ " lista.remove(eleTup)\n",
+ " continue\n",
+ " return swap\n",
+ "\n",
+ "ListaRepetidos(['hola', 'mundo', 'hola'])\n",
+ "# Test_01 ListaRepetidos (['hola', 'mundo', 'hola'])\n",
+ "# Lista_esperada = [('hola',2),('mundo',1)]\n",
+ "# Test_02 ListaRepetidos ([10,11,11,12,15,17,20,20])\n",
+ "# Lista_esperada = [(10,1),(11,2),(12,1),(15,1),(17,1),(20,2)]\n",
+ "# Test_03 ListaRepetidos ((1,2,3,3))\n",
+ "# Lista_esperada = None"
+ ]
}
],
"metadata": {
From a6213bb9a11985901a9086410ccdc11c84b66fd5 Mon Sep 17 00:00:00 2001
From: Jorge Cordova <55065873+jcordovaj@users.noreply.github.com>
Date: Sat, 28 Jan 2023 19:23:20 -0300
Subject: [PATCH 14/16] Up Hasta Ej ClassAuto, 24 pts acumulados, resta 1
---
Workbench/Taller/FuncionFactorial.py | 6 +-
Workbench/Taller/HC280123.ipynb | 223 +++++++++++++++++++++++++--
2 files changed, 212 insertions(+), 17 deletions(-)
diff --git a/Workbench/Taller/FuncionFactorial.py b/Workbench/Taller/FuncionFactorial.py
index c004bb55e..33750e301 100644
--- a/Workbench/Taller/FuncionFactorial.py
+++ b/Workbench/Taller/FuncionFactorial.py
@@ -12,11 +12,11 @@
def factorial(n):
if (n <1):
return None
- if n==0 or n==1:
+ elif n==0 or n==1:
resultado=1
- elif n>1:
+ if n>1:
resultado=n*factorial(n-1)
return resultado
-fact=factorial(5)
+fact=factorial(0)
print (fact)
\ No newline at end of file
diff --git a/Workbench/Taller/HC280123.ipynb b/Workbench/Taller/HC280123.ipynb
index eb07e7368..ef10b0d74 100644
--- a/Workbench/Taller/HC280123.ipynb
+++ b/Workbench/Taller/HC280123.ipynb
@@ -159,16 +159,16 @@
},
{
"cell_type": "code",
- "execution_count": 22,
+ "execution_count": 56,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
- "362880"
+ "1"
]
},
- "execution_count": 22,
+ "execution_count": 56,
"metadata": {},
"output_type": "execute_result"
}
@@ -186,15 +186,17 @@
" Factorial(0) debe retornar 1\n",
" '''\n",
" #Tu código aca:\n",
- " if (numero <1):\n",
+ " if (type(numero) != int):\n",
" return None\n",
- " if numero==0 or numero==1:\n",
- " resultado=1\n",
- " elif numero>1:\n",
- " resultado=numero*Factorial(numero-1)\n",
- " return resultado\n",
+ " if (numero < 0):\n",
+ " return None\n",
+ " factorial = 1\n",
+ " for n in range(1, (numero)+1):\n",
+ " factorial = factorial * n\n",
+ " return factorial\n",
+ " \n",
+ "Factorial(1)\n",
"\n",
- "Factorial(9)\n",
"# Test 1 Factorial(5) OK\n",
"# valor_esperado = 120\n",
"# Test 2 Factorial(1) OK\n",
@@ -205,6 +207,36 @@
"# valor_esperado = 362880"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": 60,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "120"
+ ]
+ },
+ "execution_count": 60,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "def Factorial(numero):\n",
+ " if (type(numero) != int):\n",
+ " return None\n",
+ " if (numero < 0):\n",
+ " return None\n",
+ " f = 1\n",
+ " for n in range(1, (numero)+1):\n",
+ " f = f * n\n",
+ " return f\n",
+ "\n",
+ "Factorial(5)"
+ ]
+ },
{
"cell_type": "code",
"execution_count": 29,
@@ -273,16 +305,16 @@
},
{
"cell_type": "code",
- "execution_count": 38,
+ "execution_count": 40,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
- "[('hola', 2), ('mundo', 1)]"
+ "[(1, 1), (2, 2), (4, 1)]"
]
},
- "execution_count": 38,
+ "execution_count": 40,
"metadata": {},
"output_type": "execute_result"
}
@@ -316,7 +348,7 @@
" continue\n",
" return swap\n",
"\n",
- "ListaRepetidos(['hola', 'mundo', 'hola'])\n",
+ "ListaRepetidos([1,2,2,4])\n",
"# Test_01 ListaRepetidos (['hola', 'mundo', 'hola'])\n",
"# Lista_esperada = [('hola',2),('mundo',1)]\n",
"# Test_02 ListaRepetidos ([10,11,11,12,15,17,20,20])\n",
@@ -324,6 +356,169 @@
"# Test_03 ListaRepetidos ((1,2,3,3))\n",
"# Lista_esperada = None"
]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 71,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "15"
+ ]
+ },
+ "execution_count": 71,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "def ClaseVehiculo(tipo, color):\n",
+ " '''\n",
+ " Esta función devuelve un objeto instanciado de la clase Vehiculo, \n",
+ " la cual debe tener los siguientes atributos:\n",
+ " Tipo: Un valor dentro de los valores posibles: ['auto','camioneta','moto']\n",
+ " Color: Un valor de tipo de dato string.\n",
+ " Velocidad: Un valor de tipo de dato float, que debe inicializarse en cero.\n",
+ " y debe tener el siguiente método:\n",
+ " Acelerar(): Este método recibe un parámetro con el valor que debe incrementar a la\n",
+ " propiedad Velocidad y luego retornarla.\n",
+ " Si la propiedad Velocidad cobra un valor menor a cero, debe quedar en cero.\n",
+ " Si la propiedad Velocidad cobra un valor mayor a cien, debe quedar en cien.\n",
+ " Recibe dos argumento:\n",
+ " tipo: Dato que se asignará al atributo Tipo del objeto de la clase Vehiculo\n",
+ " color: Dato que se asignará al atributo Color del objeto de la clase Vehiculo\n",
+ " Ej:\n",
+ " a = ClaseVehículo('auto','gris')\n",
+ " a.Acelerar(10) -> debe devolver 10\n",
+ " a.Acelerar(15) -> debe devolver 25\n",
+ " a.Acelerar(-10) -> debe devolver 15\n",
+ " '''\n",
+ " #Tu código aca:\n",
+ " class Vehiculo:\n",
+ " def __init__(self, tipo, color):\n",
+ " if (tipo=='auto' or tipo =='camioneta' or tipo=='moto'):\n",
+ " self.Tipo = tipo\n",
+ " else:\n",
+ " raise TypeError ('el tipo de vehículo tiene que ser auto, camioneta o moto')\n",
+ " self.Color = color\n",
+ " self.Velocidad = 0\n",
+ "\n",
+ " def Acelerar(self, acel):\n",
+ " self.Velocidad += acel\n",
+ " if self.Velocidad < 0:\n",
+ " self.Velocidad=0\n",
+ " if self.Velocidad>100:\n",
+ " self.Velocidad=100\n",
+ " return self.Velocidad\n",
+ " \n",
+ " a = Vehiculo(tipo, color) \n",
+ " return a\n",
+ "\n",
+ "# Test_01 ClaseVehiculo('auto','verde')\n",
+ "# valor_test = a.Acelerar(10)\n",
+ "# valor_test = a.Acelerar(100)\n",
+ "# valor_test = a.Acelerar(-20)\n",
+ "# valor_esperado = 80\n",
+ "# self.assertEqual(valor_test, valor_esperado)\n",
+ "# Test_02 ClaseVehiculo('camioneta','azul')\n",
+ "# valor_test = a.Acelerar(20)\n",
+ "# valor_test = a.Acelerar(-30)\n",
+ "# valor_esperado = 0\n",
+ "# Test_03 ClaseVehiculo('moto','negra')\n",
+ "# valor_test = a.Acelerar(10)\n",
+ "# valor_test = a.Acelerar(100)\n",
+ "# valor_esperado = 100\n",
+ "\n",
+ "a= ClaseVehiculo ('auto','verde')\n",
+ "\n",
+ "a.Acelerar(10) #debe devolver 10\n",
+ "a.Acelerar(15) #debe devolver 25\n",
+ "a.Acelerar(-10) "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dicc = {\n",
+ " 'clave1':['c','a','b'],\n",
+ " 'clave2':['casa','auto','barco'],\n",
+ " 'clave3':[1,2,3]\n",
+ " }\n",
+ "def OrdenarDiccionario(diccionario_par, clave, descendente=True):\n",
+ " '''\n",
+ " Esta función recibe como parámetro un diccionario, cuyas listas de valores tienen el mismo\n",
+ " tamaño y sus elementos enésimos están asociados. Y otros dos parámetros que indican\n",
+ " la clave por la cual debe ordenarse y si es descendente o ascendente.\n",
+ " La función debe devolver el diccionario ordenado, teniendo en cuenta de no perder la\n",
+ " relación entre los elementos enésimos.\n",
+ " Recibe tres argumentos:\n",
+ " diccionario: Diccionario a ordenar.\n",
+ " clave: Clave del diccionario recibido, por la cual ordenar.\n",
+ " descendente: Un valor booleano, que al ser verdadero indica ordenamiento ascendente y \n",
+ " descendente si es falso. \n",
+ " Debe tratarse de un parámetro por defecto en True.\n",
+ " Si el parámetro diccionario no es un tipo de dato diccionario ó el parámetro clave no \n",
+ " se encuentra dentro de las claves del diccionario, debe devolver nulo.\n",
+ " Ej:\n",
+ " dicc = {'clave1':['c','a','b'],\n",
+ " 'clave2':['casa','auto','barco'],\n",
+ " 'clave3':[1,2,3]}\n",
+ " OrdenarDiccionario(dicc, 'clave1') debe retornar {'clave1':['a','b','c'],\n",
+ " 'clave2':['auto','barco','casa'],\n",
+ " 'clave3':[2,3,1]}\n",
+ " OrdenarDiccionario(dicc, 'clave3', False) debe retornar {'clave1':['b','a','c'],\n",
+ " 'clave2':['barco','auto','casa'],\n",
+ " 'clave3':[3,2,1]}\n",
+ " '''\n",
+ " #Tu código aca:\n",
+ " # Variables a usar, incluye nuevas listas auxiliares para hacer los arreglos de swap, sin perder la hilación.\n",
+ " cantidadValores=0 # Recibe valores del diccionario en el proceso de pasarlo a Lista de diccs\n",
+ " numKeys=0 # Recibe n elementos del tipo llave que tiene el diccionario DICC, para ejecutar los ciclos. \n",
+ " newArr=[] \t\t # Va a recibir mi lista de diccionarios originales convertidos a listas\n",
+ " newArrSorted=[] # Va a recibir los diccionarios ordenados por la clave ingresada\n",
+ " res =[]\n",
+ " if not (type(diccionario_par) is dict): # diccionario_par= Parámetro que recibe un DICT\n",
+ "\t return 'Null' # Si el parámetro, no es de tipo diccionario, retorna 'null'\n",
+ " if not (clave in diccionario_par.keys()): # Si la clave recibiba como parámetro no existe, retorna null\n",
+ "\t return 'Null' # descendente=True ==> Orden ASCENDENTE, es al revés, FALSE==> DESCENDENTE \n",
+ " \n",
+ " # Este es un problema de Un diccionario de listas que debe ser transformado en una lista de diccionarios para poder\n",
+ " # ser maniplado con los métodos de 'list'. Al final, se debe convertir a DICT nuevamente.\n",
+ " # Convertimos el dicc de list a list de dict\n",
+ "\n",
+ " #print (len(diccionario_par[list(diccionario_par.keys())[0]]))\n",
+ " # chequeamos qué valor estamos reciendo\n",
+ " print()\n",
+ " if len(diccionario_par[list(diccionario_par.keys())[0]])>0: \n",
+ " cantidadValores=len(diccionario_par[list(diccionario_par.keys())[0]])\n",
+ " # convertimos el diccionario de listas, a una lista de diccionarios:\t\n",
+ " for i in range(0, cantidadValores):\n",
+ " newObj={}\n",
+ " for key in diccionario_par:\n",
+ " newObj[key]=diccionario_par[key][i]\n",
+ " newArr.append(newObj)\n",
+ " #print(newArr) Aquí se generó una lista de diccionarios\n",
+ " # Ahora ordenemos\n",
+ " newArrSorted = sorted(newArr, key=lambda d: d[clave], reverse=not (descendente))\n",
+ " print (newArrSorted) #verificar contenido del nuevo arreglo\n",
+ " # Convertimos la lista de diccionarios, en un diccionario de listas:\n",
+ " for key in diccionario_par:\n",
+ " newArr2 = []\n",
+ " for i in range(0, cantidadValores):\n",
+ " newArr2.append(newArrSorted[i][key])\n",
+ " res[key] = newArr2\n",
+ " #Si no tienen valores devolvemos el mismo diccionario:\n",
+ " else:\n",
+ " return diccionario_par\n",
+ " return res\n",
+ "\n",
+ "OrdenarDiccionario(dicc, 'clave1') "
+ ]
}
],
"metadata": {
From daaf40958d86509fc8b1c85a8084ae8b3ba42d96 Mon Sep 17 00:00:00 2001
From: Jorge Cordova <55065873+jcordovaj@users.noreply.github.com>
Date: Sat, 28 Jan 2023 21:46:18 -0300
Subject: [PATCH 15/16] Up2143, todos OK, 1 falla, error en test
---
Workbench/Taller/HC280123.ipynb | 53 ++++++++++++++++----------
Workbench/Taller/OrdenarDiccionario.py | 34 +++++++++++++++++
2 files changed, 67 insertions(+), 20 deletions(-)
create mode 100644 Workbench/Taller/OrdenarDiccionario.py
diff --git a/Workbench/Taller/HC280123.ipynb b/Workbench/Taller/HC280123.ipynb
index ef10b0d74..13ff5fa94 100644
--- a/Workbench/Taller/HC280123.ipynb
+++ b/Workbench/Taller/HC280123.ipynb
@@ -440,15 +440,23 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 76,
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "list indices must be integers or slices, not str",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[1;32mIn[76], line 74\u001b[0m\n\u001b[0;32m 71\u001b[0m \u001b[39mreturn\u001b[39;00m diccionario_par\n\u001b[0;32m 72\u001b[0m \u001b[39mreturn\u001b[39;00m res\n\u001b[1;32m---> 74\u001b[0m OrdenarDiccionario(dicc, \u001b[39m'\u001b[39;49m\u001b[39mclave1\u001b[39;49m\u001b[39m'\u001b[39;49m) \n",
+ "Cell \u001b[1;32mIn[76], line 68\u001b[0m, in \u001b[0;36mOrdenarDiccionario\u001b[1;34m(diccionario_par, clave, descendente)\u001b[0m\n\u001b[0;32m 66\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39m0\u001b[39m, cantidadValores):\n\u001b[0;32m 67\u001b[0m newArr2\u001b[39m.\u001b[39mappend(newArrSorted[i][key])\n\u001b[1;32m---> 68\u001b[0m res[key] \u001b[39m=\u001b[39m newArr2\n\u001b[0;32m 69\u001b[0m \u001b[39m#Si no tienen valores devolvemos el mismo diccionario:\u001b[39;00m\n\u001b[0;32m 70\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m 71\u001b[0m \u001b[39mreturn\u001b[39;00m diccionario_par\n",
+ "\u001b[1;31mTypeError\u001b[0m: list indices must be integers or slices, not str"
+ ]
+ }
+ ],
"source": [
- "dicc = {\n",
- " 'clave1':['c','a','b'],\n",
- " 'clave2':['casa','auto','barco'],\n",
- " 'clave3':[1,2,3]\n",
- " }\n",
"def OrdenarDiccionario(diccionario_par, clave, descendente=True):\n",
" '''\n",
" Esta función recibe como parámetro un diccionario, cuyas listas de valores tienen el mismo\n",
@@ -493,7 +501,7 @@
"\n",
" #print (len(diccionario_par[list(diccionario_par.keys())[0]]))\n",
" # chequeamos qué valor estamos reciendo\n",
- " print()\n",
+ " #print()\n",
" if len(diccionario_par[list(diccionario_par.keys())[0]])>0: \n",
" cantidadValores=len(diccionario_par[list(diccionario_par.keys())[0]])\n",
" # convertimos el diccionario de listas, a una lista de diccionarios:\t\n",
@@ -502,21 +510,26 @@
" for key in diccionario_par:\n",
" newObj[key]=diccionario_par[key][i]\n",
" newArr.append(newObj)\n",
- " #print(newArr) Aquí se generó una lista de diccionarios\n",
- " # Ahora ordenemos\n",
- " newArrSorted = sorted(newArr, key=lambda d: d[clave], reverse=not (descendente))\n",
- " print (newArrSorted) #verificar contenido del nuevo arreglo\n",
- " # Convertimos la lista de diccionarios, en un diccionario de listas:\n",
- " for key in diccionario_par:\n",
- " newArr2 = []\n",
- " for i in range(0, cantidadValores):\n",
- " newArr2.append(newArrSorted[i][key])\n",
- " res[key] = newArr2\n",
+ " #print(newArr) Aquí se generó una lista de diccionarios\n",
+ " # Ahora ordenemos\n",
+ " newArrSorted = sorted(newArr, key=lambda d: d[clave], reverse=not (descendente))\n",
+ " # print (newArrSorted) #verificar contenido del nuevo arreglo\n",
+ " # Convertimos la lista de diccionarios, en un diccionario de listas:\n",
+ " for key in diccionario_par:\n",
+ " newArr2 = []\n",
+ " for i in range(0, cantidadValores):\n",
+ " newArr2.append(newArrSorted[i][key])\n",
+ " res[key] = newArr2\n",
" #Si no tienen valores devolvemos el mismo diccionario:\n",
" else:\n",
- " return diccionario_par\n",
+ " return diccionario_par\n",
+ " \n",
" return res\n",
- "\n",
+ "dicc = {\n",
+ " 'clave1':['c','a','b'],\n",
+ " 'clave2':['casa','auto','barco'],\n",
+ " 'clave3':[1,2,3]\n",
+ " }\n",
"OrdenarDiccionario(dicc, 'clave1') "
]
}
diff --git a/Workbench/Taller/OrdenarDiccionario.py b/Workbench/Taller/OrdenarDiccionario.py
new file mode 100644
index 000000000..12f5352d4
--- /dev/null
+++ b/Workbench/Taller/OrdenarDiccionario.py
@@ -0,0 +1,34 @@
+def OrdenarDiccionario(diccionario_par, clave, descendente=True):
+ cantidadValores=0
+ newArr=[]
+ newArrSorted=[]
+ res ={}
+ if not (type(diccionario_par) is dict):
+ return None
+ if not (clave in diccionario_par.keys()):
+ return None
+ if len(diccionario_par[list(diccionario_par.keys())[0]])>0:
+ cantidadValores=len(diccionario_par[list(diccionario_par.keys())[0]])
+ for i in range(0, cantidadValores):
+ newObj={}
+ for key in diccionario_par:
+ newObj[key]=diccionario_par[key][i]
+ newArr.append(newObj)
+ newArrSorted = sorted(newArr, key=lambda d: d[clave], reverse=not (descendente))
+ for key in diccionario_par:
+ newArr2 = []
+ for i in range(0, cantidadValores):
+ newArr2.append(newArrSorted[i][key])
+ res[key] = newArr2
+ else:
+ return diccionario_par
+
+ return res
+
+dicc = {
+ 'clave1':['c','a','b'],
+ 'clave2':['casa','auto','barco'],
+ 'clave3':[1,2,3]
+ }
+
+print (OrdenarDiccionario(dicc,"clave1"))
From a3ebd8ab0009e9bfd664716cc5be689d03afde6f Mon Sep 17 00:00:00 2001
From: Jorge Cordova <55065873+jcordovaj@users.noreply.github.com>
Date: Sun, 29 Jan 2023 03:31:47 -0300
Subject: [PATCH 16/16] Up2901230327, PruebasDiccListas
---
Workbench/Taller/HC280123.ipynb | 2 +-
Workbench/Taller/pruebaerror.ipynb | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/Workbench/Taller/HC280123.ipynb b/Workbench/Taller/HC280123.ipynb
index 13ff5fa94..2091cee27 100644
--- a/Workbench/Taller/HC280123.ipynb
+++ b/Workbench/Taller/HC280123.ipynb
@@ -550,7 +550,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.10.6"
+ "version": "3.10.6 (tags/v3.10.6:9c7b4bd, Aug 1 2022, 21:53:49) [MSC v.1932 64 bit (AMD64)]"
},
"orig_nbformat": 4,
"vscode": {
diff --git a/Workbench/Taller/pruebaerror.ipynb b/Workbench/Taller/pruebaerror.ipynb
index 635127dd4..11e97c9d6 100644
--- a/Workbench/Taller/pruebaerror.ipynb
+++ b/Workbench/Taller/pruebaerror.ipynb
@@ -1428,7 +1428,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.10.6"
+ "version": "3.10.6 (tags/v3.10.6:9c7b4bd, Aug 1 2022, 21:53:49) [MSC v.1932 64 bit (AMD64)]"
},
"orig_nbformat": 4,
"vscode": {
![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}