├── 1.-introduccion ├── comentarios.py ├── constantes.py ├── entrada.py ├── logicos.py ├── main.py ├── multiples.py ├── relacionales.py ├── tipado.py ├── tipos.py └── variables.py ├── 2.-Listas ├── listas.py └── matrices.py ├── 3.-Tuplas ├── comprimir.py ├── descomprimir.py ├── listas.py └── tuplas.py ├── 4.-Strings ├── alineacion.py ├── busqueda.py ├── concatenar.py ├── formatos.py ├── imprimir.py └── strings.py ├── 5.-Diccionarios ├── diccionarios.py ├── elementos.py ├── eliminar.py └── llaves.py ├── 6.-Condiciones ├── anidados.py ├── booleanos.py ├── break.py ├── condiciones.py ├── for.py ├── multiples.py ├── none.py ├── range.py ├── ternario.py └── while.py ├── 7.-Funciones ├── __pycache__ │ └── documentar.cpython-37.pyc ├── anidadas.py ├── argumentos.py ├── callbacks.py ├── closures.py ├── decoradores.py ├── documentar.py ├── funciones.py ├── labmdas.py ├── nonlocal.py ├── parametros.py └── scope.py └── 8.-Clases ├── clases.py ├── herencia.py ├── main.py └── metodos.py /1.-introduccion/comentarios.py: -------------------------------------------------------------------------------- 1 | # Esta línea se encuentra comentada. 2 | print('Hola mundo') 3 | 4 | """ 5 | Este es un comentario 6 | que posee saltos 7 | de línea. 8 | """ -------------------------------------------------------------------------------- /1.-introduccion/constantes.py: -------------------------------------------------------------------------------- 1 | TITULO_CURSO = 'Curso profesional de Python' 2 | 3 | print(TITULO_CURSO) -------------------------------------------------------------------------------- /1.-introduccion/entrada.py: -------------------------------------------------------------------------------- 1 | nombre_completo = input('Ingresa tu nombre completo: ') # str 2 | 3 | edad = int(input('Ingresa tu edad: ')) 4 | 5 | altura = float(input('Ingresa tu altura: ')) 6 | 7 | autorizacion = input('¿Autorizas el programa? (si/no)') == 'si' 8 | 9 | print(nombre_completo) 10 | print(edad) 11 | print(altura) 12 | print(autorizacion) -------------------------------------------------------------------------------- /1.-introduccion/logicos.py: -------------------------------------------------------------------------------- 1 | # and, or y not 2 | 3 | resultado_final = not True 4 | print(resultado_final) -------------------------------------------------------------------------------- /1.-introduccion/main.py: -------------------------------------------------------------------------------- 1 | print("Hola, te encuentras en un nuevo curso de CódigoFacilito.") -------------------------------------------------------------------------------- /1.-introduccion/multiples.py: -------------------------------------------------------------------------------- 1 | nombre, apellido, titulo = 'Eduardo', 'García', 'Mr.' 2 | 3 | print(nombre) 4 | print(apellido) 5 | print(titulo) -------------------------------------------------------------------------------- /1.-introduccion/relacionales.py: -------------------------------------------------------------------------------- 1 | numero_uno = 20 2 | numero_dos = 50 3 | 4 | """ 5 | > 6 | < 7 | >= 8 | <= 9 | == 10 | != 11 | """ 12 | 13 | resulto = numero_uno == numero_dos 14 | print(resulto) -------------------------------------------------------------------------------- /1.-introduccion/tipado.py: -------------------------------------------------------------------------------- 1 | valor = "Eduardo" 2 | print(type(valor)) 3 | 4 | valor = 2 5 | print(type(valor)) 6 | 7 | valor = 3.1 8 | print(type(valor)) 9 | 10 | valor = True 11 | print(type(valor)) -------------------------------------------------------------------------------- /1.-introduccion/tipos.py: -------------------------------------------------------------------------------- 1 | # String 2 | titulo_curso = 'Curso profesional de Python' 3 | print(titulo_curso) 4 | 5 | nombre_completo = "Eduardo Ismael" 6 | print(nombre_completo) 7 | 8 | mensaje = '''Te encuentras 9 | en el curso: Profesional de Python. 10 | En CódigoFacilito''' 11 | 12 | print(mensaje) 13 | 14 | # Int 15 | # Al divir con / Obtenemos un tipo de dato flotante 16 | # Al divir con // Obtenemos un tipo de dato entero 17 | numero_uno = 10 // 3 18 | print(numero_uno) 19 | 20 | # Float 21 | numero_dos = -3.14 22 | print(numero_dos) 23 | 24 | # Bool 25 | # True - False 26 | valor = False 27 | print(valor) -------------------------------------------------------------------------------- /1.-introduccion/variables.py: -------------------------------------------------------------------------------- 1 | titulo_curso = 'Curso profesional de Python' 2 | 3 | nombre_completo = 'Eduardo Ismael García Pérez' 4 | 5 | print(titulo_curso) -------------------------------------------------------------------------------- /2.-Listas/listas.py: -------------------------------------------------------------------------------- 1 | lista = [8, 5, 90, 1, 5, 44, 132, 600, 3, 4, 5] 2 | 3 | print(5 in lista) 4 | 5 | index = lista. 6 | (5) 7 | print(index) -------------------------------------------------------------------------------- /2.-Listas/matrices.py: -------------------------------------------------------------------------------- 1 | columna_a = [10, 20, 30, 40] 2 | columna_b = [30, 40, 50, 60] 3 | 4 | matriz = [columna_a, columna_b] # 2 x 4 5 | 6 | print(matriz[1][3]) -------------------------------------------------------------------------------- /3.-Tuplas/comprimir.py: -------------------------------------------------------------------------------- 1 | lista = [1, 2, 3, 4, 5, 6, 7] 2 | 3 | tupla = (10, 20, 30, 40, 50) 4 | 5 | lista_2 = [100, 200, 300, 400, 500, 600, 700] 6 | 7 | tupla_2 = (1000, 2000, 3000, 4000, 5000) 8 | 9 | resultado = zip(lista, tupla, lista_2, tupla_2) # -> zip 10 | resultado = tuple(resultado) 11 | 12 | print(resultado) -------------------------------------------------------------------------------- /3.-Tuplas/descomprimir.py: -------------------------------------------------------------------------------- 1 | # * -> lista 2 | # _ -> Omitir valor 3 | 4 | numeros = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) 5 | uno, _, tres, cuatro, *_, nueve, diez = numeros 6 | 7 | print(uno) 8 | 9 | print(tres) 10 | print(cuatro) 11 | 12 | print(nueve) 13 | print(diez) 14 | 15 | # print(resto_numeros) 16 | -------------------------------------------------------------------------------- /3.-Tuplas/listas.py: -------------------------------------------------------------------------------- 1 | cursos = ['Python', 'Django', 'Flask'] 2 | 3 | cursos_tupla = tuple(cursos) 4 | 5 | print(cursos_tupla) 6 | print(type(cursos_tupla)) 7 | 8 | niveles = ('Básico', 'Intermedio', 'Avanzado') 9 | 10 | niveles_lista = list(niveles) 11 | 12 | print(niveles_lista) 13 | print(type(niveles_lista)) -------------------------------------------------------------------------------- /3.-Tuplas/tuplas.py: -------------------------------------------------------------------------------- 1 | cursos = ('Python', 'Flask', 'Django', 'Rails', 'MongoDB') 2 | # 0 1 2 3 4 3 | 4 | primer_curso = cursos[0] 5 | print(primer_curso) 6 | 7 | ultimo_curso = cursos[-1] 8 | print(ultimo_curso) 9 | 10 | sub_tupla = cursos[:] 11 | print(sub_tupla) -------------------------------------------------------------------------------- /4.-Strings/alineacion.py: -------------------------------------------------------------------------------- 1 | mensaje = 'Hola mundo!' 2 | 3 | # ljust -> Justificar a la Izquierda 4 | # rjust -> Justificar a la Derecha 5 | # center -> Centrar 6 | 7 | mensaje = mensaje.center(20) 8 | 9 | print(mensaje) 10 | -------------------------------------------------------------------------------- /4.-Strings/busqueda.py: -------------------------------------------------------------------------------- 1 | titulo_curso = 'Curso profesional de Python, donde aprenderemos Python' 2 | 3 | """ 4 | contador = titulo_curso.count('a') 5 | 6 | print(contador) 7 | """ 8 | 9 | # startswith 10 | # endswith 11 | 12 | print(titulo_curso.endswith('Python')) -------------------------------------------------------------------------------- /4.-Strings/concatenar.py: -------------------------------------------------------------------------------- 1 | nombre = 'Eduardo Ismael' 2 | apellido = 'García' 3 | 4 | # nombre_completo = 'Mr.' + nombre + ' ' + apellido + '.' 5 | 6 | # nombre_completo = 'Mr. %s %s %s.' %(nombre, apellido, 'Pérez') 7 | 8 | """ 9 | nombre_completo = 'Mr. {nombre} {primer_apellido} {segundo_apellido}.'.format( 10 | nombre=nombre, 11 | primer_apellido=apellido, 12 | segundo_apellido='Pérez' 13 | ) 14 | """ 15 | 16 | nombre_completo = f'Mr. {nombre} {apellido} { 10 * 20 }' 17 | 18 | print(nombre_completo) -------------------------------------------------------------------------------- /4.-Strings/formatos.py: -------------------------------------------------------------------------------- 1 | mensaje = ' Curso profesional de Python, donde aprenderemos Python. ' 2 | 3 | # mensaje = mensaje.upper() 4 | # mensaje = mensaje.lower() 5 | 6 | # mensaje = mensaje.replace(' ', '-') 7 | 8 | mensaje = mensaje.strip() 9 | 10 | print(mensaje) 11 | # print(mensaje.islower()) # isupper() o islower() -------------------------------------------------------------------------------- /4.-Strings/imprimir.py: -------------------------------------------------------------------------------- 1 | nombre = 'Eduardo Ismael' 2 | apellido = 'García' 3 | 4 | print(nombre, apellido, 'Pérez', sep=' ') -------------------------------------------------------------------------------- /4.-Strings/strings.py: -------------------------------------------------------------------------------- 1 | """ 2 | lenguajes = 'Python Ruby Java Rust C++ C' 3 | 4 | listado_lenguajes = lenguajes.split('') # espacios 5 | 6 | print(listado_lenguajes) 7 | """ 8 | 9 | lenguajes = ['Python', 'Ruby', 'Java', 'Rust'] 10 | 11 | string_lenguajes = '-'.join(lenguajes) 12 | 13 | print(string_lenguajes) 14 | print(type(string_lenguajes)) -------------------------------------------------------------------------------- /5.-Diccionarios/diccionarios.py: -------------------------------------------------------------------------------- 1 | elementos = {'a': 1, 'b': 2, 'c':3, 'a': 4} 2 | 3 | """ 4 | elementos['nombre'] ='Cody' # Crea la llave con su valor 5 | elementos[(1, 2, 3)] ='La llave es una tupla' 6 | 7 | # Actualiza el valor de la llave 8 | elementos['nombre'] = 'CódigoFacilito' 9 | """ 10 | 11 | print(elementos) 12 | print(len(elementos)) -------------------------------------------------------------------------------- /5.-Diccionarios/elementos.py: -------------------------------------------------------------------------------- 1 | diccionario = {'a': 1, 'b': 2, 'c': 3, 'd': 4} 2 | 3 | print('z' in diccionario) 4 | 5 | """ 6 | valor = diccionario['z'] 7 | print(valor) 8 | """ 9 | 10 | # get 11 | # setdefault 12 | valor = diccionario.setdefault('e', 5) 13 | 14 | print(valor) 15 | print(diccionario) -------------------------------------------------------------------------------- /5.-Diccionarios/eliminar.py: -------------------------------------------------------------------------------- 1 | diccionario = {'a': 1, 'b': 2, 'c': 3, 'd': 4} 2 | 3 | print(len(diccionario)) 4 | 5 | del diccionario['a'] # 1 6 | valor = diccionario.pop('b') # 2 7 | 8 | diccionario.clear() 9 | 10 | print(valor) 11 | 12 | print(diccionario) 13 | print(len(diccionario)) -------------------------------------------------------------------------------- /5.-Diccionarios/llaves.py: -------------------------------------------------------------------------------- 1 | diccionario = {'a': 1, 'b': 2, 'c': 3, 'd': 4} 2 | 3 | # keys 4 | # values 5 | # items 6 | 7 | llaves = tuple(diccionario.keys()) 8 | print(llaves) 9 | 10 | valores = tuple(diccionario.values()) 11 | print(valores) 12 | 13 | elementos = tuple(diccionario.items()) 14 | print(elementos) -------------------------------------------------------------------------------- /6.-Condiciones/anidados.py: -------------------------------------------------------------------------------- 1 | calificacion = 8 2 | 3 | if calificacion == 10: 4 | print('Felicidades, aprobaste con una calificación perfecta.') 5 | else: 6 | print('Reprobate la materia.') -------------------------------------------------------------------------------- /6.-Condiciones/booleanos.py: -------------------------------------------------------------------------------- 1 | """ 2 | False 3 | None 4 | 0 5 | 0.0 6 | '' / "" 7 | [] 8 | () 9 | {} 10 | """ -------------------------------------------------------------------------------- /6.-Condiciones/break.py: -------------------------------------------------------------------------------- 1 | titulo_curso = 'Curso profesional de Python' 2 | 3 | for caracter in titulo_curso: 4 | 5 | if caracter == 'P': 6 | continue # break 7 | 8 | print(caracter) -------------------------------------------------------------------------------- /6.-Condiciones/condiciones.py: -------------------------------------------------------------------------------- 1 | resultado = 15 2 | 3 | if resultado > 10 and resultado < 20: 4 | print('La variable cumple con la condición.') 5 | else: 6 | print('La condición no se cumplio :( ') -------------------------------------------------------------------------------- /6.-Condiciones/for.py: -------------------------------------------------------------------------------- 1 | usuarios = ['usuario1', 'usuario2', 'usuario3', 'usuario4'] 2 | 3 | for usuario in usuarios: 4 | print(usuario) 5 | -------------------------------------------------------------------------------- /6.-Condiciones/multiples.py: -------------------------------------------------------------------------------- 1 | calificacion = 4 2 | 3 | if calificacion == 10: 4 | print('Felicidades, aprobaste la materia con una calificación perfecta.') 5 | elif calificacion == 9 or calificacion == 8: 6 | print('Felicidades, aprobate la materia.') 7 | elif calificacion == 7 or calificacion == 6: 8 | print('Aprobaste la materia.') 9 | else: 10 | print('Reprobaste la materia.') -------------------------------------------------------------------------------- /6.-Condiciones/none.py: -------------------------------------------------------------------------------- 1 | resultado = None # Falso 2 | 3 | resultado = [1, 2, 3] 4 | 5 | print(resultado) 6 | print(type(resultado)) 7 | 8 | # True (1) / False (0) 9 | 10 | """ 11 | False 12 | None 13 | 0 14 | 0.0 15 | '' / "" 16 | [] 17 | () 18 | {} 19 | """ -------------------------------------------------------------------------------- /6.-Condiciones/range.py: -------------------------------------------------------------------------------- 1 | # start = 0, end, skips 2 | # for valor in range(5, 21, 3): 3 | # print(valor) 4 | 5 | numeros = [10, 20, 30, 40, 50] 6 | 7 | for indice, numero in enumerate(numeros): 8 | print(indice, numero) 9 | -------------------------------------------------------------------------------- /6.-Condiciones/ternario.py: -------------------------------------------------------------------------------- 1 | calificacion = 10 2 | 3 | color = 'Verde' if calificacion >= 7 else 'Rojo' 4 | 5 | print(calificacion, color) -------------------------------------------------------------------------------- /6.-Condiciones/while.py: -------------------------------------------------------------------------------- 1 | numero = 123456789 2 | contador_digitos = 0 3 | 4 | while numero >= 1: 5 | # contador_digitos = contador_digitos + 1 6 | contador_digitos += 1 7 | 8 | numero = numero / 10 9 | else: 10 | print(contador_digitos) -------------------------------------------------------------------------------- /7.-Funciones/__pycache__/documentar.cpython-37.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codigofacilito/curso-profesional-python/dd15621e2bcefc66f190eb364471ce2de4a03581/7.-Funciones/__pycache__/documentar.cpython-37.pyc -------------------------------------------------------------------------------- /7.-Funciones/anidadas.py: -------------------------------------------------------------------------------- 1 | def operacion(cantidad, balance, tipo='deposito'): 2 | 3 | def deposito(cantidad, balance): 4 | return cantidad + balance 5 | 6 | 7 | def retiro(cantidad, balance): 8 | 9 | if cantidad <= balance: 10 | return balance - cantidad 11 | else: 12 | return None 13 | 14 | print(id(cantidad)) 15 | print(id(balance)) 16 | 17 | if tipo == 'deposito': 18 | return deposito(cantidad, balance) 19 | elif tipo == 'retiro': 20 | return retiro(cantidad, balance) 21 | 22 | resultado = operacion(10, 30, 'retiro') 23 | print(resultado) -------------------------------------------------------------------------------- /7.-Funciones/argumentos.py: -------------------------------------------------------------------------------- 1 | def promedio(*args): # Tupla 2 | return sum(args) / len(args) 3 | 4 | 5 | def usuarios(**kwargs): # Dict 6 | print(kwargs) 7 | print(type(kwargs)) 8 | 9 | 10 | def combinacion(p1, p2, *args, **kwargs, p5=500): 11 | print(args) 12 | print(kwargs) 13 | 14 | 15 | combinacion(1, 2, 3, 4, 5, cody=True, curso='Python') -------------------------------------------------------------------------------- /7.-Funciones/callbacks.py: -------------------------------------------------------------------------------- 1 | promedio = lambda *args : sum(args) / len(args) 2 | 3 | aprobatorio = lambda calificacion : calificacion >= 7 4 | 5 | def es_aprobatorio(calificacion): 6 | return calificacion >= 90 7 | 8 | def mostrar_mensaje(func_promedio, func_aprobatorio, *args): 9 | promedio = func_promedio(*args) 10 | 11 | if func_aprobatorio(promedio): 12 | print(f'Felicidades, aprobaste la materia con {promedio}.') 13 | else: 14 | print('No aprobaste la materia.') 15 | 16 | 17 | mostrar_mensaje(promedio, aprobatorio, 10, 10, 8, 7, 7) -------------------------------------------------------------------------------- /7.-Funciones/closures.py: -------------------------------------------------------------------------------- 1 | def saludar(username): 2 | mensaje = f'Hola {username}' # Variable Local 3 | 4 | def mostrar_mensaje(): # Anidada 5 | print(mensaje) 6 | 7 | return mostrar_mensaje 8 | 9 | username = 'Cody' 10 | respuesta = saludar(username) 11 | 12 | username = 'Eduardo' 13 | 14 | respuesta() 15 | respuesta() 16 | respuesta() -------------------------------------------------------------------------------- /7.-Funciones/decoradores.py: -------------------------------------------------------------------------------- 1 | """ 2 | a -> La función principal (Decorador) 3 | b -> La función de decorar 4 | c -> La función decorada 5 | 6 | a(b) -> c 7 | """ 8 | 9 | def funcion_a(funcion_b): 10 | 11 | def funcion_c(*args, **kwargs): 12 | print('>>> Antes del llamado.') 13 | 14 | resultado = funcion_b(*args, **kwargs) 15 | 16 | print('>>> Después del llamado.') 17 | 18 | return resultado 19 | 20 | return funcion_c 21 | 22 | 23 | @funcion_a 24 | def suma(numero_1, numero_2): 25 | return numero_1 + numero_2 26 | 27 | resultado = suma(15, 60) 28 | print(resultado) -------------------------------------------------------------------------------- /7.-Funciones/documentar.py: -------------------------------------------------------------------------------- 1 | # Docstring 2 | # __doc__ (Módulos, Clases, Métodos y Funciones) 3 | 4 | def suma(numero_1, numero_2): 5 | """ 6 | La función suma 2 números enteros. 7 | 8 | Argumentos: 9 | numero_1 (int) 10 | numero_2 (int) 11 | 12 | Se retorna la suma de los parámetros. 13 | 14 | >>> suma(10, 20) 15 | 30 16 | 17 | >>> suma(100, 200) 18 | 300 19 | 20 | """ 21 | return numero_1 + numero_2 22 | 23 | 24 | def resta(numero_1, numero_2): 25 | """ 26 | >>> resta(100, 200) 27 | -100 28 | """ 29 | return numero_1 - numero_2 -------------------------------------------------------------------------------- /7.-Funciones/funciones.py: -------------------------------------------------------------------------------- 1 | def suma(n1, n2): 2 | return n1 + n2, 'La función retornar 2 valores' 3 | 4 | numero_uno = int(input('Ingresa el primer número entero: ')) # str 5 | numero_dos = int(input('Ingresa el segundo número entero: ')) 6 | 7 | resultado, _ = suma(numero_uno, numero_dos) 8 | 9 | print('El resultado es:', resultado) 10 | -------------------------------------------------------------------------------- /7.-Funciones/labmdas.py: -------------------------------------------------------------------------------- 1 | # lambda : 2 | 3 | funcion_grados = lambda grados : grados * 1.8 + 32 4 | 5 | print(funcion_grados(10)) 6 | 7 | """ 8 | sin_parametros = lambda : True 9 | paremtros_default = lambda p1=10, p2=20, p3=30 : p1 + p2 + p3 10 | asterisco = lambda *args, **kwargs: len(args) + len(kwargs) 11 | """ -------------------------------------------------------------------------------- /7.-Funciones/nonlocal.py: -------------------------------------------------------------------------------- 1 | e = 'e' # Variables global 2 | 3 | def funcion_principal(): 4 | a = 'a' # Variables locales 5 | b = 'b' 6 | 7 | def funcion_anidada(): 8 | c = 'c' # Variables locales 9 | 10 | nonlocal b 11 | b = 'Cambio de valor' 12 | 13 | print(a) 14 | print(b) 15 | print(id(b)) 16 | 17 | print(e) 18 | 19 | funcion_anidada() 20 | # print(c) 21 | print(b) 22 | print(id(b)) 23 | 24 | funcion_principal() -------------------------------------------------------------------------------- /7.-Funciones/parametros.py: -------------------------------------------------------------------------------- 1 | def area_circulo(radio, pi=3.14): 2 | return pi * (radio ** 2) 3 | 4 | resultado = area_circulo(pi=3.141592, radio=10) 5 | print(resultado) 6 | 7 | 8 | def operacion(cantidad, balance, tipo='deposito'): 9 | 10 | def deposito(cantidad, balance): 11 | return cantidad + balance 12 | 13 | def retiro(n1, n2): 14 | return cantidad - balance 15 | 16 | if tipo == 'deposito': 17 | return deposito(cantidad, balance) 18 | 19 | elif tipo == 'retiro': 20 | return deposito(cantidad, balance) 21 | 22 | # Por default las funciones en Python retornara None -------------------------------------------------------------------------------- /7.-Funciones/scope.py: -------------------------------------------------------------------------------- 1 | # Scope 2 | animal = 'León' # Variable Global -> Función, Condición o Ciclo 3 | 4 | def imprimir_animal(): 5 | global animal 6 | animal = 'Ballena' 7 | 8 | # animal = 'Ballena' # Variable Local 9 | 10 | tipo = 'Mamifero' # Variable Local 11 | 12 | print(animal) 13 | print(id(animal)) 14 | 15 | imprimir_animal() 16 | 17 | print(animal) 18 | print(id(animal)) 19 | -------------------------------------------------------------------------------- /8.-Clases/clases.py: -------------------------------------------------------------------------------- 1 | # Attrs de clase 2 | # Attrs de instancia 3 | 4 | class Usuario: 5 | 6 | # Object 7 | def __init__(self, username='', password=''): 8 | self.username = username 9 | self.password = password 10 | 11 | def saludar(self): 12 | mensaje = self.obtener_mensaje() 13 | print(mensaje) 14 | 15 | def obtener_mensaje(self): 16 | return f'Hola, {self.username} te saluda.' 17 | 18 | cody = Usuario('Cody') 19 | cody.saludar() -------------------------------------------------------------------------------- /8.-Clases/herencia.py: -------------------------------------------------------------------------------- 1 | class SerVivo: 2 | 3 | def dormir(self): 4 | print('El ser duerme.') 5 | 6 | class Animal(SerVivo): # Clase Padre 7 | 8 | def comer(self): 9 | print('El animal come.') 10 | 11 | class Mascota(Animal): # Clase Padre 12 | 13 | def comer(self): 14 | super().comer() 15 | print(type(super())) 16 | print('La mascota come.') 17 | 18 | class Felino: 19 | 20 | def cazar(self): 21 | print('El felino caza.') 22 | 23 | class Gato(Mascota, Felino): # Clase Hija 24 | 25 | def __init__(self, nombre): 26 | self.nombre = nombre 27 | 28 | def comer(self): 29 | super().comer() 30 | print(f'{self.nombre} come.') 31 | 32 | 33 | patricio = Gato('Patricio') 34 | 35 | patricio.comer() 36 | -------------------------------------------------------------------------------- /8.-Clases/main.py: -------------------------------------------------------------------------------- 1 | # 0 1 2 3 4 5 2 | tupla = ('String', 10, 15.4, True, [1, 2, 3], (4, 5, 6)) 3 | 4 | print(tupla) -------------------------------------------------------------------------------- /8.-Clases/metodos.py: -------------------------------------------------------------------------------- 1 | class Circulo: 2 | 3 | pi = 3.141592 4 | 5 | @classmethod 6 | def area(cls, radio): 7 | return cls.pi * (radio ** 2) 8 | 9 | resultado = Circulo.area(14) 10 | print(resultado) --------------------------------------------------------------------------------