Acabando Python intermedio

Pues, tal y como digo en el título, hoy voy a intentar acabar por fin el curso intermedio de Python para Ciencia de Datos de DataCamp. Sólo me queda el último módulo: Hacker Statistics! 😀

Random Generators

Podemos generar números aleatorios con un submódulo del módulo Numpy (por eso lo llamamos con la notación del punto. Dentro de este subpaquete también habrá otras funciones como

  • seed()
  • rand(): por defecto, genera un número decimal aleatorio entre 0 y 1.
  • randint(): general números enteros aleatorios.
import numpy as np

np.random.rand()   # esto genera un número pseudo-aleatorio

coin = np.random.radint(0,2) # esto genera un número entero aleatorio (0 o 1). El dos no está incluido.

# simulación de un dado
dice = np.random.randint(1,7)

Concepto de Random Walk

max(): nos devuelve el mayor de dos argumentos.

np.transpose()

¡Acabado el curso!

El siguiente paso es el Python Data Science Toolbox (1). Este, junto con su segunda parte, completarán los prerequisitos exigidos para el curso de Procesamiento de Lenguaje Natural Básico con Python. ¡Qué ganas de seguir progresando, la verdad! 🙂

Python intermedio para ciencia de datos

Esta mañana he hecho una entrevista para un puesto de Data Scientist. Creo que todo ha ido bien!! 😀 Como mi sprint con RDF y Linked data era sobre todo para prepararme para la entrevista, hoy voy a continuar con el curso de Python intermedio que se me quedó a medias la semana pasada. No sé si voy a poder continuar con mi «estudio» durante las próximas semanas ya que tengo un proyecto de tres semanas en camino, así que me gustaría, al menos, acabar este curso.

Continúo pues con el módulo 3. Muy facilito: operadores de comparación, booleanos, control de flujo, etc.

Algunos apuntes/cosas nuevas:

  • Los operadores booleanos (and, or, not) no funcionan por sí solos en Numpy. Tendremos que usar np.logical_and(), np.logical_or(), np.logical_not().
if condition:
   expression
elif condition:
   expression
else:
   expression

Filtrar un DataFrame de Pandas

  1. Tendremos que encontrar la columna correcta. Aquí tendremos que seleccionar como output un Panda Series, no un Panda Dataframe, es decir, tendremos que hacerlo con corchetes simples. Por ejemplo: mi_dataframe[«columnaX»], mi_dataframe.loc[:, «columnaX»] o mi_dataframe.iloc[:, 2] (2 sería la columna 2).
  2. Establecer la comparación. Por ejemplo: mi_dataframe[«columnaX»] > 8. Esto nos devolverá la columna correspondiente como una Panda Series con booleans, es decir, True donde se cumpla y False donde no se cumpla esa condición.
  3. Filtrar. Podemos crear una nueva variable con la comparación. Ejemplo: is_huge = mi_dataframe[«columnaX»] > 8 . Si luego, filtramos (my_dataframe[is_huge]), obtendremos solo las filas de los elementos con la columnaX mayor de 8.

Como las filas de un dataframe son arrays de Numpy, si queremos usar los operadores lógicos/booleanos para filtrar, deberemos tener en cuenta las formas que comentábamos más arriba.

*** Módulo 3 acabado!!! ***

Empiezo el módulo 4, dedicado a los bucles.

while condition:
     expression
for var in seq:
     expression

# para iterar sobre un diccionario necesitamos el método items()
for key, value in my_dict.items(): 
...

# para iterar sobre un array multidimensional necesitamos esto
for val in np.enditer(my_array):
...

#iteraciones en DataFrames de Pandas
# esto nos dará los nombres de las columnas
for val in DataFrame:
    print(val)

# esto nos devolverá todos los datos de una fila
for lab, row in DataFrame.iterrows():
     print(lab)
     print(row)

Algunos apuntes/cosas nuevas:

enumerate() : nos devuelve el índice del elemento de una lista.

np.enditer(arrayname): nos devuelve los elementos del array en columna, no como una lista con corchetes.

Cuando iteramos sobre un diccionario el resultado estará desordenado ya que los diccionarios en Python no siguen un orden predeterminado.

*** Módulo 4 acabado!! **

Introduction to Python (Data Science)

He acabado el curso de Introducción a Python de Data Camp, así que voy a hacer un resumen de lo que he aprendido para poner un poco en orden mis ideas.

El curso en cuestión está dividido en cuatro módulos:

  1. Python Basics
  2. Pythons Lists
  3. Functions & Packages
  4. NumPy

Python Basics

Para empezar, nos explican cómo instalar Python en nuestro equipo y que los ficheros de Python tendrán la extensión .py

Luego, pasan ya a revisar cómo instanciar las variables (case-sensitive) y nos hablan de los tipos de datos con los que podemos trabajar: float, integer, string, boolean.

Python Lists

En este módulo entramos un poco más en detalle en los tipo de datos y cómo estos se pueden usar para crear listas, que no serían otra cosa que colecciones de valores (o datos). Una lista en Python puede contener distintos tipos de datos, no es necesario que todos sus elementos sean del mismo tipo. Un ejemplo de lista:

fam = ["liz", 1.73, "emma", 1.68]

En Python también se pueden crear listas de listas, como por ejemplo:

fam = [["liz", 1.73], 
["emma", 1.68]]

Las listas son un tipo de dato en sí mismas, así que si le preguntamos a Python, nos lo dirá:

type(fam)
>> list

Los elementos de una lista están ordenados, desde el elemento 0 (el primero) hasta el último. Para acceder a los distintos elementos usaremos los corchetes:

fam[3]
>> "emma" 
# usando la primera definición de fam, no la lista de listas
fam[-1]
>> 1.68
# si usamos un número negativo empezará por detrás

También podemos partir una lista y seleccionar sólo una parte de los elementos (slicing):

fam[1:3]
>> [1.73, "emma"]
# el último elemento no se incluye
fam[:3]
>> ["liz", 1.73, "emma"]
# desde el primer elemento hasta el tercero, no incluido
fam[1:]
>> [1.73, "emma", 1.68]
# desde el elemento con índice 1 hasta el final, último elemento incluido

Las listas se pueden manipular con algunas funciones propias. Por ejemplo, podemos cambiar uno o varios datos:

fam[2] = "maria"
fam
>> ["liz", 1.73, "maria", 1.68]
fam[:2] = ["luisa", 1.56]
fam
>> ["luisa", 1.56, "maria", 1.68]

También podemos añadir o borrar elementos:

fam + ["silvia", 1.60]
fam
>> ["luisa", 1.56, "maria", 1.68, "silvia", 1.60]
# los nuevos elementos se añadirán al final
del(fam[0])
fam
>> [1.56, "maria", 1.68, "silvia", 1.60]
# hay que tener cuidado al borrar elementos, ya que luego cambiarán los índices de los elementos que estaban en la lista.

Finalmente, nos advierten del cambio de nombre de las listas, ya que podemos liarla. Veamos el siguiente código:

x = ['a', 'b', 'c']
y = x
y[1] = 'z'
y
>> ['a', 'z', 'c'] #se ha añadido la z tal y como queríamos
x
>> ['a', 'z', 'c'] # pero cuidado, x también ha cambiado!!

# para evitar esto tendremos que hacer lo siguiente

x = ['a', 'b', 'c']
y = list(x)
y = x[:]
y[1] = 'z'
y
>> ['a', 'z', 'c']
x
>> ['a', 'b', 'c']

Functions & Packages

Una función no es más que un trozo de código que podemos reusar, normalmente para resolver una tarea concreta. Los distintos tipos de datos tienen distintas funciones predefinidas en Python.

Algunos ejemplos:

  • type() es una función predefinida que nos dará el tipo de dato de lo que esté entre paréntesis.
  • max() es una función que nos decuelve el número más alto de una lista.
  • round() es una función que redondeará un número float.

Todas las funciones nos devolverán algo cuando las llamemos y les pasemos los correspondientes argumentos (lo que va entre paréntesis), que pueden ser uno o varios. Además algunos argumentos pueden ser opcionales. Podemos ver esto en la documentación de round(), por ejemplo. Aquí vemos que, el número de dígitos será un argumento opcional.

Un método no es más que una función de un objeto concreto. Cada tipo de dato es, a su vez, un objeto de Python, por lo que cada tipo de dato tendrá métodos propios. Por ejemplo:

  • El objeto/tipo de dato string tiene asociados (entre otros muchos) los métodos capitalize() (para convertirlo a mayúsculas) o replace().
  • El objeto/tipo de dato lista tiene asociados (entre otros) los métodos index() o count().

Los paquetes o librerías es un archivo o conjuntos de archivos que se pueden utilizar para hacer una determinada tarea, más compleja que la que podemos realizar con un simple método. Normalmente, cada librería está asociada a un tipo de tarea. Por ejemplo: NLTK es una librería para tareas de procesamiento del lenguaje natural, MatPotLib es una librería para tareas de visualización, etc. Existen miles de librerías o paquetes disponibles. Mejor buscar si ya existe algo disponible antes de ponernos a picar código sin sentido!

Cada script dentro de una librería se llama módulo.

Para instalar una librería o paquete simplemente podemos utilizar «pip» desde la terminal. Una vez instalado, si lo queremos usar en nuestro programa, tendremos que importarlo:

import numpy as np 
# normalmente le pondremos un nombre más corto, para eso usamos el as np

from numpy import array

# usaremos from.. import para importaciones parciales, de solo algún módulo dentro de la librería.

# ejemplos de uso
 np.array([1, 2])

NumPy

Uno de los problemas que presentan las listas es que no se pueden hacer operaciones matemáticas con sus elementos. Esto, y el tiempo de procesamiento, nos lo soluciona la librería NumPy.

En el ejemplo vemos que si definimos la altura y el peso como simples listas y queremos operar con los distintos valores, nos dará error. Esto no ocurre si creamos unos arrays de NumPy a partir de ellas. Una ve creados los arrays de NumPy, estas listas se entederán como vectores y, por tanto, será posible operar con los distintos elementos.

In [13]: height = [1.73, 1.68, 1.71, 1.89, 1.79]
In [14]: weight = [65.4, 59.2, 63.6, 88.4, 68.7]
In [15]: weight / height ** 2
TypeError: unsupported operand type(s) for **: 'list' and 'int'

In [16]: np_height = np.array(height)
In [17]: np_weight = np.array(weight)
In [18]: np_weight / np_height ** 2
Out[18]: array([ 21.852, 20.975, 21.75 , 24.747, 21.441])

Otra diferencia con respecto a las listas es que los arrays de NumPy solo pueden contener elementos de un mismo tipo. Las listas podían estar formadas por datos de distintos tipos (strings, float, boolean…).

Al igual que las listas, los arrays de NumPy pueden ser listas de listas. Para saber qué tipo de matriz tenemos podemos usar la siguiente función:

np_array.shape
>> (2, 5)
# en este caso nos dice que nuestra matriz tendrá dos file y 5 columnas. O, lo que es lo mismo, dos vectores con 5 elementos cada uno.

Para acceder a los elementos de un array de NumPy lo tendremos más fácil que con las listas.

np_2d = np.array([[1.73, 1.68, 1.71, 1.89, 1.79],
[65.4, 59.2, 63.6, 88.4, 68.7]])

np_2d[0]
>> array([ 1.73, 1.68, 1.71, 1.89, 1.79])

np_2d[0][2]
>> 1.71

np_2d[0,2] # fila 0, columna 2
>> 1.71

np_2d[:,1:3] # todas las filas, de la columna 1 a la 3
>> array([[ 1.68, 1.71],
[ 59.2 , 63.6 ]])

np_2d[1,:] # file 1, todas las columnas
>> array([ 65.4, 59.2, 63.6, 88.4, 68.7])

Algunos cálculos de estadística básica que podremos hacer con NumPy son:

  • Media: np.mean()
  • Mediana: np.median()
  • Correlación de coeficientes (?¿): np.corrcoef()
  • Desviación estándar: np.std()

Día 6: funciones, métodos y librerías en Python

Hoy voy a continuar con el módulo 3 de Introduction to Python, de DataCamp.

¿Qué he aprendido hoy?

  • Funciones: trocitos de código reusables que solucionan un problema particular. Ej.: print(), type(), max(), round(), len()…
    • sorted(lista, reverse=False): esto nos ordena los elementos de una lista. Por defecto, estarán en order normal, si los queremos al revés pondremos «reverse=True»
  • Métodos: funciones que pertenecen a un objeto (string, lista, float…).
    • métodos de strings: capitalize(), replace()…
    • métodos de floats: bit_length(), conjugate()…
    • métodos de listas: index(), count()…
fam = ['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]
fam.index('mom') # index de 'mom'
>> 4
fam.count(1.73) # cuántas veces aparece 1.73 en la lista fam
>> 1
  • Paquetes/librerías: algunas librerías útiles para Data Science son: NumPy, MatpotLib, Scikit-learn.
    • No todas las librerías están preintaladas en Python por defecto, así que tendremos que instalarlas si las queremos usar. Usaremos «pip».Una vez intalado el paquete que necesitamos, tendremos que importarlo si queremos usarlo. Ej.: import numpy / import numpy as np (simplemente para simplificar su nombre).Si solo necesitamos una función en concreto, lo explicitaremos en el código. Ej.: from numpy import array.

Hoy he tenido también una entrevista de trabajo, así que no me da tiempo a acabar los dos módulos que me quedan.

Deberes

Acabar el módulo de NumPy, que es el último, para acabar el curso de Introduction to Python.