FACULTAD DE INGENIERÍA

CARRERA DE INGENIERÍA DE SISTEMAS E INFORMATICA

Tarea Académica 1:
Clases persistentes con Python, C# y Scala

AUTORES

 Jhanpier Jack Valdivia Rios

Docente

MARLENE PILAR AGUILAR SUARES

Curso:
Programación Orientada a Objetos

1
 Ciudad de Lima - Perú
2022
Clases persistentes con Python, C# y Scala

I. Introducción

En la programación una de las tareas más importantes y criticas sin duda es la de

salvar y recuperar los datos que se manejan en la aplicación que estemos

desarrollando, para esto usamos la persistencia. Consiste en almacenar los datos en

memoria hasta que posteriormente recuperemos los mismos. Sin el uso de clases

persistentes los programas serían mucho más pesados tanto para el desarrollador

como para el usuario final dada su lenta implementación de datos. Podemos inferir

su importancia a la hora de programar alguna resolución de un problema en concreto

en el que estemos trabajando, a nivel de programación consideramos indispensable la

implementación de clases persistentes en el sistema.

II. Desarrollo

a. Clases persistentes.

Se llama clases persistentes a aquellas que se encuentran en la capa de

persistencia que se implementen a la resolución del problema en el que

estemos trabajando, por ejemplo, Cliente y Pedido en un programa de ventas.

Cabe aclarar que esto no implica que todas las instancias de una clase

persistente se encuentren en un estado persistente, ya que una instancia puede

ser transitorio o separada.

2
Llamamos capa persistente al lugar donde se encuentran las clases y

complementos donde se guarda la información del programa y de donde se

pueden recuperar los datos. Las clases persistentes que creemos dentro de

está pueden ser guardados en un almacén de datos y recuperarse después.

b. Clases persistentes en Python.

Las clases persistentes en Python como en cualquier otro lenguaje de

programación tiene la capacidad de convertir objetos de ciertas clases para su

existencia fuera de una clase, lo que hará que se conserve con el paso del

tiempo.

Python cuenta con procesos los cuales permiten la realización de este, entre el

módulo “pickle”, en el cual los objetos de la clase se convertirán en una

secuencia de bytes que podrán ser almacenados mediante la serialización.

Al igual que “pickle”, otro módulo de serialización es “marshal”, aunque

diferenciándose en que “marshal” pueda no ser portable en todas las

versiones existentes de Python, lo cual genera una desventaja a la hora de su

uso, por lo cual los programadores de Python hacen mayor uso de “pickle”.

JSON (por sus siglas JavaScript Object Notation) es otro protocolo de

serialización, el cual se basa en un formato de serialización de texto, a

diferencia del anterior pickle que serializa en binario. JSON puede ser legible

por cualquier persona gracias a su serialización en texto, además de poder

3
 operar en lenguajes distintos a Python, a diferencia de los dos mencionados

anteriormente.

Así como cada uno de ellos permite la serialización mediante sus módulos,

también tienen la capacidad hacer una deserialización, lo cual viene a ser el

proceso invertido.

Cuando el objeto en cuestión acaba de ser convertido, se encuentra listo para

ser almacenado, lo cual el programador tendrá la decisión de poder

almacenarlo a su conveniencia. Para este tipo de casos se hace uso del

módulo “shelve”, el cual es una opción de almacenamiento persistente para

los objetos de Python cuando no es esencial es uso de una base de datos.

c. Clases persistentes en 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

4
 lenguaje de C# admite los conceptos de encapsulación, herencia y

polimorfismo y facilita el desarrollo de componentes de software mediante

varias construcciones de lenguaje innovadoras.

Clase en 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.

Sintaxis de una clase en

C#:

d. Clases persistentes en Scala.

En Scala, las clases son plantillas estáticas que pueden ser instanciadas por

muchos objetos en tiempo de ejecución. Aquí se presenta una clase la cual

define la clase Point:

5
class Point (xc: Int, yc: Int) {

var x: Int = xc

var y: Int = yc

def move (dx: Int, dy: Int) {

x = x + dx

y = y + dy

override def toString(): String = "(" + x + ", " + y + ")";

Esta clase define dos variables x e y, y dos métodos: move y

toString. El método move recibe dos argumentos de tipo

entero, pero no retorna ningún valor (implícitamente se retorna

el tipo Unit, el cual se corresponde a void en lenguajes tipo

Java). toString, por otro lado, no recibe ningún parámetro,

pero retorna un valor tipo String. Ya que toString sobreescribe

el método toString predefinido en una superclase, tiene que ser

anotado con override.

Las clases en Scala son parametrizadas con argumentos constructores

(inicializadores). En el código anterior se definen dos argumentos

constructores, xc y yc; ambos son visibles en toda la clase. En nuestro

ejemplo son utilizados para inicializar las variables x e y.

6
Para instanciar una clase es necesario usar la primitiva new, como se muestra

en el siguiente ejemplo:

object Classes {

def main (args: Array[String]) {

val pt = new Point(1, 2)

println(pt)

pt.move(10, 10)

println(pt)

El programa define una aplicación ejecutable a través del método main del

objeto singleton Classes. El método main crea un nuevo Point y lo almacena

en pt. Note que valores definidos con la signatura val son distintos de los

definidos con var (véase la clase Point arriba) ya que los primeros (val) no

permiten reasignaciones; es decir, que el valor es una constante.

Aquí se muestra la salida del programa:

(1, 2)

(11, 12)

HEREDA LA SCALA

7
 Scala heredan de una clase base con Java es muy similar, pero hay que

prestar atención a los siguientes puntos:

1, reescribir un método no abstracto debe utilizar el modificador override.

2, está disponible en el pasado sólo el constructor principal de los parámetros

de escritura constructor de la clase base.

3. Cuando se reemplaza en una subclase de la superclase abstracta, no es

necesario utilizar la palabra clave override.

e. Ejemplos de prácticos.

import json

import pickle

datos = {'personas': []}

maria = {'dni': '12345678', 'nombre': 'Maria', 'apellido': 'Martinez', 'edad': 35}

jorge = {'dni': '87654321', 'nombre': 'Jorge', 'apellido': 'Salas', 'edad': 28}

pedro = {'dni': '32456785', 'nombre': 'Pedro', 'apellido': 'Ramirez', 'edad': 22}

datos['personas'].append(maria)

datos['personas'].append(jorge)

8
datos['personas'].append(pedro)

with open('personas.json', 'w') as f:

json.dump(datos, f)

print()

with open('personas.json', 'r') as f:

datos_personas = json.load(f)

for p in datos_personas['personas']:

print('DNI: %s' % p['dni'])

print('nombre: %s' % p['nombre'])

print('apellido: %s' % p['apellido'])

print('edad: %i' % p['edad'])

print()

print()

with open('personas.pkl', 'wb') as f:

pickle.dump(datos, f, protocol=pickle.HIGHEST_PROTOCOL)

with open('personas.pkl', 'rb') as f:

datos_deserializados = pickle.load(f)

print(type(datos_deserializados))

print(datos_deserializados)

9
for p in datos_deserializados['personas']:

print('DNI: %s' % p['dni'])

print('nombre: %s' % p['nombre'])

print('apellido: %s' % p['apellido'])

print('edad: %i' % p['edad'])

print()

10
Ejemplo en C#:

11
Clases Persistentes en C#

12
Con respecto a C#, la persistencia es aquel que se puede guardar en la memoria secundaria

la computadora como un disco o memoria donde los códigos programados permanezcan más

allá de la ejecución del programa. Para guardar una clase usando persistencia se debe

etiquetar usando [Serializable] antes de la clase.

Ejemplo:

using System;

using System.Collections.Generic;

using Systen.Linq;

using System.Text;

namespace ObjetosPersistentes

[Serializable]

class Persona

private string Nombre;

private int Edad;

public Persona()

Nombre =””;

Edad = 0;

public void SetNombre (string Nombre) {

this. Nombre =Nombre;

public void SetEdad (int Edad) {

this.Edad = Edad;

13
 }

public string GetNombre () {

return Nombre;

public int GetEdad () {

return Edad;

Ejemplo de heredar una Scala:

class Point(xc: Int, yc: Int) {

var x: Int = xc

var y: Int = yc

def move(dx: Int, dy: Int) {

x = x + dx

y = y + dy

println ("x: " + x);

println ("y: " + y);

class Location(override val xc: Int, override val yc: Int, val zc :Int)

extends Point(xc, yc){

var z: Int = zc

def move(dx: Int, dy: Int, dz: Int) {

14
 x = x + dx

y = y + dy

z = z + dz

println ("x: " + x);

println ("y: " + y);

println ("z: " + z);

El uso de palabras clave Scala se extiende a heredar una clase. Ubicación instancias clase

hereda la clase Point. Punto llama la clase padre (clase base), la ubicación se llama una

subclase.

val anular xc reescribir el campo de la clase padre.

Todas las propiedades y métodos heredan heredará la clase padre, Scala sólo permite

heredar de una clase principal.

Ejemplos son los siguientes:

import java.io._

class Point(val xc: Int, val yc: Int) {

var x: Int = xc

var y: Int = yc

def move(dx: Int, dy: Int) {

x = x + dx

y = y + dy

15
 println ("x : " + x);

println ("y: " + y);

class Location(override val xc: Int, override val yc: Int, val zc :Int)

extends Point(xc, yc){

var z: Int = zc

def move(dx: Int, dy: Int, dz: Int) {

x = x + dx

y = y + dy

z = z + dz

println ("x : " + x);

println ("y: " + y);

println ("z: " + z);

object Test {

def main(args: Array[String]) {

val loc = new Location(10, 20, 15);

loc.move(10, 10, 5);

16
Aplicación del código anterior, la salida es:

$ scalac Test.scala

$ scala Test

x: 20

y: 30

z: 20

Scala reescribir un método no abstracto tendrá prioridad modificador.

class Person {

var name = ""

override def toString = getClass.getName + "[name=" + name + "]"

class Employee extends Person {

var salary = 0.0

override def toString = super.toString + "[salary=" + salary + "]"

object Test extends App {

val fred = new Employee

fred.name = "Fred"

fred.salary = 50000

println(fred)

Aplicación del código anterior, la salida es:

$ scalac Test.scala

17
$ scala Test

Employee[name=Fred][salary=50000.0]

III. CONCLUSIONES

A modo de conclusión, las clases persistentes nos brindan una gran ventaja al

momento del desarrollo para todos aquellos que vemos a la programación como una

profesión, ya que abstrae el proceso del uso de datos implicando una gran reducción

de tiempo y complejidad al momento del desarrollo de la aplicación.

La persistencia permite al programador almacenar, transferir y recuperar el estado de

los objetos.

El uso de las clases persistentes permite el almacenamiento de datos y su posterior

recuperación mediante la serialización y deserialización, respectivamente.

En síntesis, a través de la capa de persistencia es posible insertar, modificar, borrar, y

recuperar datos sin escribir una sola línea de código SQL. Por lo tanto, el uso de la

capa de persistencia por parte de aplicaciones cliente, implica una reducción de la

complejidad y del tiempo de desarrollo. Otra ventaja de usar la capa de persistencia

es que abstrae completamente el proceso de acceso a datos, y contribuye al

desarrollo de aplicaciones orientadas a objeto basada en tres capas (interfaz, negocio,

y datos), lo cual representa una buena práctica en el desarrollo de software.

Además, el hecho de encapsular todo el acceso a datos en la capa de persistencia

permite que podamos cambiar de gestor de base de datos (siempre y

18
 cuando el proveedor esté soportado) sin tener que modificar el código de la

aplicación.

IV. REFERENCIA

BAUER, C. (2020). Persistencia relacional para Java idiomático. Hibernate, Clases

persistentes (Capítulo 4), 4.1.-4.1.1. Recuperado de:

https://docs.jboss.org/hibernate/core/3.5/reference/es-ES/html/persistent-classes.html

Bell, D. & Parr, M. (2010). C# Para Estudiantes. (Primera edición). Ciudad de

Mexico: Pearson Educación de México. Recuperado de

https://profesorezequielruizgarcia.files.wordpress.com/2013/08/c-sharp-para-

estudiantes.pdf

Contenido de la documentación de Python. Python. Recuperado de:

https://docs.python.org/es/3/contents.html

Hernández González, A. (2000). Capa persistente de clases para el almacenamiento

de objetos. Recuperado de:

https://www.researchgate.net/publication/312577212_CAPA_PERSISTENTE_DE_

CLASES_PARA_EL_ALMACENAMIENTO_DE_OBJETOS

Scala. (29 de junio del 2022). Tour of Scala.

https://docs.scala-lang.org/es/tour/classes.html

19
w3big. (29 de junio del 2022). Clases y objetos Scala.

http://www.w3big.com/es/scala/scala-classes-objects.html

20