Merge pull request #6449 from Dkp-Dev/main

#4 - Python

Author: Roswell468

Roadmap/04 - CADENAS DE CARACTERES/python/Dkp-Dev.py

@@ -0,0 +1,125 @@
+"""
+EJERCICIO:
+ * Muestra ejemplos de todas las operaciones que puedes realizar con cadenas de caracteres
+ * en tu lenguaje. Algunas de esas operaciones podrían ser (busca todas las que puedas):
+ * - Acceso a caracteres específicos, subcadenas, longitud, concatenación, repetición,
+ *   recorrido, conversión a mayúsculas y minúsculas, reemplazo, división, unión,
+ *   interpolación, verificación...
+"""
+
+# Operaciones
+
+x1 = "Perro"
+x2 = "Conejo"
+x3 = "tortuga nadando"
+
+print(x1 + x2)      # Concatenacion (pegar dos o mas cadenas de texto)
+
+print(x1 * 3)       # Repeticion
+
+print(x1[4] + x1[3] + x1[2] + x1[1] + x1[0])    # Indexacion (indicar un solo caracter de la cadena)
+
+print(len(x2))      # Longitud
+
+print(x2[2:6])      # Slicing (porcionar la cadena de texto)
+print(x2[2:])
+print(x2[:4])
+
+print("e" in x1)    # Busqueda (comprobar si el/los caracteres se encuentran en una cadena de texto)
+print("jo" in x2)
+
+print(x2.replace("o","a"))  # Remplazo
+
+print(x2.split("e"))        # Division de una cadena que da como resultado una lista
+
+print(x3.upper())   # Convertir a Mayusculas
+
+print(x1.lower())   # Convertir a minusculas
+
+print(x3.title())   # Primera letra a mayuscula de cada palabra
+
+print(x3.capitalize())  # Primera letra a mayuscula de toda la cadena de texto
+
+print(" Dkp Dev ")
+print(" Dkp Dev ".strip())  # Elimincacion de espacios al comienzo y al final de la cadena
+
+print(x3.startswith("Tor")) # Comprueba si la cadena inicia con los caracteres que se especifiquen
+print(x3.startswith("tor"))
+
+print(x3.find("ando"))  # Busqueda por posicion del caracter
+
+print(x3.count("a"))    # Busqueda de ocurrencias (cuantas veces aparece el caracter)
+
+print("{}, {} y {}".format(x1,x2,x3))   # Formateo de una cadena eligiendo donde insertare mis cadenas de texto
+
+print(f"{x2}, {x1} y {x3}")     # Interpolacion
+
+print(list(x1))         # Transforma una cadena en lista
+
+l1 = [x1, x2, "y", x3]
+print(" ".join(l1))     # Transforma una lista a cadena de texto
+
+x4 = "357"          # Transformar una cadena numerica en un 'int'
+x4 = int(x4)
+print(x4)
+
+x5 = "35.7"         # Transformar una cadena numerica en un 'float'
+x5 = float(x5)
+print(x5)
+
+x1 = "Perro"            # Comprobaciones
+x6 = "123123"
+print(x1.isalpha())     # Si la cadena es alfabetica (solo contiene letras)
+print(x6.isalpha())
+
+print(x1.isnumeric())   # Si la cadena es numerica (solo contiene numeros)
+print(x6.isnumeric())
+
+print(x1.isalnum())     # Si la cadena es alfanumerica (contiene letras y/o numeros)
+print(x6.isalnum())
+
+"""
+DIFICULTAD EXTRA (opcional):
+ * Crea un programa que analice dos palabras diferentes y realice comprobaciones
+ * para descubrir si son:
+ * - Palíndromos (palabras que se leen igual aunque se posiciones en orden inverso como radar o salas)
+ * - Anagramas (palabras que contiene las mismas letras pero en diferente orden)
+ * - Isogramas (palabras que no tienen mas de una letra repetida)
+
+"""
+
+def check(cadena1: str,cadena2: str):
+
+    # Palindromo
+    print(f"Es {cadena1} un palindromo?: {cadena1 == cadena1[::-1]}")   # Mediante el slicing comprobamos si la cadena se lee igual en reversa
+    print(f"Es {cadena2} un palindromo?: {cadena2 == cadena2[::-1]}")
+
+    # Anagramas
+    print(f"Es {cadena1} un anagrama de {cadena2}?: {sorted(cadena1) == sorted(cadena2)}")      # Se ordenan las cadenas y se comprueban los characteres
+
+    # Isograma
+
+    def isograma(cadena:str) -> bool:       # Funcion que recibe una cadena y arroja un booleano
+
+        cadena_dict = dict()        # Primero un dict de la cadena
+        for letras in cadena:
+            cadena_dict[letras] = cadena_dict.get(letras, 0) + 1
+
+        isograma = True
+        valor = list(cadena_dict.values())      # Lista de values
+        isograma_len = valor[0]
+        for cadena_count in valor:              # Se cuentan los values
+            if cadena_count != isograma_len:    # Se comprueban ambas listas
+                isograma = False
+                break
+
+        return isograma
+
+    print(f"Es {cadena1} un isograma? {isograma(cadena1)}")
+    print(f"Es {cadena2} un isograma? {isograma(cadena2)}")
+
+
+   
+
+check("radar","quesoqueso")
+check("amor","roma")

Roadmap/05 - VALOR Y REFERENCIA/python/Dkp-Dev.py

@@ -0,0 +1,90 @@
+"""
+* EJERCICIO:
+ * - Muestra ejemplos de asignación de variables "por valor" y "por referencia", según
+ *   su tipo de dato.
+ * - Muestra ejemplos de funciones con variables que se les pasan "por valor" y 
+ *   "por referencia", y cómo se comportan en cada caso en el momento de ser modificadas.
+ * (Entender estos conceptos es algo esencial en la gran mayoría de lenguajes)
+"""
+
+# Tipos de dato por valor
+# Los valores de las variables estan indicados y aunque otra variable copie su valor creara su propia direccion
+
+a = 10
+b = a
+b = 20
+
+print(a)    # Imprime 10
+print(b)    # Imprime 20 a pesar de que en un punto se le indico que copiara el valor de a
+
+# Tipo de dato por referencia
+
+list_a = [10,20]
+list_b = list_a
+list_b.append(30)
+
+print(list_a)   # Ambas impresiones tienen el mismo valor [10,20,30]
+print(list_b)
+
+# Los tipos de dato por referencia no "adquieren" valores sino "heredan" o "apuntan" direcciones, por esto mismo al cambiar el valor b cambia el de a
+
+
+# Funciones con datos por referencia
+
+def list_func(my_list: list):
+    my_list.append(30)
+
+    list_z = my_list
+    list_z.append(40)
+
+    print(my_list)
+    print(list_z)
+
+
+list_x = [10,20]
+list_func(list_x)
+print(list_x)
+
+
+"""
+DIFICULTAD EXTRA (opcional):
+ * Crea dos programas que reciban dos parámetros (cada uno) definidos como
+ * variables anteriormente.
+ * - Cada programa recibe, en un caso, dos parámetros por valor, y en otro caso, por referencia.
+ *   Estos parámetros los intercambia entre ellos en su interior, los retorna, y su retorno
+ *   se asigna a dos variables diferentes a las originales. A continuación, imprime
+ *   el valor de las variables originales y las nuevas, comprobando que se ha invertido
+ *   su valor en las segundas.
+ *   Comprueba también que se ha conservado el valor original en las primeras.
+"""
+
+# Por Valor
+
+def box(var1: int, var2: int) -> tuple:
+    var_t = var1
+    var1 = var2
+    var2 = var_t
+    return var1, var2
+
+var_x = 10
+var_z = 20
+var_r, var_s = box(var_x,var_z)
+
+print(f"X es {var_x} y Z es {var_z}")
+print(f"R es {var_r} y S es {var_s}")
+
+# Por referencia
+
+def chest(var1: list, var2: list) -> tuple:
+    var_t = var1
+    var1 = var2
+    var2 = var_t
+    return var1, var2
+
+list_x = [10,20]
+list_z = [30,40]
+list_r, list_s = chest(list_x,list_z)
+
+print(f"X es {list_x} y Z es {list_z}")
+print(f"R es {list_r} y S es {list_s}")
+