Tarea Academica Python
Tarea Academica Python
Tarea Academica Python
Profesor:
Curso:
Alumno:
Índice
2
1 Introducción............................................................................................................................. 3
2 Conceptos de Python............................................................................................................... 4
2.1 Definición......................................................................................................................... 4
3 Persistencia en Python............................................................................................................ 6
4 Ejercicios Propuestos............................................................................................................... 8
5.1.1 Características......................................................................................................... 15
6 MySQL................................................................................................................................... 15
6.1 PhpMyAdmin.................................................................................................................. 15
7 SQLite.................................................................................................................................... 24
8 Conclusiones......................................................................................................................... 30
9 Bibliografías........................................................................................................................... 30
3
1 Introducción
Para empezar, debemos tener en cuenta que las clases persistentes sirven como un
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
decir que la información del objeto se almacena de forma permanente para luego recuperarse y
reutilizarse.
datos en un archivo, base de datos u otro medio similar, y el proceso inverso de recuperar
Ahora con la finalidad de enfocarse más en el tema, se investigó sobre las clases
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
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
implementación.
4
2.1 Definición
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
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
productividad.
de la actualidad.
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
clase Coche que tiene sus atributos y métodos. Luego se le instancia el objeto “miCoche”
Figura 1
3 Persistencia en Python
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
casos son los definidos en arreglos o vectores, en los que se almacenaran los datos y se podrá
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
Hay dos aspectos en el uso de clases persistentes en Python, convertir datos entre un
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”.
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
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
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
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
Figura 2
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
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
Figura 4
clases con sus constructores. Luego hacemos uso de la función “open” y guardamos las clases
haciendo un dump.
Figura 5
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
Figura 6
Creación de catálogos.
13
enviar y recuperar datos. Hay muchos administradores de bases de datos para usar. En las
llama base de datos. Las bases de datos han evolucionado a medida que los avances en
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
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
5.1.1 Características
Mínima repetición.
6 MySQL
MySQL al ser un código de fuente abierto, permite que las empresas y los
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
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
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
PhpMyAdmin.
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
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,
Figura 9
Figura 10
Figura 11
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
Figura 12
Creación de la interfaz.
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
Figura 14
Muestra de la interfaz.
23
7 SQLite
servidor de base de datos como MySQL, PostgreSQL, Oracle entre otros. Es rápido, riguroso,
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
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
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
Finalmente establecemos la conexión con la BD, para luego crear nuestras tablas con sus
respectivas variables.
Figura 15
restricciones para manipular el CRUD. La cual lo haremos a través de los botones que serán
Figura 16
Figura 17
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
Figura 18
Creación de la interfaz.
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
pierdan nuestros catálogos, ya que esta persistirá en nuestra nuestra base de datos.
Figura 19
Muestra de la interfaz.
29
8 Conclusiones
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
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,
9 Bibliografías
https://dspace.uazuay.edu.ec/bitstream/datos/2326/1/06827.pdf
30