├── 01_Hola.py ├── 02_Variables.py ├── 03_Estilo_WCODE.py ├── 04_Introducir_Datos.py ├── 05_00_Operadores_Aritmeticos.py ├── 05_01_Solucion_AreaCuadrado.py ├── 05_02_Solucion_AreaTriangulo.py ├── 05_03_Solucion_AreaCirculo.py ├── 05_04_Solucion_FarenheitCelcius.py ├── 05_05_Solucion_SumarTramas.py ├── 06_Elementos_de_Listas.py ├── 07_Metodos_de_Listas.py ├── 08_Manejo_de_Cadenas.py ├── 09_Metodos_de_Cadenas.py ├── 10_Tuplas_ Diccionarios.py ├── 11_Nuevo_Fomato.py ├── 12_Alineacion_de_Caracteres.py ├── 13_00_Ejercicios_Colecciones_Cadenas.py ├── 13_01_Solucion_Colecciones_Forma1.py ├── 13_02_Solucion_Colecciones_Forma2.py ├── 14_Estructuras_Condicionales.py ├── 15_00_Ejercicios _Estructuras_Condicionales.py ├── 15_01_Solucion_Estructuras_Condicionales.py ├── 16_Estructuras_Repetitivas.py ├── 17_Bucle_Infinito.py ├── 18_Bucle_for_in.py ├── 19_Bucle_for_in_range.py ├── 20_00_Ejercicios_Estructuras_Repetitivas.py ├── 20_01_Solucion_Estructuras_Repetitivas.py ├── 21_00_Bucles_Anidados.py ├── 21_01_Solucion_Bucles_Anidados.py ├── 22_00_Variables_Auxiliares.py ├── 22_01_Solucion_Variables_Auxiliares.py ├── 23_00_Banderas_de_Estado.py ├── 23_01_Solucion_Banderas_de_Estado.py ├── 24_Funciones.py ├── 25_Funciones con Parametros.py ├── 26_Parametros_Arbitrarios.py ├── 27_Recursividad.py ├── 28_Funciones_Lambda.py ├── 28_Validacion_de_Datos.py ├── 29_Manejo_de_Excepciones.py └── README.md /01_Hola.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ingwplanchez/wcode-python-3x/9bc1fea7e1711f517767886475676d01a5ed48e4/01_Hola.py -------------------------------------------------------------------------------- /02_Variables.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ingwplanchez/wcode-python-3x/9bc1fea7e1711f517767886475676d01a5ed48e4/02_Variables.py -------------------------------------------------------------------------------- /03_Estilo_WCODE.py: -------------------------------------------------------------------------------- 1 | # ESTILO WCODE 2 | 3 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 4 | # float_Nombre_variable = tipo_dato ; Variables con decimales 5 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 6 | # bool_Nombre_variable = tipo_dato ; variables booleanas 7 | 8 | # Pseudocódigo: 9 | 10 | # nombre_variable = tipo_dato 11 | # imprime nombre_variable 12 | 13 | int_Numero = 100 14 | float_Ddecimal = 78.2 15 | str_Cadena = "WCODE" 16 | bool_Estado = True 17 | 18 | print ("TIPOS DE VARIABLES") 19 | print ("") 20 | print ("Variable tipo entera : %d" %(int_Numero)) 21 | print ("Variable tipo flotante: %f" %(float_Ddecimal)) 22 | print ("Variable tipo cadena : %s" %(str_Cadena)) 23 | print ("Variable tipo booleana: %d" %(bool_Estado)) 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /04_Introducir_Datos.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ingwplanchez/wcode-python-3x/9bc1fea7e1711f517767886475676d01a5ed48e4/04_Introducir_Datos.py -------------------------------------------------------------------------------- /05_00_Operadores_Aritmeticos.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ingwplanchez/wcode-python-3x/9bc1fea7e1711f517767886475676d01a5ed48e4/05_00_Operadores_Aritmeticos.py -------------------------------------------------------------------------------- /05_01_Solucion_AreaCuadrado.py: -------------------------------------------------------------------------------- 1 | 2 | # 1) Programa que solicite al usuario los datos para 3 | # calcular el area de un Cuadrado 4 | 5 | #VARIABLES 6 | 7 | int_Lado = 0 8 | int_Area = 0 9 | 10 | #Inicio de Programa 11 | 12 | print("CALCULAR EL AREA DEL CUADRADO") 13 | 14 | int_Lado = int(input('Introduzca el valor del lado del cuadrado: ')) 15 | 16 | # AREA DEL CUADRADO 17 | # Area = Lado ** 2 18 | int_Area = int_Lado**2 19 | 20 | print("El area del cuadrado es: %d"%(int_Area)) 21 | 22 | -------------------------------------------------------------------------------- /05_02_Solucion_AreaTriangulo.py: -------------------------------------------------------------------------------- 1 | 2 | # 2) Programa que solicite al usuario los datos para calcular 3 | # el area de un Triangulo. 4 | 5 | # VARIABLES 6 | 7 | int_Base = 0 8 | int_Altura = 0 9 | float_Area = 0.0 10 | 11 | # Incio de programa 12 | 13 | print("CALCULAR EL AREA DEL TRIANGULO") 14 | 15 | int_Base = int(input('Introduzca el valor de la Base: ')) 16 | int_Altura = int(input('Introduzca el valor de la Altura:')) 17 | 18 | # AREA DEL TRIANGULO 19 | # Area = (Base*Altura)/2 20 | float_Area = (int_Base*int_Altura)/2 21 | 22 | print("El area del triangulo es: %0.2f"%(float_Area)) 23 | -------------------------------------------------------------------------------- /05_03_Solucion_AreaCirculo.py: -------------------------------------------------------------------------------- 1 | 2 | # 3) Programa que solicite al usuario los datos para calcular 3 | # el area de un Circulo 4 | 5 | 6 | # CONSTANTES 7 | 8 | PI = 3.1416 # Valor aproximado de PI 9 | 10 | # VARIABLES 11 | 12 | int_Radio = 0 13 | float_Area = 0 14 | 15 | # Incio de programa 16 | 17 | print("CALCULAR EL AREA DEL CIRCULO") 18 | 19 | int_Radio = int(input('Introduzca el radio del circulo: ')) 20 | 21 | # AREA DE UN CIRCULO 22 | # Area = PI*(Radio**2) 23 | float_Area = PI*(int_Radio**2) 24 | 25 | print("El area del circulo es: %0.2f"%(float_Area)) -------------------------------------------------------------------------------- /05_04_Solucion_FarenheitCelcius.py: -------------------------------------------------------------------------------- 1 | 2 | # 4) Programa que solicite al usuario los datos para llevar 3 | # Grados farenheit a Grados Celcius 4 | 5 | # VARIABLES 6 | 7 | int_farenheit = 0 8 | float_celcius = 0.0 9 | 10 | # Incio de programa 11 | 12 | print("LLEVAR GRADOS FARENHEIT A CELCIUS") 13 | 14 | int_farenheit = int(input('Introduzca los grados Farenheit: ')) 15 | 16 | # FAHRENHEIT A CELCIUS 17 | # celcius = (fahrenheit - 32.0) * 5.0 / 9.0 18 | float_celcius = (int_farenheit-32.0)*5.0/9.0 19 | 20 | print("Grados Celsius: %0.2f"%(float_celcius)) 21 | 22 | -------------------------------------------------------------------------------- /05_05_Solucion_SumarTramas.py: -------------------------------------------------------------------------------- 1 | 2 | # 5) Sumar 4 Tramas de datos(Stings) que contengan el precio de un producto. 3 | 4 | # Consideraciones: 5 | 6 | # Trama = 6E + 3D 7 | # Representacion = 6E.3D 8 | # La suma no debe exceder el numero 999999999 9 | 10 | # VARIABLES 11 | 12 | # Se definen 4 variables del tipo String manualmente 13 | 14 | str_Precio1 = "11111111" 15 | str_Precio2 = "22222222" 16 | str_Precio3 = "33333333" 17 | str_Precio4 = "44444444" 18 | 19 | # Inicializacion de Variables 20 | 21 | int_Total = 0 22 | int_Parte_Entera = 0 23 | int_Parte_Decimal = 0 24 | 25 | # Se Transforma cada valor a un entero y se suma en una variable 26 | 27 | int_Total = int(str_Precio1) + int(str_Precio2) + int(str_Precio3) + int(str_Precio4) 28 | 29 | # Se Calcula la parte entera y la parte decimal: (6E+3D) 30 | 31 | print("****************************") 32 | 33 | int_Parte_Entera = int_Total / 1000 34 | print("Parte Entera (6E): %d " %(int_Parte_Entera )) 35 | 36 | int_Parte_Decimal = int_Total % 1000 37 | print("Parte Decimal (3D): %d " %(int_Parte_Decimal)) 38 | 39 | # Se muestra un mensaje con los valores en pantalla 40 | 41 | print("****************************") 42 | print("Precio(6E+3D): %d.%03d" %(int_Parte_Entera,int_Parte_Decimal)) 43 | print("****************************") 44 | 45 | -------------------------------------------------------------------------------- /06_Elementos_de_Listas.py: -------------------------------------------------------------------------------- 1 | 2 | # Arrays (Listas) 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] 18 | 19 | # Declaracion de Constantes 20 | 21 | INICIO = 0 22 | FIN = -1 23 | INDICE = 2 24 | SALTO = 1 25 | 26 | # Declaracion de variables 27 | 28 | # Index: 0 1 2 3 4 29 | list_Lista = ["Hola",'Soy','WCode',[1,2] ,3] 30 | 31 | 32 | ################################################################################### 33 | 34 | print ("\n********ELEMENTOS DE LA LISTA********\n") 35 | 36 | print (list_Lista[0]) # Hola 37 | print (list_Lista[1]) # Soy 38 | print (list_Lista[2]) # WCode 39 | print (list_Lista[3]) # [1,2] 40 | print (list_Lista[3][0]) # 1 41 | print (list_Lista[3][1]) # 2 42 | print (list_Lista[-1]) # 3 43 | print (list_Lista[-2]) # [1,2] 44 | 45 | ################################################################################### 46 | 47 | print("\n*********FORMATEAR ELEMENTOS**********\n") 48 | 49 | print("Las cadenas son: "+list_Lista[0]+" "+list_Lista[1]+" "+list_Lista[2]) 50 | 51 | print("Elementos Formateados: "+str(list_Lista[3])+" y "+str(list_Lista[4])) 52 | 53 | ################################################################################### 54 | 55 | print ("\n***********NUMEROS MAGICOS************\n") 56 | print("Posicion inicial: " + str(INICIO)+ "\n") 57 | print (list_Lista[INICIO]) # Hola 58 | 59 | print("\nPosicion final: " + str(FIN) + "\n") 60 | print (list_Lista[FIN]) # 3 61 | 62 | ################################################################################# 63 | 64 | print ("\n*******PARTICIONADO DE LISTAS*********\n") 65 | print("Imprimir listas:\n") 66 | print (list_Lista) 67 | 68 | # lista(inicio:fin) 69 | #Se omite el elemento "fin" 70 | print("\nParticionado: lista(inicio:fin)\n") 71 | print (list_Lista[0:4]) 72 | print (list_Lista[0:]) 73 | 74 | # lista(inicio:fin:salto) 75 | print("\nParticionado: lista(inicio:fin:salto)") 76 | print("Numero : lista(0:2:1)\n") 77 | print (list_Lista[0:2:1]) 78 | 79 | print("\nParticionado: lista(inicio:fin:salto)") 80 | print("Constantes : lista(INICIO:INDICE:SALTO)\n") 81 | print (list_Lista[INICIO:INDICE:SALTO]) 82 | 83 | ################################################################################ 84 | 85 | print ("\n*******PARTICIONADO POR DEFECTO*********\n") 86 | 87 | print("Imprime todos los elementos:") 88 | print (list_Lista[:]) 89 | 90 | print("\nImprime desde el indice 2 incluyendo e ultimo:") 91 | print (list_Lista[2:]) # print (list_Lista[INDICE:]) 92 | 93 | print("\nImprime un rango:") 94 | print (list_Lista[:4]) # print (list_Lista[:FIN]) 95 | 96 | print("\nMuestra los datos de 1 en 1:") 97 | print (list_Lista[::1]) # print (list_Lista[::SALTO]) 98 | 99 | print("\nMuestra los Datos de 2 en 2:") 100 | print (list_Lista[::2]) # print (list_Lista[::SALTO]) 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | -------------------------------------------------------------------------------- /07_Metodos_de_Listas.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ingwplanchez/wcode-python-3x/9bc1fea7e1711f517767886475676d01a5ed48e4/07_Metodos_de_Listas.py -------------------------------------------------------------------------------- /08_Manejo_de_Cadenas.py: -------------------------------------------------------------------------------- 1 | 2 | # Manejo de Cadenas 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | 19 | ################################################################################# 20 | 21 | # Manejo de Listas 22 | 23 | # lista[INDICE] ; Dato guardado en el INDICE 24 | # lista = [] ; Lista vacia 25 | 26 | # Particionado 27 | # 28 | # lista[INICIO:FIN] 29 | # lista[INICIO:FIN:SALTO] 30 | # lista[:] 31 | # Lista[INDICE:] 32 | # Lista[:FIN] 33 | # Lista[::SALTO] 34 | 35 | # Metododos de Listas 36 | # 37 | # lista.append(dato) ; Agrega nuevos elementos 38 | # lista.extend([dato1,dato2,...] ; Agregar uno a uno nuevos elementos 39 | # len(lista) ; Permite saber el tama?o de una lista 40 | # lista.remove(dato) ; Remueve un elemento que se le pase 41 | # como paramentro de la lista a donde 42 | # se este aplicando. 43 | # lista.pop(indice) ; Remueve un elemento por su indice 44 | # lista.index(elemento) ; Devuelve el n?mero de indice del 45 | # elemento pasado como parametro 46 | # list.count(elemento) ; Se usa para saber las veces que se 47 | # repite un elemento dentro de la lista. 48 | # lista.reverse() ; Permite invertir los elementos de 49 | # una lista. 50 | # 51 | ################################################################################# 52 | 53 | 54 | ## [subcode] 55 | 56 | # IDLEx 57 | # Descarga: http://idlex.sourceforge.net/download.html 58 | 59 | # Declaracion de constantes 60 | 61 | PORT_DB_SERVER = 3307 62 | USER_DB_SERVER = "root" 63 | PASS_DB_SERVER = "123456" 64 | DB_NAME = "nomina" 65 | 66 | # Declaracion de variables 67 | 68 | list_Trama = ['Producto', 'Descripcion', 'Cantidad', 'Precio'] 69 | list_Lista_Vacia = [] 70 | list_Lista_Vacia2 = [] 71 | str_Trama = "" 72 | str_Trama2 = "" 73 | 74 | ################################################################################# 75 | 76 | print("\n***********METODOS DE SEPARACION Y UNION***********\n") 77 | 78 | print("1) Metodo join()") 79 | str_Trama = " ".join(list_Trama) 80 | str_Trama2 = "|".join(list_Trama) 81 | 82 | print("\n- Lista original : " + str(list_Trama) ) 83 | print("\n- Cadena formateada con ' ': " + str_Trama ) 84 | print("\n- Cadena formateada con '|': " + str_Trama2 ) 85 | 86 | ################################################################################# 87 | 88 | ## [subcode] 89 | 90 | print("\n2) Metodo split()") 91 | 92 | print("\n- split() por defecto con ' ':\n") 93 | 94 | print("Cadena Original: "+str_Trama) 95 | list_Lista_Vacia = str_Trama.split() 96 | print("List Final : "+str(list_Lista_Vacia)) 97 | 98 | print("\n- split('X') con separador '|':\n") 99 | print("Cadena Original: "+str_Trama2) 100 | 101 | list_Lista_Vacia = str_Trama2.split('|') 102 | print("Lista Final : "+str(list_Lista_Vacia)) 103 | 104 | ################################################################################ 105 | 106 | ## [subcode] 107 | 108 | print ("\n*************EXTRACCION DE SUBSTRINGS*************\n") 109 | 110 | str_Trama = "" 111 | str_Trama = str(PORT_DB_SERVER)+USER_DB_SERVER+PASS_DB_SERVER+DB_NAME 112 | 113 | print("TRAMA : "+ str_Trama) 114 | print("\nPuerto : " + str_Trama[:4]) 115 | print("Usuario: " + str_Trama[4:8]) 116 | print("Clave : " + str_Trama[8:14]) 117 | print("Tabla : " + str_Trama[14:]) 118 | 119 | # 5C 5C 5E 3E + 2D 120 | # Trama = Producto|Descripcion|Cantidad|Precio 121 | # Trama = ProductoDescripcionCantidadPrecio 122 | -------------------------------------------------------------------------------- /09_Metodos_de_Cadenas.py: -------------------------------------------------------------------------------- 1 | 2 | # Metodos para el manejo de cadenas 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | 19 | 20 | ############################################################################# 21 | 22 | # Manejo de Listas 23 | 24 | # lista[INDICE] ; Dato guardado en el INDICE 25 | # lista = [] ; Lista vacia 26 | 27 | # Particionado 28 | # 29 | # lista[INICIO:FIN] 30 | # lista[INICIO:FIN:SALTO] 31 | # lista[:] 32 | # Lista[INDICE:] 33 | # Lista[:FIN] 34 | # Lista[::SALTO] 35 | 36 | # Metododos de Listas 37 | # 38 | # lista.append(dato) ; Agrega nuevos elementos 39 | # lista.extend([dato1,dato2,...] ; Agregar uno a uno nuevos elementos 40 | # len(lista) ; Permite saber el tama?o de una lista 41 | # lista.remove(dato) ; Remueve un elemento que se le pase 42 | # como par?mentro de la lista a donde 43 | # se est? aplicando. 44 | # lista.pop(indice) ; Remueve un elemento por su indice 45 | # lista.index(elemento) ; Devuelve el n?mero de indice del 46 | # elemento pasado como par?metro 47 | # list.count(elemento) ; Se usa para saber las veces que se 48 | # repite un elemento dentro de la lista. 49 | # lista.reverse() ; Permite invertir los elementos de 50 | # una lista. 51 | # 52 | ############################################################################# 53 | 54 | # Manejo de Cadenas 55 | 56 | # Datos dentro de una cadena 57 | # %d ; Numero entero dentro de la cadena 58 | # %f ; Numero Flotante Dentro de la cadena 59 | # %s ; String dentro de la cadena 60 | 61 | # Formateo de datos 62 | # str(lista) ; Lista Formateada como String 63 | # str(Numero) ; Dato Numerico formateado como string 64 | # int(Cadena) ; Cadena numerica formateada como Entero 65 | # float(Cadena) ; Cadena numerica Formateada como float 66 | 67 | # Metodos de listas 68 | # 69 | # "X".join(lista) ; Une los elementos de una lista donde 70 | # ; "X" es el simbolo usado para la union 71 | # ; de los elementos 72 | 73 | # Cadena.split('X') ; Separa los elementos de la cadena 74 | # ; Cada vez que el interprete consiga 75 | # ; El elemento separador X 76 | 77 | # Substrings 78 | # cadena[:FIN] 79 | # cadena[INICIO:FIN] 80 | # cadena[INDICE:] 81 | # 82 | ############################################################################# 83 | 84 | ## [subcode] 85 | 86 | print("\n******************METODOS DE ANALISIS********************\n") 87 | 88 | # cadena.count(): retorna el numero de veces que se repite un conjunto 89 | # de caracteres especificado. 90 | 91 | str_cadena = "" 92 | print("1) Metodo count():") 93 | 94 | str_cadena = "Hola WCODE" 95 | str_cadena.count("Hola") 96 | 97 | print("- La palabra 'Hola' aparece %d vez" %(str_cadena.count("Hola"))) 98 | 99 | ############################################################################# 100 | 101 | ## [subcode] 102 | 103 | # cadena.find() : Retornan la ubicacion en la que se encuentra el argumento 104 | # indicado. 105 | 106 | print("\n2) Metodo find():\n") 107 | print("- Indice Encontrado: %d " %(str_cadena.find("WCODE"))) 108 | print("- Indice fallido : %d " %(str_cadena.find("Mundo"))) 109 | 110 | ############################################################################# 111 | 112 | ## [subcode] 113 | 114 | # cadena.index() : Retorna la ubicacion en la que se encuentra el argumento 115 | # indicado 116 | 117 | print("\n3) Metodo index():\n") 118 | print("- Indice encontrado: %d " %(str_cadena.index("WCODE"))) 119 | ##print("- Indice fallido : %d " %(str_cadena.index("Mundo"))) 120 | 121 | ############################################################################# 122 | 123 | ## [subcode] 124 | 125 | # cadena.startswith("Subcadena"): Permite Saber si una cadena comienza con una 126 | # subcadena determinada. 127 | 128 | # cadena.endswith("Subcadena") : Permite Saber si una cadena finaliza con una 129 | # subcadena determinada. 130 | 131 | # STX: Inicio de la Trama (02) 132 | # ETX: Fin de la trama (03) 133 | 134 | # Trama = STX|DATOS|ETX 135 | 136 | str_Trama1 = '02|Producto|Descripcion|Cantidad|Precio|03' 137 | str_Trama2 = '00|Producto|Descripcion|Cantidad|Precio|00' 138 | 139 | print("\n4) Metodo startswith() :\n") 140 | print("- Inicio de Trama 1 (02): %s" %(str_Trama1.startswith("02") )) 141 | print("- Inicio de Trama 2 (02): %s \n" %(str_Trama2.startswith("02") )) 142 | 143 | print("5) Metodo endswith() :\n") 144 | print("- Fin de Trama 1 (03): %s" %(str_Trama1.endswith("03") )) 145 | print("- Fin de Trama 2 (03): %s" %(str_Trama2.endswith("03") )) 146 | 147 | ############################################################################# 148 | 149 | ## [subcode] 150 | 151 | print("\n******************METODOS DE VALIDACION********************\n") 152 | 153 | # Cadena.isdigit() : Permite saber si una cadena es num?rica 154 | # Cadena.isalnum() : Permite saber si una cadena es alfanum?ricas 155 | # Cadena.isalpha() : Permite saber si una cadena es alfab?tica 156 | # Cadena.isspace() : Permite saber si una cadena contiene solo espacios 157 | # en blanco 158 | 159 | str_Cadena = "123456" 160 | print ("6) Metodo isdigit():\n") 161 | print("- La cadena '%9s' es Numerica? | %s\n" %(str_Cadena,str_Cadena.isdigit())) 162 | 163 | str_Cadena = "WCODE123" 164 | print ("7) Metodo isalnum():\n") 165 | print("- La cadena '%9s' es Alfanumerica? | %s\n" %(str_Cadena,str_Cadena.isalnum())) 166 | 167 | str_Cadena = "HolaWCODE" 168 | print ("8) Metodo isalpha():\n") 169 | print("- La cadena '%9s' es Alfabetica? | %s\n" %(str_Cadena,str_Cadena.isalpha())) 170 | 171 | str_Cadena = " " 172 | print ("9) Metodo isspace():\n") 173 | print("- La cadena '%9s' contiene espacios? | %s" %(str_Cadena,str_Cadena.isspace())) 174 | 175 | ############################################################################# 176 | 177 | ## [subcode] 178 | 179 | print("\n*****************METODOS DE TRANSFORMACION*****************\n") 180 | 181 | # cadena.upper() : Permite Convertir una cadena a may?sculas 182 | # cadena.lower() : Permite Convertir una cadena a min?sculas 183 | # cadena.replace("Cadena","Nuevacadena") : Permite reemplazar una cadena 184 | # por otras 185 | 186 | str_Cadena = "De 0 a ProGramaDor" 187 | 188 | print ("10) Metodo upper():\n") 189 | print("- Cadena Original : %s" %(str_Cadena)) 190 | print("- Cadena en mayusculas : %s\n" %(str_Cadena.upper())) 191 | 192 | print ("11) Metodo lower():\n") 193 | print("- Cadena Original : %s" %(str_Cadena)) 194 | print("- Cadena en Minusculas : %s\n" %(str_Cadena.lower())) 195 | 196 | print ("12) Metodo replace(Cadena,Nuevacadena):\n") 197 | print("- Cadena Original : %s" %(str_Cadena)) 198 | print("- Cadena reemplazada : %s\n" %(str_Cadena.replace("ProGramaDor", "Profesional"))) 199 | 200 | ## [subcode] 201 | 202 | # cadena.center(Longitud,Caracter_relleno): Devuelve una cadena centrada 203 | # cadena.ljust(Longitud,Caracter_relleno): Devuelve una cadena alineada a la 204 | # Izquierda 205 | # cadena.rjust(Longitud,Caracter_relleno): Devuelve una cadena alineada a la 206 | # derecha 207 | 208 | str_Izquierda = "TEXTO ALINEADO A LA IZQUIERDA " 209 | str_Centro = " TEXTO ALINEADO AL CENTRO " 210 | str_Derecha = " TEXTO ALINEADO A LA DERECHA" 211 | 212 | str_Tabla = """\ 213 | +---------------------------------------------------------------------+ 214 | | WCODE: SI LO IMAGINAS LO CREAS | 215 | |---------------------------------------------------------------------| 216 | | CURSO DE 0 A PROGRAMADOR! | 217 | +---------------------------------------------------------------------+ 218 | """\ 219 | 220 | print("\n" + str_Izquierda.ljust(71, "*")) 221 | print("\n" + str_Centro.center(71, "*")) 222 | print("\n" + str_Derecha.rjust(71, "*")) 223 | 224 | print("\n" + str_Tabla + "\n") 225 | 226 | ## [subcode] 227 | -------------------------------------------------------------------------------- /10_Tuplas_ Diccionarios.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ingwplanchez/wcode-python-3x/9bc1fea7e1711f517767886475676d01a5ed48e4/10_Tuplas_ Diccionarios.py -------------------------------------------------------------------------------- /11_Nuevo_Fomato.py: -------------------------------------------------------------------------------- 1 | 2 | # Nuevo Formato 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ############################################################################# 22 | 23 | # Descarga de Pyscripter: 24 | # https://sourceforge.net/projects/pyscripter/files/ 25 | 26 | str_Lenguaje1 = "Pseudocodigo" 27 | str_Lenguaje2 = "Python" 28 | 29 | # cadena.format(): Permite Formatear la cadenas 30 | 31 | str_Centro = " METODO FORMAT() " 32 | 33 | print("\n" + str_Centro.center(80, "-") + "\n") 34 | 35 | print("1) El lenguaje es {0}.\n".format(str_Lenguaje1)) 36 | 37 | print("2) Los lenguajes son: {0} y {1}.\n".format(str_Lenguaje1,str_Lenguaje2 )) 38 | 39 | print("3) Los lenguajes son: {} y {}.\n".format(str_Lenguaje1,str_Lenguaje2 )) 40 | 41 | print("4) Los lenguajes son: {a} y {b}.\n" 42 | .format(a = str_Lenguaje1 ,b = str_Lenguaje2)) 43 | 44 | print("5) Intercalado: {0} , {1} , {0} , {1}.\n" 45 | .format(str_Lenguaje1,str_Lenguaje2 )) 46 | 47 | ############################################################################# 48 | -------------------------------------------------------------------------------- /12_Alineacion_de_Caracteres.py: -------------------------------------------------------------------------------- 1 | 2 | # Alineacion de Caracteres 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ############################################################################# 22 | 23 | # Declaracion de Constantes 24 | 25 | PRODUCTO = 0 26 | DESCRIPCION= 1 27 | CANTIDAD = 2 28 | PRECIO = 3 29 | 30 | # Declaracion de variables y colecciones 31 | 32 | list_Trama = ['Producto', 'Descripcion', 'Cantidad'] 33 | list_Pedido = ['SmartPhone', 'Iphone 12 Pro Max', '2'] 34 | 35 | list_Trama2 = ['Producto', 'Descripcion', 'Cantidad','Precio'] 36 | list_Pedido2 = ['SmartPhone', 'Iphone 12 Pro Max', '2','2000'] 37 | 38 | str_Centro = " ALINEACION DE CARACTERES " 39 | 40 | ################################################################################ 41 | 42 | # Inicio de programa 43 | 44 | print("\n" + str_Centro.center(70, "-") + "\n") 45 | 46 | print(" Alineado por defecto ".center(70, "*")) 47 | 48 | print("{0} | {1} | {2}|" 49 | .format(list_Trama[PRODUCTO],list_Trama[DESCRIPCION],list_Trama[CANTIDAD])) 50 | 51 | print("".center(70, "*")) 52 | 53 | ################################################################################ 54 | 55 | # Alineado a la izquierda 56 | 57 | # '<' : Alinea a la izquierda, generalmente se omite ya que es la opción 58 | # por defecto en la mayoría de los objetos. 59 | 60 | # {:' : Alinea a la derecha. 79 | # {:>X} : Muestra el contenido alineado a la derecha y ocupa X caracteres 80 | 81 | print("\n") 82 | print(" Alineado a la Derecha ".center(70, "*")) 83 | print("| {:>20} | {:>20} | {:>20} |" 84 | .format(list_Trama[PRODUCTO],list_Trama[DESCRIPCION],list_Trama[CANTIDAD])) 85 | 86 | print("".center(70, "*")) 87 | 88 | print("| {:>20} | {:>20} | {:>20} |".format(list_Pedido[PRODUCTO] , 89 | list_Pedido[DESCRIPCION], 90 | list_Pedido[CANTIDAD])) 91 | 92 | ################################################################################ 93 | 94 | # Centrado del texto 95 | 96 | # '^' : Centrado del texto 97 | # {:^X} : Muestra el contenido centrado y ocupa X caracteres 98 | 99 | print("\n") 100 | print(" Centrado del texto ".center(70, "*")) 101 | print("| {:^20} | {:^20} | {:^20} |" 102 | .format(list_Trama[PRODUCTO],list_Trama[DESCRIPCION],list_Trama[CANTIDAD])) 103 | print("".center(70, "*")) 104 | print("| {:^20} | {:^20} | {:^20} |".format(list_Pedido[PRODUCTO] , 105 | list_Pedido[DESCRIPCION], 106 | list_Pedido[CANTIDAD])) 107 | 108 | ################################################################################ 109 | 110 | # Ejemplo 111 | 112 | ##print("\n") 113 | ##print(" EJEMPLO ".center(80, "-")) 114 | 115 | print("\n") 116 | print("".center(80, "*")) 117 | print("| {:^20} | {:^20} | {:^10} | {:^18}|\n".format(list_Trama2[PRODUCTO], 118 | list_Trama2[DESCRIPCION], 119 | list_Trama2[CANTIDAD], 120 | list_Trama2[PRECIO])) 121 | 122 | print("".center(80, "*")) 123 | print("| {:^20} | {:^20} | {:^10} | {:^18}|\n".format(list_Pedido2[PRODUCTO], 124 | list_Pedido2[DESCRIPCION], 125 | list_Pedido2[CANTIDAD], 126 | list_Pedido2[PRECIO])) 127 | 128 | ################################################################################ 129 | 130 | -------------------------------------------------------------------------------- /13_00_Ejercicios_Colecciones_Cadenas.py: -------------------------------------------------------------------------------- 1 | 2 | # Ejercicios de Colecciones y cadenas 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ################################################################################ 22 | 23 | # Manejo de Listas 24 | 25 | # lista[INDICE] ; Dato guardado en el INDICE 26 | # lista = [] ; Lista vacia 27 | 28 | # Particionado 29 | # 30 | # lista[INICIO:FIN] 31 | # lista[INICIO:FIN:SALTO] 32 | # lista[:] 33 | # Lista[INDICE:] 34 | # Lista[:FIN] 35 | # Lista[::SALTO] 36 | 37 | # Metododos de Listas 38 | # 39 | # lista.append(dato) ; Agrega nuevos elementos 40 | # lista.extend([dato1,dato2,...] ; Agregar uno a uno nuevos elementos 41 | # len(lista) ; Permite saber el tama?o de una lista 42 | # lista.remove(dato) ; Remueve un elemento que se le pase 43 | # como par?mentro de la lista a donde 44 | # se est? aplicando. 45 | # lista.pop(indice) ; Remueve un elemento por su indice 46 | # lista.index(elemento) ; Devuelve el n?mero de indice del 47 | # elemento pasado como par?metro 48 | # list.count(elemento) ; Se usa para saber las veces que se 49 | # repite un elemento dentro de la lista. 50 | # lista.reverse() ; Permite invertir los elementos de 51 | # una lista. 52 | # 53 | ################################################################################ 54 | 55 | # Manejo de Cadenas 56 | 57 | # Datos dentro de una cadena 58 | # %d ; Numero entero dentro de la cadena 59 | # %f ; Numero Flotante Dentro de la cadena 60 | # %s ; String dentro de la cadena 61 | 62 | # Formateo de datos 63 | # str(lista) ; Lista Formateada como String 64 | # str(Numero) ; Dato Numerico formateado como string 65 | # int(Cadena) ; Cadena numerica formateada como Entero 66 | # float(Cadena) ; Cadena numerica Formateada como float 67 | 68 | # Metodos de listas 69 | # 70 | # "X".join(lista) ; Une los elementos de una lista donde 71 | # ; "X" es el simbolo usado para la union 72 | # ; de los elementos 73 | 74 | # Cadena.split('X') ; Separa los elementos de la cadena 75 | # ; Cada vez que el interprete consiga 76 | # ; El elemento separador X 77 | 78 | # Substrings 79 | # cadena[:FIN] 80 | # cadena[INICIO:FIN] 81 | # cadena[INDICE:] 82 | # 83 | 84 | ################################################################################ 85 | 86 | # Metodos de cadenas 87 | 88 | # cadena.count(): retorna el numero de veces que se repite un conjunto 89 | # de caracteres especificado. 90 | 91 | # cadena.find() : Retornan la ubicacion en la que se encuentra el argumento 92 | # indicado. 93 | 94 | # cadena.index() : Retorna la ubicacion en la que se encuentra el argumento 95 | # indicado. 96 | 97 | # cadena.startswith("Subcadena"): Permite Saber si una cadena comienza con una 98 | # subcadena determinada. 99 | 100 | # cadena.endswith("Subcadena") : Permite Saber si una cadena finaliza con una 101 | # subcadena determinada. 102 | 103 | # Cadena.isdigit() : Permite saber si una cadena es numerica 104 | # Cadena.isalnum() : Permite saber si una cadena es alfanumericas 105 | # Cadena.isalpha() : Permite saber si una cadena es alfabetica 106 | # Cadena.isspace() : Permite saber si una cadena contiene solo espacios 107 | # en blanco 108 | 109 | # cadena.upper() : Permite Convertir una cadena a mayusculas 110 | # cadena.lower() : Permite Convertir una cadena a minusculas 111 | 112 | # cadena.replace("Cadena","Nuevacadena") : Permite reemplazar una cadena 113 | # por otras 114 | 115 | # cadena.center(Longitud,Caracter_relleno): Devuelve una cadena centrada 116 | 117 | # cadena.ljust(Longitud,Caracter_relleno): Devuelve una cadena alineada a la 118 | # Izquierda. 119 | 120 | # cadena.rjust(Longitud,Caracter_relleno): Devuelve una cadena alineada a la 121 | # derecha. 122 | # 123 | ################################################################################ 124 | 125 | PRODUCTO = 0 126 | DESCRIPCION = 1 127 | CANTIDAD = 2 128 | PRECIO = 3 129 | 130 | # Declaracion de variables y colecciones 131 | 132 | list_Trama = ['Producto', 'Descripcion', 'Cantidad','Precio'] 133 | 134 | # FORMA 1 135 | 136 | list_Producto1 = ['2000','1', 'Iphone 12 Pro Max','Smartphone'] 137 | list_Producto2 = ['1500','1', 'Iphone 11 Pro Max','Smartphone'] 138 | list_Producto3 = ['1200','1', 'Iphone 10 Pro Max','Smartphone'] 139 | list_Producto4 = ['1000','1', 'Iphone 09 Pro Max','Smartphone'] 140 | 141 | # FORMA 2 142 | 143 | ## tuple_Trama = ('Producto', 'Descripcion', 'Cantidad','Precio') 144 | 145 | ## str_Producto = 'Smartphone|Iphone 12 Pro Max|1|2000' 146 | ## str_Producto = 'Smartphone|Iphone 11 Pro Max|1|1500' 147 | ## str_Producto = 'Smartphone|Iphone 10 Pro Max|1|1200' 148 | ## str_Producto = 'Smartphone|Iphone 09 Pro Max|1|1000' 149 | 150 | # Resultado final 151 | 152 | ## ***************************************************************************** 153 | ## | Producto | Descripcion | Cantidad | Precio | 154 | ## ***************************************************************************** 155 | ## | SmartPhone | Iphone 12 Pro Max | 1 | 2000 | 156 | ## | SmartPhone | Iphone 11 Pro Max | 1 | 1500 | 157 | ## | SmartPhone | Iphone 10 Pro Max | 1 | 1200 | 158 | ## | SmartPhone | Iphone 09 Pro Max | 1 | 1000 | 159 | ## ***************************************************************************** 160 | ## | TOTAL | 5700 | 161 | ## ***************************************************************************** 162 | 163 | -------------------------------------------------------------------------------- /13_01_Solucion_Colecciones_Forma1.py: -------------------------------------------------------------------------------- 1 | 2 | # FORMA 1 3 | 4 | # Resultado final 5 | 6 | ## ***************************************************************************** 7 | ## | Producto | Descripcion | Cantidad | Precio | 8 | ## ***************************************************************************** 9 | ## | SmartPhone | Iphone 12 Pro Max | 1 | 2000 | 10 | ## | SmartPhone | Iphone 11 Pro Max | 1 | 1500 | 11 | ## | SmartPhone | Iphone 10 Pro Max | 1 | 1200 | 12 | ## | SmartPhone | Iphone 09 Pro Max | 1 | 1000 | 13 | ## ***************************************************************************** 14 | ## | TOTAL | 5700 | 15 | ## ***************************************************************************** 16 | 17 | # Indices de la trama 18 | 19 | PRODUCTO = 0 20 | DESCRIPCION = 1 21 | CANTIDAD = 2 22 | PRECIO = 3 23 | 24 | # Valores para dibujar la tabla 25 | 26 | ANCHO = 75 27 | RELLENO = "*" 28 | COMILLAS = "" 29 | MENSAJE = "TOTAL" 30 | 31 | # Definicion de Tramas 32 | 33 | list_Trama = ["Producto", "Descripcion", "Cantidad", "Precio"] 34 | 35 | list_Producto1 = ["2000", "1", "Iphone 12 pro Max", "Smartphone"] 36 | list_Producto2 = ["1500", "1", "Iphone 12 pro Max", "Smartphone"] 37 | list_Producto3 = ["1200", "1", "Iphone 12 pro Max", "Smartphone"] 38 | list_Producto4 = ["1000", "1", "Iphone 12 pro Max", "Smartphone"] 39 | 40 | # Formato para mostrar variables: str_Formato.format() 41 | 42 | str_Formato = "|{:^20}|{:^20}|{:^15}|{:^15}|" 43 | str_Total = "|{:^20} {:^20} {:^15}|{:^15}|" 44 | 45 | # Variable para almacenar la sumatoria de precios Total 46 | 47 | int_Total = 0 48 | 49 | ################################################################################ 50 | 51 | # Inicio del Programa 52 | 53 | # Se aplica el Metodo .reverse() para ordenar las listas 54 | 55 | list_Producto1.reverse() 56 | list_Producto2.reverse() 57 | list_Producto3.reverse() 58 | list_Producto4.reverse() 59 | 60 | print (COMILLAS.center(ANCHO,RELLENO)) 61 | 62 | print(str_Formato.format(list_Trama[PRODUCTO], 63 | list_Trama[DESCRIPCION], 64 | list_Trama[CANTIDAD], 65 | list_Trama[PRECIO])) 66 | 67 | print (COMILLAS.center(ANCHO,RELLENO)) 68 | 69 | print(str_Formato.format(list_Producto1[PRODUCTO], 70 | list_Producto1[DESCRIPCION], 71 | list_Producto1[CANTIDAD], 72 | list_Producto1[PRECIO])) 73 | 74 | print(str_Formato.format(list_Producto2[PRODUCTO], 75 | list_Producto2[DESCRIPCION], 76 | list_Producto2[CANTIDAD], 77 | list_Producto2[PRECIO])) 78 | 79 | print(str_Formato.format(list_Producto3[PRODUCTO], 80 | list_Producto3[DESCRIPCION], 81 | list_Producto3[CANTIDAD], 82 | list_Producto3[PRECIO])) 83 | 84 | print(str_Formato.format(list_Producto4[PRODUCTO], 85 | list_Producto4[DESCRIPCION], 86 | list_Producto4[CANTIDAD], 87 | list_Producto4[PRECIO])) 88 | 89 | print (COMILLAS.center(ANCHO,RELLENO)) 90 | 91 | int_Total= int (list_Producto1[PRECIO])+int (list_Producto2[PRECIO])+int (list_Producto3[PRECIO])+int (list_Producto4[PRECIO]) 92 | 93 | print(str_Total.format(COMILLAS,COMILLAS,MENSAJE,int_Total)) 94 | 95 | print (COMILLAS.center(ANCHO,RELLENO)) 96 | 97 | -------------------------------------------------------------------------------- /13_02_Solucion_Colecciones_Forma2.py: -------------------------------------------------------------------------------- 1 | 2 | # FORMA 2 3 | 4 | # Resultado final 5 | 6 | ## ***************************************************************************** 7 | ## | Producto | Descripcion | Cantidad | Precio | 8 | ## ***************************************************************************** 9 | ## | SmartPhone | Iphone 12 Pro Max | 1 | 2000 | 10 | ## | SmartPhone | Iphone 11 Pro Max | 1 | 1500 | 11 | ## | SmartPhone | Iphone 10 Pro Max | 1 | 1200 | 12 | ## | SmartPhone | Iphone 09 Pro Max | 1 | 1000 | 13 | ## ***************************************************************************** 14 | ## | TOTAL | 5700 | 15 | ## ***************************************************************************** 16 | 17 | # Indices de la trama 18 | 19 | PRODUCTO = 0 20 | DESCRIPCION = 1 21 | CANTIDAD = 2 22 | PRECIO = 3 23 | 24 | # Valores para dibujar la tabla 25 | 26 | ANCHO = 75 27 | RELLENO = "*" 28 | COMILLAS = "" 29 | MENSAJE = "TOTAL" 30 | SEPARADOR = "|" 31 | 32 | # Definicion de Tramas 33 | 34 | tuple_Trama = ('Producto', 'Descripcion', 'Cantidad','Precio') 35 | 36 | str_Producto1 = 'Smartphone|Iphone 12 Pro Max|1|2000' 37 | str_Producto2 = 'Smartphone|Iphone 11 Pro Max|1|1500' 38 | str_Producto3 = 'Smartphone|Iphone 10 Pro Max|1|1200' 39 | str_Producto4 = 'Smartphone|Iphone 09 Pro Max|1|1000' 40 | 41 | # Formato para mostrar variables: str_Formato.format() 42 | 43 | str_Formato = "|{:^20}|{:^20}|{:^15}|{:^15}|" 44 | str_Total = "|{:^20} {:^20} {:^15}|{:^15}|" 45 | 46 | # Declaracion de Listas Vacias para guardar los elementos de str_Producto 47 | 48 | list_Producto1 = [] 49 | list_Producto2 = [] 50 | list_Producto3 = [] 51 | list_Producto4 = [] 52 | 53 | # Variable para almacenar la sumatoria de precios Total 54 | 55 | int_Total = 0 56 | 57 | ################################################################################ 58 | 59 | # Inicio del Programa 60 | 61 | # Se aplica el metodo .split() y se guardan los elementos en una lista 62 | 63 | list_Producto1 = str_Producto1.split(SEPARADOR) 64 | list_Producto2 = str_Producto2.split(SEPARADOR) 65 | list_Producto3 = str_Producto3.split(SEPARADOR) 66 | list_Producto4 = str_Producto4.split(SEPARADOR) 67 | 68 | print (COMILLAS.center(ANCHO,RELLENO)) 69 | 70 | print(str_Formato.format(tuple_Trama[PRODUCTO], 71 | tuple_Trama[DESCRIPCION], 72 | tuple_Trama[CANTIDAD], 73 | tuple_Trama[PRECIO])) 74 | 75 | print (COMILLAS.center(ANCHO,RELLENO)) 76 | 77 | print(str_Formato.format(list_Producto1[PRODUCTO], 78 | list_Producto1[DESCRIPCION], 79 | list_Producto1[CANTIDAD], 80 | list_Producto1[PRECIO])) 81 | 82 | print(str_Formato.format(list_Producto2[PRODUCTO], 83 | list_Producto2[DESCRIPCION], 84 | list_Producto2[CANTIDAD], 85 | list_Producto2[PRECIO])) 86 | 87 | print(str_Formato.format(list_Producto3[PRODUCTO], 88 | list_Producto3[DESCRIPCION], 89 | list_Producto3[CANTIDAD], 90 | list_Producto3[PRECIO])) 91 | 92 | print(str_Formato.format(list_Producto4[PRODUCTO], 93 | list_Producto4[DESCRIPCION], 94 | list_Producto4[CANTIDAD], 95 | list_Producto4[PRECIO])) 96 | 97 | print (COMILLAS.center(ANCHO,RELLENO)) 98 | 99 | int_Total= int (list_Producto1[PRECIO])+int (list_Producto2[PRECIO])+int (list_Producto3[PRECIO])+int (list_Producto4[PRECIO]) 100 | 101 | print(str_Total.format(COMILLAS,COMILLAS,MENSAJE,int_Total)) 102 | 103 | print (COMILLAS.center(ANCHO,RELLENO)) 104 | 105 | 106 | 107 | 108 | 109 | 110 | -------------------------------------------------------------------------------- /14_Estructuras_Condicionales.py: -------------------------------------------------------------------------------- 1 | 2 | #Estructuras Alternativas. 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ############################################################################# 22 | 23 | # OPERADORES ARITMÉTICOS 24 | 25 | # --------------------------------------------------------------------------- 26 | # Símbolo Significado Ejemplo Resultado 27 | 28 | # + Suma a = 10 + 5 a es 15 29 | # - Resta a = 12 - 7 a es 5 30 | # * Multiplicación a = 7 * 5 a es 35 31 | # ** Exponente a = 2 ** 3 a es 8 32 | # / División a = 12.5 / 2 a es 6.25 33 | # // División entera a = 12.5 // 2 a es 6.0 34 | # % Módulo a = 7 % 2 a es 1 35 | 36 | ############################################################################# 37 | 38 | # OPERADORES CONDICIONALES O DE COMPARACION 39 | 40 | # --------------------------------------------------------------------------- 41 | # Símbolo Significado Ejemplo Resultado 42 | 43 | # == Igual que 5 == 7 Falso 44 | # != Distinto que rojo != verde Verdadero 45 | # < Menor que 8 < 12 Verdadero 46 | # > Mayor que 12 > 7 Falso 47 | # <= Menor o igual que 12 <= 12 Verdadero 48 | # >= Mayor o igual que 4 >= 5 Falso 49 | 50 | ############################################################################# 51 | 52 | # OPERADORES LOGICOS 53 | 54 | # --------------------------------------------------------------------------- 55 | 56 | # Operador Ejemplo Resultado 57 | # 58 | # and (y) 5 == 7 and 7 < 12 0 y 0 Falso 59 | # 9 < 12 and 12 > 7 1 y 1 Verdadero 60 | # 9 < 12 and 12 > 15 1 y 0 Falso 61 | # or (o) 12 == 12 or 15 < 7 1 o 0 Verdadero 62 | 63 | ############################################################################# 64 | 65 | # Pseudocodigo: 66 | 67 | # 1) Instruccion IF: 68 | 69 | # IF condicion 70 | # instrucciones 71 | # FIN del IF 72 | 73 | # Ejemplo: 74 | 75 | str_Cadena = 'WCODE' 76 | 77 | print ("\n1) if str_Cadena == 'WCODE': ") 78 | 79 | if str_Cadena == 'WCODE': 80 | print ("La condicion es VERDADERA!\n"), 81 | 82 | print("\n2) if str_Cadena == 'wcode': ") 83 | 84 | if str_Cadena == 'wcode': 85 | print("La condicon es FALSA!\n") 86 | 87 | print("No se ejecuto la condicion\n") 88 | 89 | print("3) if str_Cadena != 'wcode':") 90 | 91 | if str_Cadena != 'wcode': 92 | print ("La condicion es VERDADERA!") 93 | 94 | ############################################################################# 95 | 96 | # Pseudocodigo: 97 | 98 | # 2) Instruccion IF - ELSE (Una Condicion) 99 | 100 | # IF condicion 101 | # instrucciones1 102 | # ELSE 103 | # instrucciones2 104 | # FIN del IF 105 | 106 | # Ejemplo: 107 | 108 | print("\n4) if str_Cadena == 'wcode' | else: "), 109 | 110 | if str_Cadena == 'wcode': 111 | print ("La condicion es VERDADERA!\n"), 112 | 113 | else: 114 | print("La condicon es FALSA!") 115 | 116 | ############################################################################# 117 | 118 | # Pseudocodigo: 119 | 120 | # 3) Instruccion IF - ELSE (Multiples condiciones) 121 | 122 | # IF condicion1 Operador-Logico1 condicion2 123 | # instrucciones1 124 | # ELSE 125 | # instrucciones2 126 | # FIN del IF 127 | 128 | # Ejemplo: 129 | 130 | print("\n5) if str_Cadena == 'wcode' or str_Cadena == 'WCODE': "), 131 | 132 | if str_Cadena == 'wcode' and str_Cadena == 'WCODE': 133 | print ("La condicion es VERDADERA!\n"), 134 | 135 | else: 136 | print("La condicon es FALSA!") 137 | 138 | ############################################################################# 139 | 140 | # Pseudocodigo: 141 | 142 | # ) Instruccion ELSE_IF 143 | 144 | # IF condicion1 145 | # instrucciones1 146 | # ELSE_IF condicion2 147 | # instrucciones2 148 | # ELSE 149 | # instrucciones3 150 | # FIN del IF 151 | 152 | # Ejemplo: 153 | 154 | print("\n6) if str_Cadena == 'wcode' | elif str_Cadena == 'WCODE': "), 155 | 156 | if str_Cadena == 'WCODE': 157 | print ("La condicion1 es VERDADERA!\n"), 158 | 159 | if str_Cadena == 'WCODE': 160 | print ("Elif condicion2 VERDADERA!\n"), 161 | 162 | else: 163 | print("La condicon es FALSA!\n") 164 | 165 | ############################################################################# 166 | 167 | 168 | 169 | 170 | -------------------------------------------------------------------------------- /15_00_Ejercicios _Estructuras_Condicionales.py: -------------------------------------------------------------------------------- 1 | 2 | # Ejercicios con estructuras condicionales 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ################################################################################ 22 | 23 | ## ENUNCIADO 1: 24 | 25 | ## 26 | ## Introducir un numero por teclado y que se muestre un mensaje indicando 27 | ## si es par o impar. 28 | 29 | ################################################################################ 30 | 31 | ## Estudio p.revio: 32 | ## 33 | ## Para saber si un numero es par o impar haremos lo siguiente: 34 | ## 35 | ## FORMA 1: 36 | ## 37 | ## Numero = int(Numero/2)*2 38 | ## 39 | ## - Si resulta el mismo numero el numero es par. 40 | ## - Si no es el mismo numero no es par. 41 | ## 42 | ## FORMA 2: 43 | ## 44 | ## Numero = Numero % 2 45 | ## 46 | ## - Si el modulo de la division es 0 el numero es par 47 | ## - Si el modulo de la division es diferente de 0 es impar 48 | 49 | ################################################################################ 50 | 51 | ## Variable 52 | ## numero = almacena un numero introducido por teclado 53 | 54 | # Pseudocodigo: 55 | 56 | ## numero = 0 57 | 58 | ## imprime "Introduce un numero:" 59 | ## introduce numero 60 | ## 61 | ## if numero = int(numero/2)*2 62 | ## imprime "El numero es par" 63 | ## else 64 | ## imprime "El numero es impar" 65 | ## fin del if 66 | ## fin del programa 67 | 68 | ################################################################################ 69 | 70 | # Declaracion de variables: 71 | 72 | int_Numero = 0 73 | 74 | ################################################################################ 75 | 76 | # Inicio del programa: 77 | 78 | int_Numero = int(input('Introduce un numero: ')) 79 | 80 | if int_Numero == (int_Numero / 2) * 2: 81 | print("El numero %d es par." %(int_Numero)) 82 | else: 83 | print("El numero %d es impar." %(int_Numero)) 84 | 85 | ################################################################################ 86 | 87 | ## ENUNCIADO 2: 88 | 89 | ## Introducir un numero por teclado y que se muestre un mensaje indicando 90 | ## si es multiplo de 3. 91 | 92 | ################################################################################ 93 | 94 | ## Estudio previo: 95 | 96 | ## Vamos a proceder de forma analoga al ejercicio anterior esta vez dividiendo 97 | ## entre 3. 98 | 99 | ## FORMA 1: 100 | ## 101 | ## Numero = int(Numero/3)*3 102 | ## 103 | ## - Si resulta el mismo numero el numero es multiplo de 3. 104 | ## - Si no es el mismo numero no es multiplo. 105 | ## 106 | ## FORMA 2: 107 | ## 108 | ## Numero = Numero % 3 109 | ## 110 | ## - Si el modulo de la division es 0 el numero es multiplo 111 | ## - Si el modulo de la division es diferente de 0 es multiplo 112 | 113 | ################################################################################ 114 | 115 | ## Variable 116 | 117 | ## numero = almacena un numero introducido por teclado 118 | 119 | # Pseudocodigo: 120 | 121 | ## numero = 0 122 | 123 | ## imprime "Introduce un numero:" 124 | ## introduce numero 125 | ## 126 | ## if numero = int(numero/3)*3 127 | ## imprime "El numero es multiplo de 3" 128 | ## else 129 | ## imprime "El numero no esmultiplo de 3" 130 | ## fin del if 131 | ## fin del programa 132 | 133 | ################################################################################ 134 | 135 | # Declaracion de variables: 136 | 137 | ################################################################################ 138 | 139 | # Inicio del programa: 140 | 141 | 142 | 143 | -------------------------------------------------------------------------------- /15_01_Solucion_Estructuras_Condicionales.py: -------------------------------------------------------------------------------- 1 | 2 | ################################################################################ 3 | 4 | ## ENUNCIADO 2: 5 | 6 | ## Introducir un numero por teclado y que se muestre un mensaje indicando 7 | ## si es multiplo de 3. 8 | 9 | ################################################################################ 10 | 11 | ## Estudio previo: 12 | 13 | ## Vamos a proceder de forma analoga al ejercicio anterior esta vez dividiendo 14 | ## entre 3. 15 | 16 | ## FORMA 1: 17 | ## 18 | ## Numero = int(Numero/3)*3 19 | ## 20 | ## - Si resulta el mismo numero el numero es multiplo de 3. 21 | ## - Si no es el mismo numero no es multiplo. 22 | ## 23 | ## FORMA 2: 24 | ## 25 | ## Numero = Numero % 3 26 | ## 27 | ## - Si el modulo de la division es 0 el numero es multiplo 28 | ## - Si el modulo de la division es diferente de 0 es multiplo 29 | 30 | ################################################################################ 31 | 32 | ## Variable 33 | 34 | ## numero = almacena un numero introducido por teclado 35 | 36 | # Pseudocodigo: 37 | 38 | ## numero = 0 39 | 40 | ## imprime "Introduce un numero:" 41 | ## introduce numero 42 | ## 43 | ## if numero = int(numero/3)*3 44 | ## imprime "El numero es multiplo de 3" 45 | ## else 46 | ## imprime "El numero no esmultiplo de 3" 47 | ## fin del if 48 | ## fin del programa 49 | 50 | ################################################################################ 51 | 52 | # Declaracion de variables: 53 | 54 | int_Numero = 0 55 | 56 | ################################################################################ 57 | 58 | # Inicio del programa: 59 | 60 | # SOLICITUD Datos en PYTHON 2.7 61 | # int_Numero = int (raw_input('Introduce un numero: ')) 62 | 63 | # SOLICITUD de Datos en PYTHON 3.x 64 | int_Numero = int(input('Introduce un numero: ')) 65 | 66 | if int_Numero == (int_Numero / 3) * 3: 67 | print("El numero %d es par." %(int_Numero)) 68 | else: 69 | print("El numero %d es impar." %(int_Numero)) 70 | 71 | -------------------------------------------------------------------------------- /16_Estructuras_Repetitivas.py: -------------------------------------------------------------------------------- 1 | 2 | # Estructuras Repetitivas. 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ################################################################################ 22 | 23 | # Pseudocodigo: 24 | 25 | # Instruccion WHILE: 26 | 27 | # HACER MIENTRAS condicion 28 | # instrucciones 29 | # FIN del HACER 30 | 31 | # Ejemplo: 32 | 33 | # Declaracion de variables 34 | 35 | int_Tabla = 11 36 | int_Numero = 1 37 | int_Resultado = 0 38 | 39 | str_Cadena = " TABLA DE MULTIPLICAR " 40 | 41 | print("\n" + str_Cadena.center(35, "*") + "\n") 42 | 43 | while int_Numero < 101: 44 | 45 | int_Resultado = int_Tabla * int_Numero 46 | 47 | print ("{} x {} = {}").format(int_Tabla,int_Numero,int_Resultado ) 48 | 49 | # Contadores 50 | # Variable = Variable +/- CONSTANTE 51 | 52 | # Acumuladores o Sumadores 53 | # Acumulador = Acumulador +/- Variable) 54 | 55 | int_Numero = int_Numero + 1 56 | 57 | ############################################################################# 58 | 59 | -------------------------------------------------------------------------------- /17_Bucle_Infinito.py: -------------------------------------------------------------------------------- 1 | 2 | # Bucle infinito 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | 22 | # Usos especiales de las variables 23 | 24 | # Contadores 25 | # Variable = Variable +/- CONSTANTE 26 | 27 | # Acumuladores o Sumadores 28 | # Acumulador = Acumulador +/- Variable) 29 | 30 | ############################################################################# 31 | 32 | # Pseudocodigo: 33 | 34 | # Instruccion WHILE: 35 | 36 | # HACER MIENTRAS condicion 37 | # instrucciones 38 | # FIN del HACER 39 | 40 | # Ejemplo: 41 | 42 | # Declaracion de variables 43 | 44 | int_Intentos = 0 45 | str_Clave = "ABC123" 46 | str_Cadena = " BUCLE INFINITO " 47 | 48 | print("\n" + str_Cadena.center(35, "*") + "\n") 49 | 50 | while True: 51 | 52 | str_Password = input("Indique la clave: ") 53 | 54 | # Contador 55 | int_Intentos = int_Intentos + 1 56 | 57 | if str_Password == str_Clave : 58 | print("Clave Correcta!\n") 59 | int_Intentos = 0 60 | 61 | elif int_Intentos == 3: 62 | print("Usuario Bloqueado\n") 63 | break 64 | 65 | else: 66 | print("Clave incorrecta intento: {} \n".format(int_Intentos)) 67 | 68 | print("".center(35, "*")) 69 | 70 | 71 | -------------------------------------------------------------------------------- /18_Bucle_for_in.py: -------------------------------------------------------------------------------- 1 | 2 | # Bucle infinito 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | 22 | # Usos especiales de las variables 23 | 24 | # Contadores 25 | # Variable = Variable +/- CONSTANTE 26 | 27 | # Acumuladores o Sumadores 28 | # Acumulador = Acumulador +/- Variable) 29 | 30 | ############################################################################# 31 | 32 | # Pseudocodigo: 33 | 34 | # Instruccion FOR IN: 35 | 36 | # PARA CADA ELEMENTO HACER 37 | # instrucciones 38 | # FIN del HACER 39 | 40 | # Ejemplo: 41 | 42 | Mi_lista = ['Juan', 'Antonio', 'Pedro', 'Herminio'] 43 | 44 | str_Cadena = " BUCLE FOR IN " 45 | print("\n" + str_Cadena.center(35, "*") + "\n") 46 | 47 | for nombre in Mi_lista: 48 | print(nombre) 49 | 50 | ############################################################################# 51 | 52 | # Pseudocodigo: 53 | 54 | # Instruccion WHILE: 55 | 56 | # HACER MIENTRAS condicion 57 | # instrucciones 58 | # FIN del HACER 59 | 60 | # Ejemplo: 61 | 62 | int_Indice = 0 63 | 64 | str_Cadena = " BUCLE FOR IN CON UN WHILE " 65 | print("\n" + str_Cadena.center(35, "*") + "\n") 66 | 67 | while int_Indice < len(Mi_lista): 68 | print(Mi_lista[int_Indice]) 69 | int_Indice = int_Indice + 1 70 | 71 | -------------------------------------------------------------------------------- /19_Bucle_for_in_range.py: -------------------------------------------------------------------------------- 1 | 2 | # Bucle infinito 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | 22 | # Usos especiales de las variables 23 | 24 | # Contadores 25 | # Variable = Variable +/- CONSTANTE 26 | 27 | # Acumuladores o Sumadores 28 | # Acumulador = Acumulador +/- Variable) 29 | 30 | ############################################################################# 31 | 32 | # Pseudocodigo: 33 | 34 | # Instruccion FOR IN RANGE: 35 | 36 | # PARA CADA ELEMENTO EN EL RANGO HACER 37 | # instrucciones 38 | # FIN del HACER 39 | 40 | # Ejemplo: 41 | 42 | str_Cadena = " BUCLE FOR IN RANGE " 43 | print("\n" + str_Cadena.center(70, "*") + "\n") 44 | 45 | numero = int(input('Intruduce el numero a elevar: ')) 46 | 47 | for potencia in range(0,11): 48 | resultado= numero ** potencia 49 | print("%d elevado a %d es %d")%(numero,potencia,resultado) 50 | 51 | ############################################################################# 52 | 53 | # Pseudocodigo: 54 | 55 | # Instruccion WHILE: 56 | 57 | # HACER MIENTRAS condicion 58 | # instrucciones 59 | # FIN del HACER 60 | 61 | # Ejemplo: 62 | 63 | potencia = 0 64 | 65 | str_Cadena = " BUCLE FOR IN RANGE CON UN WHILE " 66 | print("\n" + str_Cadena.center(70, "*") + "\n") 67 | 68 | while potencia >= 0 and potencia < 11: 69 | resultado= numero ** potencia 70 | print("%d elevado a %d es %d")%(numero,potencia,resultado) 71 | potencia = potencia + 1 72 | 73 | -------------------------------------------------------------------------------- /20_00_Ejercicios_Estructuras_Repetitivas.py: -------------------------------------------------------------------------------- 1 | 2 | # Ejercicios con estructuras repetitivas. 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ################################################################################ 22 | 23 | ## ENUNCIADO 1: 24 | 25 | ## Hacer un programa que imprima todos numeros naturales que hay desde la 26 | ## unidad hasta un numero que introducimos por teclado 27 | 28 | ################################################################################ 29 | 30 | ## Estudio previo: 31 | 32 | ## Se requiere una variable para guardar el numero introducido por teclado. 33 | ## Se deben empezar a imprimir los numeros desde el 1 hasta el valor intro- 34 | ## ducido por teclado 35 | ## 36 | ## El proceso de introducir un numero es el siguiente: 37 | ## 38 | ## - Antes del Ciclo: Para saber hasta que numero debemos imprimir 39 | ## - Fuera del ciclo: Para que solo se pida una vez 40 | 41 | 42 | ################################################################################ 43 | 44 | ## Variables 45 | 46 | ## numero = variable para introducir un numero 47 | ## contador = variable para generar e imprimir los numeros 48 | 49 | # Pseudocodigo: 50 | 51 | ## numero = 0 52 | ## contador = 1 53 | ## 54 | ## imprime "Introduce un numero: " 55 | ## introduce numero 56 | ## Hacer mientras contador <= numero 57 | ## contador = contador + 1 58 | ## imprime contador 59 | ## fin del hacer 60 | ## fin del programa 61 | 62 | ################################################################################ 63 | 64 | # Declaracion de variables: 65 | 66 | int_Numero = 0 67 | int_Contador = 1 68 | 69 | ################################################################################ 70 | 71 | # Inicio del programa: 72 | 73 | int_Numero = int(input('Introduce un numero: ')) 74 | 75 | while int_Contador <= int_Numero: 76 | 77 | print(int_Contador) 78 | int_Contador = int_Contador + 1 79 | 80 | 81 | ################################################################################ 82 | 83 | ## ENUNCIADO 2: 84 | 85 | ## Introducir tantas frases por teclado como deseemos y contarlas 86 | 87 | ################################################################################ 88 | 89 | ## Estudio previo: 90 | 91 | ## Las frases estan formadas por letras y numeros 92 | ## el proceso para introducir frases es repetitivo por lo tanto ira dentro 93 | ## del bucle. 94 | 95 | ################################################################################ 96 | 97 | ## Variables 98 | 99 | ## respuesta = para preguntar si queremos introducir mas frases 100 | ## frase = almacena la frase 101 | ## contador = variable para contar el numero de frases 102 | 103 | # Pseudocodigo: 104 | 105 | ## respuesta = 'S' 106 | ## frase = "" 107 | ## contador = 0 108 | 109 | ## Hacer mientras respuesta == 'S' 110 | ## imprime "Introduce una frase: " 111 | ## introduce frase 112 | ## contador = contador + 1 113 | ## imprime "Deseas introducir mas Frases (S/N): " 114 | ## introduce respuesta 115 | ## fin del Hacer 116 | ## 117 | ## imprime "El numero de frases introducidas son: " 118 | ## imprime "Contador" 119 | ## 120 | ## fin del programa 121 | 122 | ################################################################################ 123 | 124 | # Declaracion de variables: 125 | 126 | 127 | 128 | 129 | ################################################################################ 130 | 131 | # Inicio del programa: 132 | 133 | 134 | 135 | 136 | ################################################################################ 137 | 138 | -------------------------------------------------------------------------------- /20_01_Solucion_Estructuras_Repetitivas.py: -------------------------------------------------------------------------------- 1 | 2 | ################################################################################ 3 | 4 | ## ENUNCIADO 2: 5 | 6 | ## Introducir tantas frases por teclado como deseemos y contarlas 7 | 8 | ################################################################################ 9 | 10 | ## Estudio previo: 11 | 12 | ## Las frases estan formadas por letras y numeros 13 | ## el proceso para introducir frases es repetitivo por lo tanto ira dentro 14 | ## del bucle. 15 | 16 | ################################################################################ 17 | 18 | ## Variables 19 | 20 | ## respuesta = para preguntar si queremos introducir mas frases 21 | ## frase = almacena la frase 22 | ## contador = variable para contar el numero de frases 23 | 24 | # Pseudocodigo: 25 | 26 | ## respuesta = 'S' 27 | ## frase = "" 28 | ## contador = 0 29 | 30 | ## Hacer mientras respuesta == 'S' 31 | ## imprime "Introduce una frase: " 32 | ## introduce frase 33 | ## contador = contador + 1 34 | ## imprime "Deseas introducir mas Frases (S/N): " 35 | ## introduce respuesta 36 | ## fin del Hacer 37 | ## 38 | ## imprime "El numero de frases introducidas son: " 39 | ## imprime "Contador" 40 | ## 41 | ## fin del programa 42 | 43 | ################################################################################ 44 | 45 | # Declaracion de variables: 46 | 47 | str_Respuesta = 'S' 48 | str_Frase = "" 49 | int_Contador = 0 50 | 51 | ################################################################################ 52 | 53 | # Inicio del programa: 54 | 55 | while str_Respuesta == 'S' or str_Respuesta == 's': 56 | 57 | # SOLICITUD de Datos en PYTHON 2.7 58 | # str_Frase = raw_input('\nIntroduce una frase: ') 59 | 60 | # SOLICITUD de Datos en PYTHON 3.x 61 | str_Frase = input('\nIntroduce una frase: ') 62 | 63 | int_Contador = int_Contador + 1 64 | 65 | str_Respuesta = input('Deseas introducir nuevas Frases (S/N):') 66 | 67 | print("El numero de frases introducidas es: %d" %(int_Contador)) 68 | -------------------------------------------------------------------------------- /21_00_Bucles_Anidados.py: -------------------------------------------------------------------------------- 1 | 2 | # Ejercicios con estructuras repetitivas. 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ################################################################################ 22 | 23 | ## Pseudocodigo: 24 | 25 | ## Hacer_1 mientras condicion1 26 | ## 27 | ## Hacer_2 mientras condicion2 28 | ## 29 | ## Hacer_3 mientras condicion3 30 | ## 31 | ## Fin del Hacer_3 32 | ## 33 | ## Fin del Hacer_2 34 | ## 35 | ## Fin del Hacer_1 36 | 37 | ################################################################################ 38 | 39 | ## ENUNCIADO 1: 40 | 41 | ## Imprimir diez veces la serie de numeros del 1 al 10. Los numeros deben 42 | ## aparecer cada 1 segundo 43 | 44 | ################################################################################ 45 | 46 | ## Estudio previo: 47 | ## 48 | ## La secuencia de numeros del 1 al 10 se realiza mediante un ciclo que 49 | ## vaya del 1 al 10 y un contador para generarlos. 50 | ## 51 | ## Esta secuencia se debe realizar 10 veces por lo tanto se requiere otro 52 | ## ciclo que cuente las veces que se ha impreso el bucle interno. Este ciclo 53 | ## aumentará en una unidad cuando se hayan visualizado los numeros 54 | ## del 1 al 10. 55 | 56 | ## El bucle exterior controla que se imprima 10 veces el bucle interno. 57 | 58 | 59 | ################################################################################ 60 | 61 | ## Variables 62 | 63 | ## numero = contador interno para generar los numeros del 1 al 10 64 | ## serie = contador de series externo del 1 al 10 65 | 66 | # Pseudocodigo: 67 | 68 | ## numero = 0 69 | ## serie = 1 70 | ## 71 | ## Hacer_1 mientras serie <= 10 72 | ## 73 | ## numero = 1 74 | ## 75 | ## Hacer_2 mientras numero <= 10 76 | ## imprime numero 77 | ## numero = numero + 1 78 | ## espera(1) 79 | ## Fin del Hacer_2 80 | ## 81 | ## serie = serie + 1 82 | ## 83 | ## Fin del Hacer_1 84 | ## Fin del programa 85 | 86 | 87 | ################################################################################ 88 | 89 | import time 90 | 91 | # Declaracion de variables: 92 | 93 | int_Numero = 0 94 | int_Serie = 1 95 | 96 | ################################################################################ 97 | 98 | # Inicio del programa: 99 | 100 | print("\nSerie numero: %d \n")%(int_Serie) 101 | 102 | while int_Serie <= 10: 103 | 104 | int_Numero = 1 105 | 106 | while int_Numero <= 10: 107 | print(int_Numero) 108 | int_Numero = int_Numero + 1 109 | time.sleep(1) 110 | 111 | int_Serie = int_Serie + 1 112 | 113 | if int_Serie <= 10: 114 | print("\nSerie numero: %d \n")%(int_Serie) 115 | 116 | ################################################################################ 117 | 118 | ## ENUNCIADO 2: 119 | 120 | ## Hacer un pseudocodigo que simule el funcionamiento de un reloj Digital 121 | ## y que permita ponerle la hora 122 | 123 | ################################################################################ 124 | 125 | ## Estudio previo: 126 | ## 127 | ## Necesitamos 3 ciclos: para las horas, los minutos y los segundos, 128 | ## uno dentro del otro. 129 | ## 130 | ## El ciclo mas pequeño será el mas interno y será el primero en terminar. 131 | ## 132 | ## Cuando termine aumentaran los minutos; los segundos se inicializan en 0. 133 | ## 134 | ## Los minutos al llegar a 60 tendran que pasar a valer 0 y se incrementa 135 | ## la hora 136 | ## 137 | ## Al cumplir las 24 horas inicia un nuevo dia. Se puede usar un bucle 138 | ## infinito externo a las horas para que el reloj no se detenga. 139 | 140 | ## Formato de presentacion 141 | ## 142 | ## HH : MM : SS 143 | ## 00 : 00 : 00 144 | ## 145 | ## En Python se Utiliza el metodo zfill(n) para hacer que una cadena 146 | ## ocupe n posiciones, añadiendo tantos ceros a la izquierda como sea 147 | ## necesario. 148 | ## 149 | ## Ejemplo: 150 | ## 151 | ## >>> '23'.zfill(4) 152 | ## '0023' 153 | ## 154 | ## >>> str(23).zfill(4) 155 | ## '0023' 156 | 157 | ################################################################################ 158 | 159 | ## Variables 160 | 161 | ## horas = contador de las horas. 162 | ## minutos = contador para los minutos 163 | ## segundos = contador para los segundos 164 | ## 165 | 166 | # Pseudocodigo: 167 | 168 | ## horas = 0 169 | ## minutos = 0 170 | ## segundos = 0 171 | ## 172 | ## imprime "Introduce horas: " 173 | ## introduce horas 174 | ## 175 | ## imprime "Introduce minutos: " 176 | ## introduce minutos 177 | ## 178 | ## imprime "Introduce segundos: " 179 | ## introduce segundos 180 | ## 181 | ## Hacer_1 Mientras TRUE 182 | ## Hacer_2 Mientras horas < 24 183 | ## Hacer_3 Mientras minutos < 60 184 | ## Hacer_4 Mientras segundos < 60 185 | ## imprime "horas : minutos : segundos" 186 | ## segundos = segundos + 1 187 | ## espera(1) 188 | ## fin del Hacer_4 189 | ## minutos = minutos + 1 190 | ## segundos = 0 191 | ## fin del Hacer_3 192 | ## horas = horas + 1 193 | ## minutos = 0 194 | ## fin del Hacer_2 195 | ## horas = 0 196 | ## fin del Hacer_1 197 | ## 198 | ################################################################################ 199 | 200 | # Declaracion de variables: 201 | 202 | 203 | ################################################################################ 204 | 205 | # Inicio del programa: -------------------------------------------------------------------------------- /21_01_Solucion_Bucles_Anidados.py: -------------------------------------------------------------------------------- 1 | 2 | ################################################################################ 3 | 4 | ## ENUNCIADO 2: 5 | 6 | ## Hacer un pseudocodigo que simule el funcionamiento de un reloj Digital 7 | ## y que permita ponerle la hora 8 | 9 | ################################################################################ 10 | 11 | ## Estudio previo: 12 | ## 13 | ## Necesitamos 3 ciclos: para las horas, los minutos y los segundos, 14 | ## uno dentro del otro. 15 | ## 16 | ## El ciclo mas pequeño será el mas interno y será el primero en terminar. 17 | ## 18 | ## Cuando termine aumentaran los minutos; los segundos se inicializan en 0. 19 | ## 20 | ## Los minutos al llegar a 60 tendran que pasar a valer 0 y se incrementa 21 | ## la hora 22 | ## 23 | ## Al cumplir las 24 horas inicia un nuevo dia. Se puede usar un bucle 24 | ## infinito externo a las horas para que el reloj no se detenga. 25 | 26 | ## Formato de presentacion 27 | ## 28 | ## HH : MM : SS 29 | ## 00 : 00 : 00 30 | ## 31 | ## En Python se Utiliza el metodo zfill(n) para hacer que una cadena 32 | ## ocupe n posiciones, añadiendo tantos ceros a la izquierda como sea 33 | ## necesario. 34 | ## 35 | ## Ejemplo: 36 | ## 37 | ## >>> '23'.zfill(4) 38 | ## '0023' 39 | ## 40 | ## >>> str(23).zfill(4) 41 | ## '0023' 42 | 43 | ################################################################################ 44 | 45 | ## Variables 46 | 47 | ## horas = contador de las horas. 48 | ## minutos = contador para los minutos 49 | ## segundos = contador para los segundos 50 | ## 51 | 52 | # Pseudocodigo: 53 | 54 | ## horas = 0 55 | ## minutos = 0 56 | ## segundos = 0 57 | ## 58 | ## imprime "Introduce horas: " 59 | ## introduce horas 60 | ## 61 | ## imprime "Introduce minutos: " 62 | ## introduce minutos 63 | ## 64 | ## imprime "Introduce segundos: " 65 | ## introduce segundos 66 | ## 67 | ## Hacer_1 Mientras TRUE 68 | ## Hacer_2 Mientras horas < 24 69 | ## Hacer_3 Mientras minutos < 60 70 | ## Hacer_4 Mientras segundos < 60 71 | ## imprime "horas : minutos : segundos" 72 | ## segundos = segundos + 1 73 | ## espera(1) 74 | ## fin del Hacer_4 75 | ## minutos = minutos + 1 76 | ## segundos = 0 77 | ## fin del Hacer_3 78 | ## horas = horas + 1 79 | ## minutos = 0 80 | ## fin del Hacer_2 81 | ## horas = 0 82 | ## fin del Hacer_1 83 | ## 84 | ################################################################################ 85 | 86 | # Importación de módulos en Python 87 | 88 | import time 89 | 90 | ################################################################################ 91 | 92 | # Declaracion de variables: 93 | 94 | horas = 0 95 | minutos = 0 96 | segundos = 0 97 | 98 | ################################################################################ 99 | 100 | # Inicio del programa: 101 | 102 | # SOLICITUD de Datos en PYTHON 2.7 103 | ##horas = int(raw_input('\nIntroduce horas: ')) 104 | ##minutos = int(raw_input('\nIntroduce minutos: ')) 105 | ##segundos = int(raw_input('\nIntroduce segundos: ')) 106 | 107 | # SOLICITUD de Datos en PYTHON 3.x 108 | horas = int(input('Introduce horas: ')) 109 | minutos = int(input('Introduce minutos: ')) 110 | segundos = int(input('Introduce segundos: ')) 111 | 112 | print("") 113 | print("%02d:%02d:%02d" %(horas,minutos,segundos)) 114 | 115 | # Hacer_1 Mientras TRUE 116 | while True: 117 | 118 | # Hacer_2 Mientras horas < 24 119 | while horas < 24: 120 | # Hacer_3 Mientras minutos < 60 121 | while minutos < 60: 122 | # Hacer_4 Mientras segundos < 60 123 | while segundos <60: 124 | print("%02d:%02d:%02d" %(horas,minutos,segundos)) 125 | segundos = segundos + 1 126 | time.sleep(1) 127 | # fin del Hacer_4 128 | minutos = minutos + 1 129 | segundos = 0 130 | # fin del Hacer_3 131 | horas = horas + 1 132 | minutos = 0 133 | # fin del Hacer_2 134 | horas = 0 135 | # fin del Hacer_1 136 | 137 | -------------------------------------------------------------------------------- /22_00_Variables_Auxiliares.py: -------------------------------------------------------------------------------- 1 | 2 | # Variables auxiliares 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ################################################################################ 22 | 23 | ## ENUNCIADO: 24 | 25 | ## Introducir dos numeros naturales por teclado. Imprimir los numeros 26 | ## naturales que hay entre ambos numeros empezando por el mas pequeñp. 27 | 28 | ################################################################################ 29 | 30 | ## Estudio previo: 31 | 32 | ## Supongamos que introducimos por teclado los numeros 5 y 20 no importa 33 | ## el orden. 34 | ## 35 | ## La impresion de los numeros la realizamos mediante un ciclo con dos 36 | ## variablesque contengan al menor y al mayor de los numeros, y un contador 37 | ## que vaya desde el numero inferior al superior. 38 | ## 39 | ## El problema es saber cual es el menor si el primero o el segundo. Si el 40 | ## mayor es el numero introducido en primer lugar debemos intercambiar los 41 | ## numeros con una variable auxiliar. 42 | ## 43 | ## Ejemplo: 44 | ## 45 | ## menor = 20 46 | ## mayor = 5 47 | ## aux = 0 48 | ## 49 | ## Volcamos el contenido de una de las variables en auxiliar: 50 | ## 51 | ## aux = menor 52 | ## 53 | ## El panorama queda de la siguiente manera 54 | ## 55 | ## menor = 20 56 | ## mayor = 5 57 | ## aux = 20 58 | ## 59 | ## El contenido de 'mayor' los volcamos en menor: 60 | ## 61 | ## menor = mayor 62 | ## 63 | ## y la situacion es: 64 | ## 65 | ## menor = 5 66 | ## mayor = 5 67 | ## aux = 20 68 | ## 69 | ## por ultimo se asigna a 'mayor' el contenido de la variable auxiliar. 70 | ## 71 | ## mayor = aux 72 | ## 73 | ## quedando los siguientes valores: 74 | ## 75 | ## menor = 5 76 | ## mayor = 20 77 | ## aux = 20 78 | ## 79 | ## en resumen el proceso será: 80 | ## 81 | ## aux = menor 82 | ## menor = mayor 83 | ## mayor = aux 84 | ## 85 | ################################################################################ 86 | 87 | ## Variables: 88 | 89 | ## num1 = recoge el primer numero introducido por teclado. 90 | ## num2 = recoge el segundo numero introducido por teclado. 91 | ## aux = variable auxiliar para realizar el intercambio de los numeros 92 | ## si num 2 es mas pequeño que num1. 93 | 94 | # Pseudocodigo: 95 | 96 | ## num1 = 0 97 | ## num2 = 0 98 | ## aux = 0 99 | ## 100 | ## imprime "Introduce el primer Numero" 101 | ## introduce num1 102 | ## imprime "Introduce el segundo Numero" 103 | ## introduce num2 104 | ## 105 | ## if num1 > num2 106 | ## aux = num1 107 | ## num1 = num2 108 | ## num2 = aux 109 | ## Fin del if 110 | ## 111 | ## Hacer mientras num1 <= num2 112 | ## imprime num1 113 | ## num1 = num1 + 1 114 | ## Fin del Hacer 115 | ## Fin del programa 116 | 117 | 118 | ################################################################################ 119 | 120 | # Declaracion de variables: 121 | 122 | ################################################################################ 123 | 124 | # Inicio del programa: 125 | 126 | -------------------------------------------------------------------------------- /22_01_Solucion_Variables_Auxiliares.py: -------------------------------------------------------------------------------- 1 | ################################################################################ 2 | 3 | ## ENUNCIADO: 4 | 5 | ## Introducir dos numeros naturales por teclado. Imprimir los numeros 6 | ## naturales que hay entre ambos numeros empezando por el mas pequeñp. 7 | 8 | ################################################################################ 9 | 10 | ## Estudio previo: 11 | 12 | ## Supongamos que introducimos por teclado los numeros 5 y 20 no importa 13 | ## el orden. 14 | ## 15 | ## La impresion de los numeros la realizamos mediante un ciclo con dos 16 | ## variablesque contengan al menor y al mayor de los numeros, y un contador 17 | ## que vaya desde el numero inferior al superior. 18 | ## 19 | ## El problema es saber cual es el menor si el primero o el segundo. Si el 20 | ## mayor es el numero introducido en primer lugar debemos intercambiar los 21 | ## numeros con una variable auxiliar. 22 | ## 23 | ## Ejemplo: 24 | ## 25 | ## menor = 20 26 | ## mayor = 5 27 | ## aux = 0 28 | ## 29 | ## Volcamos el contenido de una de las variables en auxiliar: 30 | ## 31 | ## aux = menor 32 | ## 33 | ## El panorama queda de la siguiente manera 34 | ## 35 | ## menor = 20 36 | ## mayor = 5 37 | ## aux = 20 38 | ## 39 | ## El contenido de 'mayor' los volcamos en menor: 40 | ## 41 | ## menor = mayor 42 | ## 43 | ## y la situacion es: 44 | ## 45 | ## menor = 5 46 | ## mayor = 5 47 | ## aux = 20 48 | ## 49 | ## por ultimo se asigna a 'mayor' el contenido de la variable auxiliar. 50 | ## 51 | ## mayor = aux 52 | ## 53 | ## quedando los siguientes valores: 54 | ## 55 | ## menor = 5 56 | ## mayor = 20 57 | ## aux = 20 58 | ## 59 | ## en resumen el proceso será: 60 | ## 61 | ## aux = menor 62 | ## menor = mayor 63 | ## mayor = aux 64 | ## 65 | ################################################################################ 66 | 67 | ## Variables: 68 | 69 | ## num1 = recoge el primer numero introducido por teclado. 70 | ## num2 = recoge el segundo numero introducido por teclado. 71 | ## aux = variable auxiliar para realizar el intercambio de los numeros 72 | ## si num 2 es mas pequeño que num1. 73 | 74 | # Pseudocodigo: 75 | 76 | ## num1 = 0 77 | ## num2 = 0 78 | ## aux = 0 79 | ## 80 | ## imprime "Introduce el primer Numero" 81 | ## introduce num1 82 | ## imprime "Introduce el segundo Numero" 83 | ## introduce num2 84 | ## 85 | ## if num1 > num2 86 | ## aux = num1 87 | ## num1 = num2 88 | ## num2 = aux 89 | ## Fin del if 90 | ## 91 | ## Hacer mientras num1 <= num2 92 | ## imprime num1 93 | ## num1 = num1 + 1 94 | ## Fin del Hacer 95 | ## Fin del programa 96 | 97 | 98 | ################################################################################ 99 | 100 | # Declaracion de variables: 101 | 102 | int_numero1 = 0 103 | int_numero2 = 0 104 | int_auxiliar = 0 105 | 106 | ################################################################################ 107 | 108 | # Inicio del programa: 109 | 110 | # SOLICITUD de Datos en PYTHON 2.7 111 | # int_numero1 = int(raw_input('\nIntroduce el primer numero: ')) 112 | # int_numero2 = int(raw_input('\nIntroduce el segundo numero: ')) 113 | 114 | # SOLICITUD de Datos en PYTHON 3.x 115 | int_numero1 = int(input('Introduce el primer numero: ')) 116 | int_numero2 = int(input('Introduce el segundo numero: ')) 117 | 118 | if int_numero1 > int_numero2: 119 | 120 | int_auxiliar = int_numero1 121 | int_numero1 = int_numero2 122 | int_numero2 = int_auxiliar 123 | 124 | while int_numero1 <= int_numero2: 125 | 126 | print(int_numero1) 127 | int_numero1 = int_numero1 + 1 128 | -------------------------------------------------------------------------------- /23_00_Banderas_de_Estado.py: -------------------------------------------------------------------------------- 1 | 2 | # Interruptor o bandera 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ################################################################################ 22 | 23 | ## TEORIA: 24 | 25 | ## Una bandera o flag es una variable que solo puede tomar dos valores 0 o 1. 26 | ## por este motivo tambien son llamadas interruptores para indicar: 27 | ## 28 | ## Encendido o apagado 29 | ## 30 | ## Se utilizan para saber si el programa ha pasado por un determinado punto 31 | ## y variar la secuencia de ejecucion de un programa dependiendo del valor 32 | ## que poseen en cada instante. 33 | 34 | ################################################################################ 35 | 36 | ## ENUNCIADO: 37 | 38 | ## Imprimir 10 veces de una forma alternativa 'Hola' y 'Adios' 39 | 40 | ################################################################################ 41 | 42 | ## Estudio previo: 43 | 44 | ## Necesitaremos un contador para imprimir la serie de numeros del 1 al 10 45 | ## 46 | ## La visualizacion de una forma alternativa de dos comentarios diferentes 47 | ## la hacemos mediante una bandera. 48 | ## 49 | ## La bandera permite saber segun su valor 0 o 1, si la última palabra fue 50 | ## 'Hola' o 'Adios' 51 | ## 52 | ################################################################################ 53 | 54 | ## Variables: 55 | 56 | ## bandera = para saber si acabamos de imprimir Hola o Adiós 57 | ## contador = variable para contar del 1 al 10 58 | 59 | # Pseudocodigo: 60 | 61 | ## bandera = 0 62 | ## contador = 0 63 | ## 64 | ## Hacer mientras contador <= 10 65 | ## if bandera = 0 66 | ## imprime "Hola" 67 | ## bandera = 1 68 | ## else 69 | ## imprime "Adios" 70 | ## bandera = 0 71 | ## fin del if 72 | ## contador = contador + 1 73 | ## fin del Hacer 74 | ## fin del programa 75 | 76 | ################################################################################ 77 | 78 | # Declaracion de variables: 79 | 80 | 81 | ################################################################################ 82 | 83 | # Inicio del programa: 84 | -------------------------------------------------------------------------------- /23_01_Solucion_Banderas_de_Estado.py: -------------------------------------------------------------------------------- 1 | 2 | ################################################################################ 3 | 4 | ## ENUNCIADO: 5 | 6 | ## Imprimir 10 veces de una forma alternativa 'Hola' y 'Adios' 7 | 8 | ################################################################################ 9 | 10 | ## Estudio previo: 11 | 12 | ## Necesitaremos un contador para imprimir la serie de numeros del 1 al 10 13 | ## 14 | ## La visualizacion de una forma alternativa de dos comentarios diferentes 15 | ## la hacemos mediante una bandera. 16 | ## 17 | ## La bandera permite saber segun su valor 0 o 1, si la última palabra fue 18 | ## 'Hola' o 'Adios' 19 | ## 20 | ################################################################################ 21 | 22 | ## Variables: 23 | 24 | ## bandera = para saber si acabamos de imprimir Hola o Adiós 25 | ## contador = variable para contar del 1 al 10 26 | 27 | # Pseudocodigo: 28 | 29 | ## bandera = 0 30 | ## contador = 1 31 | ## 32 | ## Hacer mientras contador <= 10 33 | ## if bandera = 0 34 | ## imprime "Hola" 35 | ## bandera = 1 36 | ## else 37 | ## imprime "Adios" 38 | ## bandera = 0 39 | ## fin del if 40 | ## contador = contador + 1 41 | ## fin del Hacer 42 | ## fin del programa 43 | 44 | ################################################################################ 45 | 46 | # Declaracion de variables: 47 | 48 | bool_Bandera = 0 49 | int_Contador = 1 50 | 51 | ################################################################################ 52 | 53 | # Inicio del programa: 54 | 55 | while int_Contador <= 10: 56 | 57 | if bool_Bandera == 0: 58 | 59 | print(int_Contador,"Hola") 60 | bool_Bandera = 1 61 | 62 | else: 63 | 64 | print(int_Contador,"Adios") 65 | bool_Bandera = 0 66 | 67 | int_Contador = int_Contador + 1 68 | -------------------------------------------------------------------------------- /24_Funciones.py: -------------------------------------------------------------------------------- 1 | 2 | # Manejo de Funciones 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ################################################################################ 22 | 23 | ## 24 | ## Pseudocodigo: 25 | 26 | ## FUNCION: 27 | ## Instruciones 28 | ## Fin de FUNCION 29 | 30 | ## Instrucciones 31 | ## Llamar FUNCION 32 | ## Instrucciones 33 | 34 | ################################################################################ 35 | 36 | # Declaracion de variables: 37 | 38 | 39 | ################################################################################ 40 | 41 | # Declaracion de Funciones: 42 | 43 | def main(): 44 | pass 45 | 46 | def mi_funcion(): 47 | print("\nMANEJO DE FUNCIONES\n") 48 | 49 | 50 | def mi_menu(): 51 | print ("- Escoge una opcion:\n") 52 | print ("1) SUMA.") 53 | print ("2) RESTA.") 54 | print ("3) MULTIPLICACION.") 55 | print ("4) DIVISION.\n") 56 | 57 | ################################################################################ 58 | 59 | # Inicio del programa: 60 | 61 | main() 62 | 63 | # LLamadas a Funciones 64 | 65 | mi_funcion() 66 | mi_menu() 67 | 68 | 69 | -------------------------------------------------------------------------------- /25_Funciones con Parametros.py: -------------------------------------------------------------------------------- 1 | 2 | # Funciones con parametros 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ################################################################################ 22 | 23 | ## 24 | ## Pseudocodigo: 25 | 26 | ## FUNCION: 27 | ## Instruciones 28 | ## Fin de FUNCION 29 | 30 | ## Instrucciones 31 | ## Hacer FUNCION 32 | ## Instrucciones 33 | 34 | ################################################################################ 35 | 36 | # Declaracion de variables: Globales 37 | 38 | ## str_Continuar : Variable para saber si se continua con el programa 39 | ## str_Opcion : Almacena la operacion a ejecutar 40 | ## int_Numero1 : Primer valor solicitado por al usuario 41 | ## int_Numero2 : Segundo Valor solicitado al usuario 42 | 43 | # Variables Globales 44 | 45 | str_Continuar = "S" 46 | str_Opcion = '' 47 | 48 | int_Numero1 = 0 49 | int_Numero2 = 0 50 | 51 | # Declaracion de Funciones: 52 | 53 | ################################################################################ 54 | ################################################################################ 55 | 56 | def str_main(): 57 | 58 | """ 59 | Descripcion : Funcion principal 60 | Parametros : Sin parametros 61 | Retorna : Un caracter para continuar o no con el programa 62 | """ 63 | 64 | print(str_main.__name__) 65 | print(str_main.__doc__) 66 | 67 | print("\nPROGRAMA PRINCIPAL\n") 68 | 69 | # Solicitud de Datos al Usuario 70 | int_Numero1 = int(input('Introduce El primer numero: ')) 71 | int_Numero2 = int(input('Introduce El Segundo numero: ')) 72 | 73 | # Almacena la Opcion a Ejecutar 74 | str_Opcion = str_menu() 75 | 76 | #Ejecuta la operacion Seleccionada 77 | operaciones(str_Opcion,int_Numero1,int_Numero2) 78 | 79 | # Se pregunta al usuario si desea Continuar 80 | # Variable local 81 | str_Continuar = input(('Desea Continuar: S/N:')) 82 | return str_Continuar 83 | 84 | ################################################################################ 85 | ################################################################################ 86 | 87 | def str_menu(): 88 | 89 | """ 90 | Descripcion : Imprime un menu de opciones 91 | Parametros : Sin parametros 92 | Retorna : Devuelve la operacion a ejecutar 93 | """ 94 | 95 | ## print(str_menu.__name__) 96 | ## print(str_menu.__doc__) 97 | 98 | print("\nMENU DE OPCIONES\n") 99 | 100 | print ("1) SUMA.") 101 | print ("2) RESTA.") 102 | print ("3) MULTIPLICACION.") 103 | print ("4) DIVISION.\n") 104 | 105 | # Variable Local 106 | str_Operacion = input('Teclea la opcion y pulsa Enter: ') 107 | return str_Operacion 108 | 109 | ################################################################################ 110 | ################################################################################ 111 | 112 | def operaciones(str_operacion,int_valor1, int_valor2): 113 | 114 | """ 115 | Descripcion : Ejecuta la operacion e imprime el resultado 116 | Parametros : str_operacion,int_valor1, int_valor2 117 | 118 | str_operacion : Caracter que guarda la operacion 119 | int_valor1 : Primer dato introducido por el usuario 120 | int_valor2 : Segundo dato introducido por el usuario 121 | 122 | Retorna : No devuelve parametros 123 | """ 124 | ## print(operaciones.__name__) 125 | ## print(operaciones.__doc__) 126 | 127 | if str_operacion == '1': 128 | print("\nEl resultado es: %1.2f\n"%(int_valor1 + int_valor2)) 129 | return 130 | 131 | elif str_operacion == '2': 132 | print("\nEl resultado es: %1.2f\n"%(int_valor1 - int_valor2)) 133 | return 134 | 135 | elif str_operacion == '3': 136 | print("\nEl resultado es: %1.2f\n"%(int_valor1 * int_valor2)) 137 | return 138 | 139 | elif str_operacion == '4': 140 | print("\nEl resultado es: %1.2f\n"%(int_valor1 / int_valor2)) 141 | return 142 | 143 | else: 144 | print("No es una opcion valida.\n") 145 | return 146 | 147 | ################################################################################ 148 | ################################################################################ 149 | 150 | ### Inicio del programa: 151 | 152 | while str_Continuar == 's' or str_Continuar =='S': 153 | 154 | str_Continuar = str_main() 155 | 156 | print("\nFIN DEL PROGRAMA\n") 157 | 158 | -------------------------------------------------------------------------------- /26_Parametros_Arbitrarios.py: -------------------------------------------------------------------------------- 1 | 2 | # Funciones con parametros arbitrarrios 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ################################################################################ 22 | 23 | ## 24 | ## Pseudocodigo: 25 | 26 | ## FUNCION: 27 | ## Instruciones 28 | ## Fin de FUNCION 29 | 30 | ## Instrucciones 31 | ## Hacer FUNCION 32 | ## Instrucciones 33 | 34 | ################################################################################ 35 | 36 | # Declaracion de variables 37 | 38 | # x = 1 39 | # y = 2 40 | # z = 3 41 | 42 | x,y,z = 1,2,3 43 | 44 | seccion = 1 45 | nombres = ['Juan', 'Antonio', 'Pedro', 'Herminio'] 46 | asignaturas = {'matematica': 20, 'fisica': 19, 'quimica': 18} 47 | 48 | ################################################################################ 49 | 50 | # Declaracion de funciones 51 | 52 | def funcion(x,y,z): 53 | print("\nParametros de la funcion: \n x = %d, y = %d, z = %d" %(x,y,z)) 54 | 55 | def alumnos(*lista): 56 | 57 | print("\nLISTA DE ALUMNOS\n") 58 | 59 | for nombre in lista: 60 | print(nombre) 61 | 62 | 63 | def notas(seccion, *lista , **asignaturas): 64 | 65 | print("\nALUMNOS EN LA SECCION: %d\n" %(seccion)) 66 | 67 | for nombre in lista: 68 | print(nombre.upper()+"\n") 69 | 70 | for elemento in asignaturas.items(): 71 | print(elemento) 72 | 73 | print("\n") 74 | 75 | ################################################################################ 76 | 77 | # Inicio del programa: 78 | 79 | funcion(x,y,z) 80 | 81 | alumnos(*nombres) 82 | 83 | notas(seccion, *nombres, **asignaturas) 84 | -------------------------------------------------------------------------------- /27_Recursividad.py: -------------------------------------------------------------------------------- 1 | 2 | # Recursividad de funciones 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ################################################################################ 22 | 23 | ## 24 | ## Pseudocodigo: 25 | 26 | ## FUNCION: 27 | ## Instruciones 28 | ## Fin de FUNCION 29 | 30 | ## Instrucciones 31 | ## Hacer FUNCION 32 | ## Instrucciones 33 | 34 | ################################################################################ 35 | 36 | # Declaracion de variables: Globales 37 | 38 | ################################################################################ 39 | 40 | ## Inicio del Programa: 41 | 42 | def clave(int_intento = 1): 43 | 44 | str_respuesta = input("Introduce la clave: ") 45 | 46 | if str_respuesta != "abc123": 47 | 48 | if int_intento < 3: 49 | 50 | print("\nClave incorrecta! Intenta de nuevo") 51 | int_intento = int_intento + 1 52 | clave(int_intento) # Llamada recursiva 53 | 54 | else: 55 | print("\nUsuario Bloqueado!") 56 | else: 57 | print("\nClave Correcta!") 58 | 59 | clave() 60 | 61 | 62 | -------------------------------------------------------------------------------- /28_Funciones_Lambda.py: -------------------------------------------------------------------------------- 1 | 2 | # Funciones lambda 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ################################################################################ 22 | 23 | ## Pseudocodigo: 24 | 25 | # variable = lambda parametro1, parametro2 : expresion 26 | 27 | # Ejemplo: 28 | # num = lambda x,y: x + y 29 | 30 | ################################################################################ 31 | 32 | 33 | def calculadora1(operador,x,y): 34 | 35 | if operador == 'sum': 36 | return x + y 37 | elif operador == 'res': 38 | return x - y 39 | elif operador == 'mul': 40 | return x * y 41 | elif operador == 'div': 42 | return x / y 43 | else: 44 | return None 45 | 46 | def calculadora2(operator,x,y): 47 | 48 | print("Calculadora") 49 | 50 | # Declaracion de un diccionario 51 | 52 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 53 | 54 | # llamar valores de un diccionario 55 | 56 | # diccionario.keys() : Regresa lista de todas las claves en el diccionario 57 | # diccionario.items(): Regresa una lista completa de elementos del 58 | # diccionario 59 | # dic_Services[clave] 60 | 61 | # diccionario.get(clave,por_defecto): Devuelve el valor correspondiente a 62 | # la clave, en caso de que no exista, no 63 | # muestra nungun error, sino que retorna 64 | # el segundo argumento. 65 | 66 | return{ 67 | 'sum': lambda: x + y, 68 | 'res': lambda: x - y, 69 | 'mul': lambda: x * y, 70 | 'div': lambda: x / y, 71 | }.get(operator, lambda: None)() 72 | 73 | 74 | num = calculadora2('res', 5, 4) 75 | print(num) 76 | 77 | -------------------------------------------------------------------------------- /28_Validacion_de_Datos.py: -------------------------------------------------------------------------------- 1 | 2 | # Validacion de datos 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ################################################################################ 22 | 23 | # Declaracion de funciones 24 | 25 | def edad(): 26 | 27 | str_edad = input("Introduce tu edad: ") 28 | 29 | if str_edad.isdigit(): 30 | print("Tu edad es: %s" %(str_edad)) 31 | else: 32 | print("\nNo has introducido valores numericos. Intenta de nuevo") 33 | edad() # Llamada recursiva 34 | 35 | edad() -------------------------------------------------------------------------------- /29_Manejo_de_Excepciones.py: -------------------------------------------------------------------------------- 1 | 2 | # Manejo de excepciones 3 | 4 | # ESTILO WCODE 5 | 6 | # Variables 7 | # int_Nombre_variable = tipo_dato ; Variables del tipo entero 8 | # float_Nombre_variable = tipo_dato ; Variables con decimales 9 | # str_Nombre_variable = tipo_dato ; variables con Cadenas o caracteres 10 | # bool_Nombre_variable = tipo_dato ; variables booleanas 11 | 12 | # Constantes 13 | # const_NOMBRE_CONSTANTE = tipo_dato ; Constante de cualquier tipo de datos 14 | # NOMBRE_CONSTANTE = tipo_dato 15 | 16 | # Colecciones 17 | # list_Nombre_Lista = [dato1,dato2,...] ; Elementos de una lista 18 | # tuple_Nombre_tupla = (dato1,dato2,...) ; Elementos de una tupla 19 | # dic_Nombre_diccionario = {'clave':dato2,...} ; Elementos de un diccionario 20 | # 21 | ################################################################################ 22 | 23 | def edad(): 24 | 25 | try: 26 | int_edad = int(input("Introduce tu edad: ")) 27 | print("Tu edad es: %d\n" %(int_edad)) 28 | 29 | except ValueError, ex: 30 | print("\nExcepcion Capturada\n") 31 | print(ex) 32 | 33 | except: 34 | print("\nNo has introducido valores numericos. Intenta de nuevo\n") 35 | edad() 36 | 37 | ################################################################################ 38 | 39 | # Inicio del programa 40 | 41 | edad() 42 | 43 | #int_edad = int(input("Introduce tu edad: ")) 44 | 45 | 46 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # wcode-python-3x 2 | Programas en Python 3 | Curso De 0 a Programador: Python desde 0 3 | --------------------------------------------------------------------------------