Contenido

Introducción................................................................................................................ 3

Investigación de Python..............................................................................................4

Investigación de Big Data...........................................................................................6

Investigación Base de Datos No Relacionales..........................................................16

Instalación de Anaconda y Python............................................................................25

Operaciones Aritméticas en Python.......................................................................... 30

Obtener Resultados De Una Página Web Con Python..............................................36

Beautiful Soup: Build a Web Scraper With Python.................................................. 38

Generación de texto en español con GPT-2.............................................................. 43

Juego del Pong en Python.........................................................................................47

Análisis Exploratorio de Datos Python.....................................................................51

Práctica Graficas en Python 1................................................................................... 62

Practica 2 Graficas Python........................................................................................68

Graficas del Proyecto Integrador.............................................................................. 77

Conclusión................................................................................................................ 86
 Introducción
En el vertiginoso mundo tecnológico del siglo XXI, la generación y el
procesamiento masivo de datos se han convertido en el epicentro de la revolución digital.
Este fenómeno, conocido como Big Data, abarca la recolección, almacenamiento, análisis y
visualización de volúmenes colosales de información generada a una velocidad vertiginosa.
La complejidad de este universo de datos plantea desafíos sin precedentes, pero también
brinda oportunidades infinitas para el descubrimiento de patrones, la toma de decisiones
informadas y la innovación en diversas áreas, desde la ciencia y la medicina hasta el
comercio y el entretenimiento.

En este contexto, Python emerge como una herramienta indispensable y versátil en

el arsenal del analista de datos moderno. Con su sintaxis clara, su extensa comunidad de
desarrolladores y su amplio conjunto de bibliotecas especializadas, Python se ha
consolidado como el lenguaje de programación preferido para el análisis y procesamiento
de datos a gran escala. Desde la manipulación de datos hasta la generación de modelos de
aprendizaje automático, Python ofrece una solución para casi cualquier desafío en el mundo
del Big Data.

A lo largo de esta investigación, exploraremos las diversas facetas del Big Data y
cómo Python se integra en cada una de ellas. Desde el análisis exploratorio de datos hasta la
generación de texto mediante inteligencia artificial, pasando por el desarrollo de juegos y la
visualización de datos, nos sumergiremos en un viaje de descubrimiento y aprendizaje en el
fascinante mundo del Big Data con Python como nuestro fiel compañero de ruta.
 Investigación de Python
Características de Python:

Legibilidad y Simplicidad: La filosofía de Python se traduce en

su sintaxis clara y legible. El código escrito en Python es como una narrativa,
donde el énfasis en el uso de palabras sobre símbolos hace que incluso los
recién llegados a la programación se sientan cómodos. Esta legibilidad no
solo facilita la comprensión, sino que también simplifica el mantenimiento
del código a lo largo del tiempo.

Versatilidad: Python es un camaleón en el mundo de la

programación. Desde el desarrollo web con frameworks como Django y
Flask hasta la exploración de la inteligencia artificial y el análisis de datos
con NumPy y Pandas, Python se adapta con gracia a una sorprendente gama
de aplicaciones. Su versatilidad es la razón por la cual es elegido tanto por
principiantes como por expertos.

Interpretado: La naturaleza interpretada de Python le da un toque

experimental y ágil. La ejecución flexible del código permite la depuración
en tiempo real y el desarrollo iterativo sin la necesidad de un proceso de
compilación previa. Esto convierte a Python en un lenguaje propicio para la
exploración y la prueba de conceptos.

Orientado a Objetos: Python abraza el paradigma de la

programación orientada a objetos. La encapsulación, la herencia y el
polimorfismo no son solo conceptos, sino herramientas clave que facilitan la
creación de código modular y reutilizable. Este enfoque estructurado es
fundamental para construir sistemas complejos de manera eficiente.

Biblioteca Estándar Rica: La biblioteca estándar de Python es

como un cofre lleno de tesoros. Desde operaciones básicas hasta funciones
avanzadas, los programadores tienen acceso a una amplia variedad de
módulos y paquetes sin depender excesivamente de bibliotecas externas.
Esto promueve la independencia y la eficiencia en el desarrollo.
 Tipos de Datos en Python:

Enteros (int): Python no pone límites a la representación de enteros. La

flexibilidad extraordinaria para manejar números de cualquier magnitud permite a
los desarrolladores trabajar con datos a una escala asombrosa.

Flotantes (float): Los números de punto flotante en Python son

como joyas matemáticas. Representan valores decimales con precisión,
proporcionando una base robusta para cálculos que van desde simples hasta
complejos.

Cadenas de texto (str): Manejar cadenas de texto en Python es

como bailar con la expresión. La intuitiva manipulación y una amplia
variedad de métodos hacen que trabajar con datos textuales sea una
experiencia creativa y eficiente.

Listas, Tuplas y Diccionarios: Estas estructuras de datos en

Python son como herramientas en un taller. Ya sea organizando datos de
manera secuencial con listas, manteniendo la integridad con tuplas o creando
asociaciones clave-valor con diccionarios, estas estructuras ofrecen
flexibilidad y eficacia en el manejo de datos estructurados.

Aplicaciones de Python:

Desarrollo Web: Django y Flask, dos nombres que resuenan en el

desarrollo web, han simplificado radicalmente la creación de aplicaciones
web en Python. La facilidad para construir interfaces dinámicas y eficientes
hace que el desarrollo web sea tan emocionante como productivo.

Ciencia de Datos e Inteligencia Artificial: Python ha emergido como el

caballero de la ciencia de datos y la inteligencia artificial. NumPy,
Pandas, TensorFlow y PyTorch son sus armas de elección para
manipular datos eficientemente y desentrañar los misterios de la
inteligencia artificial.
 Automatización y Scripting: La legibilidad y simplicidad de
Python lo convierten en la herramienta ideal para la automatización de tareas
del sistema y el scripting. La capacidad de agilizar procesos mejora la
eficiencia operativa en diversos entornos.

Desarrollo de Software: Proyectos completos o partes

sustanciales de software se construyen con Python debido a su
productividad. La facilidad para colaborar y acelerar los ciclos de desarrollo
convierte a Python en un aliado confiable en la construcción de soluciones
tecnológicas.

Investigación de Big Data

El uso de datos ha crecido rápidamente en los últimos

años. Pero ¿cuál es la historia detrás del big data? Los primeros
registros del uso de datos para rastrear y controlar negocios se
remontan a más de 7.000 años. A medida que pasa el tiempo, los
principios contables siguen mejorando. En su primer relato sobre
el análisis de datos estadísticos, recopiló sus hallazgos en el libro
"Observaciones sobre la naturaleza y la política". Y por tanto uno
de los pioneros en la historia del big data. El primer recuerdo de
datos modernos se remonta a 1887, cuando Herman Hollerith
inventó una máquina informática que podía leer los agujeros
hechos en tarjetas de papel para organizar los datos del censo.

Siglo 20
El primer proyecto de big data fue creado en 1937 y
encargado por la administración de Franklin D. Después de que
se aprobó la Ley de Seguridad Social, el gobierno tuvo que
realizar un seguimiento de las contribuciones de 26 millones de
 estadounidenses y más de 3 millones de empleadores. A IBM se
le adjudicó un contrato para desarrollar lectores de tarjetas
perforadas para este gran proyecto de contabilidad. La primera
máquina procesadora de datos apareció en 1943. En 1952 se
creó la Agencia de Seguridad Nacional (NSA) y en 10 años se
empleó a más de 12.000 criptólogos. En 1965, el gobierno de
Estados Unidos decidió construir el primer centro de datos para
almacenar más de 742 millones de declaraciones de impuestos.
Así como 175 millones de conjuntos de huellas dactilares que
transfieren todos esos registros a cintas magnéticas de
computadora que deben almacenarse en un solo lugar.
Posteriormente, el proyecto fue abandonado por temor al "Gran
Hermano". Sin embargo, se acepta generalmente que este es el
comienzo de la era del almacenamiento electrónico de datos en
la historia del big data. A partir de la década de 1990, la
generación de datos aumentó a medida que más y más
dispositivos se conectaban a Internet.

El término “big data” abarca datos que contienen una mayor variedad y
que se presentan en volúmenes crecientes y a una velocidad
superior. Esto también se conoce como “las tres V”.
Dicho de otro modo, el big data está formado por conjuntos de datos de
mayor tamaño y más complejos, especialmente procedentes de
nuevas fuentes de datos. Estos conjuntos de datos son tan
voluminosos que el software de procesamiento de datos
convencional sencillamente no puede gestionarlos. Sin embargo,
 estos volúmenes masivos de datos pueden utilizarse para
abordar problemas empresariales que antes no hubiera sido
posible solucionar.

Surgieron dos V más durante los últimos años: valor y

veracidad. Los datos poseen un valor intrínseco. Sin
embargo, no tienen ninguna utilidad hasta que dicho
valor se descubre. De igual importancia:
¿Cuán veraz son sus datos? ¿Cuánto puede confiar en ellos?

Hoy en día, el big data se ha convertido en un activo crucial.

Piense en algunas de las mayores empresas
tecnológicas del mundo. Gran parte del valor que
ofrecen procede de sus datos, que analizan
constantemente para generar una mayor eficiencia y
desarrollar nuevos productos. Avances tecnológicos
recientes han reducido exponencialmente el costo del
 almacenamiento y la computación de datos, haciendo
que almacenar datos resulte más fácil y barato que
nunca. Actualmente, con un mayor volumen de big data
más barato y accesible, puede tomar decisiones
empresariales más acertadas y precisas. Identificar el
valor del big data no pasa solo por analizarlo (que es ya
una ventaja en sí misma). Se trata de todo un proceso
de descubrimiento que requiere que los analistas,
usuarios empresariales y ejecutivos se planteen las
preguntas correctas, identifiquen patrones, tomen
decisiones informadas y predigan comportamientos.

• El big data le permite obtener respuestas más completas, ya que

dispone de mayor cantidad de información.
• La disponibilidad de respuestas más completas significa una mayor
fiabilidad de los datos, lo que implica un enfoque completamente
distinto a la hora de abordar problemas.

El big data puede ayudarle a abordar una serie de

actividades empresariales, desde la experiencia de cliente
hasta la analítica. A continuación, recopilamos algunas de
ellas
En primer lugar, el big data se caracteriza por su gran
tamaño. Aunque se han desarrollado nuevas tecnologías
para el almacenamiento de datos, el volumen de datos
duplica su tamaño cada dos años aproximadamente. Las
organizaciones continúan esforzándose por mantener el
ritmo de crecimiento de sus datos y por encontrar formas
de almacenarlos eficazmente. Pero no basta con
almacenar los datos. Para ser de algún valor, los datos
deben poder utilizarse, y esto depende de su
conservación. Disponer de datos limpios —es decir, datos
relevantes para el cliente y organizados de tal modo que
permitan un análisis significativo— requiere una gran
cantidad de trabajo. Los científicos de datos dedican entre
un 50 y un 80 por ciento de su tiempo a seleccionar y
preparar los datos antes de que estos puedan utilizarse.
Por último, la tecnología de big data cambia a un ritmo
rápido. Hace unos años, Apache Hadoop era la tecnología
más conocida utilizada para gestionar big data. Más tarde,
en 2014, entraría en juego Apache
Spark. Hoy en día, el enfoque óptimo parece ser una
combinación de ambos marcos. Mantenerse al día en
cuanto a tecnología de big data supone un desafío
constante.
El big data le aporta nuevas perspectivas que abren paso
a nuevas oportunidades y modelos de negocio. Iniciarse
en ello requiere de tres acciones clave:

1.Integración

Big data concentra datos de numerosas fuentes y

aplicaciones distintas. Los mecanismos de integración de
datos convencionales, como “extraer, transformar y cargar”
(extract, transform, load, ETL), generalmente no están a la
altura en dicha tarea. Analizar conjuntos de big data de
uno o más terabytes, o incluso petabytes, de tamaño
requiere de nuevas estrategias y tecnologías.

Durante la integración, es necesario incorporar los datos,

procesarlos y asegurarse de que estén formateados y
disponibles de tal forma que los analistas empresariales
puedan empezar a utilizarlos.

2.Gestión

Big data requiere almacenamiento. Su solución de

almacenamiento puede residir en la nube, on premises o
en ambos. Puede almacenar sus datos de cualquier forma
que desee e incorporar los requisitos de procesamiento de
su preferencia y los motores de procesamiento necesarios
a dichos conjuntos de datos on-demand. Muchas personas
eligen su solución de almacenamiento en función de
dónde residan sus datos en cada momento. La nube está
aumentando progresivamente su popularidad porque es
compatible con sus requisitos tecnológicos actuales y
porque le permite incorporar recursos a medida que los
necesita.

3.Análisis

La inversión en big data se rentabiliza en cuanto se

analizan y utilizan los datos. Adquiera una nueva claridad
con un análisis visual de sus diversos conjuntos de datos.
Continúe explorando los datos para realizar nuevos
descubrimientos. Comparta sus hallazgos con otras
personas. Construya modelos de datos con aprendizaje
automático e inteligencia artificial. Ponga sus datos a
trabajar.

Para ayudarle en su transición a big data, hemos

recopilado una serie de mejores prácticas que debe tener
en cuenta.

A continuación, detallamos nuestras pautas para crear con

éxito una base de big data.
Actualmente los usos del Big Data se encuentra en muchas operaciones
de nuestras vidas, cuando hacemos un pedido a Rappi, cuando
usamos Waze, Spotify, Prime Videos o Netflix, cuando pedimos
un Uber o cuando Amazon nos muestra los productos
recomendados a partir de nuestras preferencias, se están
utilizando tecnologías dentro del ecosistema de Big Data tales
 como: machine learning, inteligencia artificial, bases de datos en
memoria y uno de los
temas que hablaremos en un próximo artículo: Data Lakes o
Lagos de Datos.

Investigación Base de Datos No Relacionales

¿

Las bases de datos NoSQL o

también conocidas como las no
relacionales, están diseñadas
específicamente para modelos de
datos específicos y tienen esquemas
flexibles para crear aplicaciones
modernas. Las bases de datos NoSQL son ampliamente reconocidas
porque son fáciles de desarrollar, por su funcionalidad y el rendimiento
a escala. Esta página incluye recursos que lo ayudan a comprender
mejor las bases de datos NoSQL y comenzar a usarlas.

Las principales características de una base de datos no

relacional son las siguientes:

• La información no se almacena en tablas sino a través de documentos.

• Son bases de datos muy útiles para organizar y gestionar información no estructurada, o
cuando no se tiene una noción clara de los datos a almacenar.

• Son bases de datos con alto grado de escalabilidad y están diseñadas para soportar grandes
volúmenes de datos.
• No utilizan el lenguaje SQL para consultas, aunque sí lo pueden usar como herramienta de
apoyo.

• Es un sistema de almacenamiento de datos relativamente nuevo, y como tal, todavía no

posee un sistema estandarizado.
• A diferencia de las no relacionales, no garantizan el cumplimiento de las cualidades ACID,
esto es, atomicidad, consistencia, integridad y durabilidad.

Una base de datos relacional tiene ciertas particularidades que las

distinguen del resto, lo cual se traduce en una serie de ventajas y
desventajas.

Ventajas
Estas son las principales ventajas de una base de datos no relacional:

• Son mucho más flexibles a la hora de crear esquemas de información, lo que las convierte
en una solución ideal para el almacenamiento y gestión de datos no estructurados o
semiestructurados.

• Ofrecen una mayor escalabilidad. Pueden soportar mayores volúmenes de datos y añadir
mayor capacidad añadiendo nuevos módulos de software, sin necesidad de añadir nuevos
servidores.

• Garantizan un alto rendimiento, ya que están diseñadas para trabajar con modelos de datos
concretos y patrones de acceso específicos.

• Son muy funcionales, ya que cuentan con API exclusivas y proporcionan modelos de datos
para trabajar con cada tipo de datos presentes en la base.

Desventajas
Por su parte, las principales desventajas de una base de datos
no relacional son las siguientes:
• No cumplen igual que las relacionales con las propiedades de atomicidad, consistencia,
integridad y durabilidad.
• No son compatibles con determinadas consultas en lenguaje SQL.
• Carecen de un sistema estandarizado ya que todavía son bases de datos relativamente
nuevas.

• Muchos sistemas de gestión de bases de datos relacionales son de código abierto y tienen
una gran comunidad detrás programando soluciones y nuevas funcionalidades. En el caso
de las bases de datos no relacionales este soporte es mucho más limitado.

Algunas de las diferencias más destacables que nos podemos encontrar

entre los sistemas NoSQL y los sistemas SQL están:

No utilizan SQL como lenguaje de consultas. La mayoría de las bases de datos

NoSQL evitan utilizar este tipo de lenguaje o lo utilizan como un lenguaje de

apoyo. Por poner algunos ejemplos, Cassandra utiliza el lenguaje CQL,
MongoDB utiliza JSON o BigTable hace uso de GQL.

No utilizan estructuras fijas como tablas para el almacenamiento de los datos.

Permiten hacer uso de otros tipos de modelos de almacenamiento de

información como sistemas de clave–valor, objetos o grafos.

No suelen permitir operaciones JOIN. Al disponer de un volumen de datos tan

extremadamente grande suele resultar deseable evitar los JOIN. Esto se debe
a que, cuando la operación no es la búsqueda de una clave, la sobrecarga
puede llegar a ser muy costosa. Las soluciones más directas consisten en
desnormalizar los datos, o bien realizar el JOIN mediante software, en la
capa de aplicación.

Arquitectura distribuida. Las bases de datos relacionales suelen estar

centralizadas en una única máquina o bien en una estructura máster–

esclavo, sin embargo en los casos NoSQL la informaciónpuede estar
 compartida en varias máquinas mediante mecanismos de tablas Hash
distribuidas.

Estos son los principales tipos de BBDD NoSQL.

Bases de datos de clave-valor
Las BBDD de clave-valor destacan por ser muy
eficientes tanto para lectura como para escritura.
Cada elemento está identificado por una clave única que
permite recuperar datos rápidamente. Los datos suelen
estar almacenados como objetos binarios

Ejemplos de bases de datos de clavevalor: Redis,

CouchDB y BigTable.

Bases de datos documentales

Las BBDD documentales o bases de datos
orientadas a documentos son las bases de datos
NoSQL más versátiles y se pueden usar en una amplia gama
de proyectos. Permiten realizar consultas más avanzadas
sobre el contenido de un documento, además de consultas
de clave-valor. Se apoyan en estructuras simples como
JSON o XML.

Ejemplos de bases de datos documentales: Elastichsearch y MongoDB.

Bases de datos orientadas a grafos

Las BBDD orientadas a grafos o bases de datos en
grafo ofrecen una experiencia de búsqueda más eficiente entre
relaciones, respecto a las bases de datos relacionales. Este
modelo usa estructuras de grafos para consultas semánticas y
representa los datos como nodos, bordes y propiedades.

Ejemplos de bases de datos orientadas a grafos: FlockDB,

 InfiniteGraph y OpenLink Virtuoso.

Bases de datos tabulares

Las BBDD tabulares ofrecen una solución híbrida
entre los sistemas de bases de datos (DBMS) tabulares y los
de clave-valor. Usa un formato tabular que permite variar
cómo se nombran y formatean los datos en cada fila dentro
de la misma tabla. Este tipo de BBDD
NoSQL acelera las consultas al almacenar los datos en
columnas.

Ejemplos de bases de datos tabulares: HBase, BigTable y Cassandra.

Bases de datos orientadas a objetos

Las BBDD orientadas a objetos
combinan las capacidades de las bases de
datos con las de los lenguajes de
programación orientados a objetos.
Los datos se representan en forma de
objetos.

Ejemplos de bases de datos orientadas a objetos: Db40,

GemStone/S y Realm.

MongoDB
MongoDB es un DBMS de código abierto, NoSQL y orientado a
documentos. MongoDB Inc. ofrece una suite integrada de servicios cloud
de bases de datos, así como soporte comercial. Se suele usar para
almacenar grandes volúmenes de datos.

Desarrollador: MongoDB Inc.

 Última actualización de MongoDB: MongoDB 6.0.1.
Licencia de MongoDB: Licencia pública del lado del servidor (SSPL).

Redis
Redis, abreviatura de «Remote Dictionary Server», es un
sistema de gestión de bases de datos de código abierto, NoSQL de
clave-valor.

Desarrollador: Redis.
Autor original: Salvatore Sanfilippo.
Última actualización de Redis: Redis 7.0.7.
Licencia de Redis: BSD de 3 cláusulas.

ObjectDB
ObjectDB es un DBMS orientado a
objetos, multiplataforma. Requiere usar una de las APIS estándar
de Java: JPA (Jakarta Persistence) o JDO (Java Data Objects). Está
pensado para proporcionar un mejor rendimiento y aplicaciones más
rápidas. Además, se presenta como la opción más productiva para
desarrollar aplicaciones de BBDD Java usando la API Java Persistence.

Desarrollador: ObjectDB Software.

Última actualización de ObjectDB: ObjectDB 2.8.8.
Licencia de ObjectDB: propietaria.

BigTable
BigTable es un sistema de gestión de bases de datos
completamente gestionado, de clave-valor y tabular. Está
diseñado para grandes cargas de trabajo analíticas y operativas.
Forma parte del portfolio de Google Cloud y, como tal, se utiliza
en muchas de las aplicaciones de Google como Google Analytics, Google Maps o
Gmail.

Desarrollador: Google.
Lanzamiento inicial de BigTable: 2005.
Licencia de BigTable: propietaria.

DynamoDB
DynamoDB o Amazon DynamoDB es un DBMS de
clavevalor y documental, multiplataforma. Forma parte del portfolio
de Amazon Web Services.

Desarrollador: Amazon.
Lanzamiento inicial de DynamoDB: 2012.
Licencia de DynamoDB: propietaria.

Cassandra
Cassandra o Apache Cassandra es un DBMS gratuito, de
código abierto y tabular —modelado a partir de BigTable—.

Está diseñado para soportar grandes volúmenes de datos y

garantizar alta disponibilidad sin puntos únicos de fallo. Inicialmente se desarrolló
para impulsar la búsqueda en la bandeja de entrada de Facebook.

Desarrollador: Apache Software Foundation.

Autores originales: Avinash Lakshman y Prashant Malik mientras
trabajaban en Facebook.

Última actualización de Cassandra: Cassandra 4.1.0.

Licencia de Cassandra: Licencia Apache 2.0.
HBase
HBase o Apache HBase es un sistema de gestión de bases de datos tabular,
de código abierto. Al igual que Cassandra, está modelado a partir de BigTable. Está
pensado para proporcionar una forma tolerante a fallos de almacenar grandes
cantidades de datos dispersos. HBase forma parte del proyecto Hadoop de Apache.

Desarrollador: Apache Software Foundation.

Autor original: Powerset.
Última actualización de HBase: HBase 2.4.14.
Licencia de HBase: Licencia Apache 2.0.

Elasticsearch
Elasticsearch es un motor de analíticas y búsqueda RESTful,
basado en la librería Lucene. Elasticsearch es el sucesor de un motor de
búsqueda anterior llamado Compass, también diseñado por Shay Banon.

Desarrollador: Elastic NV.

Autor original: Shay Banon.
Última actualización de Elasticsearch: Elasticsearch 8.5.0.
Licencia de Elasticsearch: Licencia dual bajo la licencia Elastic y
Licencia pública del lado del servidor.

CouchDB
CouchDB o Apache CouchDB es un DBMS de clave-valor, de
código abierto. Está optimizado para usarlo en dispositivos móviles
gracias a sus capacidades de sincronización y replicación. Permite
trabajar offline mientras la conexión de red no está disponible.

Desarrollador: Apache Software Foundation.

 Autores originales: Damien Katz, Jan Lehnardt, Naomi Slater,
Christopher Lenz,
J. Chris Anderson, Paul Davis, Adam Kocoloski, Jason Davies, Benoît
Chesneau, Filipe Manana y Robert Newson.

Última actualización de CouchDB: CouchDB 3.2.2.

Licencia de CouchDB: Licencia Apache 2.0.

InfiniteGraph
InfiniteGraph es un DBMS orientado a grafos,
multiplataforma, escalable y habilitado para la

nube.
Está pensado para soportar un rendimiento alto y optimizado para grandes
conjuntos de datos, altamente conectados y complejos.

Desarrollador: Objectivity, Inc.

Licencia de InfiniteGraph: propietaria.

Zope Object Database

Zope Object Database (ZODB) es un sistema de gestión
de BBDD orientado a objetos. Está diseñado para almacenar objetos
Python de modo transparente y persistente. Aunque está incluido en
el servidor de aplicación web de Zope, también se puede usar de
forma independiente.

Desarrollador: Zope Foundation.

Última actualización de Zope Object Database: ZODB 5.6.0.
Licencia de Zope Object Database: Licencia Pública Zope.
 Instalación de Anaconda y Python

Instalación

1. Descargamos anaconda

2. Le damos en aceptar

3. Le damos en solo para mi

4. Seleccionamos donde queremos que se instale

5. Le damos en register
6. Le damos en instalar

7. Ya instalado
8. El final
9. Abrimos la terminal

10. Crear una carpeta

11. Abrir Jupyterlab y ya esta instalado, y en la carpeta de pruebas

 Operaciones Aritméticas en Python

Ejercicios
1. En la división aritmética, por ejemplo 17/6, el cociente es 2 y el residuo es 5. De tal
manera que 6*2+5=17

En Phyton, el operador que muestra el cociente (parte entera de la

división 17/6) es //. Y el operador que calcula el residuo (resto, o módulo) es %.
 Utiliza Jupyter Notebook y JupiterLab para determinar si los siguientes
enunciados son verdaderos o falsos. a. 8 // 3 =2

b. 8 % 3= 1

c. 111 // 6=16

d. 194 % 2=0

e. La parte entera de 326 entre 15 es, 22

f. El residuo de dividir 978 entre 125 es, 103

g. 25 módulo 3 es, 1

2. Utiliza Jupyter Notebook y JupiterLab para realizar los siguientes cálculos.

Identifica aquel que genera un error y explica la

razón por la que ocurre.

a. 25 / 4=

b.

25 // 4=

c.

0 / 4=

d.

0 // 4=

e. 25 /

0=

f. 25 // 0=
3. Utiliza Jupyter Notebook y JupiterLab para realizar los siguientes cálculos. Guarda
tus resultados en un archivo con nombre prueba2. Identifica aquel que genera un error y
explica la razón por la que ocurre.

a. 32 / 8 -3=

b. 32 // 8 -3=

c. 32 / (8 -3)=

d. 32 // (8 -3)=
e. 32 / (8 -8)=

f. 32 / (8 -5)=
 Obtener Resultados De Una Página Web Con Python
1. Importamos las librerias necesarias

2. Se indica la url de la pagina

Futbol

1. Se importan las librerías y se asigna la url

Beautiful Soup: Build a Web Scraper With Python
1. Como primer paso inspecionamos la pagina
 2. Luego empezamos con el código para leer el contenido de una página
y como se puede ver si se lee el contenido de la pagina

3. Ahora haremos lo mismo, pero con Beautiful Soup, y como se puede

ver siempre sigue funcionando el contenido de la página pero en una parte en
específico.
4. Al igual que en el anterior, se imprime una pagina en especifico

5. Ahora buscaremos los elementos por identificación

 6. Ahora se extraerá un Extracto de texto de elementos HTML, y como
se puede ver aparece la información que esta puesta en el HTML pero ya no en
forma de código.

7. En este caso queda la celda vacia, ya que cuando usas string=Como

lo hiciste arriba, tu programa busca esa cuerda exactamente. Cualquier diferencia en
la ortidad, la capitalización o el espacio blanco impedirá que el elemento cointee.

8. En estos casos como el anterior no funciono se pasa al método

BeautifulSoup
 9. Sin embargo, cuando intentas ejecutar tu raspador para imprimir la
información de los trabajos filtrados de Python, te encontrarás con un error:
AttributeError: 'NoneType' object has no attribute 'text'

Este mensaje es un error común que se encontrará con mucho

cuando estás intentando hacer web scraping en la información de Internet. Así que
tendremos que inspeccionar el HTML de un elemento en tu python_jobslista.

10. En este punto ya se soluciono el error y ya esta te saca los enlaces de

los lugares junto con el nombre de las empresas y a que se dedican.
 Generación de texto en español con GPT-2
Ejecutamos estas líneas en nuestra terminal
• conda create -n gpt2 python=3.9 -y

# Activa el nuevo ambiente con: 'conda activate gpt2'

• conda install numpy tqdm transformers -y

# si tienes GPU instala Pytorch con:

• conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia

# si no tienes GPU, instala con:

• conda install pytorch torchvision torchaudio cpuonly -c pytorch
 Importamos las librerías
Ahora pasamos a un notebook o una IDE Python y empezamos importando las
librerías python que utilizaremos, incluyendo transformers de HuggingFace:

El uso del GPU o el CPU todo depende de en que entorno lo estes

manejando
Haremos una distinción; si vamos a utilizar GPU para entrenar ó CPU, definiendo
una variable llamada device. Nótese que también alteramos el tamaño que usaremos de
batch. En el caso de GPU, podemos utilizar valores 2 ó 3 según el tamaño de memoria
RAM que tenga la tarjeta gráfica.

Cargamos el Modelo de HuggingFace

 La primera vez que ejecutemos esta celda, tomará unos minutos en descargar los
500MB del modelo y el tokenizador en Español desde HuggingFace, pero luego ya se
utilizará esa copia desde el disco, siendo una ejecución inmediata.

Para este ejercicio estamos creando un “token especial” (de control) que llamaremos “ibai”
con el que luego indicaremos al modelo que queremos obtener una salida de este tipo.

Cargamos el Dataset “Ibai_textos.txt”

Creamos una clase python que hereda de Dataset que recibe el archivo txt que
contiene los textos para fine-tuning.
 Entrenamos haciendo el Fine-Tuning
Realizando entre 1 y 3 epochs debería ser suficiente para que el modelo quede
tuneado. Ahora si, a entrenar el modelo durante cerca de 2 horas si tenemos GPU ó durante
un día entero en CPU. El código es bastante estándar en PyTorch para entreno de redes
neuronales profundas; un loop principal por epoch donde procesamos por batches las
líneas de texto del dataset y hacemos backpropagation.
7. Guardar el modelo, para uso futuro

8. Crear Texto al estilo influencer

Juego del Pong en Python

1. Se importarán las librerías
 2. Crear la Clase Agente
Dentro de la clase Agente encontraremos la tabla donde iremos
almacenando las políticas.

En nuestro caso la tabla cuenta de 3 coordenadas:

• La posición actual del jugador.
• La posición “y” de la pelota.
• La posición en el eje “x” de la pelota.

3. Crear la Clase Environment

Encontramos implementada la lógica y control del juego del pong.
 4. Parte del Juego y la simulación
Finalmente definimos una función para jugar, donde indicamos la cantidad de
veces que queremos iterar la simulación del juego e iremos almacenando
algunas estadísticas sobre el comportamiento del agente, si mejora el puntaje
con las iteraciones
y el máximo puntaje
alcanzado.

5. Y vemos la salida del entreno, luego de unos 2 minutos:

 En las salidas vemos sobre todo cómo va mejorando en la cantidad de “steps” que
da el agente antes de perder la partida.

6. Y este es el Resultado

Análisis Exploratorio de Datos Python

1. Importar librerías

• import pandas as pd: Permite manipular y analizar datos mediante la biblioteca

pandas.
• import numpy as np: Facilita operaciones numéricas eficientes utilizando la
biblioteca numpy.
• import matplotlib.pyplot as plt: Ofrece capacidades de visualización mediante el
módulo pyplot de la biblioteca matplotlib.
• import statsmodels.api as sm: Proporciona herramientas avanzadas para realizar
análisis estadísticos, como la estimación de modelos y pruebas de hipótesis,
utilizando la biblioteca statsmodels.

2. Carga de archivo csv desde una URL

Este descarga un conjunto de datos sobre países desde una URL que
apunta a un archivo CSV. Luego, utiliza la biblioteca pandas para cargar
esos datos en un DataFrame llamado df. Finalmente, imprime las primeras
5 filas de este DataFrame para mostrar una vista previa de la información
contenida en el archivo CSV.

3. Conocer la Información básica

 Estos dos bloques de código proporcionan información básica sobre
la estructura del DataFrame, mostrando la cantidad de filas y columnas, así
como los nombres de las columnas.

4. Descripción concisa
Proporciona una descripción concisa y general del DataFrame. Esta
función de pandas imprime información sobre el índice, el tipo de datos y
la memoria utilizada. En resumen, es una forma rápida de obtener una
visión general de la estructura de los datos contenidos en el DataFrame.

5. Generar estadísticas
Genera estadísticas descriptivas para cada columna numérica en el
DataFrame, como la media, la desviación estándar, los cuartiles, etc.
Proporciona una visión general rápida de la distribución y la variabilidad
de los datos numéricos en el DataFrame. Es útil para obtener una
comprensión inicial de la naturaleza de los datos cuantitativos.

Y aquí se puede observar la descripción que se lleva a cabo

6. Matriz de Correlación
Calcula y visualiza la matriz de correlación entre las variables
numéricas de un DataFrame, ayudando a entender las relaciones lineales
entre estas variables.

7. Cargar una segunda fuente de datos

Descarga datos sobre el crecimiento de la población desde una URL
que apunta a un archivo CSV y carga esos datos en un DataFrame llamado
df_pop. Luego, imprime las primeras 5 filas del DataFrame para
proporcionar una vista previa de la información contenida en el archivo
CSV.
8. Población de España año tras año
Crea un nuevo DataFrame llamado df_pop_es que contiene solo las filas del
DataFrame original (df_pop) donde la columna "country" es igual a

'Spain' (España). Luego, imprime las primeras filas del DataFrame

df_pop_es para mostrar información específica sobre el crecimiento de la

población en España.

9. Visualizar datos
Elimina la columna 'country' de un DataFrame que contiene datos
de crecimiento de población para España y luego representa gráficamente
la evolución de la población en España a lo largo del tiempo mediante un
gráfico de barras.
10. Crecimiento de la población en Argentina
Crea un nuevo DataFrame llamado df_pop_ar que contiene solo

las filas del DataFrame original ( df_pop) donde la columna "country" es

igual a 'Argentina'. Luego, imprime las primeras filas del DataFrame

df_pop_ar para mostrar información específica sobre el crecimiento de la

población en Argentina.

11. Dupla de dimensiones

Devuelve la tupla de dimensiones del DataFrame df_pop_ar, que

representa la cantidad de filas y columnas en ese DataFrame. En este

contexto, proporciona la cantidad de datos disponibles para el crecimiento
de la población en Argentina.
12. Grafica de barras de la evolución del crecimiento en la evolución de Argentina Establece la
columna 'year' como índice del DataFrame df_pop_ar y luego crea un gráfico de barras que
muestra la evolución del crecimiento de la población en Argentina a lo largo del tiempo.
Cada barra representa un año, y la altura de la barra indica el valor correspondiente al
crecimiento de la población
en ese año.

13. Comparativa entre dos países

Crea un DataFrame (df_plot) utilizando los datos de población de
Argentina y España para los años específicos disponibles en ambos
conjuntos de datos. Luego, genera un gráfico de barras que compara el
crecimiento de la población en Argentina y España para cada año. Cada
barra representa un año, y las alturas de las barras comparan las
poblaciones de ambos países en ese año.
14. Filtrar países hispanohablantes
Filtra un DataFrame para incluir solo las filas donde el idioma
principal es el español ('es'). También reemplaza los valores NaN con
cadenas de texto vacías:

15. Dupla de dimensiones

Devuelve la tupla de dimensiones del DataFrame df_espanol, que
representa la cantidad de filas y columnas en ese DataFrame después de
aplicar las operaciones de filtrado y reemplazo de NaN. Proporciona
 información sobre la cantidad de datos disponibles en el conjunto de datos
resultante que incluye solo las filas donde el idioma principal es español.

16. Visualizar por población

Visualiza las poblaciones y áreas de los países de habla hispana en
un gráfico de barras, donde los nombres de los países están rotados para
mejorar la legibilidad:

17. Detección de outliers

Utiliza una función llamada find_anomalies para detectar

anomalías (outliers) en la columna 'population' del DataFrame df_espanol.

La función calcula límites superior e inferior basados en la media y la

desviación estándar y identifica las filas que caen fuera de estos límites
como anomalías. Las filas identificadas como anomalías se almacenan en
la lista anomalies.
18. Eliminar filas
Elimina las filas correspondientes a los países con códigos 'BRA' (Brasil) y

'USA' (Estados Unidos) del DataFrame df_espanol. Se utiliza el

método drop con los índices 30 y 233 y se especifica inplace=True para

realizar la modificación directamente en el DataFrame original.

19. Visualizar poblaciones y áreas de los países habla hispana

Visualiza las poblaciones y áreas de los países de habla hispana,
después de eliminar las filas correspondientes a Brasil y Estados Unidos,
en un gráfico de barras con nombres de países rotados para mejorar la
legibilidad:
20. Graficar ordenando por tamaño de población
Visualiza las poblaciones y áreas de los países de habla hispana en
un gráfico de barras ordenado por población, con nombres de países
rotados para mejorar la legibilidad:

21. Visualizar por área

 Visualiza las áreas de los países de habla hispana en un gráfico de
barras ordenado por área, con nombres de países rotados para mejorar la
legibilidad:

22. Filtrar
Filtra el DataFrame df_espanol para incluir solo las filas donde el

valor en la columna 'area' es mayor a 110,000 km². El nuevo DataFrame

resultante se llama df_2. En resumen, este código selecciona países de

habla hispana con áreas superiores a 110,000 km²

23. visualizar las áreas de los países de habla hispana con áreas superiores a 110,000 km²
 Visualiza las áreas de los países de habla hispana con áreas
superiores a 110,000 km² en un gráfico de barras, ordenado por área y con
nombres de países rotados para mejorar la legibilidad:
 Práctica Graficas en Python 1
Ejercicio 1
Escribir un programa que pregunte al usuario por las ventas de un rango de años y muestre
por pantalla un diagrama de líneas con la evolución de las ventas.

import matplotlib.pyplot as plt

# Solicitar al usuario el rango de años anio_inicial

= int(input("Ingrese el año inicial: ")) anio_final
= int(input("Ingrese el año final: "))

# Inicializar una lista vacía para los datos de ventas ventas_datos = []

# Solicitar al usuario las ventas para cada año en el rango for anio in
range(anio_inicial, anio_final + 1):
venta = float(input(f"Ingrese las ventas para el año {anio}: "))
ventas_datos.append(venta)

# Crear un diagrama de líneas con la evolución de las ventas

plt.plot(ventas_datos) plt.title(f"Evolución de Ventas desde {anio_inicial}
hasta {anio_final}") plt.xlabel("Año") plt.ylabel("Ventas") plt.show()

1. Importar la biblioteca matplotlib.pyplot con el alias plt para poder utilizar sus funciones
de trazado de gráficos.
2. Solicitar al usuario que ingrese el año inicial y final del rango que desea analizar.
3. Inicializar una lista vacía llamada ventas_datos para almacenar los datos de ventas de cada
año.
4. Utilizar un bucle for para iterar a través de cada año en el rango especificado por el usuario.
5. En cada iteración del bucle, solicitar al usuario que ingrese las ventas para el año
correspondiente y agrega este valor a la lista ventas_datos.
6. Utilizar la función plt.plot() de Matplotlib para crear un diagrama de líneas con los datos de
ventas. En este caso, se traza la evolución de las ventas a lo largo de los años.
7. Se agrega un título al gráfico utilizando plt.title() que indica la evolución de ventas desde el
año inicial hasta el año final.
8. Se etiquetan los ejes x e y del gráfico con "Año" y "Ventas", respectivamente, utilizando
plt.xlabel() y plt.ylabel().
9. Finalmente, se muestra el diagrama de líneas utilizando plt.show().
10. Se ejecutará el código
Y se obtiene esto

Ejercicio 2
Escribir una función que reciba un diccionario con las notas de las asignaturas de un curso
y una cadena con el nombre de un color y devuelva un diagrama de barras de las notas en
el color dado.
 import matplotlib.pyplot as plt def
crear_diagrama_barras(notas, color):
"""
Crea un diagrama de barras de las notas de un curso en un color
específico.

Parámetros: notas (dict): Un diccionario con el nombre de la

asignatura como clave y la nota como valor. color (str): Una cadena
con el nombre de un color.

Devuelve:
None: Muestra el diagrama de barras.
"""

# Extraer los nombres de las asignaturas y las notas en dos

listas separadas asignaturas = list(notas.keys())
notas_valores = list(notas.values())

# Crear el diagrama de barras con el color especificado

plt.bar(asignaturas, notas_valores, color=color)

# Agregar etiquetas y título al diagrama de

barras plt.xlabel("Asignaturas")
plt.ylabel("Notas") plt.title("Diagrama de
Barras de Notas")

# Mostrar el diagrama de barras

plt.show()

# Ejemplo de uso notas = {"Matemáticas": 8.5, "Física": 9.0, "Química":

7.0, "Programación":
10.0} crear_diagrama_barras(notas,
"lightblue")

1. La función crear_diagrama_barras toma dos parámetros:

• notas: Un diccionario donde las claves son los nombres de las asignaturas y los valores son
las notas.
• color: Una cadena que especifica el color que se utilizará para las barras del diagrama.

2. Dentro de la función, se extraen los nombres de las asignaturas y las notas del diccionario y
se almacenan en listas separadas.
3. Se utiliza plt.bar() para crear el diagrama de barras. Se pasan las listas de asignaturas y
notas, junto con el color especificado.
4. Se agregan etiquetas a los ejes x e y del diagrama utilizando plt.xlabel() y plt.ylabel()
respectivamente.
5. Se agrega un título al diagrama utilizando plt.title(). 6. Finalmente, se muestra el diagrama
de barras utilizando plt.show().

Se ejecutará el código

Y obtendremos esto:

Ejercicio 3
Escribir una función que reciba una serie de Pandas con las notas de los alumnos de un
curso y devuelva un diagrama de cajas con las notas. El diagrama debe tener el título
“Distribución de notas”.
import pandas as pd import
matplotlib.pyplot as plt def
 crear_diagrama_cajas(notas_serie)
:
"""
Crea un diagrama de cajas de las notas de los alumnos de un curso.

:param notas_serie: Una serie de Pandas con las notas de los alumnos.
:return: None
"""
# Crear un DataFrame con las notas notas_df =
pd.DataFrame(notas_serie, columns=["Notas"])

# Crear el diagrama de cajas

plt.boxplot(notas_df["Notas"])

# Agregar título y etiquetas

plt.title("Distribución de notas")
plt.xlabel("Notas")

# Mostrar el diagrama
plt.show()

# Ejemplo de uso: notas = pd.Series([8.5, 9.0, 7.8, 6.2, 9.5, 8.8,

7.6, 9.1, 8.2, 7.9]) crear_diagrama_cajas(notas)

1. Importar las bibliotecas necesarias: pandas y matplotlib.pyplot.

2. Definir una función llamada crear_diagrama_cajas que toma una serie de Pandas que
contiene las notas de los alumnos como entrada.
3. Dentro de la función:
• Convierte la serie de notas en un DataFrame con una columna llamada "Notas".
• Utiliza plt.boxplot() para crear el diagrama de cajas con las notas del DataFrame.
• Agrega un título al diagrama de cajas utilizando plt.title() y etiqueta el eje x como "Notas"
utilizando plt.xlabel().
• Muestra el diagrama de cajas utilizando plt.show().
4. Ejecutar un ejemplo de uso de la función crear_diagrama_cajas con una serie de notas
ficticias. Ejecutar el código:

Se obtendrá esto:
 Practica 2 Graficas Python
1.- Ejercicio 4:

Importamos las bibliotecas pandas y matplotlib con los alias pd y plt, respectivamente.
Posteriormente, definimos nuestra función llamada "diagrama_evolucion_ventas".
Dentro de esta función, utilizamos el diccionario "gráficos" con la ayuda de plt, que
nos proporcionará herramientas para generar gráficos de líneas, barras, sectores y
áreas. Utilizamos el DataFrame df_ventas, donde los años actúan como índices.
 import pandas as pd
import matplotlib.pyplot

as plt

def diagrama_evolucion_ventas(ventas, tipo): #

Definimos un diccionario con los tipos de gráficos graficos
= {'lineas':'line', 'barras':'bar', 'sectores':'pie', 'area':'area'} #
Definimos la figura y los ejes del gráfico con Matplotlib
fig, ax = plt.subplots()

# Dibujamos las series de líneas con los ingresos y los gastos

ventas.plot(kind = graficos[tipo], ax = ax)

# Añadimos el título
plt.title('Evolución del número de ventas')

# Devolvemos el objeto con los ejes y el gráfico que contienten

return ax

df_ventas = pd.Series([1200, 840, 1325, 1280, 1500], index = [2000, 2001, 2002,
2003, 2004]) diagrama_evolucion_ventas(df_ventas, 'lineas') plt.show()
diagrama_evolucion_ventas(df_ventas, 'area') plt.show()
diagrama_evolucion_ventas(df_ventas, 'barras') plt.show()

diagrama_evolucion_ventas(df_ventas, 'sectores') plt.show()

Imagen funcionando:
 Actividad 5:

Importamos las bibliotecas pandas y matplotlib con los alias pd y plt,

respectivamente. En esta fase, nos enfocamos en la importación de las herramientas
necesarias para el ejercicio. Posteriormente, definimos la biblioteca de pandas para el
manejo de datos y la generación de gráficos.

Luego, procedemos a leer el archivo llamado "titanic.csv". Después de la lectura,

creamos la figura y los conjuntos de ejes mediante plt. A continuación, calculamos los
valores de la columna 'survived' utilizando el DataFrame df_titanic y generamos un
gráfico de pastel para visualizar la proporción de fallecidos y supervivientes.

import pandas as pd
import matplotlib.pyplot

as plt

def diagrama_evolucion_ventas(ventas, tipo): #

Definimos un diccionario con los tipos de gráficos graficos
= {'lineas':'line', 'barras':'bar', 'sectores':'pie', 'area':'area'} #
Definimos la figura y los ejes del gráfico con Matplotlib
fig, ax = plt.subplots()

# Dibujamos las series de líneas con los ingresos y los gastos

ventas.plot(kind = graficos[tipo], ax = ax)

# Añadimos el título
plt.title('Evolución del número de ventas')

# Devolvemos el objeto con los ejes y el gráfico que contienten

return ax

df_ventas = pd.Series([1200, 840, 1325, 1280, 1500], index = [2000, 2001, 2002,
2003, 2004]) diagrama_evolucion_ventas(df_ventas, 'lineas') plt.show()
diagrama_evolucion_ventas(df_ventas, 'area') plt.show()
diagrama_evolucion_ventas(df_ventas, 'barras') plt.show()

diagrama_evolucion_ventas(df_ventas, 'sectores')
plt.show()
 Actividad 6:

Importamos las bibliotecas pandas y matplotlib. Utilizaremos la misma función

denominada "diagrama_evolucion_ventas", que genera una serie de pandas con las ventas,
utilizando los años como índices. Luego, se accede al gráfico para mapear los tipos de
gráficos con los pandas. Se crea la figura y los ejes con plt.

El código existente posibilita la creación del gráfico y, al llamarlo, devuelve el

objeto del gráfico. Además, permite agregar un título al gráfico y devuelve el objeto de los
ejes. Se define el DataFrame df_ventas con las ventas correspondientes a los años.

import pandas as pd
import matplotlib.pyplot

as plt
 def diagrama_lineas_ingresos_gastos(datos):

# Definimos la figura y los ejes del gráfico con

Matplotlib fig, ax = plt.subplots()

# Dibujamos las series de líneas con los ingresos y los gastos

datos.plot(ax = ax)

# Añadimos la escala del eje y ax.set_ylim([0, max(datos.Ingresos.max(),

datos.Gastos.max()) + 500])

# Añadimos el título
plt.title('Evolución de ingresos y gastos')

# Devolvemos el objeto con los ejes y el gráfico que contienten

return ax

datos = {'Mes':['Ene', 'Feb', 'Mar', 'Abr'], 'Ingresos':[4500, 5200, 4800,

5300], 'Gastos':[2300, 2450, 2000, 2200]} df_datos =
pd.DataFrame(datos).set_index('Mes')
diagrama_lineas_ingresos_gastos(df_datos) plt.show()

Actividad 8:
 Importamos la Librería pandas como pd y matplotlib como plt, ahora solo
andamos haciendo la importación del ejercicio, ahora definiremos la biblioteca de pandas
como el manejo de datos y el trazdo de gráficos, leeremos el archivo llamado titanic.csv,
ahora después de leerlo se creara la figura y los conjuntos de ejes.
Ahora calcularemos el valor de las columnas del survicved que es el dataframe con
el df_titanic, con un grafico de pasteles y obtendremos el pastel de muertos y
supervivientes.

import pandas as pd
import matplotlib.pyplot as plt

# Creamos un dataframe a partir del

fichero csv df_titanic =
pd.read_csv('titanic.csv') # Creamos la figura
y los ejes fig, ax = plt.subplots()

# Diagrama de sectores de falleccidos y supervivientes

df_titanic.Survived.value_counts().plot(kind = "pie", labels =

["Muertos", "Supervivientes"], title = "Distribución de supervivientes") plt.show()

 Graficas del Proyecto Integrador
Introducción:
En la actualidad, el análisis de datos se ha convertido en un pilar fundamental en una amplia
gama de industrias y disciplinas. Desde la medicina hasta las finanzas, pasando por la
ingeniería y el marketing, el poder de los datos para generar conocimiento y tomar decisiones
informadas es innegable. En este contexto, herramientas como Anaconda JupyterLab
Notebook emergen como aliados indispensables, brindando a los usuarios un entorno
interactivo y flexible para explorar, analizar y visualizar datos de manera efectiva.
 #Importamos las Librerías necesarias Import
requests from bs4 import BeautifulSoup
import matplotlib.pyplot as plt

- requests: Esta librería permite enviar solicitudes HTTP fácilmente desde Python. Se usa para
obtener el contenido HTML de una página web.
- BeautifulSoup: Es una librería de Python para extraer datos de archivos HTML y XML. Se
utiliza para analizar el contenido HTML y extraer la información deseada.
- matplotlib.pyplot: Es una librería de trazado de gráficos en 2D de Python. Se utiliza para
visualizar los datos en forma de gráficos.

# Obtener el HTML de la página web

url = "http://renegade.com/" response =
requests.get(url) html_content =
response.text

Aquí, se define la URL de la página web que deseas analizar (url). Luego, se envía una
solicitud HTTP GET a esa URL utilizando requests.get(url), y el contenido HTML de la página
se guarda en la variable html_content.

# Analizar el HTML con BeautifulSoup soup =

BeautifulSoup(html_content, "html.parser")

Se utiliza BeautifulSoup para analizar el contenido HTML de la página web.

html.parser es un analizador HTML incorporado en Python que utiliza BeautifulSoup para
analizar el HTML.

# Extraer los datos de los productos destacados productos_destacados = {}

categorias = soup.find_all("h5", class_="white-text center bold") tablas =
soup.find_all("table", class_="highlight centered responsive-table") for i, categoria in
enumerate(categorias): productos_destacados[categoria.text] = {}
tabla = tablas[i] filas =
tabla.find_all("tr") for fila in filas[1:]:
columna = fila.find_all("td") producto =
columna[0].text precio =
float(columna[1].text.strip("$"))
productos_destacados[categoria.text][producto] =
precio extrae los datos de los productos destacados de
la página web. Utiliza las etiquetas HTML específicas y
sus clases para encontrar las categorías y los precios
de los productos.
# Generar gráficas for categoria, productos in
productos_destacados.items(): productos_nombres =
list(productos.keys())
precios = list(productos.values())

plt.figure(figsize=(8, 6))
plt.bar(productos_nombres, precios, color='skyblue')
plt.xlabel('Productos') plt.ylabel('Precio ($)')
plt.title(f'Precios de Productos Destacados en la categoría "{categoria}"')
plt.xticks(rotation=45, ha='right') plt.tight_layout() plt.show()

código genera gráficas para visualizar los precios de los productos destacados en cada
categoría. Utiliza matplotlib.pyplot para trazar gráficos de barras con nombres de productos en
el eje x y precios en el eje y.
Resultados Obtenidos
import matplotlib.pyplot as plt
 import seaborn as sns # Importamos Seaborn para acceder a paletas de colores más
atractivas
from bs4 import BeautifulSoup import requests

- matplotlib.pyplot: Se utiliza para trazar gráficos en 2D en Python.

- seaborn: Es una librería de visualización de datos basada en matplotlib, que proporciona una
interfaz de alto nivel para dibujar gráficos estadísticos atractivos y informativos.
- BeautifulSoup: Se utiliza para analizar el contenido HTML de la página web.
- requests: Se usa para enviar solicitudes HTTP GET a la URL especificada y obtener los datos.

# URL que contiene los datos

url = "http://renegade.com/"

# Hacemos la solicitud GET a la URL para obtener los datos response =

requests.get(url)

# Parseamos el HTML con BeautifulSoup

soup = BeautifulSoup(response.text, 'html.parser')

Aquí, se envía una solicitud GET a la URL proporcionada, y luego se utiliza

BeautifulSoup para analizar el contenido HTML de la página web.

# Buscamos la tabla que contiene los datos del rendimiento de ventas por producto
table = soup.find_all('table')[-1] # Última tabla, según el HTML proporcionado

# Extraemos los datos de la tabla y los almacenamos en una lista de listas rows =
table.find_all('tr') data = [] for row in rows:
cols = row.find_all(['td', 'th']) cols =
[col.text.strip() for col in cols]
data.append(cols)

Este bloque de código busca la última tabla en la página web, que se supone que contiene los
datos de rendimiento de ventas por producto. Luego extrae los datos de la tabla y los
almacena en una lista de listas llamada data.
# Eliminamos la fila de encabezado
data = data[1:]

# Transponemos los datos para que los meses estén en las filas y los productos en las
columnas
data_transposed = list(zip(*data))
Los datos se transponen para que los meses estén en las filas y los productos en las
columnas, lo que facilita la manipulación de los datos para la visualización.

# Obtenemos las etiquetas de los productos y los datos de ventas productos =

data_transposed[0]
ventas = [list(map(int, ventas_mes)) for ventas_mes in data_transposed[1:]]

# Definimos las etiquetas del eje x en base a la longitud de los datos de ventas
disponibles
etiquetas_meses = ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio'][:len(ventas[0])]

Se extraen los nombres de los productos y los datos de ventas por mes. Además, se definen
las etiquetas de los meses en base a la longitud de los datos de ventas disponibles.

# Utilizamos una paleta de colores de Seaborn palette =

sns.color_palette("husl", len(productos))

# Graficamos cada producto por separado for producto, ventas_producto,

color in zip(productos, ventas, palette):
plt.figure(figsize=(10, 6))
plt.bar(etiquetas_meses, ventas_producto, color=color, width=0.5) # Ajustamos el ancho de
las barras
plt.title(f'Rendimiento de ventas de {producto}')
plt.xlabel('Mes') plt.ylabel('Ventas')
plt.xticks(rotation=45) plt.grid(True) plt.tight_layout()
plt.show()

Se utiliza una paleta de colores de Seaborn para asignar un color diferente a cada producto.
Luego, se itera sobre cada producto y se grafica su rendimiento de ventas a lo largo de los
meses.
Resultados Obtenidos

Conclusión:
En conclusión, el análisis de datos en Anaconda JupyterLab Notebook ofrece un marco
robusto para abordar los desafíos de la era digital. Al proporcionar una plataforma intuitiva y
poderosa para la manipulación de datos, esta herramienta no solo fortalece las habilidades
analíticas de los usuarios, sino que también impulsa la innovación y el descubrimiento en
múltiples campos. En un mundo cada vez más orientado a los datos, dominar estas
habilidades se vuelve esencial para el éxito profesional y académico.

Conclusión
En el emocionante viaje a través del Big Data con Python como guía, hemos
explorado las profundidades de un universo digital en constante expansión y evolución.
Desde la manipulación de datos hasta la generación de conocimientos significativos, Python
ha demostrado ser una herramienta incomparable en el arsenal del analista de datos
moderno. Su flexibilidad, eficiencia y robustez lo convierten en el lenguaje ideal para
abordar los desafíos del Big Data en todas sus dimensiones.

Desde el análisis exploratorio de datos hasta el desarrollo de juegos y la generación

de texto mediante inteligencia artificial, hemos presenciado el poder transformador de
Python en acción. Su capacidad para manejar grandes volúmenes de datos, su amplia gama
de bibliotecas especializadas y su comunidad vibrante de desarrolladores hacen de Python
la opción preferida para cualquier proyecto de Big Data, ya sea en la academia, la industria
o la investigación.

En un mundo cada vez más impulsado por los datos, dominar Python se ha
convertido en una habilidad esencial para cualquier profesional que busque sobresalir en el
campo del Big Data. Ya sea que estemos analizando tendencias de mercado, descubriendo
patrones ocultos en conjuntos de datos masivos o desarrollando soluciones innovadoras,
Python nos brinda las herramientas necesarias para triunfar en este apasionante viaje hacia
el futuro digital. En última instancia, con Python como aliado, el potencial del Big Data es
verdaderamente ilimitado, y el único límite es nuestra imaginación y creatividad.