Machine Translated by Google

Machine Translated by Google

Machine Translated by Google
Machine Translated by Google
Machine Translated by Google

© Copyright 2019 ­ Todos los derechos reservados.

El contenido de este libro no puede reproducirse, duplicarse ni transmitirse sin el permiso directo por escrito del autor o del editor.

Bajo ninguna circunstancia se tendrá culpa o responsabilidad legal contra el editor o el autor por cualquier daño, reparación o
pérdida monetaria debido a la información contenida en este libro. Ya sea directa o indirectamente.

Aviso Legal:

Este libro está protegido por derechos de autor. Este libro es sólo para uso personal. No puede modificar, distribuir, vender, usar,
citar o parafrasear ninguna parte o el contenido de este libro sin el consentimiento del autor o editor.

Aviso de exención de responsabilidad:

Tenga en cuenta que la información contenida en este documento tiene fines educativos y de entretenimiento únicamente. Se
han realizado todos los esfuerzos posibles para presentar información precisa, actualizada, confiable y completa. No se declaran
ni implican garantías de ningún tipo. Los lectores reconocen que el autor no se dedica a brindar asesoramiento legal, financiero,
médico o profesional. El contenido de este libro se ha obtenido de diversas fuentes. Consulte a un profesional autorizado antes
de intentar cualquier técnica descrita en este libro.

Al leer este documento, el lector acepta que bajo ninguna circunstancia el autor es responsable de las pérdidas, directas o
indirectas, que se produzcan como resultado del uso de la información contenida en este documento, incluidos, entre otros,
errores, omisiones o inexactitudes.
Machine Translated by Google

TABLA DE CONTENIDO

Introducción

Describir:

Capítulo 1: Conceptos básicos de Python

Capítulo 2: Análisis de datos con Python

Capítulo 3: Visualización de datos con Python
Capítulo 4: Capítulo adicional: Introducción al aprendizaje
automático con Python

Capítulo 1 : Conceptos básicos de Python

Historia de Python
Instalación de Python
Ventanas:
Sistema operativo Mac/Linux:

Ventanas:

El navegador Anaconda
Codificar con Python: los rudimentos
Declaraciones, comandos y expresiones
Comentarios

Tipos de datos de Python

Números

Enteros
flotadores

Números complejos
Instrumentos de cuerda

Concatenación de cadenas
variables
Liza

Indexación de listas

Indexación de cadenas

tuplas
Diccionarios
Machine Translated by Google

Booleanos

Operadores de comparación
Operadores logicos

Declaraciones condicionales y bucles

Comprensión de listas
Funciones

Capítulo 2 : Análisis de datos con Python

NumPy
Instalación del paquete

Manipulación de matrices

Indexación y selección de matrices.

Selección condicional

Operaciones de matriz numérica

pandas

Serie
marcos de datos

Selección condicional

Datos perdidos
Agrupar por

Concatenar, unir y fusionar

Leer y escribir datos
Leer
Escribir

Capítulo 3 : Visualización de datos con Python

Matplotlib
nacido en el mar

pandas

Capítulo 4 : Aprendizaje automático con Python Entonces,

¿qué es el aprendizaje automático?

Bien, el aprendizaje automático es genial. ¿Cómo se relaciona

con la ciencia de datos?

Python y el aprendizaje automático

Machine Translated by Google

Tipos de aprendizaje automático

Conclusión
Machine Translated by Google

Introducción

Según un informe publicado por LinkedIn, la ciencia de datos es uno de los campos tecnológicos de
más rápido crecimiento en los últimos 7 años. La necesidad de que las empresas comprendan
mejor los datos generados a través de su negocio ha despertado mucho interés en este campo. Sin
embargo, existe una brecha que superar, ya que la oferta de científicos de datos competentes es
muy inferior a la demanda. Esto hace que la ciencia de datos sea una habilidad muy demandada,
con una generosa compensación para los pocos que poseen la cartera relevante. En promedio, un
científico de datos gana alrededor de 109.000 dólares al año (según glassdoor.com); esto coloca a
los científicos de datos en las filas mejor pagadas de la industria tecnológica. Esto tiende a plantear
ciertas preguntas: en una escala que va desde la "ciencia espacial" hasta la "física cuántica", ¿qué
tan complicada es la ciencia de datos? Bueno, si usted, como muchas otras personas (incluido yo
mismo), se ha preguntado qué es la ciencia de datos y por qué los científicos de datos tienen tanta
demanda, entonces esa pregunta no es tan descabellada.
Por el contrario, la ciencia de datos no es tan complicada.

A riesgo de simplificar demasiado, la ciencia de datos es simplemente la aplicación de diversas

técnicas, que generalmente emplean la organización, visualización e interpretación de datos rápida
y eficiente de programas o software de computadora para transformar datos sin procesar en
información para la toma de decisiones. Este tipo de información es útil para los gerentes de
instituciones corporativas para evaluaciones de riesgos informadas, optimización de ganancias,
detección de fraude, etc. Imagine las grandes perspectivas que la ciencia de datos ofrece a tales
empresas para estar constantemente por delante de la competencia (suponiendo que la competencia
no aproveche por igual las ventajas). maravilla de la ciencia de datos).
Los anuncios están mejor dirigidos a los consumidores, las empresas son más conscientes de su
desempeño económico y de posibles tendencias u opciones en la producción, etc.
Estas perspectivas disponibles sirven como excelentes motivaciones para considerar una carrera en ciencia de
datos. Sin embargo, sin las herramientas, la orientación y la dedicación adecuadas, dominar las habilidades
necesarias para la ciencia de datos sería una tarea muy tediosa y larga. Ésta es la razón por la que escribo este
libro; para ponerlo al día sobre las habilidades y herramientas para comenzar un viaje hacia el apasionante y
gratificante mundo de la ciencia de datos.

En este punto, probablemente esté bastante entusiasmado con la ciencia de datos y los secretos
que tiene para ofrecer; sin embargo, puede preguntarse "¿qué tiene que ver Python con esto?"

¿Recuerda que la ciencia de datos aprovecha la excepcional capacidad de procesamiento y

manipulación de datos de las computadoras? Para ello, el científico de datos debe
Machine Translated by Google

comunicar la tarea de manera clara y lógica a la computadora. El problema surge en el hecho de

que las computadoras no entienden el lenguaje humano; de ahí la necesidad de lenguajes de
programación que permitan comunicaciones poderosas entre personas y computadoras.

Python es un lenguaje de programación de alto nivel que reduce la complejidad de la codificación

utilizando expresiones casi humanas en su sintaxis. Esto permite a los programadores crear
algoritmos y sistemas complejos con rendimientos excepcionales, al tiempo que reducen el
tiempo y los recursos de codificación. Además, Python tiene una extensa biblioteca de
herramientas y aplicaciones que hacen que la ciencia de datos sea menos técnica para
programadores principiantes o intermedios. Por lo tanto, la mayoría de los científicos de datos
tienen Python como su herramienta principal para big data, análisis de datos, etc.

Ahora, aquí está el momento de la pastilla roja y la pastilla azul. Este libro ha sido cuidadosamente
diseñado para llevarlo en un viaje para aprovechar el potencial de Python para la ciencia de
datos. Sin embargo, el alcance de tu progreso también depende de ti. Cada capítulo se describe
para presentar un concepto determinado y se brindan consejos útiles que le permitirán evitar
errores comunes de Noob (Noob es una jerga de programación para principiantes). Además,
habrá ejercicios de práctica para que puedas ponerte a prueba después de cada capítulo. Esto
pretende servir como motivación para practicar las técnicas o lecciones que se introdujeron en
el capítulo.

Se espera que, al seguir cada sección de este libro y practicar todas las lecciones presentadas,
así como las preguntas de práctica incluidas, no solo habrá aprendido las técnicas básicas
necesarias para usar Python para la ciencia de datos, sino que también tendrá confianza para
Construya sus propios sistemas y proyectos prácticos utilizando Python.

El resumen de este libro se detalla a continuación y es una guía para maximizar su uso
dependiendo de su nivel en programación. En este sentido, le deseo buena suerte en su recorrido
por este libro para convertirse en un científico de datos con Python.
Machine Translated by Google

Describir:

Capítulo 1: Conceptos básicos

de Python Este capítulo le presenta los conceptos básicos de Python. El alcance de
este capítulo abarca todos los detalles necesarios para comenzar con Python: descarga
e instalación de paquetes y herramientas de Python relevantes, es decir, Anaconda,
administración de entornos Python y codificación real con Python. Esto es especialmente
importante para aquellos con poca o ninguna experiencia en programación. Incluso con
experiencia en programación (pero nuevo en Python), es recomendable leer este capítulo.
La mayoría de las lecciones de este capítulo se recordarán en capítulos posteriores
a medida que profundicemos en las aplicaciones de Python para la ciencia de datos.
Sin embargo, si ya conoce los conceptos básicos de Python y puede manejar
problemas prácticos con Python, puede omitir este capítulo. Al final de este capítulo,
se completará un proyecto básico usando Python y también podrá probar algunos
de los ejercicios que siguen. Estos ejercicios incorporarían todas las lecciones del
capítulo y realizarlos aceleraría enormemente su progreso.

Capítulo 2: Análisis de datos con Python Aquí,

las habilidades y técnicas aprendidas en el capítulo 1 se aprovechan para iniciarse en
la ciencia de datos. Se presentan los marcos más importantes (y populares) para
analizar y estructurar datos con Python, es decir, los marcos NumPy y Pandas. Se
considerarán algunos ejemplos prácticos sobre el uso de estos marcos y se
proporcionarán ejercicios de práctica.

Capítulo 3: Visualización de datos con Python Este

capítulo presenta al lector varias técnicas de trazado en Python.
Existen varias bibliotecas de gráficos para la visualización de datos usando Python,
que incluyen: Matplotlib, Seaborn y Pandas, etc. La visualización de datos es una
parte importante de la ciencia de datos, ya que explica mejor los datos analizados
mediante representaciones gráficas. Por ejemplo, sería mucho más fácil ver la
tendencia de suscripción de los usuarios a un servicio a través de un cuadro, gráfico
o incluso un pictograma, en lugar de simplemente mirar números en una hoja de
cálculo o tabla. Esta es la esencia de las bibliotecas de visualización de datos
disponibles a través de Python, y exploraremos sus capacidades y uso específico en
este capítulo. Además, aquí se presentarán ejemplos y se darán preguntas prácticas relevantes. A
Machine Translated by Google

En este capítulo, puede ser aconsejable repasar todas las lecciones del capítulo 2 y, una
vez que esté seguro de su competencia, intentar resolver algunos problemas de la vida
real utilizando las habilidades adquiridas al leer estos capítulos. Después de todo, ¡el
propósito de la ciencia de datos es resolver problemas del mundo real!

Capítulo 4: Capítulo adicional: Introducción al aprendizaje automático con Python Este es

un paquete
adicional agregado a este libro. El aprendizaje automático es útil para la ciencia de datos,
ya que implica el uso de potentes técnicas y herramientas estadísticas para mejorar los
resultados mediante la evaluación de big data. A través del aprendizaje automático, se
aprovecha la poderosa capacidad de las computadoras para encontrar patrones y predecir
resultados mediante la teoría de la probabilidad. Si bien este no es un estudio exhaustivo
sobre el tema, se presentan al lector los conceptos, aplicaciones y herramientas
subyacentes respaldados por Python para liberar el poder de la inteligencia artificial.
Machine Translated by Google

Capítulo 1

Conceptos básicos de Python

Historia de Python

Este es un resumen rápido de la historia de Python, junto con algunas terminologías/referencias

comunes que puede encontrar al interactuar con otros programadores de Python.

Python fue desarrollado e introducido a finales de la década de 1980 por el programador

holandés Guido Van Rossum. Es . un lenguaje de programación de alto nivel, interpretado y
orientado a objetos con alta portabilidad, es decir, el código/aplicaciones Python se pueden
ejecutar en múltiples plataformas que tengan una versión de Python. instalado. El nombre Python
también fue adaptado del nombre de un programa popular, "Monty Python", que Guido estaba
viendo en el momento en que desarrolló el lenguaje. Hasta ahora, ha habido varias versiones
del lenguaje, siendo la última Python 3.7 a partir de 2018. Si bien ha habido debates sobre cuál
es la mejor versión de Python para usar, es decir, la versión 2xx o 3xx de Python, solo hay
diferencias menores en cualquiera de las versiones. . Sin embargo, en este libro usaremos la
última versión de Python 3xx.

Instalación de Python

La forma básica de instalar Python en su computadora es visitando el sitio web oficial de Python
www.python.org y descargando la versión de Python que necesitas. Recuerde descargar la
configuración específica de su sistema operativo, ya sea Windows, Mac Os o Linux. Para los
usuarios de Linux o Mac, es posible que ya tengan una versión de Python instalada en su
computadora. Después de descargar e instalar Python a través del archivo de configuración, la
instalación se puede verificar abriendo una terminal en Mac o Linux, o el símbolo del sistema en
Windows. Este ejemplo está basado en el sistema operativo Windows, ya que no tiene Python
instalado de forma predeterminada. Sin embargo, el mismo comando funciona en Mac y Linux.

Ventanas:

Abra una búsqueda presionando la tecla Windows + Q, busque el símbolo del sistema,
Machine Translated by Google

Haga clic derecho en el resultado y seleccione "ejecutar como administrador". Se abre la ventana
Símbolo del sistema­Administrador, escriba: python ­ ­version.

Si Python está instalado correctamente, debería obtener un resultado como este: Python 3.7. X .

Sistema operativo Mac/Linux:

Abra una terminal yendo a 'Aplicaciones >> Utilidades, luego haga clic en Terminal.
Alternativamente, puede abrir una búsqueda presionando la tecla Comando + barra espaciadora,
luego buscar terminal y presionar Enter. Una vez que se abra la terminal, escriba: python ­
­version.

Obtendrá un resultado como este: Python 2.7. X .

Sin embargo, esta versión podría ser el Python básico que viene con el sistema operativo. Para
comprobar si está instalada la versión 3xx de Python, escriba: python3 ­ ­version

Obtendrá un resultado como este: Python 3.7. X .

Para comenzar a usar Python a través del símbolo del sistema o terminal, escriba: python (sin
comillas). Debería ver algo como esto:

Ventanas:

Python 3.7.2 (tags/v3.7.2:9a3ffc0492, 23 de diciembre de 2018, 22:20:52) [MSC v.1916 32 bits (Intel)] en win32

Escriba "ayuda", "derechos de autor", "créditos" o "licencia" para obtener más información.

>>>

Las tres puntas de flecha/signos de mayor que en la parte inferior son la marca registrada de la
consola Python. Esto significa que ahora está en un entorno Python y puede comenzar a escribir
códigos Python.

¡Escribamos nuestro primer código Python usando el símbolo del sistema!

En la consola de Python (después de escribir 'python' en la ventana de comandos), ingrese el

siguiente código: print ('Hello World') y presione enter. Deberías obtener un resultado como este:

imprimir ('Hola mundo')

Hola Mundo

Allí, acabamos de escribir nuestro primer programa Python mostrando un mensaje usando la función
de impresión de Python.
Machine Translated by Google

Sugerencia: Cabe señalar que, mientras Python 3xx usa la función de impresión como un objeto, es decir,
imprimir ("Hola mundo"), la función de impresión es una declaración en Python 2xx, es decir, imprimir "Hola
mundo". Esta es una (entre algunas otras) de las diferencias entre el uso de Python 2 y Python 3. Por lo
tanto, para evitar errores en los ejemplos de código, es importante utilizar la versión 3xx de Python para
seguir las lecciones de este libro.

Ahora hemos aprendido cómo ejecutar Python a través de la ventana de comandos. Sin embargo, para
escribir programas más grandes que preferiríamos terminar de desarrollar antes de ejecutarlos (¡la ventana
de comandos ejecuta cada línea de código inmediatamente!), se han diseñado algunos editores de texto
como notepad, notepad++ y varios IDE para crear y guardar programas Python. La extensión preferida para
archivos Python es '.py', por ejemplo
Hello_world.py y se puede ejecutar desde la consola escribiendo la ruta completa al archivo Python en la
ventana de comandos.

Por ejemplo, si guardamos nuestro programa Hello_world en el escritorio. La ruta del archivo podría ser algo
como esto: C:\Users\yourcomputername\Desktop\Hello_World.py. Para ejecutar nuestro programa Python:

Abra la ventana de comando e ingrese 'ruta del archivo', debería ver algo como esto:

Microsoft Windows [Versión 10.0.17134.648]

(c) 2018 Corporación Microsoft. Reservados todos los derechos.

C:\Usuarios\Nombre de usuario >C:\Usuarios\Nombre de usuario\Desktop\Hello_World.py

Hola Mundo

Consejo: Para escribir scripts de Python con el bloc de notas: cree un archivo de texto del bloc de notas y
ábralo >> Una vez abierto, escriba su código Python en el archivo >> en la esquina superior izquierda, haga
clic en archivo y seleccione guardar como >> seleccione la ubicación para guardar su código >> En el cuadro
'nombre de archivo', nombre el archivo con una extensión '.py', por ejemplo, programa.py, y en la lista
desplegable 'Guardar como tipo', seleccione 'Todos los archivos'. Luego haga clic en guardar.

Deberías ver un archivo Python en tu ubicación para guardar. También puede arrastrar y soltar este archivo
en la ventana de comandos y ejecutarlo presionando Intro.

Ejercicio : Intente escribir programas divertidos para mostrar texto usando la función de impresión como se
describe en el ejemplo.

El navegador Anaconda
Machine Translated by Google

Esta es una interfaz gráfica de usuario para ejecutar Python y está especialmente optimizada
para la ciencia de datos con Python. Es muy recomendable para comenzar con la ciencia
de datos con Python, ya que facilita la administración de importantes paquetes de ciencia
de datos y bibliotecas de Python. Es parte de la distribución Anaconda, que viene con una
versión de Python (la última Anaconda todavía viene con Python 3.7 en este momento,
mayo de 2019), es decir, si no tiene Python instalado, anaconda instalará una versión de
Python en tu computadora.

Figura 1: El navegador anaconda

La ventaja más importante de usar anaconda son las funciones de hacer clic para iniciar
que ofrece para ejecutar cualquier paquete instalado en su ruta. Reduce en gran medida la
necesidad de instalar paquetes a través del símbolo del sistema utilizando el método de
instalación pip. Además, es fácil crear entornos virtuales para instalar y ejecutar varias
versiones de Python y otros programas de ciencia de datos como 'R'. Los entornos virtuales
son rutas (o carpetas) específicas de determinadas aplicaciones o paquetes en un sistema operativo.
Por lo tanto, al separar varios paquetes en sus respectivos entornos virtuales, no habría riesgo de
conflicto al ejecutar varios paquetes/programas al mismo tiempo.

Anaconda también viene con un IDE (entorno de desarrollo integrado) interactivo para
ejecutar códigos Python. Existe el IDE de Spyder, que utiliza un
Machine Translated by Google

interfaz de consola y script; el cuaderno Jupyter, que ejecuta una consola Python interactiva y
una GUI en su navegador; Jupyter Lab, etc. Usaríamos el cuaderno Jupyter para nuestra
programación Python posterior en este libro.

Para instalar el navegador anaconda, vaya a www.anaconda.com/downloads y descargue la

última versión de la distribución anaconda. Después de la descarga, ejecute el archivo de
instalación y siga las instrucciones en pantalla para instalar completamente anaconda en su
computadora.

Una vez realizada la instalación, el siguiente paso es verificar si anaconda está instalada
correctamente.

Abra una búsqueda usando Winkey + Q y escriba anaconda. Debería ver el navegador anaconda
y el mensaje de anaconda. Haga clic en el navegador anaconda.

Si se abre el navegador anaconda, significa que ha instalado anaconda correctamente.

Alternativamente, puede abrir el indicador de anaconda para verificar la versión de anaconda
instalada y también ejecutar anaconda navigator.

En el indicador de anaconda, escriba: conda –version. Deberías obtener un resultado como este:
(base) C:\Usuarios\Nombre de usuario >Conda ­­versión

conda 4.6.14

Para verificar la versión de Python instalada con la distribución Anaconda, escriba: python –
version .
(base) C:\Users\Oguntuase>python ­­versión
Pitón 3.7.0

Para iniciar el navegador, escriba: anaconda­navigator

Una vez que se abre el navegador, se verifica la instalación y nuestro trabajo está hecho.

Ahora que hemos instalado Python a través de anaconda en nuestra computadora, estamos
listos para comenzar nuestro viaje en ciencia de datos con Python. Sin embargo, como se indica
en el esquema, introduciremos algunos fundamentos de Python que se consideran requisitos
previos para las lecciones de ciencia de datos.

Consejo: si bien la idea de la programación informática es mayoritariamente similar, la diferencia

entre los lenguajes de programación existe en su sintaxis. Cosas como declaración de variables,
bucles, etc. tienen formatos válidos en Python y lo exploraremos pronto. Asegúrese de seguir los
ejemplos y pruebe los ejercicios de práctica.
Machine Translated by Google

Abra el cuaderno de Jupyter haciendo clic en iniciar a través del navegador anaconda o abra el
.
indicador de anaconda y escriba: Cuaderno de Jupyter Se abrirá una ventana del navegador como se
muestra en la figura 2 a continuación.

Figura 2: cuaderno Jupyter

Una vez en el cuaderno de Jupyter, en el lado derecho, haga clic en Nuevo >> luego, en el cuaderno,
haga clic en python 3/python[predeterminado] .

Esto abrirá un editor de Python donde podrá escribir y ejecutar códigos en tiempo real.

Consejo : los archivos del cuaderno de Jupyter se guardan como '. ipynb', y se puede acceder/abrir
navegando hasta la ubicación del archivo a través de la página del explorador del cuaderno Jupyter.
Jupyter también admite Markdown y otras funciones de codificación en vivo que facilitan la
anotación de código. Para obtener información adicional sobre el uso de Jupyter, visite: https://
jupyter.readthedocs.io/en/latest/running.html#running

Codificar con Python: los rudimentos

En esta sección, puede realizar los ejercicios utilizando Spyder IDE,
Machine Translated by Google

Cuaderno Jupyter, o IDLE (para aquellos que tienen Python instalado fuera de anaconda). Sin
embargo, se recomienda utilizar el laboratorio de Jupyter para familiarizarse con la interfaz, ya
que la usaríamos para la sección de ciencia de datos.

Declaraciones, comandos y expresiones

Los lenguajes de programación de alto nivel no son tan diferentes del lenguaje humano.
Siguen un patrón y una regla particulares. Una vez que se omite esa regla, se produce un error.
En lenguaje, se llama error gramatical; En programación, se llama error de sintaxis.

Una declaración en Python es un conjunto completo de instrucciones que logra una tarea. Puede
considerarse como un equivalente a la oración en el idioma inglés que contiene sujeto, verbo y
objeto.

¿Recuerda su primer programa Python, imprimir ('Hola mundo')? La función print() utilizada es
un comando. Puede considerarse como un verbo que por sí solo no hace nada. La parte 'Hola
mundo' es la expresión, que es lo que hay que hacer . Juntos crean una instrucción completa .
llamada declaración, que le dice a Python exactamente qué hacer y cómo.

Hay muchos comandos para hacer varias cosas en Python y nos familiarizaremos con su uso a
medida que avancemos. Las expresiones, por el contrario, adoptan diversas formas. A veces se
puede evaluar, por ejemplo, 4+5; otras veces, como en el ejemplo anterior, es solo un texto para
mostrar.

Probemos otra versión del ejemplo 'Hola mundo'. ¿Qué tal si le decimos a Python que muestre
las dos palabras más espantosas que esperarías no ver en tu pantalla mientras juegas? 'JUEGO
TERMINADO'

Información: Python también es una gran herramienta para el desarrollo de juegos. Este ejemplo
es una referencia a esa posibilidad en la aplicación de Python. Sin embargo, para el
desarrollo de juegos estándar, necesitarás aprender algunas bibliotecas y métodos
específicos de Python. Puede encontrar información adicional sobre esto en: https://
wiki.python.org/moin/PythonGames

Para hacer esto, podríamos simplemente modificar la expresión en nuestro programa anterior.

En el cuaderno Jupyter, escriba: print ('¡JUEGO TERMINADO!') y presione Shift + Enter para
ejecutar. Deberías tener un resultado como este:
En 1]: imprimir ('¡JUEGO TERMINADO!')

Fuera[1]: ¡JUEGO TERMINADO!

Machine Translated by Google

Consejo: para la función de impresión en Python, puede encerrar sus expresiones entre comillas
simples '', comillas dobles ““ o tres comillas “' “”. Sin embargo, asegúrese siempre de utilizar el mismo
tipo de comillas para iniciar y terminar la expresión.

Comentarios

Considere este código que se ejecuta en el cuaderno Jupyter:

En [2]: # Este programa dice Hola al mundo

# Autor: random_Coder_Guy

imprimir ('¡Hola, mundo!')

Fuera[2]: ¡Hola Mundo!

Puede notar fácilmente que lo único que se muestra en el resultado es la declaración "Hola, mundo".
Ahora intentemos esto:
En [3]: Este programa dice Hola al mundo

Autor: random_Coder_Guy

imprimir ('¡Hola, mundo!')

Archivo "<ipython­input­14­239b196f5fd8>", línea 1

Este programa dice Hola al mundo

^

Error de sintaxis: sintaxis invalida

Recibimos un error. ¡Python incluso tiene la amabilidad de decirnos que nuestro error está en la
primera línea! La diferencia entre estos dos códigos salta a la vista inmediatamente. El primer código
no arrojó un error debido al signo de almohadilla/hashtag (#) en las líneas 1 y 2. Esto se llama
comentario .

Los comentarios están destinados a ilustrar el código y mejorar su legibilidad. Al leer el primer código,
resulta obvio lo que pretende hacer el programa. Sin embargo, para evitar que Python ejecute esas
líneas en nuestro código (lo que lleva a un error de sintaxis como en el segundo código), usamos el
signo de comentario para distinguirlas.
textos.

Una buena pregunta sería: ¿son obligatorios los comentarios? ¡La única respuesta es SÍ!
Los comentarios le salvarán la vida (al menos mientras codifica, no servirían de mucho en un
enfrentamiento mexicano) y probablemente evitarán que otros se arranquen los pelos mientras
Machine Translated by Google

¡Tratando de entender tu código!

¿Alguna vez resolviste un problema o jugaste un nivel en un juego y años después no recuerdas cómo lo hiciste?
Ahora imagina que eso le sucede a un código muy importante que escribiste; dos años después, no puedes entender
qué hace ni cómo funciona. Esa es una forma de mala programación y la lección que se debe aprender es '¡SIEMPRE
COMENTA TU CÓDIGO!'

El uso del cuaderno Jupyter también ofrece más opciones para mejorar la legibilidad del código.
Dado que utiliza un marco basado en web, admite 'markdown' (que es solo una forma de formatear
textos en páginas web). Para explorar completamente esta característica interesante con Jupyter,
y otro cosa
visite: https://www.dataquest.io/blog/jupyter­notebook­tips­tricks­shortcuts/

Tipos de datos de Python

Los tipos de datos son especificaciones del tipo de operaciones que un programador espera
que la computadora realice con elementos de datos específicos. Es lo que determina los
atributos de los elementos de una expresión, según lo declarado por el programador, es decir
Tú.

Python, como cualquier otro lenguaje de programación, también es muy particular en

cuanto a sus tipos de datos. Los siguientes son los diversos tipos de datos disponibles en
Python que usaremos más adelante:

Números (es decir, enteros, flotantes, complejos, etc.)

Cadenas
Listas
Tuplas
Diccionarios
Booleanos
Formato de impresión

Números

Los números se representan en Python como números enteros, flotantes (números de

punto flotante) o números complejos.

Enteros

Los números que no tienen puntos decimales se representan como números enteros en Python
Machine Translated by Google

con el tipo int(). De forma predeterminada, Python supone que los números enteros están en
decimal (o base 10), pero las bases se pueden cambiar si es necesario trabajar en binario, octal
o hexadecimal.

Puede realizar operaciones aritméticas con números enteros directamente desde el mensaje (o celda
de código en el cuaderno Jupyter).

# Código para operaciones aritméticas con Python

En [4]: 5 + 10

Fuera[4]: 15

En [5]: 20 ­ 12

Fuera[5]: 8

En [6]: 3*5

Fuera[6]: 15

En [7]: 20/5

Fuera[7]: 4.0

Aquí podemos ver que Python puede realizar operaciones aritméticas básicas con números enteros. Si
observas, está claro que la suma, resta y multiplicación de números enteros con otro número entero da
como resultado un número entero. Sin embargo, en el caso de la división, el resultado es un número
con punto decimal. Este es un número de punto flotante.

Consejo: hay otras operaciones aritméticas posibles con números enteros. Todas estas operaciones
son similares a las de matemáticas básicas. ¿Recuerdas Bodmas, Pedmas o Pemdas? Me gusta usar
el acrónimo Bedmas para recordar la prioridad de las operaciones aritméticas de Python.

Las raquetas tienen la primera prioridad, seguidas de la exponenciación, luego la división o la

multiplicación (tienen la misma prioridad y se pueden intercambiar) y finalmente la suma y la resta (que
también tienen la misma prioridad).

Esto se ilustra en el siguiente código:

En [8]: # Este código intenta determinar el orden de las operaciones con números enteros

(7­2*2)**3 / (12­3**2)

Fuera[8]: 9.0
Machine Translated by Google

Ahora bien, ¿cómo funciona este código? Primero, en caso de que te lo hayas perdido, el '**' es
el signo de exponenciación en Python (algunos otros lenguajes permiten el uso de '^').

Al observar el primer paréntesis teniendo en cuenta a Bedmas, resulta obvio que la

exponenciación dentro del primer paréntesis se trata, lo que la convierte en (7­4), lo que da 3.
Luego, 3 elevado a 3 da 27.

Para el segundo grupo, se aplica la misma técnica y el resultado es 3. Entonces, 27/3 da 9 y

Python devuelve un valor de punto flotante de 9,0 debido a la división.

Ejercicio: Pruebe algunas otras operaciones aritméticas con números enteros y vea lo que
obtiene. Recuerda seguir el orden de las operaciones aritméticas para evitar errores.

Inicialmente, había un límite en la cantidad de caracteres permitidos para un tipo de datos tipo
int (), pero se eliminó en las nuevas versiones de Python. Ahora puedes declarar un tipo entero
con tantos caracteres numéricos como sea posible (¡por supuesto, existe el límite de la memoria
de tu computadora!). Además, como se indicó anteriormente, puede realizar operaciones
aritméticas con números enteros en varias bases. Python convierte estos números enteros a
decimales y luego realiza la operación aritmética.

Ejemplo 1: Suponiendo que necesitamos multiplicar 52 por 158 . 5 en base 2 es '101', y

15 en base 8 es '17'
En [9]: # Este código multiplica números enteros en varias bases y muestra el equivalente decimal

# para especificar 101 en base 2, usamos 0b101

# para especificar 17 en base 8, usamos 0o17

0b101 * 0o17

Fuera[9]: 75

Ejercicio: Pruebe algunas operaciones matemáticas aleatorias con números enteros en varias
bases; hexadecimal todavía no se utiliza.

flotadores

Son números que tienen un punto decimal en su representación. Pueden considerarse números
reales tal como se definen en matemáticas. Los flotadores se introdujeron como un medio para
aumentar la precisión de la representación de números en programas de computadora.
Machine Translated by Google

Todas las operaciones numéricas que son posibles con números enteros también se pueden replicar
con flotantes, y Python también admite operaciones flotantes con números enteros.

Python 3 maneja las operaciones flotantes de forma sencilla. Sin embargo, en Python 2, al realizar una
división, al menos uno de los números (normalmente el divisor) siempre debe representarse como un
flotante para evitar errores de truncamiento en el resultado.

¿Recuerda que los números enteros tienen representación ilimitada en Python? Los flotadores no tienen
lo mismo. El valor máximo que puede tomar un flotante es inferior a 1.8e308 (que se considera infinito
en Python).
En [10]: 1.8e308
Fuera[10]: inf

En el otro extremo de la recta numérica, los flotadores tienen un valor mínimo de 1e­325, que se
considera cero.

En [11]: 1e­325
Fuera[11]: 0.0

Consejo: Pruebe todas las operaciones que ha realizado con números enteros utilizando puntos flotantes.

Números complejos

Si sabes acerca de números complejos, lo más probable es que tengas algo de experiencia en
matemáticas o ingeniería. Esto muestra el potencial de aplicar Python para resolver problemas
abstractos de ingeniería o matemáticas.

Los números complejos están representados por sus partes real e imaginaria en Python, y todas las
reglas de las operaciones matemáticas que se aplican a números enteros y flotantes siguen siendo
válidas con los números complejos de Python.

En Python, los números complejos se representan como {real} + {imaginario} j .

Sin embargo, los matemáticos podrían enfadarse, ya que prefieren el operador 'i' para un número
imaginario.

Ejemplo 2: escribir un programa para calcular el producto de 5+3i y 2+4i (los problemas de ingeniería
pueden tener la forma: 5+3j y 2+4j o 5+j3 y 2+j4)
En [12]: # Este programa calcula el producto de números complejos
Machine Translated by Google

(5+3j) * (2+4j)

Fuera[12]: (­2+26j)

Instrumentos de cuerda

Esta es la representación de caracteres de texto en un lenguaje de programación. En Python, las

cadenas se especifican entre comillas, ya sean comillas simples, dobles o triples. ¿Recuerdas el
programa Hola Mundo que escribimos anteriormente? Bueno, ¡era una cuerda!

Ejemplo 3: Intentemos crear cadenas con delimitadores de comillas simples, dobles y triples. Puede
notar que Python muestra los mismos resultados.
En [13]: 'Michael Foster'

Fuera[13]: 'Michael Foster'

En [14]: “David Beckham”

Fuera[14]: 'David Beckham'

En [15]: """Guillermo Giovani"""

Fuera[15]: 'Guillermo Giovani'

Quizás se pregunte por qué las cadenas se representan igualmente mediante comillas simples, dobles
o triples. ¿Por qué no ceñirse a una convención? La respuesta es obvia en la forma en que se escribe el
idioma inglés. Hay casos en los que las palabras escritas requieren comillas simples o dobles (como
máximo). La regla es utilizar una mayor cantidad de comillas para ajustar la cadena.

Por ejemplo, digamos que quiero que Python imprima la siguiente declaración: Hola Mark, ¡un placer
conocerte!

Probemos con las comillas simples:

En [16]: 'Hola Mark, ¡un placer conocerte!'

Archivo "<ipython­input­23­43365d0419fc>" , línea 1

'¡Hola Mark, es un placer conocerte!'

^

Error de sintaxis: sintaxis invalida

Sin embargo, usar comillas dobles nos da la respuesta correcta.

Machine Translated by Google

En [17]: "¡Hola Mark, un placer conocerte!"

Out[17]: "¡Hola Mark, es un placer conocerte!"

Observe que la salida en este caso también está entre comillas dobles. Esto se debe al
escape del apóstrofe dentro de la expresión (Python interpreta un apóstrofe como una comilla
simple). Se sigue el mismo proceso para las comillas dobles en la expresión.

Si bien es posible utilizar tres comillas para escribir cadenas/comentarios de varias líneas.
No es una forma formal de hacerlo. # sigue siendo el enfoque de comentario predeterminado
en Python (línea por línea).

Ejemplo 4: Probemos con un ejemplo divertido. Mostraríamos un logo genial de Mortal

Kombat usando la función de impresión. Esto es sólo una modificación del programa 'Hola
mundo' que escribimos anteriormente.

Para hacer este ejemplo, necesitamos tener una forma de especificar el logotipo como cadenas. Para
ello, necesitamos arte ASCII, que puedes diseñar tú mismo, o copiar arte de ejemplo de este repositorio:
https://www.asciiart.eu/video­games/mortal­kombat

El código y el arte resultante se pueden ver en la figura 3.

Figura 3: Ilustración de gráficos con la función de impresión y cadenas

Machine Translated by Google

Ejercicio: visite el repositorio de arte Ascii e intente replicar la visualización de gráficos usando Python.

Concatenación de cadenas

Si bien no es factible realizar operaciones aritméticas con cadenas (las cadenas se interpretan como
texto, no se pueden hacer operaciones matemáticas con texto), las cadenas se pueden unir o replicar.

Ejemplo 5: Supongamos que queremos escribir el nombre de una persona al azar. Tenemos el
nombre y apellido.
En [18]: 'Fuego' + '¡galleta!'

Fuera[18]: 'Galleta de fuego'

Consejo: En este ejemplo, observe cómo introduje un espacio antes de la palabra "galleta".
Esto es para garantizar que el resultado tenga sentido, ya que de lo contrario Python habría unido todo
como este 'Firecracker' .

Ejemplo 6: Ahora intentemos replicar una cadena. ¡Imagínate que necesitas escribir la misma frase 100
veces! ¿Sólo si hubiera una manera de hacerlo solo una vez?

En este ejemplo, repetiríamos la afirmación "Me encanta la programación en Python, es increíble" tres
veces. El mismo método utilizado se puede adaptar para una repetición más grande, ¡solo requiere tu
creatividad!
En [19]: print(“Me encanta la programación en Python, es increíble\n” * 3)

Out[19]: Me encanta la programación en Python, es increíble

Me encanta la programación en Python, es increíble.

Me encanta la programación en Python, es increíble.

Consejo: La función de impresión ayuda a mostrar las cadenas de manera adecuada, sin comillas.
Además, permite el uso de opciones de formato, como el carácter de nueva línea \n en el código anterior.
Intente utilizar este consejo para mostrar cadenas más elaboradas.

variables

Estos son marcadores de posición para datos de cualquier tipo, es decir, números enteros, cadenas, etc.
Si bien es muy efectivo imaginar una variable como un espacio de almacenamiento para guardar datos
temporalmente hasta que se necesiten, prefiero pensar en variables como dinero.

¿Esperar lo? Sí, dinero. Si bien técnicamente no equivale en la descripción, es

Machine Translated by Google

Bueno para visualizar lo que hace una variable con sus datos.

En primer lugar, creo que ustedes son conscientes de que el dinero sólo tiene el valor que le asigna un
consenso de personas, como dice el Banco Mundial. (Es más complicado que eso, pero esa es la idea
general). Eso significa que el billete de 10 dólares que tiene hoy puede ser más valioso o menos valioso el
próximo año dependiendo de lo que suceda en la economía del país emisor y en todo el mundo. También
podría no valer nada si el mundo así lo decide.

Ahora, relacionándolo con las variables. Como se describió anteriormente, son marcadores de posición para datos.
Para declarar una variable, diga "X", le asignará datos con el valor de un tipo de datos específico. Luego,
el valor asignado se convierte en el valor de su variable.
Ahora, la variable tiene el mismo valor y tipo de datos que los datos originales hasta que elija reasignarla o
los eventos de su programa la reasignen.

¿Tiene sentido? Probemos algunos ejemplos para comprender mejor las variables en Python.

En [20]: x = 5

y = 10

x+y

Fuera[20]: 15

Como puede observar en el código, x ahora tiene el valor 5 y y tiene el valor 10. Si verificamos el tipo de
datos de x o y, ambos tendrían el mismo tipo de datos int() que sus datos asignados.

En [21]: escriba (x)

Fuera[21]: int

Ejercicio : Intente verificar el tipo de la otra variable y. Cambia los valores de xey y realiza operaciones
adicionales con ellos. Recuerde que las variables también pueden contener cadenas, solo recuerde poner
comillas para declarar cadenas.

Consejo : existen algunas reglas para declarar variables de Python: Primero, las variables de Python solo
pueden comenzar con un guión bajo (_) o un alfabeto. No puede iniciar una variable de Python con números
o caracteres especiales, es decir, @, $, %, etc.

En segundo lugar, Python tiene algunos nombres reservados para funciones, es decir, print, sum, lambda,
class, continue, if, else, etc. Estos nombres no se pueden usar para declarar variables para evitar
operaciones conflictivas de Python.

Además, en la declaración de variables, es aconsejable utilizar una convención de nomenclatura que mejor
Machine Translated by Google

describe lo que hace su variable. Si su elección de nombre de variable contiene varias palabras,
sepárelas con un guión bajo como este: nombre_variable, número_matriz, número_total_de_autos,
etc.

Ejemplo 7: construyamos un programa más elaborado para ilustrar la concatenación de cadenas.

En [22]: # Este programa concatena nombre y apellido y muestra el nombre completo.

Nombre = 'James'

Apellido = 'Potter'

''
Nombre completo = Nombre + + Apellido

imprimir (nombre completo)

Fuera[22]: James Potter

Consejo: ¿Notaste que no se utilizaban las comillas en la función de impresión?

Esto se debe a que la variable 'Nombre completo' ya tiene las comillas como atributos.
Al poner cadenas en la función de impresión, Python pensaría que desea imprimir la cadena 'Nombre
completo' .

Comprobemos el atributo de la variable 'Nombre completo'.

En [23]: escriba (nombre completo)

Fuera[23]: str

Nuevamente, construyamos una versión más complicada del programa de nombres que acepte
entradas del usuario para nombre, apellido y edad, y luego muestre algo ingenioso.

En este ejemplo se utilizaría la función input() y su sintaxis se puede deducir del código.

En [24]: # Este programa muestra el nombre y dice cosas ingeniosas

First_name = input ('¿Cuál es tu nombre?\t')

Apellido = entrada ('¿Apellido también?\t')

Edad = str (entrada ('¿Tu edad?\t '))

''
Nombre completo = Nombre + + Apellido

imprimir ('Hola '+ Nombre completo + '\n\n')

print ('Debe ser lindo ser '+ Edad + '; ¡Soy una computadora, no tengo edad!')
Machine Translated by Google

Out[24]: ¿Cuál es tu nombre? David

¿Apellido también? Maxwell

Su edad ? 25
Hola David Maxwell.

Debe ser agradable tener 25 años; ¡Soy una computadora, no tengo edad!

También podría ser fácil observar la conversión del tipo de datos de la variable edad a una cadena usando
la función str() . Esto también es posible para la conversión a otros tipos de datos, es decir, int () para
convertir a números enteros, float () para convertir a números de punto flotante y complex () para cambiar
a números complejos.

Ejercicios

1. Crea un programa simple que tome el nombre de tres amigos y

les da la bienvenida a un restaurante, por ejemplo, McDonalds.

2. Escriba un programa que acepte un valor entero y lo muestre como un

número de punto flotante.

3. Escriba un programa simple que acepte un valor de temperatura en Celsius,

y muestra su equivalente en Fahrenheit.

Sugerencia: la conversión de Celsius a Fahrenheit viene dada por:

Liza
Las listas de Python no son tan diferentes de la idea general de listas en el lenguaje normal.
Es solo una colección de valores en una secuencia separados por comas. Las listas pueden contener
valores con diferentes tipos de datos, es decir, una lista de Python puede ser una secuencia combinada de
números enteros, flotantes, cadenas, etc. Las listas se pueden asignar a variables en su declaración, y en
los siguientes ejemplos se ilustran algunas operaciones de lista:
# Lista de ejemplos
Machine Translated by Google

[1,2,3,4,6] # Lista de números enteros

[12.1,13.42,15.6,18.93,20.0] # Lista de flotadores

['Nuevo', 'Tomado', 'Extra'] # Lista de cadenas

['Verdadero Falso'] # Lista de expresiones booleanas

['Derek',25,125.50,True,] # Lista de diferentes tipos de datos

Para declarar una lista de Python, se utilizan corchetes [] y los valores están separados por comas.

Todas las listas declaradas anteriormente muestran cómo las listas de Python son flexibles para contener datos
de cualquier tipo. Sin embargo, estas listas sólo se declaran para ser evaluadas una vez en la ventana de
comandos. Es una mejor práctica asignar listas a variables para su reutilización.

Consejo: Para ejecutar el ejemplo anterior, copie y ejecute cada lista individualmente; si copia
todas estas listas anteriores en una celda de Jupyter, Python devolverá solo el resultado de la
última lista declarada.

Indexación de listas

Una vez que haya declarado una lista, se puede acceder a cada valor de la lista mediante un método llamado
indexación. Para entender este concepto, imagina que una lista es una biblioteca con varios tipos de libros. Los
bibliotecarios suelen organizar los libros por categoría/tipo y, como tal, no esperarías encontrar un libro de ciencia
en la sección de artes. Además, en cada categoría, el bibliotecario puede facilitar el acceso asignando un número
de serie a cada libro. Por ejemplo, el libro sobre 'Geografía mundial' podría tener el identificador 'Ciencia A2', que
pertenece únicamente a ese libro en esa biblioteca específica.

En otra biblioteca, ese mismo identificador puede hacer referencia a "Ciencias espaciales" o algo más. El punto
es que cada elemento en una lista específica tiene un identificador para acceder a él, y la indexación de listas es
el proceso de recuperar elementos de una lista usando sus identificadores.

Para utilizar la indexación de listas, primero se debe asignar la lista a una variable. También vale la pena señalar
que la indexación de listas de Python depende de la dirección. Para indexar de izquierda a derecha, Python
comienza a indexar en '0', mientras que la indexación de derecha a izquierda comienza en ­1.

Ejemplo 8: tomemos el tercer elemento de una lista.

En []: Lista_aleatoria = [1,2,3,4,'comida']
Machine Translated by Google

Lista_aleatoria [2]

Afuera[]: 3

Alternativamente, podríamos haber tomado el valor 3 de Random_List usando el comando

Random_List [­3] ; sin embargo, no es una convención común.

También existen otras versiones de listas que contienen otras listas. Se denominan listas anidadas.

Ejemplo 9 : Esta es una lista anidada

Random_List2 = [[1,2,3,4,'integers'],'food', [12.3,5.2,10.0,'floats']]

Para entender las listas anidadas, imaginemos las muñecas rusas anidadas. El nombre se deriva
del hecho de que la primera capa de muñecas contiene las otras muñecas. Si se quita la capa, la
siguiente capa alberga el resto de las muñecas. Esto continúa hasta que se eliminan todas las capas
de muñecas para revelar la capa deseada de la muñeca. Lo que muestra esta analogía es que el
mismo enfoque de indexación funciona para listas anidadas dentro de otras listas.

Ejemplo 10: tomemos el valor 10.0 de Random_List2.

En []: Random_List2 = [[1,2,3,4,'enteros'],'comida',[12.3,5.2,10.0,'flotadores']]

Lista_aleatoria2 [2][2]

Fuera[]: 10.0

Esto es lo que pasó. Al usar el primer comando, Random_List2 [2] pudo tomar la lista anidada , nosotros

que contiene el valor deseado 10.0. Si cuentas, esa lista es el tercer elemento de Random_List2 .
Ahora, después de usar la primera indexación para obtener esa lista, ahora también podemos
indexar esa nueva lista. Dentro de esta nueva lista 'Random_List2[2]' el valor 10.0 es el elemento 3,
tercero

o en el índice 2 (recuerde que Python indexa desde cero, también podemos seleccionarlo con '­2' ),
así que para capturarlo, simplemente indexamos esa lista en 2: 'Random_List2[2][2]' .
¿Suficientemente fácil? Puedes intentar capturar otros elementos de la lista usando esta idea.

Ejemplo 11: creemos un programa que acepte información del usuario y muestre algunos resultados.

En []: # Programa que acepta datos del usuario.

user_Data = eval (input (''''Por favor ingrese su información en el siguiente

orden:
Machine Translated by Google

['Nombre', Edad, Altura (en metros), Casado (ingrese Verdadero/Falso)]

'''))

Por favor ingresa tu información en el siguiente orden:

['Nombre', Edad, Altura (en metros), Casado (ingrese Verdadero/Falso)]

['James Franco', 41, 1.8, Falso]

Producción

El método 'eval' en el código anterior se utiliza para evaluar cualquier entrada sugerida por el usuario. Esto permite
a Python aceptar la entrada en forma de cadena literal e interpretarla como código Python. En este caso, Python
reconoce la entrada como una lista debido a []. También asigna el tipo de datos apropiado a cada elemento como
se especifica en la lista.

Ahora que se ha preparado la lista user_Data, podemos asignar cada elemento de la lista a sus variables
correspondientes e imprimir el resultado deseado.
En []: Nombre = datos_usuario[0]

Edad = datos_usuario[1]

Altura = datos_usuario[2]

M_Estado = datos_usuario[3]

print(('''Aquí están tus datos

Nombre: {}

Edad: {}

Altura: {}m

Casado: {}''').format(Nombre,Edad,Altura,M_Estado))

Producción
Aquí están tus datos

Nombre: James Franco

Edad: 41

Altura: 1,8 m
Machine Translated by Google

Casado: Falso

Eso fue divertido, ¿verdad? Sin embargo, puede observar que se introdujo un nuevo método en
esta sección, el '. método de impresión "formato" . Así es como funciona el código: de la lista
user_Data que hemos declarado en la primera celda, tomamos cada elemento y los asignamos a
las variables 'Nombre, Edad, Altura y M_Status'.
Para mostrar todos estos elementos sin la necesidad de concatenar cadenas o cambiar tipos de
datos, podemos usar la función de impresión con comillas triples para imprimir en varias líneas.
Alternativamente, podríamos haber usado comillas simples o dobles junto con opciones de
escape de nueva línea/tabulación, es decir, \n o \t.

El '. El método "formato" es una forma de controlar la impresión. Solo necesita colocar { } en los
lugares donde irían sus valores y luego especificar el orden.

Suponiendo que queremos imprimir algo como: Tengo 5 años y tengo $20.
En []: print (('Tengo {} años y tengo {}.').format(5,'$20'))

Salida
Tengo 5 años y tengo $20.

Sugerencia : en el código anterior, los $20 debían especificarse como una cadena. Un mejor
enfoque sería utilizar la asignación de variables, es decir, asignar 5 y $20 a las variables y
pasarlas al método '.format' .

Ejercicio: escriba un programa que muestre el historial de la cuenta bancaria de un cliente. Esta
es sólo una variación del programa de ejemplo. Si su código no funciona, revise los ejemplos,
sugerencias y comentarios para obtener una nueva perspectiva.

Indexación de un rango (corte de lista)

Suponiendo que necesitamos tomar una variedad de elementos de una lista, digamos los primeros
tres elementos, esto se puede lograr mediante la indexación o división de rangos. El operador de
rango son los dos puntos ':' y la técnica tiene la siguiente sintaxis: Nombre de lista [inicio de rango:
final de rango +1].

Ejemplo 12: tome los nombres de los animales domésticos de la siguiente lista ['Gato', 'Perro',
'Cabra', 'Jaguar', 'León'] y asígnelos a una variable animales_domésticos .
En []: Animales = ['Gato', 'Perro', 'Cabra', 'Jaguar', 'León']
Machine Translated by Google

animales_domésticos = Animales [0:3]

imprimir (animales_domésticos)

Producción

['Gato', 'Perro', 'Cabra']

Alternativamente, si nuestros datos deseados comienzan desde el primer elemento, no es necesario especificar el
índice '0 ' (o índice '­1 ' en la indexación de derecha a izquierda), también podríamos haber capturado los datos con
'animales_domésticos = Animales [ : 3]' .

Puede observar que el elemento 'Cabra' está en el índice '2'; sin embargo, la sintaxis de rango
requiere que el argumento 'fin de rango' se especifique como 'fin de rango +1', que es 3 en este
caso.

El mismo enfoque se utiliza para realizar capturas de datos más complicadas, como se ve en el siguiente ejemplo.

Ejemplo 13: Escriba un programa que seleccione tres delicias diferentes de una lista de alimentos e imprima un
mensaje.

En []: lista_comida = ['arroz', 'ensalada', ['pastel', 'helado', 'galletas', 'donas'],'Frijoles']

golosinas = lista_comida [2] [1:4]

print ('Me encanta {}, {} y {}.'.format(golosinas[0],golosinas[1],golosinas[2]))

Salida Me

encantan los helados, las galletas y los donuts.

¿Ves cómo combinamos la indexación de rango con el método .format ? Pruebe algunos ejemplos divertidos usted
mismo y considere su competencia en el uso de estas técnicas.

Indexación de cadenas

Las cadenas son sólo un montón de caracteres "encadenados" entre sí. Por lo tanto, todas las operaciones de
indexación de listas también son aplicables a cadenas.

Ejemplo 14 : tome la palabra 'excepto' de una cadena.

En []: # Este programa ilustra la indexación de cadenas.

Cadena = 'Excepcional'

# índice ­slice
Machine Translated by Google

# índice ­slice

nueva_cadena = Cadena[:6]

# Imprimir la salida

print(new_string)

Producción
Excepto

Ejemplo 15: tome la palabra "avena" de cualquier elemento de una lista.

En []: # tomando la palabra "médico" de una lista

lista_palabras = ['náutico',['medieval', 'extravagancia'],'extra' ]

palabra = lista_palabras[1][0][:4] + lista_palabras[0][5:8]

imprimir (palabra)

Producción
médico

Consejo : siga probando variaciones de indexación de listas y cadenas; serán muy útiles en los
capítulos siguientes.

Ahora que hemos aprendido cómo indexar listas y cadenas, consideremos el caso en el que
necesitamos asignar nuevos elementos a una lista.

El primer caso es la reasignación de elementos. Las listas son mutables (las cadenas no son
mutables), lo que significa que pueden permitirle cambiar su declaración inicial.
Puede reasignar elementos de la lista mediante la indexación y también puede agregarlos o
, .extender , .eliminar métodos.
eliminarlos de una lista utilizando .append , .insert

Ejemplo 16: Aquí hay una lista de frutas que queremos manipular ['Manzana', 'Naranja', 'Plátano',
'Anacardo', 'Almendra'].
En []: # Declarando la lista de frutas

frutas = ['Manzana', 'Naranja', 'Plátano', 'Anacardo', 'Almendra']

frutas

Fuera[]: ['Manzana', 'Naranja', 'Plátano', 'Anacardo', 'Almendra']

Ahora, reasignemos el segundo elemento de la lista, es decir, 'Naranja' y cambiémoslo a

Machine Translated by Google

'Guayaba'
En []: frutas[1] = 'Guayaba'

frutas

Fuera[]: ['Manzana', 'Guayaba', 'Plátano', 'Anacardo', 'Almendra']

Observe que la guayaba ha sido indexada como el segundo elemento de la lista. Sin embargo, Orange
ha sido eliminado/reemplazado.

Sugerencia: este método utiliza la idea de reasignación de variables. El elemento 'Naranja' es una
variable en la lista de frutas y su nombre se basa en su índice, es decir, frutas[1], del mismo modo que
el nombre de la variable para 'Banana' sería frutas[2]. Entonces, es sólo cuestión de reasignar un valor
a la variable como aprendimos en la sección anterior.

Se puede utilizar el mismo método para reasignar cualquier elemento en esa lista. Sin embargo, ¿qué
pasa si tenemos una lista anidada?

Ejemplo 17: Las reasignaciones de listas anidadas también siguen la misma idea. Primero tome el
elemento anidado que se va a reasignar y luego asígnele un nuevo valor.
En []: # Para reasignar un elemento anidado.

New_list = ['Manzana', ['Naranja','Guayaba'], 'Plátano', 'Anacardo', 'Almendra']

Lista nueva

Fuera[]: ['Manzana', ['Naranja', 'Guayaba'], 'Plátano', 'Anacardo', 'Almendra']

En []: Nueva_lista[1][0] = 'Mango'

Lista nueva

Fuera[]: ['Manzana', ['Mango', 'Guayaba'], 'Plátano', 'Anacardo', 'Almendra']

Ejercicio: Ahora, intenta cambiar el elemento 'target' por 'targeting' en esta lista: nest = [1,2,3,
[4,5, ['target']]]

Usando nuestra lista inicial de frutas, usemos el método .append. Este método toma el valor que se le
pasa y lo agrega al final de la lista. Sólo puede agregar un elemento a una lista a la vez. Si se pasa
más de un elemento al método, lo agrega como una sublista a la lista deseada.
Machine Translated by Google

Ejemplo 18: Agregue la fruta Papaya a la lista de frutas y conviértala en el último elemento.

En []: # Declarando la lista de frutas

frutas = ['Manzana', 'Naranja', 'Plátano', 'Anacardo', 'Almendra']

frutas.append ('papa')

frutas

Fuera[]: ['Manzana', 'Naranja', 'Plátano', 'Anacardo', 'Almendra', 'Papaya']

Para agregar una sublista, use el método .append ('[elementos de sublista]')

Ejemplo 19: agreguemos una sublista de carbohidratos a esta lista de alimentos.

En []: #Declarando la lista de alimentos

alimentos = ['Frijoles','plátano','pescado']

alimentos.append (['Arroz, 'Trigo'])

alimentos

Fuera[]: ['Frijoles', 'plátano', 'pescado', ['Arroz', 'Trigo']]

Ahora, usemos otro método '.extend' . Este método también agrega sus valores
de entrada al final de una lista. Sin embargo, a diferencia del método .append, en el caso de
múltiples valores de entrada, el método .extend agrega cada elemento a la lista, extendiendo así
el índice de la lista.

Ejemplo 20: utilice el método .extend para agregar dos elementos al final de una lista.
En []: # Declarando la lista de alimentos

alimentos = ['Frijoles','plátano','pescado']

alimentos.extend(['Arroz', 'Trigo'])

alimentos

Fuera[]: ['Frijoles', 'plátano', 'pescado', 'Arroz', 'Trigo']

Consejo: Los métodos .append y .extend aceptan solo un argumento de entrada. Si es más de
uno, incluya las entradas entre corchetes. Esto se ve en los ejemplos 19 y 20.

Bien, has aprendido cómo agregar elementos al final de una lista usando los métodos .append
y .extend. Imagine un caso en el que desea agregar un elemento.
Machine Translated by Google

a cualquier parte de una lista sin reemplazar el elemento en ese índice. El método .insert es
apropiado para esto. También acepta un argumento e inserta ese valor en el índice especificado.

El método .insert tiene la siguiente sintaxis: ListName.insert (índice deseado, nuevo valor)

ListName es el nombre de la lista que se va a manipular . El índice deseado es la posición

esperada de ese elemento (recuerde que la indexación comienza desde 0 o ­1 según la
preferencia de indexación) y Nuevo valor es el elemento que se insertará en el índice especificado.

Ejemplo 21: Considere la siguiente lista de números enteros, agregue el valor correcto para que
la secuencia sea correcta. Count_to_ten = [1,2,4,5,6,7,8,10].
En []: # Este programa ilustra el método .insert.

Contar hasta diez = [1,2,4,5,6,7,8,10]

Count_to_ten.insert(2,3)

Count_to_ten.insert(8,9)

Cuenta hasta diez

Fuera[]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Repasemos cómo funcionó. El primer uso de .insert en el ejemplo 21 asigna el valor 3 al índice
2 como lo especifica la sintaxis. Ahora la lista 'Count_to_ten' ha aumentado en tamaño e
indexación en un valor de 1, es decir, Count_to_ten = [1,2,3,4,5,6,7,8,10] .
Ahora podemos agregar el valor 9 al índice adecuado de 8 como la
mostrado en el 4 línea de código.

Consejo: tenga en cuenta la expansión del índice antes de asignar elementos. En el ejemplo
anterior, si asignamos primero el valor 9, la indexación del otro valor 3 no se habría visto afectada
por el aumento en el tamaño de la lista. Entonces el siguiente código habría logrado el mismo
resultado:
En []: Count_to_ten = [1,2,4,5,6,7,8,10]

Count_to_ten.insert(7,9)

Count_to_ten.insert(2,3)

Cuenta hasta diez

Fuera[]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Esto se debe a que la inserción de un valor en la lista desplaza los elementos de la lista de
Machine Translated by Google

ese índice de inserción a la derecha. Cada uno de los elementos desplazados ahora tiene un índice
incrementado por el número de elementos insertados, es decir, si un elemento tenía un índice de 3 en
una lista y se insertaron dos elementos en su índice o antes de su índice, ese elemento ahora tiene un
índice de 5. .

El último método que consideraríamos en las operaciones de lista es el método .remove.

Esto se utiliza para eliminar un elemento de una lista. También tiene una sintaxis similar al método .insert
y utiliza indexación de listas.

Ejemplo 22: agreguemos el valor 11 a la lista Count_to_ten y luego borremoslo usando el método .remove.

En []: # Usando la lista de salida del último ejemplo

Count_to_ten.append(11)

Fuera[]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,11]

En []: # Restableciendo a 10

Count_to_ten.remove(11)

Fuera[]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Hay algo a tener en cuenta aquí: el método .remove no requiere la especificación del índice del elemento
no deseado. Sólo se necesita el nombre o valor del elemento no deseado.

Ejercicio: crea una lista de coches y practica varias manipulaciones con ella. Practica agregar a la lista,
eliminar elementos, etc.

Sugerencia: deje que su ejercicio requiera todas las manipulaciones de listas que hemos practicado hasta
ahora. ¡Se creativo!

¿Recuerda en qué se parecen las listas a las cadenas en algunas operaciones? Bueno, también puedes
hacer sumas y multiplicaciones (repeticiones) de listas como hicimos con las cadenas.

Ejemplo 23: aquí hay algunas sumas y multiplicaciones de listas

En []: # Suma y multiplicación de listas

Lista1 = ['A', 'B', 'C', 'D']

Lista2 = [1, 2, 3, 4]
ListaCombinada = Lista1 + Lista2
Machine Translated by Google

Lista combinada

Fuera[]: ['A', 'B', 'C', 'D', 1, 2, 3, 4]

En []: # Multiplicación de listas

Lista2*2

Fuera[]: [1, 2, 3, 4, 1, 2, 3, 4]

Si bien hay más operaciones posibles con listas, hemos cubierto lo suficiente como para servir como una
buena base para futuras aplicaciones con listas.

tuplas
Son similares a listas, es decir, una secuencia de valores separados por comas. Sin embargo, a diferencia
de las listas, las tuplas son inmutables y se definen mediante paréntesis ().
También se pueden obtener datos de tuplas utilizando la técnica de indexación. La utilidad de las tuplas
surge de la necesidad de crear partes del programa que el usuario/programa no pueda cambiar durante la
operación. Imagínese crear un programa de cuenta bancaria. Cosas como el pin de su cajero automático
podrían estar abiertos a la modificación del usuario.
Sin embargo, ¡imagínese permitir que las personas tengan acceso para cambiar los detalles de su cuenta!
Esto podría causar un conflicto en el programa bancario. Estos son los tipos de datos que pueden contener
las tuplas. Los usuarios pueden recuperar dichos datos; sin embargo, no se pueden cambiar.

Ejemplo 24: Declaremos algunas tuplas.

En []: # Las tuplas se pueden declarar de dos maneras

mi_Tupla = (1,2,3,4,5) # camino 1

imprimir(mi_tupla)

tipo(mi_tupla)

Afuera[]: (1,2,3,4,5)

tupla

En []: my_Tuple2 = 1,2,3,4,5, # camino 2

imprimir(mi_Tuple2)

tipo(mi_Tuple2)

Fuera[]: (1,2,3,4,5)

tupla
Machine Translated by Google

Podemos considerar los dos tipos de declaraciones de tuplas que se muestran en los códigos anteriores.
Si bien el primer método es el tradicional y recomendado, el otro método es igualmente aceptable. El
segundo método se llama "empaquetado de tuplas" y analizaremos su relevancia más adelante.

Cualquier secuencia de elementos separados por comas declarados sin un operador o caracteres
especiales como [ ], { }, etc. se asigna automáticamente como una tupla. Esto es importante.

Como se explicó anteriormente, todas las operaciones de indexación regulares que involucran la captura
de datos se pueden realizar con tuplas; sin embargo, no admite la asignación/reasignación de elementos
una vez declarados.

Otra razón por la que un programador de Python podría preferir usar una tupla en lugar de una lista es
porque las operaciones con tuplas son más rápidas que con listas, ya que las tuplas requieren menos
asignación de memoria.

Ejemplo 25:
En []: # Comparando listas con tuplas

mi_Lista = ['Hombres', 'Índice', 1,2,3]

mi_tuple = ('Hombres', 'Índice', 1,2,3)

a = my_tuple.__sizeof__() # obtener el tamaño de la tupla

b = my_List.__sizeof__() # obtener el tamaño de la lista

print('el tamaño de la lista es {} y el tamaño de la tupla es {}.'.format(b,a))

Out[]: el tamaño de la lista es 80 y el tamaño de la tupla es 64.

Aunque los elementos de una tupla y una lista son exactamente iguales, tienen diferentes tamaños (en
términos de memoria). Esto es especialmente útil para diseñar sistemas que tienen recursos limitados
con requisitos de alta eficiencia.

Ejemplo 26: tomemos algunos elementos de una tupla usando indexación

Machine Translated by Google

En []: # agarrando elementos de tupla

A = mi_tupla[0]

B = mi_tupla[1]

print ('El {} de {} es 0.'.format(B,A))

Out[]: El índice de hombres es 0.

Ejercicio: Pruebe otras operaciones de indexación con tuplas. Cree una tupla e intente reasignar uno de los
elementos mediante la indexación. ¿Qué observaste y por qué?

Las tuplas también permiten una operación llamada "empacar y desempaquetar". Cualquiera de las
operaciones depende del lado del operador de igualdad en el que se encuentra la tupla.

Ejemplo 27: Ilustremos el empaquetado y desempaquetado de tuplas.

En []: # embalaje y desembalaje de tuplas

Tupla = 'Daniel', 'Dean', 'James' # Embalaje de tupla

[Nombre1, Nombre2, Nombre3] = Tupla # tupla descomprimiendo

print(Nombre1)

imprimir(Nombre2)

imprimir(Nombre3)

Fuera[]: Daniel

Decano

Jaime

El empaquetado y desempaquetado de tuplas es una forma conveniente de usar tuplas para asignar/crear
variables. Empaquetar una tupla es solo una cuestión de declararla; sin embargo, para descomprimirla,
simplemente declara una cantidad de variables de elección igual a la cantidad de elementos en la tupla.
Luego, cada variable toma el valor correspondiente en la tupla según el orden de disposición. Como se
puede observar, la variable Nombre1 corresponde al elemento de la tupla 'Daniel', y

pronto.

Sugerencia: Los corchetes alrededor de las variables declaradas no son necesarios al descomprimir tuplas.
Es una práctica estándar, sin embargo, usar () o nada dará los mismos resultados. ¡Intentalo!

Un uso común de las tuplas es contener pares de valores. Esto es especialmente útil para
Machine Translated by Google

recopilar datos como información del usuario para los cuales cada elemento almacena datos de usuario
específicos.

Ejemplo 28:
En []: # recopilando datos con tuplas

User_Info = (('Nombre','James'),( 'Edad',22)) #tupla anidada

A,B = User_Info[0] # Desembalaje de tupla interna

C,D = User_Info[1] # Desembalaje de tupla interna

imprimir (A, ': ',B)

imprimir (C, ': ',D)

Fuera[]: Nombre: James

Edad: 22

Diccionarios
También son similares a listas y tuplas en ciertos aspectos. A diferencia de las listas y tuplas,
los diccionarios se declaran como pares clave­valor y mediante llaves, es decir, { } .
Piense en los diccionarios como cajas de seguridad. Puedes guardar cualquier artículo que
quieras en él (excepto tu coche, por supuesto, el tamaño sí importa), ¡pero solo puedes acceder
a él con tu llave!

En Diccionarios la indexación se realiza con la clave asociada al valor almacenado.

Los diccionarios son mutables en sus claves y valores (no tan­caja­de­seguridad), sin embargo,
se pueden proteger usando tuplas como claves o pares clave­valor (según el nivel de acceso
deseado).

Ejemplo 29: Declaremos un diccionario.

En []: # Declaración de diccionario

my_Dict = {'Clave1': 'Películas', 'Clave2': ['Iron Man', 'Vengadores']}

imprimir(mi_Dict)

imprimir(escribir(mi_Dict))

Fuera[]: {'Clave1': 'Películas', 'Clave2': ['Iron Man', 'Vengadores']}

<clase 'dict'>
Machine Translated by Google

Allí acabamos de declarar un diccionario. Observe que el primer valor es una cadena y el segundo valor
es una lista. Las claves también pueden ser otros tipos de datos y no necesariamente cadenas; sin
embargo, generalmente se prefieren los nombres de claves de cadena para mantener los valores y
facilitar la lectura del código y las llamadas.

Para capturar elementos en un diccionario, primero se llama a las claves que contienen el valor.

Ejemplo 30: Tomar elementos del diccionario

En []: A = my_Dict['Clave1']

B = my_Dict['Clave2']

imprimir (A,': ',B)

Fuera[]: Películas: ['Iron Man', 'Avengers']

Podemos ver que al llamar a las claves del diccionario, pasamos los valores mantenidos por la
Clave 1 y la Clave 2 a las variables A y B. Se puede realizar una indexación de claves de diccionario
más complicada.

Ejemplo 31: Tomar elementos de un diccionario anidado.

Primero, declaramos nuestro diccionario:

En []: Acct_Dict = {'Nombre':'Cliente1','Tipo de cuenta'

:{'tipo1':'Ahorros','tipo2': 'Actual'}}

Cuenta_Dict

Salida[]: {'Nombre': 'Cliente1', 'Tipo de cuenta': {'tipo1': 'Ahorros', 'tipo2': 'Actual'}}

Si necesitamos imprimir que el usuario tiene una cuenta bancaria de tipo ahorro, primero necesitaríamos
tomar la segunda clave 'Tipo de cuenta' y luego tomar la primera clave de ese diccionario resultante.
Luego podemos pasar eso fácilmente a la declaración impresa.
En []: print('Tienes una '+ Acct_Dict['Tipo de cuenta']['tipo1']+ ' cuenta')

Out[]: Tienes una cuenta de ahorros

Observe cómo la palabra "Ahorros" se obtuvo mediante la indexación de valores clave del diccionario.
Dado que el nombre de las claves de un diccionario es importante para obtener sus valores, es importante
determinar las claves que contiene en cualquier momento. Para ver una lista de las claves que contiene
un diccionario, utilice el método .keys().
En []: Acct_Dict.keys() # Comprobando las claves en poder de Acct_Dict
Machine Translated by Google

Salida[]: dict_keys(['Nombre', 'Tipo de cuenta'])

En []: Acct_Dict['Tipo de cuenta'].keys() # Comprobando las claves internas

Fuera[]: dict_keys(['tipo1', 'tipo2'])

Consejo: existen otros métodos que se pueden utilizar con un diccionario, aunque esto es
todo lo que necesitaríamos para nuestras lecciones aquí. Sin embargo, para usar estos
métodos con un diccionario o para encontrar los métodos disponibles para cualquier otro tipo
de datos, use el método dir().
En []: # Comprobando posibles métodos con tipos de datos

# Primero declaremos algunos tipos de datos y verifiquemos sus métodos.

Cadena = 'Bob'; entero = 100; Flotación = 25,3

Lista = ['Hombre']; Tupla = 5, # Para declarar una sola tupla

# poner una coma después del valor único

Diccionario = dict([('Nombre','Max')]) # Se pueden declarar diccionarios

# usando dict() también.

A = directorio (Cadena); B = directorio (entero); C = directorio (flotante)

D = directorio(Lista); E = dir(Tupla); F = dir(Diccionario)

print ('''' Aquí están los métodos posibles con cada tipo

Instrumentos de cuerda
Machine Translated by Google

{}

Enteros

{}

flotadores

{}

Liza

{}

tuplas

{}

Diccionarios

{}

'''.formato(A,B,C,D,E,F))

Intente copiar y ejecutar el código anterior o escriba su propia variación. Sin embargo, el
punto es que descubras todos los métodos posibles disponibles para cualquier tipo de
datos en Python. Esta información le brinda acceso para realizar manipulaciones avanzadas.
Observe también los comentarios en el código, se introdujeron algunos métodos nuevos
para declarar 'Tuplas' y 'Diccionarios'. Estos son adicionales; sólo trucos que quizás desees
Machine Translated by Google

usar. Lo mismo ocurre con el uso del punto y coma para permitir declarar múltiples variables o
comandos en una línea.

Booleanos

Estos son tipos de datos condicionales que se utilizan para determinar el estado de una
declaración o bloque de código. Los booleanos tienen dos valores posibles, "Verdadero" o
"Falso", que tienen valores enteros correspondientes de 1 y 0 respectivamente.
En []: A = Verdadero # Los valores booleanos parecen cadenas pero no están entre comillas

escribe un)

Fuera[]: booleano

En []: int(A) # Valor entero del booleano

Afuera[]: 1

Como puede verse, el valor entero correspondiente al booleano 'Verdadero' es 1. Pruebe el

código anterior para el booleano 'Falso'.

Para la mayoría de las operaciones, los booleanos suelen ser valores de salida que se utilizan
para especificar condiciones en una declaración de bucle o comprobar la existencia de un
elemento o condición. Esto nos lleva al uso de operadores lógicos y de comparación.

Operadores de comparación

Estos operadores, como su nombre lo indica, se utilizan para verificar la validez o no de una
comparación. Los siguientes son operadores de comparación:

Tabla 1: Operadores de comparación

<
Menos que
>
Mas grande que
==
Igual a
<=
Menos que o igual a
>=
Mayor qué o igual a
!
No operador (se puede combinar con cualquiera de los anteriores)

Esto comprueba la existencia de un elemento/valor.

Machine Translated by Google

en

Ejemplo 32: Comprobemos las condiciones utilizando los operadores de comparación.

En []: #Este código ilustra el resultado de la comparación booleana

imprimir (5 <10); imprimir (3>4); print('Bob'=='María');

imprimir (Verdadero == 1); imprimir (Falso == 0); imprimir (Verdadero! = 1)

Fuera[]: Verdadero

FALSO

FALSO

Verdadero

Verdadero

FALSO

En []: #El operador 'en'

imprimir ('Max' en 'Max Payne'); imprimir (2 en [1,3,4,5]); imprimir (Verdadero en [1,0])

Fuera[]: Verdadero

FALSO

Verdadero

Operadores logicos

Estos son el equivalente en Python de las puertas lógicas. Esta es una técnica básica para
realizar operaciones lógicas y también se puede combinar utilizando las versiones interpretadas
de la ley de De Morgan.

En caso de que se lo pregunte, De Morgan es un británico que encontró una manera de

simplificar la lógica booleana utilizando reglas inventadas anteriormente por otro británico,
George Boole (Boolean lleva el nombre de este tipo).

Tabla2: Operadores lógicos

y/&
Se evalúa como verdadero si, y sólo si, ambos operandos son verdaderos; en caso contrario, falso.

Se evalúa como verdadero si, al menos, uno de los operandos es verdadero; en caso contrario, es falso.

o/ |
Esta es una inversión del valor/operación de su operando.
Machine Translated by Google

no/ !

Ejemplo 33: Probemos algunas operaciones lógicas (tabla de verdad) con el operador 'y'.

En []: #El operador 'y'

imprimir (Verdadero y Verdadero); imprimir (Verdadero y Falso); imprimir (Falso y Falso)

imprimir (Falso y Verdadero); print('foo' en 'foobar' y 1<2)

Fuera[]: Verdadero

FALSO

FALSO

FALSO

Verdadero

Ejemplo 34: Probemos algunas operaciones lógicas (tabla de verdad) con el operador 'o'.

En []: #El operador 'o'

imprimir (Verdadero | Verdadero); imprimir (Verdadero o Falso); imprimir (Falso o Falso) imprimir

(Falso o Verdadero); imprimir (('foo' en 'foobar') | 1<2)

Fuera[]: Verdadero

Verdadero

FALSO

Verdadero

Verdadero

Para la última operación en el código anterior, observe cómo la operación de cadena está entre
paréntesis antes de usar el 'o lógico'. Esto se debe a que Python arroja un error en el caso de
comparar operaciones de cadena directamente con otros tipos usando la lógica o.

Ejercicios:

1. Aquí hay dos listas de alimentos: ['Frijoles','Trigo','Pan'] y

Machine Translated by Google

['Arroz','Plátano','Pizza','Espagueti']

a. Escriba un código Python para comprobar si la palabra 'Rice' existe en ambas listas.

b. Escriba un código Python para comprobar si 'Pizza' existe en al menos uno de los
liza.

2. Cree un diccionario de Python con dos claves. La clave 1 debe ser inmutable, mientras que
la clave 2 puede cambiar. Alternativamente, los valores mantenidos por las claves 1 y 2 son
una secuencia de números enteros; sin embargo, los valores de la clave 1 se pueden editar,
mientras que los de la clave 2 deben ser inmutables. Sugerencia: recuerde, los tipos de
datos inmutables son cadenas y tuplas.

Ahora que hemos analizado todos los tipos de datos, pasemos a los bucles y los condicionales.

Declaraciones condicionales y bucles

Estos son un poco diferentes de lo que hemos estado haciendo hasta ahora. Nuestros ejemplos
anteriores pueden describirse como 'ejecución secuencial de programas', en la que las expresiones se
evalúan línea por línea sin ningún tipo de control. Sin embargo, las declaraciones condicionales se
utilizan para controlar cómo y cuándo se ejecutan las líneas de código. Los bucles, por otro lado, se
utilizan para repetir la ejecución de un código o bloques de código específicos. Estos dos algoritmos de
control diferentes se utilizan principalmente juntos para desarrollar programas de diversa complejidad,
aunque se pueden utilizar de forma independiente uno del otro.

Consideremos la declaración condicional más básica y de uso frecuente: la 'SI '.

declaración.

Esto tiene una sintaxis de la forma:

si expresión :

declaración

La expresión en este caso suele ser una operación booleana, mientras que la declaración es una línea/
bloque de código que se ejecutará una vez que el booleano se evalúe como verdadero o falso (o no sea
verdadero o falso).
Machine Translated by Google

Ejemplo 35: escribamos un programa que otorgue acceso a un usuario cuando se ingresa cualquiera de
las tres contraseñas correctas.
En []: # Otorgar acceso si la contraseña del usuario es correcta

contraseña_pool = ('Smith_crete','Alex@456','CEO4life')

user_password = input ('Ingrese su contraseña: \t')

# Ahora la condición IF

si contraseña_usuario en grupo_contraseñas:

print('\n ¡Acceso concedido!')

Fuera[]: Por favor introduzca su contraseña: CEO4life

¡Acceso permitido!

Ese fue un programa divertido, ¿verdad? La idea es que Python verifique si la contraseña ingresada por el
usuario está disponible en el grupo de contraseñas declarado anteriormente (¿observa que el grupo de
contraseñas es una tupla? Esta es una forma práctica de crear contraseñas fijas/seguras)

Ejercicio: escriba un programa para calcular cuánto debe una persona por conservar una película después
de la fecha de vencimiento del alquiler. Supongamos que habrá un aumento en el precio dado que la
persona conserva la película más de 3 días.

Ejemplo 36:
En []: # Precio de alquiler vencido de película

precio1 = 5 # $ 5 por cada día vencido dentro de los primeros 3 días

precio2 = 7 # $ 7 por cada día de atraso después de los primeros 3 días

días_pasados_due = eval(input('Cuántos días vencidos:\t'))

# Si declaración

si días_pasados_vencimiento <= 3:

print('\nDebes $',(days_past_due*price1))

si días_pasados_vencidos > 3:

print('\nDebes $',(3*precio1 + (days_past_due ­ 3)*precio2))

Machine Translated by Google

Salida[]: Cuantos días de atraso: 4

Debes $22

¿Ves cómo podemos combinar múltiples declaraciones if para escribir código aún más complejo? Sin
embargo, existe una mejor sintaxis para evaluar múltiples declaraciones IF condicionales; las
declaraciones IF­ELSE .

Tiene una sintaxis como esta:

si expresión :

declaración

demás:

declaración alternativa

Ejemplo 37: Versión mejorada del ejemplo 35 usando IF­ELSE

En []: # Otorgar acceso si la contraseña del usuario es correcta o generar alarma

contraseña_pool = ('Smith_crete','Alex@456','CEO4life')

user_password = input ('Ingrese su contraseña: \t')

# Ahora las condiciones IF­ELSE

si contraseña_usuario en grupo_contraseñas:

print('\n ¡Acceso concedido!')

demás:

print('\n ¡Acceso denegado! Llamando a seguridad…')

Out[]: Por favor ingrese su contraseña: contraseña incorrecta

¡Acceso denegado! Llamando a seguridad...

Ahora bien, este parece un sistema de seguridad más razonable, ¿verdad? Aún así, el condicional IF
mejora con la sintaxis IF­ELIF­ELSE. Esto le permite especificar acciones en múltiples situaciones.

Sintaxis:
si expresión :

declaración
Machine Translated by Google

expresión elif :

declaración

expresión elif :

declaración

demás:

declaración alternativa/predeterminada

La sintaxis anterior se puede explicar en lenguaje normal como "Si se cumple la primera
condición, ejecute la acción dentro de la primera declaración, o si no, si no se cumple la primera
condición, realice la acción bajo la segunda declaración". Esto continúa hasta la declaración
else que por defecto indica la incapacidad del programa para cumplir cualquiera de las
condiciones dentro de las declaraciones IF y ELIF.

Ejemplo 38: una versión aún mejor del ejemplo 35.

En []: # Otorga acceso y saluda al usuario si la contraseña del usuario es correcta.

# De lo contrario, dé la alarma.

contraseña_pool = ('Smith_crete','Alex@456','CEO4life')

user_password = input ('Ingrese su contraseña: \t')

# Ahora las condiciones IF­ELIF­ELSE

si contraseña_usuario en grupo_contraseñas y contraseña_usuario == 'Smith_crete':

print('\n¡Acceso concedido! Bienvenido Dr. Smith')

elif contraseña_usuario en grupo_contraseñas y contraseña_usuario == 'Alex@456': print('\n¡Acceso

concedido! Bienvenido Sr. Alexander')

elif contraseña_usuario en grupo_contraseñas y contraseña_usuario == 'CEO4life':

print('\n¡Acceso concedido! Bienvenido, Sr. CEO')

else: print('\n¡Acceso denegado! Llamando a seguridad...')

Out[]: Por favor ingrese su contraseña: contraseña incorrecta

¡Acceso denegado! Llamando a seguridad...

Machine Translated by Google

Fuera[]: Por favor ingrese su contraseña: Alex@456

¡Acceso permitido! Bienvenido Sr. Alejandro

Fuera[]: Por favor ingrese su contraseña: Smith_crete

¡Acceso permitido! Bienvenido Dr. Smith

Fuera[]: Por favor introduzca su contraseña: CEO4life

¡Acceso permitido! Bienvenido Sr. CEO

Ejercicio: ahora que ha aprendido el enunciado condicional IF y sus variaciones, pruebe por su cuenta
algunos ejemplos más creativos y complicados.
Por ejemplo, puede escribir un programa que verifique una base de datos, imprima las puntuaciones
de los exámenes de matemáticas de los estudiantes y comente si aprobaron el examen o no.

Sugerencia: La base de datos en su ejemplo podría ser una variación del 'grupo de contraseñas en el
ejemplo 37'

Veamos ahora los bucles. Consideraremos dos bucles: el bucle While y el bucle. Como se describió
For específico . anteriormente, un bucle se ejecutará indefinidamente hasta que se produzca un bucle
se cumple la condición. Debido a esto, se pueden utilizar para automatizar y realizar operaciones
realmente poderosas que abarcan un amplio rango; sin embargo, deben usarse con precaución para
evitar bucles infinitos.

Mientras bucle

Este bucle se utiliza para ejecutar un conjunto de declaraciones o código siempre que una condición
especificada sea verdadera. La declaración condicional que controla el algoritmo se llama bandera y
siempre es verdadera para todos los valores distintos de cero. Cuando la bandera se vuelve cero, el
bucle while pasa a la siguiente línea de código que le sigue. Podría haber una sola declaración o
varias dentro del ciclo while, y Python admite la declaración else para el ciclo while.

Un bucle while tiene la siguiente sintaxis:

Machine Translated by Google

mientras bandera :

declaración

Ejemplo 39: Escribir un bucle while para imprimir una declaración 5 veces.
En []: # bucle while para imprimir la salida 5 veces

yo = 1 # encimera

mientras yo <6: # bandera

imprimir (i,': Me encanta Python')

yo = yo+1 # Esto incrementa el valor de 'i'

demás:

imprimir ('\nEl programa se ha completado')

Fuera[]: 1: Me encanta Python

2: Me encanta Python

3: Me encanta Python

4: Me encanta Python

5: Me encanta Python

El programa ha finalizado

Bien, el programa funcionó. ¿Pero cómo?

Lo primero es la bandera. La variable 'i ' se declaró con un valor de 1. Para la primera iteración,
Python verifica si 1 es menor que 6: la bandera es verdadera ya que 1 es menor que 6 y se
ejecuta la declaración de impresión (junto con el contador que agregamos para imprimir el
estado del bucle). Esto continúa hasta que se completa el ciclo (cuando i=6), luego se ejecuta
la instrucción else (ya que la bandera ahora es falsa). Suponiendo que la declaración else
estuviera ausente, la declaración while finaliza (o en el caso de un programa más grande, pasa
a la siguiente línea de código).

Sugerencia: ¿Observa el incremento que incluimos después de la declaración impresa? Esto

es importante, ya que es lo que hace que el valor de nuestro contador cambie para permitir una
duración de bucle específica. También tuvo que colocarse dentro del bucle While de manera
que el incremento se ejecute en cada iteración. Si eliminamos el código de incremento,
tendríamos un bucle infinito ya que 'i' (con un valor inicial de 1) nunca será igual
Machine Translated by Google

a6

Los bucles de Python tienen algunas declaraciones de control adicionales para manejar su ejecución.
Tenemos los 'Pausa', 'Continuar' y 'Pasar'. La declaración break se utiliza para detener la ejecución
del bucle una vez invocado. A veces podría resultar útil para proteger un bucle contra el incumplimiento
de un bucle infinito. La instrucción continue, sin embargo, vuelve a probar la condición del bucle
desde el momento en que se invoca, esto conduce a una continuación del bucle desde un punto de
parada (usualmente usado para reanudar el bucle después de una instrucción de interrupción).

No usaríamos la instrucción pass aquí, ya que solo es útil para omitir la ejecución de una expresión
de bucle que de otro modo sería requerida por la sintaxis del bucle.

Ejemplo 40: usemos un bucle while junto con la instrucción continue para crear un programa que
imprima números del 1 al 10, pero se salte el 8.
En []: # Este programa imprime del 1 al 10 pero se salta el 8

yo = 0 # Encimera

mientras yo <= 9:

yo = yo+1 # Incremento

si yo == 8:

continuar

imprimir(yo)

else: imprimir ('\nEl programa ha finalizado')

Fuera[]: 1

10
Machine Translated by Google

El programa ha terminado

Consejo: ¿Observó cómo se colocó nuestro incremento antes de la ' declaración de continuación '?
Esto es importante para evitar un bucle infinito. En este caso, cuando el contador ' i ' es igual a 7,
se incrementa a 8 y la instrucción if ejecuta la ' instrucción continuar '. Luego se vuelve a probar la
condición y el incremento suma 1 al valor. Como 9 es mayor que 8, el resto del código se ejecuta
hasta que finaliza el ciclo.

Suponiendo que el incremento es posterior a las declaraciones if & continue , cuando 'i' es igual a
8, la declaración continue vuelve a probar la condición. Ahora bien, como no hay ningún incremento
en el valor de 'i' después de este punto, la condición 8 <= 9 siempre será verdadera y el ciclo
continúa indefinidamente.

Escribamos la versión de bucle indefinido de este programa y usemos la instrucción break para
finalizarlo después de 15 iteraciones.

Ejemplo 41: este programa utiliza la instrucción break y continue para crear un bucle indefinido y
una secuencia de escape.
En []: # Este programa está destinado a imprimir del 1 al 10 y omitir 8

# Funciona indefinidamente hasta un descanso.

yo = 1 # variables de bucle

j=1

mientras yo<=10:

imprimir ('Iteración ',j)

si j >= 15:

romper # secuencia de escape de bucle

j = j+1

si yo == 8:

continuar # bucle indefinido

imprimir('\tvalor =',i)

yo = yo+1

else: print('\nEl programa ha finalizado')

Fuera[]: Iteración 1
Machine Translated by Google

valor = 1

Iteración 2

valor = 2

Iteración 3

valor = 3

Iteración 4

valor = 4

Iteración 5

valor = 5

Iteración 6

valor = 6

Iteración 7

valor = 7

Iteración 8

Iteración 9

Iteración 10

Iteración 11

Iteración 12

Iteración 13

Iteración 14

Iteración 15

Vea cómo el bucle se volvió indefinido en la salida '7' como se explicó anteriormente.

Consejo: asegúrese siempre de que su bucle pueda finalizar o insertar una declaración de interrupción para
manejar dichos errores.

En bucle

Estos bucles se utilizan para iterar a través de una secuencia de valores. Ejecuta una declaración
de código por cada elemento presente en la secuencia de destino. Al igual que los bucles while,
también están sujetos a una ejecución indefinida dependiendo de cómo se declaren.

El bucle for tiene la siguiente sintaxis:

para iterador en secuencia:
Machine Translated by Google

declaración

Recuerde el operador 'in' de nuestros ejemplos comparativos. Es un operador de bucle for.

La variable o el nombre del iterador no importa en el bucle for, puede ser cualquier cosa; sin embargo,
la secuencia debe especificarse correctamente junto con el bucle.
declaración.

Nota: Si bien no es común que los bucles for sean infinitos en Python, es posible.
Dado que el bucle for itera a través de una secuencia, es lógico que la duración del bucle dependa
del tamaño de la secuencia. Si la secuencia fuera infinita en longitud, entonces el bucle for se
ejecutará para siempre.

A continuación se muestra un ejemplo de un bucle for infinito. Observe cómo la lista crecerá
indefinidamente a través del incremento del tamaño de la lista y los elementos mediante el método
de lista .append.

En []: Lista_indefinida = [0]

para x en lista_indefinida:

Lista_indefinida.append(0)

imprimir(x)

El resultado no se incluye aquí porque el código se ejecuta para siempre. Puede intentar ejecutar
este programa; sin embargo, cuando el código se ejecute indefinidamente, haga clic en la pestaña
'Kernel' en la parte superior de su computadora portátil Jupyter y seleccione 'reiniciar kernel y borrar
salida'. Esto reiniciará esa celda actual y detendrá el ciclo inmediatamente.

Ahora probemos algunos ejemplos de bucles for.

Ejemplo 42: escribamos un código que imprima todos los elementos de una lista.
En []: # Este programa acepta una lista e imprime los números de sus elementos

Lista = eval (entrada ('Ingrese una secuencia de números usando [ ] :\t'))

por valor en la lista:

print ('\nValor',valor,'es: ',Lista[valor­1])

Out[]: Ingrese una secuencia de números usando [ ] : [1,2,3,4,5]

El valor 1 es: 1
Machine Translated by Google

El valor 2 es: 2

El valor 3 es: 3

El valor 4 es: 4

El valor 5 es: 5

Recuerde, el bucle for requiere una secuencia para que se produzca su iteración. En los casos
en los que necesite una cierta cantidad de iteraciones y desee declarar una secuencia arbitraria
de valores con la longitud deseada, puede usar la función range() de Python.

La función de rango crea una secuencia de valores numéricos comenzando desde los
argumentos inferiores hasta una cantidad de elementos especificados por el argumento superior.

Sintaxis: rango(x,y)

Aquí, x es el valor inicial de la secuencia con valores de y , y el último valor de un rango suele
ser y ­1.

Ejemplo 43: cree una lista de 10 números enteros separados entre 0 y 10.
En []: # usando la función de rango

Lista = lista(rango(0,10))

imprimir (lista)

Fuera[]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Consejo: En este ejemplo, la lista se creó utilizando el método list(). Sin embargo, se ha
demostrado la función de rango.

Ejercicio: escriba un bucle for que repita una lista de 10 elementos e imprima el valor de cada
elemento junto con la iteración.

Sugerencia: use la función range() y el método list() para generar su lista. Pruebe también
diferentes variaciones de este ejercicio (aplicaciones más prácticas y complicadas).
Machine Translated by Google

Comprensión de listas

Esta es una forma sencilla de ejecutar bucles for y algunas otras operaciones condicionales con
listas en Python.
Sintaxis:

[declaración para iterador en secuencia si condición]

para iterador en secuencia: # Código equivalente

si condición:

Ejemplo 44: usemos la comprensión de listas para elevar al cuadrado todos los elementos de una lista
En []: lista_prueba = lista(rango(10))

[(trial_List[item])**2 para el artículo en try_List]

Fuera[]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Para utilizar la parte de la sintaxis de la declaración IF , consideramos una sintaxis de declaración

IF rápida permitida por Python.
Una condición if else B

Esto le permite escribir una declaración IF de una línea que ejecuta la acción/declaración 'A ' si
se cumple la condición ; de lo contrario, evalúa B . Por lo tanto, para la parte de la declaración IF
de la sintaxis de comprensión de listas, podemos considerar la declaración ' anterior para el
'
iterador en la secuencia e como 'A ' que se ejecuta si se cumple una condición.

Ejemplo 45: Usemos la parte IF de la comprensión de listas para capturar solo las tres primeras
letras de cada elemento de cadena en una lista.
En []: # Toma las primeras tres letras de las cadenas

Lista = ['Matrix','Trilogía',1,3.4,'Ganado']

# bucle de agarre

new_List = [cosas[:3] para cosas en la Lista si tipo(cosas)== str]

imprimir (nueva_lista)
Machine Translated by Google

Fuera[]: ['Mat', 'Tri', 'Cat']

Vea lo útil y compacto que es este código. Aquí iteramos a través de la Lista usando el iterador
'cosas', y le pedimos a Python que tome la porción de 'cosas' (que sería el elemento que indexa en
cualquier instante del ciclo) hasta el tercer elemento, es decir, cosas [:3 ] (¿recuerda los ejemplos y
ejercicios de captura de corte/rango?).
Todas estas acciones luego son controladas por la última declaración IF que verifica si el elemento
indexado por 'cosas' tiene un tipo == cadena , es decir, es una cadena. ¿Suficientemente fácil?

Ejercicio: A la lista del ejemplo 45, agregue las siguientes palabras 'Jeep', 'Man' y 'Go'. Ejecute el
mismo código del ejemplo 45 con la lista actualizada; sin embargo, solo tome las primeras 3 letras
de las palabras que tengan al menos 3 letras, es decir, todos los elementos de su lista de salida
deben tener tres letras.

Sugerencia: utilice el método list .extend() de ejemplos anteriores para actualizar la lista.
Además, utilice la función len() para comprobar el número de letras de una palabra. Finalmente, la
declaración IF puede tomar operadores lógicos 'y, o, no' .

Con la comprensión de listas, usar la declaración IF­ELSE es un poco diferente. En este caso,
primero viene la declaración IF­ELSE y luego el bucle for.

Sintaxis: [A si la condición es B para el iterador en secuencia]

Esto es similar a la declaración IF de una sola línea, pero con un bucle for al lado.

Ejemplo 46: Escriba un programa que acepte entradas del usuario para la cantidad de elementos de
la lista. Luego, el programa crea una lista numérica del 1 a ese número, cuyos valores son los
cuadrados de cada número impar y la mitad para los números pares.

En []: # Crear lista definida por el usuario

nitems = eval(input('Ingrese el número de elementos de la lista: '))

new_list = [x**2 if x%2 != 0 else x/2 for x in range(1,nitems+1)]

print('\n Aquí está su lista personalizada\n\n',new_list)

Out[]: Ingrese el número de elementos de la lista: 10

Machine Translated by Google

Aquí está tu lista personalizada

[1, 1,0, 9, 2,0, 25, 3,0, 49, 4,0, 81, 5,0]

Vea cómo creamos un programa tan poderoso en 3 líneas. Esa es la ventaja de la

comprensión de listas.

Consejo: Tómese el tiempo para revisar la sintaxis para comprender la lista, ya que será muy
útil para escribir códigos concisos en el futuro.

Hay otros tipos de comprensión en Python, como la comprensión del diccionario; sin embargo,
lo que necesitamos por ahora es comprender la lista.

Funciones
En Python, o cualquier otro lenguaje de programación, no se puede subestimar el uso de
funciones. Permite al programador llamar a ciertos bloques de código para realizar una
acción sin tener que escribir dicho código cada vez. Python tiene algunas funciones
integradas como 'rango ()', 'lista ()', 'tipo ()', etc. que hemos usado en ejemplos anteriores.
Como notamos, el uso de estas funciones nos ahorró tiempo en su uso. Sin embargo, dado
que Python se parece más a una herramienta/plantilla para escribir varios programas
compatibles con su biblioteca, difícilmente puede contener funciones que realicen cualquier
acción que un programador pueda requerir. Es por eso que existe una opción para definir
funciones personalizadas en Python. Con esta opción, puede escribir y llamar su propio
código para realizar una operación más grande.

Para definir una función en Python, usamos la palabra clave def (). Puede optar por interpretar
la palabra clave en el sentido de "definir". Hace que sea más fácil de comprender.

Sintaxis: def nombre_función('argumentos'):

líneas de código

El nombre_función es el nombre que desee asignar a su función. Este debería ser un nombre
que tenga sentido en cuanto a lo que hace la función. Las funciones también aceptan
argumentos , que son entradas para que la función las evalúe.
Dependiendo de la función que elija definir, los argumentos pueden ser cualquier cosa o
nada.
Machine Translated by Google

Parece bastante fácil, ¿verdad? Definamos algunas funciones y llamémoslas para realizar ciertas
acciones.

Ejemplo 47: Defina una función que imprima ("Hola usuario") cuando se llame.
En []: saludo definido (nombre):

imprimir('Hola',nombre)

Ahora llamemos a la función

En []: saludar('David')

Hola David

En []: saludar ('chico usuario de Python')

Hola usuario de Python.

Mira, solo necesitábamos llamar a la función y pasar nuestro argumento. Con este método, podemos
enviar un saludo a cualquier valor de cadena sin tener que escribir ninguna declaración impresa.

Es una buena práctica incluir una 'cadena de documentos' al escribir una función. Estos son
comentarios (generalmente de varias líneas) que le dicen al usuario de la función cómo llamarla y
qué hace. En el cuaderno Jupyter, una vez que se escribe el nombre de una función, presione la
tecla Mayús + tabulador en Windows y se muestra la cadena de documentación. Puedes probar esto
para cualquiera de las funciones que hemos utilizado hasta ahora.
Machine Translated by Google

Figura 4: Ejemplo de cadena de documentos para la función de impresión.

Para incluir una cadena de documentación para su función, simplemente agregue un comentario
de varias líneas utilizando el método de las tres comillas. Ahora puede consultar la documentación
de su función.

Intentemos recrear el ejemplo 46 usando una función. La función solicita al usuario la longitud de la
lista requerida y luego genera una lista personalizada. También incluiríamos una documentación.

Ejemplo 48:
En []: # función que crea una lista definida por el usuario

def lista_personalizada(nitems):

"""

Esta función acepta un valor numérico y crea una lista.

La lista contiene cuadrados de números impares dentro del rango

de 1 y entrada del usuario, así como valores medios para el par

números en ese rango.

sintaxis: lista_personalizada (valor numérico)

Machine Translated by Google

"""

si nitems > 0: # Esto garantiza el cumplimiento del usuario

new_list = [x**2 if x%2 != 0 else x/2 for x in range(1,nitems+1)]

else: print('¡Ingrese un número válido!') # en caso de falla.

print('\n Aquí está su lista personalizada\n\n',new_list)

Ahora hemos creado nuestra función. Llamemos a la función para ver la acción.

En []: # llamando a la función

lista_personalizada(5)

Afuera[]: Aquí está tu lista personalizada

[1, 1,0, 9, 2,0, 25]

¡La función funciona! Sin embargo, como solo imprimimos el resultado, no podemos acceder a
la lista creada por la función. Suponiendo que necesitamos usar esa lista para otras operaciones
dentro de nuestro código en lugar de solo verla, podemos usar la declaración return para asignar
la salida de nuestra función a una variable, que luego podemos usar más adelante.

Esta es solo una variación del código del ejemplo 48.

Ejemplo 49:

En []: # función que crea una lista definida por el usuario y devuelve un valor

def lista_personalizada(nitems):

"""

Esta función acepta un valor numérico y devuelve una lista.

La lista contiene cuadrados de números impares dentro del rango

de 1 y entrada del usuario, así como valores medios para el par

números en ese rango.

Machine Translated by Google

sintaxis: Nombre_lista = lista_personalizada(valor numérico)

"""

si nitems > 0: # Esto garantiza el cumplimiento del usuario

new_list = [x**2 if x%2 != 0 else x/2 for x in range(1,nitems+1)]

else: print('¡Ingrese un número válido!') # en caso de falla.

devolver nueva_lista

Ahora llamemos a nuestra función para asignar la lista a una variable 'Lista'.
En []: Lista = lista_personalizada(10)

Lista

Fuera[]: [1, 1,0, 9, 2,0, 25, 3,0, 49, 4,0, 81, 5,0]

¿Observa cómo llamar a 'Lista' produce una salida? La función funciona correctamente.

Ejercicio: Intente crear una función que realice una variación de la acción del ejemplo 45. La
función acepta una lista de entrada (de tipos mixtos) y extrae solo números de la lista.

Consejo: para detectar números, puede utilizar una variación del método ilustrado en el ejemplo
45, es decir, tipo(elemento) == int o double. Otro método es utilizar el método .isdigit(), es decir,
item.isdigits

Ejemplo 50: Ilustración del método .isdigits(). # cadena

En []: cadena = '123456ABC' mixta con dígitos y caracteres
A = [x para x en cadena si x.isdigit()]

Fuera[]: ['1', '2', '3', '4', '5', '6']

Para concluir este capítulo introductorio a la programación en Python, veremos

Machine Translated by Google

Algunas funciones más que serían útiles se encuentran en la siguiente sección. Estos incluyen:
la función de mapa, el filtro y las expresiones lambda. Analicemos primero las expresiones
lambda, ya que también son más útiles para mapear funciones y filtros.

expresión lambda

Esto también se llama función anónima. Las expresiones Lambda se utilizan en casos en los que
no desea escribir una función completa. En este caso, sólo necesita usar la función temporalmente
y definir una función completa solo para eso parece redundante.

También reduce el esfuerzo al escribir código para definir funciones. Tiene la siguiente sintaxis:
var = argumento lambda: declaración

Una función también se puede expresar en una línea como tal:

def nombre_función (argumento): salida de retorno

Ejemplo 51: escribamos una función rápida que eleve un número al cuadrado y devuelva un
valor.
En []: def valor_cuadrado (número): número de retorno**2 #definición

valor_cuadrado(10) # llamando a la función

Afuera []: 100

Alternativamente, usando la expresión lambda:

En []: cuadrado = número lambda:número**2

cuadrado(10)

Afuera[]: 100

La expresión lambda del ejemplo 51 se puede comparar con la función valor_cuadrado. Se

puede observar que se han eliminado algunas palabras: def, return y nombre_función. Tenga en
cuenta que las expresiones lambda deben asignarse a una variable, y luego la variable actúa
como una función como lo ilustra la variable 'cuadrada' que logra el mismo resultado que la
función valor_cuadrado.
Machine Translated by Google

Función de mapa

La función de mapa es otra forma conveniente de trabajar con listas, especialmente en los casos
en los que es necesario pasar los elementos de una lista a una función en una iteración. Como
era de esperar, los bucles for son la primera consideración para tal tarea.
Sin embargo, la función de mapa, que recorre cada elemento de una lista y los pasa a un
argumento de función, simplifica dicha tarea.
Sintaxis: mapa (función, secuencia/lista)

Para devolver el mapa como una lista de valores, use la función list () y asígnela a una variable.

var = lista (mapa (función, secuencia/lista))

Podrías pasar una función real al mapa o, más prácticamente, usar una expresión lambda.

Ejemplo 52: escribamos un código usando la función de mapa para elevar al cuadrado todos los
elementos de una lista.

En []: # Este programa cuadra todos los elementos de una lista

Lista = lista(rango(1,11))

# usando la expresión lambda 'cuadrado'

nueva_lista = lista(mapa(cuadrado,Lista))

lista nueva

Fuera[]: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Ejercicio: utilizando la expresión lambda y la función de mapa, escriba un programa que cree
una lista de valores y muestre todos los elementos de la lista.

Función de filtro

Se utilizan para extraer elementos específicos de una secuencia basada en una función
booleana. La función booleana también se puede crear usando una expresión lambda y el filtro
devuelve los valores esperados que cumplen con los criterios del filtro (considérelo como una
versión simplificada de una declaración if).

Sintaxis: filtro (función, secuencia/lista)

Para devolver el mapa como una lista de valores, use la función list () y asígnelo a un
Machine Translated by Google

variable.
var = lista (filtro (función, secuencia/lista))

Ejemplo 53: extraiga solo los números pares de la nueva lista creada en el ejemplo 52 usando la
función de filtro.

En []: # Extrayendo números pares

criterios = valor lambda: valor%2==0 # identificador de número par

# usando new_list del ejemplo 52

lista_pareja = lista(filtro(criterios,lista_nueva))

lista_pareja

Fuera[]: [4, 16, 36, 64, 100]

Generalmente se utilizan lambda, mapa y filtro respectivamente. Es importante dominarlos y mejorará

considerablemente tus habilidades con la manipulación de listas, lo cual es muy importante en la
sección siguiente.

Con esto concluye la parte introductoria a Python y todos los requisitos previos para seguir las lecciones
del siguiente capítulo. Complete los siguientes ejercicios para poner a prueba su conocimiento actual
de las principales lecciones de este capítulo. ¡Toda la suerte!

Ejercicios:

Estos ejercicios ponen a prueba tus habilidades en todo lo que has aprendido en este capítulo. Intente
resolverlos usted mismo y, si encuentra alguna dificultad, revise todos los ejemplos y la sintaxis.

1. Dadas las siguientes variables: cantidad = 'Gravedad', unidad = 'm/s^2' y valor = 10, use el
método .format() para imprimir la siguiente declaración: La gravedad tiene un valor de 10 m/
s ^2.

2. Escriba una función que imprima Verdadero si la palabra 'bueno ' aparece en cualquier lista
de cadenas.

3. Utilice la expresión lambda y la función de filtro para extraer palabras que se encuentren en
no empezar con la letra 'b ' la siguiente lista
['pan','arroz','mantequilla','frijoles','pizza','lasaña','huevos']

4. Dada esta lista anidada, utilice la indexación para capturar la palabra "hola Python".
Machine Translated by Google

lista = [1,2,[3,4],[5,[100,200,['hola Python']],23,11],1,7]

5. Dado este diccionario anidado, tome la palabra "hola Python"

d = {'k1':[1,2,3,{'tricky':['oh','man','inception',{'target':[1,2,3,'hola']}] }]}

6. Escribe una función que acepte dos argumentos. El primer argumento es el

nombre del estudiante, el otro es la puntuación del estudiante. Deje que el programa imprima el
nombre del estudiante y grado.

La salida depende de los siguientes criterios:

Criterios:

Si la puntuación del estudiante es inferior a 40: Hola nombre de estudiante , tenías una F

Si la puntuación del estudiante está entre 40 y 44: Hola nombre de estudiante , tenías una E

Si la puntuación del estudiante está entre 45 y 49: Hola nombre de estudiante , tenías una D

Si la puntuación del estudiante está entre 50 y 59: Hola nombre de estudiante , tenías una C

Si la puntuación del estudiante está entre 60 y 69: Hola nombre de estudiante , tenías una B

Si la puntuación del estudiante es de 70 o más: obtuviste hola nombre del estudiante

una A, ¡genial!
Machine Translated by Google

Capitulo 2

Análisis de datos con Python

El análisis de datos incluye todas las técnicas y procesos utilizados para extraer información a
partir de datos sin procesar. Dado que los datos brutos suelen tener una forma no estructurada
y poco informativos, la necesidad de organizarlos se vuelve aún más importante. Si bien
existen muchas herramientas adicionales que se pueden usar para manejar el análisis de
datos, es decir, Microsoft Excel, lenguaje R, SQL, etc., la mayoría de los científicos de datos
prefieren usar Python debido a sus extensas bibliotecas y paquetes de soporte para el análisis de datos.
Los paquetes/marcos más populares que exploraremos en este capítulo son NumPy y Pandas.

NumPy
Este es el paquete numérico de Python que admite operaciones vectoriales y matriciales. Es
un paquete Python muy popular para programación científica, matemática y de ingeniería;
especialmente para problemas algebraicos lineales. En gran medida, los datos numéricos se
pueden simplificar en matrices (vectores o matrices, según las dimensiones), y es por eso que
NumPy es igualmente útil en la manipulación y organización de datos.

Instalación del paquete

Para comenzar con NumPy, debemos instalar el paquete en nuestra versión de Python. Si
bien el método básico para instalar paquetes en Python es el método pip install l, usaremos el
método conda install l. Esta es la forma recomendada de administrar todos los paquetes de
Python y entornos virtuales utilizando el marco anaconda.

Dado que instalamos una versión reciente de Anaconda, la mayoría de los paquetes que
necesitamos se habrían incluido en la distribución. Para verificar si hay algún paquete
instalado, puede usar el comando conda lis t a través del indicador anaconda. Esto muestra
todos los paquetes actualmente instalados y accesibles a través de anaconda. Si el paquete
deseado no está disponible, puede instalarlo mediante este método:
Machine Translated by Google

Primero, asegúrese de tener una conexión a Internet. Esto es necesario para descargar el paquete
de destino a través de conda. Abra el mensaje de anaconda, luego ingrese el siguiente código:

Paquete de instalación de Conda

Nota : En el código anterior, 'paquete' es lo que se debe instalar, por ejemplo, NumPy, Pandas, etc.

Como se describió anteriormente, trabajaríamos con matrices NumPy. En programación, una

matriz es una colección ordenada de elementos similares. ¿Suena familiar? Sí, son como listas de
Python, pero con superpoderes. Las matrices NumPy tienen dos formas: vectores y matrices. Son
prácticamente iguales, solo que los vectores son matrices unidimensionales (ya sea una columna
o una fila de elementos ordenados), mientras que una matriz es bidimensional (filas y columnas).
Estos son los bloques fundamentales de la mayoría de las operaciones que haríamos con NumPy.
Si bien las matrices incorporan la mayoría de las operaciones posibles con las listas de Python,
introduciríamos algunos métodos más nuevos para crearlas y manipularlas.

Para comenzar a usar los métodos NumPy, primero debemos importar el paquete a nuestro
espacio de trabajo actual. Esto puede lograrse de dos formas:
importar numpy como np

de importación numerosa *

En el cuaderno Jupyter, ingrese cualquiera de los códigos anteriores para importar el paquete
NumPy. Se recomienda el primer método de importación, especialmente para principiantes, ya
que ayuda a realizar un seguimiento del paquete específico del que proviene una función/método llamado.
Esto se debe a la asignación de variables, por ejemplo, 'np', que hace referencia al paquete
importado durante la sesión de codificación.

Observe el uso de un asterisco en el segundo método de importación. Esto significa "todo/todos"

en programación. Por lo tanto, el código dice '¡¡desde NumPy importa todo!! '

Consejo: En Python, se nos pediría que hagamos referencia al paquete con el que estamos
operando, por ejemplo, NumPy, Pandas, etc. Es más fácil asignarles nombres de variables que
puedan usarse en operaciones posteriores. Esto es muy útil en un caso en el que se utilizan varios
paquetes y se utilizan nombres de variables estándar como
Machine Translated by Google

como: 'np' para NumPy, 'pd' para Pandas, etc. hace que el código sea más legible.

Ejemplo 55: Creación de vectores y matrices a partir de listas de Python.

Declaremos una lista de Python.

En []: # Esta es una lista de números enteros

Lista_int = [1,2,3,4,5]

lista_int

Afuera[]: [1,2,3,4,5]

Importando el paquete NumPy y creando una matriz de números enteros.

En []: # importar sintaxis

importar numpy como np

np.array(lista_int)

Afuera[]: matriz([1, 2, 3, 4, 5])

¿Notas la diferencia en las salidas? La segunda salida indica que tenemos

Creamos una matriz y podemos asignar fácilmente esta matriz a una variable para futuras
referencia.

Para confirmar, podemos verificar el tipo.

En []: x = np.array(Int_list)

tipo(x)

Afuera[]: numpy.ndarray

Hemos creado un vector porque tiene una dimensión (1 fila). Para comprobar esto,
Se puede utilizar el método 'ndim'.

En []: x.ndim # esto muestra cuántas dimensiones tiene la matriz

Afuera[]: 1

Alternativamente, se puede utilizar el método de la forma para ver los arreglos.

En []: x.shape # esto muestra la forma

Afuera[]: (5,)

Python describe matrices como (filas, columnas). En este caso, describe un vector.
Machine Translated by Google

como (número de elementos,).

Para crear una matriz a partir de una lista de Python, debemos pasar una lista anidada que contenga
los elementos que necesitamos. Recuerde, las matrices son rectangulares y, por lo tanto, cada lista
de la lista anidada debe tener el mismo tamaño.
En []: # Esta es una matriz

x = [1,2,3]

y = [4,5,6]

mi_lista = [y,x] # lista anidada

my_matrix = np.array(my_list) # creando la matriz

A = mi_matriz.ndim

B = mi_matriz.forma

# Impresión

print('Matriz resultante:\n\n',mi_matriz,'\n\nDimensiones:',A,

'\nforma (filas,columnas):',B)

Out[]: Matriz resultante:

[[4 5 6]

[1 2 3]]

Dimensiones: 2

forma (filas, columnas): (2, 3)

Machine Translated by Google

Ahora hemos creado una matriz de 2 por 3. Observe cómo el método de la forma muestra
las filas y columnas de la matriz. Para encontrar la transposición de esta matriz, es decir,
cambiar las filas a columnas, utilice el método de transposición ().

En []: # esto encuentra la transpuesta de la matriz

t_matrix = mi_matriz.transpose()

matriz_t

Afuera[]: matriz([[4, 1],

[5, 2],

[6, 3]])

Consejo: Otra forma de saber el número de dimensiones de una matriz es contando los
corchetes que abren y cierran la matriz (inmediatamente después del paréntesis). En el
ejemplo del vector, observe que la matriz estaba entre corchetes simples. Sin embargo,
en el ejemplo de la matriz bidimensional, hay dos corchetes. Además, se pueden utilizar
tuplas en lugar de listas para crear matrices.

Existen otros métodos para crear matrices en Python y pueden ser más intuitivos que usar
listas en alguna aplicación. Un método rápido utiliza la función arange().

Sintaxis: np.arange(valor inicial, valor final, tamaño de paso, dtype = 'tipo')

Este método es similar al método range() que usamos en el ejemplo 43. En este caso, no
necesitamos pasar su salida a la función de lista, nuestro resultado es un objeto de matriz
de un tipo de datos especificado por 'dtype'.

Ejemplo 56 : Creación de matrices con la función arange().

Crearemos una matriz de números del 0 al 10, con un incremento de 2 (números pares).

En []: # Matriz de números pares entre 0 y 10

Matriz_pareja = np.arange(0,11,2)

matriz_pareja

Afuera[]: matriz([0, 2, 4, 6, 8, 10])

Observe que se comporta como el método range () de nuestra lista de ejemplos. Devolvió
todos los valores pares entre 0 y 11 (siendo 10 el máximo). Aquí no especificamos
Machine Translated by Google

los tipos de los elementos.

Consejo: Recuerde, el método de rango devuelve un valor hasta el 'valor de parada – 1'; por lo
tanto, incluso si cambiamos el 11 por el 12, todavía obtendríamos 10 como máximo.

Como los elementos son numéricos, pueden ser números enteros o flotantes. Los números enteros son
los predeterminados; sin embargo, para devolver los valores como flotantes, también podemos especificar
el tipo numérico.
En []: Even_array2 = np.arange(0,11,2, dtype='float')

matriz_pareja2

Afuera[]: matriz([0., 2., 4., 6., 8., 10.])

Otra función útil para crear matrices es linspace() . Esto devuelve

una matriz numérica de valores de espacio lineal dentro de un intervalo. También permite
especificar el número de puntos requerido y tiene la siguiente sintaxis:
np.linspace (valor inicial, valor final, número de puntos)

De forma predeterminada, linspace devuelve una matriz de 50 puntos espaciados uniformemente

dentro del intervalo definido.

Ejemplo 57 : Crear matrices de puntos espaciados uniformemente con linspace()

En []: # Matrices de puntos espaciados linealmente

A = np.linspace(0,5,5) # 5 puntos iguales entre 0 y 5

B = np.linspace (51,100) # 50 puntos iguales entre 51 y 100

print ('Aquí están los arreglos:\n')

Aquí están las matrices:

Salida[ ]: matriz([0. , 1.25, 2.5 , 3.75, 5. ])

Fuera[ ]: matriz([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15 ., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25.,
26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48. , 49., 50.])

Observe cómo el segundo uso de linspace no requirió un tercer argumento. Esto es

Machine Translated by Google

porque queríamos 50 valores igualmente espaciados, que es el valor predeterminado. El 'tipo'

también se puede especificar como lo hicimos con la función de rango.

Consejo 1: las matrices Linspace son particularmente útiles en los gráficos. Se pueden utilizar
para crear un eje de tiempo o cualquier otro eje necesario para producir gráficos bien definidos y
escalados.

Consejo 2: El formato de salida en el ejemplo anterior no es la forma predeterminada de salida

en el cuaderno Jupyter. Jupyter muestra el último resultado por celda, de forma predeterminada.
Para mostrar múltiples resultados (sin tener que usar la declaración de impresión cada vez), el
método de salida se puede cambiar usando el siguiente código.
En []: # Permitir que Jupyter genere todos los resultados por celda.

# ejecuta el siguiente código en una celda de Jupyter.

desde IPython.core.interactiveshell importar InteractiveShell

InteractiveShell.ast_node_interactivity = "todos"

Hay ocasiones en las que un programador necesita matrices únicas como la matriz de identidad
o una matriz de unos/ceros. NumPy proporciona una manera conveniente de crearlos con las
funciones ceros (), unos () y ojo ().

Ejemplo 58: creación de matrices con elementos únicos.

Usemos la función ceros () para crear un vector y una matriz.

En []: np.zeros(3) # Un vector de 3 elementos

np.zeros((2,3)) # Una matriz de 6 elementos, es decir, 2 filas, 3 columnas

Fuera[]: matriz([0., 0., 0.])

Fuera[]: matriz([[0., 0., 0.],

[0., 0., 0.]])

Observe cómo la segunda salida es una matriz bidimensional, es decir, dos corchetes (una matriz
de 2 columnas y 3 filas como se especifica en el código).

Lo mismo ocurre con la creación de un vector o matriz en la que todos los elementos tengan un
valor de '1'.
En []: np.ones(3) # Un vector de 3 elementos
Machine Translated by Google

np.ones((2,3)) # Una matriz de 6 elementos, es decir, 2 filas, 3 columnas

Fuera[]: matriz([1., 1., 1.])

Fuera[]: matriz([[1., 1., 1.],

[1., 1., 1.]])

Además, observe cómo el código para crear las matrices requiere que las instrucciones de fila y
columna se pasen como una tupla. Esto se debe a que la función acepta una entrada, por lo que
sería necesario pasar varias entradas como tuplas o listas en el orden requerido (se recomiendan
las tuplas. Recuerde, son más rápidas de operar).

En el caso de la matriz identidad, la función ojo() solo requiere un valor.

Dado que las matrices identidad siempre son cuadradas, el valor pasado determina el número
de filas y columnas.
En []: np.eye(2) # Una matriz de 4 elementos 2 filas, 2 columnas

np.eye(3) # 3 filas, 3 columnas

Fuera[]: matriz([[1., 0.],

[0., 1.]])

Fuera[]: matriz([[1., 0., 0.],

[0., 1., 0.],

[0., 0., 1.]])

NumPy también cuenta con generadores de números aleatorios. Estos se pueden utilizar para
crear matrices, así como valores individuales, según la aplicación requerida. Para acceder al
,
generador de números aleatorios, llamamos a la biblioteca a través de np.rando my luego
elegimos el método aleatorio que prefiramos. Consideraremos tres métodos para generar
números aleatorios: rand(), randn() y randint().

Ejemplo 59: Generando matrices con valores aleatorios.

Comencemos con el método rand (). Esto genera números aleatorios distribuidos uniformemente
entre 0 y 1.
En []: np.random.rand (2) # Un vector de 2 valores aleatorios

np.random.rand (2,3) # Una matriz de 6 valores aleatorios

Fuera[]: matriz([0.01562571, 0.54649508])

Machine Translated by Google

Fuera[]: matriz([[0.22445055, 0.35909056, 0.53403529],

[0,70449515, 0,96560456, 0,79583743]])

Observe cómo cada valor dentro de las matrices está entre 0 y 1. Puede probar esto usted
mismo y observar los valores devueltos. Al ser una generación aleatoria, estos valores pueden
ser diferentes a los tuyos. Además, en el caso de los generadores de números aleatorios, no es
necesario pasar las especificaciones matriciales como listas o tuplas, como se observa en la
segunda línea de código.

El método randn () genera números aleatorios a partir de la distribución normal estándar o

gaussiana. Es posible que desees repasar algunos conceptos básicos de estadística; sin
embargo, esto sólo implica que los valores devueltos tendrían una tendencia hacia la media (que
es cero en este caso), es decir, los valores estarían centrados alrededor de cero.

En []: np.random.randn (2) # Un vector de 2 valores aleatorios

np.random.randn (2,3) # Una matriz de 6 valores aleatorios

Fuera[]: matriz([ 0.73197866, ­0.31538023])

Fuera[]: matriz([[­0.79848228, ­0.7176693, 0.74770505],

[­2.10234448, 0.10995745, ­0.54636425]])

El método randint() genera números enteros aleatorios dentro de un rango o intervalo específico.
Tenga en cuenta que el valor del rango más alto es exclusivo (es decir, no tiene posibilidades de
ser seleccionado al azar), mientras que el valor más bajo es inclusivo (podría incluirse en la
selección aleatoria).

Sintaxis: np.random(valor inferior, valor superior, número de valores, tipo d)

Si no se especifica el número de valores, Python simplemente devuelve un valor único dentro

del rango definido.
En []: np.random.randint (1,5) # Un valor aleatorio entre 1 y 5

np.random.randint (1,100,6) # Un vector de 6 valores aleatorios

np.random.randint (1,100,(2,3)) # Una matriz de 6 valores aleatorios

Fuera[]: 4

Fuera[]: matriz([74, 42, 92, 10, 76, 43])

Fuera[]: matriz([[92, 9, 99],

[73, 36, 93]])

Machine Translated by Google

Consejo: observe cómo el parámetro de tamaño para la tercera línea se especificó mediante una tupla.
Así es como se crea una matriz de números enteros aleatorios usando randint.

Ejemplo 59 : Ilustración de randint().

Creemos un programa divertido de tirada de dados usando el método randint(). Permitiríamos dos
dados y la función devolverá una salida basada en los valores aleatorios generados en la tirada.

En []: # creando un juego de tirada de dados con randint()

# Definiendo la función def

roll_dice():

""" Esta función muestra un

valor de la tirada de dados cuando se llama"""

dice1 = np.random.randint(1,7) # Esto permite que 6 sea inclusivo

dado2 = np.random.randint(1,7)

# Condición de visualización.

si dado1 == dado2:

print('Tira: ',dado1,'&',dado2,'\ndodobles!')

si dado1 == 1:

print('¡ojos de serpiente!\n')

demás:

print('Tira: ',dado1,'&',dado2)

En []: # Llamando a la función

tirar el dado()

Afuera[]: Rollo: 1 y 1

¡dobles!

ojos de serpiente!

Sugerencia: piense en un programa divertido y útil para ilustrar el uso de estos generadores de números
aleatorios, y escribir dichos programas mejorará sus posibilidades de comprensión. Además, una
revisión rápida de las estadísticas, especialmente las medidas de tendencia central y dispersión/
extensión, será útil en su viaje hacia la ciencia de datos.
Machine Translated by Google

Manipulación de matrices

Ahora que hemos aprendido cómo declarar matrices, continuaremos con algunos métodos para
modificar estas matrices. Primero, consideraremos el método reshape (), que se utiliza para
cambiar las dimensiones de una matriz.

Ejemplo 60 : uso del método reshape().

Declaremos algunas matrices y llamemos al método de remodelación para cambiar sus

dimensiones.
En []: frecuencia = np.arange(10);valores = np.random.randn(10)

frecuencia; valores

Fuera[]: matriz([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Fuera[]: matriz([ 1.33534821, 1.73863505, 0.1982571, ­0.47513784, 1.80118596, ­1.73710743, ­0.24994721,

1.41695744, ­0.28384007, 0.5844606 5])

Usando el método de remodelación, haríamos que 'freq' y 'values' fueran bidimensionales.

En []: np.reshape(frecuencia,(5,2))

Fuera[]: matriz([[0, 1],

[2, 3],

[4, 5],

[6, 7],

[8, 9]])

En []: np.reshape(valores,(2,5))

Fuera[]: matriz([[ 1.33534821, 1.73863505, 0.1982571, ­0.47513784, 1.80118596],

[­1.73710743, ­0.24994721, 1.41695744, ­0.28384007, 0.58446065]])

Aunque la matriz de valores todavía se ve similar después de remodelarla, observe los dos
corchetes que indican que se ha cambiado a una matriz. El método de remodelación resulta útil
cuando necesitamos realizar operaciones con matrices y nuestras matrices son inconsistentes
en dimensiones. También es importante asegurarse de que el nuevo parámetro de tamaño
pasado al método de remodelación no difiera del número de elementos de la matriz original. La
idea es simple: al llamar al método de remodelación, el producto
Machine Translated by Google

de los parámetros de tamaño debe ser igual al número de elementos de la matriz original.

Como se ve en el Ejemplo 60, el parámetro de tamaño pasado como una tupla a los métodos
de remodelación da un valor de 10 cuando se multiplica, y este es también el número de
elementos en 'freq' y 'values' respectivamente.

Hay ocasiones en las que es posible que necesitemos encontrar los valores máximos y
mínimos dentro de una matriz (o datos del mundo real) y posiblemente el índice de dichos
valores máximos o mínimos. Para obtener esta información, podemos utilizar los
métodos .max( ), .min( ), .argmax( ) y .argmin( ) respectivamente.

Ejemplo 61:

Encontremos los valores máximo y mínimo en la matriz de 'valores', junto con el índice del
mínimo y máximo dentro de la matriz.
En []: A = valores.max();B = valores.min();

C = valores.argmax()+1; D = valores.argmin()+1

print('Valor máximo: {}\nValor mínimo: {}\

\nEl artículo {} es el valor máximo, mientras que el artículo {}\

es el valor mínimo'.format(A,B,C,D))

Producción
Valor máximo: 1.8011859577930067

Valor mínimo: ­1.7371074259180737

El ítem 5 es el valor máximo, mientras que el ítem 6 es el valor mínimo

Algunas cosas a tener en cuenta en el código anterior: Las variables C&D, que definen la
posición de los valores máximo y mínimo, se evalúan como se muestra [sumando 1 al índice
de los valores máximo y mínimo obtenidos mediante argmax () y argmin () ], porque la
indexación de Python comienza en cero. Python indexaría el valor máximo en 4 y el mínimo
en 5, que no son las posiciones reales de estos elementos dentro de la matriz (¡es menos
probable que comiences a contar elementos en una lista desde cero! A menos que seas
Python, por supuesto).

Se puede hacer otra observación en el código. La declaración impresa se divide en algunas

líneas usando Enter. Para permitir que Python sepa que la siguiente línea de código es una
continuación, se utiliza la barra invertida '\'. Otra forma sería utilizar tres comillas para una
cadena de varias líneas.
Machine Translated by Google

Indexación y selección de matrices.

La indexación de matrices es muy similar a la indexación de listas con las mismas

técnicas de selección y división de elementos (usando corchetes). Los métodos son aún
más similares cuando la matriz es un vector.

Ejemplo 62:
En []: # Indexación de una matriz vectorial (valores)

valores

valores[0] # tomando el primer elemento

valores[­1] # tomando el último elemento

valores[1:3] # capturando el segundo y tercer elemento

valores[3:8] # elemento 4 a 8

Fuera[]: matriz([ 1.33534821, 1.73863505, 0.1982571, ­0.47513784, 1.80118596, ­1.73710743, ­0.24994721,

1.41695744, ­0.28384007, 0.5844606 5])

Fuera[]: 1.3353482110285562

Fuera[]: 0,5844606470172699

Fuera[]: matriz([1.73863505, 0.1982571])

Fuera[]: matriz([­0.47513784, 1.80118596, ­1.73710743, ­0.24994721, 1.41695744])

La principal diferencia entre matrices y listas está en la propiedad de transmisión de las

matrices. Cuando una porción de una lista se asigna a otra variable, cualquier cambio en
esa nueva variable no afecta la lista original. Esto se ve en el siguiente ejemplo:

En []: num_list = lista(rango(11)) # lista del 0 al 10

lista_núm # lista de visualización

list_slice = num_list[:4] # primeros 4 elementos

lista_rebanada # mostrar segmento

list_slice[:] = [5,7,9,3] # Reasignación de

elementos

valores # mostrar
actualizados de list_slice
Machine Translated by Google

# comprobando cambios print('

¡La lista cambió!') if list_slice == num_list[:4]\ else print(' no hay cambios en

la lista original')

Fuera[]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Fuera[]: [0, 1, 2, 3]

Fuera[]: [5, 7, 9, 3]

no hay cambios en la lista original

Sin embargo, para las matrices, un cambio en la porción de una matriz también se actualiza o
transmite a la matriz original, cambiando así sus valores.
En []: # Comprobando la función de transmisión de matrices

num_array = np.arange(11) # matriz del 0 al 10

número_matriz # matriz de visualización

array_slice = num_array[:4] # primeros 4 elementos

corte_matriz # mostrar segmento

array_slice[:] = [5,7,9,3] # Reasignación de

elementos

valores # mostrar
actualizados de array_slice

número_matriz

Fuera[]: matriz([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

Fuera[]: matriz([0, 1, 2, 3])

Fuera[]: matriz([5, 7, 9, 3])

Machine Translated by Google

Fuera[]: matriz([ 5, 7, 9, 3, 4, 5, 6, 7, 8, 9, 10])

Esto sucede porque Python intenta ahorrar la asignación de memoria permitiendo que las porciones
de una matriz sean como accesos directos o enlaces a la matriz real. De esta manera no es
necesario asignarle una ubicación de memoria separada. Esto es especialmente ingenioso en el
caso de matrices grandes cuyas porciones también pueden ocupar una cantidad significativa de memoria.
Sin embargo, para ocupar una porción de una matriz sin transmisión, puede crear una 'porción de
una copia' de la matriz. Se llama al método array.copy() para crear una copia de la matriz original.

En []: # Aquí hay una asignación de matriz sin transmisión

num_array # Matriz del último ejemplo

# copia los primeros 4 elementos de la copia de la matriz

array_slice = num_array.copia()[:4]

# mostrar
matriz_slice_array

array_slice[:] = 10 # re­
asignar matriz

valores # mostrar
actualizados de array_slice

num_array # comprobación
lista original

Fuera[]: matriz([ 5, 7, 9, 3, 4, 5, 6, 7, 8, 9, 10])

Fuera[]: matriz([5, 7, 9, 3])

Fuera[]: matriz([10, 10, 10, 10])

Fuera[]: matriz([ 5, 7, 9, 3, 4, 5, 6, 7, 8, 9, 10])

Observe que la matriz original permanece sin cambios.

Para matrices o matrices bidimensionales, funcionan los mismos métodos de indexación y división.
Sin embargo, siempre es fácil considerar la primera dimensión como las filas y la otra como las
columnas. Para seleccionar cualquier elemento o segmento de elementos, se especifica el índice
de las filas y columnas. Ilustremos esto con algunos ejemplos:
Machine Translated by Google

Ejemplo 63 : Tomar elementos de una matriz

Hay dos métodos para tomar elementos de una matriz: nombre_matriz[fila] [col] o
nombre_matriz[fila,col] .
En []: # Creando la matriz

matriz = np.array(([5,10,15],[20,25,30],[35,40,45]))

matriz #display matriz

matriz[1] # Agarrando la segunda fila

matriz[2][0] # Agarrando 35

matriz[0:2] # Tomando las primeras 2 filas

matriz[2,2] # Tomando 45

Fuera[]: matriz([[ 5, 10, 15],

[20, 25, 30],

[35, 40, 45]])

Fuera[]: matriz([20, 25, 30])

Fuera[]: 35

Fuera[]: matriz([[ 5, 10, 15],

[20, 25, 30]])

Fuera[]: 45

Consejo: Se recomienda utilizar el método nombre_matriz[fila,col], ya que ahorra escritura y es más

compacto. Esta será la convención para el resto de esta sección.

Para capturar columnas, especificamos una porción de la fila y la columna. Intentemos

tomar la segunda columna de la matriz y asignarla a una variable column_slice.
En []: # Tomando la segunda columna

column_slice = matriz[:,1:2] # Asignación a variable

segmento_columna

Fuera[]: matriz([[10],
Machine Translated by Google

[25],

[40]])

Consideremos lo que pasó aquí. Para tomar el segmento de columna, primero especificamos
la fila antes de la coma. Dado que nuestra columna contiene elementos en todas las filas,
'
Necesitamos que todas las filas se incluyan en nuestra selección, de ahí el signo: 'para todos'.
'
,
Alternativamente, podríamos usar '0 : que podría ser más fácil de entender. Después
Al seleccionar la fila, luego elegimos la columna especificando un segmento desde '1:2 ' que le ,
indica a Python que tome desde el segundo elemento hasta (pero sin incluir) el
tercer elemento. Recuerde, la indexación de Python comienza desde cero.

Ejercicio: intente crear una matriz más grande y utilice estas técnicas de indexación para capturar
ciertos elementos de la matriz. Por ejemplo, aquí hay una matriz más grande:

En []: #5 10 Matriz de números pares entre 0 y 100.

matriz_grande = np.arange(0,100,2).reshape(5,10)

matriz_grande # mostrar

Fuera[]: matriz([[ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18],

[20, 22, 24, 26, 28, 30, 32, 34, 36, 38],

[40, 42, 44, 46, 48, 50, 52, 54, 56, 58],

[60, 62, 64, 66, 68, 70, 72, 74, 76, 78],

[80, 82, 84, 86, 88, 90, 92, 94, 96, 98]])

Consejo: intente tomar elementos y filas individuales de matrices aleatorias que cree.
Después de familiarizarse con esto, intente seleccionar columnas. El punto es intentarlo como
tantas combinaciones como sea posible para que se familiarice con el enfoque. Si el
Las notaciones de corte e indexación son confusas, intente volver a visitar la sección debajo de la lista.
o corte e indexación de cadenas.

Haga clic en este enlace para volver a visitar los ejemplos de corte: Indexación de listas

Selección condicional

Considere un caso en el que necesitamos extraer ciertos valores de una matriz que cumplan
un criterio booleano. NumPy ofrece una manera conveniente de hacer esto sin
tener que utilizar bucles.

Ejemplo 64: uso de selección condicional

Machine Translated by Google

Considere esta matriz de números impares entre 0 y 20. Suponiendo que necesitamos tomar
elementos superiores a 11. Primero tenemos que crear la matriz condicional que seleccione esto:

En []: odd_array = np.arange(1,20,2) # Vector de

números impares

matriz_impar # Mostrar vector

matriz_bool = matriz_impar >

11 # matriz condicional booleana

matriz_bool

Fuera[]: matriz([ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19])

Fuera[]: matriz([Falso, Falso, Falso, Falso, Falso, Falso, Verdadero, Verdadero, Verdadero, Verdadero])

Observe cómo bool_array se evalúa como Verdadero en todos los casos en los que los elementos de
odd_array cumplen con el criterio booleano.

La matriz booleana en sí misma no suele ser tan útil. Para devolver los valores que necesitamos,
pasaremos Boolean_array a la matriz original para obtener nuestros resultados.
En []: útil_Array = odd_array[bool_array] # Los valores que queremos

matriz_útil

Fuera[]: matriz([13, 15, 17, 19])

Ahora bien, así es como se capturan elementos mediante la selección condicional. Sin embargo,
existe una forma más compacta de hacerlo. Es la misma idea, pero reduce la escritura.

En lugar de declarar primero una matriz_booleana para contener nuestros valores de verdad,
simplemente pasamos la condición a la matriz misma, como hicimos con la matriz_útil.
En []: # Este código es más compacto

compact = odd_array[odd_array>11] # Una línea

compacto

Fuera[]: matriz([13, 15, 17, 19])

¿Ves cómo logramos el mismo resultado con solo dos líneas? Se recomienda utilizar este segundo
método, ya que ahorra tiempo y recursos de codificación. El primer método ayuda a explicar cómo
funciona todo. Sin embargo, usaríamos el segundo método para todos los demás casos de este libro.
Machine Translated by Google

Ejercicio: La selección condicional funciona en todos los arreglos (tanto vectores como matrices). Cree

una matriz de dos 3 3 de elementos mayor que 80 a partir de la 'matriz_grande' proporcionada en el

último ejercicio.

Sugerencia: use el método de remodelación para convertir la matriz resultante en una 3

matriz 3.

Operaciones de matriz numérica

Finalmente, exploraremos operaciones aritméticas básicas con matrices NumPy.

Estas operaciones no son diferentes a las de las listas de Python enteras o flotantes.

Matriz – Operaciones de matriz

En NumPy, las matrices pueden operar entre sí utilizando varios operadores aritméticos. Cosas como
la suma de dos matrices, división, etc.

Ejemplo 65:
En []: # Matriz ­ Operaciones de matriz

# Declarando dos matrices de 10 elementos

Array1 = np.arange(10).reshape(2,5)

Array2 = np.random.randn(10).reshape(2,5)

Matriz1;Matriz2 # Mostrar las matrices

# Suma

suma_matriz = Matriz1 + Matriz2

suma_matriz # mostrar matriz de resultados

#Sustracción

matriz_menos = Matriz1 ­ Matriz2

matriz_menos # Mostrar matriz

# Multiplicación

matriz_producto = Matriz1 * Matriz2

matriz_producto # Espectáculo
Machine Translated by Google

# División

matriz_divide = Matriz1 / Matriz2

matriz_divide # Espectáculo

Fuera[]: matriz([[0, 1, 2, 3, 4],

[5, 6, 7, 8, 9]])

matriz ([[ 2.09122638, 0.45323217, ­0.50086442, 1.00633093, 1.24838264], [ 1.64954711, ­0.93396737,

1.05965475, 0.78422255, ­1.8459550 5]])

matriz ([[2.09122638, 1.45323217, 1.49913558, 4.00633093, 5.24838264], [6.64954711, 5.06603263, 8.05965475,

8.78422255, 7.15404495] ])

matriz ([[­2.09122638, 0.54676783, 2.50086442, 1.99366907, 2.75161736], [3.35045289, 6.93396737,

5.94034525, 7.21577745, 10.845955 05]])

matriz ([[ 0. , 0,45323217, ­1,00172885, 3,01899278, 4,99353055],

[ 8.24773555, ­5.60380425, 7.41758328, 6.27378038, ­16.61359546]])

matriz([[ 0. , 2.20637474, ­3.99309655, 2.9811267 , 3.20414581], [ 3.03113501, ­6.42420727,

6.60592516, 10.20118591, ­4.875525 ]])

Cada una de las operaciones aritméticas realizadas son por elementos. Sin embargo, las operaciones
de la división requieren un cuidado especial. En Python, la mayoría de los errores aritméticos en el
código generan un error de tiempo de ejecución, lo que ayuda en la depuración. Para NumPy, sin
embargo, el código podría ejecutarse con una advertencia.

Matriz: operaciones escalares

Además, NumPy admite operaciones escalares con matrices. Un escalar en este contexto es solo
un valor numérico único de tipo entero o flotante. Las operaciones escalares de matrices también
son por elementos, en virtud de la función de transmisión de las matrices NumPy.

Ejemplo 66:
En []: #Scalar­ Operaciones de matriz

new_array = np.arange(0,11) # Matriz de valores del 0 al 10

imprimir('Nueva_matriz')

nueva_matriz # Espectáculo
Machine Translated by Google

Sc = 100 # Valor escalar

# hagamos una matriz con un rango de 100 ­ 110 (usando +) add_array = new_array +

Sc # Agregando 100 a cada elemento

imprimir('\nAgregar_matriz')

agregar_matriz # Espectáculo

# Hagamos una matriz de cientos (usando ­)

centurión = add_array ­ new_array print('\nCenturión')

centurión # Espectáculo

# Hagamos algunas multiplicaciones (usando *)

múltiplex = nueva_matriz * 100

imprimir('\nMultiplex')

multicine # Espectáculo

# división [cuídate], generemos deliberadamente

# un error. Haremos una división por cero.

err_vec = nueva_matriz / nueva_matriz

imprimir('\nError_vec')

err_vec # Espectáculo

Nueva_matriz

Fuera[]: matriz([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

Agregar_matriz

Fuera[]: matriz([100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110])

centurión

Fuera[]: matriz([100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100])
Machine Translated by Google

Multicine

Fuera[]: matriz([ 0, 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000])

Error_vec

C:\Users\Oguntuase\Anaconda3\lib\site­
paquetes\ipykernel_launcher.py:27: RuntimeWarning: se encontró un valor no válido en
true_divide

matriz([nan, 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

¿Notas el error de tiempo de ejecución generado? Esta división por el valor cero fue causada por la
división del primer elemento de new_arra y por sí mismo, es decir, 0/ 0. Esto. daría un
error de división por cero en un entorno normal de Python y no ejecuta el código.
NumPy, sin embargo, ejecutó el código e indicó la división por cero en Error_ve
c matriz como tipo 'nan ' (no es un número). Esto también se aplica a los valores que evalúan
hasta el infinito, que estaría representado por el valor '+/­ inf ' (pruebe 1/ 0 usando
Operación NumPy array­scalar o array­array).

Consejo: tenga siempre cuidado al utilizar la división para evitar errores de tiempo de ejecución que
Más tarde podría alterar su código.

Funciones de matriz universal

Estas son algunas funciones integradas diseñadas para operar en forma de elementos.
en matrices NumPy. Incluyen matemáticas, comparación, trigonométricas,
Operaciones booleanas, etc. Se llaman usando np.function_name(array)
método.

Ejemplo 67 : algunas funciones de Universal Array (U­Func)

En []: # Usando U­Funcs

U_add = np.add(new_array,Sc) # suma

U_añadir # Espectáculo

U_sub = np.subtract(agregar_matriz,nueva_matriz)

U_sub # Espectáculo
Machine Translated by Google

U_log = np.log(new_array) # Registro natural

U_log # Espectáculo

sinusoide = np.sin(new_array) # Onda sinusoidal

sinusoide # Espectáculo

# Alternativamente, podemos usar el método .

nueva_matriz.max() # encontrar máximo

np.max(nueva_matriz) # la misma cosa

Fuera[]: matriz([100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110])

Fuera[]: matriz([100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100])

C:\Users\Oguntuase\Anaconda3\lib\site­
packages\ipykernel_launcher.py:8: RuntimeWarning: división por cero encontrada en el registro

Fuera[]: ­inf, 0. , 0,69314718, 1,09861229, 1,38629436, 1,60943791, 1,79175947,

matriz([ 1.94591015, 2.07944154, 2.19722458, 2.30258509])

Fuera[]: matriz([ 0. , 0,84147098, 0,90929743, 0,14112001, ­0,7568025, 0,98935825, ,

­0.95892427, ­0.2794155 , 0.6569866 0,41211849, ­0,54402111])

Fuera[]: 10

Fuera[]: 10

Todavía hay muchas más funciones disponibles y se puede encontrar una referencia completa
en la documentación de NumPy para funciones universales aquí:
https://docs.scipy.org/doc/numpy/reference/ufuncs.html

Ahora que hemos explorado NumPy para crear matrices, consideraríamos la

Marco de Pandas para manipular estas matrices y organizarlas en datos
marcos.

pandas

Esta es una biblioteca de código abierto que amplía las capacidades de NumPy. Es compatible
limpieza y preparación de datos, con capacidades de análisis rápido. es más como
Marco de Microsoft Excel, pero con Python. A diferencia de NumPy, tiene su propio
Machine Translated by Google

Funciones de visualización integradas y puede trabajar con datos de una variedad de fuentes.
Es uno de los paquetes más versátiles para ciencia de datos con Python y exploraremos cómo usarlo de
manera efectiva.

Para usar pandas, asegúrese de que actualmente sea parte de sus paquetes instalados verificando con el
método conda list. Si no está instalado, puede instalarlo usando el comando conda install panda s;
necesitas una conexión a Internet para esto.

Ahora que Pandas está disponible en tu PC, puedes empezar a trabajar con el paquete. Primero,
comenzamos con la serie Pandas.

Serie
Esta es una extensión de la matriz NumPy. Tiene muchas similitudes, pero con una diferencia en la
capacidad de indexación. Las matrices NumPy solo se indexan mediante notaciones numéricas
correspondientes a las filas y columnas deseadas a las que se accede. Para la serie Pandas, los ejes
tienen etiquetas que pueden usarse para indexar sus elementos.
Además, mientras que las matrices NumPy, como las listas de Python, se usan esencialmente para
contener datos numéricos, las series Pandas se usan para contener cualquier forma de datos/objetos de Python.

Ejemplo 68 : Ilustremos cómo crear y utilizar la serie Pandas.

Primero, tenemos que importar el paquete Pandas a nuestro espacio de trabajo. Usaremos el nombre de
variable pd para Pandas, tal como usamos np para NumPy en la sección anterior.

En []: importar numpy como np #importando numpy para su uso

importar pandas como pd # importando el paquete Pandas

También importamos el paquete numpy porque este ejemplo involucra una matriz numpy.

En []: # objetos de Python para usar

etiquetas = ['Primero','Segundo','Tercero'] #
lista de cadenas

valores = [10,20,30] # lista numérica

matriz = np.arange(10,31,10) # matriz numerosa

dico = {'Primero':10,'Segundo':20,'Tercero':30}
# Diccionario de Python

# crear varias series

Machine Translated by Google

c = pd.Series(valores)

print('Serie predeterminada')

A #espectáculo

B = pd.Series(valores,etiquetas)

print('\nLista numérica y etiqueta de Python')

B #espectáculo

C = pd.Series(array,labels)

print('\nUsando matrices y etiquetas de Python')

C #espectáculo

D = pd.Series(dico)

print('\nPasando un diccionario')

D #espectáculo

Serie predeterminada

Fuera[]: 0 10

1 20

2 30

tipo de letra: int64

Lista numérica y etiqueta de Python

Afuera[]: primeros 10

Segundo 20

Tercero 30

tipo de letra: int64

Usando matrices y etiquetas de Python

Afuera[]: primeros 10

Segundo 20

Tercero 30
Machine Translated by Google

tipo de letra: int32

Pasando un diccionario

Fuera[]: Primeros 10

Segundo 20

Tercero 30

tipo de letra: int64

Acabamos de explorar algunas formas de crear una serie de Pandas utilizando una matriz numpy,
una lista de Python y un diccionario. ¿Observas cómo las etiquetas corresponden a los valores?
Además, los tipos son diferentes. Dado que los datos son numéricos y de tipo entero, Python
asigna el tipo apropiado de memoria entera a los datos.
La creación de series a partir de matrices NumPy devuelve el tamaño entero más pequeño (int
32). La diferencia entre enteros sin signo de 32 bits y 64 bits es la asignación de memoria
correspondiente. Obviamente, 32 bits requieren menos memoria (4 bytes, ya que 8 bits forman un
byte), y 64 bits requerirían el doble (8 bytes). Sin embargo, los números enteros de 32 bits se
procesan más rápido, pero tienen una capacidad limitada para contener valores, en comparación
con los de 64 bits.

La serie Pandas también admite la asignación de cualquier tipo de datos u objeto como puntos de
datos.
En []: pd.Series(etiquetas,valores)

Fuera[]: 10 Primero

20 segundos

30 Tercero

tipo de objeto: objeto

Aquí, los elementos de cadena de la lista de etiquetas son ahora los puntos de datos. Además,
observe que el tipo d no es "objeto".

Este tipo de versatilidad en la operación y almacenamiento de artículos es lo que hace que la serie
pandas sea muy robusta. Las series de Pandas están indexadas mediante etiquetas. Esto se
ilustra en los siguientes ejemplos:

Ejemplo 69:
En []: # serie de países de la Segunda Guerra Mundial
Machine Translated by Google

pool1 = pd.Series([1,2,3,4],['EE.UU.','Gran Bretaña','Francia','Alemania'])

pool1 #show

print('tomando el primer elemento')

pool1['USA'] # índice de primera etiqueta

Fuera[]: EE.UU. 1

Gran Bretaña 2

Francia 3

Alemania 4

tipo de letra: int64

agarrando el primer elemento

Fuera[]: 1

Como se muestra en el código anterior, para capturar un elemento de serie, use el mismo
enfoque que la indexación de matriz numpy, pero pasando la etiqueta correspondiente a ese
punto de datos. El tipo de datos de la etiqueta también es importante; observe que la etiqueta
'USA' se pasó como una cadena para capturar el punto de datos '1'. Si la etiqueta es
numérica, entonces la indexación sería similar a la de una matriz numpy. Considere la
indexación numérica en el siguiente ejemplo:
En []: pool2 = pd.Series(['EE.UU.','Gran Bretaña','Francia','Alemania'],[1,2,3,4])

pool2 #show

print('tomando el primer elemento')

pool2[1] #indexación numérica

Fuera[]: 1 EE.UU.

2 Gran Bretaña

3 Francia

4 Alemania

tipo de objeto: objeto

agarrando el primer elemento

Fuera[]: 'EE.UU.'

Consejo: puede conocer fácilmente los datos que contiene una serie a través del tipo d.
Observe cómo los tipos de grupo1 y grupo2 son diferentes, aunque ambos se crearon a partir
de las mismas listas. La diferencia es que pool2 contiene cadenas como puntos de datos,
Machine Translated by Google

mientras que pool1 contiene números enteros (int64).

Las series Panda se pueden sumar. Funciona mejor si las dos series tienen etiquetas y puntos de datos
similares.

Ejemplo 70 : Agregar series

Creemos una tercera serie 'grupo 3'. Esta es una serie similar a pool1, pero Gran Bretaña ha sido
reemplazada por 'URSS' y un valor de punto de datos correspondiente de 5.

En []: pool3 = pd.Series([1,5,3,4],['EE.UU.','URSS','Francia', 'Alemania'])

piscina3

Fuera[]: EE.UU. 1

URSS 5

Francia 3

Alemania 4

tipo de letra: int64

Ahora agregando series:

En []: # Demostrando la suma de series

piscina_doble = piscina1 + piscina1

print('Piscina Doble')

piscina_doble

piscina_mixta = piscina1 + piscina3

print('\nGrupo mixto')

piscina_mixta

piscina_divertida = piscina1 + piscina2

Machine Translated by Google

print('\nPiscina divertida')

piscina_divertida

Piscina Doble

Fuera[]: EE.UU. 2

Gran Bretaña 4

Francia 6

Alemania 8

tipo de letra: int64

Piscina Mixta

Fuera[]: Gran Bretaña NaN

Francia 6.0

Alemania 8,0

Estados Unidos 2.0

URSS NaN

tipo de letra: float64

piscina divertida

C:\Users\Oguntuase\Anaconda3\lib\site­packages\pandas\core\indexes\base.py:3772: RuntimeWarning: '<' no se

admite entre instancias de 'str' e 'int', el orden de clasificación no está definido para objetos incomparables

devolver this.join(otro, cómo=cómo, return_indexers=return_indexers)

Fuera[]: EE.UU. NaN

Gran Bretaña NaN

Francia NaN

Alemania NaN

1 Yaya

2 Yaya

3 Yaya

4 Yaya

tipo de objeto: objeto

Machine Translated by Google

Al agregar series, el resultado es el incremento en los valores de los puntos de datos de etiquetas
(o índices) similares. Se devuelve un 'NaN' en los casos en que las etiquetas no coinciden.

Observe la diferencia entre Mixed_pool y Funny_pool: en un grupo mixto, algunas etiquetas

coinciden y sus valores se suman (debido a la operación de suma). Para Funny_pool, ninguna
etiqueta coincide y los puntos de datos son de diferentes tipos. Se devuelve un mensaje de error y
el resultado es una concatenación vertical de las dos series con puntos de datos 'NaN'.

Consejo: siempre que dos series contengan las mismas etiquetas y puntos de datos del mismo
tipo, se pueden realizar operaciones básicas de matriz como suma, resta, etc. El orden de las
etiquetas no importa, los valores se cambiarán según el operador que se utilice. Para comprender
esto completamente, intente ejecutar variaciones de los ejemplos dados anteriormente.

marcos de datos

Un marco de datos de Pandas es solo una colección ordenada de series de Pandas con un índice
común/compartido. En su forma básica, un marco de datos se parece más a una hoja de Excel con
filas, columnas, etiquetas y encabezados. Para crear un marco de datos, se utiliza la siguiente
sintaxis:
pd.DataFrame(datos=Ninguno, índice=Ninguno, columnas=Ninguno, dtype=Ninguno, copia=Falso)

Normalmente, la entrada de datos es una matriz de valores (de cualquier tipo de datos). Los
parámetros de índice y columna suelen ser listas/vectores de tipo numérico o de cadena.

Si se pasa una serie de Pandas a un objeto de marco de datos, el índice se convierte

automáticamente en columnas y los puntos de datos se asignan en consecuencia.

Ejemplo 71 : creación de un marco de datos

En []: df = pd.DataFrame([pool1]) # pasando una serie

df # espectáculo

# dos series

índice = 'Primera Guerra Mundial Segunda Guerra Mundial'.split()

nuevo_df = pd.DataFrame([grupo1,grupo3],índice) nuevo_df

# espectáculo
Machine Translated by Google

Producción:

EE.UU Bretaña Francia Alemania

0 1 2 3 4

EE.UU Bretaña Francia Alemania

Primera Guerra Mundial 1 2 3 4

segunda Guerra Mundial 5 1 3 4

Hemos creado dos marcos de datos de las series del grupo 1 y del grupo 3 que creamos.
más temprano. Observe cómo el primer marco de datos asigna las etiquetas de la serie como columna.
encabezados, y como no se asignó ningún índice, se estableció un valor de '0' en ese índice, es decir
encabezado de fila.

Para el segundo marco de datos, las etiquetas de las filas se especificaron pasando una lista de
cadenas ['Primera Guerra Mundial', 'Segunda Guerra Mundial'].

Consejo: El método de cadena .split( ) es una forma rápida de crear listas de cadenas. Él
funciona dividiendo una cadena en los caracteres que la componen, dependiendo del
delimitador pasado al método de cadena.

Por ejemplo, dividamos este correo electrónico '[email protected]' en una lista

que contiene el nombre de usuario y el nombre de dominio.

En []: # Ilustrando el método split()

correo electrónico = '[email protected]'

string_vec = correo electrónico.split('@')

string_vec # mostrar

A = cadena_vec[0]; B = string_vec[1] # Extrayendo valores

print('Nombre de usuario:',A,'\nNombre de dominio:',B)

Fuera[]: ['pythonguy', 'gmail.com']

Nombre de usuario: pythonguy

Nombre de dominio: gmail.com

Para crear un marco de datos con una matriz, podemos usar el siguiente método:
Machine Translated by Google

# Creando un marco de datos con una matriz

Matriz = np.arange(1,21).reshape(5,4) # matriz numerosa

row_labels = 'ABCD E'.split()

col_labels = 'impar1 par1 impar2 par2'.split()

Arr_df = pd.DataFrame(Array,row_labels,col_labels)

Arr_df

Producción:

impar1 incluso1 impar2 incluso2

A 1 2 3 4

B 5 6 7 8

C 9 10 11 12

D 13 14 15 dieciséis

mi 17 18 19 20

Observe que esto no es diferente a cómo creamos hojas de cálculo en Excel. Intenta jugar
alrededor de la creación de marcos de datos.

Ejercicio: cree un marco de datos a partir de una matriz de 5 4 distribuida uniformemente

valores aleatorios. Incluya los nombres de fila y columna de su elección usando .split()
método.

Sugerencia: use la función rand para generar sus valores y use el método de remodelación
para formar una matriz.

Ahora que podemos crear marcos de datos cómodamente, aprenderemos cómo

indexar y tomar elementos de ellos.

Consejo: aspectos a tener en cuenta sobre los marcos de datos.

Son una colección de series (más bien una lista con series de Pandas).
como sus elementos).

Son similares a matrices numpy, es decir, se parecen más a matrices de n metro

dimensiones, donde 'n' son las filas y 'm' son las

columnas.
Machine Translated by Google

Ejemplo 72 : Tomar elementos de un marco de datos.

Los elementos más fáciles de agarrar son las columnas. Esto se debe a que, por defecto, cada
El elemento de columna es una serie con los encabezados de fila como etiquetas. Podemos agarrarlos por
usando un método similar de la serie: indexar por nombre.

En []: # Tomar elementos del marco de datos

Arr_df['odd1'] # tomando la primera columna

Fuera[]: A 1

B5

C9

D 13

E 17

Nombre: impar1, tipo d: int32

Bastante fácil, ¿verdad? Observe cómo el resultado es como una serie de Pandas. puedes verificar
esto usando el comando type(Arr_df[ 'odd1' ] ).

Sin embargo, cuando se toma más de una columna, se devuelve un marco de datos (que
tiene sentido, ya que un marco de datos es una colección de al menos dos series). Agarrar
más de una columna, pase los nombres de las columnas a la indexación como una lista. Esto es
se muestra en el código de ejemplo siguiente:

En []: # Toma dos columnas

Arr_df[['odd1','even2']] # capturando la primera y la última columna

Producción:

impar1 incluso2

A 1 4

B 5 8

C 9 12

D 13 dieciséis

mi 17 20
Machine Translated by Google

Para seleccionar un elemento específico, utilice la notación de indexación entre corchetes

dobles que aprendimos en la indexación de matrices. Por ejemplo, seleccionemos el valor
15 de Arr_df.
En []: Arr_df['odd2']['D']
Fuera[]: 15

Puedes decidir dividir los pasos en dos, si te resulta más fácil. Sin embargo, se prefiere este
método ya que ahorra memoria de la asignación de variables. Para explicarlo, dividámoslo
en dos pasos.
En []: x = Arr_df['odd2']
X

Fuera[]: A 3
B7
C 11
D 15
E 19

Nombre: impar2, tipo d: int32

Observe que la primera operación devuelve una serie que contiene el elemento '15'. Esta
serie ahora se puede indexar para obtener 15 usando la etiqueta 'D'.
En []: x['D']
Fuera[]: 15

Si bien este enfoque funciona y es el preferido por los principiantes, un mejor enfoque es
familiarizarse con el primer método para ahorrar tiempo y recursos de codificación.

Para capturar filas, se utiliza un método de indexación diferente.

usar ya sea data_frame_name.loc['row_name' Puedes ] o
data_frame_name.iloc['row_index' ] .

Tomemos la fila E de Arr_d f .

En []: print("usando .loc['E']")
Arr_df.loc['E']

print('\nusando .iloc[4]')
Arr_df.iloc[4]
Machine Translated by Google

usando .loc['E']

Afuera[]:

impar1 17

incluso1 18

impar2 19

incluso2 20

Nombre: E, tipo d: int32

usando .iloc[4]

Afuera[]:

impar1 17

incluso1 18

impar2 19

incluso2 20

Nombre: E, tipo d: int32

¡Mira, el mismo resultado!

También puede utilizar el método de indexación de filas para seleccionar elementos individuales.

En []: Arr_df.loc['E']['even2']

#o

Arr_df.iloc[4]['even2']

Fuera[]: 20

Fuera[]: 20

Continuando, intentaremos crear nuevas columnas en un marco de datos y también eliminar una columna.

En []: # Agreguemos dos columnas de suma a Arr_df

Arr_df['Suma impar'] = Arr_df['odd1']+Arr_df['odd2']

Arr_df['suma par'] = Arr_df['par1']+Arr_df['par2']

Arr_df
Machine Translated by Google

Producción:
impar1 incluso1 impar2 incluso2 suma impar suma par

un 1 2 3 4 4 6

B5 6 7 8 12 14

C9 10 11 12 20 22

D 13 14 15 dieciséis 28 30

E 17 18 19 20 36 38

Observe cómo se declaran las nuevas columnas. Además, las operaciones aritméticas son
posible con cada elemento en el marco de datos, tal como lo hicimos con la serie.

Ejercicio: agregue una columna adicional a este marco de datos. Llámelo Suma Total, y
debe ser la suma de la suma impar y la suma par.

Para eliminar una columna de un marco de datos, utilizamos data_frame_name.drop()

método.

Eliminemos la inserción de una nueva columna y luego eliminémosla usando .drop()

método.

En []: Arr_df['desechable'] = np.zeros(5) # nuevo

columna

Arr_df #mostrar

Producción:
Extraño Incluso
impar1par1impar2par2 desechable
suma suma

A1 2 34 4 6 0.0

B5 6 78 12 14 0.0

C9 10 11 12 20 22 0.0

D13 14 15 16 28 30 0.0

E17 18 19 20 36 38 0.0
Machine Translated by Google

Para eliminar la columna no deseada:

En []: # para eliminar

Arr_df.drop('desechable',eje=1,inplace=True)
Arr_df

Producción:

Incluso
impar1 incluso1 impar2 incluso2 suma impar
suma

un 1 2 3 4 4 6

B5 6 7 8 12 14

C9 10 11 12 20 22

D 13 14 15 dieciséis 28 30

mi 17 18 19 20 36 38

Observe los argumentos 'axis=1' e 'inplace = True'. Estos son parámetros que
especifique la ubicación para realizar la caída, es decir, el eje (eje = 0 especifica la fila
operación), y la intención de transmitir la caída al marco de datos original,
respectivamente. Si 'inplace= False', el marco de datos aún contendrá el elemento eliminado
columna.

Consejo: El método 'inplace = False' se utiliza para asignar una matriz a otra
variable sin incluir ciertas columnas.

Selección condicional

De manera similar a cómo funciona la selección condicional con matrices NumPy, podemos seleccionar
elementos de un marco de datos que satisfacen un criterio booleano.

Se espera que esté familiarizado con este método, por lo tanto, se realizará en una sola
paso.

Ejemplo 72: tomemos secciones del marco de datos 'Arr_df' donde el valor es >
5.
Machine Translated by Google

En []: # Agarra elementos mayores a cinco

Arr_df[Arr_df>5]

Producción:

impar1 incluso1 impar2 incluso2 suma impar suma par

Un NaN Yaya Yaya Yaya Yaya 6

B NaN 6.0 7.0 8.0 12.0 14

C9.0 10.0 11.0 12.0 20.0 22

D 13.0 14.0 15.0 16.0 28.0 30

mi 17.0 18.0 19.0 20.0 36.0 38

Observe cómo las instancias de valores menores a 5 se representan con un 'NaN'.

Otra forma de utilizar este formato condicional es formatear según la columna.

especificaciones.

Puede eliminar filas enteras de datos especificando una condición booleana basada
de una sola columna. Suponiendo que queremos devolver el marco de datos Arr_df sin
la fila 'C'. Podemos especificar una condición para devolver valores donde los elementos de
la columna 'odd1' no es igual a '9' (ya que la fila C contiene 9 en la columna
'impar1').

En []: # eliminando la fila C hasta la primera columna

Arr_df[Arr_df['odd1']!= 9]

Producción:

impar1 incluso1 impar2 incluso2 suma impar suma par

un 1 2 3 4 4 6

B5 6 7 8 12 14

D 13 14 15 dieciséis 28 30

mi 17 18 19 20 36 38
Machine Translated by Google

Observe que la fila 'C' se ha filtrado. Esto se puede lograr a través de una inteligente
declaración condicional a través de cualquiera de las columnas.

En []: # hace lo mismo: eliminar la fila 'C'

# Arr_df[Arr_df['even2']!= 12]

En[]: # Eliminemos las filas D y E hasta 'even2'

Arr_df[Arr_df['even2']<= 12]

Producción

impar1 incluso1 impar2 incluso2 suma impar suma par

un 1 2 3 4 4 6

B5 6 7 8 12 14

C9 10 11 12 20 22

Ejercicio: elimine las filas C, D, E mediante la columna 'Suma par'. Además, prueba otros
operaciones que usted prefiera.

Para combinar declaraciones de selección condicional, podemos usar el método 'lógico y, es decir
&', y el 'lógico o, es decir |' para anidar múltiples condiciones. El 'y' normal
y los operadores 'o' no funcionarían en este caso ya que se utilizan para comparar
elementos individuales. Aquí compararemos una serie de elementos que evalúan
a verdadero o falso, y esos operadores genéricos encuentran tales operaciones ambiguas.

Ejemplo 73: Seleccionemos elementos que cumplan con el criterio de ser mayores que 1
en la primera columna y menos de 22 en la última columna. Recuerde, el 'y
declaración' sólo se evalúa como verdadera si ambas condiciones son verdaderas.

En []: Arr_df[(Arr_df['impar1']>1) & (Arr_df['Suma par']<22)]

Producción:

impar1 incluso1 impar2 incluso2 suma impar suma par

B5 6 7 8 12 14

Sólo los elementos de la fila 'B' cumplen este criterio y se devolvieron en los datos.
marco.
Machine Translated by Google

Este enfoque se puede ampliar para crear un marco de datos aún más poderoso.
filtros.

Datos perdidos

Hay casos en los que los datos que se importan o generan en pandas son
están incompletos o faltan puntos de datos. En tal caso, la solución probable es
eliminar dichos valores del conjunto de datos o completar nuevos valores basados en algunos
Técnicas de extrapolación estadística. Si bien no estaríamos explorando completamente
medidas estadísticas de extrapolación (puedes leer sobre eso en cualquier buen
libro de texto de estadística), estaríamos considerando el uso de .dropna() y
Métodos .fillna() para eliminar y completar puntos de datos faltantes, respectivamente.

Para ilustrar esto, crearemos un marco de datos para representar los datos importados con
valores faltantes y luego utilice estos dos métodos de preparación de datos.

Ejemplo 73: Otra forma de crear un marco de datos es mediante el uso de un diccionario.
Recuerde, un diccionario de Python es de alguna manera similar a una serie de Pandas en ese sentido.
tienen pares clave­valor, al igual que las series Pandas son pares etiqueta­valor (aunque
esta es una comparación simplista en aras de la conceptualización).

En []: # Primero, nuestro diccionario

dico = {'X':[1,2,np.nan],'Y':[4,np.nan,np.nan],'Z':[7,8,9]}

dico #mostrar

# pasar el diccionario a un marco de datos

etiquetas_fila = 'AB C'.split()

df = pd.DataFrame(dico,row_labels)

df #mostrar

Producción:

{'X': [1, 2, nan], 'Y': [4, nan, nan], 'Z': [7, 8, 9]}

X Y z

A 1.0 4.0 7

B 2.0 Yaya 8
Machine Translated by Google

C Yaya Yaya 9

Ahora, comencemos con el método .dropna(). Esto elimina cualquier valor "nulo" o
valores 'nan' en el marco de datos que se cancela, ya sea en columnas o en filas,
dependiendo de la especificación del eje y otros argumentos pasados al método. Él
tiene la siguiente sintaxis predeterminada:
df.dropna(eje=0, how='cualquiera', umbral=Ninguno, subconjunto=Ninguno, inplace=False)

El 'df' de arriba es el nombre del marco de datos. El eje predeterminado se establece en cero, lo que
Representa la operación por filas. Por lo tanto, de forma predeterminada, el método eliminará cualquier fila.
que contiene valores 'nan'.

Veamos qué sucede cuando llamamos a este método para nuestro marco de datos.
En []: # esto elimina 'nan' por filas

df.dropna()

Producción: X Y z

A 1.0 4.0 7

Observe que las filas B y C contienen al menos un valor 'nan'. Por lo tanto, fueron
remoto.

Probemos una operación por columnas especificando el eje = 1.

En []: # esto elimina 'nan' en columnas

df.dropna(eje=1)

Producción:
z

A 7

B 8

C 9
Machine Translated by Google

Como era de esperar, sólo se devolvió la columna 'Z'.

Ahora, en caso de que queramos establecer una condición para un número mínimo de 'no nan'
valores/puntos de datos reales necesarios para realizar el corte (o escapar del corte, dependiendo
Según su perspectiva), podemos usar el parámetro 'thresh' (abreviatura de umbral) para
especifique esto.

Digamos que queremos eliminar 'nan' por filas, pero solo queremos eliminar instancias
donde la fila tenía más de un valor de punto de datos real. Podemos configurar el
umbral a 2 como se ilustra en el siguiente código:
En []: # eliminar filas con menos de 2 valores reales

df.dropna(umbral = 2)

Producción:

X Y z

A 1.0 4.0 7

B 2.0 Yaya 8

Observe cómo hemos filtrado la fila C, ya que contiene solo un valor real.
'9'.

Ejercicio: filtrar columnas en el marco de datos 'df' que contengan menos de 2 columnas reales
puntos de datos

A continuación, usemos el método .fillna() para reemplazar los valores faltantes con nuestro
extrapolaciones.

Este método tiene la siguiente sintaxis:

df.fillna(valor=Ninguno, método=Ninguno, eje=Ninguno, inplace=False, límite=Ninguno,
abatido=Ninguno, **kwargs)

Consejo: Recordatorio, siempre puedes usar shift + tab b para verificar la documentación de
métodos y funciones para conocer su sintaxis.

Sigamos adelante y reemplacemos nuestros valores 'NaN' con un marcador 'x'. Podemos
especifique la 'X' como una cadena y pásela al parámetro 'valor' en .fillna() .
En []: # llenando NaN
Machine Translated by Google

df.fillna('X')

X Y z
Producción:

A 1 4 7

B 2 X 8

C X X 9

Si bien marcar los datos faltantes con una 'X' es divertido, a veces es más intuitivo
(a falta de un mejor enfoque estadístico), utilizar la media de la columna afectada
como reemplazo de los elementos faltantes.

Ejemplo 74 : Completar los datos faltantes.

Primero usemos el método de la media para llenar la columna 'X', luego basándonos en ese simple
paso, usaremos un bucle for para completar automáticamente los datos faltantes en el archivo
marco.

En []: # Reemplazar los valores faltantes con la media en la columna 'X'

df['X'].fillna(valor = df['X'].media())
Fuera[]: A 1.0
B2.0

C 1.5

Nombre: X, tipo d: float64

Observe que el valor del tercer elemento en la columna 'X' ha cambiado a 1,5. Este
es la media de esa columna. El código de una línea que logró esto podría haber
se ha dividido en varias líneas para una mejor comprensión. Esto es mostrado
abajo:

En []: # variables

xcol_var = df['X']

xcol_mean = xcol_var.mean() # o utilizar media(xcol_var)

# instrucción

xcol_var.fillna(valor = xcol_mean)
Machine Translated by Google

Fuera[]: A 1.0

B2.0

C 1.5

Nombre: X, tipo d: float64

Los mismos resultados, pero más codificación y más uso de memoria mediante asignación de variables.

Ahora, automaticemos todo el proceso.

En []: para i en 'XY Z'.split(): # bucle

df[i].fillna(valor = df[i].mean(),inplace=True)
df # espectáculo

X YZ

Un 1.0 4.0 7

B2.0 NaN8

C NaN NaN9

Producción:

X Y z

A 1.0 4.0 7

B 2.0 4.0 8

C 1.5 4.0 9

Nuevo marco de datos Marco de datos antiguo

Si bien la salida solo muestra el marco de datos de la izquierda, el marco de datos original
se pone aquí para comparar. Observe los nuevos valores que reemplazan a los NaN. Para el
columna 'Y', la media es 4,0, ya que ese es el único valor presente.

Esta es una operación pequeña que se puede ampliar para preparar y formatear archivos más grandes.
conjuntos de datos en Pandas.

Consejo: Se pueden explorar los demás argumentos del método .fillna(), incluido el
métodos de relleno: por ejemplo, relleno directo, que rellena el valor faltante con el
valor de fila/columna anterior basado en el valor del parámetro de límite, es decir, si el límite
Machine Translated by Google

= 1, llena la siguiente fila/columna con el valor de fila/columna anterior; también el

back­fill: que hace lo mismo que el relleno hacia adelante, pero hacia atrás.

Agrupar por

Este método Pandas, como su nombre indica, permite agrupar datos relacionados para
realizar operaciones combinadas/agregadas sobre ellos.

Ejemplo 75: Creación de un marco de datos de ventas de la tienda XYZ.

En []: # Información de ventas de la empresa XYZ

# Diccionario que contiene los datos necesarios

datos = {'Vendedor':'Sam Charlie Amy Vanessa Carl Sarah'.split(),

'Producto':'Hp Hp Apple Apple Dell Dell'.split(),

'Ventas':[200,120,340,124,243,350]}

print('Información de ventas XYZ\n________________') # imprimir información.

serie = lista (rango (1,7)) # nombres de filas del 1 al 6

df = pd.DataFrame(datos,serial) # construir marco de datos

df

Producción:

Información de ventas XYZ

_________________________________________________

Vendedor Producto Ventas

1 Sam CV 200

2 charlie CV 120

3 amy Manzana 340

4 vanessa Manzana 124

5 carlos Dell 243

6 sara Dell 350

Desde nuestro conjunto de datos, podemos observar algunos elementos comunes bajo el producto.
Machine Translated by Google

columna. Este es un ejemplo de un punto de entrada para el método agrupar por en una base de datos.
colocar. Podemos encontrar información sobre las ventas utilizando la agrupación de productos.

En []: # encontrar información de ventas por producto

print('Total de artículos vendidos: por producto')

df.groupby('Producto').sum()

Total de artículos vendidos: por producto

Ventas

Producto

Manzana 464

Dell 593

CV 320

Este es un ejemplo de una operación agregada que utiliza groupby. Otras funciones pueden
ser llamado para mostrar resultados interesantes también. Por ejemplo, .count() :

En []: df.groupby('Producto').count()

Producción:

Vendedor Ventas

Producto

Manzana 2 2

Dell 2 2

CV 2 2

Si bien la operación anterior no pudo devolver el campo 'Vendedor', ya que un

Una operación numérica como 'suma' no se puede realizar en una cadena, el método de conteo
devuelve las instancias de cada producto dentro de ambas categorías. A través de esta salida, nosotros
Se puede inferir fácilmente que la empresa XYZ asigna dos vendedores por producto, y
que cada uno de los vendedores realizó una venta de los productos. Sin embargo, a diferencia del
Machine Translated by Google

método de suma, este método de recuento no ofrece una visión más clara de las ventas.
Esta es la razón por la que se suelen recurrir a tantos métodos para explicar ciertos aspectos de la
datos. Un método muy útil para comprobar información múltiple a la vez es el
Método .describe().

En []: #Obteniendo mejor información usando describe ()

df.groupby('Producto').describe()

Producción:

Ventas

contar media estándar mín. 25 % 50 % 75 % máx.

Producto

manzana 2.0 232,0 152,735065124,0 178,00 232,0 286,00 340,0

Dell 2.0 296,5 75,660426 243,0 269,75 296,5 323,25 350,0

hp 2.0 160,0 56,568542 120,0 140,00 160,0 180,00 200,0

Ahora, esto es más informativo. Dice mucho sobre los datos de un vistazo. Individual
También se pueden seleccionar productos: df.groupby('Product').describe()['Nombre del producto, por ejemplo, 'Apple' ] .

Concatenar, unir y fusionar

Estos son métodos para combinar múltiples marcos de datos o conjuntos de datos en un solo
uno. Se diferencian en la sintaxis y logran combinaciones específicas de marcos de datos.
en función del resultado previsto.

La concatenación permite que los conjuntos de datos se "peguen" entre sí, ya sea por filas o por
columnas. Aquí, las dimensiones de los marcos de datos deben ser las mismas a lo largo del eje de
concatenación, es decir, la concatenación por filas requiere que los dos marcos de datos tengan
el mismo número de columnas y viceversa.

Ejemplo 76: creemos dos marcos de datos de ejemplo y usemos la función concatenar
método.
Machine Translated by Google

En []: # Definiendo un diccionario de valores

d1 = {'A':'A1 A2 A3'.split(),'B':'B1 B2 B3'.split(),

'C':'C1 C2 C3'.split()}

d2 = {'A':'A4 A5 A6'.split(),'B':'B4 B5 B6'.split(),

'C':'C4 C5 C6'.split()}

# Ahora los marcos de datos

df1 = pd.DataFrame(d1,índice= '1 2 3'.split())

df2 = pd.DataFrame(d2,index= '4 5 6'.split())

# concatenando

pd.concat([df1,df2]) # eje por filas = 0

pd.concat([df1,df2],axis=1,sort=True) # eje de columnas = 1

Afuera[]:

A B C

1 A1 B1 C1

2 A2 B2 C2

3 A3 B3 C3

4 A4 B4 C4

5 A5 B5 C5

6 A6 B6 C6

Afuera[]:

A B C A B C

1 A1 B1 C1 Yaya Yaya Yaya

2 A2 B2 C2 Yaya Yaya Yaya

3 A3 B3 C3 Yaya Yaya Yaya

Machine Translated by Google

3 A3 B3 C3 Yaya Yaya Yaya

4 Yaya Yaya NaN A4 B4 C4

5 Yaya Yaya NaN A5 B5 C5

6 Yaya Yaya NaN A6 B6 C6

Observe cómo el resultado de la concatenación de filas es como colocar la primera

marco de datos encima del otro. El intento de concatenación de columnas para estos
Los marcos de datos dieron como resultado NaN porque tienen índices variables. Mientras que df1 tiene
su índice del 1 al 3, con sus valores correspondientes; df2 tiene su propio índice que va
del 4 al 6. Para permitir una concatenación de columnas adecuada, tenemos que especificar un
índice similar al siguiente.

En []: df2.index = '1 2 3'.split() # configurando el mismo índice que df1

# Esto debería funcionar entonces

pd.concat([df1,df2],axis=1) # eje en sentido vertical = 1

Fuera[21]:

A B C A B C

1 A1 B1 C1 A4 B4 C4

2 A2 B2 C2 A5 B5 C5

3 A3 B3 C3 A6 B6 C6

Ahora bien, este es un conjunto de datos muy bien combinado. Este es más probablemente el tipo de
concatenación que encontraría al trabajar con hojas de datos, ya que permite
para una denominación más flexible para las columnas, mientras comparte índices de fila similares.

Ejercicio: cambie los últimos tres nombres de columnas en la tabla de resultados anterior a 'DE
F', es decir, la tabla ahora debería tener las columnas 'ABCDE F'.

Sugerencia: use df2.columns = 'value ' para cambiar los nombres de las columnas.

Merge y Join, por otro lado, son más similares. Toman dos marcos de datos.
Machine Translated by Google

y combinarlos en columnas. Ambos requieren una especificación para un marco de datos derecho
e izquierdo respectivamente para determinar la organización. Además, requieren una especificación
adicional para un punto de entrada (generalmente llamado clave) donde ocurre la operación de
unión o fusión. Si bien los métodos Merge y Join son poderosos, no los exploraremos.

Leer y escribir datos

En las aplicaciones del mundo real, los datos vienen en varios formatos. Estos son los más
comunes: CSV, hojas de cálculo Excel (xlsx/xls), HTML y SQL. Si bien Pandas puede leer archivos
SQL, no es necesariamente el mejor para trabajar con bases de datos SQL, ya que existen
bastantes motores SQL: SQL lite, PostgreSQL, MySQL, etc. Por lo tanto, solo consideraremos
CSV, Excel y HTML.

Leer

El método pd.read_file_type('file_name' ) es la forma predeterminada de leer archivos en el marco

de Pandas. Después de la importación, pandas muestra el contenido como un marco de datos
para su manipulación utilizando todos los métodos que hemos practicado hasta ahora y más.

CSV (variables separadas por comas) y Excel

Cree un archivo CSV en Excel y guárdelo en su directorio de Python. Puede verificar dónde está
su directorio de Python en el cuaderno de Jupyter escribiendo: pwd(). Si
desea cambiar a otro directorio que contenga sus archivos (por ejemplo, Escritorio), puede usar el
siguiente código:
En []: importar sistema operativo

os.chdir('C:\\Usuarios\\Nombre de usuario\\Escritorio')

Para importar su archivo CSV, escriba: pd.read_csv('csv_file_name'). Pandas detectará

automáticamente los datos almacenados en el archivo y los mostrará como un marco de datos.
Un mejor enfoque sería asignar los datos importados a una variable como esta:
En []: Csv_data = pd.read_csv('archivo de ejemplo.csv')

datos_csv # espectáculo

Al ejecutar esta celda, se asignarán los datos del 'archivo de ejemplo.csv' a la variable Csv_data,
que es del tipo marco de datos. Ahora se puede llamar más tarde o utilizar para realizar algunas
de las operaciones del marco de datos.

Para archivos de Excel (archivos .xlsx y .xls), se adopta el mismo enfoque. para leer un excel
Machine Translated by Google

archivo llamado 'class data.xlsx', usamos el siguiente código:

En []: Xl_data = pd.read_excel('clase datos.xlsx')

datos_xl # espectáculo

Esto devuelve un marco de datos de los valores requeridos. Puede notar que un índice
comenzando desde 0 se asigna automáticamente en el lado izquierdo. Esto es similar a
declarar un marco de datos sin incluir explícitamente el campo de índice. Puedes añadir
nombres de índice, como hicimos en ejemplos anteriores.

Consejo: en caso de que la hoja de cálculo de Excel tenga varias hojas llenas. Puedes especificar el
hoja que necesita ser importada. Digamos que solo necesitamos la hoja 1, usamos: nombre de hoja =
'
'Hoja 1 Para obtener
. funcionalidad adicional, puede consultar la documentación para
read_excel() usando shift+ta b .

Escribir

Después de trabajar con nuestros marcos de datos importados o creados por pandas, podemos escribir el
marco de datos resultante en varios formatos. Sin embargo, sólo consideraremos
escribiendo de nuevo en CSV y Excel. Para escribir un marco de datos en CSV, utilice lo siguiente
sintaxis:
En []: Csv_data.to_csv(' nombre de archivo ',índice = Falso)

Esto escribe el marco de datos 'Csv_data' en un archivo CSV con el nombre de archivo especificado.
en el directorio de Python. Si el archivo no existe, lo crea.

Consejo: también puedes utilizar este método para crear archivos de hojas de cálculo a través de Python. El
El parámetro de índice falso es para garantizar que la indexación automática de Jupyter no sea
escrito en el archivo, alterando así su formato.

Para escribir en un archivo de Excel, se utiliza una sintaxis similar, pero con el nombre de la hoja.
especificado para el marco de datos que se exporta.
En []: Xl_data.to_excel('nombre de archivo.xlsx',nombre_hoja = 'Hoja 1')

Esto escribe el marco de datos Xl_dat a en la hoja uno de 'nombre de archivo.xlsx' .

HTML

La lectura de archivos HTML a través de pandas requiere la instalación de algunas bibliotecas:

htmllib5, lxml y BeautifulSoup4. Desde que instalamos la última Anaconda,
Es probable que se incluyan estas bibliotecas. Utilice conda list t para verificar y conda
Machine Translated by Google

install l para instalar los que faltan.

Las tablas HTML se pueden leer directamente en pandas utilizando el método pd.read_html ('URL
de la hoja'). La URL de la hoja es un enlace web al conjunto de datos que se va a importar. Como
ejemplo, importemos el conjunto de datos 'Listas de bancos fallidos' del sitio web de la FDIC y
llamémoslo w_data.
En []: w_data = pd.read_html('http://www.fdic.gov/bank/individual/failed/banklist.html')

w_datos[0]

Para mostrar el resultado, aquí usamos w_data [0 ] . Esto se debe a que la tabla que
necesitamos es el primer elemento de hoja en el código fuente de la página web. Si está familiarizado
con HTML, podrá identificar fácilmente dónde se encuentra cada elemento. Para inspeccionar el
código fuente de una página web, utilice el navegador Chrome. En la página web >> haga clic
'
.
derecho >> luego seleccione 'ver fuente de la página. Dado que lo que estamos buscando son datos
en forma de tabla, se especificarán así en el código fuente. Por ejemplo, aquí es donde se crea el
conjunto de datos en el código fuente de la página de la FDIC:

Fuente de la página de la FDIC a través de Chrome

Esta sección concluye nuestras lecciones sobre el marco Pandas. Para poner a prueba sus
conocimientos sobre todo lo que se ha introducido, asegúrese de intentar todos los ejercicios a
continuación. En el próximo capítulo, exploraremos algunos marcos de visualización de datos.

Para el ejercicio, trabajaremos en un conjunto de datos de ejemplo. Una hoja de cálculo salarial
de Kaggle.com. Continúe y descargue la hoja de cálculo desde este enlace: www.kaggle.com/
kaggle/sf­salaries
Machine Translated by Google

Nota: Es posible que deba registrarse antes de descargar el archivo. Descargue el archivo a su
directorio de Python y extráigalo.

Ejercicios: Aplicaremos todo lo que hemos aprendido aquí.

1. Importar pandas como pd

2. Importe el archivo CSV al cuaderno Jupyter, asígnelo a una variable

'Sal' y muestra los primeros 5 valores.

Sugerencia: utilice el método .head( ) para mostrar los primeros 5 valores de un marco
de datos. Asimismo, .tail() se utiliza para mostrar los últimos 5 resultados. Para
especificar más valores, pase 'n=valor' al método.

3. ¿Cuál es el salario más alto (incluidos los beneficios)? Respuesta: 567595,43

Sugerencia: utilice la indexación de columnas del marco de datos y el método .max().

4. Según los datos, ¿cuál es el puesto de trabajo de MONICA FIELDS y cuánto gana
más beneficios? Respuesta: Subjefe del Cuerpo de Bomberos, y $261.366,14 .

Sugerencia: La selección de columnas del marco de datos y la selección condicional

funcionan (la selección condicional se puede encontrar en el Ejemplo 72. Utilice el
índice de columna =='cadena' para la condición booleana).

5. Por último, quién gana el salario básico más alto (menos prestaciones) y en qué
medida su salario es superior al salario básico medio.
Respuesta: NATHANIEL FORD gana el más alto. Su salario es superior al
promedio en $492827.1080282971.

Sugerencia: utilice .max(). La y métodos .mean() para la brecha salarial.

selección condicional con indexación de columnas también funciona para el nombre
del empleado con el salario más alto.

Toda la suerte.
Machine Translated by Google

Capítulo 3

Visualización de datos con Python

La visualización de datos se puede describir como las diversas formas en que se muestran los datos
analizados, es decir, la información. A veces, incluso los datos bien analizados no son lo
suficientemente informativos a simple vista. Con la visualización de datos, que incluye gráficos de
líneas, gráficos de barras, pictogramas, etc., los resultados/análisis que se presentan se vuelven
menos abstractos para el usuario final y se mejora la toma de decisiones. En este capítulo,
aprenderemos varias técnicas para mostrar los resultados de nuestro análisis con los marcos NumPy
y Pandas.

Matplotlib
Esta es una biblioteca de Python para producir gráficos 2D de alta calidad. Para aquellos que
tienen algo de experiencia en MATLAB, las técnicas de trazado y visualizaciones aquí les
resultarán familiares. Matplotlib ofrece mucha flexibilidad con los gráficos, en términos de
control sobre aspectos como los ejes, las fuentes, los estilos y el tamaño de las líneas, etc. Sin
embargo, todo esto requiere escribir líneas de código adicionales. Entonces, si no le importa
hacer un esfuerzo adicional (escribiendo código) para especificar completamente sus gráficos,
entonces matplotlib es su amigo. Para obtener información adicional sobre este paquete, visite
la página oficial en www.matplotlib.org

Básicamente, existen dos enfoques para trazar datos en matplotlib: el enfoque funcional y el orientado
a objetos (OO), respectivamente. Es posible que encuentre los dos términos constantemente al
interactuar con programadores y otros lenguajes de programación, pero son solo dos enfoques de
programación ligeramente diferentes.
Aquí solo consideraremos el enfoque funcional, ya que es fácil de entender para los principiantes y
también requiere escribir menos líneas de código. El método OO, sin embargo, ofrece más control
sobre las tramas como consecuencia de escribir más líneas de código.

Para empezar, creemos un gráfico de coseno simple utilizando el enfoque funcional.

Primero, importemos las bibliotecas relevantes y creemos datos de trazado:

En []: importar matplotlib.pyplot como plt
Machine Translated by Google

importar numpy como np

%matplotlib en línea #

creando valores de trazado

x = np.linspace(0,10) # eje x/escala de tiempo

y = np.cos(x) # valores de coseno correspondientes

La opción %matplotlib inline en el código garantiza que todos nuestros gráficos se muestren a
medida que ejecutamos cada celda. Si está ejecutando una consola Python diferente, puede
colocar plt.show() al final de su código para mostrar sus gráficos. plt.show( ) es la función print( )
equivalente para los gráficos matplotlib.

Método funcional

En []: # gráfico funcional

plt.plot(x,y)

Fuera[]: [<matplotlib.lines.Line2D en 0x25108cf27f0>]

Observe que obtenemos una declaración Out[ ]. Esto se debe a que no imprimimos el resultado
usando plt.show(). Si bien esto no es significativo si usas Jupyter, puede ser necesario para otras
consolas.

También podemos trazar múltiples funciones en un gráfico.

En []: z = np.sin(x) # Agregar una variable de trama adicional

plt.plot(x,y,x,z);plt.show()
Machine Translated by Google

Para imprimir varios gráficos, simplemente pase cada argumento a la declaración del gráfico y separe los gráficos
con comas.

Para que nuestros gráficos sean más significativos, podemos etiquetar los ejes y darle un título al
gráfico.

En []: plt.plot(x,y,x,z)

plt.xlabel('Eje de tiempo') # etiquetado del eje x

plt.ylabel('Magnitud') # etiquetado del eje y

plt.title('Ondas seno y coseno') # título del gráfico

plt.show() # imprimiendo

Producción:
Machine Translated by Google

Ahora, esta es una cifra mejor. Dado que agregamos más de un gráfico, hay una funcionalidad adicional llamada
"leyenda" que ayuda a diferenciar entre los gráficos.

La función de leyenda toma dos argumentos. El primero suele ser un argumento de cadena para etiquetar los
gráficos en orden. El segundo es para funcionalidad adicional, como dónde debería estar la leyenda. El argumento
de ubicación se especifica usando 'loc=value'. Para valor = 1, esquina superior derecha; 2, para la esquina
superior izquierda; 3, para la esquina inferior izquierda; y 4 para la esquina inferior derecha. Sin embargo, si
prefiere dejar que matplotlib decida la mejor ubicación, utilice 'valor=0'.

En []: plt.plot(x,y,x,z)

plt.xlabel('Eje de tiempo')

plt.ylabel('Magnitud')

plt.title('Ondas seno y coseno')

plt.legend(['y','z'],loc=0) #
loc=0 significa mejor ubicación

plt.mostrar()

Producción:
Machine Translated by Google

Suponiendo que deseamos trazar las ondas coseno y sinusoidal arriba, pero una al lado de la otra.

Podemos usar el comando subtrama para hacer esto. Piense en la trama secundaria como una serie
de figuras con una especificación del número de filas y columnas. Entonces, si queremos solo dos
gráficos uno al lado del otro, podemos considerarlo como una matriz de 1 fila y 2 columnas.

En []: # subtrama

plt.subplot(1,2,1) # trama 1

plt.plot(x,y)

plt.title('Gráfico de coseno')

plt.subplot(1,2,2) # trama 2

plt.plot(x,z)

plt.title('Gráfico sinusoidal')

plt.tight_layout() # evita la superposición de gráficos

plt.mostrar()

Consejo: La línea Tight_layout() garantiza que todas las subtramas estén bien espaciadas. Utilice
siempre esto al realizar subtramas para que sus tramas sean más agradables. ¡Intenta eliminar esa
línea y compara el resultado!
Machine Translated by Google

Producción:

Para explicar la línea de la subtrama, es decir, subtrama (1,2,1) y subtrama (1,2,2): Los dos
primeros valores son el número de filas y columnas de la subtrama. Como se ve en el resultado
anterior, la gráfica está en una fila y dos columnas. El último valor especifica el orden del
gráfico; por lo tanto, (1,2,1) se traduce en trazar esa cifra en la primera fila y en la primera
columna de dos.

Podemos especificar los colores de línea en nuestros trazados, así como el estilo de línea. Esto se pasa
como una cadena después del argumento de la trama. Dado que todas las opciones de trazado, incluido el
estilo del marcador y los me gusta, son exactamente las mismas que para Matlab, aquí hay un enlace a la
documentación del trazado de Matlab para explorar todas las funciones de personalización adicionales que
matplotlib: transfiera su ahttps://www.mathworks.com / puede utilizar para los trazados de
help/matlab/ref/plot.html#btzpndl­1

Cambiemos el color y las fuentes en nuestras subtramas para ilustrar esto.

En []: plt.subplot(1,2,1) # trama 1

plt.plot(x,y,'rx') # gráfico rojo con marcador ­x

plt.title('gráfico de coseno')

plt.subplot(1,2,2) # trama 2

plt.plot(x,z,'go') # gráfico verde con marcador ­o

plt.title('Gráfico sinusoidal')

plt.tight_layout() # seguimos evitando los gráficos generales

Machine Translated by Google

plt.mostrar()

Producción:

Ejercicio: ahora que ha aprendido a trazar utilizando el enfoque funcional, pruebe sus habilidades.

Traza esto:
Machine Translated by Google

Consejo: utilice np.arange(0,10,11) para el eje x.

Después de crear su trama, es posible que necesite importarla a sus documentos o simplemente
guardarla en su dispositivo. Para hacer esto, puede hacer clic derecho en la imagen en su cuaderno
Jupyter y hacer clic en copiar. Luego, puede pegar la imagen copiada en su documento.

Si prefiere guardar, puede utilizar el método plt.savefig('figurename.extension', DPI = value). Aquí,

nombre de figura es el nombre deseado para su imagen guardada; La extensión es el formato deseado,
es decir, PNG, JPG, BMP, etc. Finalmente, el DPI especifica la calidad de la imagen, cuanto mayor,
mejor. Por lo general, para una calidad de impresión estándar, alrededor de 300 es suficiente.

Consejo: aprender un poco más sobre estas especificaciones realmente puede ayudarlo a generar
mejores imágenes a partir de sus gráficos.

nacido en el mar

Esta es otra biblioteca de visualización de datos que amplía el rango gráfico de la biblioteca matplotlib.
Aquí se aplican muchos métodos de matplotlib para personalizar gráficos. Sin embargo, genera gráficos
dinámicos de alta calidad en menos líneas de código.
Machine Translated by Google

Seaborn está más optimizado para trazar tendencias en conjuntos de datos y vamos a
explorar un conjunto de datos usando esta biblioteca. Desde entonces, Seaborn está precargado con algunos
conjuntos de datos (puede llamar y cargar ciertos conjuntos de datos desde su repositorio en línea),
simplemente cargue uno de estos para nuestro ejemplo.

Ejemplo 77 : cargar un conjunto de datos marítimos y trazar tendencias

Al igual que con otros paquetes, tenemos que importar seaborn usando la variable estándar
nombre 'sns'.

En []: # importando nacidos marinos

importar seaborn como sns

%matplotlib en línea

A continuación, cargaremos el popular conjunto de datos de "consejos" de Seaborn. Este conjunto de datos contiene
información sobre un restaurante, las propinas que se dan a los camareros, cantidad de propina, tamaño
del grupo de clientes (por ejemplo, un grupo de 3 personas), etc.

En []: # cargando un conjunto de datos desde seaborn

tips_dataset = sns.load_dataset('consejos')

consejos_dataset.head()

Afuera[]:

cuenta total consejo

sexo fumador día tiempo tamaño

0 16,99 1.01 Femenino No Sol Cena 2

1 10.34 1,66 Masculino No Sol Cena 3

2 21.01 3.50 Masculino No Sol Cena 3

3 23,68 3.31 Masculino No Sol Cena 2

4 24,59 3.61 Femenino No Sol Cena 4

A continuación, podemos encontrar tendencias en los datos utilizando diferentes tipos de gráficos. Usemos el
dist_plot (gráfico de distribución) para observar cómo se distribuye total_bill en todo el
conjunto de datos.

En []: #Usar diagrama de distribución

sns.distplot(tips_dataset['total_bill'],bins = 30,kde=False)
Machine Translated by Google

Fuera[]:<matplotlib.axes._subplots.AxesSubplot en 0x28d3867d6d8>

El diagrama de distribución muestra la distribución de ciertas tendencias dentro de los datos.

Según el gráfico anterior, podemos inferir que la mayoría de los billetes están dentro del
rango de $10 ­ $20, ya que tienen los contenedores más altos dentro de la distribución. Es
posible que observe algunos argumentos adicionales en el código de distplot; el argumento
bins controla la cantidad de histogramas que se muestran dentro de la población. Cuanto
mayor sea el valor, más histogramas. Sin embargo, a veces un valor más alto puede hacer
que los datos sean menos obvios de leer, por lo que es importante encontrar un equilibrio. El
siguiente argumento es 'kde', que significa estimación de la densidad del núcleo. A veces se
prefiere a los histogramas o junto con los histogramas para una interpretación más precisa
de los datos. Es principalmente una estimación de la función de densidad de probabilidad de
cualquier variable dentro de la distribución, más parecida al histograma pero más suave.
Puede leer para obtener antecedentes estadísticos más completos sobre algunas de estas cosas.

Otro gráfico útil es el relplot, que muestra la relación entre dos variables dentro de un conjunto
de datos. Es bueno para comparar y puede ordenar los resultados según categorías, es decir,
sexo, edad, etc. dentro de los datos.

Demostremos cómo se relaciona total_bill con la propina estimada y clasifiquemos por

categoría masculino/femenino.
En []: # estimación de propina con respecto a total_bill

sns.relplot(x ="total_bill", y="tip", datos = tips_dataset)

afuera []:
Machine Translated by Google

Aquí hay una trama básica sin el argumento de categoría. Esto nos indica que las propinas
generalmente aumentan con respecto a la factura total. Los billetes más altos corresponden a
propinas más altas y los billetes más bajos a propinas más bajas. Agregar categorías hace que los
datos sean más interesantes ya que podemos ver la categoría que da más o menos propina.
En []: sns.relplot(x ="total_bill", y="tip", data = tips_dataset, hue = 'sexo')

Fuera[]: <seaborn.axisgrid.FacetGrid en 0x28d3b9cedd8>

Vea cómo este es un dato más informativo. Esto muestra cómo los clientes masculinos dieron
propinas más altas por factura total en promedio que las mujeres.

Ahora esta idea se puede ampliar y aplicar a datos más avanzados. Puede explorar más a fondo
varias opciones de trazado con relplot a través de este enlace: www.seaborn.pydata.org/tutorial/
relational.html

El relplot se amplía incluso con la opción pairplot, que relaciona todo en un conjunto de datos en un
solo gráfico. Es una excelente manera de obtener una descripción general rápida de importantes
Machine Translated by Google

tendencias dentro de sus datos.

En []: sns.pairplot(tips_dataset,hue = 'sexo', paleta = 'coolwarm')

Fuera[]:<seaborn.axisgrid.PairGrid en 0x28d412f2e48>

Vea lo fácil que es observar las variaciones entre los tres parámetros principales dentro de los datos: total_bill,
propina y tamaño. También se ha pasado a la categoría "sexo" para observar las tendencias en ese sentido.
Para cada caso en el que se compara una variable consigo misma, obtenemos una estimación de la densidad
del núcleo o un histograma, si se especifica. Las otras comparaciones se realizan mediante diagramas de
dispersión.

Del gráfico de pares, podemos inferir rápidamente que las propinas no necesariamente aumentan al aumentar
el tamaño del partido, considerando que la propina más grande está dentro del tamaño del partido de 3. Esta
inferencia se puede encontrar observando los gráficos 2,3 y 3,2 ( fila columna).
Machine Translated by Google

Quizás se pregunte: ¿podríamos encontrar también el tamaño de la población dentro de un conjunto de datos mediante
¿categoría? Bueno, countplot es muy útil para eso. Es común ver este tipo de
de parcelas dentro de un documento como el informe del censo de Estados Unidos. Básicamente muestra una barra.
gráfico, con la altura correspondiente a la población de una categoría dentro del
conjunto de datos.

En []: sns.countplot(x ='sexo', datos = tips_dataset)

Fuera[]: <matplotlib.axes._subplots.AxesSubplot en 0x28d41990978>

Para validar esto, podemos usar el método pandas groupby junto con count. Esperanza
¡Puedes recordar estos métodos!

En []: importar pandas como pd #importar pandas para usar groupby()

tips_dataset.groupby('sexo').count()

Afuera[]:

cuenta total consejo

fumador día tiempo tamaño

sexo

Masculino 157 157 157 157 157 157

Femenino 87 87 87 87 87 87
Machine Translated by Google

Como era de esperar, observe cómo los recuentos masculinos y femeninos de 157 y 87 respectivamente se
corresponden con el gráfico de recuento anterior.

Estas y muchas más son las capacidades de visualización de datos de Seaborn. Por ahora, estos son algunos
ejemplos básicos para empezar; puede visitar la galería de documentación oficial de Seaborn para explorar más
estilos y opciones de gráficos a través de este enlace: https://seaborn.pydata.org/examples/index.html

pandas

Bueno, son nuestros amigables pandas otra vez. La biblioteca también tiene algunas capacidades de visualización
altamente funcionales. Es bastante intuitivo en ese momento utilizar estas opciones de visualización integradas
mientras se trabaja con pandas, a menos que se requiera algo más especializado.

Primero, importamos algunas bibliotecas familiares:

En []: # importando todas las bibliotecas necesarias

importar numpy como np

importar pandas como pd

importar matplotlib.pyplot como plt

%matplotlib en línea

importar seaborn como sns

Quizás se pregunte por qué se importan todas las demás bibliotecas, además de Pandas.
Bueno, tus resultados se verán mucho mejor con estas bibliotecas sincronizadas.
Pandas traza usando la funcionalidad de la biblioteca matplotlib, aunque no la llama directamente, y la biblioteca
seaborn hace que los gráficos/trazados se vean mejor.

Trabajemos con un conjunto de datos diferente. Podemos crear nuestro propio marco de datos y llamar a los

gráficos a partir de él.

Crearemos un marco de datos a partir de una distribución uniforme.

En []: # creemos nuestro diccionario

d = {'A':np.random.rand(5),

'B':np.aleatorio.rand(5),

'C':np.random.rand(5),

'D':np.aleatorio.rand(5)}

# ahora creando un marco de datos

Machine Translated by Google

df = pd.DataFrame(d)
df

Afuera[]:

A B C D

0 0.982520 0.469717 0.973735 0.397019

1 0.602272 0.148608 0.433559 0.929647

2 0.566168 0.737165 0.040840 0,435978

3 0.632309 0.772419 0,341389 0.603980

4 0.949631 0.906318 0.895018 0.679825

Con nuestro marco de datos, ahora podemos observar tendencias. Para crear un gráfico de histograma
usando pandas, use la función hist(). Además, puedes pasar algo de matplotlib.
argumentos como 'contenedores'

En []: df[['A']].hist(bins=30)

Out[]: array([[<matplotlib.axes._subplots.AxesSubplot objeto en 0x0000028D432E50B8>]],

tipo d=objeto)

También podemos hacer una gráfica de área de los valores, que es esencialmente una gráfica lineal de
Machine Translated by Google

los valores con el área debajo sombreada:

En []: df.plot.area()
Fuera[]: <matplotlib.axes._subplots.AxesSubplot en 0x28d433b2438>

La configuración de transparencia de este gráfico se puede establecer con el argumento 'alfa = valor'.

También podemos hacer un diagrama de barras que pueda categorizar nuestros datos según nuestro
índice de fila.
En []: df.plot.bar()
Fuera[]: <matplotlib.axes._subplots.AxesSubplot en 0x28d435fe828>
Machine Translated by Google

Mira, nuestro eje x tiene el índice de fila y el eje y muestra el valor de en cada columna por índice.

Este tipo de gráfico puede ser útil para cosas como tendencias de ventas por mes (con ventas como
valores y meses como índice_fila), asistencia a la escuela por día, etc. Sin embargo, nuestros gráficos
actuales pueden no ser demasiado informativos ya que estamos usando datos aleatorios. un conjunto de
datos real revelaría más detalles.

Si lo prefiere, los gráficos de barras se pueden apilar para brindar una mejor visualización:
En []: df.plot.bar(stacked = True, alpha = 0.8)
Fuera[]: <matplotlib.axes._subplots.AxesSubplot en 0x28d43a6e048>
Machine Translated by Google

Este tipo de gráfico nos da una idea de los valores totales por categoría, así como de los porcentajes que
representan ese total. Todavía podemos observar que el valor de la columna 'A' es el que más contribuye en
la categoría '0', seguido de 'C', y así sucesivamente.

Trama lineal:

En []: df.plot.line(y =['B','C'])

Fuera[]: <matplotlib.axes._subplots.AxesSubplot en 0x28d43b6fc88>
Machine Translated by Google

El gráfico lineal toma argumentos posicionales de los ejes x e y. En este caso, se ha especificado el
eje y. También se pueden incluir otras especificaciones como: ancho de línea 'lw', tamaño de figura,
etc.

También podemos hacer diagramas de dispersión, diagramas de caja y algunos otros diagramas que
pueden resultar útiles para interpretar datos. Dependiendo de su elección y de su dominio de estas
técnicas de trazado, podrá dominar los datos y la información que contienen.

Continúe y consulte estos enlaces útiles para obtener información adicional sobre cómo trazar con
pandas:
https://towardsdatascience.com/introduction­to­data­visualization­in­python­89a54c97fbed
https://
pandas.pydata.org/pandas­docs/ estable/user_guide/visualization.html

Con estas opciones de visualización de datos, puede comenzar a poner a prueba sus habilidades
mostrando datos en una amplia gama de formatos. Es bastante obvio que un buen conocimiento de
los métodos estadísticos sería muy útil para sobresalir como científico de datos, ya que la ciencia de
datos se ocupa principalmente de datos estadísticos. Si bien las estadísticas pueden resultar
intimidantes sin ayudas gráficas, su propio enfoque será mejor ya que ahora tiene todo el potencial
de matplotlib, seaborn y pandas para visualizar sus lecciones. Para opciones de visualización
interactiva (no cubiertas aquí), puede consultar las bibliotecas 'plotly y cufflinks' desde este enlace:
https://plot.ly/ipython­notebooks/cufflinks/

Sin embargo, en la siguiente sección ofrecemos una breve introducción al mundo y los conceptos del
aprendizaje automático.
Machine Translated by Google

Capítulo 4

Aprendizaje automático con Python

Entonces, ¿qué es el aprendizaje automático?

El aprendizaje automático es una forma avanzada de análisis y cálculo de datos que utiliza la velocidad de
procesamiento excepcional y las técnicas de reconocimiento de patrones de las computadoras para encontrar
y aprender nuevas tendencias en los datos. Bastante largo, ¿eh?

En pocas palabras, es una técnica de programación inspirada en la inteligencia artificial que permite a las
computadoras mejorar sus capacidades de aprendizaje a través de los datos a los que reciben o a los que
pueden acceder. Esto es muy parecido a la forma en que los seres humanos se desarrollan a lo largo de la vida.

Si bien el aprendizaje automático no es un concepto o tecnología nueva (de hecho, el término fue introducido
por primera vez en IBM en 1959 por el experto estadounidense en juegos e inteligencia artificial, Arthur
Samuel), recientemente ha ganado muchos intereses en términos de investigación y aplicaciones en diversos
campos. . Esto se debe principalmente a la mejora en las capacidades de procesamiento de las computadoras
de la generación moderna, junto con lenguajes de programación rápidos, portátiles y de alto nivel que
admiten el reconocimiento de patrones avanzado. El concepto detrás de la técnica se mejora y prueba
constantemente, y será un actor clave en la revolución tecnológica más grande del futuro.

Bien, el aprendizaje automático es genial. ¿Cómo se relaciona con la ciencia de datos?

Imagínate esto: eres jugador de fútbol (o fútbol en algunos países, ¡Dios mío!) y juegas a la defensiva. Has
intentado marcar al extremo del equipo contrario tres veces, y en cada encuentro, él dio un paso adelante y
dribló hacia la izquierda. Ahora, tu equipo está defendiendo y ese delantero se enfrenta a tu co­defensor;
estás lo suficientemente cerca como para gritarle instrucciones, ¿qué dices?

Marca a la izquierda!!!

¿Bien? Desafortunadamente, regatea hacia la derecha y anota. Todo el mundo te culpa.

Vale, esa historia tiene un mal final, pero la cuestión es que hiciste una predicción basada en lo que
aprendiste sobre ese delantero durante tu anterior
Machine Translated by Google

encuentros.

¿Qué pasaría si, antes del partido, hubieras visto imágenes de un año de las técnicas y trucos
de regate de ese delantero? Tendrían muy pocas posibilidades de pasarte, ¿verdad? ¿Qué tal
un metraje de 10 años de duración (que podrías ver en exceso como The Flash!)? ¡Ninguna
posibilidad, en absoluto!

Aquí es donde la capacidad del aprendizaje automático se aplica a la ciencia de datos.

Las computadoras, aunque no son tan inteligentes como los humanos, son excepcionalmente
buenas para encontrar tendencias (por supuesto que lo son, las operaciones de la computadora
tienen que ver con el reconocimiento de patrones a través de unos y ceros). Ahora, imagina que
esa máquina tiene acceso a una gran base de datos, como todos los tweets en Twitter de los
últimos 5 años. Aprendería mucho sobre la cultura pop, eso es seguro (predicciones de acciones
financieras, detección de fraudes, etc.). Estas son las aplicaciones más populares del aprendizaje
automático y la técnica se basa en extraer información de los datos; ¡Ciencia de los datos!

Por lo tanto, es importante que cualquier científico de datos actual o aspirante a unirse a la
creciente comunidad de aprendizaje automático y contribuir con una cuota para mejorar la
tecnología. Existen algunas herramientas de programación que están optimizadas para el
aprendizaje automático y Python es una de ellas.

Python y el aprendizaje automático

Como ocurre con la mayoría de las aplicaciones de Python, existe una biblioteca para
aprendizaje automático y se llama Scikit Learn. Lo más probable es que el paquete de
aprendizaje Scikit esté incluido en su distribución de anaconda, y puede continuar y verificar
con conda list en el indicador de anaconda. Puede consultar la documentación oficial de Scikit­
learn a través de este enlace: https://scikit­learn.org/stable/

Tipos de aprendizaje automático

Actualmente existen cuatro categorías generalizadas de aprendizaje automático y este

conocimiento es importante según la aplicación en mente. Tenemos: El aprendizaje automático
supervisado, semisupervisado, no supervisado y de refuerzo.

En el aprendizaje supervisado, el formador (usted o quien esté detrás del teclado) conoce el
resultado deseado. La máquina se entrena utilizando entradas etiquetadas que asocia con las
salidas correspondientes. A través de esto, la máquina desarrolla un modelo predictivo para
vincular esas entradas con salidas específicas durante un período de aprendizaje iterativo. No
es tan diferente de la forma en que aprendemos en un
Machine Translated by Google

aula, con un profesor disponible para corregir errores. Este es el enfoque más sencillo, pero
normalmente costoso, del aprendizaje automático.

Para el aprendizaje no supervisado, no existe un objetivo específico en mente. En ocasiones, el

formador no sabe la respuesta correcta y la computadora sólo encuentra tendencias interesantes
en los datos basándose en un algoritmo de entrenamiento (normalmente una técnica de
agrupamiento). Esto es similar al proceso de aprendizaje informal en los humanos, donde
aprendemos en función de nuestra interacción con nuestro entorno.

El enfoque semisupervisado es solo una versión reducida del supervisado, que resulta útil en
ausencia de un conjunto de datos de entrenamiento completo y etiquetado. En este caso, la máquina
tiene que hacer algunas aproximaciones para compensar los datos no etiquetados. Es más barato
que el aprendizaje supervisado, pero más lento y relativamente menos eficiente.

Finalmente, la técnica del aprendizaje por refuerzo es un enfoque de prueba y error basado en el
sistema de recompensa de puntos en los juegos (en realidad se utiliza en nuevos motores de juegos
para crear jefes competitivos). Aquí, el objetivo es encontrar la mejor ruta posible para alcanzar un
objetivo. Esto incluye utilizar los recursos mínimos y maximizar el tiempo. También es muy útil en la
robótica moderna. Aquí, la máquina aprende de su experiencia mientras interactúa con el entorno.

Todas estas aplicaciones de aprendizaje automático son posibles y están listas para explorarse a
través de Scikit learn with python. Todo lo que necesitas es un buen recurso, tiempo, dedicación y
todo el conocimiento de análisis y visualización de datos básicos de las secciones anteriores de
este libro; Esto se debe a que la limpieza y preparación de datos es una parte importante del
aprendizaje automático.

El aprendizaje automático, al igual que otros elementos de la ciencia de datos, requiere una buena
formación en análisis estadístico. Cosas como análisis de regresión, es decir, regresión lineal y
logística, agrupación de K­medias, K­NN (vecino más cercano), etc. Aquí hay un enlace para
descargar un libro bueno y gratuito que puede presentarle algunos de estos conceptos
estadísticos:http: //www­bcf.usc.edu/~gareth/ISL/ISLR%20Seventh%20Printing.pdf
Machine Translated by Google

Conclusión

Esperamos que haya aprendido muchísimo de este libro. El dominio de una habilidad no
consiste sólo en saberlo, sino en una práctica continua, en la que reside la singularidad de
la habilidad y la competencia. Con el tiempo, seguirás buscando esa interminable extensión
de conocimientos que es la ciencia de datos. ¡Al menos ya no eres un novato!