├── Clase 1
└── esquema.png
├── Clase 2
└── Estructuras de Control.pdf
├── Clase 3
└── python_3.pdf
├── Codigo
├── .idea
│ ├── .gitignore
│ ├── Ejemplo01.iml
│ ├── inspectionProfiles
│ │ └── profiles_settings.xml
│ ├── misc.xml
│ └── modules.xml
├── CajeroAutomatico.py
├── Ejemplo03.py
├── EjemplosClass.py
├── EjemplosClass1.py
├── EjemplosClass2.py
├── EjemplosClass3.py
├── EjemplosClass4.py
├── EjemplosClass5.py
├── EjemplosClass6.py
├── EjemplosEncapsulacion.py
├── MapaFinal.py
├── Programa1.py
├── Programa2.py
├── Programa3.py
├── Programa4.py
├── Programa5.py
├── Programa6.py
├── celsiusafahrenheit.py
├── ejercicio10.py
├── ejercicio11.py
├── ejercicio12.py
├── ejercicio13.py
├── ejercicio14.py
├── ejercicio5.py
├── ejercicio6.py
├── ejercicio7.py
├── ejercicio8.py
├── ejercicio9.py
├── ingresesunombre.py
├── juego.py
├── listas.py
├── mensaje.py
└── randomMap.py
├── README.md
└── experimentacion
└── archivo_modificado.py
/Clase 1/esquema.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/XploOiD/Programacion-Basica/233857acf56da772bb1893d3859a88d8b656bafe/Clase 1/esquema.png
--------------------------------------------------------------------------------
/Clase 2/Estructuras de Control.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/XploOiD/Programacion-Basica/233857acf56da772bb1893d3859a88d8b656bafe/Clase 2/Estructuras de Control.pdf
--------------------------------------------------------------------------------
/Clase 3/python_3.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/XploOiD/Programacion-Basica/233857acf56da772bb1893d3859a88d8b656bafe/Clase 3/python_3.pdf
--------------------------------------------------------------------------------
/Codigo/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 | # Editor-based HTTP Client requests
5 | /httpRequests/
6 | # Datasource local storage ignored files
7 | /dataSources/
8 | /dataSources.local.xml
9 |
--------------------------------------------------------------------------------
/Codigo/.idea/Ejemplo01.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
--------------------------------------------------------------------------------
/Codigo/.idea/inspectionProfiles/profiles_settings.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/Codigo/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
--------------------------------------------------------------------------------
/Codigo/.idea/modules.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/Codigo/CajeroAutomatico.py:
--------------------------------------------------------------------------------
1 | #Cajero Automatico
2 |
3 | #Saldo inicial del usuario
4 |
5 | saldo = 1000
6 |
7 | #Funcion para consultar saldo
8 |
9 | def consultar_saldo():
10 | print(f"Su saldo actual es: ${saldo}")
11 |
12 | #Funcion para depositar dinero
13 |
14 | def depositar_dinero():
15 | global saldo #Declaramos que usaremos la variable global "saldo"
16 | cantidad= float(input("Ingrese la cantidad que desea depositar: $"))
17 | if cantidad > 0:
18 | saldo += cantidad #Aunmenta el saldo en la cantidad depositada
19 | print(f"Has depositado ${cantidad}. Su nuevo saldo es: ${saldo}")
20 | else:
21 | print("La cantidad debe ser mayor a 0.")
22 |
23 | #Funcion para retirar dinero
24 |
25 | def retirar_dinero():
26 | global saldo
27 | cantidad= float(input("Ingrese la cantidad que desea retirar: $"))
28 | if 0 < cantidad <= saldo:
29 | saldo -= cantidad
30 | print(f"Has retirado ${cantidad}. Su nuevo saldo es:${saldo}")
31 | elif cantidad > saldo:
32 | print("Fondos insuficientes")
33 | else:
34 | print("La cantidad debe ser mayor a 0.")
35 |
36 | # Funcion principal para mostrar el menú y realizar las operaciones
37 |
38 | def menu():
39 | while True:
40 | print("\nCajero Automatico")
41 | print("1.Consultar saldo")
42 | print("2.Depositar dinero")
43 | print("3.Retirar dinero")
44 | print("4.Salir")
45 |
46 | opcion = input("Seleccione una opcion: ")
47 | if opcion == "1":
48 | consultar_saldo()
49 | elif opcion == "2":
50 | depositar_dinero()
51 | elif opcion == "3":
52 | retirar_dinero()
53 | elif opcion == "4":
54 | print("Gracias por usar el cajero automatico.")
55 | break
56 | else:
57 | print("Opcion no valida.porfavor, intente de nuevo")
58 | #Llamar para iniciar el programa
59 | menu()
--------------------------------------------------------------------------------
/Codigo/Ejemplo03.py:
--------------------------------------------------------------------------------
1 | def main():
2 | # Pedir al usuario el número de alumnos
3 | while True:
4 | try:
5 | N = int(input("Ingrese el número de alumnos: "))
6 | if N <= 0:
7 | print("El número de alumnos debe ser mayor que 0.")
8 | continue
9 | break
10 | except ValueError:
11 | print("Por favor, ingrese un número entero válido.")
12 |
13 | # Crear una lista para almacenar la información de los alumnos
14 | alumnos = []
15 |
16 | for i in range(N):
17 | print(f"\nAlumno {i + 1}:")
18 | nombre = input("Ingrese el nombre del alumno: ").strip()
19 |
20 | while True:
21 | try:
22 | m = int(input("Ingrese la cantidad de cursos que está tomando: "))
23 | if m < 0:
24 | print("La cantidad de cursos no puede ser negativa.")
25 | continue
26 | break
27 | except ValueError:
28 | print("Por favor, ingrese un número entero válido.")
29 |
30 | cursos = []
31 | for j in range(m):
32 | curso = input(f"Ingrese el nombre del curso {j + 1}: ").strip()
33 | cursos.append(curso)
34 |
35 | # Añadir el alumno con su información a la lista
36 | alumnos.append({
37 | 'nombre': nombre,
38 | 'cursos': cursos
39 | })
40 |
41 | # Mostrar la información ingresada
42 | print("\nInformación de los alumnos:")
43 | for alumno in alumnos:
44 | print(f"\nNombre: {alumno['nombre']}")
45 | print("Cursos:")
46 | for curso in alumno['cursos']:
47 | print(f"- {curso}")
48 |
49 |
50 | if __name__ == "__main__":
51 | main()
52 |
53 |
--------------------------------------------------------------------------------
/Codigo/EjemplosClass.py:
--------------------------------------------------------------------------------
1 | class Galleta:
2 | pass
3 | galleta=Galleta()
4 | galleta.sabor= "Salado"
5 | galleta.color= "marron"
6 |
7 | print(f"El sabor de la galleta es {galleta.sabor}" f" y de color {galleta.color}")
8 |
--------------------------------------------------------------------------------
/Codigo/EjemplosClass1.py:
--------------------------------------------------------------------------------
1 | class Galleta:
2 | chocolate = False
3 | galleta = Galleta()
4 | if galleta.chocolate:
5 | print("La galleta tiene chocolate")
6 | else:
7 | print("La galleta no tiene chocolate")
--------------------------------------------------------------------------------
/Codigo/EjemplosClass2.py:
--------------------------------------------------------------------------------
1 | class Galleta:
2 | chocolate = False
3 |
4 | def saludar():
5 | print("Hola, soy una galleta de buen sabor")
6 |
7 | Galleta.saludar()
8 |
--------------------------------------------------------------------------------
/Codigo/EjemplosClass3.py:
--------------------------------------------------------------------------------
1 | class Galleta:
2 |
3 | def __init__(self) -> None:
4 | print("Galleta Horneada")
5 |
6 | galleta = Galleta()
7 |
--------------------------------------------------------------------------------
/Codigo/EjemplosClass4.py:
--------------------------------------------------------------------------------
1 | class Galleta:
2 |
3 | def __init__(self,sabor,color):
4 | self.sabor = sabor
5 | self.color = color
6 |
7 | def __str__(self):
8 | return f"Soy una galleta {self.color} y {self.sabor}."
9 |
10 | galleta = Galleta("Dulce","Blanca")
11 |
12 | print(galleta)
13 | print(str(galleta))
14 | print(galleta,str())
15 |
16 |
--------------------------------------------------------------------------------
/Codigo/EjemplosClass5.py:
--------------------------------------------------------------------------------
1 | class Cancion:
2 |
3 | def __init__(self,autor,titulo,duracion):
4 | self.duracion = duracion
5 |
6 |
7 | def __len__(self):
8 | return self.duracion
9 |
10 | cancion = Cancion("Metallica","Master of Puppets",220)
11 |
12 | print(len(cancion))
13 | print(cancion.__len__)
--------------------------------------------------------------------------------
/Codigo/EjemplosClass6.py:
--------------------------------------------------------------------------------
1 | class pelicula:
2 |
3 | #Constructor de clase
4 | def __init__(self,titulo,duracion,lanzamiento):
5 | self.titulo = titulo
6 | self.duracion = duracion
7 | self.lanzamiento = lanzamiento
8 |
9 |
10 | def __str__(self):
11 | return '{}({})'.format(self.titulo, self.lanzamiento)
12 |
13 | class Catalogo:
14 |
15 | peliculas = [] #Esta lista contendra objetos de la clase pelicula
16 |
17 | def __init__(self,peliculas=[]):
18 | self.peliculas = peliculas
19 |
20 | def agregar(self,p): #p sera un objeto de la pelicula
21 | self.peliculas.append(p)
22 |
23 | def mostrar(self):
24 | for p in self.peliculas:
25 | print('Se ha creado la pelicula:',p) #print toma por defecto str(p)
26 |
27 | p = pelicula("El padrino",175,1972)
28 | c = Catalogo([p]) #Añado una lista con una pelicula desde el principio
29 | c.mostrar()
30 | c.agregar(pelicula("El padrino: Parte 2",202,1974)) #añadimos otra
31 | c.mostrar()
--------------------------------------------------------------------------------
/Codigo/EjemplosEncapsulacion.py:
--------------------------------------------------------------------------------
1 | class Ejemplo:
2 | __atributo_privado = "Soy un atributo inalcanzable desde afuera."
3 |
4 | def __metodo_privado(self):
5 | print("Soy un metodo inalcanzable desde afuera.")
6 |
7 | def atributo_publico(self):
8 | return self.__atributo_privado
9 |
10 | def metodo_publico(self):
11 | return self.__metodo_privado()
12 |
13 | e = Ejemplo()
14 | print(e.atributo_publico())
15 | e.metodo_publico()
--------------------------------------------------------------------------------
/Codigo/MapaFinal.py:
--------------------------------------------------------------------------------
1 | import random
2 | from tkinter import *
3 |
4 | # Definimos los tipos de terreno
5 | TIPOS_DE_TERRITORIO = ['🏞', '🌊', '🌳', '⛰️'] # '🏞' = Tierra, '🌊' = Agua, '🌳' = Bosque, '⛰️' = Montaña
6 |
7 | class GeneradorDeMapa:
8 | """
9 | Clase que genera un mapa con terrenos aleatorios.
10 |
11 | Atributos:
12 | ancho (int): Ancho del mapa en celdas.
13 | alto (int): Alto del mapa en celdas.
14 | mapa (list): Lista bidimensional que representa el mapa generado.
15 | """
16 |
17 | def __init__(self, ancho, alto):
18 | """
19 | Inicializa el generador de mapas con las dimensiones especificadas.
20 |
21 | Parámetros:
22 | ancho (int): El número de columnas del mapa.
23 | alto (int): El número de filas del mapa.
24 | """
25 | self.ancho = ancho
26 | self.alto = alto
27 | self.mapa = self.generar_mapa()
28 |
29 | def generar_mapa(self):
30 | """
31 | Genera un mapa aleatorio de tipo de terrenos.
32 |
33 | Retorna:
34 | list: Una lista bidimensional que representa el mapa,
35 | donde cada celda tiene un tipo de terreno aleatorio.
36 | """
37 | mapa = []
38 |
39 | for i in range(self.alto):
40 | fila = []
41 | for j in range(self.ancho):
42 | terreno = random.choice(TIPOS_DE_TERRITORIO) # Elegimos un terreno aleatorio
43 | fila.append(terreno)
44 | mapa.append(fila)
45 |
46 | return mapa
47 |
48 | def mostrar_mapa(self):
49 | """
50 | Muestra el mapa de manera legible en la consola.
51 |
52 | Este método imprime el mapa en la consola, con los terrenos representados
53 | por sus respectivos símbolos.
54 | """
55 | for fila in self.mapa:
56 | print(' '.join(fila))
57 |
58 | class InterfazGrafica:
59 | """
60 | Clase que crea una interfaz gráfica para mostrar el mapa generado usando Tkinter.
61 |
62 | Atributos:
63 | generador (GeneradorDeMapa): Instancia del generador de mapas.
64 | root (Tk): Instancia de la ventana principal de Tkinter.
65 | """
66 |
67 | def __init__(self, generador):
68 | """
69 | Inicializa la interfaz gráfica para mostrar el mapa generado.
70 |
71 | Parámetros:
72 | generador (GeneradorDeMapa): El generador de mapas con los datos que se van a mostrar.
73 | """
74 | self.generador = generador
75 | self.root = Tk()
76 | self.root.title("Generador de Mapa")
77 |
78 | # Crear la interfaz gráfica
79 | self.crear_interfaz()
80 |
81 | def crear_interfaz(self):
82 | """
83 | Crea la interfaz gráfica para mostrar el mapa en una cuadrícula.
84 |
85 | Cada celda del mapa es representada por un `Label` con el símbolo del terreno y un color de fondo.
86 | """
87 | for i in range(self.generador.alto):
88 | for j in range(self.generador.ancho):
89 | terreno = self.generador.mapa[i][j]
90 | color = self.obtener_color(terreno)
91 | label = Label(self.root, text=terreno, width=4, height=2, bg=color, relief="solid")
92 | label.grid(row=i, column=j)
93 |
94 | def obtener_color(self, terreno):
95 | """
96 | Determina el color de fondo basado en el tipo de terreno.
97 |
98 | Parámetros:
99 | terreno (str): El tipo de terreno (🏞, 🌊, 🌳, ⛰️).
100 |
101 | Retorna:
102 | str: El color correspondiente al terreno.
103 | """
104 | if terreno == '🏞': # Tierra
105 | return 'saddlebrown'
106 | elif terreno == '🌊': # Agua
107 | return 'blue'
108 | elif terreno == '🌳': # Bosque
109 | return 'green'
110 | elif terreno == '⛰️': # Montaña
111 | return 'gray'
112 |
113 | def mostrar(self):
114 | """
115 | Muestra la ventana de Tkinter con el mapa generado.
116 |
117 | Este método inicia el ciclo de eventos de Tkinter para que la interfaz sea interactiva.
118 | """
119 | self.root.mainloop()
120 |
121 | # Usamos el generador de mapas
122 | ancho = 60 # Ancho del mapa
123 | alto = 30 # Alto del mapa
124 |
125 | generador = GeneradorDeMapa(ancho, alto)
126 |
127 | # Mostrar el mapa generado en consola
128 | print("Mapa Aleatorio:")
129 | generador.mostrar_mapa()
130 |
131 | # Crear la interfaz gráfica para mostrar el mapa
132 | interfaz = InterfazGrafica(generador)
133 | interfaz.mostrar()
--------------------------------------------------------------------------------
/Codigo/Programa1.py:
--------------------------------------------------------------------------------
1 | def main():
2 | # Pedir al usuario el número de alumnos
3 | while True:
4 | try:
5 | N = int(input("Ingrese el número de alumnos: "))
6 | if N <= 0:
7 | print("El número de alumnos debe ser mayor que 0.")
8 | continue
9 | break
10 | except ValueError:
11 | print("Por favor, ingrese un número entero válido.")
12 |
13 | # Crear una lista para almacenar la información de los alumnos
14 | alumnos = []
15 |
16 | for i in range(N):
17 | print(f"\nAlumno {i + 1}:")
18 | nombre = input("Ingrese el nombre del alumno: ").strip()
19 |
20 | while True:
21 | try:
22 | m = int(input("Ingrese la cantidad de cursos que está tomando: "))
23 | if m < 0:
24 | print("La cantidad de cursos no puede ser negativa.")
25 | continue
26 | break
27 | except ValueError:
28 | print("Por favor, ingrese un número entero válido.")
29 |
30 | cursos = []
31 | for j in range(m):
32 | curso = input(f"Ingrese el nombre del curso {j + 1}: ").strip()
33 | cursos.append(curso)
34 |
35 | # Añadir el alumno con su información a la lista
36 | alumnos.append({'nombre': nombre, 'cursos': cursos})
37 |
38 | # Mostrar la información ingresada
39 | print("\nInformación de los alumnos:")
40 | for alumno in alumnos:
41 | print(f"\nNombre: {alumno['nombre']}")
42 | print("Cursos:")
43 | for curso in alumno['cursos']:
44 | print(f"- {curso}")
45 |
46 |
47 | if __name__ == "__main__":
48 | main()
49 |
50 |
--------------------------------------------------------------------------------
/Codigo/Programa2.py:
--------------------------------------------------------------------------------
1 | def calcularNota(n1,n2,n3):
2 | return (n1*0.3 + n2*0.3 + n3*0.4)
3 | n1=float(input("Ingrese la primera nota : "))
4 | n2=float(input("Ingrese la segunda nota : "))
5 | n3=float(input("Ingrese la tercera nota : "))
6 |
7 | notaFinal=calcularNota(n1,n2,n3)
8 | print("La nota final es: ",notaFinal)
9 |
--------------------------------------------------------------------------------
/Codigo/Programa3.py:
--------------------------------------------------------------------------------
1 | def calcularIncremento(salario,x):
2 | nuevoSalario=salario + (salario*(x/100))
3 | return nuevoSalario
4 |
5 | salarioActual=float(input("Ingrese el salario actual del trabajador: "))
6 | incremento=float(input("Ingrese el porcentaje de incremento que tendra el salario del trabajador: "))
7 | nuevoSalario=calcularIncremento(salarioActual,incremento)
8 | print("El nuevo salario del trabajador es: ", nuevoSalario)
9 |
--------------------------------------------------------------------------------
/Codigo/Programa4.py:
--------------------------------------------------------------------------------
1 | nombre = input("¿Como te llamas? ")
2 | n = input("Introduce un numero entero: ")
3 | print((nombre + "\n") * int(n))
4 |
--------------------------------------------------------------------------------
/Codigo/Programa5.py:
--------------------------------------------------------------------------------
1 | nombre = input("¿Como te llamas?\n ")
2 | print(nombre.upper()+" tiene "+str(len(nombre))+ " letras ")
3 |
--------------------------------------------------------------------------------
/Codigo/Programa6.py:
--------------------------------------------------------------------------------
1 | email = input("Introduce tu correo electronico: ")
2 | print(email[:email.find('@')]+'@ceu.es')
3 |
--------------------------------------------------------------------------------
/Codigo/celsiusafahrenheit.py:
--------------------------------------------------------------------------------
1 | #Solicitar al usuario ingresar la temperatura en grados Celsius
2 | celsius_str = input("Ingresa la temperatura en grados Celsius:")
3 |
4 | #Convertir el valor ingresado a un numéro flotate
5 | celsius = float(celsius_str)
6 |
7 | #Realizar la conversión de temperatura a grados Fahrenheit
8 | fahrenheit = (celsius * 9/5) + 32
9 |
10 | #Imprimir el resultado de la conversión
11 | print("La temperatura en grados Fahrenheit es:", fahrenheit)
12 |
--------------------------------------------------------------------------------
/Codigo/ejercicio10.py:
--------------------------------------------------------------------------------
1 | #Solicito al usuario el numero de ondas
2 | waves = int(input("Ingrese un numero: "))
3 | #Generar el Patron de Ondas
4 | for _ in range(3):
5 | for _ in range(waves):
6 | print("~", end="")
7 | print()
8 | for _ in range(2):
9 | print("~", end="")
10 | print()
--------------------------------------------------------------------------------
/Codigo/ejercicio11.py:
--------------------------------------------------------------------------------
1 | #Define la cantidad de puntos de tu linea
2 | length = int(input("Ingrese la longitud de la linea de puntos: "))
3 | direction = input("Horizontal(h) o Vertical(v): ").lower()
4 |
5 | if direction == "h":
6 | print("#" * length)
7 | elif direction == "v":
8 | for _ in range(length):
9 | print("#")
10 | else:
11 | print("Direccion no valida.")
12 |
--------------------------------------------------------------------------------
/Codigo/ejercicio12.py:
--------------------------------------------------------------------------------
1 | size = 7
2 | for i in range(size):
3 | line = ""
4 | for j in range(size):
5 | if i == 0 or i == size-1 or j == 0 or j == size-1:
6 | line += "*"
7 | elif i == 1 or i == size-2 or j == 1 or j == size-2:
8 | line += "+"
9 | else:
10 | line += ""
11 | print(line)
12 |
--------------------------------------------------------------------------------
/Codigo/ejercicio13.py:
--------------------------------------------------------------------------------
1 | import random
2 | symbols = ["#","*","@","&"]
3 | for y in range(10):
4 | line = ""
5 | for x in range(10):
6 | line += random.choice(symbols) + ""
7 | print(line)
--------------------------------------------------------------------------------
/Codigo/ejercicio14.py:
--------------------------------------------------------------------------------
1 | def introduction(first_name, last_name):
2 | print("Hola, mi nombre es", first_name, last_name)
3 |
4 | introduction("Luke","Skywalker")
5 | introduction("Jesse","Quick")
6 | introduction("Clark","Kent")
7 |
8 | introduction(first_name="James",last_name="Bond")
9 | introduction(last_name="Skywalker",first_name="Luke")
--------------------------------------------------------------------------------
/Codigo/ejercicio5.py:
--------------------------------------------------------------------------------
1 | #Definir la lcase persona
2 | class persona:
3 | #Contructor de la clase
4 | def __init__(self,nombre,edad):
5 | self.nombre = nombre
6 | self.edad = edad
7 |
8 | #Metodo para mostrar la informacion de la persona
9 | def mostrar_informacion(self):
10 | print(f"Nombre:{self.nombre},Edad:{self.edad}")
11 |
12 |
13 | #metodo para verificar si es mayor de edad
14 | def es_mayor_de_edad(self):
15 | if self.edad >= 18:
16 | return True
17 | else:
18 | return False
19 |
20 | #Crear una instancia de la clase persona
21 | persona1 = persona("Carlos",16)
22 |
23 | #Llamar al metado para mostrar la informacion
24 | persona1.mostrar_informacion()
25 |
26 | #Comprobar si la persona es mayor de edad
27 | if persona1.es_mayor_de_edad():
28 | print(f"{persona1.nombre} es mayor de edad.")
29 | else:
30 | print(f"{persona1.nombre} no es mayor de edad")
31 |
--------------------------------------------------------------------------------
/Codigo/ejercicio6.py:
--------------------------------------------------------------------------------
1 |
2 |
3 | class Auto:
4 | marca = ""
5 | modelo = 2004
6 | placa = ""
7 |
8 | taxi = Auto()
9 | print(taxi.modelo)
10 |
--------------------------------------------------------------------------------
/Codigo/ejercicio7.py:
--------------------------------------------------------------------------------
1 | class Empleado:
2 | def __init__(self,nombre,salario_mensual):
3 | self.nombre = nombre
4 | self.salario_mensual = salario_mensual
5 | #Metodo para calcular el salario mensual
6 | def calcular_salario_anual(self):
7 | return self.salario_mensual * 12
8 | #Metodo para mostrar la informacion del empleado
9 | def mostrar_informacion(self):
10 | print(f"Empleado:{self.nombre},Salario mensual:{self.salario_mensual}")
11 | #Crear instancia
12 | empleado1 = Empleado("Ana",2000)
13 |
14 | empleado1.mostrar_informacion()
15 | print(f"Salario Anual:{empleado1.calcular_salario_anual()}")
16 |
17 |
18 |
19 |
--------------------------------------------------------------------------------
/Codigo/ejercicio8.py:
--------------------------------------------------------------------------------
1 | import random
2 |
3 | # Dimensiones de la cuadrícula
4 | filas = 10
5 | columnas = 10
6 |
7 | # Crear una cuadrícula vacía
8 | cuadricula = [[' ' for _ in range(columnas)] for _ in range(filas)]
9 |
10 | # Número de puntos a dibujar
11 | num_puntos = random.randint(5, 20)
12 |
13 | # Colocar puntos aleatorios en la cuadrícula
14 | for _ in range(num_puntos):
15 | x = random.randint(0, filas - 1)
16 | y = random.randint(0, columnas - 1)
17 | cuadricula[x][y] = '.'
18 |
19 | # Dibujar la cuadrícula
20 | for fila in cuadricula:
21 | print(' '.join(fila))
--------------------------------------------------------------------------------
/Codigo/ejercicio9.py:
--------------------------------------------------------------------------------
1 | import random
2 |
3 | for y in range(10):
4 | line = "."
5 | for x in range(10):
6 | if random.choice([True,False]):
7 | line += "."
8 | else:
9 | line += ""
10 | print(line)
--------------------------------------------------------------------------------
/Codigo/ingresesunombre.py:
--------------------------------------------------------------------------------
1 | #Solicitar al usuario que ingrese su nombre
2 | nombre = input("Por favor, ingresa tu nombre:")
3 |
4 | #Imprimir un saludo personalizado
5 | print("hola",nombre,"!Bienvenido a Phyton.")
--------------------------------------------------------------------------------
/Codigo/juego.py:
--------------------------------------------------------------------------------
1 | import random
2 |
3 | # Define the character class
4 | class Character:
5 | def __init__(self, name, health, attack):
6 | self.name = name
7 | self.health = health
8 | self.attack = attack
9 |
10 | def is_alive(self):
11 | return self.health > 0
12 |
13 | def take_damage(self, damage):
14 | self.health -= damage
15 | if self.health < 0:
16 | self.health = 0
17 |
18 | def attack_enemy(self, enemy):
19 | print(f"{self.name} attacks {enemy.name} for {self.attack} damage.")
20 | enemy.take_damage(self.attack)
21 | print(f"{enemy.name} has {enemy.health} health left.")
22 |
23 | # Define the player class
24 | class Player(Character):
25 | def __init__(self, name):
26 | super().__init__(name, health=100, attack=10)
27 |
28 | def heal(self):
29 | heal_amount = random.randint(10, 30)
30 | self.health += heal_amount
31 | print(f"{self.name} heals for {heal_amount}. Health is now {self.health}.")
32 |
33 | # Define the enemy class
34 | class Enemy(Character):
35 | def __init__(self, name, health, attack):
36 | super().__init__(name, health, attack)
37 |
38 | # Game logic
39 | def battle(player, enemy):
40 | while player.is_alive() and enemy.is_alive():
41 | player.attack_enemy(enemy)
42 | if enemy.is_alive():
43 | enemy.attack_enemy(player)
44 | print() # Empty line for better readability
45 |
46 | def main():
47 | print("Welcome to the RPG Game!")
48 |
49 | # Create player
50 | player_name = input("Enter your character's name: ")
51 | player = Player(player_name)
52 |
53 | # Create enemies
54 | enemies = [
55 | Enemy("Goblin", health=30, attack=5),
56 | Enemy("Orc", health=50, attack=7),
57 | Enemy("Dragon", health=80, attack=15)
58 | ]
59 |
60 | # Main game loop
61 | for enemy in enemies:
62 | print(f"A wild {enemy.name} appears!")
63 | battle(player, enemy)
64 | if not player.is_alive():
65 | print("You have been defeated. Game Over!")
66 | break
67 | else:
68 | print(f"You defeated the {enemy.name}!")
69 | player.heal()
70 | print() # Empty line for better readability
71 |
72 | if player.is_alive():
73 | print("Congratulations! You have defeated all enemies!")
74 |
75 | if __name__ == "__main__":
76 | main()
--------------------------------------------------------------------------------
/Codigo/listas.py:
--------------------------------------------------------------------------------
1 | #LISTAS: son colecciones ordenadas y modificables de elementos. Pueden conterner elementos de diferentes tipos de datos y se definen
2 | #Lista de numeros
3 | numeros = [1, 2, 3, 4, 5]
4 | #Lista de cadenas de texto
5 | nombres = ["Juan", "María", "Pedro"]
6 |
7 | #Lista mixta
8 | mixta = [1, "Hola", True, 3.14]
9 | #Acceder a elementos de una Lista
10 | print(numeros[0]) #Imprime el primer elemento de la lista de numeros
11 | print(nombres[-1]) #Imprime el ultimo elemento de la lista de nombres al poner - quiere decir ultimo -2 penultimo y asi sucesivamente
12 |
13 | #TUPLAS son colecciones ordenadas e inmutables de elementos. A diferencia de las listas, una vez creadas, no se pueden modificar.
14 | #Tupla de numeros
15 | coordenadas = (10, 20)
16 |
--------------------------------------------------------------------------------
/Codigo/mensaje.py:
--------------------------------------------------------------------------------
1 | #Funciones
2 | #Se define una funcion saludar() y se la utiliza para crear un
3 | #mensaje de saludo personalizado
4 |
5 | def saludar(nombre):
6 | return "!Hola," + nombre + "!"
7 |
8 | mensaje_saludo = saludar("Estudiante")
9 |
10 | #Manejo de Errores
11 | try:
12 | resultado_division = 0 / 0
13 | except ZeroDivisionError:
14 | print("¡Error! No se puede dividir por cero.")
15 | finally:
16 | print("Bloque 'finally': Este código se ejecuta siempre, haya o no haya errores.")
17 |
18 | #Trabajo con Archivos
19 | with open("archivo.txt", "w") as archivo:
20 | archivo.write("¡Hola desde un archivo!")
21 |
22 |
23 |
--------------------------------------------------------------------------------
/Codigo/randomMap.py:
--------------------------------------------------------------------------------
1 | import random
2 |
3 | # Definimos los tipos de terreno
4 | TIPOS_DE_TERRITORIO = ['T', 'W', 'F', 'M'] # 'T' = Tierra, 'W' = Agua, 'F' = Bosque, 'M' = Montaña
5 |
6 | class GeneradorDeMapa:
7 | def __init__(self, ancho, alto):
8 | self.ancho = ancho
9 | self.alto = alto
10 | self.mapa = self.generar_mapa()
11 |
12 | def generar_mapa(self):
13 | # Creamos una matriz vacía para el mapa
14 | mapa = []
15 |
16 | # Llenamos la matriz con terrenos aleatorios
17 | for i in range(self.alto):
18 | fila = []
19 | for j in range(self.ancho):
20 | terreno = random.choice(TIPOS_DE_TERRITORIO) # Elegimos un terreno aleatorio
21 | fila.append(terreno)
22 | mapa.append(fila)
23 |
24 | return mapa
25 |
26 | def mostrar_mapa(self):
27 | # Mostrar el mapa de manera legible
28 | for fila in self.mapa:
29 | print(' '.join(fila))
30 |
31 | # Usamos el generador de mapas
32 | ancho = 10 # Ancho del mapa
33 | alto = 6 # Alto del mapa
34 |
35 | generador = GeneradorDeMapa(ancho, alto)
36 |
37 | # Mostrar el mapa generado
38 | print("Mapa Aleatorio:")
39 | generador.mostrar_mapa()
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/XploOiD/Programacion-Basica/233857acf56da772bb1893d3859a88d8b656bafe/README.md
--------------------------------------------------------------------------------
/experimentacion/archivo_modificado.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/XploOiD/Programacion-Basica/233857acf56da772bb1893d3859a88d8b656bafe/experimentacion/archivo_modificado.py
--------------------------------------------------------------------------------