Contenido

Week 02 - Basic Data Processing with Pandas ................................................................................................................ 2

1. Introduction ......................................................................................................................................................................... 2
2. The Series Data Structure ............................................................................................................................................... 3
03. Quering a Series ............................................................................................................................................................... 4
04 The DataFrame Data Structure ................................................................................................................................... 6
05. DataFrame Indexind and Loading ............................................................................................................................. 8
06. Queryng a DataFrame .................................................................................................................................................... 9
07. Indexing Dataframes ................................................................................................................................................... 10
Week 03 - Pandas Python Avanzado ................................................................................................................................ 12
1. Merging DataFrames ...................................................................................................................................................... 12
2. Idiomatic Python ............................................................................................................................................................. 13
3. Scales .................................................................................................................................................................................... 15
4. Pivot tables. ....................................................................................................................................................................... 17
5. Data Functionality ........................................................................................................................................................... 17
Week 4 – Proyecto de Análisis estadístico en Python ................................................................................................ 18
01. Introduction. ................................................................................................................................................................... 18
02. Distributions. .................................................................................................................................................................. 18
03. More distributions........................................................................................................................................................ 19
04. Hypothesis Testing in Python .................................................................................................................................. 21

1
 Week 02 - Basic Data Processing with Pandas
1. Introduction

Esta semana profundizaremos nuestra investigación sobre cómo se puede usar Python para manipular,
limpiar y consultar datos mirando el kit de herramientas de datos Pandas. Pandas fue creado por Wes
McKinney en 2008, y es un proyecto de código abierto bajo una licencia muy permisiva. Como proyecto
de código abierto, tiene una comunidad fuerte, con 100 desarrolladores de software que comprometen
el código para ayudar a mejorarlo. Hay un par de lugares a los que debería considerar acudir para
obtener ayuda con Pandas. Obviamente, los foros de discusión del curso son un gran recurso. Pero no
creo que sean el mejor recurso para los problemas de Pandas en particular. Creo que el mejor recurso
es un sitio de preguntas y respuestas llamado Stack Overflow. Stack Overflow se usa ampliamente
dentro de la comunidad de desarrollo de software para publicar preguntas sobre programación,

2
lenguajes de programación y kits de herramientas de programación. Lo especial de Stack Overflow es
que está fuertemente curada por la comunidad. Y la comunidad de Pandas, en particular, lo utiliza como
su recurso número uno para ayudar a los nuevos miembros. Es muy posible si publica una pregunta en
Stack Overflow y la etiqueta como relacionada con Pandas y Python, que un desarrollador de Pandas
realmente responda a su pregunta. Además de publicar preguntas, Stack Overflow es un gran lugar para
ver qué problemas tienen las personas y cómo se pueden resolver. Puedes aprender mucho explorando
Stacks en Stack Overflow. Un segundo recurso que puede considerar son los libros. En 2012, Wes
McKinney escribió el libro de referencia definitivo de Pandas llamado Python for Data Analysis y
publicado por O'Reilly. Si bien está comenzando a ponerse un poco anticuado, recientemente anunció
que se lanzará una nueva edición del libro, y todavía considero que es un libro para entender cómo
funciona Pandas. También aprecio el libro más breve Leaning the Pandas Library de Matt Harrison. No
es un libro completo sobre análisis de datos y estadísticas. Pero si solo quieres aprender los conceptos
básicos de Pandas y quieres hacerlo rápidamente, creo que es un volumen bien diseñado. El campo de
la ciencia de datos está cambiando rápidamente. Todos los días se crean nuevos kits de herramientas y
métodos. Puede ser difícil mantenerse al tanto de todo. Y Marco Rodríguez y Tim Golden mantuvieron
un maravilloso sitio agregador de blogs llamado Planet Python. Puede visitar la página web en
planetpython.org, suscribirse con un lector RSS u obtener los últimos artículos del feed de Twitter
@PlanetPython. Hay muchos contribuyentes regulares de ciencia de datos de Python, y lo recomiendo
encarecidamente si sigue los canales RSS. Aquí está mi último complemento sobre cómo profundizar su
aprendizaje. Kyle Polich ejecuta un excelente podcast llamado Data Skeptic. Bueno, no está basado en
Python per se, está bien producido y tiene una maravillosa mezcla de entrevistas con expertos en el
campo, así como lecciones educativas cortas. Gran parte de la palabra que describe es específica de los
métodos de aprendizaje automático. Pero si eso es algo que planeas explorar a través de esta
especialización en la que se encuentra este curso, realmente te animo a que te suscribas a su podcast.
Bueno, eso es todo por una pequeña introducción a esta semana. A continuación, vamos a sumergirnos
en Pandas y hablar sobre la estructura de datos de la serie.

2. The Series Data Structure

La serie es una de las estructuras de datos centrales en los pandas. Piensas que es un cruce entre una
lista y un diccionario. Todos los elementos se almacenan en un orden y hay etiquetas con las que puede
recuperarlos. Una manera fácil de visualizar esto es dos columnas de datos. El primero es el índice
especial, muy parecido a las teclas del diccionario. Mientras que el segundo es su información real. Es
importante tener en cuenta que la columna de datos tiene una etiqueta propia y se puede recuperar con
el atributo .name. Esto es diferente que con los diccionarios y es útil cuando se trata de fusionar
múltiples columnas de datos. Y hablaremos de eso más adelante en el curso. Como es de esperar, puede

3
crear una serie pasando una lista de valores. Cuando hace esto, Pandas asigna automáticamente un
índice que comienza con cero y establece el nombre de la serie en Ninguno. Veamos un ejemplo de esto.
Primero, comenzaré importando la biblioteca de pandas como pd, luego echemos un vistazo al objeto
de la serie. Aquí puede ver que la documentación indica que puede pasar algunos datos, un índice y un
nombre. Los datos pueden ser cualquier cosa, como una matriz, como una lista. Así que vamos a
intentarlo. Haremos una lista de mis tres animales favoritos, un tigre, un oso y un alce. Veremos aquí
que los pandas identificaron automáticamente el tipo de datos que se mantienen en la lista, en este caso
pasamos una lista de cadenas y panda estableció el tipo en objeto. No tenemos que usar cadenas. Si
pasamos en una lista de números enteros, por ejemplo, podríamos ver que panda establece el tipo en n
64. Debajo de panda almacena valores de serie en una matriz tipada usando la biblioteca Numpy. Esto
ofrece una aceleración significativa al procesar datos en comparación con las listas tradicionales de
Python. Hay otros detalles de escritura que existen para el rendimiento que es importante saber. Lo
más importante es cómo Numpy y, por lo tanto, los pandas manejan los datos que faltan. En Python,
tenemos el tipo none para indicar la falta de datos. Pero, ¿qué hacemos si queremos tener una lista
escrita como lo hacemos en el objeto de la serie? Debajo, los pandas hacen algún tipo de conversión. Si
creamos una lista de cadenas y tenemos un elemento, un tipo None, pandas lo inserta como None y usa
el objeto type para la matriz subyacente. Si creamos una lista de números, enteros o flotantes, y
colocamos el tipo Ninguno, los pandas automáticamente lo convierten en un valor especial de coma
flotante designado como NAN, que no representa un número. Para aquellos que quizás no hayan hecho
computación científica en Python antes, este es un punto bastante importante. NAN no es ninguno y
cuando probamos la prueba de igualdad, es falsa. Resulta que en realidad no puedes hacerte una prueba
de igualdad de NAN. Cuando lo haces, la respuesta siempre es falsa. Debe usar funciones especiales para
comprobar la presencia de un número, como la biblioteca Numpy es NAN. Volveremos a esto más
adelante en la tarea, pero tenga en cuenta que cuando vea NAN, su significado es similar a ninguno, pero
es un valor numérico y se trata de manera diferente por razones de eficiencia. Hablemos más sobre
cómo se pueden crear las series de pandas. Si bien mi lista de animales podría ser una forma común de
crear algunos datos de juego, a menudo tiene datos de etiquetas que desea manipular. Se puede crear
una serie a partir de datos del diccionario. Si hace esto, el índice se asigna automáticamente a las claves
del diccionario que proporcionó y no solo a los enteros incrementales. Aquí hay un ejemplo usando
algunos datos de Wikipedia sobre deportes nacionales oficiales. Cuando creamos la serie, vemos que,
dado que se trataba de datos de cadena, panda establece el tipo de datos de la serie para objetar.
Establecemos la lista de países como el valor de la serie y que los valores de índice se pueden establecer
en las teclas de nuestro diccionario. Una vez que se ha creado la serie, podemos obtener el objeto de
índice utilizando el atributo de índice. También puede separar la creación de su índice de los datos
pasando el índice como una lista explícitamente a la serie. Entonces, ¿qué sucede si su lista de valores
en el objeto de índice no está alineada con las claves de su diccionario para crear la serie? Bueno, pandas
anula la creación automática para favorecer solo y todos los valores de índices que proporcionó. Por lo
tanto, lo ignorará de su diccionario, todas las claves, que no están en su índice, y los pandas agregarán
valores sin tipo o NAN para cualquier valor de índice que proporcione, que no está en su lista de claves
del diccionario. En este ejemplo, pasamos un diccionario de cuatro elementos, pero solo dos se
conservan en el objeto de la serie debido a la lista de índice. Vemos que se ha agregado hockey, pero
como también está en la lista de índice, no tiene ningún valor asociado. Así es como creamos una serie.
En la próxima clase, profundizaremos y veremos cómo sacamos datos de la serie.
03. Quering a Series
Un panda.serie se puede consultar, ya sea por la posición del índice o por la etiqueta del índice. Como
vimos, si no le da un índice a la serie, la posición y la etiqueta son efectivamente los mismos valores.
Para consultar por ubicación numérica, comenzando en cero, use el atributo iloc. Para consultar por la
etiqueta de índice, puede usar el atributo loc. Aquí hay un ejemplo usando datos de eventos deportivos
nacionales de Wikipedia. Digamos que queremos tener una lista de todos los deportes en nuestro índice
y una lista de países como valores. Puede mantenerlos en un diccionario y crear una serie como

4
discutimos. Si quisiera ver el cuarto país en esto, usaríamos el atributo iloc con el parámetro 3. Si
quisiera ver qué país tiene el golf como deporte nacional, usaríamos el atributo loc con el parámetro
golf. Tenga en cuenta que iloc y loc no son métodos, son atributos. Por lo tanto, no utiliza paréntesis
para consultarlos, sino corchetes, que llamaremos operador de indexación. Aunque en Python, esto
llama a obtener y establecer un método de elementos según el contexto de su uso. Esto puede parecer
un poco confuso si está acostumbrado a lenguajes donde la encapsulación de atributos, variables y
propiedades es común, como en Java. Pandas intenta hacer que nuestro código sea un poco más legible
y proporciona una especie de sintaxis inteligente utilizando el operador de indexación directamente en
la propia serie. Por ejemplo, si pasa un parámetro entero, el operador se comportará como si quisiera
consultar a través del atributo iloc. Si pasa un objeto, consultará como si quisiera usar el atributo loc
basado en etiquetas. Entonces, ¿qué sucede si su índice es una lista de enteros? Esto es un poco
complicado, y Pandas no puede determinar automáticamente si tiene la intención de consultar por
posición de índice o etiqueta de índice. Por lo tanto, debe tener cuidado al usar el operador de
indexación en la serie misma. Y la opción más segura es ser más explícito y usar los atributos iloc o loc
directamente. Aquí hay un ejemplo utilizando algunos datos deportivos nuevos, donde los países están
indexados por entero. Si intentamos llamar a s bajo cero, obtenemos un error clave, porque no hay
ningún elemento en la lista de deportes con un índice de cero. En cambio, tenemos que llamar a iloc
explícitamente si queremos el primer elemento. Bien, ahora sabemos cómo obtener datos de la serie.
Hablemos de trabajar con los datos. Una tarea común es querer considerar todos los valores dentro de
una serie y querer hacer algún tipo de operación. Esto podría ser tratar de encontrar un número
determinado, resumir datos o transformar los datos de alguna manera. Un enfoque programático típico
para esto sería iterar sobre todos los elementos de la serie e invocar la operación que le interesa. Por
ejemplo, podríamos crear un marco de datos de valores de coma flotante. Pensemos en estos como
precios de diferentes productos. Podríamos escribir una pequeña rutina que repita todos los elementos
de la serie y los sume para obtener un total. Esto funciona, pero es lento. Las computadoras modernas
pueden hacer muchas tareas simultáneamente, especialmente, pero no solo, tareas que involucran
matemáticas. Pandas y las bibliotecas subyacentes NumPy admiten un método de cálculo llamado
vectorización. La vectorización funciona con la mayoría de las funciones de la biblioteca NumPy,
incluida la función de suma. Así es como realmente escribiríamos el código usando el método de suma
NumPy. Primero necesitamos importar el módulo numpy, y luego simplemente llamamos a np.sum y
pasamos un elemento iterable. En este caso, nuestra serie panda. Ahora ambos métodos crean el mismo
valor, pero ¿es uno realmente más rápido? El Jupyter Notebook tiene una función mágica que puede
ayudar. Primero, creemos una gran serie de números aleatorios. Verás que esto se usa mucho al
demostrar técnicas con Pandas. Tenga en cuenta que acabo de usar el método head, que reduce la
cantidad de datos impresos por la serie a los primeros cinco elementos. De hecho, podemos verificar
que la longitud de la serie es correcta utilizando la función len. Las funciones mágicas comienzan con
un signo de porcentaje. Si escribimos este signo y luego presionamos la tecla Tab, podemos ver una lista
de las funciones mágicas disponibles. También podrías escribir tus propias funciones mágicas, pero eso
está un poco fuera del alcance de este curso. De hecho, vamos a utilizar lo que se llama una función
mágica celular. Estos comienzan con dos signos de porcentaje y modifican un código raptor en la celda
Jupyter actual. La función que vamos a usar se llama timeit. Y como puede haber adivinado por el
nombre, esta función ejecutará nuestro código varias veces para determinar, en promedio, cuánto
tiempo lleva. Ejecute timeit con nuestro código iterativo original. Puede darle tiempo a la cantidad de
bucles que desea ejecutar. Por defecto, usaremos 1,000 bucles. Le pediré a timeit aquí que use 100
carreras porque estamos grabando esto. No está mal. Timeit ejecutó este código y no parece que tarde
mucho. Ahora intentemos con la vectorización. ¡Guauu! Esta es una diferencia bastante sorprendente
en la velocidad y demuestra por qué los científicos de datos deben conocer las características de
computación paralela y comenzar a pensar en términos de programación funcional. La característica
relacionada en Pandas y NumPy se llama transmisión. Con la transmisión, puede aplicar una operación
a cada valor de la serie, cambiando la serie. Por ejemplo, si quisiéramos aumentar cada variable
aleatoria en 2, podríamos hacerlo rápidamente usando el operador + = directamente en el objeto de la
serie. Aquí solo usaré el operador de cabeza para imprimir las cinco primeras filas de la serie. La forma
5
procesal de hacer esto sería iterar a través de todos los elementos de la serie y aumentar los valores
directamente. Un rápido a un lado aquí. Pandas admite la iteración a través de una serie como un
diccionario, lo que le permite desempaquetar valores fácilmente. Pero si te encuentras iterando a través
de una serie, debes preguntarte si estás haciendo las cosas de la mejor manera posible. Así es como lo
haríamos con el método del valor establecido en serie. Probemos y cronometremos los dos enfoques.
Increíble. No solo es significativamente más rápido, sino que es más conciso y tal vez incluso más fácil
de leer. Las operaciones matemáticas típicas que esperaría son vectorizadas, y la documentación de
NumPy describe lo que se necesita para crear sus propias funciones vectorizadas. Una última nota sobre
el uso de los operadores de indexación para acceder a los datos de la serie. El atributo .loc le permite no
solo modificar los datos en su lugar, sino también agregar nuevos datos. Si el valor que pasa como índice
no existe, se agrega una nueva entrada. Y tenga en cuenta que los índices pueden tener tipos mixtos. Si
bien es importante tener en cuenta la escritura debajo, Pandas cambiará automáticamente los tipos de
NumPy subyacentes según corresponda. Aquí hay un ejemplo usando una serie de algunos números.
Podríamos agregar un nuevo valor, tal vez un animal, como saben, me gustan los osos. Simplemente
llamando al operador de indexación .loc. Vemos que los tipos mixtos para valores de datos o etiquetas
de índice no son un problema para Pandas. Hasta ahora solo he mostrado ejemplos de una serie en la
que los valores del índice eran únicos. Quiero finalizar esta conferencia mostrando un ejemplo en el que
los valores de índice no son únicos, y esto hace que los marcos de datos sean diferentes,
conceptualmente, de lo que podría ser una base de datos relacional. Revisando el tema de los países y
sus deportes nacionales, resulta que a muchos países parece gustarles este juego de cricket. Volvemos
a nuestra serie original sobre deportes. Es posible crear un nuevo objeto de serie con múltiples entradas
para cricket, y luego usar append para unirlos. Hay un par de consideraciones importantes al usar
append. Primero, Pandas tomará su serie e intentará inferir los mejores tipos de datos para usar. En
este ejemplo, todo es una cadena, por lo que no hay problemas aquí. En segundo lugar, el método append
no cambia realmente la serie subyacente. En su lugar, devuelve una nueva serie que se compone de los
dos anexos. Podemos ver esto volviendo atrás e imprimiendo la serie original de valores y viendo que
no han cambiado. Esto es realmente un problema importante para los nuevos usuarios de Pandas que
están acostumbrados a que los objetos se cambien en su lugar. Así que ten cuidado, no solo con append
sino también con otras funciones de Pandas. Finalmente, vemos que cuando consultamos las series
adjuntas para aquellos que tienen el cricket como su deporte nacional, no obtenemos un solo valor, sino
una serie en sí misma. Esto es realmente muy común, y si tiene un fondo de base de datos relacional,
esto es muy similar a cada consulta de tabla que resulta en un conjunto de retorno que en sí mismo es
una tabla. En esta conferencia, nos centramos en uno de los tipos de datos principales de la biblioteca
Pandas, la serie. Hay muchos más métodos asociados con este objeto de serie de los que no hemos
hablado. Pero con estos conceptos básicos desactivados, pasaremos a hablar sobre la estructura de
datos bidimensionales del Panda, el marco de datos. El marco de datos es muy similar al objeto de la
serie, pero incluye varias columnas de datos, y es la estructura con la que pasará la mayor parte de su
tiempo trabajando al limpiar y agregar datos. Pero antes de pasar a una discusión sobre el marco de
datos, nuestro asistente de tutoría para este curso proporcionará una visión más profunda de cómo se
puede usar el objeto de la serie.
04 The DataFrame Data Structure
La estructura de datos de DataFrame es el corazón de la biblioteca de Panda. Es un objeto principal con
el que trabajará en tareas de análisis y limpieza de datos. El DataFrame es conceptualmente un objeto
de serie bidimensional, donde hay un índice y varias columnas de contenido, y cada columna tiene una
etiqueta. De hecho, la distinción entre una columna y una fila es realmente solo una distinción
conceptual. Y puede pensar en el DataFrame en sí mismo como simplemente una matriz etiquetada de
dos ejes. Puede crear un DataFrame de muchas maneras diferentes, algunas de las cuales puede esperar.
Por ejemplo, puede usar un grupo de series, donde cada serie representa una fila de datos. O podría
usar un grupo de diccionarios, donde cada diccionario representa una fila de datos. Echemos un vistazo
a un ejemplo. Voy a crear tres registros de órdenes de compra como objetos de serie para una especie

6
de tienda ficticia. Cada serie tiene el nombre de un cliente, la cadena que describe el artículo que se
compra y el costo de los artículos. Me gustan los perros, así que compraré un montón de comida para
perros. Kevin Cullens Thompson, el instructor del tercer curso de la serie, me parece más un hombre
gato, así que le pediré que compre arena para gatos. Y creo que Vinod, que enseña el cuarto curso de
esta serie, es más un hombre pájaro, así que agregaré algunas semillas de pájaros allí. Luego
alimentaremos esto en el DataFrame como primer argumento y estableceremos valores de índice que
indiquen en qué tienda se realizó cada compra. Verá que cuando imprimimos un DataFrame, el
cuaderno de Júpiter está tratando de mejorarlo un poco e imprimirlo como una tabla, lo cual es bueno.
Similar a la serie, podemos extraer datos usando los atributos iLock y Lock. Debido a que el DataFrame
es bidimensional, pasar un solo valor al operador de indexación de bloqueo devolverá series si solo hay
una fila para devolver. En este ejemplo, si quisiéramos seleccionar datos asociados con la Tienda 2, solo
consultaríamos el atributo de bloqueo con un parámetro. Notará que el nombre de la serie se devuelve
como el valor del índice de la fila, mientras que el nombre de la columna también se incluye en la salida.
Podemos verificar el tipo de datos de la devolución utilizando la función de tipo python. Es importante
recordar que los índices y los nombres de columna a lo largo de los ejes, horizontales o verticales,
podrían no ser únicos. Por ejemplo, en este ejemplo, vemos dos registros de compra para la Tienda 1
como filas diferentes. Si usamos un solo valor con el atributo de bloqueo DataFrame, retornarán varias
filas del DataFrame, no como una nueva serie, sino como un nuevo DataFrame. Por ejemplo, si
consultamos los registros de la Tienda 1, vemos que Chris y Kevin compran en la misma tienda de
suministros para mascotas. Uno de los poderes del DataFrame de Panda es que puede seleccionar
rápidamente datos basados en múltiples ejes. Por ejemplo, si solo quisiera enumerar los costos de la
Tienda 1, proporcionaría dos parámetros a .log, uno es el índice de la fila y el otro el nombre de la
columna. Si solo estamos interesados en los costos de la Tienda 1, podríamos escribir esto como df.lock
('Tienda 1', 'Costo'). ¿Qué sucede si solo quisiéramos seleccionar columnas y obtener una lista de todos
los costos? Bueno, hay un par de opciones. Primero, puede obtener una transposición del DataFrame,
utilizando el atributo T mayúscula, que intercambia todas las columnas y filas. Esto esencialmente
convierte los nombres de sus columnas en índices. Y luego podemos usar el método .lock. Esto funciona,
pero es bastante feo. Como iloc y loc se usan para la selección de filas, los desarrolladores de Panda
reservaron el operador de indexación directamente en el DataFrame para la selección de columnas. En
un DataFrame de Panda, las columnas siempre tienen un nombre. Por lo tanto, esta selección siempre
se basa en etiquetas, no es tan confusa como cuando se usa el operador de corchetes en los objetos de
la serie. Para aquellos familiarizados con las bases de datos relacionales, este operador es análogo a la
proyección de columna. Finalmente, como resultado del uso de los operadores de indexación, el
DataFrame o la serie, puede encadenar las operaciones juntas. Por ejemplo, podríamos haber reescrito
la consulta para todos los costos de la Tienda 1 como df.loc ('Tienda 1', 'Costo'). Esto parece bastante
razonable y nos da el resultado que queríamos. Pero encadenar puede tener algunos costos y es mejor
evitarlo si puede usar otro enfoque. En particular, el encadenamiento tiende a hacer que Pandas
devuelva una copia del DataFrame en lugar de una vista en el DataFrame. Para seleccionar un dato, esto
no es un gran problema, aunque podría ser más lento de lo necesario. Sin embargo, si está cambiando
datos, esta es una distinción importante y puede ser una fuente de error. Aquí hay otro método. Como
vimos, .loc hace la selección de fila, y puede tomar dos parámetros, el índice de fila y la lista de nombres
de columna. .loc también es compatible con el corte. Si quisiéramos seleccionar todas las filas, podemos
usar una columna para indicar un segmento completo de principio a fin. Y luego agregue el nombre de
la columna como el segundo parámetro como una cadena. De hecho, si quisiéramos incluir columnas de
multiplicación, podríamos hacerlo en una lista. Y Pandas traerá de vuelta solo las columnas que hemos
pedido. Aquí hay un ejemplo, donde pedimos todos los valores de nombre y costo para todas las tiendas
que usan el operador .loc. Entonces eso es seleccionar y proyectar datos de un DataFrame basado en
etiquetas de fila y columna. Los conceptos clave para recordar son que las filas y columnas son
realmente solo para nuestro beneficio. Debajo de esto hay solo una matriz etiquetada de dos ejes, y la
transposición de las columnas es fácil. Además, considere el tema de encadenar cuidadosamente e
intente evitarlo, ya que puede causar resultados impredecibles. Donde su intención era obtener una
vista de los datos, pero Pandas le devuelve una copia. En el mundo de los Panda, los amigos no dejan
7
que los amigos encadenen llamadas. Entonces, si lo ve, indíquelo y comparta una solución menos
ambigua. Ahora, antes de dejar la discusión sobre el acceso a los datos en DataFrames, hablemos sobre
la caída de datos. Es fácil eliminar datos en series y marcos de datos, y podemos usar la función de soltar
para hacerlo. Esta función toma un solo parámetro, que es el índice o la etiqueta del rollo, para soltar.
Este es otro lugar complicado para que los nuevos usuarios completen esto. La función soltar no cambia
el DataFrame por defecto. Y, en cambio, le devuelve una copia del DataFrame con las filas dadas
eliminadas. Podemos ver que nuestro DataFrame original todavía está intacto. Hagamos una copia con
el método de copia y hagamos una gota en su lugar. Este es un patrón muy típico en Pandas, donde los
cambios en el lugar a un DataFrame solo se realizan si es necesario, generalmente en cambios que
involucran índices. Por lo tanto, es importante tener en cuenta. Drop tiene dos parámetros opcionales
interesantes. El primero se llama en su lugar, y si se establece en verdadero, el DataFrame se actualizará
en su lugar, en lugar de que se devuelva una copia. El segundo parámetro son los ejes, que deben
descartarse. Por defecto, este valor es 0, lo que indica los ejes de la fila. Pero puede cambiarlo a 1 si
desea soltar una columna. Sin embargo, hay una segunda forma de soltar una columna. Y eso es
directamente a través del uso del operador de indexación, usando la palabra clave del. Sin embargo,
esta forma de descartar datos tiene efecto inmediato en el DataFrame y no devuelve una vista.
Finalmente, agregar una nueva columna al DataFrame es tan fácil como asignarlo a algún valor. Por
ejemplo, si quisiéramos agregar una nueva ubicación como una columna con el valor predeterminado
de none, podríamos hacerlo utilizando el operador de asignación después de los corchetes. Esto
transmite el valor predeterminado a la nueva columna de inmediato.
05. DataFrame Indexind and Loading
El flujo de trabajo común es leer tus datos dentro del dataframe luego reducir este dataframe en
columnas particulares o filas con las que estés interesado en trabajar. Asi como ves, el kit de
herramientas de pandas intenta darte vistas de un dataframe Esto es mucho mas rápido que estar
copiando datos y mucho mas eficiente en el uso de la memoria también. Pero esto significa que si estas
manipulando los datos tienes que ser consciente de que cualquier cambio en el dataframe con el que
estas trabajando puede tener un impacto en la base del dataframe que usaste originalmente. Aquí hay
un ejemplo usando nuestro mismo dataframe de compras de antes. Podemos crear una series basada
solo en la categoría de costo usando los corchetes. Luego podemos incrementar los costos en esta series
usando la transmisión. Ahora si nos fijamos en nuestro dataframe original, vemos que esos costos han
aumentado también. Esta es una importante consideración a tener en cuenta. Si quieres explícitamente
usar una copia, entonces deberías considerar para esto primero llamar al método copy en el dataframe.
En este curso, estarás en gran parte usando pequeños, moderados tamaños de conjunto de datos. Como
he dicho, Un flujo común de trabajo es leer el dataset usualmente desde dentro de algunos archivos
externos. Vimos previamente como puedes hacer esto usando Python, con listas y diccionarios.
Podemos imaginar como puedes usar estos diccionarios para crear un Pandas dataframe.
Afortunadamente, Pandas ha incorporado soporte para archivos delimitados tal como archivos CSV al
igual que una variedad de otros formatos de datos incluyendo bases de datos relacionales, Excel, y tablas
HTML. Tengo guardado un archivo CSV llamado olympics.csv, el cual tiene datos sacados de wikipedia
que contienen un lista de resumen de las medallas de varias ciudades que han ganado en los juegos
olimpicos. Podemos echar un vistazo a estos archivos usando el comando shell cat. El cual podemos
invocar directamente usando el signo de exclamación. Lo que sucede aquí es que cuando Jupyter
notebook ve una linea que comienza con un signo de exclamación, envía el resto de la linea al shell del
sistema operativo para Feedback
sobre el rendimiento. Ademas cat trabaja sobre Linux y Macs, al igual que en la plataforma de Coursera,
pero podría no trabajar en Windows No tienes que preocuparte mucho por esto. Solo buscaba mostrar
como Jupyter notebook se puede integrar con el sistema operativo para proveerte con incluso mas
herramientas para mirar tus datos. Vemos que desde la salida cat parece ser una lista numérica de
columnas seguidas por un manojo de columnas de identificadores. El identificador de columna tiene
algunos caracteres de aspecto extraño en ellos. Esto es el signo del numero unicode, el cual significa
8
numero de. Luego tenemos filas de datos, todos separados en columnas. Podemos leer esto dentro de
un dataframe mediante el llamado de la función read_csv. Cuando observamos el dataframe, vemos que
la primera celda tiene un NaN dentro de ella ya que esto es un valor vacío, y las filas se han indexado
automáticamente para nosotros. Parece claro que la primera fila de los datos del dataframe es la que
realmente queremos ver como los nombres de las columnas. También parece que la primera columna
de los datos es el nombre de las ciudades, las cuales nos gastaría tener como indices. read_csv tiene un
numero de parámetros que podemos usar para indicar a Pandas como las filas y las columnas deberían
estar etiquetadas. Por ejemplo, podemos usar la llamada de los indices para indicar cual columna
debería ser el indice y podemos ademas usar el parámetro de cabecera para indicar cual fila desde el
archivo de datos debería ser usada como la cabecera. Volvamos a importar esos datos y centrar el valor
de los indices para que sea 0 la cual es la primera columna y permite configurar un encabezado de
columna para leer desde la segunda fila de datos. Podemos hacer esto usando el parámetro skiprows,
para decir a Pandas que ignore la primera fila, la cual estaba compuesta por nombres numéricos de
columnas. Ahora estos datos provienen de la tabla de medallas de todos los juegos olímpicos en
Wikipedia. Si nos dirigimos a la página, podríamos ver que en lugar de oro, plata y bronce en la pagina,
estos pequeños iconos con un uno, un dos y un tres en ellos. En nuestro archivo csv estos fueron
representados con las cadenas 01! 02!, y asi sucesivamente. Podemos ver que los valores de las
columnas estan repetidos lo cual realmente no es una buena practica. Pandas reconoce esto en un
panda.1 y .2 para hacer las cosas únicas. Pero este etiquetado no es realmente tan claro como podría
ser, por lo que debemos limpiar el archivo de datos. Por supuesto, podemos hacerlo simplemente yendo
y editando el archivo CSV directamente, pero podemos también establecer los nombres de las columnas
usando las propiedades de los nombres de Pandas. Panda almacena una lista de todas las columnas en
el atributo .columns. Podemos cambiar los valores de los nombres de las columnas mediante la iteración
sobre esta lista y llamando al método rename del dataframe. Ahora, voy a copiar y pegar esto para
acelerar las cosas pero podemos pasar a través de lo que esta pasando aquí. Aquí solo iteramos a través
de todas las columnas buscando ver si empiezan con 01,02,03 o un caracter numérico. Si lo hacen,
podemos llamar a rename y establecer los parámetros de columna como un diccionario siendo las
claves las columnas que queremos reemplazar y los valores siendo los nuevos valores que queremos.
Aquí cortaremos algunos de los antiguos valores en dos, ya que no queremos perder los valores únicos
anexados. También estableceremos el importante parámetro inplace como verdadero, ademas Pandas
sabe actualizar este dataframe directamente. De acuerdo, eso es más sobre el dataframe con un enfoque
en el flujo de trabajo incluso obtener datos en y dentro de un lugar donde podríamos querer
consultarlos.
06. Queryng a DataFrame
Antes de hablar sobre cómo consultar dataframes, necesitamos hablar sobre el enmascaramiento
booleano. El enmascaramiento booleano es el corazón de las consultas rápidas y eficientes en Numpy.
Es un poco análogo al enmascaramiento utilizado en otras áreas computacionales. Una máscara
booleana es una matriz que puede ser de una dimensión como una series, o dos dimensiones como un
dataframe, donde cada uno de los valores de la matriz es verdadero o falso. Esta matriz se superpone
esencialmente sobre la estructura de datos que estamos consultando. Y cualquier celda alineada con el
valor verdadero sera admitida en nuestro resultado final, y cualquier signo alineado con un valor falso
no sera admitido. El enmascaramiento booleano es poderoso conceptualmente y es la piedra angular
de las consultas eficientes de NumPy y Pandas. Esta técnica es bien usada en otras areas de la ciencia
de la computación, por ejemplo en gráficos. Pero esto en realidad no tiene un análogo en otras bases de
datos relacionales tradicionales, por lo que creo que vale la pena señalarlo aquí. Las máscaras booleanas
se crean aplicando operadores directamente a la serie de pandas o objetos dataframe. Por ejemplo, en
nuestro conjunto de datos de los juegos olímpicos, puedes estar interesado en ver solo aquellos países
que han alcanzado una medalla de oro en las olimpiadas de verano. Para construir una mascara
booleana para esta consulta, resalta la columna de Gold usando el operador de indexación y aplique el
operador "mayor que" para una comparación con el valor cero. Este es esencialmente una transmisión

9
de un operador de comparación, mayor que, con el resultado siendo retornado como una series
booleana. La series resultante es indexada donde el valor de cada celda es ya sea verdadero o
falso,dependiendo de si un país ha ganado al menos una medalla de oro, y el index es el nombre de la
ciudad. Por tanto esto nos construye la máscara booleana, que es la mitad de la batalla. Lo que queremos
hacer a continuación es superponer esa máscara sobre el dataframe. Podemos hacer esto usando la
función where La función where toma una mascara booleana como una condición, lo aplica al dataframe
o a la series, y retorna una nuevo dataframe o series de la misma forma. Apliquemos esta máscara
booleana a nuestros datos de las Olimpiadas y creemos un dataframe de solo aquellos países que han
ganado una medalla de oro en los juegos de verano. Vemos que el dataframe resultante mantiene los
valores indexados originales, y solo se conservan los datos de los países que cumplen con la condición.
Todos los países que no cumplieron con la condición tienen el dato NaN en su lugar Está bien. La
mayoría de las funciones estadísticas integradas en el objeto dataframe ignoran los valores de NaN. Por
ejemplo, si llamamos al df.count en el dataframe only_gold, vemos que hay 100 paises que han ganado
medallas de oro en los juegos de verano, mientras que si llamamos count en el original dataframe, vemos
que hay 147 países en total. A menudo queremos eliminar esas filas que no tienen datos. Para hacer
esto, podemos usar la función dropna(). Puedes opcionalmente proveer a dropna los ejes que debería
considerar. Recuerda que los ejes son solo un indicador para las columnas o filas y y que por defecto es
cero, lo que significa filas. Cuando te encuentras hablando de pandas y diciendo frases como, a menudo
quiero, es muy probable que los desarrolladores hayan incluido un atajo para estas operaciones
comunes. Por ejemplo, en este ejemplo en la actualidad no tenemos que usar la función where
explícitamente. Los desarrolladores de pandas permiten al operador de indexación tomar una mascara
booleana como un valor en lugar de solo una lista de nombres de columnas. La sintaxis puede parecer
un poco desordenada, especialmente si no estás acostumbrado a programar lenguajes con operadores
sobrecargados, pero el resultado es que puede filtrar y reducir los dataframes con relativa rapidez. Aquí
hay un ejemplo más conciso de cómo podríamos consultar este dataframe. Notará que no hay NaNs
cuando consulta el dataframe de esta manera. pandas automáticamente filtra las salidas de las filas con
valores de ahora. Una cosa más a tener en cuenta si no estás acostumbrado al enmascaramiento
booleano o de bits para reducción de datos. La salida de dos enmascaramientos booleanos que se
comparan con operadores lógicos es otra máscara booleana. Esto significa que puede encadenar juntas
un montón de declaraciones and/or para crear consultas más complejas, y el resultado es una sola
máscara booleana. Por ejemplo, podríamos crear una mascara para todos aquellos países que han
recibido un oro en las Olimpiadas de verano y lógicamente ordenar eso con todos aquellos países que
han recibido un oro en los Juegos Olímpicos de invierno. Si aplicamos esto al dataframe y usamos la
función len para ver cuantas filas hay, vemos que hay 101 países que han ganado una medalla de oro al
mismo tiempo. Otro ejemplo para divertirnos. ¿Ha habido algún país que solo haya ganado un oro en
los Juegos Olímpicos de invierno y nunca en los Juegos Olímpicos de verano? Aquí hay una forma de
responder a eso. Pobre Liechtenstein. Afortunadamente los Juegos Olímpicos vienen cada cuatro años.
Sé a quién animaré en 2020 para ganar su primer oro de verano. Extremadamente importante, y con
frecuencia un problema para los nuevos usuarios, es recordar que cada mascara booleana necesita ser
encerrada en paréntesis debido al orden de las operaciones. Esto puede causar un sinfín de
frustraciones si no estás acostumbrado a eso, así que ten cuidado. En esta conferencia, echamos un
vistazo al enmascaramiento booleano. No teníamos mucho código para escribir, pero aplicar máscaras
a dataframes es realmente el núcleo del flujo de trabajo de pandas y vale la pena practicar.
07. Indexing Dataframes
Como hemos visto, tanto las series como los dataframes pueden tener indices aplicados a ellos. El index
es esencialmente una etiqueta de nivel de fila y sabemos que las filas corresponden al eje cero. En
nuestros datos de las olimpiadas, indexamos los dataframes por medio de los nombres de los países.
Los índices pueden también inferirse, como cuando creamos una nueva series sin un index, en cual caso
obtenemos valores numéricos, o se pueden establecer explícitamente, como cuando usamos el objeto
diccionario para crear las series, o cuando cargamos datos desde los archivos CSV y especificamos las

10
cabeceras. Otra opción para establecer un índice es usar la función set_index. Esta función toma una
lista de columnas y promueve esas columnas a un index. Establecer index es un proceso destructivo, no
mantiene el índice actual. Si quieres mantener el index actual, necesita crear manualmente una nueva
columna y copiar en ella los valores desde el atributo index. Regresemos a nuestro dataframe de las
olimpiadas. Digamos que no queremos indexar el DataFrame por países, si no en su lugar, queremos
indexar por el número de medallas de oro que se ganaron en los juegos de verano. Primero necesitamos
preservar la información de los países en una nueva columna. Podemos hacer esto usando los
operadores de indexación o el string que tiene la etiqueta de columna. Luego podemos usar el set_index
para establecer como índice la columna de los que ganaron la medalla de oro en verano. Verá que
cuando creamos un nuevo índice a partir de una columna existente, parece que se ha agregado una
nueva primera fila con valores vacíos. Esto no es exactamente lo que está pasando. Y esto lo sabemos
en parte porque realmente se representa un valor vacío como none o NaN si el tipo de dato de la
columna es numérico. Lo que realmente sucedió es que el índice tiene un nombre. Cualquiera que haya
sido el nombre de la columna en el cuaderno de Júpiter acaba de proporcionar esto en la salida.
Podemos eliminar el índice completamente llamando a la función reset_index. Esto promueve el índice
en una columna y crea un índice numerado predeterminado. Una buena característica de pandas es que
tiene la opción para hacer indexación multinivel. Esto es similar a las claves compuestas en sistemas de
base de datos relacionales. Para crear un indice multinivel, simplemente llamamos a set_index y le
damos una lista de columnas que nos interesa promover a un indice. Pandas buscará a través de estas
en orden, encontrando los distintos datos y formando indices compuestos. Un buen ejemplo de esto se
encuentra a menudo cuando se trata con datos geográficos que estan ordenados por regiones o datos
demográficos. Cambiemos los conjuntos de datos y veamos algunos datos del censo para ver un mejor
ejemplo. Estos datos estan almacenados en el archivo census.csv y provienen de la oficina del censo de
los Estados Unidos. En concreto, este es un desglose de los datos de nivel de población a nivel de
condado de EE. UU. Esto es un mejor ejemplo de como diferentes tipos de conjunto de datos pueden ser
formateados cuando estas intentando limpiarlos. Por ejemplo, en este conjunto de datos hay dos niveles
resumidos, Una que contiene datos resumidos para todo el país. y uno que contiene datos resumidos
para cada estado, y uno que contiene datos resumidos para cada condado. A menudo encuentro que
quiero ver una lista de todos los valores únicos en una columna dada. En este dataframe, podemos ver
que los posibles valores para SUMLEV estan usando la función unique en el dataframe Esto es similar
al operador distinct de SQL. Aquí podemos ejecutar unique sobre la SUMLEV de nuestro dataframe
actual y ver que hay solo dos valores diferentes, 40 y 50. Vamos a deshacernos de todas las filas que son
resúmenes a nivel de estado y solo conservemos los datos de condado. Ademas mientras este conjunto
de datos es interesante por un numero diferente de razones, reduzcamos los datos que vamos a analizar
solo a las estimaciones de la población total y al numero total de nacimientos. Podemos hacerlo creando
una lista de nombres de columnas que queremos conservar luego proyectarlo y asignar el DataFrame
resultante a nuestra variable df. Los datos del Censo de los Estados Unidos desglosan las estimaciones
de los datos de población por estado y condado. Podemos cargar los datos y establecer el índice para
que sea una combinación de valores de estado y de condado y ver como pandas lo maneja en un
dataframe. Lo hacemos creando una lista de los identificadores de columna que queremos tener
indexado. Y luego, llamando a set_index con esta lista y asignando el resultado según corresponda.
Podemos ver aquí que tenemos un indice dual, primero el nombre del estado y luego el nombre del
condado. Una pregunta inmediata que surge es ¿cómo podemos consultar este DataFrame? Por ejemplo,
vimos anteriormente que el atributo loc del dataframe puede tomar múltiples argumentos. Y podría
consultar tanto la fila como las columnas. Cuando usas indices múltiples, debes proporcionar los
argumentos en orden por el nivel que desea consultar. Dentro del indice, cada columna es llamada nivel
y la columna más externa es el nivel cero. Por ejemplo, si queremos ver los resultados de la población
del condado de Washtenaw, que es donde vivo, querría el primer argumento como el estado de
Michigan. Podrías estar interesado simplemente en comparar dos condados. Por ejemplo, Washtenaw
donde vivo y el condado de Wayne que cubre Detroit. Para hacer esto, podemos pasar el método loc,
una lista de tuplas que describen los índices que deseamos consultar. Ya que tenemos un indice
multinivel de dos valores, el estado y el condado, necesitamos proporcionar dos valores como cada
11
elemento de nuestra lista de filtrado. Bien, así es como funcionan los índices jerárquicos en pocas
palabras. Hay una parte especial de la biblioteca de pandas que creo que puede facilitar la gestión y el
razonamiento sobre los datos. Por supuesto, el etiquetado jerárquico no es solo para filas. Por ejemplo,
puedes transponer esta matriz y ahora tener etiquetas de columnas jerárquicas. Y proyectando una sola
columna que tiene estas etiquetas funciona exactamente de la manera que se esperaría.
Week 03 - Pandas Python Avanzado
1. Merging DataFrames
La semana pasada, nos presentaron a la biblioteca de análisis y manipulación de datos de pandas. Vimos
que realmente hay estructuras de datos de dos núcleos que son muy similares, el objeto de serie
unidimensional y el objeto de marco de datos bidimensional. La consulta de estas dos estructuras de
datos se realiza de diferentes maneras, como el uso de los atributos iloc o loc para consultas basadas en
filas, o el uso de corchetes en el propio objeto para consultas basadas en columnas. Lo más importante,
vimos que uno puede consultar los objetos DataFrame y Series a través del enmascaramiento booleano.
Y el enmascaramiento booleano es un poderoso método de filtrado que nos permite usar la transmisión
para determinar qué datos deben mantenerse en nuestro análisis. En la conferencia de esta semana,
vamos a entrar en más detalles sobre cómo manipular DataFrame, en particular. Vamos a explorar cómo
reducir y procesar datos usando GroupBy y Apply, y cómo unir conjuntos de datos de múltiples archivos
en uno solo. También hablaremos sobre algunas características que tienen los pandas que son útiles
tanto para los análisis estadísticos tradicionales como para el aprendizaje automático. Comencemos con
cómo combinar conjuntos de datos. Ya hemos visto cómo agregamos nuevos datos a un DataFrame
existente. Simplemente utilizamos el operador de corchetes con el nuevo nombre de columna, y los
datos se agregan siempre que se comparta un índice. Si no hay un índice compartido y se pasa un valor
escalar, recuerde que un valor escalar es solo un valor único como un entero o una cadena. La nueva
columna de valor se agrega con el valor escalar como valor predeterminado. ¿Qué pasa si quisiéramos
asignar un valor diferente para cada fila? Bueno, se vuelve más complicado. Si pudiéramos codificar los
valores en una lista, los pandas los descomprimirán y los asignarán a las filas. Pero si la lista que
tenemos no es lo suficientemente larga, entonces no podemos hacer esto, ya que Pandas no sabe dónde
deberían ir los valores faltantes. Aquí hay un ejemplo. Utilizamos el DataFrame de compras en tiendas
de una de nuestras conferencias anteriores, donde el índice es una lista de tiendas y las columnas de
datos de compras en tiendas. Si queremos agregar una nueva columna llamada Fecha al DataFrame,
está bien. Solo usamos el operador de corchetes directamente en el DataFrame, siempre que la columna
sea tan larga como el resto de los registros. Si queremos agregar algún campo nuevo, puede ser un
indicador de entrega, eso también es fácil ya que es un valor escalar. El problema surge cuando solo
tenemos unos pocos elementos para agregar. Para que esto funcione, debemos proporcionar a los
pandas la lista que es lo suficientemente larga para el DataFrame, de modo que cada fila se pueda
completar. Esto significa que tenemos que ingresar ninguno de los valores nosotros mismos. Si cada
una de nuestras filas tiene un índice único, entonces podríamos asignar el nuevo identificador de
columna a la serie. Por ejemplo, si restablecemos el índice en este ejemplo para que el DataFrame esté
etiquetado del 1 al 2, entonces creamos una nueva serie con estas etiquetas, podemos aplicarlo. Y los
resultados que obtenemos son los que esperábamos. El aspecto interesante de este enfoque es que
podríamos ignorar los elementos que no conocemos y los pandas pondrán valores perdidos para
nosotros. Así que esta es una muy buena manera de hacerlo. Más comúnmente, queremos unir dos
DataFrames más grandes, y esto es un poco más complejo. Antes de saltar al código, necesitamos
abordar un poco de teoría relacional y descifrar algunas convenciones del lenguaje. Este es un diagrama
de Venn. Un diagrama de Venn se usa tradicionalmente para mostrar la membresía establecida. Por
ejemplo, el círculo de la izquierda es la población de estudiantes en una universidad. El círculo de la
derecha es la población del personal de una universidad. Y la región superpuesta en el medio son todos
aquellos estudiantes que también son personal. Tal vez estos estudiantes ejecutan tutoriales para un
curso, o asignan calificaciones, o participan en la realización de experimentos de investigación.
Podríamos pensar en estas dos poblaciones como índices en marcos de datos separados, tal vez con la
12
etiqueta de Nombre de persona. Cuando queremos unir los DataFrames, tenemos que tomar algunas
decisiones. Primero, ¿qué pasa si queremos una lista de todas las personas, independientemente de si
son personal o estudiantes, y toda la información que podemos obtener sobre ellas? En la terminología
de la base de datos, esto se llama una unión externa completa. Y en teoría de conjuntos, se llama unión.
En el diagrama de Venn, representa a todos en cualquier círculo.Sin embargo, es muy posible que solo
queramos aquellas personas para quienes tenemos la máxima información, aquellas personas que son
tanto personal como estudiantes. En la terminología de la base de datos, esto se denomina unión
interna. O en teoría de conjuntos, la intersección. Y esto se representa en el diagrama de Venn como las
partes superpuestas de cada círculo. Bien, veamos un ejemplo de cómo haríamos esto en pandas, donde
usaríamos la función de fusión. Primero creamos dos DataFrames, personal y estudiantes. Hay cierta
superposición en estos marcos de datos, en el sentido de que James y Sally son estudiantes y personal,
pero Mike y Kelly no. Es importante destacar que ambos DataFrames están indexados a lo largo del
valor en el que queremos fusionarlos, que se llama Nombre. Si queremos la unión de estos, llamaríamos
a merge pasando en el DataFrame a la izquierda y el DataFrame a la derecha, y diciéndole a merge que
queremos que use una unión externa. Le decimos a fusionar que queremos usar los índices izquierdo y
derecho como columnas de unión. Vemos en el DataFrame resultante que todos están en la lista. Y dado
que Mike no tiene un rol y John no tiene una escuela, esas celdas se enumeran como valores faltantes.
Si quisiéramos obtener la intersección, es decir, solo aquellos estudiantes que también son personal,
podríamos establecer el atributo how en interno. Y establecemos que el DataFrame resultante solo tiene
a James y Sally. Ahora hay otros dos casos de uso comunes al combinar DataFrames. Ambos son
ejemplos de lo que llamaríamos suma de conjuntos. La primera es cuando nos gustaría obtener una lista
de todo el personal, independientemente de si eran estudiantes o no. Pero si fueran estudiantes,
también querríamos obtener los detalles de sus estudiantes. Para hacer esto, usaríamos una
combinación izquierda. Probablemente puedas adivinar lo que viene después. Queremos una lista de
todos los estudiantes y sus roles si también fueran miembros del personal. Para hacer esto, haríamos
una unión correcta. El método de fusión tiene un par de otros parámetros interesantes. Primero, no
necesita usar índices para unirse, también puede usar columnas. Aquí hay un ejemplo. Entonces, ¿qué
sucede cuando tenemos conflictos entre los marcos de datos? Echemos un vistazo creando nuevos
marcos de datos de personal y estudiantes que tengan una información de ubicación agregada. En el
DataFrame del personal, esta es una ubicación de oficina donde podemos encontrar a la persona del
personal. Y podemos ver que el Director de Recursos Humanos está en State Street, mientras que los
dos estudiantes están en Washington Avenue. Pero para el DataFrame del estudiante, la información de
ubicación es en realidad su domicilio. La función de fusión conserva esta información, pero agrega un
_x o _y para ayudar a diferenciar entre qué índice fue con qué columna de datos. El _x es siempre la
información de DataFrame izquierda, y el _ y es siempre la información de DataFrame correcta. Y puede
controlar los nombres de _x y _y con parámetros adicionales si lo desea. Ahora lo intentas. Aquí hay un
DataFrame de productos y facturas. El producto tiene un identificador y un precio de etiqueta. La factura
enumera las personas, productos, identificadores y cantidad. Suponiendo que queremos generar
totales, ¿cómo unimos estos dos DataFrames para que tengamos uno que enumere toda la información
que necesitamos? Antes de dejar la fusión de DataFrames, hablemos sobre la indexación múltiple y las
columnas múltiples. Es muy posible que el nombre de los estudiantes y el personal se superpongan,
pero el apellido no. En este caso, utilizamos una lista de las múltiples columnas que se deben usar para
unir claves en los parámetros left_on y right_on. Como puede ver aquí, James Wilde y James Hammond
no coinciden en ambas teclas. Por lo tanto, la unión interna no incluye a estos individuos en la salida, y
solo se retiene Sally Brooks. Eso es todo por la fusión de DataFrames. pandas tiene muchas más
opciones en el área, pero creo que la función de fusión es quizás la más fácil de entender y la más flexible.
En la siguiente sección, vamos a hablar sobre cómo escribir pandas idiomáticos y profundizar un poco
más en funciones más avanzadas para manipular DataFrames.
2. Idiomatic Python

13
Los programadores de Python a menudo sugieren que hay muchas formas en que el lenguaje puede
usarse para resolver un problema en particular. Pero que algunos son más apropiados que otros. Las
mejores soluciones se celebran como Idiomatic Python y hay muchos ejemplos excelentes de esto en el
desbordamiento de pila y en los sitios web. Una solución idiomática es a menudo una que tiene alto
rendimiento y alta legibilidad. Esto no es necesariamente cierto. Una especie de sub-lenguaje dentro de
Python, Pandas tiene su propio conjunto de expresiones idiomáticas. Ya hemos aludido a algunos de
estos, como usar la vectorización siempre que sea posible y no usar bucles iterativos si no es necesario.
Varios desarrolladores y usuarios dentro de la comunidad de Panda han usado el término pandorable
para estos modismos. Creo que es un gran término. Entonces, quería compartir con ustedes un par de
características clave sobre cómo hacer que su código sea pandorable. El primero de ellos se llama
método de encadenamiento. Ahora vimos que anteriormente, podría encadenar llamadas de pandas
cuando consulta DataFrames. Por ejemplo, si desea seleccionar filas en función del índice, como el
nombre del condado. Entonces solo quería proyectar ciertas columnas como la población total, puede
escribir una consulta, como df.loc [“Washtenaw”] [“Población total”] Esta es una forma de
encadenamiento, llamada indexación en cadena. Y generalmente es una mala práctica. Debido a que es
posible que los pandas puedan devolver una copia o una vista del DataFrame dependiendo de la
biblioteca NumPy subyacente. En sus descripciones del idiomático desarrollador de patrones de
Pandas, Tom Osberger describió una regla general para esto. Si ve corchetes consecutivos, debe pensar
detenidamente si desea realizar una indexación en cadena. Creo que esto es genial como una especie de
código de olor o anti patrón. Sin embargo, el método de encadenamiento es un poco diferente. La idea
general detrás del encadenamiento de métodos es que cada método en un objeto devuelve una
referencia a ese objeto. La belleza de esto es que puede condensar muchas operaciones diferentes en
un DataFrame, por ejemplo, en una línea o al menos una declaración de código. Aquí hay un ejemplo de
dos piezas de código en pandas usando nuestros datos del censo. La primera es la forma pandorable de
escribir el código con el método de encadenamiento. En este código, no se está utilizando un indicador
en el lugar y puede verlo cuando ejecutamos por primera vez una consulta where, luego una dropna,
luego un set_index y luego un cambio de nombre. Quizás se pregunte por qué toda la declaración está
encerrada entre paréntesis y eso es solo para que la declaración sea más legible. En Python, si comienza
con un paréntesis abierto, puede abarcar una declaración en varias líneas y las cosas se leerán un poco
mejor. El segundo ejemplo es una forma más tradicional de escribir código. No hay nada de malo en este
código en el sentido funcional, incluso podría entenderlo mejor como una persona nueva en el idioma.
Simplemente no es tan pandorable como el primer ejemplo. Ahora, la clave con cualquier buen lenguaje
es entender cuándo no te está ayudando. En este caso, puede cronometrar ambos métodos y ver que el
último método es más rápido. Por lo tanto, este es un ejemplo particular de un equilibrio clásico de
legibilidad en el tiempo. Verá muchos ejemplos sobre el desbordamiento de existencias y en la
documentación de personas que utilizan el método de encadenamiento en sus pandas. Por lo tanto, creo
que poder leer y comprender la sintaxis realmente vale la pena. Aquí hay otro idioma de pandas. Python
tiene una función maravillosa llamada mapa, que es una especie de base para la programación funcional
en el lenguaje. Cuando desea utilizar el mapa en Python, le pasa alguna función a la que desea llamar y
otra iterable, como una lista, a la que desea que se aplique la función. Los resultados son que la función
se llama a cada elemento de la lista, y hay una lista resultante de todas las evaluaciones de esa función.
Python tiene una función similar llamada applymap. En applymap, proporciona alguna función que
debe operar en cada celda de un DataFrame, y el conjunto de retorno es en sí mismo un DataFrame.
Ahora creo que applymap está bien, pero en realidad rara vez lo uso. En cambio, a menudo me encuentro
con ganas de mapear todas las filas en un DataFrame. Y pandas tiene una función que uso mucho allí,
llamada aplicar. Veamos un ejemplo. Tomemos nuestro Marco de datos del censo. En este DataFrame,
tenemos cinco columnas para estimaciones de población. Cada columna corresponde a un año de
estimaciones. Es bastante razonable querer crear algunas columnas nuevas para valores mínimos o
máximos, y la función de aplicación es una manera fácil de hacerlo. Primero, necesitamos escribir una
función que tome una fila particular de datos, encuentre valores mínimos y máximos, y devuelva una
nueva fila de datos. Llamaremos a esta función min_max, esto es bastante sencillo. Podemos crear una
pequeña porción de fila proyectando las columnas de población. Luego use las funciones mín. Y máx. De
14
NumPy, y cree una nueva serie con una etiqueta. Los valores representan los nuevos valores que
queremos aplicar. Entonces solo necesitamos llamar a apply en el DataFrame. Apply toma la función y
el eje sobre el cual operar como parámetros. Ahora, debemos ser un poco cuidadosos, hemos hablado
sobre el eje cero como las filas del DataFrame en el pasado. Pero este parámetro es realmente el
parámetro del índice a utilizar. Entonces, para aplicar en todas las filas, pasa un eje igual a uno. Por
supuesto, no hay necesidad de limitarse a devolver un nuevo objeto de serie. Si está haciendo esto como
parte de la limpieza de datos, es probable que desee agregar nuevos datos al DataFrame existente. En
ese caso, simplemente tome los valores de las filas y agregue nuevas columnas que indiquen las
puntuaciones máximas y mínimas. Esta es una parte regular de mi flujo de trabajo al incorporar datos
y crear estadísticas resumidas o descriptivas. Y a menudo se usa mucho con la fusión de DataFrames.
De acuerdo, todo esto es genial, y aplicar es una herramienta extremadamente importante en su kit de
herramientas. Pero no se suponía que esta conferencia fuera sobre las nuevas características de la API,
sino sobre cómo hacer un código que se pueda pagar. La razón por la que introduje el suministro aquí
es porque rara vez se ve que se usa con definiciones de funciones grandes, como lo hicimos nosotros.
En cambio, normalmente lo ves usado con lambdas. Ahora, recordará desde la primera semana de este
curso que saber lambda no es un requisito del curso. Pero para aprovechar al máximo las discusiones
que verá en línea, necesitará saber cómo leer lambdas al menos. Aquí hay un ejemplo de una línea de
cómo podría calcular el máximo de las columnas usando la función de aplicación. Puede imaginar cómo
puede encadenar varias llamadas de aplicación con lambdas juntas para crear un script de
manipulación de datos legible pero sucinto. Así que hay un par de modismos de pandas. Pero creo que
hay muchos más, y no he hablado de ellos aquí. Así que aquí hay una tarea no oficial para ti. Mire algunas
de las preguntas mejor calificadas sobre pandas en Stack Overflow, y vea cómo algunos de los autores
más experimentados responden esas preguntas. ¿Ves algún patrón interesante? Interviene en los foros
de discusión del curso y construyamos juntos algunos documentos que se puedan pagar. Nuestras
próximas conferencias serán sobre funciones grupales y nos vemos luego.
3. Scales
Ahora que hemos cubierto muchas de las mecánicas de Pandas, quiero detenerme y hablar por un
momento sobre los tipos de datos y las escalas. Ya hemos visto que Pandas admite varios tipos de datos
computacionales diferentes, como cadenas, enteros y números de coma flotante. Lo que esto no captura
es lo que llamamos la escala de los datos. Digamos que tenemos un marco de datos de los estudiantes y
sus niveles académicos, como estar en el grado 1 o grado 2 y grado 3. Hay una diferencia entre un
estudiante en el grado 1 y un estudiante en el grado 2, lo mismo que la diferencia entre un estudiante
en el grado 8 y un estudiante en el grado 9. Bueno, pensemos en los puntajes del examen final que estos
estudiantes podrían obtener en las tareas. ¿La diferencia entre una A y una A menos es igual a la
diferencia entre una A menos y una B más? Al menos en la Universidad de Michigan, la respuesta suele
ser no. Hemos visto intuitivamente algunas escalas diferentes, y a medida que avanzamos por la
limpieza de datos y el análisis estadístico y el aprendizaje automático, es importante aclarar nuestro
conocimiento y terminología. Como científico de datos, hay cuatro escalas que vale la pena conocer. El
primero es una escala de razón. En la escala de razón, las unidades de medida están igualmente
espaciadas y las operaciones matemáticas, como restar, dividir y multiplicar, son todas válidas. Buenos
ejemplos de medidas de escala de relación podrían ser la altura y el peso. La siguiente escala es la escala
de intervalo. En la escala de intervalo, las unidades de medida están igualmente espaciadas como la
escala de relación. Pero no hay una clara ausencia de valor. Es decir, no hay un cero verdadero, por lo
que operaciones como la multiplicación y la división no son válidas. Un ejemplo de la escala de intervalo
podría ser la temperatura medida en grados Celsius o Fahrenheit. Dado que nunca hay ausencia de
temperatura y 0 grados es un valor significativo de temperatura. La dirección en un campus podría ser
otro buen ejemplo donde 0 grados en el campus no indican una falta de dirección. Para la mayoría del
trabajo que realiza en la minería de datos, las diferencias entre las escalas de relación e intervalo pueden
no ser claramente aparentes o importantes que el algoritmo que está aplicando. Pero es importante
tener esto en mente cuando aplique pruebas estadísticas avanzadas. La siguiente escala es la escala

15
ordinal, y esto también es importante. En la escala ordinal, el orden de los valores es importante, pero
las diferencias entre los valores no están equidistantes. Aquí hay un método de calificación que se usa
en muchas clases en la Universidad de Michigan como un gran ejemplo, donde las calificaciones en letras
se otorgan con más y menos. Pero cuando compara esto con los valores porcentuales, ve que una letra
por sí sola cubre el 4% de las calificaciones disponibles y que una letra con más o menos suele ser solo
el 4% para las calificaciones disponibles. En base a esto, sería extraño si hubiera tantos estudiantes que
recibieron una A más o A menos que otros que recibieron una A. Los datos ordinarios son muy comunes
en el aprendizaje automático y a veces puede ser un desafío trabajar con ellos. La última escala que
mencionaré es la escala nominal, que a menudo se llama simplemente datos categóricos. Aquí los
nombres de los equipos en un deporte podrían ser un buen ejemplo. Hay un número limitado de
equipos, pero cambiar su orden o jugar una función matemática no tiene sentido. Los valores
categóricos son muy comunes y generalmente nos referimos a categorías donde solo hay dos valores
posibles como binarios. Entonces, ¿por qué dejé de hablar sobre Pandas y me metí en esta discusión
sobre la escala? Bueno, dada la importancia que tienen en estadística y aprendizaje automático, Pandas
tiene una serie de funciones interesantes para tratar la conversión entre escalas de medición.
Comencemos primero con datos nominales, que en Pandas se llaman datos categóricos. En realidad,
Panda tiene un tipo incorporado para datos categóricos y puede establecer una columna de sus datos
en datos categóricos utilizando el método como tipo. Como tipo intenta cambiar el tipo subyacente de
sus datos, en este caso a datos de categoría. Puede cambiar esto aún más a datos ordinales pasando un
indicador ordenado establecido a verdadero y pasando las categorías de manera ordenada. Aquí hay un
ejemplo. Creemos un marco de datos de calificaciones de letras en orden descendente. También
podemos establecer un valor de índice de alguna medida de grano más. Ahora, cuando le indicamos a
Pandas que represente esto como datos categóricos, vemos que el tipo D se ha establecido como
categoría y que hay 11 categorías diferentes. Si queremos indicarle a Pandas que estos datos están en
un orden lógico, pasamos el indicador ordenado igual a verdadero y vemos aquellos reflejados en el tipo
de categoría D usando el signo menor que. ¿Qué puedes hacer con esto? Bueno, los datos ordinales
tienen orden, por lo que pueden ayudarlo con el enmascaramiento booleano. Por ejemplo, si tenemos
nuestra lista de calificaciones y las comparamos con una C. Si hiciéramos esto lexográficamente,
haríamos que una C + y una C- fueran ambas mayores que una C. En lugar de codificar cada una de ellas
en algo que es lexográfico, como un número, podemos indicar que hay un orden claro en los datos. Y
luego la transmisión funcionará como esperamos. Entonces podemos usar un cierto conjunto de
operadores matemáticos como mínimo, máximo y otros en los datos ordinales. A veces es útil
representar valores categóricos ya que cada uno es una columna con un valor verdadero o falso en
cuanto a si esa categoría se aplica. Esto es especialmente común en la extracción de características, que
es un tema en el tercer curso de esta especialización. Las variables con un valor booleano generalmente
se denominan variables ficticias. Y pandas tiene una función incorporada llamada get dummies, que
convertirá los valores de una sola columna en varias columnas de 0 y 1, lo que indica la presencia de
una variable ficticia. Hay una función más en escalas de la que me gustaría hablar. Y eso se trata de
reducir un valor que está en la escala de intervalo o relación, como una calificación numérica, en uno
que sea categórico como una calificación de letra. Ahora, esto puede parecer un poco intuitivo para
usted, ya que está perdiendo información sobre el valor. Pero es útil en un par de lugares. Primero, si
está visualizando las frecuencias de categorías, y este puede ser un enfoque extremadamente útil y los
histogramas se usan regularmente con intervalos convertidos o datos raciales. Y veremos los
histogramas en el segundo curso de esta especialización. En segundo lugar, si está utilizando un enfoque
de clasificación de aprendizaje automático en los datos, entonces debe estar utilizando datos
categóricos. Por lo tanto, reducir la dimensionalidad también es útil allí. Panda dice una función llamada
corte, que toma un argumento que es una estructura real similar a una columna, un marco de datos o
una serie. También se necesitan varios contenedores para utilizarlos y todos se mantienen a la misma
distancia. Volvamos a nuestros datos del censo como ejemplo. Vimos que podríamos agrupar por
estado, luego agregar para obtener una lista del tamaño promedio del condado por estado. Si aplicamos
un corte adicional a esto con, digamos, 10 contenedores, podemos ver que los estados enumerados
como categóricos usan el tamaño promedio del condado. Aquí vemos que estados como Alabama y
16
Alaska caen en la misma categoría, mientras que California y el Distrito de Colombia caen en una
categoría muy diferente. Ahora, cortar es solo una forma de crear categorías a partir de sus datos, y hay
muchos otros métodos. Por ejemplo, cortar le proporciona datos de intervalo, donde el espacio entre
cada categoría es del mismo tamaño. Pero a veces quieres formar categorías basadas en la frecuencia.
Desea que el número de elementos en cada contenedor sea el mismo, en lugar del espacio entre los
contenedores. Realmente depende de la forma de sus datos y de lo que planea hacer con ellos. Y veremos
algunos ejemplos de esto en el curso de gráficos y gráficos para aquellos de ustedes que están inscritos
en la especialización. Eso es todo para este módulo del curso. Hay una tarea de programación para
evaluar su conocimiento del contenido de este módulo y lo veré en el próximo módulo como un resumen
donde hablaremos más sobre estadísticas y estableceremos algunos conceptos básicos para comparar
los resultados del análisis.
4. Pivot tables.
Una tabla dinámica es una forma de resumir datos en un marco de datos para un propósito particular.
Hace un uso intensivo de la función de agregación. Una tabla dinámica es en sí misma un marco de datos,
donde las filas representan una variable que le interesa, las columnas otra y el valor agregado de la
celda. Una tabla dinámica también tiende a incluir valores marginales, que son las sumas para cada
columna y fila. Esto le permite poder ver la relación entre dos variables de un vistazo. Echemos un
vistazo a un ejemplo. Aquí cargaremos un nuevo conjunto de datos, cars.csv. Este conjunto de datos
proviene de la Iniciativa de Datos Abiertos del gobierno canadiense. Y tiene información sobre la
eficiencia de los diferentes autos eléctricos que están disponibles para la compra. Cuando miramos el
encabezado del marco de datos, veremos que hay años de modelo, vendedores, tamaños de automóviles
y estadísticas, como qué tan grande es la batería en kilovatios hora. Una tabla dinámica nos permite
convertir una de estas columnas en nuevos encabezados de columna y compararla con otra columna
como índices de fila. Por ejemplo, digamos que queríamos comparar las marcas de vehículos eléctricos
con los años y que queríamos hacer esta comparación en términos de capacidad de la batería. Para hacer
esto, les decimos a los pandas que queremos que los valores sean kilovatios, que el índice sea el año y
que las columnas sean la marca. Luego especificamos que la función de agregación, y aquí usaremos la
media NumPy. Aquí están los resultados. Vemos que hay valores NaN para proveedores que no tuvieron
una entrada en un año determinado como Ford en 2012. Y vemos que la mayoría de los vendedores no
tienen un cambio en la capacidad de la batería a lo largo de los años, excepto Tesla, ya que ' Hemos
introducido varios modelos nuevos. Ahora, las tablas dinámicas no se limitan a una función que quizás
desee aplicar. Puede pasar aggfunc, una lista de las diferentes funciones a aplicar, y los pandas le
proporcionarán el resultado usando nombres de columnas jerárquicas. Aquí, también pasaré márgenes
igual a verdadero. Y que puede ver para cada una de las funciones, ahora hay una categoría completa,
que muestra la media general y los valores mínimos para un año determinado y un proveedor
determinado. Así que eso es tablas dinámicas. Esta ha sido una descripción bastante corta, pero son
increíblemente útiles cuando se trata de datos numéricos. Y, por supuesto, puede pasar cualquier
función que desee a la función agregada, incluidas las que usted mismo defina.
5. Data Functionality
Bienvenido al tutorial de hoy, donde veremos las series de tiempo y la fecha funcionalmente en pandas.
Pandas tiene cuatro clases relacionadas con el tiempo principal. Marca de tiempo, DatetimeIndex,
Period y PeriodIndex. Primero, echemos un vistazo a Timestamp. La marca de tiempo representa una
única marca de tiempo y asocia valores con puntos en el tiempo. Por ejemplo, creemos una marca de
tiempo usando una cadena 1/9/2016 10:05 AM, y aquí tenemos nuestra marca de tiempo. La marca de
tiempo es intercambiable con la fecha y hora de Python en la mayoría de los casos. Supongamos que no
estuviéramos interesados en un punto específico en el tiempo y, en cambio, quisiéramos un período de
tiempo. Aquí es donde entra en juego el período. El período representa un período de tiempo único,
como un día o mes específico. Aquí estamos creando un período que es enero de 2016, y aquí hay un
ejemplo de un período que es el 5 de marzo de 2016. El índice de una marca de tiempo es DatetimeIndex.

17
Veamos un ejemplo rápido. Primero, creemos nuestra serie de ejemplo t1, usaremos la marca de tiempo
del 1, 2 y 3 de septiembre de 2016. Cuando miramos la serie, cada marca de tiempo es el índice y tiene
un valor asociado, en este caso, un , byc. Mirando el tipo de nuestro índice de serie, vemos que es
DatetimeIndex. Del mismo modo, el índice del período es PeriodIndex. Creemos otra serie de ejemplo
t2. Esta vez, usaremos los valores d, e y f y los igualaremos con el período septiembre, octubre y
noviembre de 2016. Observando el tipo de ts2.index, podemos ver que es PeriodIndex. Ahora, veamos
cómo convertir a Datetime. Supongamos que tenemos una lista de fechas como cadenas. Si creamos un
DataFrame usando estas fechas como índice. Y algunos datos generados al azar, este es el DataFrame
que obtenemos. Mirando el índice podemos ver que es bastante desordenado y las fechas están en
diferentes formatos. Usando pandas to_datetime, los pandas intentarán convertirlos a Datetime y
ponerlos en un formato estándar. to_datetime también tiene opciones para cambiar el orden de análisis
de fecha. Por ejemplo, podemos pasar el argumento dayfirst = True para analizar la fecha en formato de
fecha europea. Timedeltas son diferencias en los tiempos. Podemos ver que cuando tomamos la
diferencia entre el 3 de septiembre y el 1 de septiembre, obtenemos un Timedelta de dos días. También
podemos hacer algo como encontrar la fecha y hora de 12 días y tres horas después del 2 de septiembre
a las 8:10 a.m. A continuación, veamos algunos trucos para trabajar con fechas en un DataFrame.
Supongamos que queremos ver nueve mediciones, tomadas cada dos semanas, todos los domingos, a
partir de octubre de 2016. Usando date_range, podemos crear este DatetimeIndex. Ahora, creemos un
DataFrame usando estas fechas y algunos datos aleatorios, y veamos qué podemos hacer con él.
Primero, podemos verificar qué día de la semana es una fecha específica. Por ejemplo, aquí podemos
ver que todas las fechas en nuestro índice son los domingos. Podemos usar diff para encontrar la
diferencia entre el valor de cada fecha. Supongamos que deseamos saber cuál es el recuento medio de
cada mes en nuestro DataFrame. Podemos hacer esto usando remuestreo. Podemos usar la indexación
parcial de cadenas para encontrar valores de un año en particular, o de un mes en particular, o incluso
podemos dividir en un rango de fechas. Por ejemplo, aquí solo queremos los valores a partir de
diciembre de 2016 en adelante. Otra cosa interesante que podemos hacer es cambiar la frecuencia de
nuestras fechas en nuestro DataFrame usando asfreq. Si usamos esto para cambiar la frecuencia de
quincenal a semanal, terminaremos con valores faltantes cada dos semanas. Así que usemos el método
de relleno directo en esos valores faltantes. Una última cosa que quería mencionar brevemente es trazar
series de tiempo. Importar matplotlib.pyplot, y usar iPython magic% mapplotlib en línea, le permitirá
visualizar las series de tiempo en el cuaderno. En el próximo curso, aprenderemos más sobre cómo
entender y crear visualizaciones. Gracias por mirar, nos vemos la próxima vez.
Week 4 – Proyecto de Análisis estadístico en Python
01. Introduction.
Bienvenidos a la cuarta semana del curso. Hasta este punto, hemos hablado a nivel de habilidades. En
la primera semana, hablamos sobre el uso de Python para interactuar y procesar datos. En la semana
dos, presentamos la biblioteca de pandas y datos tabulares en forma de Series y Dataframes. En la
semana tres, profundizamos nuestro conocimiento sobre cómo usar pandas agrupando datos,
aplicando funciones, y uniendo conjunto de datos. En la cuarta semana del curso, queremos presentar
el proyecto del curso, que pondrá a prueba su capacidad de utilizar las habilidades que desarrolló en
las semanas una a tres. El objetivo de este proyecto es ayudarte a practicar no solo esas habilidades
sino comenzar a construir una cartera de problemas de ciencia de datos del mundo real, que puede
usar para demostrar su capacidad de adquirir, manipular, limpiar y ejecutar análisis de datos básicos.
Sin embargo, antes de llegar al proyecto, quiero dejar en tu mente algunos conceptos estadísticos que
ayudarán a fundamentar sus estudios adicionales en ciencia de datos. Y tenga en cuenta que este no es
un curso completo de estadísticas de ninguna manera, por lo que Te animo a que revises las muchas
opciones de aprendizaje de estadísticas sobre este plataforma y otras.
02. Distributions.

18
Empecemos con una discusión sobre distribuciones. Y comenzaremos con lo mas común, usando una
moneda. Cuando una moneda es lanzada tiene una probabilidad de caer cara y una probabilidad de caer
cruz. Si lanzamos una moneda muchas veces reunimos un numero de mediciones de caras y cruces que
cayeron boca arriba, e intuitivamente sabemos que el numero de veces que conseguimos caras será
igual aproximadamente al numero de veces que conseguimos cruces, para una monea justa. Si tu
lanzaste una moneda unas cien veces y recibiste caras cada vez, tu probablemente dudarías de la
imparcialidad de esa moneda. Podemos considerar el resultado de cada lanzamiento de esta moneda
como una variable aleatoria. Cuando podemos considerar el conjunto de todas las posibles variables
aleatorias a la vez podemos llamar a esto una distribución. En este caso la distribución se llama binomial
ya que hay dos posibles resultados, una cara o una cruz. Esto también es un ejemplo de una distribución
discreta ya que solo hay categorías siendo usadas, una cara y un sello pero no números reales. NumPy
actualmente tiene algunas distribuciones incorporadas en ella permitiéndonos hacer lanzamientos
aleatorios de una moneda con parámetros dados. Vamos a probarlo. Aquí pedimos un numero de la
distribución binomial de NumPy. Tenemos dos parámetros para pasarle. El primero es el numero de
veces que queremos ejecutarlo. El segundo es la posibilidad de que obtengamos un cero, el cual
utilizaremos para representar las caras aquí. Vamos a ejecutar una ronda de esta simulación. Genial asi
que si sigues el cuaderno de Jupyter, obtienes o un cero o un uno. Y la mitad de ustedes tiene un valor
que concuerda con el que yo tengo. Que pasa si ejecutamos el simulador unas mil veces y dividimos el
resultado por mil. Bueno, se ve un número muy cerca a 0.5 que significa que la mitad de las veces
tuvimos cara y la mitad de las veces tuvimos cruz. Por supuesto, una distribución binomial ponderada
uniforme es solo un ejemplo simple. También podemos tener distribuciones binomiales ponderadas no
uniformes Por ejemplo, cuál es la posibilidad de que hoy estemos en un tornado mientras estoy
filmando. Es bastante baja, incluso aunque tengamos tornados aquí. Así que tal vez hay una centésima
de porcentaje de probabilidad. Podemos poner esto dentro de una distribución binomial como una
ponderación en NumPy. Si ejecutamos esto 100000 veces, vemos que hay eventos de tornado bastante
mínimos. Así que quizás se pregunten por qué estoy hablando de una manera tan simple e intuitiva de
la distribución. Quiero decir que todos entendemos que es lanzar una moneda cuando teníamos que
hacer importantes decisiones de niños. Pero lo que quiero demostrar es que las herramientas
computacionales están comenzando a permitirnos simular el mundo, lo cual nos ayuda a responder
preguntas. Podría haberte mostrado las matemáticas detrás de esto, así que podríamos haber calculado
las probabilidades. Pero una simulación es esencialmente otra forma de indagación. Tomemos otro
ejemplo. Digamos, la probabilidad de un tornado aquí en Ann Arbor en un día cualquiera es 1%,
independientemente de la época del año. Eso es más grande que en la realidad, pero lo hacemos para
una demostración más rápida. Y digamos que si hay un tornado voy a alejarme de las ventanas y
ocultarme, luego volveré y haré mi grabación al día siguiente. Entonces, ¿cuál es la probabilidad de que
esto suceda dos días seguidos? Bien, podemos usar la distribución binomial en NumPy para simular
esto. Aquí creamos una lista vacía y creamos un numero de potenciales eventos de tornado al solicitar
la función binomial NumPy usando nuestra probabilidad de tornado. Haremos esto un millón de veces,
lo que equivale a casi 3.000 años de eventos. Este proceso es denominado muestreo de la distribución.
Ahora podemos escribir un pequeño bucle para ir a través de la lista y buscar cualesquiera dos pares
adyacentes de unos, lo que significa que allí hubo dos días en que sucedieron tornados seguidos. Vemos
que esto termina siendo aproximadamente 96 días de tornados durante los 3,000 años. Que,
francamente, todavía es demasiado para mí. Sin embargo, mi punto aquí es que la potencia
computacional moderna nos permite simular muy rápidamente los efectos de diferentes parámetros en
una distribución. Conduce a una nueva forma de entender el problema. No tienes que calcular todas las
matemáticas, puedes bastante a menudo simular el problema en su lugar y observar los resultados. En
la siguiente clase hablaremos un poco más sobre las distribuciones.
03. More distributions.
Muchas de las distribuciones que usa en la ciencia de datos no son binomiales discretos, y en cambio,
continúan donde el valor de la observación dada no es una categoría como cara o cruz, sino que puede

19
representarse mediante un número real. Es común graficar estas distribuciones cuando se habla de
ellas, donde el eje x es el valor de la observación y el eje y representa la probabilidad de que ocurra una
observación dada. Si todos los números tienen la misma probabilidad de extraerse cuando se muestrea,
se debe representar gráficamente como una línea horizontal plana. Y esta línea plana en realidad se
llama distribución uniforme. Hay algunas otras distribuciones que se vuelven mucho más interesantes.
Tomemos la distribución normal que también se llama distribución gaussiana o, a veces, una curva de
campana. Esta distribución se parece a una joroba donde el número que tiene la mayor probabilidad de
ser dibujado es un cero, y hay dos curvas decrecientes a cada lado del eje X. Una de las propiedades de
esta distribución es que la media es cero, no las dos curvas en ambos lados son simétricas. Quiero
presentarles el término valor esperado. Creo que la mayoría de nosotros estamos familiarizados con la
media es la suma de todos los valores divididos por el número total de valores. El cálculo de los valores
medios es un proceso computacional, y se lleva a cabo al observar las muestras de la distribución. Por
ejemplo, lanzar un dado tres veces podría darte 1, 2 y 6, el valor medio es entonces 4,5. El valor esperado
es que la probabilidad de la distribución subyacente es lo que sería la media de una tirada de dados si
hiciéramos un número infinito de tiradas. El resultado es 3.5 ya que es probable que aparezca cada cara
del dado. Por lo tanto, el valor esperado es 3.5, mientras que el valor medio depende de las muestras
que hemos tomado, y converge con el valor esperado dado un conjunto de muestras suficientemente
grande. Hablaremos más sobre los valores esperados en el curso tres. Una segunda propiedad es que la
varianza de la distribución se puede describir de cierta manera. La varianza es una medida de qué tan
mal se extienden los valores de las muestras de la media. Seamos un poco más formales acerca de cinco
características diferentes de las distribuciones. Primero, podemos hablar sobre la tendencia central de
distribución, y las medidas que usaríamos para esto son moda, mediana o media. Esta característica es
realmente acerca de dónde está la mayor parte de la probabilidad en la distribución. También podemos
hablar sobre la variabilidad en la distribución. Hay un par de maneras en que podemos hablar de esto.
La desviación estándar es uno, el rango intercuartil es otro. La desviación estándar es simplemente una
medida de cuán diferente es cada elemento, en nuestra muestra, de la media. Aquí está la fórmula para
la desviación estándar. Puede parecer un poco más intimidante de lo que realmente es. Veamos cómo
escribiríamos esto. Dibujemos 1,000 muestras de una distribución normal con un valor esperado de
0.75 y una desviación estándar de 1. Luego calculamos la media real usando la función de media de
NumPy. La parte dentro de la suma dice barra xi- x. Xi es el elemento actual en la lista y la barra x es la
media. Entonces calculamos la diferencia, luego cuadramos el resultado, luego sumamos todo esto. Este
podría ser un lugar razonable para usar un mapa y aplicar una lambda para calcular las diferencias
entre la media y el valor medido. Luego, para volver a convertir esto en una lista, NumPy puede usarlo.
Ahora solo tenemos que cuadrar cada valor, sumarlos y sacar la raíz cuadrada. Así que ese es el tamaño
de nuestra desviación estándar. Cubre aproximadamente el 68% del área alrededor de la media,
dividida equitativamente alrededor del lado de la media. Ahora normalmente no tenemos que hacer
todo este trabajo nosotros mismos, pero quería mostrarle cómo puede tomar muestras de la
distribución, crear una descripción programática precisa de una fórmula y aplicarla a sus datos. Pero
para la desviación estándar, que es solo una medida particular de variabilidad, NumPy tiene una función
incorporada que puede aplicar, llamada STD. Hay un par de medidas más de distribución de las que es
interesante hablar. Una de ellas es la forma de los cuentos de la distribución y esto se llama curtosis.
Podemos medir la curtosis usando las funciones estadísticas en el paquete SciPy. Un valor negativo
significa que la curva es ligeramente más plana que una distribución normal, y un valor positivo significa
que la curva es ligeramente más alta que una distribución normal. Recuerde que no estamos midiendo
la curtosis de la distribución per se, sino de los mil valores que tomamos de la distribución. Este es un
subarriendo pero una distinción importante. También podríamos salir de las distribuciones normales
y empujar el pico de la curva de una manera u otra. Y esto se llama sesgo. Si probamos nuestros datos
de muestra actuales, vemos que no hay mucha distorsión. Cambiemos las distribuciones y echemos un
vistazo a una distribución llamada distribución Chi Cuadrada, que también se usa con bastante
frecuencia en estadística. La Distribución Cuadrada Chi tiene solo un parámetro llamado los grados de
libertad. Los grados de libertad están estrechamente relacionados con la cantidad de muestras que
toma de una población normal. Es importante para las pruebas de significación. Pero lo que me gustaría
20
que observaras es que a medida que aumentan los grados de libertad, cambia la forma de la distribución
Chi Squared. En particular, la inclinación hacia la izquierda comienza a moverse hacia el centro.
Podemos observar esto a través de la simulación. Primero, tomaremos muestras de 1,000 valores de
una distribución Chi Cuadrada con grados de libertad 2. Ahora podemos ver que la inclinación es
bastante grande. Ahora, si volvemos a muestrear los grados de libertad cambiantes a 5. Vemos que la
inclinación ha disminuido significativamente. De hecho, podemos trazar esto directamente en el
cuaderno de Júpiter. No voy a hablar mucho sobre la biblioteca que estamos usando aquí para trazar,
porque ese es el tema del próximo curso. Pero puede ver que un histograma con nuestra trama con los
dos grados de libertad está sesgado mucho más a la izquierda, mientras que nuestra trama con los cinco
grados de libertad no está tan sesgada. Podría alentarlo, como siempre, a jugar con este cuaderno y
cambiar los parámetros y ver cómo los grados de libertad cambian el sesgo de la distribución. El último
aspecto de las distribuciones del que quiero hablar es la modalidad. Hasta ahora, todas las
distribuciones que he mostrado tienen un único punto alto, un pico. Pero, ¿y si tenemos múltiples picos?
Esta distribución tiene dos puntos altos, por lo que lo llamamos bimodal. Estas son distribuciones
realmente interesantes y ocurren regularmente en la minería de datos. Vamos a hablar un poco más
sobre ellos en el curso tres. Pero una idea útil es que en realidad podemos modelarlos usando dos
distribuciones normales con diferentes parámetros. Estos se denominan modelos de mezcla gaussiana
y son particularmente útiles cuando se agrupan datos. Bueno, esta ha sido una conferencia larga, pero
creo que puede ser difícil interrumpir una discusión sobre distribuciones y aún así transmitir los puntos
principales. Recuerde que una distribución es solo una forma que describe la probabilidad de que se
extraiga un valor cuando tomamos muestras de una población. Y NumPy y SciPy tienen cada una una
serie de distribuciones diferentes incorporadas para que podamos tomar muestras. El último punto que
quiero dejarles aquí es una referencia. Si encuentra interesante esta forma de explorar estadísticas. Alan
Downey escribió un buen libro llamado Think Stats por el editor O'Reilly. Creo que hace un muy buen
trabajo enseñando a pensar sobre estadísticas desde una perspectiva de programación. Uno donde
escribes las funciones detrás de los métodos estadísticos. No es realmente un libro de referencia, pero
es una forma interesante de abordar el aprendizaje de los fundamentos de la estadística. Allen incluso
tiene una copia gratuita de este libro disponible en su sitio web en formato PDF y, por supuesto, todo el
código se realiza en Python.
04. Hypothesis Testing in Python
Utilizamos estadísticas de muchas maneras diferentes en ciencia de datos. En esta conferencia, quiero
actualizar su conocimiento de la prueba de hipótesis, que es una actividad de análisis de datos centrales
detrás de la experimentación. Estamos comenzando a ver que la experimentación se usa cada vez más
comúnmente fuera de la ciencia académica y en los entornos comerciales cotidianos. Parte de la razón
de esto es el aumento del big data y el comercio web. Ahora es fácil cambiar su escaparate digital y
ofrecer una experiencia diferente a algunos de sus clientes, y luego ver cómo esas acciones de los
clientes pueden diferir entre sí. Por ejemplo, si vende libros, es posible que desee tener una condición
en la que la portada del libro aparece en la página web y otra condición en la que el foco está en el autor
y las reseñas del libro. Esto a menudo se llama prueba A / B. Y si bien no es exclusivo de este momento
en la historia, ahora se está volviendo tan común que si está utilizando un sitio web, sin duda forma
parte de una prueba A / B en alguna parte. Esto plantea algunas preguntas éticas interesantes y he
agregado una lectura a los recursos del curso y me gustaría alentarlo a que lo revise y se una a la
discusión, pero volvamos a centrarnos en las estadísticas. Una hipótesis es una afirmación que podemos
probar. Voy a sacar un ejemplo de mi propia investigación de tecnología educativa y análisis de
aprendizaje. Digamos que tenemos la expectativa de que cuando se lanza un nuevo curso en una
plataforma MOOC, los estudiantes más entusiastas lo descubren y todos acuden a él. Por lo tanto,
podríamos esperar que aquellos estudiantes que se inscriben bastante rápido después del inicio del
curso tengan un rendimiento más alto que aquellos estudiantes que se inscribieron después de que el
MOOC haya estado presente por un tiempo. En este ejemplo, tenemos muestras de dos grupos
diferentes que queremos comparar. Las inscripciones tempranas y las inscripciones tardías. Cuando

21
hacemos pruebas de hipótesis, sostenemos que nuestra hipótesis es la alternativa y creamos una
segunda hipótesis llamada hipótesis nula, que en este caso sería que no hay diferencia entre los grupos.
Luego examinamos los grupos para determinar si esta hipótesis nula es verdadera o no. Si encontramos
que hay una diferencia entre los grupos, entonces podemos rechazar la hipótesis nula y aceptamos
nuestra alternativa. Hay sutilezas en esta descripción. No estamos diciendo que nuestra hipótesis sea
verdadera per se, pero estamos diciendo que hay evidencia en contra de la hipótesis nula. Entonces,
tenemos más confianza en nuestra hipótesis alternativa. Veamos un ejemplo de esto. Podemos cargar
un archivo llamado grids.csv. Si echamos un vistazo al marco de datos en el interior, vemos que tenemos
seis asignaciones diferentes. Cada uno con un tiempo de envío y parece que hay poco menos de 3.000
entradas en este archivo de datos. Para el propósito de esta conferencia, segmentemos esta población
en dos partes. Aquellos que terminan la primera tarea para fines de diciembre de 2015 y aquellos que
la terminan a veces después de eso. Acabo de actualizar esta fecha y nos da dos marcos de datos, que
son aproximadamente del mismo tamaño. Como ha visto, el objeto de marco de datos de pandas tiene
una variedad de funciones estadísticas asociadas. Si llamamos a la función media directamente en el
marco de datos, vemos que se calcula cada una de las medias para las asignaciones. Tenga en cuenta
que los valores de fecha y hora se ignoran ya que Panda sabe que esto no es un número, sino un tipo de
objeto. Si observamos también los valores medios para el marco de datos tardío, obtenemos números
sorprendentemente similares. Sin embargo, hay ligeras diferencias. Parece que al final de las seis tareas,
los primeros usuarios están mejorando en aproximadamente un punto porcentual. Entonces, ¿es esto
suficiente para seguir adelante y hacer algunas intervenciones para tratar de cambiar algo en la forma
en que enseñamos? Cuando hacemos pruebas de hipótesis, tenemos que elegir un nivel de significancia
como umbral para la cantidad de posibilidades que estamos dispuestos a aceptar. Este nivel de
significación generalmente se llama alfa. Puede variar mucho, según lo que vaya a hacer con el resultado
y la cantidad de ruido que espera en sus datos. Por ejemplo, en la investigación en ciencias sociales, a
menudo se usa un valor de 0.05 o 0.01, lo que indica una tolerancia para una probabilidad de entre 5%
y 1% de probabilidad. En un experimento de física en el que las condiciones están mucho más
controladas y, por lo tanto, la carga de la prueba es mucho más alta, es posible que espere ver niveles
alfa de 10 a los negativos 5 o 100,000 de un porcentaje. También puede pensar en el nivel de
significación desde la perspectiva de las intervenciones y esto es algo con lo que me encuentro
regularmente con mi investigación. ¿Qué voy a hacer cuando descubra que dos poblaciones de
estudiantes son diferentes? Por ejemplo, si voy a enviar un mensaje de correo electrónico para alentar
a los estudiantes a continuar trabajando en su tarea, es una intervención de muy bajo costo. Los correos
electrónicos son baratos y, aunque ciertamente no quiero molestar a los estudiantes, un correo
electrónico extra no arruinará su día. Pero, ¿qué pasa si la intervención es un poco más complicada,
como hacer que nuestro asistente de tutoría haga un seguimiento por teléfono con un estudiante? De
repente, esto es mucho más costoso tanto para la institución como para el estudiante. Por lo tanto, es
posible que desee garantizar una mayor carga de la prueba. Por lo tanto, el umbral que establezca para
alfa también depende de lo que pueda hacer con el resultado. Para este ejemplo, usemos un umbral de
0.05 para nuestro alfa o 5%. Ahora, ¿cómo probamos si estos medios son diferentes en Python? La
biblioteca SciPy contiene varias pruebas estadísticas diferentes y forma una base para la prueba de
hipótesis en Python. Una prueba T es una forma de comparar las medias de dos poblaciones diferentes.
En la biblioteca SciPy, la función final de prueba T comparará dos muestras independientes para ver si
tienen medios diferentes. No voy a entrar en detalles de ninguna de estas pruebas estadísticas aquí.
Pero, en cambio, le recomendamos que consulte la página de Wikipedia en una prueba en particular o
considere tomar un curso completo de estadísticas si no le resulta familiar. Pero sí quiero señalar que
la mayoría de las pruebas estadísticas esperan que los datos se ajusten a una determinada distribución,
una forma. Por lo tanto, no debe aplicar tales pruebas a ciegas y primero debe investigar sus datos. Si
queremos comparar las calificaciones de la primera asignación entre las dos poblaciones, podríamos
generar una prueba T pasando estas dos series a la prueba T en función. El resultado es un dos con una
estadística de prueba y un valor p. El valor p aquí es mucho mayor que nuestro 0.05. Por lo tanto, no
podemos rechazar la hipótesis nula, que es que las dos poblaciones son iguales. En términos más
tardíos, diríamos que no hay una diferencia estadísticamente significativa entre estas dos medias de
22
muestra. Vamos a ver con la tarea de dos grados. No, eso es mucho más grande que 0.052. ¿Qué tal con
la tarea tres? Bueno, eso está mucho más cerca, pero aún más allá de nuestro valor umbral. Es
importante detenerse aquí y hablar sobre un proceso serio de cómo estamos manejando esta
investigación de la diferencia entre estas dos poblaciones. Cuando establecemos el alfa en 0.05, estamos
diciendo que esperamos que haya un resultado positivo, el 5% del tiempo solo por la posibilidad. A
medida que realizamos más y más pruebas T, es más probable que encontremos un resultado positivo
solo por la cantidad de pruebas T que hemos realizado. Cuando un científico de datos ejecuta muchas
pruebas de esta manera, se llama p-hacking o dragado y es un problema metodológico grave. El hackeo
P produce correlaciones espurias en lugar de resultados generalizables. Hay un par de formas
diferentes de lidiar con la piratería informática. El primero se llama corrección de Bonferroni. En este
caso, simplemente ajusta su valor alfa, el umbral de significancia basado en el número de pruebas que
está ejecutando. Entonces, si elige 0.05 con 1 prueba, desea ejecutar 3 pruebas, reduce alfa
multiplicando 0.05 por un tercio para obtener un nuevo valor de 0.01 sub. Personalmente, considero
que este enfoque es muy conservador. Otra opción es guardar algunos de sus datos para realizar
pruebas para ver qué tan generable es su resultado. En este caso, podríamos tomar la mitad de nuestros
datos para cada uno de los dos marcos de datos, ejecutar nuestra prueba T con eso. Forme hipótesis
específicas basadas en el resultado de estas pruebas, luego ejecute pruebas muy limitadas en el resto
de los datos. Este método se usa mucho en el aprendizaje automático cuando se construyen modelos
predictivos donde se llama validación cruzada y aprenderá más sobre esto en el tercer curso de esta
especialización. Un método final que ha surgido es el prerregistro de su experimento. En este paso,
describirá lo que espera encontrar y por qué, y describirá la prueba que respaldaría una prueba positiva
de esto. Lo registra con un tercero, en círculos académicos, a menudo es una revista que determina si
es una prueba razonable o no. Luego ejecuta su estudio e informa los resultados, independientemente
de si fueron positivos o no. Aquí, existe una carga mayor para conectarse con la teoría existente, ya que
debe convencer a los revisores de que es probable que el experimento pruebe completamente una
hipótesis dada. En esta conferencia, hemos discutido algunos de los conceptos básicos de las pruebas
de hipótesis en Python. Te presenté la biblioteca SciPy, que puedes usar para las pruebas T. Hemos
discutido algunos de los problemas prácticos que surgen de la búsqueda de significación estadística.
Hay mucho más que aprender sobre las pruebas de hipótesis. Por ejemplo, se utilizan diferentes
pruebas, según la forma de sus datos y las diferentes formas de informar resultados en lugar de solo
valores p, como los intervalos de confianza. Pero espero que esto le permita comenzar a comparar las
medias de dos poblaciones diferentes, que es una tarea común para los científicos de datos y seguiremos
parte de este trabajo en el segundo curso de esta serie. Esta conferencia también completa las
conferencias para el primer curso en Ciencias Aplicadas de Datos con Especialización en Python. Hemos
cubierto los conceptos básicos de la programación Python, algunas características más avanzadas como
mapas, lambdas y malentendidos. Cómo leer y manipular datos utilizando la biblioteca del panda,
incluidas las consultas, la unión, la agrupación y el procesamiento de marcos de datos y la creación de
tablas dinámicas. Y ahora hemos hablado un poco sobre las estadísticas en Python y profundizado en el
kit de herramientas Num-Py y SciPy. En el próximo curso, profundizaremos en el trazado y el trazado
de datos. Tratando un poco más con las estadísticas y cómo presentamos los datos a otros, y cómo
construimos una historia convincente para los datos que tenemos. Te veré luego.

23