miércoles, 25 de octubre de 2023
domingo, 1 de octubre de 2023
EJERCICIOS VARIOS DE PYTHON
Saludos a todos, les traigo unos ejercicio variados para practicar, pueden aplicar para exámenes.
Consta en la creación de 7 funciones, espero les sirva:
1. Obtener un número binario: recibe como argumento un número entero mayor ó igual a cero y lo devuelve en su representación binaria. Debe recibir y devolver un valor de tipo entero.
1
2
3
4
5
6 | def numeroBinario(numero):
if (isinstance(numero, int)) and numero>-1:
binario=format(numero,'b')
return int(binario)
else:
return None
|
2. Dividir y multiplicar números en listas: La función recibe como argumento una lista de números enteros, y debe retornar una lista con los siguientes parámetros:
- Los números que sean positivos y pares se deben dividir por 2, y el resultado expresado como entero (sin decimales, no redondeando, debe tomar sólo la parte entera de la división por 2).
- Los números negativos multiplicados por 2.
- Los que no cumplan los criterios anteriores deben quedar igual al valor original.
- Ordenar los números de mayor a menor.
Ej: dividirMultiplicar([2,4,1,-3]): debe retornar: [2, 1, 1, -6]
1
2
3
4
5
6
7
8
9
10
11 | def dividirMultiplicar(lista):
lista_entero = []
for i in lista:
if (i >= 0 and i%2 == 0):
lista_entero.append(i//2)
elif i<0:
lista_entero.append(i*2)
else:
lista_entero.append(i)
lista_entero.sort(reverse=True)
return lista_entero
|
3. Ordenar palabras: La función recibe como argumento una secuencia de palabras unidas por guiones, y debe retornar las mismas palabras, unidas por guiones, pero en orden alfabético. Si el argumento que se le pasa no es un string o no contiene guiones, debe retornar nulo.
EJ: ordenarPalabras('saco-libro-casa') debe retornar 'casa-libro-saco'
EJ: ordenarPalabras('Hola') debe retornar nulo
Pista: investigar métodos de string
1
2
3
4
5
6
7
8 | def ordenarPalabras(palabras):
if "-" not in palabras:
return None
palabras_separadas = palabras.split("-")
palabras_ordenadas = sorted(palabras_separadas)
resultado = "-".join(palabras_ordenadas)
return resultado
|
4. Triángulo rectángulo: La función debe recibir como argumentos el valor en cm de los lados de un triángulo (a y b son los catetos), y dado estos valores, retornar True si en efecto corresponden a un triángulo rectángulo, o False en caso contrario. Sólo se debe poder pasar valores enteros como argumentos de la función, caso contrario debe retornar nulo.
EJ: trianguloRectangulo(3.5,3.5,2.4), debe retornar nulo
EJ: trianguloRectangulo(3,3,3), debe retornar False
EJ: trianguloRectangulo(3,4,5), debe retornar True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25 | def trianguloRectangulo(a,b,c):
if (isinstance(a, int)==True and isinstance(b, int)==True and isinstance(c, int)==True):
if (a>b and a>c): # la hipotenusa es a
hipotenusa = a
cateto1 = b
cateto2 = c
elif (b>a and b>c): #la hipotenusa es b
hipotenusa = b
cateto1 = a
cateto2 = c
elif (c>a and c>b): # la hipotenusa es c
hipotenusa = c
cateto1 = a
cateto2 = b
else:
hipotenusa = a
cateto1 = b
cateto2 = c
if (hipotenusa**2 == cateto1**2 + cateto2**2 ):
return True
else:
return False
return None
|
5. Diccionario: La función recibe como argumento una lista de números enteros, y debe retornar un diccionario con tres claves, "multiplos3", 'cuadrados", "menores_promedio".
Para la clave "multiplos3", el valor debe ser una lista con los múltiplos de 3 de la lista original.
Para la clave "cuadrados", el valor debe ser una lista con los valores de la lista original elevados al cuadrado.
Para la clave "menores_promedio", el valor debe ser una lista con los valores menores al promedio de la lista original.
EJ: crearDiccionario([3,6,7,12]): debe retornar: {'multiplos3': [3, 6, 12], 'cuadrados': [9, 36, 49, 144], 'menores_promedio': [3, 6]}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 | def crearDiccionario(lista):
multiplos3=[]
cuadrados=[]
menores_promedio=[]
longitud_lista=len(lista)
suma_lista=sum(lista)
promedio_lista=suma_lista/longitud_lista
for numero in lista:
cuadrados.append(numero**2)
if numero%3==0:
multiplos3.append(numero)
if numero<promedio_lista:
menores_promedio.append(numero)
diccionario ={
'multiplos3':multiplos3,
'cuadrados':cuadrados,
'menores_promedio':menores_promedio
}
return diccionario
|
6. Diccionario adicional: Dado el siguiente diccionario ciudades, la función debe retornar una lista de listas, donde cada elemento de la lista sea una lista con el par ['ciudad', población], pero sólo de las ciudades que comiencen con la letra 'B', y como último elemento de la lista el par ['promedio', promedio de población] con el promedio de población de las ciudades seleccionadas.
ciudades = {
'São Paulo': 21048514,
'Buenos Aires': 14975587,
'Río de Janeiro': 11902701,
'Bogotá': 10777931,
'Lima': 10479899,
'Santiago de Chile': 7112808,
'Belo Horizonte': 6006091,
'Caracas': 5622798,
'Brasília': 4291577
}
Ej: Si se pidiera ciudades que comiencen con la letra 'S', debe devolver: [['São Paulo', 21048514], ['Santiago de Chile', 7112808],['promedio', 14080661.0]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14 | def ciudadesPoblacion(diccionario):
ciudades_B=[]
total_poblacion=0
for ciudad, poblacion in diccionario.items():
if ciudad.startswith('B'):
ciudades_B.append([ciudad,poblacion])
total_poblacion=total_poblacion+poblacion
promedio=total_poblacion/len(ciudades_B)
ciudades_B.append(["promedio",promedio])
return ciudades_B
|
Muchas gracias por la visita.
jueves, 11 de mayo de 2023
CONCEPTOS BÁSICOS DE JAVA: PROGRAMACION ORIENTADA A OBJETOS (POO)
- Clase
- Objeto
- Encapsulamiento
- Herencia
- Polimorfismo
- Asociación
- Composición
public class Persona {
private String nombre;
private int edad;
public Persona(String nombre, int edad) {//Constructor
this.nombre = nombre;
this.edad = edad;
}
public void saludar() {//método
System.out.println("Hola, soy " + nombre + " y tengo " + edad + " años.");
}
public static void main(String[] args) {//método
Persona persona1 = new Persona("Juan", 25);//Creación instancia de la clase Persona
System.out.println(persona1.nombre); // Imprime "Juan"
System.out.println(persona1.edad); // Imprime 25
persona1.saludar(); // Imprime "Hola, soy Juan y tengo 25 años."
}
}
El
método saludar imprime un mensaje de saludo utilizando los valores de nombre y edad.
En
el método main, se crea una instancia de la clase Persona llamada persona1,
pasando los valores "Juan" y 25 para el nombre y la edad,
respectivamente. Luego, se accede a los atributos nombre y edad de la
instancia y se llama al método saludar, que
muestra un mensaje en la consola.
OBJETO
Un objeto es una instancia concreta de una clase. Posee propiedades (atributos) y comportamientos (métodos) definidos por su clase. Los objetos representan entidades del mundo real y se utilizan para interactuar con el sistema.
public class Persona {
private String nombre;
private int edad;
public Persona(String nombre, int
edad) {
this.nombre = nombre;
this.edad = edad;
}
public void saludar() {
System.out.println("Hola, soy " + nombre + " y tengo " + edad + " años.");
}
public static void main(String[] args) {
Persona persona1 = new Persona("Juan", 25);
persona1.saludar(); // Imprime "Hola, soy Juan y tengo 25
años."
}
}
En
el método main, se crea una instancia de Persona llamada persona1
con los valores "Juan" y 25 para el nombre y la edad,
respectivamente. Luego, se llama al método saludar de persona1,
lo cual muestra un mensaje de saludo en la consola.
ENCAPSULAMIENTO
La encapsulación es un principio de la POO que consiste en ocultar los detalles internos de un objeto y exponer solo una interfaz para interactuar con él. Permite proteger los datos y asegurar que solo puedan ser accedidos y modificados a través de métodos definidos en la clase.
public class Persona {
private String nombre;
private int edad;
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
if (edad > 0) {
this.edad = edad;
} else {
System.out.println("La edad debe ser mayor que 0.");
}
}
}
En
este ejemplo, los atributos nombre y edad están definidos como privados, lo que
significa que solo se pueden acceder a ellos desde dentro de la clase Persona.
Para acceder a estos atributos desde fuera de la clase, se proporcionan métodos
públicos de acceso, conocidos como getters y setters.
Los
métodos getNombre y getEdad son getters, que devuelven el valor de los
atributos nombre y edad, respectivamente.
ABSTRACCIÓN: La
abstracción es el proceso de simplificar un objeto o sistema enfocándose solo
en los aspectos relevantes para un contexto determinado. Permite definir clases
y objetos que representen conceptos del dominio de manera abstracta, sin
considerar todos los detalles de implementación.
HERENCIA
La herencia es un mecanismo que permite crear nuevas clases basadas en clases existentes, heredando sus propiedades y comportamientos. La clase existente se denomina clase base o superclase, mientras que la nueva clase se denomina clase derivada o subclase. La herencia facilita la reutilización de código y la extensibilidad.
Volvemos a utilizar nuestra clase Persona la cuál sería la clase existente, por lo tanto es nuestra clase base(superclase)
class Persona {
private String nombre;
private int edad;
public Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
this.edad = edad;
}
public void saludar() {
System.out.println("Hola, soy " + nombre + " y tengo " + edad + " años.");
}
}
Aplicaremos la herencia utilizando la clase Estudiante la cual se denomina clase derivada o subclase.
class Estudiante extends Persona {
private String curso;
public Estudiante(String nombre, int edad, String curso) {
super(nombre, edad);
this.curso = curso;
}
public String getCurso() {
return curso;
}
public void setCurso(String curso) {
this.curso = curso;
}
public void estudiar() {
System.out.println("Estoy estudiando " + curso);
}
}
public class EjemploHerencia {
public static void main(String[] args) {
Estudiante estudiante = new Estudiante("Juan", 20, "Informática");
estudiante.saludar();
estudiante.estudiar();
}
}
Ejercicio: De acuerdo a lo estudiado a este punto, ¿Cuáles son las salidas que nos dará la implementación del código?
POLIMORFISMO
El polimorfismo permite que un objeto pueda tomar diferentes formas y
comportarse de manera distinta en diferentes contextos. Puede manifestarse a
través de la sobrecarga de métodos (mismos nombres, diferentes parámetros) o la
sobrescritura de métodos (implementaciones diferentes en las subclases).
public class Animal {
public void hacerSonido() {
System.out.println("El animal hace un sonido.");
}
}
public class Perro extends Animal {
@Override
public void hacerSonido() {
System.out.println("El perro ladra.");
}
}
public class Gato extends Animal {
@Override
public void hacerSonido() {
System.out.println("El gato maulla.");
}
}
public class EjemploPolimorfismo {
public static void main(String[] args) {
Animal animal1 = new Perro();
Animal animal2 = new Gato();
animal1.hacerSonido();
animal2.hacerSonido();
}
}
En este ejemplo, tenemos una clase base Animal con un método hacerSonido(). Las subclases Perro y Gato heredan de la clase Animal y sobrescriben el método hacerSonido() con su propia implementación.
En el método main(), creamos objetos de las subclases Perro y Gato pero los asignamos a variables de tipo Animal. Esto es posible debido al principio de polimorfismo en la programación orientada a objetos.
Al
llamar al método hacerSonido() en los objetos animal1 y animal2, se ejecutará
la implementación específica de cada subclase (Perro y Gato). Esto demuestra
cómo el mismo método puede comportarse de manera diferente dependiendo del tipo
de objeto al que se llama en tiempo de ejecución.
El
@Override es una anotación en Java que se utiliza para indicar que un método de
una subclase está sobrescribiendo un método de la clase base. Esta anotación es
opcional, pero se considera una buena práctica incluirla para mejorar la
legibilidad del código y evitar posibles errores.
ASOCIACIÓN
La asociación es una relación entre dos o más clases, donde cada clase conserva
su independencia. Puede haber asociaciones unidireccionales o bidireccionales,
y pueden ser de tipo uno a uno, uno a muchos o muchos a muchos.
public class Usuario {
private String nombre;
private int edad;
public Usuario(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
public String getNombre() {
return nombre;
}
public int getEdad() {
return edad;
}
}
public class Biblioteca {
private String nombre;
private Usuario[] usuarios;
public Biblioteca(String nombre) {
this.nombre = nombre;
this.usuarios = new Usuario[100];
}
public void agregarUsuario(Usuario usuario) {
// Lógica para agregar un usuario a la biblioteca
// Aquí se puede implementar la asociación entre Usuario y Biblioteca
}
public void mostrarUsuarios() {
// Lógica para mostrar los usuarios de la biblioteca
// Aquí se puede acceder a los datos de los usuarios asociados
}
}
public class EjemploAsociacion {
public static void main(String[] args) {
Usuario usuario1 = new Usuario("Juan", 25);
Usuario usuario2 = new Usuario("María", 30);
Biblioteca biblioteca = new Biblioteca("Biblioteca Central");
biblioteca.agregarUsuario(usuario1);
biblioteca.agregarUsuario(usuario2);
biblioteca.mostrarUsuarios();
}
}
En este ejemplo, las clases Usuario y Biblioteca están asociadas. La clase Usuario representa a un usuario con un nombre y una edad. La clase Biblioteca representa una biblioteca con un nombre y una lista de usuarios.
La asociación se establece a través del método agregarUsuario() en la clase Biblioteca. Este método permite agregar un usuario a la lista de usuarios de la biblioteca.
Mediante esta asociación, la clase Biblioteca puede acceder a los datos de los usuarios asociados y realizar operaciones relacionadas, como mostrar la lista de usuarios en el método mostrarUsuarios().
En
el método main(), creamos instancias de Usuario y una instancia de Biblioteca.
Luego, agregamos los usuarios a la biblioteca utilizando el método
agregarUsuario(). Finalmente, mostramos la lista de usuarios llamando al método
mostrarUsuarios() de la biblioteca.
Este ejemplo ilustra cómo las clases Usuario y Biblioteca están asociadas, permitiendo que la biblioteca gestione y acceda a los usuarios asociados.
COMPOSICIÓN
La composición es un tipo especial de asociación donde una clase contiene a
otras clases como parte de su estructura interna. La relación de composición es
más fuerte que la asociación, ya que las clases contenidas no existen de forma
independiente y su ciclo de vida está estrechamente ligado a la clase
contenedora.
public class Coche {
private String marca;
private Motor motor;
public Coche(String marca, String tipoMotor) {
this.marca = marca;
this.motor = new Motor(tipoMotor);
}
public String getMarca() {
return marca;
}
public String getTipoMotor() {
return motor.getTipo();
}
}
public class EjemploComposicion {
public static void main(String[] args) {
Coche coche = new Coche("Toyota", "Gasolina");
System.out.println("Marca: " + coche.getMarca());
System.out.println("Tipo de motor: " + coche.getTipoMotor());
}
}
En este ejemplo, la clase Coche tiene una composición con la clase Motor. Cada instancia de Coche contiene un objeto Motor como parte de su estructura interna.
La clase Motor representa el motor de un coche y tiene un atributo tipo que indica el tipo de motor.
La clase Coche tiene un atributo marca para indicar la marca del coche y un atributo motor que es una instancia de la clase Motor.
En el constructor de Coche, se crea una instancia de Motor pasando el tipo de motor como argumento y se asigna a la variable motor.
En el método main(), creamos un objeto Coche y obtenemos la marca y el tipo de motor llamando a los métodos getMarca() y getTipoMotor() respectivamente.
La
composición se refleja en el hecho de que un coche está compuesto por un motor.
El objeto Motor es creado y gestionado por la clase Coche, y forma parte
integral de la estructura del coche.
La salida del programa será:
Marca: Toyota
Tipo de motor: Gasolina
jueves, 4 de mayo de 2023
TO DO LIST(CRUD): JAVA+SPRINGBOOT+ MYSQL-PARTE I
Saludos a todos
Le solicitamos a ChatGPT que nos dijera cómo hacer un todo List utilizando Java, Spring Boot y MySQL y nos dio la siguiente lista de tareas las cuales iremos ejecutando y explicando a detalle.
Este ejercicio to do list nos permite realizar un CRUD: Create (Crear), Read (Leer), Update (Actualizar) y Delete (Borrar) información de una base de datos. Nos centraremos en el backend del ejercicio y en la segunda parte implementaremos el Front End de la aplicación.
Puedes ingresar al GITHUB y descarga aquí el código
- Crear un proyecto Spring Boot en el IDE de preferencia.
- CREACIÓN BD: Esta base de datos será creada con MySQL Workbench 8.0 y tendrá columnas: (id, titulo, descripción y fecha). Tener en cuenta el tipo de dato de cada atributo.
- CONEXIÓN BD: Se requiere conectarla a un servidor, en este caso sigo usando MySQL Server, el cuál está dentro de nuestro programa MySQL Workbench 8.0
- CONFIGURACION: Para la configuración de "application.properties". Tener presente que esta configuración sólo aplica para MySQL, si tienes otro gestor de BD debes consultar la configuración.
spring.datasource.url=jdbc:mysql://localhost:3306/todolist
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
spring.jpa.hibernate.ddl-auto=update
- Crear la entidad "Tarea" que representará las tareas en la base de datos.
package com.example.demo.Entity;
import jakarta.persistence.*;
import java.time.LocalDate;
@Entity
@Table(name = "todolist")
public class TodolistEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "titulo")
private String titulo;
@Column(name = "descripcion")
private String descripcion;
@Column(name = "fecha")
private LocalDate fecha;
public TodolistEntity(){
}
public TodolistEntity(String titulo, String descripcion, LocalDate fecha) {
this.titulo = titulo;
this.descripcion = descripcion;
this.fecha = fecha;
}
public String getTitulo() {
return titulo;
}
public void setTitulo(String titulo) {
this.titulo = titulo;
}
public String getDescripcion() {
return descripcion;
}
public void setDescripcion(String descripcion) {
this.descripcion = descripcion;
}
public LocalDate getFecha() {
return fecha;
}
public void setFecha(LocalDate fecha) {
this.fecha = fecha;
}
}
package com.example.demo.Repository;
import com.example.demo.Entity.TodolistEntity;
import org.springframework.data.jpa.repository.JpaRepository;
public interface TodolistRepository extends JpaRepository<TodolistEntity, Long> {
}
package com.example.demo.Controller;
import com.example.demo.Entity.TodolistEntity;
import com.example.demo.Repository.TodolistRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/tareas")
public class TodolistController {
@Autowired
private TodolistRepository todolistRepository;
@GetMapping("")
public List<TodolistEntity> mostrarTarea(){
return todolistRepository.findAll();
}
@PostMapping("")
public TodolistEntity crearTarea(@RequestBody TodolistEntity todolistEntity){
return todolistRepository.save(todolistEntity);
}
@PutMapping("/{id}")
public TodolistEntity actualizarTarea(@RequestBody TodolistEntity todolistEntity){
return todolistRepository.save(todolistEntity);
}
@DeleteMapping("/{id}")
public void eliminarTarea(@PathVariable Long id){
todolistRepository.deleteById(id);
}
}
miércoles, 19 de abril de 2023
PROYECTO: JAVA+SPRING BOOT+MYSQL+PHPMYADMIN
Hola a todos siguiendo con el proceso de desarrollo backend, les traigo este ejercicio que consta de mostrar una base de datos utilizando MYSQL+PHPMYADMIN+JAVA+SPRING BOOT.
- MYSQL y PHPMYADMIN: Crear una base de datos llamada empleado. Esta base debe tener los siguientes atributos: id, name, email,empresa,rol y agrega datos, los cuales son los que vamos a mostrar más adelante en nuestro navegador.
Puedes crear esta BD usando directamente MySQL o PHPMyAdmin, recuerda que esta configuración se hizo descargando XAMPP. (¿Qué diferencias notaste entre la creación de tablas entre MySQL y PHPMyAdmin?). Para poder utilizar el PHPMyAdmin debe estar corriendo nuestro servidor Apache.
3. JAVA: Utilizando el editor IntelliJ IDEA iniciamos revisando nuestro archivo pom.xml y verificando que todas nuestras dependencias hayan sido cargadas.
- Entity: Dentro de este package crea una clase llamada Empleado:
package com.example.demo.Entity;
import jakarta.persistence.*;
@Entity
@Table(name = "empleado")
public class Empleado {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long Id;
@Column(name = "name")
private String name;
@Column(name = "email")
private String email;
@Column(name = "empresa")
private String empresa;
@Column(name = "rol")
private String rol;
public Empleado(){
}
public Empleado(String name, String email, String empresa, String rol) {
this.name = name;
this.email = email;
this.empresa = empresa;
this.rol = rol;
}
public Long getId() {
return Id;
}
public void setId(Long id) {
Id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getEmpresa() {
return empresa;
}
public void setEmpresa(String empresa) {
this.empresa = empresa;
}
public String getRol() {
return rol;
}
public void setRol(String rol) {
this.rol = rol;
}
}
package com.example.demo.Repository;
import com.example.demo.Entity.Empleado;
import org.springframework.data.jpa.repository.JpaRepository;
public interface EmpleadoRepository extends JpaRepository<Empleado, Long> {
}
package com.example.demo.Controller;
import com.example.demo.Entity.Empleado;
import com.example.demo.Repository.EmpleadoRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
@RestController
@RequestMapping("/empleado")
public class Controllerempleado {
@Autowired
private EmpleadoRepository empleadoRepository;
@GetMapping
public List<Empleado> getAllEmpleados(){
return empleadoRepository.findAll();
}
}
spring.datasource.url=jdbc:mysql://localhost:3306/empleado?useSSL=false
spring.datasource.username=root
spring.datasource.password=password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
spring.jpa.hibernate.ddl-auto=update