manuelver/Curso-lenguaje-python
1
0
Fork 0
Code Issues Pull Requests Releases Activity

Restructure content and add notes from HolaMundo

Browse Source 
Signed-off-by: Manuel Vergara <manuel@vergaracarmona.es>
This commit is contained in:
Manuel Vergara
2023-05-20 09:36:26 +02:00
parent 64ed03f811
commit f4e9797c4b
430 changed files with 889 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
python-total/README.md Normal file
View File

@@ -0,0 +1,140 @@
# Apuntes de python de python-total
Estos apuntes y ejercicios en python han sido realizados en el trascurso del curso de python-total de Federico Garay:
- [Python-total](https://www.udemy.com/course/python-total)
¡Te recomiendo que hagas el curso y redactes tus propios apuntes! Este repositorio es para mi uso personal, pero si te sirve de ayuda, ¡pues me alegro!
# Índice del curso y sus contenidos
- [Día 1 - Programa un creador de nombres](dia_01/README.md)
- 1.1. - print
- 1.2. - strings
- 1.3. - input
- 1.4. - Proyecto del Día 1
- [Día 2 - Programa un calculador de comisiones](dia_02/README.md)
- 2.1. - Tipos de datos
- 2.2. - Variables
- 2.3. - Nombres de variables
- 2.4. - integers & floats
- 2.5. - Conversiones
- 2.6. - Formatear cadenas
- 2.7. - Operadores matemáticos
- 2.8. - Redondeo
- 2.9. - Proyecto del Día 2
- [Día 3 - Programa un analizador de texto](dia_03/README.md)
- 3.1. - Index( )
- 3.2. - Substrings
- 3.3. - Métodos para Strings
- 3.4. - Strings: propiedades
- 3.5. - Listas
- 3.6. - Diccionarios
- 3.7. - Tuples
- 3.8. - sets
- 3.9. - booleanos
- 3.10. - Proyecto del Día 3
- [Día 4 - Programa el juego "adivina el número"](dia_04/README.md)
- 4.1. - Operadores de comparación
- 4.2. - Operadores lógicos
- 4.3. - Control de flujo
- 4.4. - loops while
- 4.5. - range( )
- 4.6. - enumerate( )
- 4.7. - zip( )
- 4.8. - min( ) & max( )
- 4.9. - random
- 4.10. - Comprensión de listas
- 4.11. - match
- 4.12. - Proyecto del Día 4
- [Día 5 - Programa el juego "El ahorcado"](dia_05/README.md)
- 5.1. - Documentación
- 5.2. - Funciones
- 5.3. - return
- 5.4. - Funciones dinámicas
- 5.5. - Interacción entre funciones
- 5.6. - *args
- 5.7. - **kwargs
- 5.8. - Ejercicios
- 5.9. - Proyecto del Día 5
- [Día 6 - Programa un recetario](dia_06/README.md)
- 6.1. - Abrir y leer archivos
- 6.2. - Crear y escribir archivos
- 6.3. - Directorios
- 6.4. - pathlib
- 6.5. - Path
- 6.6. - Limpiar la consola
- 6.7. - Archivos + funciones
- 6.8. - Proyecto del Día 6
- [Día 7 - Programa una cuenta bancaria](dia_07/README.md)
- 7.1. - Clases
- 7.2. - Atributos
- 7.3. - Métodos
- 7.4. - Tipos de métodos
- 7.5. - Herencia
- 7.6. - Herencia extendida
- 7.7. - Polimorfismo
- 7.8. - Pilares de la Programación Orientada a Objetos
- 7.9. - Métodos especiales
- 7.10. - Proyecto del Día 7
- [Día 8 - Programa una consola de turnos](dia_08/README.md)
- 8.1. - Instalar paquetes
- 8.2. - Módulos y paquetes
- 8.3. - Manejo de errores
- 8.4. - pylint
- 8.5. - unittest
- 8.6. - Decoradores
- 8.7. - Generadores
- 8.8. - Proyecto del Día 8
- [Día 9 - Programa un buscador de números de serie](dia_09/README.md)
- 9.1. - Módulo collections
- 9.2. - Módulos shutil & os
- 9.3. - Módulo datetime
- 9.4. - Módulo para medir el tiempo
- 9.5. - Módulo math
- 9.6. - Expresiones regulares
- 9.7. - Comprimir y descomprimir archivos
- 9.8. - Proyecto del Día 9
- [Día 10 - Programa el juego "Invasión espacial"](dia_10/README.md)
- 10.1. - Distancia entre dos puntos
- 10.2. - Convertir el Juego en un Archivo Ejecutable (.exe)
- [Día 11 - Programa un web scraping](dia_11/README.md)
- 11.1. - Extraer elementos de una clase
- [Día 12 - Programa un gestor de restaurantes](dia_12/README.md)
- [Día 13 - Programa un asistente de voz](dia_13/README.md)
- 13.1. - Librerias y módulos
- 13.2. - Algunos problemas con las bibliotecas
- 13.3. - Enlaces
- [Día 14 - Programa un controlador de asistencia](dia_14/README.md)
- 14.1. - Bibliotecas
- [Día 15 - Programa un modelo de machine learning](dia_15/README.md)
- 5.1. - Bibliotecas
- 5.2. - Definiciones
- 5.3. - Cuadernos de trabajo en Colab de google drive
- [Día 16 - Programa una aplicación web de tareas pendientes](dia_16/README.md)
- 16.1. - Entornos Virtuales
- 16.2. - Módulos
- 16.3. - Preparación de estructura de trabajo
- 16.4. - Configurar url
- 16.5. - Crear tabla de tareas
- 16.6. - Configurar la vista
- 16.7. - Configurar la vista de Detalle
- 16.8. - Crear Links a Detalle
- 16.9. - Agregar nueva tarea
- 16.10. - Formulario para nueva tarea
- 16.11. - Editar tarea
- 16.12. - Eliminar tarea
- 16.13. - Crear la lógica de Logueo / Deslogueo
- 16.14. - Formulario de Logueo / Deslogueo
- 16.15. - Restringir acceso
- 16.16. - Información específica de usuario
- 16.17. - Registrar nuevo usuario
- 16.18. - Barra de búsquedas
- 16.19. - Un estilo para todas las vistas
- 16.20. - Estilo general
- 16.21. - Estilo de barra superiores
- 16.22. - estilo de la lista
- 16.23. - Estilo de la barra de cerca
- 16.24. - Terminar el sitio
- [Día 17 - Extra bibliotecas para hacking ético](dia_17/README.md)
- 17.1. - Bibliotecas

107
python-total/dia_01/README.md Normal file
View File

@@ -0,0 +1,107 @@
# Día 1 - Programa un creador de nombres
## Índice
- [Día 1 - Programa un creador de nombres](#día-1---programa-un-creador-de-nombres)
- [Índice](#índice)
- [1.1. - print](#11---print)
- [1.1.1. - Mostrar texto](#111---mostrar-texto)
- [1.1.2. - Mostrar números](#112---mostrar-números)
- [1.2. - strings](#12---strings)
- [1.2.1. - Concatenación](#121---concatenación)
- [1.2.2. - Caracteres especiales](#122---caracteres-especiales)
- [1.3. - input](#13---input)
- [1.4. - Proyecto del Día 1](#14---proyecto-del-día-1)
- [Ficheros y documentación del día 1](#ficheros-y-documentación-del-día-1)
## 1.1. - print
print - Declaración que al ejecutarse muestra (o imprime) en pantalla el argumento que se introduce dentro de los paréntesis.
### 1.1.1. - Mostrar texto
Ingresamos entre comillas simples o dobles los caracteres de texto que deben mostrarse en pantalla.
```python
print("Hola mundo")
```
Output
Hola mundo
### 1.1.2. - Mostrar números
Podemos entregarle a print() el número que debe mostrar, o una operación matemática a resolver. No empleamos comillas en estos casos.
```python
print(150 + 50)
```
output
200
## 1.2. - strings
Los strings en Python son un tipo de dato formado por cadenas (o secuencias) de caracteres de cualquier tipo, formando un texto.
### 1.2.1. - Concatenación
Unificación de cadenas de texto:
```python
print("Hola" + " " + "mundo")
```
output
Hola mundo
### 1.2.2. - Caracteres especiales
Indicamos a la consola que el caracter a continuación del símbolo \ debe ser tratado como un caracter especial.
- `\"` --> Imprime comillas
- `\n` --> Separa texto en una nueva linea
- `\t` --> Imprime un tabulador
- `\\` --> Imprime la barra invertida textualmente
## 1.3. - input
Función que permite al usuario introducir información por medio del teclado al ejecutarse, otorgándole una instrucción acerca del ingreso solicitado. El código continuará ejecutándose luego de que el usuario realice la acción.
```python
input("Dime tu nombre: ")
```
output
Dime tu nombre: |
```python
print("Tu nombre es " + input("Dime tu nombre: "))
```
output
Dime tu nombre: Federico
Tu nombre es Federico
## 1.4. - Proyecto del Día 1
Imagina esta situación: tu mejor amigo ha puesto una fábrica de cerveza y tiene todo listo. Su producto es fantástico, tiene cuerpo, buen sabor, buen color, el nivel justo de espuma… pero le falta una identidad. No se le ocurre qué nombre ponerle su cerveza para que tenga una identidad única y original. Entonces vienes tú y le dices "No te preocupes, yo voy a crear un programa que te va a hacer dos preguntas y luego te va a decir cuál es el nombre de tu cerveza". Así de simple.
Ya sé que en el mundo real no necesitaríamos desarrollar un software solo para hacer dos preguntas, pero hasta que aprendamos más funcionalidades los programas van a tener que mantenerse en el terreno de lo simple. Igualmente, si está recién comenzando, este va a ser todo un desafío.
Vas a crear un código en Python que le pida a tu amigo que responda dos preguntas que requieran una sola palabra cada una y que luego le muestre en pantalla esas palabras combinadas, para formar una marca creativa.
Puedes usar las preguntas que quieras. La idea es que el resultado sea original, creativo, y hasta cómico, y si quieres agregar dificultad al desafío, te sugiero que intentes que el nombre de la cerveza se imprima entre comillas. Recuerda que hay diferentes formas de que la función print muestre las comillas sin cortar el string, y que ingrese la impresión final en al menos dos líneas utilizando saltos de línea dentro del código.
Intenta hacerlo por tu cuenta y si se complica, no te preocupes, en la próxima elección lo vamos a resolver juntos.
## Ficheros y documentación del día 1
- [main.py](main.py)
- [primer_programa.py](primer_programa.py)
- [programa01.py](programa01.py)
[Documentación del día](../doc_curso/01_creador_de_nombres/)
---
Enlaces a todos los días: [dia 1 - creador de nombres](../dia_01/README.md) / [dia 2 - calculador de comisiones](../dia_02/README.md) / [dia 3 - analizador de texto](../dia_03/README.md) / [dia 4 - juego "adivina el número"](../dia_04/README.md) / [dia 5 - juego "El ahorcado"](../dia_05/README.md) / [dia 6 - recetario](../dia_06/README.md) / [dia 7 - cuenta bancaria](../dia_07/README.md) / [dia 8 - consola de turnos](../dia_08/README.md) / [dia 9 - buscador de números de serie](../dia_09/README.md) / [dia 10 - juego "Invasión espacial"](../dia_10/README.md) / [dia 11 - web scraping](../dia_11/README.md) / [dia 12 - gestor de restaurantes](../dia_12/README.md) / [dia 13 - asistente de voz](../dia_13/README.md) / [dia 14 - controlador de asistencia](../dia_14/README.md) / [dia 15 - machine learning](../dia_15/README.md) / [dia 16 - aplicación web de tareas pendientes](../dia_16/README.md)

16
python-total/dia_01/main.py Normal file
View File

@@ -0,0 +1,16 @@
# This is a sample Python script.
# Press Shift+F10 to execute it or replace it with your code.
# Press Double Shift to search everywhere for classes, files, tool windows, actions, and settings.
def print_hi(name):
# Use a breakpoint in the code line below to debug your script.
print(f'Hi, {name}') # Press Ctrl+F8 to toggle the breakpoint.
# Press the green button in the gutter to run the script.
if __name__ == '__main__':
print_hi('PyCharm')
# See PyCharm help at https://www.jetbrains.com/help/pycharm/

26
python-total/dia_01/primer_proyecto.py Normal file
View File

@@ -0,0 +1,26 @@
""" Primeros ejercicios """
print("Hola mundo")
print(100 + 50)
print("\nHOLA" + " " + 'MUNDO')
print("\nMe llamo \"Manuel\"")
print("Primera linea\nSegunda linea")
print("\ttabulemos")
print("This isn't a number")
print('This isn\'t a number')
print("Este signo \"\\\" es una barra invertida")
print("\n\nHola ")
print("Tu nombre es " + input("Introduce tu nombre: ")
+ " y tu apellido es "
+ input("Introduce tu apellido: "))
print(input("¿Qué estás estudiando? "))
print(input("Escribe tu nombre: ") + " " + input("Escribe tu apellido: "))

4
python-total/dia_01/programa01.py Normal file
View File

@@ -0,0 +1,4 @@
""" programa 01 del curso """
print("La cerveza se llama\n"
+ "\"" + input("¿Cuál es tu mascota favorita? ") + " " + input("¿Cuál es tu color favorito? ")
+ "\"\n¡Felicidades por tu espumosa!")

22
python-total/dia_02/01_variables.py Normal file
View File

@@ -0,0 +1,22 @@
nombre = "Julia"
apellido = "Roberts"
nombrecompleto = nombre + " " + apellido
nombre = "Juan"
print(nombre)
nombre = "Laura"
print(nombre)
edad = 30
edad2 = 15
print(edad + edad2)
totaledad = edad + edad2
print(totaledad)
nombre = input("Dime tu nombre: ")
apellido = input("Dime tu apellido: ")
print("Tu nombre completo es " + nombre + " " + apellido)

27
python-total/dia_02/02_Intengers_Floats.py Normal file
View File

@@ -0,0 +1,27 @@
""" Intenger & float """
# La suma convierte el int en un float, para poder operar
mi_numero = 5 + 5.8
mi_numero = mi_numero + mi_numero
print(mi_numero)
print(mi_numero + mi_numero)
print(type(mi_numero))
# Cuando pedimos un numero recogemos un string
edad = input("Dime tu edad: ")
print("Tu edad es " + edad)
print(type(edad))
# Por eso tenemos que aplicar una conversión si queremos operar
op_edad = int(edad)
print(type(op_edad))
nueva_edad = 1 + op_edad
# Y si queremos volver a implimir concatenando, debemos transformarlo de nuevo
wr_nueva_edad = str(nueva_edad)
print("Cumpliras " + wr_nueva_edad)
print(type(wr_nueva_edad))

16
python-total/dia_02/02_Intengers_math.py Normal file
View File

@@ -0,0 +1,16 @@
import math
print(round(1.3)) # redondeo al número más cercano
print(round(1.7)) # redondeo al número más cercano
print(round(1.5)) # redondeo al número más cercano
print(abs(-77)) # Número absoluto
print(abs(55)) # Número absoluto
# Con el módulo math. Todos los metodos en https://docs.python.org/3/library/math.html
print(math.ceil(1.1)) # Lleva al número más cercano hacia arriba
print(math.floor(1.9999)) # Lleva al número más cercano hacia abajo
print(math.isnan(23)) # Indica si no es un número el valor
# print(math.isnan("23")) # Indica si no es un número el valor
print(math.pow(10, 3)) # Potencia
print(math.sqrt(25)) # Raiz cuadrada

32
python-total/dia_02/03_Conversiones.py Normal file
View File

@@ -0,0 +1,32 @@
num1 = 20
num2 = 30.5
# Aquí num1 sigue siendo int
print(num1)
print(type(num1))
print(type(num2))
# Pero con una operación
num1 = num1 + num2
# Transformamos el tipo de num1 a float con una conversión """implícita""" de python
print(num1)
print(type(num1))
print(type(num2))
# Ahora vamos a hacer una conversión explícita
num3 = 5.8
print(num3)
print(type(num3))
# Aquí surge la conversión explícita
num4 = int(num3)
print(num4)
print(type(num4))
# Interesante el ejercicio de convertir str en floar dentro de un print
num1 = "7.5"
num2 = "10"
print(float(num1) + float(num2))

20
python-total/dia_02/04_format.py Normal file
View File

@@ -0,0 +1,20 @@
color_auto = 'rojo'
matricula = 266254
print("Mi coche es {} con la matrícula {}".format(color_auto,matricula))
# A partir de la versiuón 3.6 se incorporaron las cadenas literales
print(f"\nMi coche es {color_auto} con la matrícula {matricula}")
# Evolución de format
x = 10
y = 5
z = x + y
print("\nMis números son " + str(x) + " y " + str(y) + " es igual a " + str(z))
print("\nMis números son {} y {} es igual a {}".format(x,y,z))
print(f"\nMis números son {x} y {y} es igual a {z}")

44
python-total/dia_02/05_operadores.py Normal file
View File

@@ -0,0 +1,44 @@
x = 6
y = 2
z = 7
# Operadores
print(f"{x} mas {y} es igual a {x+y}")
print(f"{x} menos {y} es igual a {x-y}")
print(f"{x} por {y} es igual a {x*y}")
print(f"{x} dividido {y} es igual a {x/y}")
# División al piso (redondeando)
print(f"\n{z} dividido al piso de {y} es igual a {z//y}")
# Módulo (resto)
print(f"\n{z} modulo de {y} es igual a {z%y}")
# Numero elevado
print(f"\n{x} elevado a la {y} es igual a {x**y}")
print(f"{x} elevado a la {y} es igual a {x**3}")
# Raiz cuadrada
print(f"\nLa raíz cuadrada de {x} es {x**0.5}")
print("")
# Redondeo (Hace el redondeo al valor entero más próximo)
print(round(100/3))
print(round(12/7,2))
## La raíz cuadrada de antes
print(f"\nLa raíz cuadrada de {x} es {round(x**0.5,3)}")
## Otro ejemplo para ver el tipo. Veremos que el round es un intenger cuando se redondea en la variable
valor = round(95.6666666666666)
print(valor)
print(type(valor))
### Aquí transformamos el float en intenger dentro del print, pero la variable es un float
valor = 95.6666666666666
print(round(valor))
print(type(valor))
### Si ponemos un redondeo de cero será un float
num1 = round(95.666666666666,0)
print(num1)
print(type(num1))

25
python-total/dia_02/06_programa02.py Normal file
View File

@@ -0,0 +1,25 @@
# Comisiones del 13% son las ventas totales
# Preguntar nombre y cuanto han vendido este mes
# Output frase que incluya su nombre y el monto que le corresponde por las comisiones
# input para preguntar y almacenar en variables
# los ingresos serán un string y se deben transformar a float
# Calcular el 13% multiplicando por 0.13
# almacenar en variable redondeando a 2 decimales
# RECOGER DATOS EN VARIABLES (Y CONVERSIÓN, TODO JUNTO)
nombre = input("¿Cuál es tu nombre? ")
ventas_mes = float(input("¿Cuáles fueron tus ventas este mes? "))
# TRANSFORMAR EL STR DE VENTAS A FLOAT PARA OPERAR
# ventas_mes = ventas_mes) # DEPRECADA, LO INTRODUZCO ARRIBA
# CALCULAR LA VENTAS TOTALES E INTRODUCIR EL RESULTADO EN UNA VARIABLE CON REDONDEO
comision = round(ventas_mes * 0.13,2)
# TRANSFORMAR LOS FLOATS EN STR PARA PODER IMPRIMIR POR PANTALLA
# ventas_mes = str(ventas_mes)
# comision = str(comision)# DEPRECADA, NO ES NECESARIA LA CONVERSIÓN
# IMPRIMIR FRASE POR PANTALLA
print(f"Hola {nombre}, tus ventas de este mes fueron {ventas_mes} Euros y tu comisión fue de {comision} Euros")

184
python-total/dia_02/README.md Normal file
View File

@@ -0,0 +1,184 @@
# Día 2 - Programa un calculador de comisiones
## Índice
- [Día 2 - Programa un calculador de comisiones](#día-2---programa-un-calculador-de-comisiones)
- [Índice](#índice)
- [2.1. - Tipos de datos](#21---tipos-de-datos)
- [2.2. - Variables](#22---variables)
- [2.2.1 - Ejemplo de uso de variables](#221---ejemplo-de-uso-de-variables)
- [2.3. - Nombres de variables](#23---nombres-de-variables)
- [2.3.1. - Reglas](#231---reglas)
- [2.4. - integers \& floats](#24---integers--floats)
- [2.4.1. - int](#241---int)
- [2.4.2. - float](#242---float)
- [2.5. - Conversiones](#25---conversiones)
- [2.6. - Formatear cadenas](#26---formatear-cadenas)
- [2.7. - Operadores matemáticos](#27---operadores-matemáticos)
- [2.8. - Redondeo](#28---redondeo)
- [2.8.1. - algunos ejemplos de uso](#281---algunos-ejemplos-de-uso)
- [2.9. - Proyecto del Día 2](#29---proyecto-del-día-2)
- [Ficheros y documentación del día 2](#ficheros-y-documentación-del-día-2)
## 2.1. - Tipos de datos
En Python tenemos varios tipos o estructuras de datos, que son fundamentales en programación ya que almacenan información, y nos permiten manipularla.
| texto (srt) | números (int, float) | booleanos (bool) |
| :---------: | :------------------: | :--------------: |
| "Python" | Int 3 | True |
| "750" | float 3.0 | False |
| estructuras | Descripción | mutable | ordenada (Tiene índice) | duplicados |
| :-------------: | ------------------ | :----------------: | :---------------------: | :-------------------------: |
| listas [] | *list* | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| tuplas () | *Entre paréntesis* | :x: | :heavy_check_mark: | :heavy_check_mark: |
| sets {} | *Entre llaves* | :heavy_check_mark: | :x: | :x: |
| diccionarios {} | *dic key:valor* | :heavy_check_mark: | :x: * | :x: : :heavy_check_mark: ** |
*: En Python 3.7+, existen consideraciones **: key es única; value puede repetirse
## 2.2. - Variables
Las variables son espacios de memoria que almacenan valores o datos de distintos tipos, y (como su nombre indica) pueden variar. Se crean en el momento que se les asigna un valor, por lo cual en Python no requerimos declararlas previamente.
### 2.2.1 - Ejemplo de uso de variables
```python
pais = "México"
nombre = input("Escribe tu nombre: ")
print("Tu nombre es " + nombre)
num1 = 55
num2 = 45
print(nun1 + num2)
```
100
## 2.3. - Nombres de variables
Existen convenciones y buenas prácticas asociadas al nombre de las variables creadas en Python. Las mismas tienen la intención de facilitar la interpretabilidad y mantenimiento del código creado.
### 2.3.1. - Reglas
1. **Legible**: nombre de la variable es relevante según su contenido
2. **Unidad**: no existen espacios (La práctica en Python es incorporar guiones bajos *ejemplo_variable*)
3. **Hispanismos**: omitir signos específicos del idioma español, como tildes o la letra ñ
4. **Números**: los nombres de las variables no deben empezar por números (aunque pueden contenerlos al final)
5. **Signos/símbolos**: no se deben incluir : `" ' , < > / ? | \ ( ) ! @ # $%^&*~-+`
6. **Palabras clave**: no utilizamos palabras reservadas por Python.
## 2.4. - integers & floats
Existen dos tipos de datos numéricos básicos en Python: int y float. Como toda variable en Python, su tipo queda definido al asignarle un valor a una variable. La función type() nos permite obtener el tipo de valor almacenado en una variable.
### 2.4.1. - int
Int, o integer, es un número entero, positivo o negativo, sin decimales, de un largo indeterminado.
```python
Num1 = 7
print(type(num1))
```
<class 'int'>
### 2.4.2. - float
Float, o "número de punto flotante" es un número que puede ser positivo o negativo, que a su vez contiene una o más posiciones decimales.
```python
Num2 = 7.525587
print(type(num2))
```
<class 'float'>
## 2.5. - Conversiones
Python realiza conversiones implícitas de tipos de datos automáticamente para operar con valores numéricos. En otros casos, necesitaremos generar una conversión de manera explícita.
```python
int(var)
```
<class 'int'> """Convierte el dato en integer"""
```python
float(var)
```
<class 'float'> """Convierte el dato en float"""
## 2.6. - Formatear cadenas
Para facilitar la concatenación de variables y texto en Python, contamos con dos herramientas que nos evitan manipular las variables, para incorporarlas directamente al texto:
- Función format: se encierra las posiciones de las variables entre corchetes { }, y a continuación del string llamamos a las variables con la función format
```python
print("Mi auto es {} y de matrícula {}".format(color_auto,matricula))
```
- Cadenas literales (f-strings): a partir de Python 3.8, podemos anticipar la concatenación de variables anteponiendo f al string
```python
print(f"Mi auto es {color_auto} y de matrícula {matricula}")
```
## 2.7. - Operadores matemáticos
Veamos cuáles son los operadores matemáticos básicos de Python, que utilizaremos para realizar cálculos:
| Operador | Descripción |
| :------: | :------------------------------------------------ |
| + | Suma |
| - | Resta |
| * | Multiplicación |
| / | División |
| // | Cociente (división "al piso". Redondeo) |
| % | Resto (módulo) (Útil para detectar valores pares) |
| ** | Potencia |
| **0.5 | Raíz cuadrada (¡es un caso especial de potencia!) |
## 2.8. - Redondeo
El redondeo facilita la interpretación de los valores calculados al limitar la cantidad de decimales que se muestran en pantalla. También, nos permite aproximar valores decimales al entero más próximo.
round(number,ndigits)
- *number* - valor a redondear cantidad de
- *ndigits* - Cantidad de decimales (si se omite, el resultado es entero)
### 2.8.1. - algunos ejemplos de uso
```python
print(round(100/3))
```
33
```python
print(round(12/7,2))
```
1.71
## 2.9. - Proyecto del Día 2
La situación es esta: tú trabajas en una empresa donde los vendedores reciben comisiones del 13% por sus ventas totales, y tu jefe quiere que ayudes a los vendedores a calcular sus comisiones creando un programa que les pregunte su nombre y cuánto han vendido en este mes. Tu programa le va a responder con una frase que incluya su nombre y el monto que le corresponde por las comisiones.
Esto no es un programa complejo, pero es entendible que pueda complicarse cuando estás aprendiendo. Por más que lo que has aprendido hasta ahora es muy simple, ponerlo todo junto en un solo programa puede ser complejo, por lo que te doy un par de ayudas:
- Este programa debería comenzar preguntando cosas al usuario, por lo tanto, vas a necesitar input para poder recibir los ingresos del usuario y deberías usar variables para almacenar esos ingresos. Recuerda que los ingresos de usuarios se almacenan como strings. Por lo tanto, deberías convertir uno de esos ingresos en un float para poder hacer operaciones con él.
- ¿Y qué operaciones necesitas hacer? Bueno, calcular el 13% del número que haya ingresado el usuario. Es decir, que debes multiplicar ese número por 13 y luego dividirlo por 100. Recuerda almacenar ese resultado en una variable.
- Sería bueno que para imprimir en pantalla el resultado te asegures de que esa información no tenga más de dos decimales, para que sea fácil de leer, y luego organiza todo eso en un string al que debes dar formato. Recuerda que conocimos dos maneras de hacerlo y cualquiera de ellas es válida.
## Ficheros y documentación del día 2
- [01_variables.py](01_variables.py)
- [02_intengers_floats.py](02_intengers_Floats.py)
- [02_intengers_math.py](02_intengers_math.py)
- [03_Conversiones.py](03_Conversiones.py)
- [04_format.py](04_format.py)
- [05_operadores.py](05_operadores.py)
- [06_programa02.py](06_programa02.py)
[Documentación del día](../doc_curso/02_calculador_comisiones/)
---
Enlaces a todos los días: [dia 1 - creador de nombres](../dia_01/README.md) / [dia 2 - calculador de comisiones](../dia_02/README.md) / [dia 3 - analizador de texto](../dia_03/README.md) / [dia 4 - juego "adivina el número"](../dia_04/README.md) / [dia 5 - juego "El ahorcado"](../dia_05/README.md) / [dia 6 - recetario](../dia_06/README.md) / [dia 7 - cuenta bancaria](../dia_07/README.md) / [dia 8 - consola de turnos](../dia_08/README.md) / [dia 9 - buscador de números de serie](../dia_09/README.md) / [dia 10 - juego "Invasión espacial"](../dia_10/README.md) / [dia 11 - web scraping](../dia_11/README.md) / [dia 12 - gestor de restaurantes](../dia_12/README.md) / [dia 13 - asistente de voz](../dia_13/README.md) / [dia 14 - controlador de asistencia](../dia_14/README.md) / [dia 15 - machine learning](../dia_15/README.md) / [dia 16 - aplicación web de tareas pendientes](../dia_16/README.md)

24
python-total/dia_03/01_index.py Normal file
View File

@@ -0,0 +1,24 @@
print("# BUSCAR LA POSICIÓN DE UN CARACTER")
# CON index() PODEMOS ENCONTRAR LA POSICIÓN DE UN CARACTER EN UN STRING
mi_texto = "hola mundo"
posicion = mi_texto.index("o",0,11)
print(f"EJEMPLO: La posición del caracter \"o\" es {posicion}")
# PREGUNTAR LETRA Y DAR POSICIÓN EN FRASE
pregunta_carater = input("PREGUNTA: De qué carater quieres saber la posición: ")
print(f"El carater \"{pregunta_carater}\" está en la posición \"{mi_texto.index(pregunta_carater)}\"")
print("\n# SE PUEDE BUSCAR CON rindex PARA BUSCAR DE DERECHA A IZQUIERDA")
posicion_r = mi_texto.rindex("o")
print(f"EJEMPLO: La posición en búsqueda reversa del caracter \"o\" es {posicion_r}")
print("\n# BUSCAR EL CARACTER DE UNA POSICIÓN")
# SABER LA LETRA DE UNA POSICIÓN
que_carater = mi_texto[3]
print(f"EJEMPLO: El carater en la posición \"3\" del string es la \"{que_carater}\"")
# PREGUNTAR POSICIÓN Y DAR RESULTADO EN FRASE
pregunta_posicion = int(input("PREGUNTA: De que posición quieres saber el caracter: "))
resultado_posicion = mi_texto[pregunta_posicion]
print(f"En la posición \"{pregunta_posicion}\" está el caracter \"{resultado_posicion}\"")

32
python-total/dia_03/02_sub_strings.py Normal file
View File

@@ -0,0 +1,32 @@
# DISTINTAS POSIBILIDADES CON Sub-strings. slicing (rebanar)
# Limitando la rebanada
print("# Limitando la rebanada")
texto = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ"
fragmento01 = texto[2:15]
print(fragmento01)
# Hasta el final
print("# Hasta el final")
fragmento02 = texto[2:]
print(fragmento02)
# Desde el inicio
print("# Desde el inicio")
fragmento03 = texto[:10]
print(fragmento03)
# Con saltos de dos
print("# Con saltos de dos")
fragmento04 = texto[2:15:2]
print(fragmento04)
# Con saltos de tres de prinicipio a fin
print("# Con saltos de tres de prinicipio a fin")
fragmento05 = texto[::3]
print(fragmento05)
# Con saltos de dos desde el final
print("# Con saltos de dos desde el final")
fragmento06 = texto[::-2]
print(fragmento06)

53
python-total/dia_03/03_metodos.py Normal file
View File

@@ -0,0 +1,53 @@
""" Métodos en strings """
texto = "Este es el texto de Federico"
# Mayúsculas
resultado01 = texto.upper()
print(resultado01)
# Mayúsculas (Podemos determinar un índice)
resultado02 = texto[20].upper()
print(resultado02)
# Mayúsculas
resultado03 = texto.upper()
print(resultado03)
# Split (Separar dentro de una lista)
resultado04 = texto.split()
print(resultado04)
# Split (Separar dentro de una lista) Se puede seleccionar el elemento separador
resultado05 = texto.split(" ")
print(resultado05)
# Join
a = "Aprender"
b = "Python"
c = "es"
d = "genial"
unir = "-".join([a,b,c,d])
print(unir)
# Find
resultado06 = texto.find("F")
print(resultado06)
## La diferencia de find con index es que
## si buscas un carácter que no existe no da error
## arroja el valor -1
resultado07 = texto.find("g")
print(resultado07)
# Reemplazar
resultado08 = texto.replace("Federico", "Manuel")
print(resultado08)
frase = "Si la implementación es difícil de explicar, puede que sea una mala idea."
resultado001 = frase.replace("difícil","fácil")
resultado002 = resultado001.replace("mala","buena")
print(resultado002)

55
python-total/dia_03/04_string.py Normal file
View File

@@ -0,0 +1,55 @@
# Métodos de strings
## Métodos de análisis
print("Hola mundo".count("Hola"))
print("Hola mundo".find("world"))
print("C:/python36/python.exe".rfind("/"))
print("Hola mundo".startswith("Hola"))
print("abc123".isdigit())
print("1234".isnumeric())
print("1234".isdecimal())
print("abc123".isalnum())
print("abc123".isalpha())
print("abcdef".islower())
print("ABCDEF".isupper())
print("Hola mundo".isspace())
print("hola mundo".capitalize())
print("Hola mundo".encode("utf-8"))
print("Hola mundo".replace("mundo", "world"))
print("Hola Mundo!".lower())
print("Hola Mundo!".upper())
print("Hola Mundo!".swapcase())
print(" Hola mundo! ".strip())
print("Hola".center(10, "*"))
print("Hola mundo!\nHello world!".split())
print("Hola mundo!\nHello world!".splitlines())
print("Hola mundo. Hello world!".partition(" "))
print("Hola mundo. Hello world!".rpartition(" "))
print(", ".join(["C", "C++", "Python", "Java"]))

37
python-total/dia_03/05_propiedades.py Normal file
View File

@@ -0,0 +1,37 @@
#INMUTABLE
# Este código intenta cambiar un caracter del string,
# con lo que no permitirá, dará error
# nombre = "Carina"
# nombre[0] = "K"
# print(nombre)
#CONCATENAR
n1 = "Kari"
n2 = "na"
print(n1 + n2)
# MULTIPLICAR
print(n1 * 5)
# MULTILINEA
# Perfecto para poemas
poema = """ Mil pequeños peces blancos
como si hirviera
el color del agua."""
print(poema)
# VERIFICAR contenido. booleano
print("agua" in poema)
# También se puede verificar si NO está
print("escorbuto" not in poema)
# LONGITUD DE STRING
print(len(poema))
print(len("Otro ejemplo"))
print(len("Anticonstitucionalidades"))
print(len("electroencefalografistas"))
print(len("Esternocleidomastoideo"))

36
python-total/dia_03/06_listas.py Normal file
View File

@@ -0,0 +1,36 @@
# LAS LISTAS
lista_1 = ["C", "C++", "Python", "Java"]
lista_2 = ["PHP", "SQL", "Visual Basic"]
lista_3 = ["d", "a", "c", "b", "e"]
lista_4 = [5, 4, 7, 1, 9]
# Ver tipo de dato de las listas
print(type(lista_1))
# Concatenar listas
lista_1_2 = lista_1 + lista_2
print(lista_1_2)
# EN LAS LISTAS SE PUEDEN MODIFICAR LOS ELEMENTOS
# Agregar un elemento a la lista
lista_1.append("R")
print(lista_1)
# Eliminar un elemento de la lista con el índice (Devuelve el valor eliminado)
print(lista_1.pop(4))
guardar_elemento = lista_1_2.pop(2)
print(guardar_elemento)
# Ordenar los elementos de la lista
lista_3.sort()
print(lista_3)
# Cuidado que no devuelve nada, modifica la variable
guardar_sort = lista_3.sort()
print(guardar_sort)
# Es de tipo None, un objecto sin valor, que no es lo mismo que 0
print(type(guardar_sort))
# Invierte el orden de los elementos (No es lo opuesto a sort)
lista_4.reverse()
print(lista_4)

56
python-total/dia_03/07_diccionarios.py Normal file
View File

@@ -0,0 +1,56 @@
# DICCIONARIOS (No se puede repetir el valor)
mi_diccionario = {"c1":"valor1","c2":"valor2"}
print(type(mi_diccionario))
print(mi_diccionario)
# Guardando un valor
resultado = mi_diccionario['c1']
print(resultado)
# Ejemplo 1
cliente = {
'nombre':'Juan',
'apellido':'Fuentes',
'peso':'88',
'talla':'1760'
}
consulta = (cliente['talla'])
print(consulta)
# Ejemplo 2
paciente ={
"nombre":"Eusebio",
"apellido":"García",
"peso":82.6,
"altura":"172"
}
print(f"El paciente se llama {paciente['nombre']} {paciente['apellido']} pesa {paciente['peso']} kg y mide {paciente['altura']} cm.")
# Diccionarios anidados y listas anidadas
dic = {'c1':55,'c2':[10,20,30],'c3':{'s1':100,'s2':200}}
print(dic['c2'])
print(dic['c2'][1])
print(dic['c3'])
print(dic['c3']['s2'])
# Ejercicio sacar la letra e en mayúscula
diccio = {'c1':['a','b','c'],'c2':['d','e','f']}
print(diccio['c2'][1].upper())
# Cambios en un diccionario
dic2 = {1:'a',2:'b'}
print(dic2)
dic2[3] = 'c'
print(dic2)
dic2[2] = 'B'
print(dic2)
print(dic2.keys())
print(dic2.values())
print(dic2.items())
mi_dic = {"nombre":"Karen", "apellido":"Jurgens", "edad":35, "ocupacion":"Periodista"}
mi_dic['edad'] = 36
mi_dic['ocupacion'] = 'Editora'
mi_dic['pais'] = 'Colombia'
print(mi_dic)

33
python-total/dia_03/08_tuplas.py Normal file
View File

@@ -0,0 +1,33 @@
mi_tuple = (1,2,3,4)
mi_tuple2 = 1,2,(10,20),4
print(type(mi_tuple))
print(mi_tuple2)
print(mi_tuple[2])
print(mi_tuple[-2])
print(mi_tuple2[2][0])
# El tuple se puede convertir en una lista
mi_tuple =list(mi_tuple)
print(type(mi_tuple))
# También al revés, se puede convertir una lista en un tuple
mi_tuple =tuple(mi_tuple)
print(type(mi_tuple))
# Se puede dar cada uno de los valores a una variable distinta
# pero tienen que coincidir la cantidad de valores con las variables
t = 1,2,1
x,y,z = t
print(x, y, z)
# Se puede pedir el número de elementos
print(len(t))
# Se puede contar la cantidad de apareciones de un valor
print(t.count(1))
# También se puede consultar el indice de un valor
print(t.index(2))

46
python-total/dia_03/09_set.py Normal file
View File

@@ -0,0 +1,46 @@
""" Sets """
mi_set = set([1, 2, 3, 4, 5])
print(type(mi_set))
print(mi_set)
# No acepta repeticiones
# No acepta listas
# pero sí tuples porque son inmutables
otro_set = set([1, 2, 3, 4, 5, (1,2,3), 1, 1, 1])
print(otro_set)
print(len(mi_set))
print(2 in mi_set)
# MÉTODOS
# Union
s1 = {1,2,3}
s2 = {3,4,5}
s3 = s1.union(s2)
print(s3)
# Agregar
s1.add(4)
print(s1)
# Eliminar. Si no encuentra el elemento
# da error
s1.remove(3)
print(s1)
# Descartar. Funciona como remove
# pero no da error si no encuentra el elemento
s1.discard(3)
print(s1)
# Elimina un elemento aleatorio
sorteo = s1.pop()
print(sorteo)
print(s1)
# Vaciar el set
s1.clear()
print(s1)

23
python-total/dia_03/10_booleanos.py Normal file
View File

@@ -0,0 +1,23 @@
"""
booleano
"""
# Creación directa del booleano
var1 = True
var2 = False
print(type(var1))
print(var1)
# Creación indirecta del booleano
numero = 5 > 2+3
print(type(numero))
print(numero)
# Creación explícita
compara = bool(5 != 5+1)
print(compara)
lista = (1, 2, 3, 4)
control = 5 not in lista
print(type(control))
print(control)

31
python-total/dia_03/11_programa03.py Normal file
View File

@@ -0,0 +1,31 @@
"""
Programa día 3 - Analizador de text
"""
txt = input("""
Ingresa un texto para analizar
""")
print("\nIngresa tres letras por favor")
l1 = input("\tIngresa la primera letra: ")
l2 = input("\tIngresa la segunda letra: ")
l3 = input("\tIngresa la tercera letra: ")
letras = [l1, l2, l3]
print("\nPRIMERO. Vamos a ver las veces que aparecen las letras en el texto:")
print(f"\t- La letra {l1} se encuentra {txt.lower().count(letras[0].lower())} veces en el texto.")
print(f"\t- La letra {l2} se encuentra {txt.lower().count(letras[1].lower())} veces en el texto.")
print(f"\t- La letra {l3} se encuentra {txt.lower().count(letras[2].lower())} veces en el texto.")
print(f"\nSEGUNDO. El texto tiene {len(txt.split())} palabras.")
pos_pri = txt[0]
pos_fin = txt[-1]
print(f"\nTERCERO. La primera letra del texto es \"{pos_pri}\" y la última es \"{pos_fin}\"")
print(f"\nCUARTO. Cuidao, el texto al revés es así:\n{' '.join(txt[::-1])}")
ser_o_no_ser = ("python" in txt)
dic_si_o_no = {True:"sí",False:"no"}
print(f"\nQUINTO. La palabra python {dic_si_o_no[ser_o_no_ser]} se encuentra en el texto")

646
python-total/dia_03/README.md Normal file
View File

@@ -0,0 +1,646 @@
# Día 3 - Programa un analizador de texto
Los strings en python tienen incorporados más de 30 métodos que nos permiten manipularlos y analizarlos. Aquí veremos algunos de los más importantes.
## Índice
- [Día 3 - Programa un analizador de texto](#día-3---programa-un-analizador-de-texto)
- [Índice](#índice)
- [3.1. - Index( )](#31---index-)
- [3.2. - Substrings](#32---substrings)
- [3.3. - Métodos para Strings](#33---métodos-para-strings)
- [3.3.1. - Métodos de análisis](#331---métodos-de-análisis)
- [3.3.2. - Métodos de transformación](#332---métodos-de-transformación)
- [3.3.3. - Métodos de separación y unión](#333---métodos-de-separación-y-unión)
- [3.4. - Strings: propiedades](#34---strings-propiedades)
- [3.5. - Listas](#35---listas)
- [3.6. - Diccionarios](#36---diccionarios)
- [3.7. - Tuples](#37---tuples)
- [3.8. - sets](#38---sets)
- [3.8.1. - Métodos set](#381---métodos-set)
- [3.9. - booleanos](#39---booleanos)
- [3.9.1. - operadores lógicos](#391---operadores-lógicos)
- [3.10. - Proyecto del Día 3](#310---proyecto-del-día-3)
- [Ficheros y documentación del día 3](#ficheros-y-documentación-del-día-3)
## 3.1. - Index( )
Cada carácter de los strings tienen una posición en el índice:
![](../img/dia03_01.png)
También podemos utilizar el índice reverso, que también empieza por cero pero luego todos los números están al revés con el signo menor.
![](../img/dia03_02.png)
Utilizamos el método index( ) para explorar strings, ya que permite hallar el índice de aparición de un caracter o cadena de caracteres dentro de un texto dado. Sintaxis:
string.index(value, start, end)
- *string*: variable que almacena un string
- *value*: caracter(es) | buscado(s)
- *start*: las apariciones antes del índice start se ignoran
- *end*: las apariciones luego del índice end se ignoran
Búsqueda en sentido inverso. Sintaxis:
string.rindex(value, start, end)
Devuelve el caracter en el índice i*
string[i]
*: En Python, el índice en primera posición es el 0.
## 3.2. - Substrings
Podemos extraer porciones de texto utilizando las herramientas de manipulación de strings conocidas como slicing (rebanar). Sintaxis:
string[start:stop:step]
- *start*: índice de inicio del sub-string (incluido)
- *stop*: índice del final del sub-string (no incluido)
- *step*: paso
Ejemplos:
![](../img/dia03_03.png)
```python
saludo = H o l a _ M u n d o
print(saludo[2:6])
```
la_M
![](../img/dia03_04.png)
```python
print(saludo[3::3])
```
auo
![](../img/dia03_05.png)
```python
print(saludo[::-1])
```
odnuM_aloH
## 3.3. - Métodos para Strings
### 3.3.1. - Métodos de análisis
**count( ) **: retorna el número de veces que se repite un conjunto de caracteres especificado.
```python
"Hola mundo".count("Hola")
```
1
**find( ) e index( )** retornan la ubicación (comenzando desde el cero) en la que se encuentra el argumento indicado. Difieren en que index lanza ValueError cuando el argumento no es encontrado, mientras find retorna
```python
"Hola mundo".find("world")
```
-1
**rfind( ) y rindex( )**.Para buscar un conjunto de caracteres pero desde el final.
```python
"C:/python36/python.exe".rfind("/")
```
11
**startswith( ) y endswith( )** indican si la cadena en cuestión comienza o termina con el conjunto de caracteres pasados como argumento, y retornan True o False en función de ello.
```python
"Hola mundo".startswith("Hola")
```
True
**isdigit( )**: determina si todos los caracteres de la cadena son dígitos, o
pueden formar números, incluidos aquellos correspondientes a lenguas
orientales.
```python
"abc123".isdigit()
```
False
**isnumeric( )**: determina si todos los caracteres de la cadena son números, incluye también caracteres de connotación numérica que no necesariamente son dígitos (por ejemplo, una fracción).
```python
"1234".isnumeric()
```
True
**isdecimal( )**: determina si todos los caracteres de la cadena son decimales; esto es, formados por dígitos del 0 al 9.
```python
"1234".isdecimal()
```
True
**isalnum( )**: determina si todos los caracteres de la cadena son alfanuméricos.
```python
"abc123".isalnum()
```
True
**isalpha( )**: determina si todos los caracteres de la cadena son alfabéticos.
```python
"abc123".isalpha()
```
False
**islower()**: determina si todos los catacteres de la cadena son minúsculas.
```python
abcdef".islower()
```
True
**isupper()**: determina si todos los catacteres de la cadena son mayúsculas.
```python
"ABCDEF".isupper()
```
True
**isprintable( )**: determina si todos los caracteres de la cadena son imprimibles (es decir, no son caracteres especiales indicados por \...).
```python
"Hola \t mundo!".isprintable()
```
False
**isspace( )**: determina si todos los caracteres de la cadena son espacios.
```python
"Hola mundo".isspace()
```
False
### 3.3.2. - Métodos de transformación
En realidad los strings son inmutables; por ende, todos los métodos a continuación no actúan sobre el objeto original sino que retornan uno nuevo.
**capitalize( )** retorna la cadena con su primera letra en mayúscula.
```python
"hola mundo".capitalize()
```
'Hola mundo'
**encode( )** codifica la cadena con el mapa de caracteres especificado y retorna una instancia del tipo bytes.
```python
"Hola mundo".encode("utf-8")
```
b'Hola mundo'
**replace( )** reemplaza una cadena por otra.
```python
"Hola mundo".replace("mundo", "world")
```
'Hola world'
**lower( )** retorna una copia de la cadena con todas sus letras en minúsculas.
```python
"Hola Mundo!".lower()
```
'hola mundo!'
**upper( )** retorna una copia de la cadena con todas sus letras en mayúsculas.
```python
"Hola Mundo!".upper()
```
'HOLA MUNDO!'
**swapcase( )** cambia las mayúsculas por minúsculas y viceversa.
```python
"Hola Mundo!".swapcase()
```
'hOLA mUNDO!'
**strip( ), lstrip( ) y rstrip( )** remueven los espacios en blanco que preceden y/o suceden a la cadena.
```python
" Hola mundo! ".strip()
```
'Hola mundo!'
Los métodos **center( ), ljust( ) y rjust( )** alinean una cadena en el centro, la izquierda o la derecha. Un segundo argumento indica con qué caracter se deben llenar los espacios vacíos (por defecto un espacio en blanco).
```python
"Hola".center(10, "*")
```
'***Hola***'
### 3.3.3. - Métodos de separación y unión
**split( )** divide una cadena según un caracter separador (por defecto son espacios en blanco). Un segundo argumento en split( ) indica cuál es el máximo de divisiones que puede tener lugar (-1 por defecto para representar una cantidad ilimitada).
```python
"Hola mundo!\nHello world!".split()
```
['Hola', 'mundo!', 'Hello', 'world!']
**splitlines( )** divide una cadena con cada aparición de un salto de línea.
```python
"Hola mundo!\nHello world!".splitlines()
```
['Hola mundo!', 'Hello world!']
**partition( )** retorna una tupla de tres elementos: el bloque de caracteres anterior a la primera ocurrencia del separador, el separador mismo, y el bloque posterior.
```python
"Hola mundo. Hello world!".partition(" ")
```
('Hola', ' ', 'mundo. Hello world!')
**rpartition( )** opera del mismo modo que el anterior, pero partiendo de derecha a izquierda.
```python
"Hola mundo. Hello world!".rpartition(" ")
```
('Hola mundo. Hello', ' ', 'world!')
**join( )** debe ser llamado desde una cadena que actúa como separador para unir dentro de una misma cadena resultante los elementos de una lista.
```python
", ".join(["C", "C++", "Python", "Java"])
```
'C, C++, Python, Java
## 3.4. - Strings: propiedades
Esto es lo que debes tener presente al trabajar con strings en Python:
- **Son inmutables**: una vez creados, no pueden modificarse sus partes, pero sí pueden reasignarse los valores de las variables a través de métodos de strings.
Las variables varian, pero los string son inmutables.
![](../img/dia03_06.png)
- **Concatenable**: es posible unir strings con el símbolo +
- **Multiplicable**: es posible concatenar repeticiones de un string con el símbolo *
![](../img/dia03_07.png)
- **Multilineales**: pueden escribirse en varias líneas al encerrarse entre triples comillas simples (''' ''') o dobles (""" """)
![](../img/dia03_08.png)
- **Determinar su longitud**: a través de la función len(mi_string)
![](../img/dia03_09.png)
- **Verificar su contenido**: a través de las palabras clave in y not in. El resultado de esta verificación es un booleano (True / False).
![](../img/dia03_10.png)
## 3.5. - Listas
Se pueden anidar listas. Se puede analizar y manipularlas, son mutables.
Una lista es de tipo `<class 'list'>`. Se pueden añadir tanto elementos str, int... todos juntos sin conflictos.
Igual que los strings, se puede seleccionar los elementos por su índice como un array:
```python
mi_lista[0:]
```
Se pueden concatenar las listas.
```python
lista_1 = ["C", "C++", "Python", "Java"]
lista_2 = ["PHP", "SQL", "Visual Basic"]
lista_3 = ["d", "a", "c", "b", "e"]
lista_4 = [5, 4, 7, 1, 9]
```
**función append( )**: agrega un elemento a una lista en el lugar
```python
lista_1.append("R")
print(lista_1)
```
["C", "C++", "Python", "Java", "R"]
**función pop( )**: elimina un elemento de la lista dado el índice, y devuelve el valor quitado
```python
print(lista_1.pop(4))
```
"R"
**función sort( )**: ordena los elementos de la lista en el lugar
```python
lista_3.sort()
print(lista_3)
```
['a', 'b', 'c', 'd', 'e']
**función reverse( )**: invierte el orden de los elementos en el lugar. *
```python
lista_4.reverse()
print(lista_4)
```
[9, 1, 7, 4, 5]
## 3.6. - Diccionarios
Los diccionarios son estructuras de datos que almacenan información en pares **clave:valor**. Son especialmente útiles para guardar y recuperar información a partir de los nombres de sus claves (no utilizan índices).
> mutable ✅ ordenado ❌* admite duplicados❌:✅
```python
mi_diccionario = {"curso":"Python TOTAL","clase":"Diccionarios"}
```
Agregar nuevos datos, o modificarlos:
```python
mi_diccionario["recursos"] = ["notas","ejercicios"]
```
Acceso a valores a través del nombre de las claves
```python
print(mi_diccionario["recursos"][1])
```
"ejercicios"
Métodos para listar los nombres de:
| Método | Descripción |
| :-------: | :-------------------- |
| keys( ) | las claves |
| values( ) | los valores |
| items( ) | los pares clave:valor |
*: A partir de Python 3.7+, los diccionarios son tipos de datos ordenados, en el sentido que dicho orden se mantiene según su orden de inserción para aumentar la eficiencia en el uso de la memoria.
Cuidado, las claves no se pueden repetir.
## 3.7. - Tuples
Los tuples o tuplas, son estructuras de datos que almacenan múltiples elementos en una única variable. Se caracterizan por ser ordenadas e inmutables. Esta característica las hace más eficientes en memoria y a prueba de daños, se procesan más rápido. Si se intentan cambiar devolverá un error.
> Mutable ❌ ordenado ✅ admite duplicados ✅
```python
mi_tuple = (1, "dos", [3.33, "cuatro"], (5.0, 6))
```
**indexado** (acceso a datos)
```python
print(mi_tuple[3][0])
```
5.0
**casting** (conversión de tipos de datos)
```python
lista_1 = list(mi_tuple)
print(lista_1)
```
[1, "dos", [3.33, "cuatro"], (5.0, 6)] # ahora es una estructura mutable
**unpacking** (extracción de datos)
```python
a, b, c, d = mi_tuple
print(c)
```
[3.33, "cuatro"]
## 3.8. - sets
Los sets son otro tipo de estructuras de datos. Se diferencian de listas, tuplas y diccionarios porque son una colección mutable de elementos inmutables, no ordenados y sin datos repetidos.
> mutable ✅ ordenado ❌ admite duplicados ❌
```python
mi_set_a = {1, 2, "tres"}
mi_set_b = {3, "tres"}
```
### 3.8.1. - Métodos set
```python
mi_set_a = {1, 2, "tres"}
mi_set_b = {3, "tres"}
```
**add(item)** agrega un elemento al set
```python
mi_set_a.add(5)
print(mi_set_a)
```
{1, 2, "tres", 5}
**clear( )** remueve todos los elementos de un set
```python
mi_set_a.clear()
print(mi_set_a)
```
set()
**copy( )** retorna una copia del set
```python
mi_set_c = mi_set_a.copy()
print(mi_set_c)
```
{1, 2, "tres"}
**difference(set)** retorna el set formado por todos los elementos que únicamente existen en el set A
```python
mi_set_c = mi_set_a.difference(mi_set_b)
print(mi_set_c)
```
{1, 2}
![](../img/dia03_11.png)
**difference_update(set)** remueve de A todos los elementos comunes a AyB
```python
mi_set_a.difference_update(mi_set_b)
print(mi_set_a)
```
{1, 2}
![](../img/dia03_12.png)
**discard(item)** remueve un elemento del set
```python
mi_set_a.discard("tres")
print(mi_set_a)
```
{1, 2}
**intersection(set)** retorna el set formado por todos los elementos que existen en A y B simultáneamente.
```python
mi_set_c = mi_set_a.intersection(mi_set_b)
print(mi_set_c)
```
{'tres'}
![](../img/dia03_13.png)
**intersection_update(set)** mantiene únicamente los elementos comunes a A y B
```python
mi_set_b.intersection_update(mi_set_a)
print(mi_set_b)
```
{"tres"}
![](../img/dia03_14.png)
**isdisjoint(set)** devuelve True si A y B no tienen elementos en común
```python
conjunto_disjunto = mi_set_a.isdisjoint(mi_set_b)
print(conjunto_disjunto)
```
False
![](../img/dia03_15.png)
**issubset(set)** devuelve True si todos los elementos de B están presentes en A
```python
es_subset = mi_set_b.issubset(mi_set_a)
print(es_subset)
```
False
![](../img/dia03_16.png)
**issuperset(set)** devuelve True si A contiene todos los elementos de B
```python
es_superset = mi_set_a.issuperset(mi_set_b)
print(es_superset)
```
False
![](../img/dia03_17.png)
**pop( )** elimina y retorna un elemento al azar del set
```python
aleatorio = mi_set_a.pop()
print(aleatorio)
```
{2}
**remove(item)** elimina un item del set, y arroja error si no existe
```python
mi_set_a.remove("tres")
print(mi_set_a)
```
{1, 2}
**symmetric_difference(set)** retorna todos los elementos de A y B, excepto aquellos que son comunes a los dos
```python
mi_set_c = mi_set_b.symmetric_difference(mi_set_a)
print(mi_set_c)
```
{1, 2, 3}
![](../img/dia03_18.png)
**symmetric_difference_update(set)** elimina los elementos comunes a A y B, agregando los que no están presentes en ambos a la vez
```python
mi_set_b.symmetric_difference_update(mi_set_a)
print(mi_set_b)
```
{1, 2, 3}
![](../img/dia03_19.png)
**union(set)** retorna un set resultado de combinar A y B (los datos duplicados se eliminan)
```python
mi_set_c = mi_set_a.union(mi_set_b)
print(mi_set_c)
```
{1, 2, 3, 'tres'}
![](../img/dia03_20.png)
**update(set)** inserta en A los elementos de B
```python
mi_set_a.update(mi_set_b)
print(mi_set_a)
```
{1, 2, 3, 'tres'}
![](../img/dia03_21.png)
## 3.9. - booleanos
Los booleanos son tipos de datos binarios (True/False), que surgen de operaciones lógicas, o pueden declararse explícitamente.
### 3.9.1. - operadores lógicos
| Operador | Descripción |
| :------: | :------------------------------------------- |
| `==` | igual a |
| `!=` | no igual a |
| `>` | mayor que |
| `<` | menos que |
| `>=` | mayor o igual a |
| `<=` | menor o igual a |
| `and` | y (True si dos declaraciones son True) |
| `or` | o (True si al menos una declaración es True) |
| `not` | no (invierte el valor del booleano |
## 3.10. - Proyecto del Día 3
Analizador de texto.
La consigna es la siguiente: vas a crear un programa que primero le pida al usuario que ingrese un texto. Puede ser un texto cualquiera: un artículo entero, un párrafo, una frase, un poema, lo que quiera.
Luego, el programa le va a pedir al usuario que también ingrese tres letras a su elección y a partir de ese momento nuestro código va a procesar esa información para hacer cinco tipos de análisis y devolverle al usuario la siguiente información:
1. Primero: ¿cuántas veces aparece cada una de las letras que eligió? Para lograr esto, te recomiendo almacenar esas letras en una lista y luego usar algún método propio de string que nos permita contar cuantas veces aparece un sub string dentro del string. Algo que debes tener en cuenta es que al buscar las letras pueden haber mayúsculas y minúsculas y esto va a afectar el resultado. Lo que deberías hacer para asegurarte de que se encuentren absolutamente todas las letras es pasar, tanto el texto original como las letras a buscar, a minúsculas.
2. Segundo: le vas a decir al usuario cuántas palabras hay a lo largo de todo el texto. Y para lograr esta parte, recuerda que hay un método de string que permite transformarlo en una lista y que luego hay una función que permite averiguar el largo de una lista.
3. Tercero: nos va a informar cuál es la primera letra del texto y cuál es la última. Aquí claramente echaremos mano de la indexación.
4. Cuarto: el sistema nos va a mostrar cómo quedaría el texto si invirtiéramos el orden de las palabras. ¿Acaso hay algún método que permita invertir el orden de una lista, y otro que permita unir esos elementos con espacios intermedios? Piénsalo.
5. Y por último: el sistema nos va a decir si la palabra “Python” se encuentra dentro del texto. Esta parte puede ser algo complicada de imaginársela, pero te voy a dar una pista: puedes usar booleanos para hacer tu averiguación y un diccionario para encontrar la manera de expresarle al usuario tu respuesta.
## Ficheros y documentación del día 3
- [01_index.py](01_index.py)
- [02_sub_strings.py](02_sub_strings.py)
- [03_metodos.py](03_metodos.py)
- [04_string.py](04_string.py)
- [05_propiedades.py](05_propiedades.py)
- [06_listas.py](06_listas.py)
- [07_diccionarios.py](07_diccionarios.py)
- [08_tuplas.py](08_tuplas.py)
- [09_set.py](09_set.py)
- [10_booleanos.py](10_booleanos.py)
- [11_programa03.py](11_programa03.py)
- [__pycache__](__pycache__)
[Documentación del día](../doc_curso/03_analizador_de_texto/)
---
Enlaces a todos los días: [dia 1 - creador de nombres](../dia_01/README.md) / [dia 2 - calculador de comisiones](../dia_02/README.md) / [dia 3 - analizador de texto](../dia_03/README.md) / [dia 4 - juego "adivina el número"](../dia_04/README.md) / [dia 5 - juego "El ahorcado"](../dia_05/README.md) / [dia 6 - recetario](../dia_06/README.md) / [dia 7 - cuenta bancaria](../dia_07/README.md) / [dia 8 - consola de turnos](../dia_08/README.md) / [dia 9 - buscador de números de serie](../dia_09/README.md) / [dia 10 - juego "Invasión espacial"](../dia_10/README.md) / [dia 11 - web scraping](../dia_11/README.md) / [dia 12 - gestor de restaurantes](../dia_12/README.md) / [dia 13 - asistente de voz](../dia_13/README.md) / [dia 14 - controlador de asistencia](../dia_14/README.md) / [dia 15 - machine learning](../dia_15/README.md) / [dia 16 - aplicación web de tareas pendientes](../dia_16/README.md)

23
python-total/dia_04/01_operadores_comparacion.py Normal file
View File

@@ -0,0 +1,23 @@
"""
Operadores de comparación
== igual a
!= diferente a
> mayor que
< menor que
>= mayor o igual que
<= menor o igual que
"""
mi_bool = 5 >= 6
print(mi_bool)
mi_bool = 5 != 6
print(mi_bool)
mi_bool = 10 == 2*5
print(mi_bool)
mi_bool = 5 < 6
print(mi_bool)

22
python-total/dia_04/02_operadores_logicos.py Normal file
View File

@@ -0,0 +1,22 @@
"""
Operadores lógicos
"""
a = 6 > 5
b = 30 == 15*3
mi_bool = a and b
print(mi_bool)
mi_bool = a or b
print(mi_bool)
mi_bool = not a
print(mi_bool)
mi_bool = (4>5) and (5 == 2+5)
print(mi_bool)
mi_bool = "perro" == "perro"
print()

31
python-total/dia_04/03_control_de_frujo.py Normal file
View File

@@ -0,0 +1,31 @@
"""
Control de flujo
if condición:
print(codigo)
elif otra_condición:
print(codigo)
else:
"""
x = True
if 5 == 2:
print("Es correcto")
else:
print("Parece que es falso")
edad = input("Dime tu edad: ")
edad = int(edad)
if edad <= 17:
print("Eres menor de edad")
calificacion = input("Que nota sacaste? ")
calificacion = int(calificacion)
if calificacion >= 5:
print("Felicitaciones! Has aprobado")
else:
print("No aprobado")
else:
print("Eres adulto")

80
python-total/dia_04/04_for.py Normal file
View File

@@ -0,0 +1,80 @@
"""
Ejemplos de bucles for
"""
nombres = ['Juan','Ana','Carlos','Belén','Fran']
for nombre in nombres:
print(f"Hola {nombre}")
print("")
lista = ['a','b','c','d']
for letra in lista:
numero_letra = lista.index(letra) + 1
print(f"Letra {numero_letra}: {letra}")
print("")
for nombre in nombres:
if nombre.startswith('B'):
print(f"Hola {nombre}")
print("")
numeros = [1,2,3,4,5]
mi_valor = 0
for numero in numeros:
mi_valor += numero
print(mi_valor)
print(f"Total ha sumado {mi_valor}")
print("")
# Si el numero de valores dentro de listas anidadas coincide
# se puede extraer su contenido buscando dos variables.
for i,j in [[1,2],['a','b'],[3,4]]:
print(i)
print(j)
print("")
# Diccionario
dic = {'clave1':'a', 'clave2':'b', 'clave3':'c'}
for item in dic:
print(item)
print("")
for item in dic.items():
print(item)
print("")
for item in dic.values():
print(item)
print("")
for a,b in dic.items():
print(a)
print(b)
print("")
# Ejercicio bonito de separar la suma de números de una lista
# por pares e impares
lista_numeros = [1,5,8,7,6,8,2,5,2,6,4,8,5,9,8,3,5,4,2,5,6,4]
suma_pares = 0
suma_impares = 0
for numero in lista_numeros:
if numero % 2 == 0:
suma_pares = suma_pares + numero
else:
suma_impares = suma_impares + numero
print(suma_pares)
print(suma_impares)

56
python-total/dia_04/05_while.py Normal file
View File

@@ -0,0 +1,56 @@
"""
Ejemplos de bucle while
"""
contador = 0
while contador < 10:
contador += 1
print(f"Iteración número {contador}")
print("Se cumplió la condición")
respuesta = 's'
while respuesta == 's':
respuesta = input("quieres seguir? (s/n) ")
else:
print("Gracias")
print("")
# pass Sirve para reservar un lugar en un bucle,
# no utilizarlo para recuperar quizá luego
while respuesta == 's':
pass
print("hola")
print("")
# break Sirve para romper un bucle y salir
nombre = input("Tu nombre: ")
for letra in nombre:
if letra == 'D':
break
print(letra)
print("")
# continue Interrumpe la iteración pero no sale,
# vuelve al inicio de la iteración
nombre = input("Tu nombre: ")
for letra in nombre:
if letra == 'D':
continue
print(letra)
comando = ""
while comando.lower() != "salir":
comando = input("$ ")
print(comando)

17
python-total/dia_04/06_rango.py Normal file
View File

@@ -0,0 +1,17 @@
"""
Rango
"""
# lista = [1,2,3,4,5]
# Puedes evitar las listas de numeros con range
for numero in range(5):
print(numero)
# Puedes decir el inicio, el final y los saltos
for numero in range(10,100,10):
print(numero)
# Se puede meter en listas
lista = list(range(1,101))
print(lista)

30
python-total/dia_04/07_enumerador.py Normal file
View File

@@ -0,0 +1,30 @@
"""
Enumerador
"""
lista = ['a', 'b', 'c']
indice = 0
for item in lista:
print(indice, item)
indice += 1
# Con el enumerador es mucho más elegante
for item in enumerate(lista):
print(item)
# La anterior devuelve un tuple,
# podemos separarla con una variable
for indice,item in enumerate(lista):
print(indice, item)
# Junto a range podemos extraer un indice de la iteración
for indice,item in enumerate(range(50,55)):
print(indice, item)
# Se puede utilizar para transformar una lista en un tuple
mis_tuples = list(enumerate(lista))
print(mis_tuples)
# Podemos acceder a un valor concreto a través de los indices
print(mis_tuples[1][1])

14
python-total/dia_04/08_zip.py Normal file
View File

@@ -0,0 +1,14 @@
"""
Zip
"""
nombres = ['Ana','Hugo','Valeria']
edades = [65,29,42,55]
ciudades = ['Lima','Madrid','Mexico']
# Cuidao, zip guarda las listas con el numero mínimo de las listas
combinados = list(zip(nombres,edades, ciudades))
for nombre,edad,ciudad in combinados:
print(f'{nombre} tiene {edad} años y vive en {ciudad}')

29
python-total/dia_04/09_min_max.py Normal file
View File

@@ -0,0 +1,29 @@
"""
min() y max()
"""
menor = min(56, 96, 72, 63, 35)
print(menor)
mayor = max(56, 96, 72, 63, 35)
print(mayor)
lista = [56, 96, 72, 63, 35]
print(f'El menor es {min(lista)} y el mayor es {max(lista)}')
# También funciona con strings, alfabéticamente, en listas
nombres = ['Juan', 'Pablo', 'Alicia', 'Carlos']
print(min(nombres))
# y en strings directamente. Buscando primero en las mayúsculas
# y después en las minúsculas
nombre = "Iñigo"
print(max(nombre))
# Y con los diccionarios
dic = {'C1':45,'C2':11}
print(min(dic)) # Esto revisa el diccionario completo
print(min(dic.values()))

31
python-total/dia_04/10_random.py Normal file
View File

@@ -0,0 +1,31 @@
"""
random
Necesitaremos importar métodos,
porque están en una librería llamada random
Veremos estos métodos:
randint()
uniform()
random()
choice()
shuffle()
"""
from random import *
aleatorio = randint(1, 50)
print(aleatorio)
aleatorio_float = round(uniform(1, 10),4)
print(aleatorio_float)
aleatorio_random = random()
print(aleatorio_random)
colores = ['rosa', 'verde','negro','azul']
aleatorio_choice = choice(colores)
print(aleatorio_choice)
numeros = list(range(5,50,5))
shuffle(numeros)
print(numeros)

70
python-total/dia_04/11_comprension_listas.py Normal file
View File

@@ -0,0 +1,70 @@
"""
Compresión de listas
"""
# Las compresión de listas susituye el siguiente ejemplo
lista = []
palabra = "python"
for letra in palabra:
lista.append(letra)
print(lista)
# Con una sintaxis más breve, de 4 a 1 linea
lista_comp = [letra for letra in "python"]
print(lista_comp)
# Ejemplo con operación
lista_num = [n /2 for n in range(0,21,2)]
print(lista_num)
# Ejemplo con condicional para agregar en la lista
lista_condici = [n for n in range(0,21,2) if n * 2 > 10]
print(lista_condici)
# Ejemplo anterior pero con else. Ahora es menos legible
# porque hay que ponerlo delante
# Lo que hacemos es sustituir el n por un texto
lista_else = [n if n * 2 > 10 else 'no' for n in range(0,21,2)]
print(lista_else)
# Ejemplo práctico
## Transformar pies en metros
pies = [10,20,30,40,50]
metros = []
for pie in pies:
metros.append(pie*3.281)
print(metros)
## Ahora la compresión del código
metros_compr = [pie*3.281 for pie in pies]
print(metros_compr)
# Valores cuadrados
valores = [1, 2, 3, 4, 5, 6, 9.5]
valores_cuadrados = [v**2 for v in valores]
print(valores_cuadrados)
# Guardar pares en la lista
valores_pares = [v for v in valores if (v%2 == 0)]
print(valores_pares)
# De fahrenheit a celsius
temperatura_fahrenheit = [32, 212, 275]
grados_celsius = [(grados_fahrenheit-32)*(5/9) for grados_fahrenheit in temperatura_fahrenheit]
print(grados_celsius)

57
python-total/dia_04/12_match.py Normal file
View File

@@ -0,0 +1,57 @@
"""
match
"""
# Hasta ahora se usaba el if
serie = "N-02"
if serie == "N-01":
print("Samsung")
elif serie == "N-02":
print("Nokia")
elif serie == "N-03":
print("Motorola")
else:
print("No existe ese producto")
# En otros lenguajes ya se usaba swich case o parecidos
# A partir de la versión 3.10, python incorpora match
match serie:
case "N-01":
print("Samsung")
case "N-02":
print("Nokia")
case "N-03":
print("Motorola")
case _:
print("No existe ese producto")
# Ejemplo que muestra todo el potencial
# Permite encontrar patrones
cliente = {'nombre':
'Federico',
'edad': 45,
'ocupacion': 'instructor'}
pelicula = {'titulo':'matrix',
'ficha_tecnica':{'protagonista':'Keanu reeves',
'director':'Lana y Lilly Wachowski'}}
elementos = [cliente, pelicula, 'libro']
for e in elementos:
match e:
case {'nombre':nombre,
'edad': edad,
'ocupacion': ocupacion}:
print("Es un cliente")
print(nombre, edad, ocupacion)
case {'titulo':titulo,
'ficha_tecnica':{'protagonista': protagonista,
'director': director}}:
print("Es una pelicula")
print(titulo, protagonista, director)
case _:
print("No se que es esto")

123
python-total/dia_04/13_programa04.py Normal file
View File

@@ -0,0 +1,123 @@
"""
Programa día 4 - Juego "Adivina el número"
"""
# Importamos módulos
from random import randint
import itertools
import threading
import time
import sys
import os
# Funciones
# Función limpiar consola
def clearConsole():
command = 'clear'
if os.name in ('nt', 'dos'): # If Machine is running on Windows, use cls
command = 'cls'
os.system(command)
# Función de la animación para 'pensar'
def animate():
for c in itertools.cycle(['|', '/', '-', '\\']):
if DONE:
break
sys.stdout.write('\rPensando un número ' + c)
sys.stdout.flush()
time.sleep(0.1)
sys.stdout.write('\rYa tengo el número! ')
sys.stdout.write('\nA ver si aciertas, dime un número: ')
# Función validar input es un número
def validar(dato, tipos):
for tipo in tipos:
try:
return tipo(dato)
except ValueError:
pass
return None
# Limpiar la terminal
clearConsole()
# Mensaje bienvenida
print("\n#########################")
print("JUEGO - Adivina el número")
print("#########################\n")
# Pregunta nombre, saluda y explica el juego (Con opción a salir)
nombre = input("¿Cuál es tu nombre? ")
print(f"\nOk {nombre}, voy a pensar un número del 1 al 100.")
print("Tienes 8 intentos para adivinarlo\n")
# Filigrana como que piensa la máquina
DONE = False
t = threading.Thread(target=animate)
t.start()
# El tiempo de ejecución
time.sleep(3)
DONE = True
# Guardando el número secreto
n_secreto = randint(1, 100)
# Bucle de intentos y control de flujo
for intentos in range(8):
# Calcular intentos restantes
lista_intentos = list(range(8))
lista_intentos.reverse()
intentos_restantes = lista_intentos.pop(intentos)
# Pregunta posible número y valida que es de type número
while True:
n_posible = input("Dime un número: ")
x = validar(n_posible, (int, float, complex))
if x is None:
print("Error: El dato introducido no es un número\n")
else:
break
# Para comparar el número se necesita que sea integer
n_posible = int(n_posible)
# Posibles casuísticas
# Si el número no está en el rango especificado
if (n_posible < 1) or (n_posible > 100):
print("\nEse número no está entre el 1 y el 100")
print(
f"Desperdiciaste un turno, te quedan {intentos_restantes} intentos")
# Si el número es menor
elif n_posible > n_secreto:
print(
f"\nLo siento, has fallado.Te quedan {intentos_restantes} intentos.")
print("\n\tPista --> El número es menor.\n")
# Si el número es mayor
elif n_posible < n_secreto:
print(
f"\nLo siento, has fallado.Te quedan {intentos_restantes} intentos.")
print("\n\tPista --> El número es mayor.\n")
# Si se acierta el número
elif n_posible == n_secreto:
print("\n¡Ole! ¡¡¡¡HAS ACERTADO!!!!")
intentos += 1
print(f"¡Felicidades {nombre}!\nLo conseguiste en {intentos} intentos")
break
# Si se agotan los intentos
if intentos == 7:
print(
f"\n¡Vaya! Has gastado los 8 intentos.\nEl número pensado era el {n_secreto}.\n Otra vez será...\nCiao!")
print("\n¡Espero que te hayas divertido!")

326
python-total/dia_04/README.md Normal file
View File

@@ -0,0 +1,326 @@
# Día 4 - Programa el juego "adivina el número"
## Índice
- [Día 4 - Programa el juego "adivina el número"](dia_04/README.md)
- [4.1. - Operadores de comparación](dia_04/01_operadores_de_comparacion.md)
- [4.2. - Operadores lógicos](dia_04/02_operadores_logicos.md)
- [4.3. - Control de flujo](dia_04/03_control_de_flujo.md)
- [4.4. - loops while](dia_04/04_loops_while.md)
- [4.5. - range( )](dia_04/05_range.md)
- [4.6. - enumerate( )](dia_04/06_enumerate.md)
- [4.7. - zip( )](dia_04/07_zip.md)
- [4.8. - min( ) & max( )](dia_04/08_min_max.md)
- [4.9. - random](dia_04/09_random.md)
- [4.10. - Comprensión de listas](dia_04/10_comprension_de_listas.md)
- [4.11. - match](dia_04/11_match.md)
- [4.12. - Proyecto del Día 4](dia_04/12_proyecto.md)
## 4.1. - Operadores de comparación
Como su nombre lo indica, sirven para comparar dos o más valores. El resultado de esta comparación es un booleano (True/False)
| Operador | Descripción |
| :------: | :---------------- |
| == | Igual a |
| != | Diferente a |
| > | Mayor que |
| < | Menor que |
| >= | mayor o igual que |
| <= | menor o igual que |
Si la comparación resulta verdadera, devuelve el resultado *True*
Si dicha comparación es falsa, el resultado es *False*
```python
mi_bool = 5 >= 6
print(mi_bool)
```
False
```python
mi_bool = 5 != 6
print(mi_bool)
```
True
```python
mi_bool = 10 == 2*5
print(mi_bool)
```
True
```python
mi_bool = 5 < 6
print(mi_bool)
```
True
## 4.2. - Operadores lógicos
Estos operadores permiten tomar decisiones basadas en múltiples condiciones.
```python
a = 6 > 5
b = 30 == 15*3
```
**and** devuelve True si todas las condiciones son verdaderas
```python
mi_bool = a and b
print(mi_bool)
```
False
**or** devuelve True si al menos una condición es verdadera
```python
mi_bool = a or b
print(mi_bool)
```
True
**not** devuelve True si el valor del booleano es False, y False si es True
```python
mi_bool = not a
print(mi_bool)
```
False
## 4.3. - Control de flujo
El control de flujo determina el orden en que el código de un programa se va ejecutando. En Python, el flujo está controlado por estructuras condicionales, loops y funciones.
### 4.3.1. - Estructuras condicionales (if)
- Expresión de resultado booleano (True/False)
- La indentación es obligatoria en Python
- Los dos puntos (:) dan paso al código que se ejecuta si expresión = True
```python
if expresión:
código a ejecutarse
elif expresión:
código a ejecutarse
elif expresión:
código a ejecutarse
...
else:
código a ejecutarse
```
- *else & elif* son opcionales y pueden incluirse varias cláusulas elif
## 4.4. - loops while
Si bien los loops while son otro tipo de bucles, resultan más parecidos a los condicionales if que a los loops for. Podemos pensar a los loops while como una estructura condicional que se ejecuta en repetición, hasta que se convierte en falsa.
```python
while condición:
expresión
else:
expresión
```
- Se compone de la Estructura condicional seguida de dos puntos (:)
- La indentación es obligatoria en Python.
- Este código se ejecutará cuando la condición se convierta en False
### 4.4.1. - instrucciones especiales
- Si el código llega a una instrucción break, se produce la salida del bucle.
- La instrucción continue interrumpe la iteración actual dentro del bucle, llevando al programa a la parte superior del bucle.
- La instrucción pass no altera el programa: ocupa un lugar donde se espera una declaración, pero no se desea realizar una acción.
## 4.5. - range( )
La función range( ) devuelve una secuencia de números dados 3 parámetros. Se utiliza fundamentalmente para controlar el número de ejecuciones de un loop o para crear rápidamente una serie de valores.
- *valor_inicio* - número a partir del cual inicia el rango (incluido)
- *valor_final* - número antes del cual el rango finaliza (no incluido)
- *paso* - diferencia entre cada valor consecutivo de la secuencia
Sintaxis:
```python
range(valor_inicio, valor_final, paso)
print(list(range(1,13,3)))
```
[1,4,7,10]
El único parámetro obligatorio es *valor_final*. Los valores predeterminados para *valor_inicio* y *paso* son 0 y 1 respectivamente.
## 4.6. - enumerate( )
La función enumerate( ) nos facilita llevar la cuenta de las iteraciones, a través de un contador de índices de un iterable, que se puede utilizar de manera directa en un loop, o convertirse en una lista de tuplas con el método list( ).
- *iterable* - Cualquier objeto que pueda ser iterado
- *inicio* - Valor [int] de inicio del índice (por defecto iniciado en 0)
Sintaixs:
```python
enumerate(iterable, inicio)
print(list(enumerate("Hola")))
```
[(0, 'H'), (1, 'o'), (2, 'l'), (3, 'a')]
```python
for indice, numero in enumerate([5.55, 6, 7.50]):
print(indice, numero)
```
0 5.55
1 6
2 7.5
## 4.7. - zip( )
La función zip( ) crea un iterador formado por los elementos agrupados del mismo índice provenientes de dos o más iterables. Zip deriva de zipper (cremallera o cierre), de modo que es una analogía muy útil para recordar.
La función se detiene al cuando se agota el iterable con menor cantidad de elementos.
```python
letras = ['w', 'x', 'c']
numeros = [50, 65, 90, 110, 135]
for letra, num in zip(letras, numeros):
print(f'Letra: {letra}, y Número: {num}')
```
Letra: w, y Número: 50
Letra: x, y Número: 65
Letra: c, y Número: 90
## 4.8. - min( ) & max( )
La función min( ) retorna el item con el valor más bajo dentro de un iterable. La función max( ) funciona del mismo modo, devolviendo el valor más alto del iterable. Si el iterable contiene strings, la comparación se realiza alfabéticamente.
```python
ciudades_habitantes = {"Tijuana":1810645, "León":1579803}
lista_valores = [5**5, 12**2, 3050, 475*2]
print(min(ciudades_habitantes.keys()))
```
León
```python
print(max(ciudades_habitantes.values()))
```
1810645
```python
print(max(lista_valores))
```
3125
## 4.9. - random
Python nos facilita un módulo (un conjunto de funciones disponibles para su uso) que nos permite generar selecciones pseudo-aleatorias* entre valores o secuencias.
Nombre del módulo:
```python
from random import *
```
* = Todos los métodos
También pueden importarse de manera independiente aquellos a utilizar.
**randint(min, max)**: devuelve un integer entre dos valores dados (ambos límites incluidos)
**uniform(min, max)**: devuelve un float entre un valor mínimo y uno máximo
**random(sin parámetros)**: devuelve un float entre 0 y 1
**choice(secuencia)**: devuelve un elemento al azar de una secuencia de valores (listas, tuples, rangos, etc.)
**shuffle(secuencia)**: toma una secuencia de valores mutable (como una lista), y la retorna cambiando el orden de sus elementos aleatoriamente.
* La mecánica en cómo se generan dichos valores aletorios viene en realidad predefinida en "semillas". Si bien sirve para todos los usos habituales, no debe emplearse con fines de seguridad o criptográficos, ya que son vulnerables.
## 4.10. - Comprensión de listas
La comprensión de listas es una manera dinámica de construir una lista. Ofrece una sintaxis más breve en la creación de una nueva lista basada en valores disponibles en otra secuencia. Vale la pena mencionar que la brevedad se logra a costo de una menor interpretabilidad. Sintaxis:
```python
nueva_lista= [expresion for item in iterable if condicion == True]
```
*expresión* - fórmula matemática
*Item* - cada elemento del iterable
*iterable* - tuplas, sets, otras listas...
*condicion == True * - operación lógica
Caso especial con else:
```python
nueva_lista= [expresion if condicion == True else otra_expresion for item in iterable]
```
Ejemplo:
```python
nueva_lista = [num**2 for num in range(10) if num < 5]
print(nueva_lista)
```
[0, 1, 4, 9, 16]
## 4.11. - match
En Python 3.10, se incorpora la coincidencia de patrones estructurales mediante las declaraciones match y case. Esto permite asociar acciones específicas basadas en las formas o patrones de tipos de datos complejos.
```python
match objeto:
case <patron_1>:
<accion_1>
case <patron_2>:
<accion_2>
case <patron_3>:
<accion_3>
case _:
<accion_comodin>
```
El caracter _ es un comodín que actúa como coincidencia si la misma no se produce en los casos anteriores.
Es posible detectar y deconstruir diferentes estructuras de datos: esto quiere decir que los patrones no son únicamente valores literales (strings o números), sino también estructuras de datos, sobre los cuales se buscan coindicencias de construcción.
## 4.12. - Proyecto del Día 4
La consigna es esta: el programa le va a preguntar al usuario su nombre, y luego le va a decir algo así como “Bueno, Juan, he pensado un número entre 1 y 100, y tienes solo ocho intentos para adivinar cuál crees que es el número”. Entonces, en cada intento el jugador dirá un número y el programa puede responder cuatro cosas distintas:
- Si el número que dijo el usuario es menor a 1 o superior a 100, le va a decir que ha elegido un número que no está permitido.
- Si el número que ha elegido el usuario es menor al que ha pensado el programa, le va a decir que su respuesta es incorrecta y que ha elegido un número menor al número secreto.
- Si el usuario eligió un número mayor al número secreto, también se lo hará saber de la misma manera.
- Y si el usuario acertó el número secreto, se le va a informar que ha ganado y cuántos intentos le ha tomado.
Si el usuario no ha acertado en este primer intento, se le va a volver a pedir que elija otro número. Y así hasta que gane o hasta que se agoten los ocho intentos.
## Ficheros y documentación del día 4
- [01_operadores_comparacion.py](01_operadores_comparacion.py)
- [02_operadores_logicos.py](02_operadores_logicos.py)
- [03_control_de_frujo.py](03_control_de_frujo.py)
- [04_for.py](04_for.py)
- [05_while.py](05_while.py)
- [06_rango.py](06_rango.py)
- [07_enumerador.py](07_enumerador.py)
- [08_zip.py](08_zip.py)
- [09_min_max.py](09_min_max.py)
- [10_random.py](10_random.py)
- [11_comprension_listas.py](11_comprension_listas.py)
- [12_match.py](12_match.py)
- [13_programa04.py](13_programa04.py)
[Documentación del día](../doc_curso/04_adivinar_numero/)
---
Enlaces a todos los días: [dia 1 - creador de nombres](../dia_01/README.md) / [dia 2 - calculador de comisiones](../dia_02/README.md) / [dia 3 - analizador de texto](../dia_03/README.md) / [dia 4 - juego "adivina el número"](../dia_04/README.md) / [dia 5 - juego "El ahorcado"](../dia_05/README.md) / [dia 6 - recetario](../dia_06/README.md) / [dia 7 - cuenta bancaria](../dia_07/README.md) / [dia 8 - consola de turnos](../dia_08/README.md) / [dia 9 - buscador de números de serie](../dia_09/README.md) / [dia 10 - juego "Invasión espacial"](../dia_10/README.md) / [dia 11 - web scraping](../dia_11/README.md) / [dia 12 - gestor de restaurantes](../dia_12/README.md) / [dia 13 - asistente de voz](../dia_13/README.md) / [dia 14 - controlador de asistencia](../dia_14/README.md) / [dia 15 - machine learning](../dia_15/README.md) / [dia 16 - aplicación web de tareas pendientes](../dia_16/README.md)

34
python-total/dia_05/01_metodos_ayuda_docs.py Normal file
View File

@@ -0,0 +1,34 @@
"""
Métodos, ayuda y documentación
"""
dic = {'clave1': 100, 'clave2': 500}
a = dic.popitem()
print(a)
print(dic)
# Ejercicio 1
exer1 = ",:_#,,,,,,:::____##Pyt%on_ _Total,,,,,,::#".lstrip(",:%_#")
print(exer1)
# Ejercicio 2
frutas = ["mango", "banana", "cereza", "ciruela", "pomelo"]
frutas.insert(3, "naranja")
print(frutas)
# Ejercicio 3
marcas_smartphones = {"Samsung", "Xiaomi", "Apple", "Huawei", "LG"}
marcas_tv = {"Sony", "Philips", "Samsung", "LG"}
conjuntos_aislados = marcas_smartphones.isdisjoint(marcas_tv)
print(conjuntos_aislados)

32
python-total/dia_05/02_funciones.py Normal file
View File

@@ -0,0 +1,32 @@
"""
funciones
"""
# Simpple
def suma5(nombre):
"""
Esto es una función para decir hola
"""
print("Hola! " + nombre)
name = input("Dime tu nombre: ")
for i in range(5):
suma5(name)
# return
def sumar(num1,num2):
total = num1 + num2
return total
resultado = sumar(10,5)
print(resultado)
# Ejercicio de codificación
def invertir_palabra(palabra):
reverso = palabra[::-1]
return reverso
print(invertir_palabra("Python").upper())

61
python-total/dia_05/03_funciones_dinamicas.py Normal file
View File

@@ -0,0 +1,61 @@
"""
funciones Dinamicas
"""
# Simple, comprobar numeros de 3 cifras
def chequear_3_cifras(numero):
return numero in range(100,1000)
suma = 347 + 231
resultado = chequear_3_cifras(suma)
print(resultado)
# Comprobar de listas si los numeros tienen 3 cifras
# return hará que se pare el bucle, como un break
def chequear_3_cifras_listas(lista):
for n in lista:
if n in range(100,1000):
return True
else:
pass
# Para que el return false funcione bien debería estar indentado aquí
lista_num = [1,34,21,15,23,2000]
comprobacion = chequear_3_cifras_listas(lista_num)
print(comprobacion)
## Siendo falso dará un tipo None
print(type(comprobacion))
## No tenía un return False
# Ejercicio comprobar positivos
def todos_positivos(lista):
for n in lista:
if n < 0:
return False
else:
pass
return True
lista_posibles_pos = [13,234,5343,7276,-1]
print(todos_positivos(lista_posibles_pos))
# Ejercicio sumar numeros entre 0 y 1000
def suma_menores(lista):
resultado2 = 0
for num in lista:
if num > 0 and num < 1000:
resultado2 += num
else:
pass
return resultado2
lista_numeros = [13,234,5343,7276,-1]
ver = suma_menores(lista_numeros)
print(ver)

34
python-total/dia_05/04_ejemplo_funcion.py Normal file
View File

@@ -0,0 +1,34 @@
"""
Ejemplo de función
"""
# Para desempacar tuples sin funciones
# por ejemplo, para saber el costo de los precios
precios_cafe = [('capuchino',1.5),('expresso',2.2),('moka',1.9)]
for cafe,precio in precios_cafe:
print(precio * 0.45)
# Pero para saber cual es el café mas caro no nos sirve
# Debemos usar una función:
def cafe_mas_caro(lista_precios):
precio_mayor = 0
cafe_mas_caro = ''
for cafe,precio in lista_precios:
if precio > precio_mayor:
precio_mayor = precio
cafe_mas_caro = cafe
else:
pass
return(cafe_mas_caro, precio_mayor)
## Podemos extraer las variables que retorna la función
cafe, precio = cafe_mas_caro(precios_cafe)
print(f"El café más caro es {cafe} con un precio de {precio}")

47
python-total/dia_05/05_palito_mas_corto.py Normal file
View File

@@ -0,0 +1,47 @@
"""
Interacción entre funciones
Programa "Escoge un palito"
"""
from random import shuffle
# Lista inicial y presentación
palitos = ['-','--','---','----']
print("¡Hola!\n")
print(f"Tenemos estos palitos:")
for palito in palitos:
print(palito)
print("\nVamos a mezclarlos y a relacionarlos con un número.\n")
# Mezclar palitos
def mezclar(lista):
shuffle(palitos)
return lista
# Pedir al usuario intento
def probar_suerte():
intento = ''
while intento not in ['1','2','3','4']:
intento = input("Elige un número del 1 al 4: ")
if intento not in ['1','2','3','4']:
print("\nError: Ingresa un valor válido\n")
else:
pass
return int(intento)
# Comprobar intento
def chequear_intento(lista,intento):
if lista[intento - 1] == '-':
print("¡Cogiste el palito más corto!\n")
else:
print("Lo siento, no es el más corto: \n")
print(lista[intento-1])
print()
# Invocamos las funciones
palitos_mezclados = mezclar(palitos)
seleccion = probar_suerte()
chequear_intento(palitos_mezclados, seleccion)

59
python-total/dia_05/06_lanzar_dados.py Normal file
View File

@@ -0,0 +1,59 @@
"""
Interacción entre funciones
LANZAR DOS DADOS
"""
from random import randint
# Función para obtener dos valores aleatorios
# entre el 1 y el 6
def lanzar_dados():
dado1 = randint(1, 6)
dado2 = randint(1, 6)
return dado1, dado2
# Función para evaluar la tirada
def evaluar_jugada(num1, num2):
suma_dados = num1 + num2
text1 = "La suma de tus dados es "
if suma_dados <= 4:
suma_dados = str(suma_dados)
mensaje = text1 + suma_dados + ". \nLamentable\n"
elif suma_dados > 4 and suma_dados <= 7:
suma_dados = str(suma_dados)
mensaje = text1 + suma_dados + ". \nBueno... esta bien.\n"
elif suma_dados > 7 and suma_dados < 10:
suma_dados = str(suma_dados)
mensaje = text1 + suma_dados + ". \nBuena tirada!\n"
else:
suma_dados = str(suma_dados)
mensaje = text1 + suma_dados + ". \nParece una jugada ganadora\n"
return mensaje
# Presentación
print("¡Vamos a tirar los dados!\n")
bandera = 's'
while bandera.lower() != "n":
# Control de flujo
if bandera.lower() == 's':
# Recogida de los valores
n1, n2 = lanzar_dados()
resultado = evaluar_jugada(n1, n2)
print(f"{resultado}")
elif bandera.lower() != 'n' or bandera.lower() != 's':
print("¿Que me estás contando?\n\t Sí ---> s\n\t No ---> n")
bandera = 's'
else:
print("\n¡Ciao!")
break
# Pregunta si quieres seguir jugando
bandera = input("¿Quieres tirar de nuevo? (s/n) ")

44
python-total/dia_05/07_limpiar_lista_promedio.py Normal file
View File

@@ -0,0 +1,44 @@
lista_numeros = [1, 2, 15, 7, 2, 3]
def reducir_lista(lista):
lista.sort()
lista_limpia = set(lista)
max_value = max(lista_limpia)
lista_limpia.remove(max_value)
return lista_limpia
def promedio(lista):
total = 0
for x in lista:
total += x
resultado = total / len(lista)
return resultado
lista2 = reducir_lista(lista_numeros)
media = promedio(lista2)
print(f"La lista limpia es {lista2}")
print(f"El valor medio de la lista resultante es {media}")
# Otra opción de limpiar la lista
def reducir_lista2(lista):
lista.sort()
lista_limpia = []
for n in lista:
if n not in lista_limpia:
lista_limpia.append(n)
max_value = max(lista_limpia)
lista_limpia.remove(max_value)
return lista_limpia
lista3 = reducir_lista2(lista_numeros)
print(f"Otra opción de limpiar la lista: {lista3}")

26
python-total/dia_05/08_lanzar_moneda.py Normal file
View File

@@ -0,0 +1,26 @@
from random import choice
def lanzar_moneda():
lista = ['Cara', 'Cruz']
cara_moneda = choice(lista)
return cara_moneda
def probar_suerte(resultado, lista):
if resultado == 'Cara':
print('La lista se autodestruirá')
lista.clear()
elif resultado == 'Cruz':
print("La lista fue salvada")
else:
pass
return lista
lista_numeros = [1, 3, 5, 2, 3, 145]
mon = lanzar_moneda()
mensaje = probar_suerte(mon, lista_numeros)
print(mon, mensaje)

172
python-total/dia_05/09_args_indeterminados.py Normal file
View File

@@ -0,0 +1,172 @@
"""
Argumentos indeterminados
*args ---> Arguments
Para definir funciones que acepten
un número indeterminado de variables
**kwargs ---> Keyword arguments
Definen funciones que acepten
diccionarios. Podemos añadir un número indeterminado
de variables y de key=value
"""
# Ejemplo de *args
# Argumentos args es una tupla, no se puede modificar
def suma(*numeros):
resultado = 0
for numero in numeros:
resultado += numero
return resultado
calculo = suma(24, 45, 22, 43, 454, 23, 12)
print(calculo)
# Ejercicio 1 - Suma cuadrados
def suma_cuadrados(*numeros):
resultado = 0
for numero in numeros:
resultado += numero**2
return resultado
print(suma_cuadrados(1, 2, 3))
# Ejercicio 2 - Suma solo absolutos
def suma_absolutos(*numeros):
resultado = 0
for numero in numeros:
resultado += abs(numero)
return resultado
print(suma_absolutos(1, -2, 3))
# Ejercicio 3 - mezclar variable y *args
def numeros_persona(nombre, *numeros):
suma_numeros = 0
for numero in numeros:
suma_numeros += numero
suma_numeros = str(suma_numeros)
para_devolver = nombre + " la suma de tus números es " + suma_numeros
return para_devolver
print(numeros_persona("Mun", 1, 3, 4, 2, 4))
# Ejemplo de **kwargs - Explicación conceptual
# Cuando pasamos los valores al kwargs
# este lo convierte en diccionario
def suma_dic(**kwargs):
print(type(kwargs))
suma_dic(x=3, y=5, z=2)
# Otro ejemplo
def suma_diccio(**kwargs):
total = 0
for clave, valor in kwargs.items():
print(f"{clave} es igual a {valor}")
total += valor
return total
print(suma_diccio(x=3, y=5, z=2))
# Con lo cual, también podemos añadir
# - Parámetros
# - *args
# - **kwargs
# Y todo en la misma función
# Deberían seguir siempre este orden
def prueba(num1, num2, *args, **kwargs):
print(f'El primer valor es {num1}')
print(f'El segundo valor es {num2}')
for arg in args:
print(f"arg es igual a {arg}")
for clave, valor in kwargs.items():
print(f"{clave} es igual a {valor}")
prueba(15, 50, 100, 200, 300, 400, x='uno', y='dos', z='tres')
# Truco para desempacar listas o tuplas
# Poner los astericos en los argumentos que se le pasa a la función
def la_lista(*lista, **dic):
for arg in lista:
print(f"arg es igual a {arg}")
for clave, valor in dic.items():
print(f"{clave} es igual a {valor}")
para_args = [1000, 2000, 3000, 4000]
kwargs = {'x': 'uno', 'y': 'dos', 'z': 'tres'}
la_lista(*para_args, **kwargs)
# Ejercicio 1 - cantidad de atributos
def cantidad_atributos(**cuentas):
contador = 0
for x in cuentas.items():
contador += 1
return contador
print(len(cuentas))
print(cantidad_atributos(x='color_ojos'))
# Ejercicio 2 - Lista atributos de values
def lista_atributos(**lista):
listado = []
for clave in lista.values():
listado.append(clave)
return listado
print(lista_atributos(x='uno', y='dos', z='tres'))
# Ejercicio 3 -
def describir_persona(nombre, **kwargs):
print(f'Características de {nombre}:')
for nombre_argumento, valor_argumento in kwargs.items():
print(f'{nombre_argumento}: {valor_argumento}')
describir_persona("María", color_ojos="azules", color_pelo="rubio")

163
python-total/dia_05/10_problemas_practicos.py Normal file
View File

@@ -0,0 +1,163 @@
"""
Problemas prácticos
"""
# Ejercicio ############
# Crea una función llamada devolver_distintos() que reciba 3 integers como parámetros.
# Si la suma de los 3 números es mayor a 15, va a devolver el número mayor.
# Si la suma de los 3 números es menor a 10, va a devolver el número menor.
# Si la suma de los 3 números es un valor entre 10 y 15 (incluidos) va a devolver el número de valor intermedio.
def devolver_distintos(num1, num2, num3):
suma = num1 + num2 + num3
lista = [num1, num2, num3]
if suma > 15:
return max(lista)
elif suma < 10:
return min(lista)
else:
lista.sort()
return lista[1]
print(devolver_distintos(6, 5, 3))
# Ejercicio 2 ############
# Escribe una función (puedes ponerle cualquier nombre que quieras)
# que reciba cualquier palabra como parámetro,
# y que devuelva todas sus letras únicas (sin repetir) pero en orden alfabético.
# Por ejemplo si al invocar esta función pasamos la palabra "entretenido",
# debería devolver ['d', 'e', 'i', 'n', 'o', 'r', 't']
def cualquier(palabra):
mi_set = set()
for letra in palabra:
mi_set.add(letra)
lista = list(mi_set)
lista.sort()
return lista
print("\n")
print(cualquier('entretenido'))
print(cualquier('cascarrabias'))
# Ejercicio 3 ############
# Escribe una función que requiera una cantidad indefinida de argumentos.
# Lo que hará esta función es devolver True
# si en algún momento se ha ingresado al numero cero repetido dos veces consecutivas.
# Por ejemplo:
# (5,6,1,0,0,9,3,5) >>> True
# (6,0,5,1,0,3,0,1) >>> False
def me_gustan_los_ceros(*ceros):
contador = 0
for num in ceros:
if num == 0:
contador += 1
if contador == 2:
contador = 0
return True
elif num != 0:
contador = 0
else:
pass
return False
print("\n")
print(me_gustan_los_ceros(5, 6, 1, 0, 0, 9, 3, 5))
print(me_gustan_los_ceros(6, 0, 5, 1, 0, 3, 0, 1))
# Solución curso
def ceros_vecinos(*args):
contador = 0
for num in args:
if contador + 1 == len(args):
return False
elif args[contador] == 0 and args[contador + 1] == 0:
return True
else:
contador += 1
return False
print("\n")
print(ceros_vecinos(5, 6, 1, 0, 0, 9, 3, 5))
print(ceros_vecinos(6, 0, 5, 1, 0, 3, 0, 1))
# Ejercicio 4 ############
# Escribe una función llamada contar_primos() que requiera un solo argumento numérico.
# Esta función va a mostrar en pantalla todos los números primos existentes
# en el rango que va desde cero hasta ese número incluido,
# y va a devolver la cantidad de números primos que encontró.
# Aclaración, por convención el 0 y el 1 no se consideran primos.
def primo(numero):
if numero == 0 or numero == 1 or numero == 4:
return False
for x in range(2, int(numero/2)):
if numero % x == 0:
return False
return True
def primos(rango_max):
rango_max += 1
lista_num = [n for n in range(1, rango_max)]
primos = []
for numero in lista_num:
es_primo = primo(numero)
if es_primo:
primos.append(numero)
contar = len(primos)
rango_max -= 1
print(f"\nEntre 0 y el {rango_max} hay {contar} números primos:")
print(*primos, sep=' ')
primos(1000)
# Solución curso
def contar_primos(numero):
primos2 = [2]
iteracion = 3
if numero < 2:
return 0
while iteracion <= numero:
for n in range(3, iteracion, 2):
if iteracion % n == 0:
iteracion += 2
break
else:
primos2.append(iteracion)
iteracion += 2
print(primos2)
return len(primos2)
print("\n")
print(contar_primos(1000))

349
python-total/dia_05/11_programa05.py Normal file
View File

@@ -0,0 +1,349 @@
'''
Programa día 5 - Juego del ahorcado
'''
from random import choice
import os
def clearConsole():
# Función limpiar consola
command = 'clear'
if os.name in ('nt', 'dos'): # If Machine is running on Windows, use cls
command = 'cls'
os.system(command)
def palabra_aleatoria():
# Función que guarda palabras en una lista y escoge una aleatoria con choice
lista_palabras = ('Argentina', 'Colombia', 'Guadalupe', 'Herramientas', 'Hogar', 'Murcielago',
'Uruguay', 'abdomen', 'abrelatas', 'abrigo', 'abuelo', 'aburrimiento',
'accion', 'agridulce', 'aguila', 'aguja', 'ahorcado', 'aire',
'alegria', 'Alemania', 'alfabeto', 'alimento', 'alma', 'almacen',
'almendra', 'alto', 'altura', 'amanecer', 'amarillo', 'ambiente',
'ambulancia', 'amiga', 'amigo', 'amor', 'analisis', 'ancho',
'anciano', 'animal', 'anochecer', 'aparato', 'apartamento', 'apoyo',
'araña', 'arbol', 'archiduque', 'area', 'aritmetica', 'arma',
'arroz', 'arte', 'articulo', 'ascensor', 'asiento', 'asociacion',
'aspecto', 'ataque', 'atencion', 'atmosfera', 'atomo', 'atun',
'aumento', 'autobus', 'automovil', 'coche', 'auto', 'autopista',
'autor', 'autoridad', 'avance', 'avena', 'avenida', 'avion',
'ayer', 'ayuda', 'azul', 'año', 'babosa', 'baloncesto',
'bambu', 'barba', 'barco', 'barro', 'lodo', 'base',
'bateria', 'bebe', 'bebida', 'beneficio', 'bicho', 'bigote',
'billete', 'bisabuelo', 'bisnieto', 'blanco', 'boca', 'boleto',
'bolsa', 'bolsillo', 'bolso', 'bomberos', 'bondad', 'bosque',
'boton', 'bragas', 'calzon', 'brazo', 'buey', 'bufanda',
'bus', 'busqueda', 'caballo', 'yegua', 'cabello', 'cabeza',
'cable', 'cabo', 'cadera', 'calamar', 'calcetines', 'calculadora',
'calendario', 'calidad', 'calle', 'calor', 'calzoncillo', 'cama',
'camara', 'camaron', 'cambio', 'camino', 'camisa', 'camiseta',
'campaña', 'campo', 'cansancio', 'cantidad', 'capacidad', 'capital',
'cara', 'caracol', 'caracter', 'caracteristica', 'cargo', 'carne',
'carpeta', 'carrera', 'carretera', 'carta', 'cartera', 'casa',
'casco', 'caso', 'castaña', 'castaño', 'causa', 'cebada',
'celeste', 'celular', 'centimetro', 'cerdo', 'cerebro', 'cero',
'cerradura', 'cerro', 'monte', 'montaña', 'cesped', 'chaqueta',
'chino', 'cielo', 'cien', 'ciento', 'ciencia', 'cierre',
'ciervo', 'cinco', 'cine', 'cintura', 'cinturon', 'circulo',
'ciruela', 'ciudad', 'claridad', 'clase', 'clavel', 'clavo',
'clima', 'club', 'cocodrilo', 'codigo', 'codo', 'cola',
'colega', 'colegio', 'color', 'coma', 'comercio', 'comida',
'comienzo', 'comision', 'compañia', 'competencia', 'competicion',
'competencia', 'computadora', 'comunicacion', 'comunidad', 'concepto',
'conciencia', 'condicion', 'conejo', 'conexion', 'confianza', 'conflicto',
'congreso', 'conjunto', 'conocido', 'conocimiento', 'consecuencia', 'consejo',
'constitucion', 'construccion', 'consumo', 'contenido', 'control', 'corazon',
'cordones', 'corriente', 'corte', 'cosa', 'costa', 'creacion',
'crecimiento', 'cremallera', 'criatura', 'crisis', 'cuaderno', 'cuadro',
'cuarto', 'cuatro', 'cucaracha', 'cuello', 'cuenta', 'cuerda',
'cordel', 'cordon', 'cuerpo', 'cuervo', 'cuestion', 'culo',
'cultura', 'curiosidad', 'curso', 'dama', 'dato', 'decada',
'decision', 'decreto', 'dedo', 'defensa', 'demanda', 'democracia',
'departamento', 'deporte', 'derecha', 'derecho', 'desarrollo', 'deseo',
'desierto', 'despejado', 'destino', 'destruccion', 'deterioro', 'dia',
'diagonal', 'diario', 'diarrea', 'dibujo', 'diccionario', 'dictadura',
'diente', 'diez', 'diferencia', 'dinero', 'dios', 'direccion',
'director', 'disposición', 'documento', 'dolor', 'domingo', 'don',
'dormitorio', 'dos', 'doña', 'dragon', 'duda', 'economia',
'edad', 'edificio', 'educacion', 'efecto', 'ejemplo', 'eleccion',
'electricidad', 'elefante', 'elemento', 'elevador', 'empatia', 'empleo',
'empresa', 'encuentro', 'energia', 'enfermedad', 'enojo', 'enfado',
'entorno', 'entrada', 'entretenimiento', 'epoca', 'equipo', 'equivocacion',
'era', 'escalera', 'escritorio', 'escritura', 'escuela', 'escultura',
'esfera', 'esfuerzo', 'espacio', 'espalda', 'español', 'especie',
'espectaculo', 'espectador', 'espera', 'espinilla', 'espiritu', 'esposa',
'esposo', 'esquina', 'estacion', 'parada', 'estado', 'este',
'estilo', 'estomago', 'estrella', 'estructura', 'estruendo', 'estudio',
'etapa', 'existencia', 'exito', 'experiencia', 'expresion', 'extasis',
'exterior', 'fabrica', 'facilidad', 'falda', 'falta', 'familia',
'fase', 'favor', 'fecha', 'ferrocarril', 'figura', 'fin',
'final', 'flor', 'fondo', 'forma', 'formacion', 'formalidad',
'fracaso', 'frances', 'frente', 'fruta', 'fuego', 'fuerza',
'funcion', 'futuro', 'gafas', 'galaxia', 'galleta', 'gallina',
'gas', 'gaseosa', 'gato', 'gente', 'geografia', 'gluteos',
'gobernador', 'intendente', 'alcalde', 'gobierno', 'gorrion', 'grabado',
'grado', 'gramo', 'gripe', 'gris', 'grupo', 'guerra',
'guitarra', 'habitacion', 'halcon', 'harina', 'hermano', 'hielo',
'hierro', 'higado', 'hijo', 'hilo', 'historia', 'hogar',
'hoja', 'hombre', 'hombro', 'hongo', 'hora', 'hotel',
'hoy', 'hueso', 'humanidad', 'humano', 'idea', 'extranjero',
'imagen', 'individuo', 'informacion', 'informatica', 'informe', 'ingles',
'inicio', 'insecto', 'instante', 'instituto', 'intento', 'interes',
'interior', 'interrupcion', 'investigacion', 'izquierda', 'japones',
'jirafa', 'joroba', 'judias', 'guisantes', 'jueves', 'juguete',
'julio', 'kilo', 'kilometro', 'labio', 'lado', 'lagarto',
'laguna', 'lago', 'langosta', 'largo', 'longitud', 'leon',
'ley', 'libertad', 'libro', 'libros', 'limon', 'litro',
'llave', 'llero', 'lluvia', 'logro', 'lombriz', 'loro',
'lugar', 'luna', 'lunes', 'luz', 'madre', 'manantial',
'manera', 'manga', 'mano', 'manzana', 'mar', 'oceano',
'maravilla', 'mariposa', 'marisco', 'marron', 'cafe', 'martes',
'matrimonio', 'mausoleo', 'mayoria', 'mañana', 'medida', 'mediodia',
'mejora', 'memoria', 'mente', 'mentira', 'mercado', 'mes',
'mesa', 'metal', 'metalico', 'metro', 'miedo', 'miercoles',
'mil', 'milenio', 'milimetro', 'millon', 'ministro', 'minoria',
'minuto', 'modo', 'molecula', 'molusco', 'momento', 'moneda',
'mono', 'mosca', 'mosquito', 'movimiento', 'mueble', 'muerte',
'mujer', 'mundo', 'municipio', 'musculo', 'musica', 'muslo',
'muñeca', 'nacimiento', 'nacion', 'naranja', 'naranja', 'anaranjado',
'nariz', 'naturaleza', 'necesidad', 'negro', 'nieto', 'nieve',
'nivel', 'niño', 'noche', 'nombre', 'norma', 'norte',
'notas', 'noticia', 'nublado', 'nueve', 'nuez', 'numero',
'objetivo', 'meta', 'objeto', 'obligacion', 'obra', 'ocasion',
'ocho', 'oeste', 'oficina', 'oido', 'ojo', 'olfato',
'omnibus', 'orden', 'ordenador', 'oreja', 'organizacion', 'origen',
'oro', 'oveja', 'padre', 'pais', 'pajaro', 'palabra',
'palma', 'panel', 'pantalla', 'pantalon', 'papel', 'paraguas',
'parasol', 'pareja', 'parlamentario', 'congresista', 'senador', 'diputado',
'parlante', 'parte', 'partido', 'pasado', 'paso', 'pasto',
'cesped', 'pata', 'patatas', 'papas', 'paz', 'pecho',
'pelusa', 'pensamiento', 'pera', 'percepcion', 'periferia', 'periodico',
'periodismo', 'perjuicio', 'permiso', 'perro', 'persona', 'personalidad',
'peso', 'pez', 'pie', 'piel', 'pierna', 'pilar',
'pino', 'pintura', 'piscina', 'piso', 'placer', 'planeta',
'planta', 'plata', 'platano', 'playa', 'plomo', 'poblacion',
'policia', 'polilla', 'politica', 'politico', 'pomelo', 'pomo',
'posavasos', 'posibilidad', 'posicion', 'potencia', 'precio', 'tarifa',
'pregunta', 'prenda', 'presencia', 'presente', 'presidente', 'primo',
'principio', 'probabilidad', 'problema', 'proceso', 'produccion', 'producto',
'profesion', 'programa', 'progreso', 'prohibicion', 'provincia', 'proyecto',
'pueblo', 'puerta', 'pulpo', 'punto', 'quejido', 'rabano',
'raiz', 'raiz', 'origen', 'fuente', 'rana', 'raton',
'rata', 'rayo', 'razon', 'realidad', 'rectangulo', 'recuerdo',
'reduccion', 'relacion', 'religion', 'representante', 'reproduccion',
'resfriado', 'respuesta', 'resultado', 'retroceso', 'reunion', 'revista',
'rio', 'rodilla', 'rojo', 'ropa', 'rosa', 'rosado', 'ruta',
'sabado', 'sal', 'salchicha', 'saltamontes', 'salud', 'sandia',
'sangre', 'sardina', 'secreto', 'sector', 'secuencia', 'segundo',
'seguridad', 'seis', 'selva', 'jungla', 'semana', 'semilla',
'sensacion', 'sentido', 'ser', 'serie', 'serpiente', 'servicio',
'señor', 'señora', 'siete', 'siglo', 'significado', 'silla', 'simbolo',
'similitud', 'sistema', 'situacion', 'sobrino', 'sociedad', 'sol',
'solapa', 'cuello', 'solicitud', 'solucion', 'sombrilla', 'sonido',
'sorpresa', 'subterraneo, metro', 'suciedad', 'suelo', 'suerte',
'sugerencia', 'sujetador', 'sosten', 'superficie', 'sur',
'sustancia', 'susto', 'tacto', 'tallo', 'talon', 'tamaño', 'tarde',
'tarima', 'telefono', 'televidente', 'tema', 'temor', 'texto',
'tiempo', 'tierra', 'tigre', 'tio', 'tipo', 'tomate', 'tormenta',
'torrefacto', 'total', 'trabajo', 'trafico', 'trancar', 'transaccion',
'transcurso', 'transito', 'transporte', 'trasero', 'tren', 'tres',
'triangulo', 'trigo', 'tristeza', 'trueno', 'tulipan', 'universidad',
'universo', 'uno', 'uso', 'utilizacion', 'utensilio', 'uña', 'vaca',
'vacaciones', 'valor', 'vanidad', 'vapor', 'vaso', 'vegetal',
'vehiculo', 'velocidad', 'ventana', 'verano', 'verdad', 'verde',
'verdura', 'vez', 'via', 'vida', 'vidrio', 'viento', 'viernes',
'villa', 'violeta', 'violin', 'visita', 'vista', 'volumen',
'voz', 'vuelto, cambio', 'xilofonoGente', 'zanahoria',
'region', 'zapatilla', 'zapato', 'zona')
palabra_secreta = choice(lista_palabras).lower()
palabra_secreta = palabra_secreta.replace('á', 'a').replace('é', 'e').replace(
'í', 'i').replace('ó', 'o').replace('ú', 'u')
return palabra_secreta
def mostrar_guiones(palabra_secreta):
# Recibe la palabra de la función anterior.
# Crea los guiones y separa las letras en una lista
clave = 0
dic = {}
rallitas = {}
for i in palabra_secreta:
clave += 1
dic[clave] = i
rallitas[clave] = '-'
return dic, rallitas
def mostrar_letras_acertadas():
cuenta_letra = 0
for k, v in dic_letras.items():
if v == letra_user:
cuenta_letra += 1
dic_guiones[k] = letra_user
else:
pass
if cuenta_letra == 1:
sing_plural = 'letra'
else:
sing_plural = 'letras'
print(f'Desvelamos {cuenta_letra} {sing_plural}: ')
print(*dic_guiones.values(), sep=' ')
print()
def ahorcado_intentos():
if intentos == 6:
print(" ____")
print(" | |")
print(" | ")
print(" | ")
print(" | ")
print("_|_")
elif intentos == 5:
print(" ____")
print(" | |")
print(" | O")
print(" | ")
print(" | ")
print("_|_")
elif intentos == 4:
print(" ____")
print(" | |")
print(" | O")
print(" | |")
print(" | ")
print("_|_")
elif intentos == 3:
print(" ____")
print(" | |")
print(" | O")
print(" | /|")
print(" | ")
print("_|_")
elif intentos == 2:
print(" ____")
print(" | |")
print(" | O")
print(" | /|\\")
print(" | ")
print("_|_")
elif intentos == 1:
print(" ____")
print(" | |")
print(" | O")
print(" | /|\\")
print(" | / ")
print("_|_")
# Limpiar la terminal
clearConsole()
# Mensaje bienvenida
print('\n###################')
print('JUEGO - El ahorcado')
print('###################\n')
# Escoger palabra aleatoria
secret = palabra_aleatoria()
# Extraer diccionario de guiones con el número de letras de la palabra
# Extraer diccionario con letras de la palabra con indice
dic_letras, dic_guiones = mostrar_guiones(secret)
# ############## PRUEBAS
# print(*dic_letras, sep=' ')
# print(*dic_letras.values(), sep=' ')
# Iniciar variable de INTENTOS
intentos = 8
SECRET = secret.upper()
# Instrucciones juego
print(
f'\nTu palabra tiene {len(dic_letras)} letras y tienes {intentos} intentos para acertarla.\n¡Suerte!\n'
)
# Mostrar guiones
print(*dic_guiones.values(), sep=' ')
print()
# Pedir letra a usuario
comando = ''
# listado para letras incorrectas y acertadas
incorrectas = list()
acertadas = list()
while comando.lower() != 'salir':
letra_user = input('Dime una letra: ')
comando = letra_user
# Validar letra
# Comando salir
if letra_user == 'salir':
print('\n\n¡Ciao!\n')
break
# # Letra ya acertada
elif letra_user in acertadas:
print('\nEsa letra ya la acertaste primo...\n')
elif letra_user in incorrectas:
print('\n¡Perdiendo intentos a lo loco! ¡A lo loco!\n')
intentos -= 1
ahorcado_intentos()
print('\nTe quedan {intentos} intentos\n')
# # acierto - Desvelar letra
elif letra_user in dic_letras.values():
print('\n¡Ole!')
acertadas.append(letra_user)
# Mostrar guiones y letras acertadas
mostrar_letras_acertadas()
# # fallo. Restar intentos
else:
intentos -= 1
incorrectas.append(letra_user)
print(f'Lo siento, no has acertado. Te quedan {intentos} intentos\n')
ahorcado_intentos()
print('\nTus errores por ahora: ')
print(*incorrectas, sep=', ')
print()
# Comprobación game over / Win / nuevo intento
if intentos == 0:
clearConsole()
print(" ____")
print(" | |")
print(" | O")
print(" | /|\\ \t\tGAME OVER")
print(" | / \\")
print("_|_")
print(f'\n\nLa palabra era: {SECRET}\n')
break
# Controlar si tiene la palabra correcta
elif '-' not in dic_guiones.values():
clearConsole()
print('\n\n\n\n\n\n\n\t\t\tWIN\t\t\t\n\n\n\n\n\n\n')
print(f'La palabra era: {SECRET}\nTe sobraron {intentos} intentos\n')
break
# Nuevo intento
else:
print("¡Inténtalo de nuevo!")

311
python-total/dia_05/README.md Normal file
View File

@@ -0,0 +1,311 @@
# Día 5 - Programa el juego "El ahorcado"
- [Día 5 - Programa el juego "El ahorcado"](#día-5---programa-el-juego-el-ahorcado)
- [5.1. - Documentación](#51---documentación)
- [5.2. - Funciones](#52---funciones)
- [5.3. - return](#53---return)
- [5.4. - Funciones dinámicas](#54---funciones-dinámicas)
- [5.5. - Interacción entre funciones](#55---interacción-entre-funciones)
- [5.6. - \*args](#56---args)
- [5.7. - \*\*kwargs](#57---kwargs)
- [5.8. - Ejercicios](#58---ejercicios)
- [5.8.1. - Ejercicio 1](#581---ejercicio-1)
- [5.8.2. - Ejercicio 2](#582---ejercicio-2)
- [5.8.3. - Ejercicio 3](#583---ejercicio-3)
- [5.8.4. - Ejercicio 4](#584---ejercicio-4)
- [5.9. - Proyecto del Día 5](#59---proyecto-del-día-5)
- [Ficheros y documentación del día 5](#ficheros-y-documentación-del-día-5)
## 5.1. - Documentación
La documentación es nuestra biblioteca de consulta en Python. Al escribir código, es de uso permanentemente para solucionar dudas relacionadas al funcionamiento de métodos y los argumentos que reciben.
Si utilizas PyCharm, sostén el cursor sobre el nombre del método del que deseas obtener información. Se desplegará una ventana flotante.
Esto funcionará en otros IDEs del mismo modo.
![](../img/dia05_01.png)
También, debes mantener cerca la documentación oficial de Python (o Biblioteca Estándar de Python), que contiene toda la información necesaria: https://docs.python.org/es/3.9/library/index.html
No dejes de buscar en Google tus dudas, para hallar una explicación que se ajuste a ti.
## 5.2. - Funciones
Una función es un bloque de código que solamente se ejecuta cuando es llamada. Puede recibir información (en forma de parámetros), y devolver datos una vez procesados como resultado.
Una función es definida mediante la palabra clave **def**
```python
def mi_funcion(argumento):
```
Los argumentos contienen información que la función utiliza o transforma para devolver un resultado
```python
mi_funcion(mi_argumento)
```
Para llamar a una función, basta utilizar su nombre, entregando los argumentos que la misma requiere entre paréntesis.
## 5.3. - return
Para que una función pueda devolver un valor (y que pueda ser almacenado en una variable, por ejemplo), utilizamos la declaración return.
```python
def mi_funcion():
return [algo]
```
La declaración return provoca la salida de la función. Cualquier código que se encuentre después en el bloque de la función, no se ejecutará
```python
resultado = mi_funcion()
```
La variable resultado almacenará el valor devuelto por la función mi_funcion( )
## 5.4. - Funciones dinámicas
La integración de diferentes herramientas de control de flujo, nos permite crear funciones dinámicas y flexibles. Si debemos utilizarlas varias veces, lograremos un programa más limpio y sencillo de mantener, evitando repeticiones de código.
- Funciones
- Loops (for/while)
- Estructuras condicionales
- Palabras clave (return, break, continue, pass)
```python
def mi_funcion(argumento):
for item in ...
if a == b ...
...
else:
return ...
return ...
```
## 5.5. - Interacción entre funciones
Las salidas de una determinada función pueden convertirse en entradas de otras funciones. De esa manera, cada función realiza una tarea definida, y el programa se construye a partir de la interacción entre funciones.
```python
def funcion_1():
|...
|return a
def funcion_2(a):
|...
|return b
def funcion_3(b):
|...
|return c
def funcion_4(a,c):
|...
|return d
```
## 5.6. - *args
En aquellos casos en los que no se conoce de antemano el número exacto de argumentos que se deben pasar a una función, se debe utilizar la sintaxis *args para referirse a todos los argumentos adicionales luego de los obligatorios.
El nombre *args no es mandatorio pero si es sugerido como buena práctica.
Cualquier nombre iniciado en * referirá a estos argumentos de cantidad variable.
La función recibirá los argumentos indefinidos *args en forma de tupla, a los que se podrá acceder o iterar de las formas habituales dentro del bloque de código de la función.
```python
def mi_funcion(arg_1, arg_2, *args):
```
```python
mi_funcion("ejemplo", 25, 40, 75, 10):
```
*arg_1* → "ejemplo"
*arg_2* → 25
*args* = (40, 75, 10)
## 5.7. - **kwargs
Los argumentos con palabras clave (keyword arguments, abreviado kwargs), sirven para identificar el argumento por su nombre, independientemente de la posición en la que se pasen a su función. Si no se conoce de antemano su cantidad, se utiliza el parámetro **kwargs que los agrupa en un diccionario.
Al igual que para *args, el nombre **kwargs no es mandatorio pero si es sugerido como buena práctica. Cualquier nombre iniciado en ** referirá a estos argumentos de cantidad variable.
```python
def atributos_persona(**kwargs):
```
```python
atributos_persona(ojos="azules", pelo="corto")
```
*kwargs* = {'ojos': 'azules', 'pelo': 'rubio'}
## 5.8. - Ejercicios
### 5.8.1. - Ejercicio 1
Crea una función llamada devolver_distintos() que reciba 3 integers como parámetros.
- Si la suma de los 3 numeros es mayor a 15, va a devolver el número mayor.
- Si la suma de los 3 numeros es menor a 10, va a devolver el número menor.
- Si la suma de los 3 números es un valor entre 10 y 15 (incluidos) va a devolver el número de valor intermedio.
**Solución:**
```python
def devolver_distintos(num1, num2, num3):
suma = num1 + num2 + num3
lista = [num1, num2, num3]
if suma > 15:
return max(lista)
elif suma < 10:
return min(lista)
else:
lista.sort()
return lista[1]
print(devolver_distintos(6, 5, 3))
```
### 5.8.2. - Ejercicio 2
Escribe una función (puedes ponerle cualquier nombre que quieras) que reciba cualquier palabra como parámetro, y que devuelva todas sus letras únicas (sin repetir) pero en orden alfabético.
Por ejemplo si al invocar esta función pasamos la palabra "entretenido", debería devolver ['d', 'e', 'i', 'n', 'o', 'r', 't']
**Solución:**
```python
def cualquier(palabra):
mi_set = set()
for letra in palabra:
mi_set.add(letra)
lista = list(mi_set)
lista.sort()
return lista
print("\n")
print(cualquier('entretenido'))
```
### 5.8.3. - Ejercicio 3
Escribe una función que requiera una cantidad indefinida de argumentos. Lo que hará esta función es devolver True si en algún momento se ha ingresado al numero cero repetido dos veces consecutivas.
Por ejemplo:
(5,6,1,0,0,9,3,5) >>> True
(6,0,5,1,0,3,0,1) >>> False
**Solución:**
```python
def me_gustan_los_ceros(*noceros):
contador = 0
for num in noceros:
if num == 0:
contador += 1
if contador == 2:
contador = 0
return True
elif num != 0:
contador = 0
else:
pass
return False
print("\n")
print(me_gustan_los_ceros(5, 6, 1, 0, 0, 9, 3, 5))
print(me_gustan_los_ceros(6, 0, 5, 1, 0, 3, 0, 1))
Solución curso:
def ceros_vecinos(*args):
contador = 0
for num in args:
if contador + 1 == len(args):
return False
elif args[contador] == 0 and args[contador + 1] == 0:
return True
else:
contador += 1
return False
print("\n")
print(ceros_vecinos(5, 6, 1, 0, 0, 9, 3, 5))
print(ceros_vecinos(6, 0, 5, 1, 0, 3, 0, 1))
```
### 5.8.4. - Ejercicio 4
Escribe una función llamada contar_primos() que requiera un solo argumento numérico.
Esta función va a mostrar en pantalla todos los números primos existentes en el rango que va desde cero hasta ese número incluido, y va a devolver la cantidad de números primos que encontró.
Aclaración, por convención el 0 y el 1 no se consideran primos.
**Solución:**
```python
def primo(numero):
if numero == 0 or numero == 1 or numero == 4:
return False
for x in range(2, int(numero/2)):
if numero % x == 0:
return False
return True
def primos(rango_max):
rango_max += 1
lista_num = [n for n in range(1, rango_max)]
primos = []
for numero in lista_num:
es_primo = primo(numero)
if es_primo:
primos.append(numero)
contar = len(primos)
rango_max -= 1
print(f"\nEntre 0 y el {rango_max} hay {contar} números primos.\n")
print(*primos, sep=' ')
primos(1000)
Solución curso:
def contar_primos(numero):
primos = [2]
iteracion = 3
if numero < 2:
return 0
while iteracion <= numero:
for n in range(3, iteracion, 2):
if iteracion % n == 0:
iteracion += 2
break
else:
primos.append(iteracion)
iteracion += 2
print(primos)
return len(primos)
print("\n")
print(contar_primos(1000))
```
## 5.9. - Proyecto del Día 5
Hoy vas a programar El Ahorcado. El programa va a elegir una palabra secreta y le va a mostrar al jugador solamente una serie de guiones que representa la cantidad de letras que tiene la palabra. El jugador en cada turno deberá elegir una letra y si la letra se encuentra en la palabra oculta, el sistema le va a mostrar en qué lugares se encuentra. Pero si el jugador dice una letra que no se encuentra en la palabra oculta, pierde una vida.
En el juego real del ahorcado, cada vez que perdemos una vida, se va completando el dibujo del ahorcado miembro por miembro. Pero en nuestro caso, como aún no tenemos elementos gráficos, simplemente le vamos a decir que tiene seis vidas y se las iremos descontando de una en una, cada vez que el jugador elija una letra incorrecta.
Si se agotan las vidas antes de adivinar la palabra, el jugador pierde. Pero si adivina la palabra completa antes de perder todas las vidas, el jugador gana.
Parece sencillo, pero ¿cómo diseñamos todo este código? Bueno, aquí van algunas ayudas:
- Primero vas a crear un código que importe el método choice, ya que lo vas a necesitar para que el sistema pueda elegir una palabra al azar dentro de una lista de palabras que también vas a crear al comienzo.
- Luego de eso, vas a crear tantas funciones como creas necesarias para que el programa haga cosas como pedirle al usuario que elija una letra, para corroborar si lo que el usuario ha ingresado es una letra válida, para chequear si la letra ingresada se encuentra en la palabra o no, para verificar si ha ganado o no, etc.
- Recuerda escribir primero las funciones y luego el código que las implementa ordenadamente.
Creo que este es un proyecto especial y de verdad quiero que sepas que no espero que lo puedas resolver sin ayuda. Las funciones parecen simples, pero cuando empezamos a poner funciones todas juntas en un código real, es difícil seguir mentalmente la sucesión del código porque se vuelve mucho menos lineal que antes. Lo importante es que lo intentes, que tu cabeza se zambulla en el problema y luego veremos cómo llegamos a la solución.
![](../img/dia05_02.png)
## Ficheros y documentación del día 5
- [01_metodos_ayuda_docs.py](01_metodos_ayuda_docs.py)
- [02_funciones.py](02_funciones.py)
- [03_funciones_dinamicas.py](03_funciones_dinamicas.py)
- [04_ejemplo_funcion.py](04_ejemplo_funcion.py)
- [05_palito_mas_corto.py](05_palito_mas_corto.py)
- [06_lanzar_dados.py](06_lanzar_dados.py)
- [07_limpiar_lista_promedio.py](07_limpiar_lista_promedio.py)
- [08_lanzar_moneda.py](08_lanzar_moneda.py)
- [09_args_indeterminados.py](09_args_indeterminados.py)
- [10_problemas_practicos.py](10_problemas_practicos.py)
- [11_programa05.py](11_programa05.py)
[Documentación del día](../doc_curso/05_ahorcado/)
---
Enlaces a todos los días: [dia 1 - creador de nombres](../dia_01/README.md) / [dia 2 - calculador de comisiones](../dia_02/README.md) / [dia 3 - analizador de texto](../dia_03/README.md) / [dia 4 - juego "adivina el número"](../dia_04/README.md) / [dia 5 - juego "El ahorcado"](../dia_05/README.md) / [dia 6 - recetario](../dia_06/README.md) / [dia 7 - cuenta bancaria](../dia_07/README.md) / [dia 8 - consola de turnos](../dia_08/README.md) / [dia 9 - buscador de números de serie](../dia_09/README.md) / [dia 10 - juego "Invasión espacial"](../dia_10/README.md) / [dia 11 - web scraping](../dia_11/README.md) / [dia 12 - gestor de restaurantes](../dia_12/README.md) / [dia 13 - asistente de voz](../dia_13/README.md) / [dia 14 - controlador de asistencia](../dia_14/README.md) / [dia 15 - machine learning](../dia_15/README.md) / [dia 16 - aplicación web de tareas pendientes](../dia_16/README.md)

73
python-total/dia_06/01_abrir_manipular_archivos.py Normal file
View File

@@ -0,0 +1,73 @@
"""
Abrir y manipular archivos
"""
# Abrir documento
archivo = open('prueba.txt')
# Leer todo el documento
archivo_total = archivo.read()
# print(archivo_total)
print(archivo_total)
archivo.close()
print('-'*25)
# Con este método se lee una sola línea
mi_archivo = open('prueba.txt')
una_linea = mi_archivo.readline()
print(una_linea.upper())
print(una_linea)
una_linea = mi_archivo.readline()
# Con el método rstrip no se efectuará salto de línea
print(una_linea.rstrip())
una_linea = mi_archivo.readline()
print(una_linea)
# close cierrar el archivo para no ocupar
# el espacio de memoria que deja abierto en open.
# Es importante usarlo siempre
mi_archivo.close()
print('-'*25)
archivo2 = open('prueba.txt')
# Se puede iterar por líneas
for l in archivo2:
print('Aquí dice que : ' + l)
archivo2.close()
print('-'*25)
arch = open('prueba.txt')
# Con este método se meten las líneas en una lista.
# Hay que tener en cuenta que estos métodos que cargan
# todo el archivo deben usarse con modelación,
# ya que cargan mucho la memoria sobretodo si son
# ficheros grandes y el mismo muchas veces.
todas = arch.readlines()
print(todas)
arch.close()
print('-'*25)
# Imprimir la segunda linea
txt = open('prueba.txt')
list_txt = txt.readlines()
cuenta_lineas = 0
for l in list_txt:
cuenta_lineas += 1
if cuenta_lineas == 2:
print(l)
print()
txt.close()

21
python-total/dia_06/02_crear_escribir_archivos.py Normal file
View File

@@ -0,0 +1,21 @@
"""
Crear y escribir archivos
Sintaxis:
mi_archivo = open('archivo.txt',modo_apetura)
Argumentos de open()
r - Solo lectura - Por defecto
w - Solo escritura. Si el archivo ya existe se resetea
a - Añadir excritura, se posiciona al final.
x - Creación
2 Métodos de escritura
write() Para escribir normal
writelines Para añadir texto en lista
"""
mi_archivo = open('prueba.txt', 'w')
mi_archivo.write('\nEste texto se escribe desde python\n')
mi_archivo.writelines(['Hola', 'mundo', 'aquí', 'estoy'])
mi_archivo.close()

58
python-total/dia_06/03_directorios.py Normal file
View File

@@ -0,0 +1,58 @@
"""
Directorios
Importaremos dos librerias:
Path de pathlib
os
"""
import os
from pathlib import Path
# Obtener el directorio de trabajo actual
ruta = os.getcwd()
print(ruta)
# Cambiar de directorio
ruta2 = os.chdir(
'/home/v/Documents/projectes/python/python_total/dia_06/Europa/')
# # Leer el fichero de esa ruta
archivo = open('Consejos.txt')
print(archivo.read())
archivo.close()
# Crear rutas nuevas
os.makedirs('/home/v/Documents/projectes/python/python_total/dia_06/Africa/')
# Separar el path y el nombre del archivo
ruta3 = '/home/v/Documents/projectes/python/python_total/dia_06/Europa/Consejos.txt'
# # Nombre base del fichero o directorio de la ruta
elemento = os.path.basename(ruta3)
print(elemento)
# # ruta completa menos base
elemento2 = os.path.dirname(ruta3)
print(elemento2)
# # ruta completa en un tuple
elemento3 = os.path.split(ruta3)
print(elemento3)
# Eliminar carpeta
os.rmdir('/home/v/Documents/projectes/python/python_total/dia_06/Africa/')
# Se importa el objeto Path de la libreria pathlib para los siguientes ejercicios
# Con Path buscará en cualquier SO
carpeta = Path(
'/home/v/Documents/projectes/python/python_total/dia_06/Europa')
archivo2 = carpeta / 'Consejos.txt'
mi_archivo = open(archivo2)
print(mi_archivo.read())
mi_archivo.close()

37
python-total/dia_06/04_pathlib.py Normal file
View File

@@ -0,0 +1,37 @@
"""
pathlib
Las que no tienen paréntesis son funciones, no métodos
Se puede transformar a una ruta de windows importando PureWindowsPath
PureWindowsPath(carpeta)
"""
from pathlib import Path
carpeta = Path(
'/home/v/Documents/projectes/python/python_total/dia_06/prueba.txt')
print(carpeta.read_text())
# Nombre fichero
print(carpeta.name)
# sufijo. Extensión
print(carpeta.suffix)
# Nombre sin la terminación
print(carpeta.stem)
# Ver si existe el fichero con un if
if not carpeta.exists():
print("Este archivo no existe")
else:
print("Genial, existe")
opcion = input("Escoger categoria: ")
if opcion.isnumeric():
print('Es')
else:
print("no")

66
python-total/dia_06/05_path.py Normal file
View File

@@ -0,0 +1,66 @@
"""
path
"""
# Ruta relativa
from pathlib import Path
guia = Path("Barcelona", "Sagrada_Familia.txt")
print(guia)
print("-"*25)
# Ruta absoluta al directorio de usuario activo
base = Path.home()
# Con lo cual, si lo unimos a la ruta relativa
# nos dará una ruta absoluta
# (siguiento el path que le hemos dado)
# Admite cadenas como objetos de path
# podemos concatenar varios trozos de paths
mi_ruta = Path('Documents/projectes/python/python_total/dia_06')
guia2 = Path(base, mi_ruta, "Europa", "España", Path(
"Barcelona", "Sagrada_Familia.txt"))
print(base)
print(guia2)
print("-"*25)
# Utilizando la ruta absoluta anterior,
# podemos cambiar el fichero de destino
guia3 = guia2.with_name("La_Pedrera.txt")
print(guia3)
print("-"*25)
# Acceder a directorios intermedios
# con parent accedemos al path superior cada vez que lo usamos
# Igual que los dos puntos en cd. (..)
print(guia2.parent.parent.parent)
print("-"*25)
# Enumerar todos los archivos txt
# # Primero hacemos la ruta
guia4 = Path(base, mi_ruta, "Europa")
# # Con el método glob recorremos cada objeto de la ruta
# # con un for
for txt in Path(guia4).glob("*.txt"):
print(txt)
print("-"*25)
# # Recursivo o_O
for txt in Path(guia4).glob("**/*.txt"):
print(txt)
print("-"*25)
# Para acceder a rutas relativas a partir de una base de rutas absolutas
guia5 = Path("Europa", "España", "Barcelona", "Sagrada_Familia.txt")
en_europa = guia5.relative_to("Europa")
en_espania = guia5.relative_to("Europa", "España")
print(en_europa)
print(en_espania)

23
python-total/dia_06/06_limpiar_consola.py Normal file
View File

@@ -0,0 +1,23 @@
"""
Limpiar consola
Introducir comandos a la terminal o_O
"""
from os import system
def limpiar_consola():
system('tree')
system('sleep 2')
system('clear')
nombre = input("Dime tu nombre: ")
print("Ahora te voy a mostrar directorios y ficheros durante 2 segundos")
system('sleep 2')
limpiar_consola()
print(f"¿Te quedo claro {nombre}?")

318
python-total/dia_06/07_programa06.py Normal file
View File

@@ -0,0 +1,318 @@
"""
Programa día 6 - Recetario
"""
import os
import shutil
from pathlib import Path
"""
Variables
"""
ruta_base = Path('Recetas')
limpiar = 'clear'
sleep = 'sleep 2'
"""
Funciones
"""
def clearConsole():
# Función limpiar consola
os.system(limpiar)
def bienvenida():
clearConsole()
# bienvenida al usuario
print('\n', '#' * 29, '\n # Bienvenid@ al Recetario #\n', '#' * 29)
os.system(sleep)
clearConsole()
info()
def info():
# informar la ruta de acceso al directorio donde se encuentran las recetas
print('*' * 17, '\n* INFORMACIÓN *\n*****************\n')
print('Las recetas están en las siguientes rutas:')
for ruta in Path(ruta_base).glob('*'):
print(f'- {ruta}')
# informar cuántas recetas hay en total dentro de esas carpetas
num_recetas = 0
for ruta in Path(ruta_base).glob('**/*.txt'):
num_recetas += 1
# Mostra menú de opciones
print(f'\nEn total, existen {num_recetas} recetas.\n')
menu_opciones()
def menu_opciones():
comando = ''
while comando.lower() != 's':
print("""********************
* MENÚ PRINCIPAL *
********************
i\t\tInformación
m\t\tMostrar recetas
cr\t\tCrear receta
cc\t\tCrear nueva categoria
er\t\tEliminar receta
ec\t\tEliminar categoria
s\t\tsalir
""")
comando = input('Selecciona una opción: ')
clearConsole()
if comando == 'i':
# Información
info()
elif comando == 'm':
com = ""
while com != 's':
# Mostrar recetas
cat = escoger_categoria()
rec = escoger_receta(cat)
mostrar_receta(rec)
com = input("¿Quieres salir de \"Mostrar recetas\"? (s/n) ")
if com == 'n':
continue
elif com == 's':
print('\n¡Ok! Volvemos al menú pricipal\n')
break
else:
print('Disculpa, ingresa un valor válido')
continue
elif comando == 'cr':
com = ""
while com != 's':
# Crear receta
cat = escoger_categoria()
crear_receta(cat)
com = input("¿Quieres salir de \"Crear receta\"? (s/n) ")
if com == 'n':
continue
elif com == 's':
print('\n¡Ok! Volvemos al menú pricipal\n')
break
else:
print('Disculpa, ingresa un valor válido')
continue
elif comando == 'cc':
# Crear nueva categoria
crear_categoria()
elif comando == 'er':
com = ""
while com != 's':
# Eliminar receta
cat = escoger_categoria()
rec = escoger_receta(cat)
eliminar_receta(rec)
com = input("¿Quieres salir de \"eliminar receta\"? (s/n) ")
if com == 'n':
continue
elif com == 's':
print('\n¡Ok! Volvemos al menú pricipal\n')
break
else:
print('Disculpa, ingresa un valor válido')
continue
elif comando == 'ec':
com = ""
while com != 's':
# Eliminar categoria
cat = escoger_categoria()
eliminar_categoria(cat)
com = input("¿Quieres salir de \"eliminar categoria\"? (s/n) ")
if com == 'n':
continue
elif com == 's':
print('\n¡Ok! Volvemos al menú pricipal\n')
break
else:
print('Disculpa, ingresa un valor válido')
continue
elif comando == 's':
# salir
break
else:
print('Disculpa, ingresa un valor válido')
os.system(sleep)
clearConsole()
info()
def escoger_categoria():
# Opción 1
# Pregunta qué categoría elige (carnes, ensaladas, etc.),
print('\nCategorías:')
num_menu = 0
lista_categorias = []
for ruta in Path(ruta_base).glob('*'):
num_menu += 1
lista_categorias.append(ruta.name)
print(f'\t{num_menu}\t {lista_categorias[num_menu - 1]}')
print('\n\ts\t salir de la opción \"escoger categoria\"\n')
opcion = ''
while opcion != 's':
opcion = input('Escoger categoria: ')
if opcion.isnumeric():
if int(opcion) in range(1, num_menu + 1):
categoria = lista_categorias[int(opcion) - 1]
return categoria
else:
print(f'\nEl número {opcion} no está en el menú\n')
continue
elif opcion.lower() == 's':
return False
else:
print('Disculpa, ingresa un valor válido')
continue
return False
def escoger_receta(catego):
if catego == False:
return False
else:
# una vez que el usuario elija una, preguntar qué receta quiere leer,
print(
f'\nEn la categoria \"{catego.upper()}\" hay las siguientes recetas: ')
num_menu = 0
lista_recetas = []
for rut in Path(ruta_base, catego).glob('*'):
num_menu += 1
lista_recetas.append(rut.name)
print(f'\t{num_menu}\t {lista_recetas[num_menu - 1]}')
print('\n\ts\t salir de la opción \"escoger receta\"\n')
opcion = ''
while opcion != 's':
opcion = input('Escoger receta: ')
if opcion.isnumeric():
if int(opcion) in range(1, num_menu + 1):
receta = lista_recetas[int(opcion) - 1]
ruta_escogida = Path(ruta_base, catego, receta)
# Devuelve receta escogida
return ruta_escogida
else:
print(f'\nEl número {opcion} no está en el menú\n')
continue
elif opcion.lower() == 's':
return False
else:
print('Disculpa, ingresa un valor válido')
continue
def mostrar_receta(ruta_escogida):
# mostrar contenido receta.
if ruta_escogida == False:
print()
else:
clearConsole()
print(
f'\nRECETA \"{ruta_escogida.stem.upper()}\"\n{ruta_escogida.read_text()}\n')
def crear_receta(categoria):
# Opción 2
# Elegir una categoría,
# va a pedir que escriba el nombre y el contenido de la nueva receta que quiere crear,
# El programa va a crear ese archivo en el lugar correcto.
if categoria == False:
print()
else:
catego = Path(ruta_base, categoria)
nombre = input('¿Cómo le quieres llamar a la receta? ')
nueva_receta = nombre + ".txt"
os.chdir(catego)
receta = open(nueva_receta.capitalize(), 'x')
receta.close()
nuevo_texto = open(nueva_receta.capitalize(), 'w')
nuevo_texto.write(input('Escribe el contenido de la receta: '))
nuevo_texto.close()
os.chdir('../..')
print(f'\nReceta de \"{nombre}\" creada con éxito\n')
def crear_categoria():
# Opcion 3
# Preguntar el nombre de la categoría que quiere crear
# Generar una carpeta nueva con ese nombre.
nueva_categ = input('¿Cómo quieres llamar la nueva categoria? ')
catego = Path(ruta_base, nueva_categ.capitalize())
os.makedirs(catego)
print(f'\nCategoria \"{nueva_categ}\" creada con éxito.\n')
def eliminar_receta(ruta_escogida):
# Opción 4
# hará lo mismo que la opción uno,
# pero en vez de leer la receta, la va a eliminar.
if ruta_escogida == False:
print()
else:
print(
f'Se ha eliminado la RECETA \"{ruta_escogida.stem.upper()}\"\n')
os.remove(ruta_escogida)
def eliminar_categoria(categoria):
# Opción 5
# Preguntar qué categoría quiere eliminar
# Eliminar categoria
if categoria == False:
print()
else:
catego = Path(ruta_base, categoria)
print(
f'Se ha eliminado la CATEGORIA \"{catego.stem.upper()}\"\n')
shutil.rmtree(catego)
"""
El programa se dispara en la función bienvenida
"""
bienvenida()
print('\n¡Ciao!\n')

1
python-total/dia_06/Europa/Consejos.txt Normal file
View File

@@ -0,0 +1 @@
Estos son los consejos

1
python-total/dia_06/Europa/España/Barcelona/La_Pedrera.txt Normal file
View File

@@ -0,0 +1 @@
Esta es La Pedrera

1
python-total/dia_06/Europa/España/Barcelona/Sagrada_Familia.txt Normal file
View File

@@ -0,0 +1 @@
Esta es la sagrada Familia

1
python-total/dia_06/Europa/España/Madrid/Museo_del_Prado.txt Normal file
View File

@@ -0,0 +1 @@
Este es el Museo del Prado

0
python-total/dia_06/Europa/Francia/Paris/Torre Eiffel.txt Normal file
View File

1
python-total/dia_06/Europa/Normativas.txt Normal file
View File

@@ -0,0 +1 @@
Estas son las normativas

209
python-total/dia_06/README.md Normal file
View File

@@ -0,0 +1,209 @@
# Día 6 - Programa un recetario
## Índice
- [Día 6 - Programa un recetario](#día-6---programa-un-recetario)
- [Índice](#índice)
- [6.1. - Abrir y leer archivos](#61---abrir-y-leer-archivos)
- [6.2. - Crear y escribir archivos](#62---crear-y-escribir-archivos)
- [6.3. - Directorios](#63---directorios)
- [6.4. - pathlib](#64---pathlib)
- [6.4.1. - Navegación](#641---navegación)
- [6.4.2. - Algunos métodos y propiedades sobre objetos Path](#642---algunos-métodos-y-propiedades-sobre-objetos-path)
- [6.5. - Path](#65---path)
- [6.6. - Limpiar la consola](#66---limpiar-la-consola)
- [6.7. - Archivos + funciones](#67---archivos--funciones)
- [6.8. - Proyecto del Día 6](#68---proyecto-del-día-6)
- [Ficheros y documentación del día 6](#ficheros-y-documentación-del-día-6)
## 6.1. - Abrir y leer archivos
La manipulación de archivos desde Python se engloba bajo las funciones de E/S (entrada/salida) o I/O (en inglés: input/output). Comenzaremos explorando las funciones utilizadas para abrir, leer y cerrar archivos:
- **open(archivo, modo)**: abre un archivo, y devuelve un objeto de tipo archivo sobre el que pueden aplicarse métodos
- **read(bytes)**: devuelve un número especificado de bytes del archivo. De manera predeterminada (sin indicar un valor en el argumento bytes), devolverá el archivo completo (equivalente a escribir -1).
- **readline(bytes)**: devuelve una línea del archivo, limitada por el número indicado en el parámetro tamaño (en bytes).
- **readlines(bytes)**: devuelve una lista que contiene cada una de las líneas del archivo como item de dicha lista. Si el tamaño excede lo indicado en el parámetro bytes, no se devolverán líneas adicionales.
- **close( )**: cierra el archivo abierto, tal que no puede ser leído o escrito luego de cerrado. Es una buena práctica utilizar este método si ya no será necesario realizar acciones sobre un archivo.
Por lo general, un byte equivale a un caracter.
## 6.2. - Crear y escribir archivos
Para escribir en un archivo desde Python, deberemos elegir con cuidado el parámetro "modo de apertura".
```python
open(arhivo, modo)
```
Parámetros de *modo* de apertura:
- **"r"** - Read (Lectura) - Predeterminado. Permite leer pero no escribir, y arroja un error si el archivo no existe.
- **"a"** - Append (Añadir) - Abre el archivo para añadir líneas a continuación de la última que ya exista en el mismo. Crea un archivo en caso de que el mismo no exista.
- **"w"** - Write (Escritura) - Abre o crea un archivo (si no existe previamente) en modo de escritura, lo que significa que cualquier contenido previo se sobreescribirá.
- **"x"** - Create (Creación) - Crea un archivo, y arroja un error si el mismo ya existe en el directorio.
El método **write( )** escribe un texto especificado en el argumento sobre el archivo.
**writelines(lista)** recibe el texto a ser escrito en forma de lista.
## 6.3. - Directorios
Trabajar sobre archivos que se encuentran en directorios diferentes al de nuestro código requiere del soporte del módulo OS, que contiene una serie de funciones para interactuar con el sistema operativo.
```python
import os
```
- **os.getcwd()**: obtiene y devuelve el directorio de trabajo actual. Será el mismo en el que corre el programa si no se ha modificado.
- **os.chdir(ruta)**: cambia el directorio de trabajo a la ruta especificada
- **os.makedirs(ruta)**: crea una carpeta, así como todas las carpetas intermedias necesarias de acuerdo a la ruta especificada.
- **os.path.basename(ruta)**: dada una ruta, obtiene el nombre del archivo (nombre de base)
- **os.path.dirname(ruta)**: dada una ruta, obtiene el directorio (carpeta) que almacena el archivo
- **os.path.split(ruta)**: devuelve una tupla que contiene dos elementos: el directorio, y el nombre de base del archivo.
- **rmdir(ruta)**: elimina el directorio indicado en la ruta.
En Windows, es necesario indicar las rutas con dobles barras invertidas (\\) para que sean correctamente interpretadas por Python.
## 6.4. - pathlib
El módulo pathlib, disponible desde Python 3.4, permite crear objetos Path, generando rutas que pueden ser interpretadas por diferentes sistemas operativos y cuentan con una serie de propiedades útiles.
```python
from pathlib import Path
ruta = Path("C:/Users/Usuario/Desktop")
```
A partir de una semántica sencilla, devuelve una ruta que el sistema puede comprender. Por ejemplo, en Windows, devolverá: C:\Users\Usuario\Desktop y en Mac: C:/Users/Usuario/Desktop
### 6.4.1. - Navegación
```python
ruta = Path("C:/Users/Usuario/Desktop") / "archivo.txt"
```
Es posible concatenar objetos Path y strings con el delimitador "/" para construir rutas completas.
### 6.4.2. - Algunos métodos y propiedades sobre objetos Path
- **read_text( )**: lee el contenido del archivo sin necesidad de abrirlo y cerrarlo
- **name**: devuelve el nombre y extensión del archivo
- **suffix**: devuelve la extensión del archivo (sufijo)
- **stem**: devuelve el nombre del archivo sin su extensión (sufijo)
- **exists( )**: verifica si el directorio o archivo al que referencia el objeto Path existe y devuelve un booleano de acuerdo al resultado (True/False)
## 6.5. - Path
La clase Path permite representar rutas de archivos en el sistema de archivos de nuestro sistema operativo. Se destaca por su legibilidad frente a alternativas semejantes.
*base = Path.home()* → Devuelve un objeto Path representando el directorio base del usuario
```python
ruta = Path(base, "Europa", "Barcelona", "SagradaFamilia.txt")
```
Se aceptan strings y otros objetos Path
```python
ruta2 = ruta.with_name("LaPedrera.txt")
```
Devuelve un nuevo objeto Path cambiando únicamente el nombre de archivo
Cada invocación de la propiedad parent devuelve la ruta de jerarquía inmediata superior
```shell
C:\Users\...
|_ Europa
|_Barcelona
|_SagradaFamilia.txt
|_LaPedrera.txt
```
```python
continente = ruta.parent.parent
print(continente)
```
C:\Users\...\Europa
Devuelve el conjunto de archivos que coinciden con el "patrón"
```python
Path(ruta).glob("*.txt")
Path(ruta).glob("**/*.txt")
```
Búsqueda recursiva en subdirectorios
## 6.6. - Limpiar la consola
Para controlar la información mostrada al usuario en consola podemos limpiarla, eliminando los diferentes mensajes que han aparecido conforme se va ejecutando el programa.
```python
from os import system
```
En Unix/Linux/MacOS:
```python
system("clear")
```
En DOS/Windows:
```python
system("cls")
```
## 6.7. - Archivos + funciones
**Recordatorio**: puedes crear funciones para que ejecuten código cada vez que sean invocadas, evitando repeticiones y facilitando su lectura. Esto aplica para todo Python, y desde luego también cuando manipulamos archivos.
¿Qué hace la función? - ¿Qué información necesita recibir?
```python
def manipular_archivo(ruta, nombre_archivo):
# Código que convierte las entradas en salidas
return
```
¿Cuál debe ser su salida?
## 6.8. - Proyecto del Día 6
Vas a crear un administrador de recetas. Básicamente esto es un programa a través del cual un usuario puede leer, crear y eliminar recetas que se encuentren en una base de datos.
Entonces, antes de comenzar, es necesario que crees en tu ordenador un directorio en la carpeta base de tu ordenador, con una carpeta llamada Recetas, que contiene cuatro carpetas y cada una de ellas contiene dos archivos de texto. Dentro de los archivos puedes escribir lo que quieras, puede ser la receta en sí misma o no, pero eso no es importante para este ejercicio. Lo importante es que escribas algo para poder leerlas cuando haga falta o, si prefieres, también puedes directamente descargar y descomprimir el archivo adjunto a esta elección y ubicarlo en tu directorio raíz si no tienes ganas de crearlo tú mismo.
![](../img/dia06_01.png)
Aquí viene la consigna: tu código le va a dar primero la bienvenida al usuario, le va a informar la ruta de acceso al directorio donde se encuentra nuestra carpeta de recetas, le va a informar cuántas recetas hay en total dentro de esa carpeta, y luego le va a pedir que elija una de estas opciones que tenemos aquí:
1. La opción 1 le va a preguntar qué categoría elige (carnes, ensaladas, etc.), y una vez que el usuario elija una, le va a preguntar qué receta quiere leer, y mostrar su contenido.
2. En la opción 2 también se le va a hacer elegir una categoría, pero luego le va a pedir que escriba el nombre y el contenido de la nueva receta que quiere crear, y el programa va a crear ese archivo en el lugar correcto.
3. La opción 3 le va a preguntar el nombre de la categoría que quiere crear y va a generar una carpeta nueva con ese nombre.
4. La opción 4, hará todo lo mismo que la opción uno, pero en vez de leer la receta, la va a eliminar.
5. La opción 5, le va a preguntar qué categoría quiere eliminar
6. Finalmente, la opción 6 simplemente va a finalizar la ejecución del código.
Este programa tiene algunas cuestiones importantes a considerar:
- Cada vez que el usuario realice exitosamente cualquiera de sus opciones, el programa le va a pedir que presione alguna letra para poder volver al inicio, por lo que el código se va a repetir una y otra vez, hasta que el usuario elija la opción 6. Esto implica que todo el menú debe estar dentro de un loop while que se repita una y otra vez hasta que no se cumpla la condición de que la elección del usuario sea 6
- Sería genial que cada vez que el usuario vuelva al menú inicial, la consola limpie la pantalla para que no se acumulen las ejecuciones anteriores. Recuerda que cuentas con system para poder reiniciar la pantalla y comenzar a mostrar todo desde cero.
- Si bien te he enseñado muchos métodos para administrar archivos, para este ejercicio vas a necesitar algunos que aún no has visto, pero que están incluidos en los objetos con los que hemos estado trabajando, por lo que en ocasiones deberás buscar entre los métodos que trae Path, por ejemplo, leer la documentación y aprender a implementarlo. Yo sé que sería mucho más fácil que yo te enseñe todo acerca de cada uno de los métodos, pero recuerda que también es importante que a medida que avanzamos vayas aprendiendo a gestionar tu propio aprendizaje. Es parte de la vida real y cotidiana del programador en el mundo en que vivimos.
- Utiliza muchas funciones, todas las que creas necesario. Las funciones ayudan a compartir, mentalizar el código y hacerlo mucho más dinámico, ordenado, repetible y más fácil de mantener.
- Recuerda comenzar con un diagrama de flujos o un gráfico hecho a mano que te permita visualizar con más facilidad el árbol de decisiones que necesitas ejecutar en tu código. Sin eso te vas a enredar más rápido de lo que crees y se te va a complicar bastante.
- Y, por último, no te frustres si no logras hacerlo o completarlo. Si logras hacer una parte, un par de funciones, algunas cosas sí y otras no, está muy bien. Siempre estamos aprendiendo y parte de aprender es no saber.
Mis desafíos siempre te van a estar ubicando en el borde de tus capacidades, sacándote del lugar de confort para que tu cerebro tenga que desconcertarse y descubrir cómo hacer algo nuevo. Tu avanza hasta donde puedas.
## Ficheros y documentación del día 6
- [01_abrir_manipular_archivos.py](01_abrir_manipular_archivos.py)
- [02_crear_escribir_archivos.py](02_crear_escribir_archivos.py)
- [03_directorios.py](03_directorios.py)
- [04_pathlib.py](04_pathlib.py)
- [05_path.py](05_path.py)
- [06_limpiar_consola.py](06_limpiar_consola.py)
- [07_programa06.py](07_programa06.py)
- [Europa](Europa/)
- [prueba.txt](prueba.txt)
- [Recetas](Recetas/)
- [Recetas.zip](Recetas.zip)
[Documentación del día](../doc_curso/06_recetario/)
---
Enlaces a todos los días: [dia 1 - creador de nombres](../dia_01/README.md) / [dia 2 - calculador de comisiones](../dia_02/README.md) / [dia 3 - analizador de texto](../dia_03/README.md) / [dia 4 - juego "adivina el número"](../dia_04/README.md) / [dia 5 - juego "El ahorcado"](../dia_05/README.md) / [dia 6 - recetario](../dia_06/README.md) / [dia 7 - cuenta bancaria](../dia_07/README.md) / [dia 8 - consola de turnos](../dia_08/README.md) / [dia 9 - buscador de números de serie](../dia_09/README.md) / [dia 10 - juego "Invasión espacial"](../dia_10/README.md) / [dia 11 - web scraping](../dia_11/README.md) / [dia 12 - gestor de restaurantes](../dia_12/README.md) / [dia 13 - asistente de voz](../dia_13/README.md) / [dia 14 - controlador de asistencia](../dia_14/README.md) / [dia 15 - machine learning](../dia_15/README.md) / [dia 16 - aplicación web de tareas pendientes](../dia_16/README.md)

BIN
python-total/dia_06/Recetas.zip Normal file
View File

Binary file not shown.

1
python-total/dia_06/Recetas/Carnes/Entrecot al Malbec.txt Normal file
View File

@@ -0,0 +1 @@
Esta es la receta del Entrecot al Malbec

1
python-total/dia_06/Recetas/Carnes/Matambre a la Pizza.txt Normal file
View File

@@ -0,0 +1 @@
Esta es la receta del Matambre a la Pizza

1
python-total/dia_06/Recetas/Ensaladas/Ensalada Griega.txt Normal file
View File

@@ -0,0 +1 @@
Esta es la receta de la Ensalada Griega

1
python-total/dia_06/Recetas/Ensaladas/Ensalada Mediterranea.txt Normal file
View File

@@ -0,0 +1 @@
Esta es la receta de la Ensalada Mediterranea

1
python-total/dia_06/Recetas/Pastas/Canelones de Espinaca.txt Normal file
View File

@@ -0,0 +1 @@
Esta es la receta de los Canelones de Espinaca

1
python-total/dia_06/Recetas/Pastas/Ravioles de Ricotta.txt Normal file
View File

@@ -0,0 +1 @@
Esta es la receta de los Ravioles de Ricotta

1
python-total/dia_06/Recetas/Postres/Compota de Manzana.txt Normal file
View File

@@ -0,0 +1 @@
Esta es la receta de la Compota de Manzana

1
python-total/dia_06/Recetas/Postres/Flan.txt Normal file
View File

@@ -0,0 +1 @@
Esta es la receta de FLAN de HUEVOS

1
python-total/dia_06/Recetas/Postres/Tarta de Frambuesa.txt Normal file
View File

@@ -0,0 +1 @@
Esta es la receta de la Tarta de Frambuesa

1
python-total/dia_06/Recetas/Postres/Trufas.txt Normal file
View File

@@ -0,0 +1 @@
Las TRUFAS están buenísimas

1
python-total/dia_06/Recetas/Verduras/Cesped.txt Normal file
View File

@@ -0,0 +1 @@
Esto es el contenido de CESPED. Enjoy!

3
python-total/dia_06/prueba.txt Normal file
View File

@@ -0,0 +1,3 @@
Este texto se escribe desde python
Holamundoaquíestoy

28
python-total/dia_07/01_clases.py Normal file
View File

@@ -0,0 +1,28 @@
"""
Clases
"""
# La mínima clase es poner pass
class Pajaro:
pass
# mi_pajaro es una instancia de Pajaro,
# que en este punto se considera un objeto
mi_pajaro = Pajaro()
# Si intentamos mostrar la expresión mínima nos dirá
# que es un objeto guardado en cierto espacio de memoria
print(mi_pajaro)
# Si mostramos el tipo nos dirá __main__
print(type(mi_pajaro))
# Podemos crear más objectos y serán distintos de la misma clase
otro_pajaro = Pajaro()
# Mostrando en pantalla nos mostrará que se guarda
# en otro espacio de memoria
print(otro_pajaro)

34
python-total/dia_07/02_atributos.py Normal file
View File

@@ -0,0 +1,34 @@
"""
Atributos
"""
# Sintaxis:
# def tipo/método (tipo_parámetro, parámetro):
# tipo_parámetro.atributo = parámetro
# Creamos la clase
class Pajaro:
# Atributos de clase
# Para valores comunes entre todos los objetos de la clase
alas = True
# Atributos de instancia
# Constructor de la clase pajaro --> Con el método__init__
def __init__(self, color, especie): # En el paréntesis pasamos dos parámetros
self.color = color # Le damos la instancia que vamos a crear con el atributo
self.especie = especie
# Creamos la instancia. Si dejamos vacios los paréntesis dará error.
# por que pajaro exige un argumento, debe ser un valor para el atributo.
mi_pajaro = Pajaro('negro', 'Tucan')
# Con el punto podremos ver el atributo entre otras propiedades
print(
f'Mi pajaro es de color {mi_pajaro.color} y de la especie {mi_pajaro.especie}')
# Los atributos de clases se pueden dar a la clase y a la instancia:
print(Pajaro.alas, mi_pajaro.alas)

61
python-total/dia_07/03_metodos.py Normal file
View File

@@ -0,0 +1,61 @@
"""
Métodos
"""
# self es un argumento obligatorio
# hace referencia a cada instancia de la clase
class Pajaro:
alas = True
def __init__(self, color, especie):
self.color = color
self.especie = especie
# Cuando se hace referencia a un atributo se debe poner self por delante
# para que se asocie correctamente
def piar(self):
print('pio, mi color es {}'.format(self.color))
def volar(self, metros):
print(f'El pajaro ha volado {metros} metros')
piolin = Pajaro('amarillo', 'canario')
piolin.piar()
piolin.volar(50)
# Otro ejemplo
class Persona:
especie = "humano"
def __init__(self, nombre, edad):
self.nombre = nombre
self.edad = edad
def saludar(self):
print(f'Hola, mi nombre es {self.nombre}')
def cumplir_anios(self, estado_humor):
print(f'Cumplir {self.edad + 1} años me pone {estado_humor}')
juan = Persona("Juan", 37)
juan.saludar()
juan.cumplir_anios("feliz")
class Alarma:
def postergar(self, cantidad_minutos):
print(f"La alarma ha sido pospuesta {cantidad_minutos} minutos")
sonar = Alarma()
sonar.postergar(10)

90
python-total/dia_07/04_tipos_metodos.py Normal file
View File

@@ -0,0 +1,90 @@
"""
Tipos de métodos
# Decoradores:
- Métodos de instancia:
def mi_metodo(self):
print('algo')
mi_metodo
- Acceden y modifican atributos del objeto.
- Acceden a otro métodos.
- Pueden modificar el estado de la clase.
- Métodos de clase @classmethod:
def mi_metodo(cls):
print('algo')
- No están asociados a las instancias de la clase, sino a la clase en si misma
- Pueden ser llamados desde la instancia y desde la clase
- No pueden acceder a los atributos de instancia pero si a los de la clase
- Métodos estáticos @staticmethod:
@staticmethod
def mi_metodo():
print('algo')
- No acepta como parámetro ni self ni cls
- No pueden modificar ni el estado de la clase ni de la instancia
- Pueden aceptar parámetros de entrada
"""
class Pajaro:
alas = True
def __init__(self, color, especie):
self.color = color
self.especie = especie
# Cuando se hace referencia a un atributo se debe poner self por delante
# para que se asocie correctamente
def piar(self):
print('pio, mi color es {}'.format(self.color))
def volar(self, metros):
print(f'El pajaro ha volado {metros} metros')
# De instancia - Acceden a otro métodos
self.piar()
# De instancia - Acceden y modifican atributos del objeto
def pintar_negro(self):
self.color = 'negro'
print(f'Ahora el pájaro es {self.color}')
# Métodos de clase. Necesita el decorador
@classmethod
def poner_huevos(cls, cantidad):
print(f'Puso {cantidad} huevos')
# No pueden acceder a los métodos de instancia
# print(f'Es de color {self.color}')
# Pero si que puede acceder a los métodos de clase
cls.alas = False
print(Pajaro.alas)
@staticmethod
def mirar():
# No accede ni a métodos de instancia ni de clase
# self.color = 'rojo'
# cls.alas = 2
# Así te aseguras que no se modifiquen los métodos
print('El pajaro mira')
Pajaro.poner_huevos(3)
Pajaro.mirar()
piolin = Pajaro('amarillo', 'canario')
piolin.pintar_negro()
piolin.volar(45)
# De instancia - Pueden modificar el estado de la clase
piolin.alas = False
print(piolin.alas)

57
python-total/dia_07/05_herencia.py Normal file
View File

@@ -0,0 +1,57 @@
"""
Herencia
D ONT'T
R EPEAT
Y OURSELF
No repitas el código!
"""
# Ejemplo
class Animal:
# Atributos
def __init__(self, edad, color):
self.edad = edad
self.color = color
# Métodos
def nacer(self):
print("Este animal ha nacido")
def morir(self):
pass
def respirar(self):
pass
class Pajaro(Animal):
pass
class Mamifero(Animal):
pass
class Insecto(Animal):
pass
# Podemos ver de donde vienen las clase con __bases__
print(Pajaro.__bases__)
# Podemos ver las subclases de una clase
print(Animal.__subclasses__())
# Creamos una instancia de pájaro y debe tener los atributos de Animal
piolin = Pajaro(2, "negro")
print(f'Piolin tiene {piolin.edad} años y es de color {piolin.color}')
# La instancia de Pájaro ha heredado los métodos de Animal
piolin.nacer()

85
python-total/dia_07/06_herencia_extendida.py Normal file
View File

@@ -0,0 +1,85 @@
"""
Herencia Extendidad
D ONT'T
R EPEAT
Y OURSELF
No repitas el código!
"""
class Animal:
def __init__(self, edad, color):
self.edad = edad
self.color = color
def nacer(self):
print("Este animal ha nacido")
def hablar(self):
print("Este animal emite un sonido")
class Pajaro(Animal):
def __init__(self, edad, color, altura_vuelo):
super().__init__(edad, color)
self.altura_vuelo = altura_vuelo
def hablar(self):
print("pio")
def volar(self, metros):
print(f'El pájaro vuela {metros} metros')
# Declarar variables
piolin = Pajaro(3, 'amarillo', 500)
mi_animal = Animal(19, 'negro')
piolin.hablar()
piolin.volar(100)
mi_animal.hablar()
# otro ejemplo
class Padre:
def hablar(self):
print('Hola')
class Madre:
def reir(self):
print('ja ja ja')
def hablar(self):
print('Que tal')
class Hijo(Padre, Madre):
pass
class Nieto(Hijo):
pass
# Nieto es capaz de hablar y reir aunque no herede directamente
mi_nieto = Nieto()
mi_nieto.reir()
# El método que hereda es el primero que se encuentra en sus atributos
mi_nieto.hablar()
# Podemos ver el orden de las herencias con __mro__
print(Nieto.__mro__)

55
python-total/dia_07/07_polimorfismo.py Normal file
View File

@@ -0,0 +1,55 @@
"""
Polimorfismo
Distintas clases pueden tener el mismo método
pero se aplicará de manera distinta para cada clase
"""
class Vaca:
def __init__(self, nombre):
self.nombre = nombre
def hablar(self):
print(self.nombre + " dice muuu")
class Oveja:
def __init__(self, nombre):
self.nombre = nombre
def hablar(self):
print(self.nombre + " dice beee")
vaca1 = Vaca('Aurora')
oveja1 = Oveja('Jacinta')
# Dos classes distintas con el mismo método
# que dicen cosas distintas
vaca1.hablar()
oveja1.hablar()
print()
# Ahora en una lista para iterar
# Cuidao! Es genial!
animales = [vaca1, oveja1]
for animal in animales:
animal.hablar()
print()
# También en funciones.
# Impresionante!
def animal_habla(animal):
animal.hablar()
animal_habla(vaca1)
animal_habla(oveja1)

66
python-total/dia_07/08_metodos_especiales.py Normal file
View File

@@ -0,0 +1,66 @@
"""
Métodos especiales
Se han visto:
__init__
__mro__
__bases__
__subclasses__
Vamos a ver:
__str__
__len__
"""
mi_lista = [1, 1, 1, 1, 1, 1, 1, 1]
# print(len(mi_lista))
class Objeto:
pass
mi_objeto = Objeto()
# No se puede aplicar len
# print(len(mi_objeto))
# Tampoco podemos ver el objeto
# print(mi_objeto)
# Otro ejemplo
class CD:
def __init__(self, autor, titulo, canciones):
self.autor = autor
self.titulo = titulo
self.canciones = canciones
# Vamos a modif el comportamiento del método especial __str__
# cada vez que se llame para mostrar lo que se quiera
def __str__(self):
return f'Albun: {self.titulo} de {self.autor}'
# Comportamiento de len
def __len__(self):
return self.canciones
# Podemos añadir un mensaje cuando usemos la función del
def __del__(self):
print("Se ha eliminado el cd")
mi_cd = CD('Pink Floyd', 'The Wall', 24)
# Ahora sí que veremos el return modificado
print(mi_cd)
# También len, hemos modificado su uso para
# que muestre el número de canciones
print(len(mi_cd))
# Podemos eliminar con la función del
del mi_cd
# Si lo intentamos imprimir nos dirá que no existe
# print(mi_cd)

167
python-total/dia_07/09_programa07.py Normal file
View File

@@ -0,0 +1,167 @@
"""
Programa día 7 - Cuenta bancaria
ESTAFA BANK
"""
import os
""" Variables """
limpiar = 'clear'
sleep = 'sleep 2'
""" Clases """
class Persona:
# Atributos: nombre y apellido
def __init__(self, nombre, apellido):
self.nombre = nombre
self.apellido = apellido
class Cliente(Persona):
# atributos propios: número de cuenta y balance
# es decir, el saldo que tiene en su cuenta bancaria.
def __init__(self, nombre, apellido, num_cuenta, balance):
super().__init__(nombre, apellido)
self.num_cuenta = num_cuenta
self.balance = float(round(balance, 2))
# tres métodos
# # método especial que permite que podamos imprimir a nuestro cliente
def __str__(self):
return f'*** CLIENTE ESTAFA BANK ***\n\n\tCliente: \t{self.nombre} {self.apellido}\n\tNº Cuenta: \t{self.num_cuenta}\n\tBalance: \t{self.balance} pesos'
# # Método Depositar que permita decidir cuánto dinero quiere agregar a su cuenta
def depositar(self, cantidad_ingreso):
self.balance += cantidad_ingreso
self.balance = round(self.balance, 2)
print(
f'\nHa ingresado {cantidad_ingreso} Pesos.\n')
# # Método llamado Retirar que permita decidir cuánto dinero quiere sacar de su cuenta
def retirar(self, cantidad_a_retirar):
if (self.balance - cantidad_a_retirar) < 0:
print(
f'\nDisculpa, no tienes tanto dinero.\nBalance: {self.balance} pesos')
else:
self.balance -= cantidad_a_retirar
self.balance = round(self.balance, 2)
print(
f'\nHa retirado {cantidad_a_retirar} Pesos.\n')
""" Funciones """
def clearConsole():
# Función limpiar consola
os.system(limpiar)
def bienvenida():
clearConsole()
# bienvenida al usuario
print(
'\n',
'#' * 39,
'\n # Bienvenid@ a tu cuenta bancaria #\n',
'#' * 39)
os.system(sleep)
clearConsole()
# Iniciar programa pidiendo datos del cliente
crear_cliente()
# Pedir operaciones a realizar - PROGRAMA
operaciones()
def despedida():
clearConsole()
print('Gracias por usar los servicios de ESTAFA BANK, su banco sincero.\n\n¡Ciao!\n')
def crear_cliente():
nombre_cliente = input("Dime tu nombre: ")
apellido_cliente = input("Dime tu/s apelludo/s: ")
global cliente1
cliente1 = Cliente(
nombre_cliente,
apellido_cliente,
'324789563417896324',
0)
def operaciones():
# PROGRAMA
# Pedir al usuario que elija si quiere hacer depósitos o retiros.
operacion = ''
while operacion.lower() != 's':
print(
f'\n',
cliente1,
'\n\n Indicar la operación a realizar:\n',
'\n\t- i\t-->\tIngresar'
'\n\t- r\t-->\tRetirar'
'\n\t- s\t-->\tSalir\n')
operacion = input()
operacion = operacion.lower()
if operacion == "i":
cantidad_a_ingresar = preguntar_cantidad('ingresar')
cliente1.depositar(cantidad_a_ingresar)
continue
elif operacion == "r":
cantidad_a_retirar = preguntar_cantidad('retirar')
cliente1.retirar(cantidad_a_retirar)
continue
elif operacion == "s":
break
else:
clearConsole()
print('Disculpa, ingresa un valor valido\n')
continue
despedida()
def preguntar_cantidad(ope):
clearConsole()
print(
f'\nSu balance actual es de {cliente1.balance} Pesos.\n\n',
f'¿Qué cantidad quiere {ope}?')
cantidad = input()
cantidad = round(float(cantidad), 2)
return cantidad
""" Programa - Se inicia a través de la función de bienvenida """
# Bienvenida e iniciar programa
bienvenida()

237
python-total/dia_07/README.md Normal file
View File

@@ -0,0 +1,237 @@
# Día 7 - Programa una cuenta bancaria
Principios de la programación orientada a objetos (POO):
- Herencia
- Polimorfismo
- Cohesión
- Abstracción
- Acoplamiento
- Encapsulamiento
## Índice
- [Día 7 - Programa una cuenta bancaria](#día-7---programa-una-cuenta-bancaria)
- [Índice](#índice)
- [7.1. - Clases](#71---clases)
- [7.2. - Atributos](#72---atributos)
- [7.3. - Métodos](#73---métodos)
- [7.4. - Tipos de métodos](#74---tipos-de-métodos)
- [7.5. - Herencia](#75---herencia)
- [7.6. - Herencia extendida](#76---herencia-extendida)
- [7.7. - Polimorfismo](#77---polimorfismo)
- [7.8. - Pilares de la Programación Orientada a Objetos](#78---pilares-de-la-programación-orientada-a-objetos)
- [7.9. - Métodos especiales](#79---métodos-especiales)
- [7.10. - Proyecto del Día 7](#710---proyecto-del-día-7)
- [Ficheros y documentación](#ficheros-y-documentación)
## 7.1. - Clases
Python es un lenguaje de Programación Orientado a Objetos (POO). Como tal, utiliza y manipula objetos, a través de sus métodos y propiedades. Las clases son las herramientas que nos permiten crear objetos, que "empaquetan" datos y funcionalidad juntos.
Podemos pensar a las clases como el "plano" o "plantilla" a partir del cual podemos crear objetos individuales, con propiedades y métodos asociados:
![](../img/dia07_01.png)
Las clases se definen con la palabra reservada `class`, seguida del nombre de la clase, y dos puntos. Por convención, los nombres de las clases se escriben con la primera letra en mayúscula, y el resto en minúsculas. Por ejemplo, `MiClase`.
## 7.2. - Atributos
Los atributos son variables que pertenecen a la clase. Existen **atributos de clase** (compartidos por todas las instancias de la clase), **y de instancia** (que son distintos en cada instancia de la clase).
![](../img/dia07_02.png)
Todas las clases tienen una función que se ejecuta al instanciarla, llamada `__init__()`, y que se utiliza para asignar valores a las propiedades del objeto que está siendo creado. self: representa a la instancia del objeto que se va a crear.
## 7.3. - Métodos
Los objetos creados a partir de clases también contienen métodos. Dicho de otra manera, los métodos son funciones que pertenecen al objeto.
```python
class Persona:
especie = "humano"
def __init__(self, nombre, edad):
self.nombre = nombre
self.edad = edad
def saludar(self):
print(f'Hola, mi nombre es {self.nombre}')
def cumplir_anios(self, estado_humor):
print(f'Cumplir {self.edad + 1} años me pone {estado_humor}')
juan = Persona("Juan", 37)
juan.saludar()
juan.cumplir_anios("feliz")
```
Hola, mi nombre es Juan
Cumplir 38 años me pone feliz
Cada vez que un atributo del objeto sea invocado (por ejemplo, en una función), debe incluirse self, que refiere a la instancia en cuestión, indicando la pertenencia de este atributo.
## 7.4. - Tipos de métodos
Los métodos estáticos y de clase anteponen un decorador específico, que indica a Python el tipo de método que se estará definiendo
| | | @classmethod | @staticmethod |
| -------------------------------------------: | :------------------: | :--------------: | :---------------: |
| | Métodos de instancia | Métodos de clase | Métodos estáticos |
| Acceso a métodos y atrbitutos de la clase | Sí | Sí | No |
| Requiere una instancia | Sí | No | No |
| Acceso a métodos y atributos de la instancia | Sí | No | No |
Así como los métodos de instancia requieren del parámetro **self** para acceder a dicha instancia, los métodos de clase requieren del parámetro **cls** para acceder a los atributos de clase. Los métodos estáticos, dado que no pueden acceder a la instancia ni a la clase, no indican un parámetro semejante.
Resumen sobre Decoradores:
- **Métodos de instancia**:
```python
def mi_metodo(self):
print('algo')
mi_metodo
```
- Acceden y modifican atributos del objeto.
- Acceden a otro métodos.
- Pueden modificar el estado de la clase.
- **Métodos de clase** - *@classmethod*:
```python
def mi_metodo(cls):
print('algo')
```
- No están asociados a las instancias de la clase, sino a la clase en si misma
- Pueden ser llamados desde la instancia y desde la clase
- No pueden acceder a los atributos de instancia pero si a los de la clase
- **Métodos estáticos** - *@staticmethod*:
```python
def mi_metodo():
print('algo')
```
- No acepta como parámetro ni self ni cls
- No pueden modificar ni el estado de la clase ni de la instancia
- Pueden aceptar parámetros de entrada
## 7.5. - Herencia
La herencia es el proceso mediante el cual una clase puede tomar métodos y atributos de una clase superior, evitando repetición del código cuando varias clases tienen atributos o métodos en común.
Es posible crear una clase "hija" con tan solo pasar como parámetro la clase de la que queremos heredar:
```python
class Personaje:
def __init__(self, nombre, herramienta):
self.nombre = nombre
self.arma = arma
class Mago(Personaje):
pass
hechicero = Mago("Merlín", "caldero")
```
Una clase "hija" puede sobreescribir los métodos o atributos, así como definir nuevos, que sean específicos para esta clase.
## 7.6. - Herencia extendida
Las clases "hijas" que heredan de las clases superiores, pueden crear nuevos métodos o sobrescribir los de la clase "padre". Asimismo, una clase "hija" puede heredar de una o más clases, y a su vez transmitir herencia a clases "nietas".
Si varias superclases tienen los mismos atributos o métodos, la subclase sólo podrá heredar de una de ellas. En estos casos Python dará prioridad a la clase que se encuentre más a la izquierda.
Del mismo modo, si un mismo método se hereda por parte de la clase "padre", e "hija", la clase "nieta" tendrá preferencia por aquella más próxima ascendente (siguiendo nuestro esquema, la tomará de la clase "hija").
![](../img/dia07_03.png)
**`Clase.__mro__`** - devuelve el orden de resolución de métodos
**`super().__init__(arg1, arg2,...)`** - hereda atributos de las superclases de manera compacta
## 7.7. - Polimorfismo
El polimorfismo es el pilar de la POO mediante el cual un mismo método puede comportarse de diferentes maneras según el objeto sobre el cual esté actuando, en función de cómo dicho método ha sido creado para la clase en particular.
El método len( ) funciona en distintos tipos de objetos: listas, tuplas, strings, entre otros. Esto se debe a que para Python, lo importante no son los tipos de objetos, sino lo que pueden hacer: sus métodos.
```python
class Perro:
def hablar(self):
print("Guau!")
class Gato:
def hablar(self):
print("Miau!")
hachiko = Perro()
garfield = Gato()
for animal in [hachiko, garfield]:
animal.hablar()
```
Guau!
Miau!
## 7.8. - Pilares de la Programación Orientada a Objetos
Se ha visto Herencia y Polimorfismo en las prácticas anteriores. Información conceptual del resto:
- Cohesión: https://escueladirecta-blog.blogspot.com/2021/09/cohesion-pilares-de-la-programacion.html
- Acoplamiento: https://escueladirecta-blog.blogspot.com/2021/10/acoplamiento-pilares-de-la-programacion.html
- Abstracción: https://escueladirecta-blog.blogspot.com/2021/10/abstraccion-pilares-de-la-programacion.html
- Encapsulamiento: https://escueladirecta-blog.blogspot.com/2021/10/encapsulamiento-pilares-de-la.html
## 7.9. - Métodos especiales
Puedes encontrarlos con el nombre de métodos mágicos o dunder methods (del inglés: dunder = double underscore, o doble guión bajo). Pueden ayudarnos a sobrescribir métodos incorporados de Python sobre nuestras clases para controlar el resultado devuelto.
```python
class Libro:
def __init__(self, autor, titulo, cant_paginas):
self.autor = autor
self.titulo = titulo
self.cant_paginas = cant_paginas
def __str__(self):
return f'Título: "{self.titulo}", escrito por {self.autor}'
def __len__(self):
return self.cant_paginas
libro1 = Libro("Stephen King", "It", 1032)
print(str(libro1))
print(len(libro1))
```
Título: "It", escrito por Stephen King
1032
## 7.10. - Proyecto del Día 7
Crear un código que le permita a una persona realizar operaciones en su cuenta bancaria. No te asustes que la consigna va a estar bien definida para que puedas hacerlo en poco tiempo.
Primero vas a crear una clase llamada Persona, y Persona va a tener solo dos atributos: nombre y apellido. Luego, vas a crear una segunda clase llamada Cliente, y Cliente va a heredar de Persona, porque los clientes son personas, por lo que el Cliente va a heredar entonces los atributos de Persona, pero también va a tener atributos propios, como número de cuenta y balance, es decir, el saldo que tiene en su cuenta bancaria.
Pero eso no es todo: Cliente también va a tener tres métodos. El primero va a ser uno de los métodos especiales y es el que permite que podamos imprimir a nuestro cliente. Este método va a permitir que cuando el código pida imprimir Cliente, se muestren todos sus datos, incluyendo el balance de su cuenta. Luego, un método llamado Depositar, que le va a permitir decidir cuánto dinero quiere agregar a su cuenta. Y finalmente, un tercer método llamado Retirar, que le permita decidir cuánto dinero quiere sacar de su cuenta.
Una vez que hayas creado estas dos clases, tienes que crear el código para que tu programa se desarrolle, pidiéndole al usuario que elija si quiere hacer depósitos o retiros. El usuario puede hacer tantas operaciones como quiera hasta que decida salir del programa. Por lo tanto, nuestro código tiene que ir llevando la cuenta de cuánto dinero hay en el balance, y debes procurar, por supuesto, que el cliente nunca pueda retirar más dinero del que posee. Esto no está permitido.
Recuerda que ahora que sabes crear clases y objetos que son estables y que retienen información, no necesitas crear funciones que devuelvan el balance, ya que la instancia de cliente puede saber constantemente cuál es su saldo debido a que puede hacer sus operaciones llamando directamente a este atributo y no a una variable separada.
Para que tu programa funcione, puedes organizar tu código como quieras, hay muchas formas de hacerlo, pero mi recomendación es que básicamente, luego de crear las dos clases que te he mencionado, crees dos funciones una que se encarguen de crear al cliente pidiéndole al usuario toda la información necesaria y devolviendo, a través del return, un objeto cliente ya creado.
La otra función (que puede llamarse inicio, o algo por el estilo), es la función que organiza la ejecución de todo el código: primero llama a la función “crear cliente” y luego se encarga de mantener al usuario en un loop que le pregunte todo el tiempo si quiere depositar, retirar o salir del programa y demostrarle el balance, cada vez que haga una modificación.
Para que este programa no se te haga súper largo o complejo, te propongo que esta vez no nos fijemos tanto en los controles, para ver si el usuario ha puesto opciones permitidas o no, si ha puesto números o no, si ha puesto mayúsculas o minúsculas, y creemos el código confiando en que el usuario va a ingresar siempre información apropiada. Por supuesto que si tú prefieres incluir todos esos controles, está genial.
## Ficheros y documentación
- [01_clases.py](01_clases.py)
- [02_atributos.py](02_atributos.py)
- [03_metodos.py](03_metodos.py)
- [04_tipos_metodos.py](04_tipos_metodos.py)
- [05_herencia.py](05_herencia.py)
- [06_herencia_extendida.py](06_herencia_extendida.py)
- [07_polimorfismo.py](07_polimorfismo.py)
- [08_metodos_especiales.py](08_metodos_especiales.py)
- [09_programa07.py](09_programa07.py)
[Documentación del día](../doc_curso/07_cuenta_bancaria/)
---
Enlaces a todos los días: [dia 1 - creador de nombres](../dia_01/README.md) / [dia 2 - calculador de comisiones](../dia_02/README.md) / [dia 3 - analizador de texto](../dia_03/README.md) / [dia 4 - juego "adivina el número"](../dia_04/README.md) / [dia 5 - juego "El ahorcado"](../dia_05/README.md) / [dia 6 - recetario](../dia_06/README.md) / [dia 7 - cuenta bancaria](../dia_07/README.md) / [dia 8 - consola de turnos](../dia_08/README.md) / [dia 9 - buscador de números de serie](../dia_09/README.md) / [dia 10 - juego "Invasión espacial"](../dia_10/README.md) / [dia 11 - web scraping](../dia_11/README.md) / [dia 12 - gestor de restaurantes](../dia_12/README.md) / [dia 13 - asistente de voz](../dia_13/README.md) / [dia 14 - controlador de asistencia](../dia_14/README.md) / [dia 15 - machine learning](../dia_15/README.md) / [dia 16 - aplicación web de tareas pendientes](../dia_16/README.md)

2
python-total/dia_08/01_pruebas_modulos/moduloOcupado.py Normal file
View File

@@ -0,0 +1,2 @@
def saludar():
print('Hola, estoy en el modulo ocupado')

3
python-total/dia_08/01_pruebas_modulos/moduloVacio.py Normal file
View File

@@ -0,0 +1,3 @@
from moduloOcupado import saludar
saludar()

10
python-total/dia_08/02_pruebas_paquete/ejercicio.py Normal file
View File

@@ -0,0 +1,10 @@
from paquete_ma import suma_y_resta
from paquete_ma.subpaquete_ma import saludo
# Importado del paquete
suma_y_resta.suma(1, 5)
suma_y_resta.resta(15, 3)
# Importado del subpaquete
saludo.hola()

0
python-total/dia_08/02_pruebas_paquete/paquete_ma/__init__.py Normal file
View File

0
python-total/dia_08/02_pruebas_paquete/paquete_ma/subpaquete_ma/__init__.py Normal file
View File

2
python-total/dia_08/02_pruebas_paquete/paquete_ma/subpaquete_ma/saludo.py Normal file
View File

@@ -0,0 +1,2 @@
def hola():
print('hey!!')

6
python-total/dia_08/02_pruebas_paquete/paquete_ma/suma_y_resta.py Normal file
View File

@@ -0,0 +1,6 @@
def suma(num1, num2):
print(num1 + num2)
def resta(num1, num2):
print(num1 - num2)

53
python-total/dia_08/03_manejo_errores.py Normal file
View File

@@ -0,0 +1,53 @@
"""
Manejo de errores
Intentar --> try
Excepción --> except
Finalmente --> finally
"""
def suma():
n1 = int(input('El numero 1: '))
n2 = int(input('El numero 2: '))
print(n1 + n2)
print('Gracias por sumar' + n1)
try:
# Codigo que queremos probar
suma()
except TypeError:
# Código a ejecutar si hay un error
print('Estas intentando concatenar tipos distintos')
except ValueError:
# Código a ejecutar si hay un error
print('Estas intentando sumar algo que no son números?')
else:
# Código a ejecutar si no hay un error
print('Hiciste todo bien')
finally:
# Código que se va a ejecutar de todos modos
print('Eso fue todo')
# Ejemplo para pedir un número de manera correcta
def pedir_numero():
while True:
try:
numero = int(input('Dame un número: '))
except:
print('\nEse no es un número')
else:
print(f'Ingresaste el número {numero}')
break
print('Gracias')
pedir_numero()

15
python-total/dia_08/04_probando_pylint.py Normal file
View File

@@ -0,0 +1,15 @@
"""
Probando pylint
"""
def una_funcion():
"""Funcion con variable que retorna un número."""
numero1 = 500
return numero1
RESULTADO = una_funcion()
# Imprimimos la variable
print(RESULTADO)

41
python-total/dia_08/05_probando_pylint/numeros.py Normal file
View File

@@ -0,0 +1,41 @@
"""
Numeros para práctica
"""
def numeros_perfumeria():
"""Esto es un comentario"""
for numeros_perfum in range(1, 10000):
yield f"P - {numeros_perfum}"
def numeros_farmacia():
"""Esto es un comentario"""
for numeros_farma in range(1, 10000):
yield f"F - {numeros_farma}"
def numeros_cosmetica():
"""Esto es un comentario"""
for numeros_cosmetic in range(1, 10000):
yield f"C - {numeros_cosmetic}"
p = numeros_perfumeria()
f = numeros_farmacia()
c = numeros_cosmetica()
def decorador(rubro):
"""Esto es un comentario"""
print("\n" + "*" * 23)
print("Su número es:")
if rubro == "P":
print(next(p))
elif rubro == "F":
print(next(f))
else:
print(next(c))
print("Aguarde y será atendido")
print("*" * 23 + "\n")

12
python-total/dia_08/05_probando_pylint/practica_pylint.py Normal file
View File

@@ -0,0 +1,12 @@
"""
Esto es un comentario
"""
def sumar(numero1, numero2):
""" Comentando tal y tal """
return numero1+numero2
SUMA = sumar(5, 7)
print(SUMA)

2
python-total/dia_08/06_probando_unittest/cambia_texto.py Normal file
View File

@@ -0,0 +1,2 @@
def todo_mayuscula(texto):
return texto.upper()

Some files were not shown because too many files have changed in this diff Show More