CURSO:

Programación Orientada a Objetos

PROYECTO:
Tarea Académica I

Integrantes:
Pashanaste Ramirez, Johan Xander
Escamilo Mendoza, Richard Manuel
Calisaya Bendezú, Elmer Josué

Docente:
Rosa Abregú

Lima-Perú

2023

pág. 1
 Índice
I. Introducción.........................................................................................................................3
II. Desarrollo...........................................................................................................................4
1. Lenguaje de Programación Python.....................................................................................4
1.1 Clases persistentes con Python.....................................................................................4
Ejercicio 1: Crear una Clase Persistente simple..............................................................5
Ejercicio 2: Uso de shelvepara persistencia de datos......................................................6
2. Lenguaje de Programación C#............................................................................................6
2.1 Clases Persistentes con C#............................................................................................7
Ejercicio 1: Crear una Clase Persistente en C#...............................................................8
Ejercicio 2: Serialización Binaria con BinaryFormatter.................................................9
3. Lenguaje de Programación Scala......................................................................................11
3.2 Clases persistentes con Scala......................................................................................11
Ejercicio 1: Serialización con Serializable....................................................................12
Ejercicio 2: Decapado con scala.decapado...................................................................13
III. Conclusión......................................................................................................................14
Bibliografía...........................................................................................................................15

pág. 2
I. Introducción
En la presente tarea académica se explicará la aplicación de la persistencia a través de
clases persistentes en los programas siguientes: C#, Python y Scala. Detallando que se
llama persistencia a la capacidad de un objeto para existir fuera de un programa, proceso,
función o hilo de control; de manera que se conserva su estado y su comportamiento. Esto
quiere decir que la persistencia hace que la información de un programa sea capaz de
guardarse para volver a utilizarse en otro momento.
Es lo que los usuarios conocen como Guardar el archivo y después Abrir el archivo. Para la
programación puede significar más cosas y suele involucrar un proceso de serialización de
los datos a un archivo o a una base de datos o a algún otro medio similar, y el proceso
inverso de recuperar los datos a partir de la información serializada

pág. 3
II. Desarrollo
La capa de persistencia está formada por un conjunto de clases y
componentes responsables del almacenamiento y recuperación de datos, a y desde una o
más fuentes de datos. Esta capa, necesariamente incluye un modelo de las entidades del
modelo del negocio.
Las clases persistentes, por lo tanto, son clases situadas en la capa de persistencia que
implementan las entidades del negocio del problema. El término clase
persistente no implica que una clase es persistente. Es más, significa que los objetos de esa
clase y su estado son gestionados por el servicio de persistencia

1. Lenguaje de Programación Python

Es un lenguaje de programación creado por Guido van Rossum a principios de los años 90.
Se trata de un lenguaje interpretado o de script, con tipado dinámico, fuertemente tipado,
multiplataforma y orientado a objetos. Un lenguaje interpretado o de script es aquel que se
ejecuta utilizando un programa intermedio llamado intérprete, en lugar de compilar el
código a lenguaje máquina que pueda comprender y ejecutar directamente una
computadora (lenguajes compilados). Python tiene muchas de las características de los
lenguajes compilados, por lo que se podría decir que es semi interpretado, esto quiere decir
que el código fuente se traduce a un pseudo código máquina intermedio llamado bytecode
la primera vez que se ejecuta, generando archivos .pyc o. pyo que son los que se ejecutarán
en sucesivas ocasiones.

1.1 Clases persistentes con Python

En programación, las clases son estructuras fundamentales para organizar y encapsular
código. Las clases persistentes son aquellas que mantienen su estado incluso después de
que el programa se haya cerrado. En Python, podemos implementar clases persistentes
utilizando técnicas como la serialización y la deserialización. Una clase en Python es una
plantilla a partir de la cual se instancian los objetos, y define que atributos y métodos
tendrán los objetos de esa clase. Se definen usando la palabra clave class, seguido del
nombre de la clase y dos puntos (:)
Ejemplo:
class Humano(): //Creamos la clase Humano
def __init__(self, edad, nombre): //Definimos el atributo edad y nombre
self.edad = edad // Definimos que el atributo edad, será la edad asignada
self.nombre = nombre // Definimos que el atributo nombre, será el nombre asignado
Persona1 = Humano(31, "Pedro") //Instancia

pág. 4
Serialización y Deserialización:

 La serialización es el proceso de convertir un objeto en una secuencia de

bytes.
 La deserialización es el proceso inverso, donde convertimos la secuencia de
bytes de vuelta a un objeto.
Persistencia de Datos:

 La persistencia de datos implica guardar y cargar el estado de un objeto para

que pueda sobrevivir a la terminación del programa.
Módulos relevantes:

 En Python, los módulos como pickleo shelveson utilizados para la

serialización de objetos y para implementar la persistencia de datos.
Ejercicio 1: Crear una Clase Persistente simple
import pickle

class Persona:
def __init__(self, nombre, edad):
self.nombre = nombre
self.edad = edad

# Serializar la instancia de Persona

mi_persona = Persona("Juan", 30)
with open("persona.pickle", "wb") as archivo:
pickle.dump(mi_persona, archivo)

# Deserializar la instancia de Persona

with open("persona.pickle", "rb") as archivo:
persona_recuperada = pickle.load(archivo)

print(f"Nombre: {persona_recuperada.nombre}, Edad: {persona_recuperada.edad}")

pág. 5
Ejercicio 2: Uso de shelvepara persistencia de datos
import shelve

class Libro:
def __init__(self, titulo, autor):
self.titulo = titulo
self.autor = autor

# Guardar un libro usando shelve

with shelve.open("biblioteca") as biblioteca:
libro = Libro("Python 101", "Guido van Rossum")
biblioteca["libro1"] = libro

# Recuperar el libro
with shelve.open("biblioteca") as biblioteca:
libro_recuperado = biblioteca["libro1"]

print(f"Título: {libro_recuperado.titulo}, Autor: {libro_recuperado.autor}")

2. Lenguaje de Programación C#
C# o C Sharp es un lenguaje de programación creado por Microsoft. Fue creado en el año
2000. Este lenguaje nació con todas las herramientas que contaban sus principales rivales
de esa época; C++ y Java. Nació como un lenguaje orientado objetos, que en ese momento
estaba en auge, como una de las herramientas más poderosas de desarrollo de software y
aún lo sigues siendo, ya que esta forma de trabajo nos permite reutilizar grandes cantidades
de códigos así pudiendo crear nuestras propias herramientas a través de las famosas clases.
C# tiene sus orígenes en la familia de lenguajes C y su primera versión, se parecía mucho a
Java. De hecho, se creó con el fin de ser una alternativa viable en este en Windows. Muchas
de sus características fueron evolucionando y mejorando hasta llegar a la versión actual.
Ahora el lenguaje de C# admite los conceptos de encapsulación, herencia polimorfismo y
facilita el desarrollo de componentes de software mediante varias construcciones de
lenguaje innovadoras.

pág. 6
2.1 Clases Persistentes con C#
Una clase es un molde del que luego se pueden crear múltiples objetos, con similares
características. Una clase es una estructura de datos que combina estados (campos) y
acciones (métodos y otros miembros de función) en una sola unidad. Una clase proporciona
una definición para instancias de la clase, también conocidas como objetos. Las clases
admiten herencia y polimorfismo, mecanismos por los que las clases derivadas pueden
extender y especializar clases base.. En C#, las clases persistentes implican la capacidad de
almacenar y recuperar el estado de los objetos para que persistan más allá del tiempo de
ejecución del programa. La serialización y deserialización son conceptos clave en este
contexto.
Ejemplo:
class Cliente
{
private string nombre;
private int monto;
public Cliente(string nom)
{
nombre = nom;
monto = 0;
}
public void Depositar(int m)
{
monto = monto + m;
}
public void Extraer(int m)
{
monto = monto - m;
}
public int RetornarMonto()
{

pág. 7
 return monto;
}
public void Imprimir()
{
Console.WriteLine(nombre + " tiene depositado la suma de " + monto);
}
}
Serialización y Deserialización:

 Serialización: Convertir objetos en un formato que pueda ser almacenado o

transmitido.
 Deserialización: Reconstruir objetos a partir del formato serializado.

Persistencia de datos en C#:

 C# ofrece el espacio de nombres System.Runtime.Serializationpara facilitar

la serialización y deserialización de objetos.
Atributos:

 Utilizamos el atributo [Serializable]para indicar que una clase puede ser

serializada.
Ejemplos y Resolución de Ejercicios:

 El uso de atributos de datos como [DataMember]puede controlar qué miembros de

una clase deben ser serializados.
Ejercicio 1: Crear una Clase Persistente en C#
using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

[Serializable]
class Persona
{

pág. 8
 public string Nombre { get; set; }
public int Edad { get; set; }
}

class Program
{
static void Main()
{
// Serializar la instancia de Persona
Persona miPersona = new Persona { Nombre = "Maria", Edad = 25 };

IFormatter formatter = new BinaryFormatter();

using (Stream stream = new FileStream("persona.dat", FileMode.Create,
FileAccess.Write))
{
formatter.Serialize(stream, miPersona);
}

// Deserializar la instancia de Persona

using (Stream stream = new FileStream("persona.dat", FileMode.Open,
FileAccess.Read))
{
Persona personaRecuperada = (Persona)formatter.Deserialize(stream);
Console.WriteLine($"Nombre: {personaRecuperada.Nombre}, Edad:
{personaRecuperada.Edad}");
}
}
}

pág. 9
Ejercicio 2: Serialización Binaria con BinaryFormatter
using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

[Serializable]
class Libro
{
public string Titulo { get; set; }
public string Autor { get; set; }
}

class Program
{
static void Main()
{
Libro miLibro = new Libro { Titulo = "C# 101", Autor = "John Doe" };

// Serializar la instancia de Libro

BinaryFormatter formatter = new BinaryFormatter();
using (FileStream fs = new FileStream("libro.dat", FileMode.Create))
{
formatter.Serialize(fs, miLibro);
}

// Deserializar la instancia de Libro

using (FileStream fs = new FileStream("libro.dat", FileMode.Open))
{

pág. 10
 Libro libroRecuperado = (Libro)formatter.Deserialize(fs);
Console.WriteLine($"Título: {libroRecuperado.Titulo}, Autor:
{libroRecuperado.Autor}");
}
}
}

3. Lenguaje de Programación Scala

Scala es un lenguaje de programación qué es multiparadigma, es decir, que implementa a la
vez varios paradigmas de programación. Está basado en Java, pero es más conciso, porque
no se tendrá que escribir demasiado en este lenguaje. También es un lenguaje orientado a
objetos donde podemos encontrar lo tradicional en POO, como clases, paquetes, módulos,
polimorfismo, herencia, etc. Y a la vez, funcional ya que, trata a las funciones como
ciudadanos de primera clase. Soporta funciones anónimas lambdas, patrones, etc.

3.2 Clases persistentes con Scala

En Scala, las clases persistentes se pueden implementar utilizando diferentes enfoques,
siendo la serialización uno de los métodos más comunes. Scala proporciona facilidades
para la serialización a través de bibliotecas como java.io.Serializabley scala.pickling. Una
clase en Scala es una plantilla definida por el programador a partir del cual se crean objetos
combinando los campos y métodos en una sola unidad. En una clase se usa un constructor
para inicializar nuevos objetos, los campos son variables que proporcionan el estado de la
clase y sus objetos, y se usan métodos para implementar el comportamiento de la clase y
sus objetos. Las clases en Scala no se declaran como públicas y puede haber varias clases
en un archivo fuente de Scala.
Por ejemplo
// Un programa de Scala para mostrar en pantalla
// Como crear una clase
// Nombre de la clase es Smartphone class Smartphone
{
// Class variables
var number: Int = 24
var nomEmp: String = "Samsung"
def Display()

pág. 11
 {
println("Nombre de la empresa : " + nomEmp);
println("Total de modelos lanzados: " + number);
}
}
object Main
{
// Main method def main(args: Array[String])
{

// Class object
var obj = new Smartphone();
obj.Display();
}
}
Serializable en Scala:

 La interfaz java.io.Serializablese utiliza para marcar clases como

serializables. Esta interfaz no tiene métodos para implementar, simplemente indica
que la clase puede ser serializada.
Decapado en Scala:

 Pickling es un concepto en Scala que se refiere a la serialización y

deserialización de datos. La biblioteca scala.picklingproporciona una forma de
realizar decapado en Scala.
Ejercicio 1: Serialización con Serializable
import java.io._

class Persona(val nombre: String, val edad: Int) extends Serializable

object Main extends App {

pág. 12
 val miPersona = new Persona("Carlos", 28)

// Serializar la instancia de Persona

val salida = new ObjectOutputStream(new FileOutputStream("persona.ser"))
salida.writeObject(miPersona)
salida.close()

// Deserializar la instancia de Persona

val entrada = new ObjectInputStream(new FileInputStream("persona.ser"))
val personaRecuperada = entrada.readObject().asInstanceOf[Persona]
entrada.close()

println(s"Nombre: ${personaRecuperada.nombre}, Edad: ${personaRecuperada.edad}")

}
Ejercicio 2: Decapado con scala.decapado
import scala.pickling.Defaults._
import scala.pickling.json._

class Libro(val titulo: String, val autor: String)

object Main extends App {

val miLibro = new Libro("Scala 101", "Jane Doe")

// Pickling del objeto Libro a formato JSON

val libroSerializado = miLibro.pickle.value

// Guardar el JSON serializado en un archivo

scala.tools.nsc.io.File("libro.json").writeAll(libroSerializado)

pág. 13
 // Deserializar el JSON desde el archivo
val libroDeserializado = scala.tools.nsc.io.File("libro.json").slurpString.unpickle[Libro]

println(s"Título: ${libroDeserializado.titulo}, Autor: ${libroDeserializado.autor}")

}

III. Conclusión
En términos muy simples, una capa de persistencia es una forma de GUARDAR y
RECUPERAR elementos que utiliza la aplicación. También se usa para aquel objeto que se
crea y luego sea guardado en la base de datos. La persistencia permite al programador
almacenar, transferir y recuperar el estado de los objetos. Para que una clase sea persistente
se debe seguir cierto tipo de pasos dependiendo del software usado. Un programa puede
grabar objetos persistentes y luego recuperarlos en un tiempo posterior

pág. 14
Bibliografía
Guagliano, C. (2019). Programación en Python II: Programación orientada a objetos.
RedUsers.
Guía de aprendizaje de Python. (s/f). Com.uy. Recuperado el 16 de noviembre de 2023, de
https://spectrum.com.uy/sitio/wp-content/uploads/2015/09/tutpython.pdf
Cabedo, R., Pérez, J., Ali, N., Ramos, I., & Carsí, J. Á. (s/f). Implementación Orientada a
Aspectos en C# de un Sistema Robótico Tele-operado. Uclm.es. Recuperado el 16 de
noviembre de 2023, de
https://www.dsi.uclm.es/personal/elenanavarro/DSOA/papersCR/CabedoDSOA.pdf
Debrauwer, L. (2012). Patrones de diseño para C#: Los 23 modelos de diseño: descripción
y soluciones ilustradas en UML 2 y C#. Ediciones ENI.
Ríos, A. J. (2014). Programación Funcional y Herencia de Clases: Tipos de Datos
Algebraicos Extensibles en Scala. https://rephip.unr.edu.ar/items/1fc52cd9-2b99-43b1-
8702-dd165ddadf75
Introducción. (s/f). Scala Documentation. Recuperado el 16 de noviembre de 2023, de
https://docs.scala-lang.org/es/tour/tour-of-scala.html

pág. 15