From 7e689e963a3786ef427790b5fc382ba2121f11d7 Mon Sep 17 00:00:00 2001 From: any7dev Date: Mon, 24 Jun 2024 01:58:26 +0200 Subject: [PATCH] #12, 13, 14, 15, 16, 17, 18 - Python --- Roadmap/12 - JSON Y XML/python/any7dev.py | 66 +++++++++++ .../13 - PRUEBAS UNITARIAS/python/any7dev.py | 29 +++++ Roadmap/14 - FECHAS/python/any7dev.py | 37 ++++++ .../15 - ASINCRON\303\215A/python/any7dev.py" | 57 +++++++++ .../python/any7dev.py | 108 ++++++++++++++++++ Roadmap/17 - ITERACIONES/python/any7dev.py | 76 ++++++++++++ Roadmap/18 - CONJUNTOS/python/any7dev.py | 56 +++++++++ 7 files changed, 429 insertions(+) create mode 100644 Roadmap/12 - JSON Y XML/python/any7dev.py create mode 100644 Roadmap/13 - PRUEBAS UNITARIAS/python/any7dev.py create mode 100644 Roadmap/14 - FECHAS/python/any7dev.py create mode 100644 "Roadmap/15 - ASINCRON\303\215A/python/any7dev.py" create mode 100644 Roadmap/16 - EXPRESIONES REGULARES/python/any7dev.py create mode 100644 Roadmap/17 - ITERACIONES/python/any7dev.py create mode 100644 Roadmap/18 - CONJUNTOS/python/any7dev.py diff --git a/Roadmap/12 - JSON Y XML/python/any7dev.py b/Roadmap/12 - JSON Y XML/python/any7dev.py new file mode 100644 index 0000000000..5ae3d2fb50 --- /dev/null +++ b/Roadmap/12 - JSON Y XML/python/any7dev.py @@ -0,0 +1,66 @@ +""" /* + * IMPORTANTE: Sólo debes subir el fichero de código como parte del ejercicio. + * + * EJERCICIO: + * Desarrolla un programa capaz de crear un archivo XML y JSON que guarde los + * siguientes datos (haciendo uso de la sintaxis correcta en cada caso): + * - Nombre + * - Edad + * - Fecha de nacimiento + * - Listado de lenguajes de programación + * Muestra el contenido de los archivos. + * Borra los archivos. + * + * DIFICULTAD EXTRA (opcional): + * Utilizando la lógica de creación de los archivos anteriores, crea un + * programa capaz de leer y transformar en una misma clase custom de tu + * lenguaje los datos almacenados en el XML y el JSON. + * Borra los archivos. + */ """ + +#EJERCICIO +import json +import xml.etree.ElementTree as ET +import os + +#JSON +contenido = { + "Nombre": "Ana", + "Edad": 36, + "Fecha Nacimiento": "11/03/1988", + "Lenguajes": ["Cobol", "Python"] +} + +with open ("archivo.json", 'w') as archivo: + json.dump(contenido, archivo, indent=3) + +with open ("archivo.json", 'r') as archivo: + print(json.load(archivo)) + +os.remove("archivo.json") + +#XML +archivo = "archivo.xml" + +#Creamos el árbol con los datos +contenido = ET.Element("contenido") +datos = ET.SubElement(contenido, "datos") +ET.SubElement(datos, "Nombre").text = "Ana" +ET.SubElement(datos, "Edad").text = "36" +ET.SubElement(datos, "Fecha_Nacimiento").text = "11/03/1988" +ET.SubElement(datos, "Lenguajes").text = "Cobol, Python" + +#Creamos el fichero +ET.indent(contenido) +et = ET.ElementTree(contenido) +et.write(archivo, xml_declaration=True, encoding="UTF-8") + +with open (archivo, 'r') as a: + print(a.read()) + +os.remove("archivo.xml") + + + + + diff --git a/Roadmap/13 - PRUEBAS UNITARIAS/python/any7dev.py b/Roadmap/13 - PRUEBAS UNITARIAS/python/any7dev.py new file mode 100644 index 0000000000..650dbf9678 --- /dev/null +++ b/Roadmap/13 - PRUEBAS UNITARIAS/python/any7dev.py @@ -0,0 +1,29 @@ +""" /* +* EJERCICIO: +* Crea una función que se encargue de sumar dos números y retornar +* su resultado. +* Crea un test, utilizando las herramientas de tu lenguaje, que sea +* capaz de determinar si esa función se ejecuta correctamente. +* +* DIFICULTAD EXTRA (opcional): +* Crea un diccionario con las siguientes claves y valores: +* "name": "Tu nombre" +* "age": "Tu edad" +* "birth_date": "Tu fecha de nacimiento" +* "programming_languages": ["Listado de lenguajes de programación"] +* Crea dos test: +* - Un primero que determine que existen todos los campos. +* - Un segundo que determine que los datos introducidos son correctos. +*/ """ + +#EJERCICIO +import unittest +from assertpy import assert_that + +def suma (num1, num2): + return num1+num2 + +class TestSuma(unittest.TestCase): + def test(self): + resultado = suma (2, 3) + assert_that(resultado).is_instance_of(int) \ No newline at end of file diff --git a/Roadmap/14 - FECHAS/python/any7dev.py b/Roadmap/14 - FECHAS/python/any7dev.py new file mode 100644 index 0000000000..556b62be38 --- /dev/null +++ b/Roadmap/14 - FECHAS/python/any7dev.py @@ -0,0 +1,37 @@ +""" /* + * EJERCICIO: + * Crea dos variables utilizando los objetos fecha (date, o semejante) de tu lenguaje: + * - Una primera que represente la fecha (día, mes, año, hora, minuto, segundo) actual. + * - Una segunda que represente tu fecha de nacimiento (te puedes inventar la hora). + * Calcula cuántos años han transcurrido entre ambas fechas. + * + * DIFICULTAD EXTRA (opcional): + * Utilizando la fecha de tu cumpleaños, formatéala y muestra su resultado de + * 10 maneras diferentes. Por ejemplo: + * - Día, mes y año. + * - Hora, minuto y segundo. + * - Día de año. + * - Día de la semana. + * - Nombre del mes. + * (lo que se te ocurra...) + */ """ + +#EJERCICIO +import datetime + +fecha_actual = datetime.datetime.now() +fecha_nacimiento = datetime.datetime(1988, 3, 11, 15, 0, 0) +print(fecha_actual.year - fecha_nacimiento.year) + +#DIFICULTAD EXTRA +print(fecha_nacimiento.strftime("%d-%m-%y")) #1 +print(fecha_nacimiento.strftime("%H:%M:%S")) #2 +print(fecha_nacimiento.timetuple()[7])#3 +print(fecha_nacimiento.isoweekday())#4 +print(fecha_nacimiento.strftime("%B"))#5 +print(fecha_nacimiento.ctime())#6 +print(fecha_nacimiento.strftime("%A, %d. %B %Y %I:%M%p"))#7 +print(fecha_nacimiento.isocalendar()[1]) #8 Número de la semana +print(fecha_nacimiento.strftime("%d %m %Y")) #9 +print(fecha_nacimiento.toordinal())#10 Ordinal gregoriano proléptico de la fecha + diff --git "a/Roadmap/15 - ASINCRON\303\215A/python/any7dev.py" "b/Roadmap/15 - ASINCRON\303\215A/python/any7dev.py" new file mode 100644 index 0000000000..d2dc238fb4 --- /dev/null +++ "b/Roadmap/15 - ASINCRON\303\215A/python/any7dev.py" @@ -0,0 +1,57 @@ +""" /* + * EJERCICIO: + * Utilizando tu lenguaje, crea un programa capaz de ejecutar de manera + * asíncrona una función que tardará en finalizar un número concreto de + * segundos parametrizables. También debes poder asignarle un nombre. + * La función imprime su nombre, cuándo empieza, el tiempo que durará + * su ejecución y cuando finaliza. + * + * DIFICULTAD EXTRA (opcional): + * Utilizando el concepto de asincronía y la función anterior, crea + * el siguiente programa que ejecuta en este orden: + * - Una función C que dura 3 segundos. + * - Una función B que dura 2 segundos. + * - Una función A que dura 1 segundo. + * - Una función D que dura 1 segundo. + * - Las funciones C, B y A se ejecutan en paralelo. + * - La función D comienza su ejecución cuando las 3 anteriores han + * finalizado. + */ """ + +#EJERCICIO +import asyncio +import time + +async def funcion_asincrona(segundos): + nombre = "Hola Mundo asíncrono" + print(nombre) + print(time.strftime("%H:%M:%S")) + print(segundos) + await asyncio.sleep(segundos) + print(time.strftime("%H:%M:%S")) + +asyncio.run(funcion_asincrona(3)) + +#DIFICULTAD EXTRA +async def funcion_a(): + print("Soy la función A") + await asyncio.sleep(1) + +async def funcion_b(): + print("Soy la función B") + await asyncio.sleep(2) + +async def funcion_c(): + print("Soy la función C") + await asyncio.sleep(3) + +async def funcion_d(): + print("Soy la función D") + await asyncio.sleep(1) + +async def extra(): + await asyncio.gather(funcion_a(), funcion_b(), funcion_c()) + await funcion_d() + + +asyncio.run(extra()) diff --git a/Roadmap/16 - EXPRESIONES REGULARES/python/any7dev.py b/Roadmap/16 - EXPRESIONES REGULARES/python/any7dev.py new file mode 100644 index 0000000000..5aaf75a8a7 --- /dev/null +++ b/Roadmap/16 - EXPRESIONES REGULARES/python/any7dev.py @@ -0,0 +1,108 @@ +""" /* + * EJERCICIO: + * Utilizando tu lenguaje, explora el concepto de expresiones regulares, + * creando una que sea capaz de encontrar y extraer todos los números + * de un texto. + * + * DIFICULTAD EXTRA (opcional): + * Crea 3 expresiones regulares (a tu criterio) capaces de: + * - Validar un email. + * - Validar un número de teléfono. + * - Validar una url. + */ """ + +#EJERCICIO +import re + +texto = ("La sociedad francesa estaba dividida en estamentos dependiendo de sus clases sociales", + "el poder mas alto lo tenía el rey, detrás estaban la nobleza y el clero y el nivel mas bajo de poder", + "lo tenia el tercer estado que estaba constituido por la burguesía, los artesanos y los campesinos.", + "Los Estados Generales eran una asamblea, compuesta por tres ordenes separados: el clero, la nobleza y el grupo formado", + "por burguesía y campesinado. Este último orden se conoce como el tercer estadeo, término que usaremos para referirnos", + "a él en lo sucesivo. Dicha asamblea se había citado por ultima vez en 1614 y el dramatismo de la situación obligó al", + "gobierno a convocarla nuevamente.", + "Luis XVI cedió a las presiones de la reina María Antonieta y del conde de Artois y dio instrucciones para que varios", + "regimientos extranjeros leales se concentraran en París y Versailles. Al mismo tiempo, Necker fue nuevamente destituido.", + "El pueblo de París respondió con la insurrección ante estos actos de provocación; los disturbios comenzaron el 12 de julio", + "y las multitudes asaltaron y tomaron La Bastilla -una prisión real que simbolizaba el despotismo de los Borbones- el 14", + "de julio.", + "El 5 de octubre de 1789, las mujeres parisinas partieron desde los barrios obreros hacia la residencia real de Versailles,", + "este suceso dió comienzo a la revolución.", + "A fines de 1792 comenzó el proceso de Convención contra Luis XVI, quien fue juzgado y condenado a la guillotina por mayoría", + "de votos. El 21 de enero de 1793, Luis subió al cadalso, inconmovible hasta el último momento en el sentimiento", + "de su inocencia. La noticia de la muerte del rey produjo indignación en Inglaterra, la que despidió al embajador o", + "representante francés. Francia contestó declarando la guerra a Inglaterra y a Holanda, su aliada.") + +patron1 = re.findall(r"\b(\d{1,})\b", str(texto)) +print(patron1) +for match in re.finditer(r"\b(\d{1,})\b", str(texto)): + print(match.group()) + +patron2 = re.findall("[0-9]", str(texto)) +print(patron2) + +#DIFICULTAD EXTRA +email1 = "ana@ana.es" +email2 = "-1.3@_dev.com" +email3 = "12345" + +patron_email = r"\b[a-z0-9\"#$% &`*+-_.\/|\^\{\} ~]+[a-z0-9]@[a-z0-9-]+.[a-z]{2,}\b" + +if re.match(patron_email, email1): + print(f"{email1} válido") +else: + print(f"{email1} no válido") + +if re.match(patron_email, email2): + print(f"{email2} válido") +else: + print(f"{email2} no válido") + +if re.match(patron_email, email3): + print(f"{email3} válido") +else: + print(f"{email3} no válido") + +tlf1 = "911203650" +tlf2 = "541201459" +tlf3 = "770777007" + +patron_tlf = r"\b[6-9]+[0-9]{8}\b" + +if re.match(patron_tlf,tlf1): + print(f"{tlf1} válido") +else: + print(f"{tlf1} no válido") + +if re.match(patron_tlf,tlf2): + print(f"{tlf2} válido") +else: + print(f"{tlf2} no válido") + +if re.match(patron_tlf,tlf3): + print(f"{tlf3} válido") +else: + print(f"{tlf3} no válido") + + +url1 = "http://www.hack.com" +url2 = "123.com" +url3 = "hola_!3.es" + +patron_url = "(http|https|ftp):\/\/[w]{3}\.[a-z0-9]+\.[a-z0-9]{2,}" + +if re.match(patron_url,url1): + print(f"{url1} válida") +else: + print(f"{url1} no válida") + +if re.match(patron_url,url2): + print(f"{url2} válido") +else: + print(f"{url2} no válida") + +if re.match(patron_url,url3): + print(f"{url3} válida") +else: + print(f"{url3} no válida") + diff --git a/Roadmap/17 - ITERACIONES/python/any7dev.py b/Roadmap/17 - ITERACIONES/python/any7dev.py new file mode 100644 index 0000000000..9309ccd150 --- /dev/null +++ b/Roadmap/17 - ITERACIONES/python/any7dev.py @@ -0,0 +1,76 @@ +""" /* + * EJERCICIO: + * Utilizando tu lenguaje, emplea 3 mecanismos diferentes para imprimir + * números del 1 al 10 mediante iteración. + * + * DIFICULTAD EXTRA (opcional): + * Escribe el mayor número de mecanismos que posea tu lenguaje + * para iterar valores. ¿Eres capaz de utilizar 5? ¿Y 10? + */ """ + +#EJERCICIO +for i in range(1, 11): #1 + print(i) + +i = 1 +while i<=10: #2 + print(i) + i += 1 + +lista_numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] #3 +for i in lista_numeros: + print(i) + +#DIFICULTAD EXTRA +def iterar(numero): + if numero <= 10: + print(numero) + iterar(numero+1) #4 + +iterar(1) + +for num in enumerate(lista_numeros): #5 + print(num) + +zip_numeros = zip(lista_numeros) #6 +for num in zip_numeros: + print(num) + +dict_numeros = {"n1":1, "n2":2, "n3":3, "n4":4, "n5":5, "n6":6, "n7":7, "n8":8, "n9":9, "n10":10} +for n, numero in dict_numeros.items(): #7 + print(n, numero) + +def generador(n): + contador = 1 + while contador <= n: + yield contador #8 + contador += 1 + +for numero in generador(10): + print(numero) + +mi_iterador = iter(lista_numeros) #9 +print(next(mi_iterador)) +print(next(mi_iterador)) +print(next(mi_iterador)) +print(next(mi_iterador)) +print(next(mi_iterador)) +print(next(mi_iterador)) +print(next(mi_iterador)) +print(next(mi_iterador)) +print(next(mi_iterador)) +print(next(mi_iterador)) + +print([num for num in lista_numeros]) #10 + +lista_numeros15= [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] + +def menores(n): + return n <= 10 + +lista_numeros15_filtrada = filter(menores, lista_numeros15) #11 +print(list(lista_numeros15_filtrada)) + +suma_lista = map(lambda n: n + 0, lista_numeros) #12 +print(list(suma_lista)) + diff --git a/Roadmap/18 - CONJUNTOS/python/any7dev.py b/Roadmap/18 - CONJUNTOS/python/any7dev.py new file mode 100644 index 0000000000..09f954bf8d --- /dev/null +++ b/Roadmap/18 - CONJUNTOS/python/any7dev.py @@ -0,0 +1,56 @@ +""" /* + * EJERCICIO: + * Utilizando tu lenguaje crea un conjunto de datos y realiza las siguientes + * operaciones (debes utilizar una estructura que las soporte): + * - Añade un elemento al final. + * - Añade un elemento al principio. + * - Añade varios elementos en bloque al final. + * - Añade varios elementos en bloque en una posición concreta. + * - Elimina un elemento en una posición concreta. + * - Actualiza el valor de un elemento en una posición concreta. + * - Comprueba si un elemento está en un conjunto. + * - Elimina todo el contenido del conjunto. + * + * DIFICULTAD EXTRA (opcional): + * Muestra ejemplos de las siguientes operaciones con conjuntos: + * - Unión. + * - Intersección. + * - Diferencia. + * - Diferencia simétrica. + */ """ + +#EJERCICIO +lista = [2, 4, 7, 20, 23, 6] #Crear +print(lista) + +lista.append(24) #Añadir al final +print(lista) + +lista.insert(0, 1) #Añadir al principio +print(lista) + +lista.extend([0, 3, 10]) #Añadir en bloque al final +print(lista) + +lista[5:3] = [11, 50, 30] #Añade varios elementos en una posición concreta +print(lista) + +lista.pop(7) #Elimina el elemento de la posición 6 +print(lista) + +lista[5] = 5 #Actualiza el valor del elemento en la posición 5 +print(lista) + +print(20 in lista) #Comprueba si 20 está en la lista + +lista.clear() #Elimina todo el contenido +print(lista) + +#DIFICULTAD EXTRA +conjunto1 = {2, 4, 7, 20, 23, 6, 0, 11} +conjunto2 = {0, 3, 10, 11, 50, 30, 7, 4} + +print(conjunto1.union(conjunto2)) +print(conjunto1.intersection(conjunto2)) +print(conjunto1.difference(conjunto2)) +print(conjunto1.symmetric_difference(conjunto2)) \ No newline at end of file