Tarea Academica Python

1
TA: Clases persistentes en Python
Profesor:
Carlos Efrain Palomino Vidal
Curso:
Programacion Orientada a Objetos
Alumno:
Cochachin Polich, Kevin (U20217096)
Índice
2
1 Introducción............................................................................................................................. 3
2 Conceptos de Python............................................................................................................... 4
2.1 Definición......................................................................................................................... 4
2.2 Ventajas de usar Python.................................................................................................. 4
2.3 Objetos, clases, atributos y métodos en Python..............................................................5
3 Persistencia en Python............................................................................................................ 6
3.1 Persistencia de objetos.................................................................................................... 6
3.2 Clases persistentes.......................................................................................................... 7
4 Ejercicios Propuestos............................................................................................................... 8
4.1 Ejercicio con archivos externos........................................................................................ 8
4.2 Ejercicio con la biblioteca Pickle....................................................................................12
5 Bases de datos con Python................................................................................................... 14
5.1 Definición de bases de datos.........................................................................................14
5.1.1 Características......................................................................................................... 15
6 MySQL................................................................................................................................... 15
6.1 PhpMyAdmin.................................................................................................................. 15
6.1.1 Ejercicio con PhpMyAdmin.......................................................................................16
7 SQLite.................................................................................................................................... 24
7.1 Módulo sqlite3................................................................................................................ 24
7.1.1 Ejercicio con el módulo sqlite3.................................................................................24
8 Conclusiones......................................................................................................................... 30
9 Bibliografías........................................................................................................................... 30
3
Clases Persistentes en Python
1 Introducción
Para empezar, debemos tener en cuenta que las clases persistentes sirven como un
almacenamiento de los atributos que se deseamos declarar. También, pueden guardarse al
estilo como de una base de datos mediante hibernación y leerse. Las clases persistentes, no es
precisamente una clase, sino que los objetos son instanciados de tal forma que la información
persista. La persistencia, es la propiedad que tienen un objeto de permanecer en el tiempo, es
decir que la información del objeto se almacena de forma permanente para luego recuperarse y
reutilizarse.
Por otro lado, la persistencia de datos es la capacidad de guardar la información del
programa para reutilizarla en otro momento; en programación significa cuidar la secuencia de
datos en un archivo, base de datos u otro medio similar, y el proceso inverso de recuperar
datos a partir de la información serializada.
Ahora con la finalidad de enfocarse más en el tema, se investigó sobre las clases
persistentes en Python, de lo cual en el presente trabajo antes de adentrarnos en el tema,
mencionaremos algunas definiciones, aspectos, modelos de uso y ventajas de Python, para así
poder dar un mejor entendimiento a nuestro tema. Asimismo, hacer algunos ejercicios en este
programa haciendo uso de las clases persistentes, las cuales nos ayudaran a la explicación de
nuestro trabajo de investigación.
2 Conceptos de Python
En este capítulo hablaremos de algunos conceptos básicos de Python para entender del
porque es uno de los lenguajes de programación más utilizados en el mundo y además de ser
muy utilizado por las grandes empresas. Asimismo, explicaremos su modelo de
implementación.
4
2.1 Definición
Python es un lenguaje de programación de propósito general, multiplataforma y
multiparadigma conocido por su código limpio y legible. Una de las razones de su éxito es que
cuenta con una licencia de código abierto que permite su uso en cualquier situación. Esto lo
convierte en uno de los lenguajes de nivel de entrada que muchos programadores estudian en
escuelas y universidades de todo el mundo.
Python es ideal para trabajar con grandes cantidades de datos porque admite
capacidades de extracción y procesamiento como una plataforma cruzada, razón por la cual las
empresas de Big Data lo eligen. Científicamente, tiene una gran biblioteca de recursos con un
enfoque especial en matemáticas para programadores novatos en campos especializados.
2.2 Ventajas de usar Python
Las principales ventajas de usar Python son:
 Facilita al programador con su legibilidad y de su fácil interpretación.
 Soporta objetos y conjuntos complejos.
 Es sencillo de aprender, es muy fácil comenzar a programar y fomenta la
productividad.
 Es de fácil portabilidad ya que se puede usar en prácticamente cualquier sistema
de la actualidad.
 Presenta módulos organizados.
2.3 Objetos, clases, atributos y métodos en Python
Las clases y los objetos sirven para crear tipos de datos definidos por el usuario. Una
clase es un tipo de dato definido por el usuario, y al crear instancias de una clase hace relación
5
a la creación de objetos de ese tipo, la cual esta puede contar con varios atributos que lo
describen. Asimismo, un método es una función que pertenece a un objeto. Las clases y los
objetos son considerados los principales bloques de desarrollo para Python.
A continuación, presentamos un ejemplo, donde se observa que en la figura 1 tenemos la
clase Coche que tiene sus atributos y métodos. Luego se le instancia el objeto “miCoche”
donde imprime los valores mostrados.
Figura 1
Ejemplo del uso de una clase y su objeto.

6
Nota. Elaboración Propia.
3 Persistencia en Python
Como lo hemos mencionado antes, la persistencia hace referencia a la acción de
conservar la información un objeto de forma permanente, y de recuperarla. A continuación,
explicaremos los tipos de persistencia que maneja Python.
3.1 Persistencia de objetos
La persistencia de objetos puede clasificarse en objetos transitorios y objetos
persistentes.
Los objetos transitorios, son aquellos datos u objetos que tiene la capacidad de
almacenarse en memoria y seguir existiendo tras varias operaciones; sin embargo, cuando se
cierra el programa esta información almacenada en memoria se pierde. Usualmente, esos
casos son los definidos en arreglos o vectores, en los que se almacenaran los datos y se podrá
interactuar con estos mientras esté activo el programa en memoria.
Los objetos persistentes, son datos u objetos que se almacenan en medios secundarios
para su uso posterior, y cuya vida es independiente del proceso de su creación. Estas cosas
generalmente se almacenan en la base de datos a través del valor de la clave principal que se
utilizará para una recuperación posterior.
3.2 Clases persistentes
Hay dos aspectos en el uso de clases persistentes en Python, convertir datos entre un
objeto en memoria y un formato de almacenamiento, y administrar el almacenamiento de datos
convertidos. Cuando queremos realizar la tarea de almacenar información y luego recuperarla
para su uso posterior, utilizamos la característica de persistencia cuya función es preservar

7
permanentemente la información del objeto. Para esto podemos trabajar con archivos externos
y serialización de objetos.
Existe una forma para que un objeto persista. Esto es posible hacerlo en Python
trabajando con ficheros externos, para ello utilizaremos el módulo estándar de Python “io”, la
cual tiene como objetivo la persistencia de datos, es decir que a la hora de almacenar datos
hacemos que estas no se pierdan, haciendo uso del fichero externo. Para eso haremos el uso
de la función “open”.
La función “open” permite abrir y acceder al fichero, la cual también es importante
devolverlo y cerrarlo, ya que el sistema operativo tiene un estándar máximo de ficheros que
pueden permanecer abiertos, además no tendría mucho sentido mantener un fichero abierto si
no es utilizado.
Por otro lado, también se puede hacer el uso de la serialización de objetos, que implica
la creación de una cadena de bytes para el almacenamiento. Esto se puede hacer con varias
bibliotecas, entre las más destacables es Pickle.
La Biblioteca Pickle es la más común al querer utilizar la persistencia, ya que está
integrado con algunos módulos de biblioteca estándar que almacenan datos serializados. Un
simple archivo plano con objetos serializados escritos uno después del otro funciona para datos
que no necesitan ser indexados. Asimismo, esta biblioteca nos permite almacenar fácilmente
colecciones y objetos en ficheros binarios abstrayendo toda la parte de escritura y lectura
binaria. Por otro lado, también tiene una gran cantidad de series de métodos. Los métodos más
destacados son el método dump, que hace un volcado de datos al fichero binario externo, y el
método load, que carga los datos del fichero binario externo.
8
4 Ejercicios Propuestos
A continuación, realizaremos algunos ejercicios en este programa haciendo uso de las
clases persistentes ya explicados anteriormente.
4.1 Ejercicio con archivos externos
En la figura 2 se ve que importamos módulo “open” de “io”, después creamos una clase
que imprimará los datos a poner. Luego, creamos el archivo con el módulo open, la cual le
pasamos los parámetros del nombre con el que queremos que se guarde nuestro archivo y el
iterador a utilizar. Finalmente imprimimos los valores y cerramos el archivo.
Figura 2
Creación del archivo externo.

9
Nota. Elaboración propia.
En la figura 3 vemos que para crear la interfaz tenemos que importar primero el módulo
Tkinter. Luego creamos la interfaz con sus respectivas escrituras. Finalmente instanciamos los
datos de nuestra clase con los textos a poner en la interfaz, y así con el botón registrar
guardaremos la información a poner.
Figura 3
Creación de la interfaz.
10
En la figura 4 se observa que, al crear la interfaz, vemos que podemos escribir textos,
en lo cual una vez completando estos espacios podemos al darle al botón registrar y esta se
almacenará en un archivo externo haciendo que se guarde la información.
Figura 4
Muestra de la interfaz terminada.

11
4.2 Ejercicio con la biblioteca Pickle
En la figura 5 se observa que importamos la biblioteca Pickle, después creamos las
clases con sus constructores. Luego hacemos uso de la función “open” y guardamos las clases
haciendo un dump.
Figura 5
Aplicando la biblioteca Pickle.

12
En la figura 6 se ve que crearemos un catálogo de películas, después agregamos las
películas que queremos y lo mostramos. Finalmente, al compilarlo podemos ver todos los
catálogos creados aun habiéndolos eliminado con “del”, y se creó un archivo en el que esta
guardada nuestros catálogos, la cual esta codificado en código binario.
Figura 6
Creación de catálogos.
13
5 Bases de datos con Python
Cuando tenemos que almacenar gran cantidad de datos y su posterior procesamiento
es muy común utilizar un gestor de bases de datos.
Usando Python, podemos comunicarnos con el administrador de la base de datos para
enviar y recuperar datos. Hay muchos administradores de bases de datos para usar. En las
siguientes líneas definiremos qué es una base de datos.
5.1 Definición de bases de datos
Una base de datos es un conjunto de información interconectada, que se almacena y
organiza de manera sistemática para facilitar su conservación, búsqueda y uso. En inglés, se
llama base de datos. Las bases de datos han evolucionado a medida que los avances en
computación y electrónica pasan de sistemas analógicos a digitales que se caracterizan por
almacenar grandes cantidades de información que pueden ser utilizadas de forma rápida y
sencilla.
Antes de existir las bases de datos se trabajaba con ficheros. Los sistemas de
ficheros surgieron al informatizar el manejo de los archivadores manuales para
proporcionar un acceso más eficiente a los datos almacenados. Un sistema de
ficheros sigue un modelo descentralizado, en el que cada departamento de la
empresa almacena y gestiona sus propios datos mediante una serie de
programas de aplicación escritos especialmente para él (Mercedes, 2011, p. 10).
El objetivo de las bases de datos es facilitar el uso y acceso a la información, por lo que
son ampliamente utilizadas en el ámbito comercial, público y científico, así como en bibliotecas
y otros campos. De igual forma, con el fin de mejorar su funcionamiento se han creado
14
sistemas de gestión de bases de datos, conocidos DBMS por sus siglas en inglés (Database
Management System), que permite un almacenamiento de información más rápido y confiable.
5.1.1 Características
Algunas características principales de los sistemas de bases de datos son:
 Mínima repetición.
 No pueden existir dos tablas con el mismo nombre ni registro.
 Acceso simultanea por varios usuarios.
 Integridad de los datos.
 Acceso a través de lenguajes de programación.
6 MySQL
MySQL es el sistema de administración de bases de datos más popular en la actualidad
porque se basa en código fuente abierto.
MySQL al ser un código de fuente abierto, permite que las empresas y los
desarrolladores tengan una solución confiable y estandarizada para sus
aplicaciones. MySQL ayudará a administrar todo de una manera simple,
razonable y organizada (Izquierdo, 2008, p. 167).
Necesitamos un programa GUI que permita el acceso a un servidor MySQL, para
consultar o crear una base de datos y administrar tablas o registros almacenados. Existen
varias alternativas de software para administrar nuestras bases de datos, una de ellas es
mediante una aplicación web, como por ejemplo PhpMyAdmin.
6.1 PhpMyAdmin
Es una aplicación web que se utiliza para gestionar fácilmente bases de datos MySQL y
además tiene una interfaz intuitiva. La ventaja de utilizar una aplicación web es que nos permite
15
conectarnos a servidores remotos, a los que no siempre se puede acceder mediante
programas GUI. Con phpMyAdmin, puedes realizar todo tipo de operaciones, desde crear,
eliminar bases de datos y hasta administrar tablas (creación, modificación, eliminación) y, por
supuesto, sus propios datos.
6.1.1Ejercicio con PhpMyAdmin
A continuación, haremos un ejemplo con base de datos en Python utilizando
PhpMyAdmin.
Para empezar con el ejercicio, primero creamos nuestra base de datos.
En la figura 7, se observa la creación de nuestra base de datos llamada “Personales” la
cual contiene una tabla de registros. En esta tabla podemos ver que tiene código, nombres,
apellidos, dirección y teléfono, la cual nos ayudará a la hora de agrupar a los personales.
Figura 7
Creación de la base de datos.

16
En la figura 8, vemos que primero tenemos que instalar la librería que nos va a permitir
conectarnos correctamente con la base de datos, para eso usaremos PyMySQL. Luego
establecemos la conexión con nuestra base de datos creada, la cual se llama “personales”.
Figura 8
Importación de PyMySQL.
17
En las figuras 9, 10 y 11 aplicamos los métodos leer, agregar, reiniciar, eliminar, seleccionar,
buscar y actualizar. Cada uno de estos métodos se les agregó sus funciones y restricciones,
que luego nos servirán a la hora de darle uso a nuestros botones.
Figura 9
Aplicación de los Métodos.

18
Figura 10

19
Figura 11
Aplicación los Métodos.

20
En las figuras 12 y 13 creamos la interfaz gráfica, la cual va a tener etiquetas, entradas de texto
y botones. Cada una de estas con sus respectivas variables y comandos, donde haremos el
uso de los métodos creados anteriormente para manejar el CRUD.
Figura 12
21
Figura 13
Creación de la Interfaz.
22
En la figura 14, se aprecia como quedó la interfaz gráfica. En esta interfaz podemos eliminar,
editar, buscar, reiniciar y sobre todo registrar correctamente a nuestros personales, lo cual, al
momento de agregarlo, esta se guardará automáticamente en nuestra base de datos creada.
Figura 14
Muestra de la interfaz.
23
7 SQLite
SQLite está diseñado para integrarse en aplicaciones, en lugar de usar software de
servidor de base de datos como MySQL, PostgreSQL, Oracle entre otros. Es rápido, riguroso,
sencilla y flexible, lo que lo hace adecuado para la creación de prototipos y la implementación
de producción para aplicaciones específicas.
Estas son algunas de las características principales de SQLite:
 Toda la base de datos en un solo archivo.
 Escrito en C, es de código abierto.
 Forma parte integral del programa.
 Se puede ejecutar completamente en la memoria, lo que lo hace muy rápido.
 Lee y escribe directamente sobre archivos que se encuentran en el disco duro.
 Tiene bibliotecas accesibles para muchos lenguajes de programación.
 El código fuente es de dominio público y está bien documentado.
7.1 Módulo sqlite3
El módulo sqlite3 implementa la interfaz de Python compatible con SQLite que, como
dijimos antes, es una base de datos relacional de procesos. Si nuestra aplicación necesita
almacenar grandes cantidades de datos, SQLite es nuestra mejor opción.
SQLite es de código abierto y está instalado por defecto en Python, ya que es parte de
la biblioteca estándar. Gracias a eso no tenemos que instalar el módulo con el comando “pip”.
24
7.1.1 Ejercicio con el módulo sqlite3
A continuación, haremos un ejemplo con base de datos en Python utilizando el módulo
sqlite3.
En la figura 15, se puede ver qué primero se importó la biblioteca tkinter junto con
sqlite3, que nos ayudaran para el desarrollo. Luego, creamos nuestra interfaz dándole sus
dimensiones, después creamos nuestras variables para almacenarlo en nuestra BD.
Finalmente establecemos la conexión con la BD, para luego crear nuestras tablas con sus
respectivas variables.
Figura 15
Creación de la Base de Datos.

25
En las figuras 16 y 17 se establecieron los métodos con sus respectivas funciones y
restricciones para manipular el CRUD. La cual lo haremos a través de los botones que serán
creados después, cada uno heredando sus comandos.
Figura 16
Aplicaciones de los Métodos.

26
Figura 17

27
En la figura 18, se agregaron estilos a nuestra tabla, creamos las etiquetas, las cajas te textos y
los botones. Finalmente instanciamos los métodos de nuestra clase con las cajas de texto y los
botones creados, para así culminar nuestra interfaz.
Figura 18
28
En la figura 19, se observa la interfaz gráfica que hemos creado. Esto nos ayudará a
registrar fácilmente nuestro catálogo de películas que deseamos crear, así como también
editar, mostrar, actualizar y eliminar. Asimismo, no tendremos que preocuparnos de que se
pierdan nuestros catálogos, ya que esta persistirá en nuestra nuestra base de datos.
Figura 19
Muestra de la interfaz.
29
8 Conclusiones
En conclusión, las clases persistentes en Python ayudan en la hora de la privatización
de los atributos, la declaración de ellos y su guardado, haciéndolos persistir mas allá del tiempo
de vida del que este programa lo instancia. Por otro lado, pudimos observar en los ejemplos
mostrados que existen varias maneras del usar la persistencia de datos. La primera es
haciendo uso de un fichero externo, que nos permitía ver los datos guardados en un archivo y
la otra manera es serializándolo con la biblioteca Pickle, codificando en código binario a
nuestros datos almacenados.
También, en esta lección aprendimos todo lo relacionado con MySQL y SQLite. La cual
es la forma más adecuada, sencilla y fácil manejo a la hora de querer que persistan nuestros
datos. Asimismo, aprendimos a conectarnos a una base de datos, crear tablas, como insertar,
obtener, modificar y eliminar registros de la base de datos.
9 Bibliografías
Mercedes (2011). “Bases de Datos”. Departamento de Ingeniería y Ciencias de las
Computadoras. Chile, Santiago: Sapientia. http://repositorio.unap.edu.pe/handle/UNAP/1949.
Izquierdo (2008). “Tutorial de Practicas del Gestor de Bases de Datos MySQL”.
Universidad del Uzuay. Ecuador, Cuenca: Bruño.
https://dspace.uazuay.edu.ec/bitstream/datos/2326/1/06827.pdf
30

Tarea Academica Python

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tarea Academica Python

Cargado por

Copyright:

Formatos disponibles

1

TA: Clases persistentes en Python

Carlos Efrain Palomino Vidal

Programacion Orientada a Objetos

Cochachin Polich, Kevin (U20217096)

2.2 Ventajas de usar Python.................................................................................................. 4

2.3 Objetos, clases, atributos y métodos en Python..............................................................5

3.1 Persistencia de objetos.................................................................................................... 6

3.2 Clases persistentes.......................................................................................................... 7

4.1 Ejercicio con archivos externos........................................................................................ 8

4.2 Ejercicio con la biblioteca Pickle....................................................................................12

5 Bases de datos con Python................................................................................................... 14

5.1 Definición de bases de datos.........................................................................................14

6.1.1 Ejercicio con PhpMyAdmin.......................................................................................16

7.1 Módulo sqlite3................................................................................................................ 24

7.1.1 Ejercicio con el módulo sqlite3.................................................................................24

Clases Persistentes en Python

almacenamiento de los atributos que se deseamos declarar. También, pueden guardarse al

persista. La persistencia, es la propiedad que tienen un objeto de permanecer en el tiempo, es

Por otro lado, la persistencia de datos es la capacidad de guardar la información del

programa para reutilizarla en otro momento; en programación significa cuidar la secuencia de

datos a partir de la información serializada.

persistentes en Python, de lo cual en el presente trabajo antes de adentrarnos en el tema,

nuestro trabajo de investigación.

muy utilizado por las grandes empresas. Asimismo, explicaremos su modelo de

Python es un lenguaje de programación de propósito general, multiplataforma y

escuelas y universidades de todo el mundo.

enfoque especial en matemáticas para programadores novatos en campos especializados.

2.2 Ventajas de usar Python

Las principales ventajas de usar Python son:

 Facilita al programador con su legibilidad y de su fácil interpretación.

 Soporta objetos y conjuntos complejos.

 Es sencillo de aprender, es muy fácil comenzar a programar y fomenta la

 Es de fácil portabilidad ya que se puede usar en prácticamente cualquier sistema

 Presenta módulos organizados.

2.3 Objetos, clases, atributos y métodos en Python

objetos son considerados los principales bloques de desarrollo para Python.

A continuación, presentamos un ejemplo, donde se observa que en la figura 1 tenemos la

donde imprime los valores mostrados.

Ejemplo del uso de una clase y su objeto.

Nota. Elaboración Propia.

Como lo hemos mencionado antes, la persistencia hace referencia a la acción de

conservar la información un objeto de forma permanente, y de recuperarla. A continuación,

explicaremos los tipos de persistencia que maneja Python.

3.1 Persistencia de objetos

La persistencia de objetos puede clasificarse en objetos transitorios y objetos

cierra el programa esta información almacenada en memoria se pierde. Usualmente, esos

interactuar con estos mientras esté activo el programa en memoria.

utilizará para una recuperación posterior.

3.2 Clases persistentes

objeto en memoria y un formato de almacenamiento, y administrar el almacenamiento de datos

convertidos. Cuando queremos realizar la tarea de almacenar información y luego recuperarla

para su uso posterior, utilizamos la característica de persistencia cuya función es preservar

La función “open” permite abrir y acceder al fichero, la cual también es importante

bibliotecas, entre las más destacables es Pickle.

La Biblioteca Pickle es la más común al querer utilizar la persistencia, ya que está

colecciones y objetos en ficheros binarios abstrayendo toda la parte de escritura y lectura

A continuación, realizaremos algunos ejercicios en este programa haciendo uso de las

clases persistentes ya explicados anteriormente.

4.1 Ejercicio con archivos externos

iterador a utilizar. Finalmente imprimimos los valores y cerramos el archivo.

Creación del archivo externo.

Nota. Elaboración propia.

guardaremos la información a poner.