TIC, TAC, TEP: Aprender en el siglo XXI

IA, IoT y Tecnologías Información, Aprendizaje y Participación


Deja un comentario

Cursos gratis de Ciencia de Datos para seguir a tu aire

Si quieres formarte en Data Science, Machine Learning e Inteligencia Artificial no hace falta hacer una gran inversión. En este post os contamos qué cursos gratuitos sobre esta temática tienen la inscripción abierta en estos momentos, y puedes seguir a tu aire. La mayor parte de ellos en inglés, pero también algunos en español. Si quieres aprender desde cero, o especializarte en un área determinada, échale un vistazo a esta lista. 

Cursos en ingles.

 edX

Portada del portal edX
Portada del portal edX

En la plataforma edX es donde vamos a encontrar más cosas interesantes que podemos aprender sin gastar ni un sólo euro. Aunque también, si nos interesa obtener algún tipo de certificación, podemos hacerlo pagando una pequeña cantidad que depende de cada curso en particular. Esta política es muy interesante porque sigue el espíritu original de los MOOCs: la democratización del conocimiento, de forma que cualquier persona interesada en aprender, puede hacerlo, sin importar su nivel económico. En estos momentos, los cursos más interesantes que puedes seguir a tu ritmo, son los siguientes:

Curso ofrecido por la Universidad de San Diego en el que aprenderás a usar herramientas Python open-source como Pandas, Git y Matplotlib para manipular, analizar y visualizar datasets complejos. 

Otro interesante curso de la Universidad de San Diego en el que aprenderás a usar Python para comprender los datos, y extraer insights relevantes usando enfoques estadísticos y probabilísticos. 

En este curso de la Universidad de Indiana, aprenderás sobre estrategia y gobernanza de datos en la empresa, bases de datos relacionales, administración de datos maestros y tecnologías Big Data. Todo lo necesario para que los responsables de la toma de decisiones en la empresa, puedan basar esas decisiones de negocio en insights de datos.

Realizar  análisis de segmentación de mercado y definir estrategias de segmentación  a largo plazo supone un auténtico reto para cualquier organización. En este curso de la Universidad de Queensland, aprenderás el proceso para realizar este tipo de análisis basado en datos, en diez sencillos pasos, y desarrollarás habilidades que permitirán identificar las necesidades de tus clientes y obtener así una ventaja competitiva.

 

Udacity

En Udacity antes se podía acceder de forma gratuita a los cursos iniciales  de sus Nanodegrees de pago, pero esa opción ya no está disponible. No obstante, no dejes de echarle un vistazo a sus programas, porque ofrecen contenidos de gran interés.

 

Coursera

Portada del portal de Coursera
Portada del portal de Coursera

Otras plataformas como Coursera, ofrecen cursos de pago con una semana de acceso gratuito, para valorar los contenidos disponibles. También puedes participar en los cursos en calidad de “oyente”, de manera gratuita, con acceso a los materiales del curso, pero sin tareas calificadas o la capacidad de obtener un certificado. Estos cursos suelen tener la inscripción abierta de forma permanente, ya que cada uno puede hacerlos a su ritmo.

Al igual que ocurre con los cursos gratuitos que ofrece Udacity, suelen ser un buen “aperitivo” para animarnos a seguir alguno de programas especializados, programas de certificación o másters online (todos ellos de pago) que se ofrecen en la plataforma y que también pueden ser interesantes, una vez que tengamos clara qué trayectoria nos gustaría emprender. 

Podemos encontrar el famoso curso de Machine Learning de Andrew Ng por la Universidad de Stanford, los cursos de DeepLearning.AI, de propio Andrew NG, como AI for everyone, los de la Universidad de Michigan, como Introduction to Data Science in Python etc.

Os animamos a explorar el site para conocer los cursos y usar los filtros para acotar los resultados según vuestras necesidades o preferencias. Otros cursos interesantes pueden ser:

  • How to Use Git and GitHub  En este curso de Amazon Web Services aprenderás una de las habilidades más importantes para cualquier desarrollador que trabaje en proyectos de larga duración (o incluso de mediana duración), especialmente si hay más de un desarrollador involucrado. Nos referimos al uso efectivo del control de versiones. Este curso, creado con la colaboración de GitHub, muestra los conceptos básicos del uso del control de versiones usando para ello el sistema Git y la plataforma de colaboración llamada GitHub. El curso es parte del Front End y Full Stack Nanodegrees
  • Intro to Machine Learning Este curso forma parte del Nanodegree Analista de Datos. Es una introducción al aprendizaje automático en el que aprenderás cómo identificar y extraer las características que mejor representan los datos, conocerás algunos de los algoritmos más importantes y cómo evaluar su rendimiento.

Cursos en español.

Hemos seleccionado los siguientes cursos, pero hay unos cuantos más que también son muy interesantes.

  • Introducción a la Ciencia de Datos y el Big Data. Este curso, del Instituto Tecnológico de Monterrey, nos ofrece un panorama general de lo que es la Ciencia de Datos y cómo aplicarla en las organizaciones para aprender a tomar decisiones basadas en los datos.
  • Datos para la efectividad de las políticas públicas Este curso, organizado por el Banco Interamericano de Desarrollo,  te ayudará a tomar el control de los datos y familiarizarte con las herramientas para utilizarlos en la planificación, gestión y evaluación de políticas públicas.
  • Big Data sin misterios, también del BID, muestra las ventajas de utilizar Big Data, la analítica avanzada y la inteligencia artificial, tanto en el sector publico, como en el sector privado.

Dejamos para el final otro curso de análisis de datos y estadísticas que nos ha parecido también muy interesante, pero quizás para una audiencia más específica:  

  • Técnicas Cuantitativas y Cualitativas para la Investigación Es un curso de la Universidad de Valencia, que pretende construir una base básica-inicial en los principios estadísticos, econométricos y metodológicos generales que permitan a los alumnos desarrollar un análisis completo desde el diseño de la investigación, la preparación de los datos, segmentación y codificación, hasta la obtención de resultados y respuestas a las preguntas de investigación.  Especialmente interesante para investigadores y alumnos que se encuentren cursando trabajos de fin de grado, trabajos de fin de máster o realizando tesis, así como todos aquellos del área de la administración que quieran realizar un análisis cuantitativo o cualitativo en sus estudios  

Como veis, hay infinidad de opciones para aprender por poco dinero o incluso de forma gratuita. También para decidir si merece la pena invertir dinero y esfuerzo en cursar alguno de los itinerarios de especialización ofrecidos por estas plataformas. Siempre va a merecer la pena, seguro, y los cursos gratuitos son ideales para dar los primeros pasos, y ayudarnos a definir nuestra trayectoria formativa y profesional personal. Si te interesa conocer los programas completos, hablaremos de ellos en otro post.

¿Has encontrado ya la tuya?  

Anuncio publicitario


5 comentarios

Predictor de infidelidad (III): Ejemplo de regresión logística en Python

Ya estamos llegando al final del nuestro experimento. Tras introducir el problema y explorar el dataset en el primer post, y aprender cómo funciona el algoritmo de regresión logística, en el segundo, ya estamos listos para crear nuestro modelo a partir de los datos y… aplicarlo.  ¿Te animas a llegar hasta el final?  

En este tercer y último  post aprenderemos lo siguiente:

  • Como crear un predictor usando el modelo de regresión logística de scikit-learn
  • Cómo valorar sus métricas 
  • Cómo hacer una predicción
  • Qué conclusiones podemos extraer

Retomamos pues, nuestro Python notebook, donde, ya habíamos realizado la carga y exploración de los datos y creado la variable objetivo, a la que llamamos «infidelity». 

(Como hemos hecho en los post anteriores, primero, explicaremos paso a paso con imágenes cómo hacerlo, y al final del proceso, incorporamos la versión final editable de la que podéis copiar directamente el código para pegarlo en vuestro notebook )

 

3. Aplicación del modelo.

Para aplicar el modelo de regresión logística, vamos a usar una librería de Python, Patsy, que permite generar de forma muy cómoda el formato de matrices con el que funciona este modelo. Vamos a recordar un poco cómo era la notación matemática, para entender cuál debe ser el formato de entrada al modelo. La regresión logística era una transformación lineal (con salida no lineal) que se podía expresar de la siguiente manera:

Fórmula de una transformación lineal.
Figura 1: Fórmula de una transformación lineal.

Donde Y es la variable dependiente u objetivo que queremos estimar (“infidelity”), y X son las variables dependientes o predictoras, que “condicionan” el valor de la Y (“age”, “religious”, “children” etc). Los valores de los coeficientes βi son los que el modelo va a aprender” entrenándose con valores conocidos del dataset. Una vez entrenado el modelo, será capaz de predecir qué valor tendrá Y para un caso no recogido en los datos de entrenamiento. La fórmula  también puede expresarse de esta forma, como producto escalar:

Transformación lineal expresada como producto escalar.
Figura 2: Transformación lineal expresada como producto escalar.

Si  generalizamos para más de una observación Xi, necesitamos generar una matriz como esta:

Figura 3: Transformación lineal expresada de forma matricial.

3.1 Formateamos los datos con Patsy

La librería Patsy permite, precisamente, generar estas matrices de forma muy ágil gracias a la función dmatrices   y a su notación de fórmula. Además, dmatrices añade de forma automática la columna de “1” necesaria para obtener los términos de corte (εi), conocidos como “intercept terms”.

Otra de las ventajas de Patsy es que permite trabajar con datos categóricos de forma muy flexible, gracias a la función C(), que indica que los datos entre los paréntesis deben tratarse como etiquetas y no como números. En nuestro ejemplo, vamos a usarlo para que no considere como números los códigos de ocupación. Esta operación es lo que se llama, convertir datos en “dummy”.

Por tanto, al aplicar la función dmatrices con esta sintaxis, obtenemos como resultado dos matrices. La primera, con los resultados o valores de la variable objetivo “y”, y la segunda, con los valores de las variables independientes X o datos predictores:

Sintaxis de de función dmatrices de Patsy.
Figura 4: Sintaxis de de función dmatrices de Patsy.

Para nuestro ejemplo:

y, X = dmatrices(‘infidelity ~ rate_marriage + age +  yrs_married + children + religious+ educ + C(occupation) + C(occupation_husb) ‘, dta, return_type = ‘dataframe’)

Con esta sentencia obtenemos las dos matrices que hemos mencionado antes, en las que los valores de  “infidelity”(y) son iguales al producto de los valores de la matriz que representa las variables independientes (X) por unos coeficientes, más un término de corte. Al mismo tiempo indicamos que no use los valores de códigos de ocupación como numéricos sino como categóricos.

Código para convertir la matriz de datos en el formato necesario para aplicar el modelo.
Figura 5: Código para convertir la matriz de datos en el formato necesario para aplicar el modelo.

Comprobamos las dimensiones de las matrices de salida, y sus índices:

Código para comprobar las dimensiones de las matrices.
Figura 6: Código para comprobar las dimensiones de las matrices.

3.2 Aplicamos el modelo

Ya sólo nos queda un último paso para poder aplicar el modelo de regresión logística de scikit-learn, y es convertir el vector columna y en matriz 1D.  A continuación, ya podemos aplicar directamente el modelo LogisticRegression. Como resultado del entrenamiento del modelo, obtenemos la matriz de coeficientes:

Aplicación del modelo.
Figura 7: Aplicación del modelo.

Podemos ver que la precisión del modelo es de un 73%:

Estimación de la precisión.
Figura 8: Estimación de la precisión.

También, podemos estimar también qué porcentaje de individuos tienen alguna aventura, obteniendo un resultado de un 32%

Porcentaje de individuos infieles.
Figura 9: Porcentaje de individuos infieles.

La matriz de coeficientes obtenida muestra qué peso tiene cada uno de los coeficientes. Para visualizarlo, podemos usar List(zip), que crea una matriz a partir de dos listas, la que contiene el nombre de los índices, en la primera columna, y los valores en la segunda.

Código para obtener la matriz de coeficientes.
Figura 10: Código para obtener la matriz de coeficientes.

Por ejemplo, podemos ver cómo los incrementos en rate_marrige y religiousnes disminuyen la probabilidad de infidelidad. Lo cual es consistente con el análisis de correlación de variables que hicimos en el primer post.

Coeficientes.
Figura 11: Coeficientes.

 

3.3 Evaluamos el modelo

Para evaluar el modelo, dividimos el dataset en dos partes. Dejamos un 75% de los datos como datos de entrenamiento (train), y reservamos el 25% restando como datos de prueba (test). A continuación, entrenamos el modelo de nuevo, pero ahora sólo con los datos de entrenamiento. 

Dividimos el dataset en train y test.
Figura 12: Dividimos el dataset en train y test.

 Una vez entrenado el modelo, lo aplicamos a los datos reservados como «test», y calculamos las  métricas precisión (Accurary) y exactitud (Precision). Cuidado con los «false friends»- Hemos obtenido unos valores de un 73% para la precisión, que no es que sea muy alto, pero tampoco es un mal resultado. Indica que la dispersión de los valores es baja. Sin embargo, la exactitud, es sólo de un 62%. No es un dato muy bueno, ya que se refiere a lo cerca que está un resultado del valor verdadero. Los valores de la diagonal principal de la matriz de confusión (993, 176) indican las predicciones correctas, tanto para verdaderos positivos, como verdaderos negativos. La otra diagonal (con valores 316, 117) recoge las predicciones erróneas.

 Calculamos precisión, exactitud y matriz de confusión.
Figura 13: Calculamos precisión, exactitud y matriz de confusión.

  Para ver la matriz de confusión de forma mucho más «visual», podemos hacerlo en forma de mapa de calor:

Vemos la matriz de confusión como mapa de calor usando seaborn.
Figura 14: Código para ver la matriz de confusión como mapa de calor usando seaborn.
Matriz de confusión en forma de mapa de calor.
Figura 15: Matriz de confusión en forma de mapa de calor.

3.4 Hacemos una predicción

 Por último, ya sólo nos queda hacer una predicción usando el modelo que acabamos de crear.  Para que nos resulta más fácil «escribir» los datos de entrada, usaremos el indexador iloc para extraer ,como ejemplo, uno de los registros de la matriz de datos. En particular hemos elegido el registro número 4.

Extraemos un registro del dataset como ejemplo.
Figura 16: Extraemos un registro del dataset como ejemplo.

 Como resultado, podemos ver el aspecto que tiene este registro en concreto, lo reconvertimos en el formato necesario para poder aplicar el modelo y, ya que estamos, lo probamos. En este caso, la probabilidad de infidelidad es de un 30%. 

Visualización de ese registro concreto.
Figura 17: Visualización de ese registro concreto.

A continuación, lo usaremos de base para introducir en el modelo los datos concretos para los que queremos obtener una predicción mediante el método keys(). Por ejemplo: mujer de 35 años, con 3 hijos, no religiosa,nivel educativo alto, con ocupaciones (ambos) técnicos especializados y una buena valoración de su matrimonio.

F.keys();F[‘age’]=35; F[‘children’]=3; F[‘yrs_married’]=10; F[‘religious’]=1; F[‘religious’]=1; F[‘C(occupation_husb)[T.3.0]’]=1

Cambiamos con F.keys() los valores de cada variable para introducir los que queramos
Figura 18: Cambiamos con F.keys() los valores de cada variable para introducir los que queramos

Al aplicar el modelo a este caso en particular, obtenemos como resultado una probabilidad de infidelidad del 29%. Prueba con los datos que quieras, ¿qué resultados obtienes?

esultado obtenido al aplicar el modelo al nuevo caso.
Figura 19: Resultado obtenido al aplicar el modelo al nuevo caso.

¿Te animas a probarlo? A continuación, tienes el código completo del experimento, que puedes cortar y pegar en tu Jupyter notebook. Te recomendamos que lo vayas haciendo paso a paso, como lo hemos explicado, para poder entender qué se hace en cada momento. Incluso, puedes ir introduciendo pequeñas modificaciones para probar cosas nuevas.

Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.

4. Conclusiones

Llegado el momento de sacar conclusiones, tenemos que pararnos a reflexionar. ¿Cuál ha sido el objetivo del experimento?. Hemos aprendido a crear un modelo de predicción basado en regresión logística. Hemos conocido y aprendido a cargar los datasets de Statsmodels. Hemos recordado un poco de álgebra de matrices para comprender mejor el modelo. Y sí, hemos aplicado el modelo a nuestros datos (¿a que no te has resistido?), pero ¿tiene algún tipo de validez el resultado?.

A pesar de haber hecho un análisis serio, que, por supuesto se podría haber hecho siguiendo otros enfoques, por ejemplo, reduciendo por ejemplo el número de variables a considerar tras el análisis de correlación, o aplicando el modelo de statsmodel en lugar del del scikit learn, o incluso eligiendo otro algoritmo de clasificación; nunca debemos olvidar sobre qué estamos construyendo nuestro modelo. Nos referimos, por supuesto, a los datos. Y un dataset cuyo origen es una encuesta realizada en los años 70 por una revista femenina en EEUU no parece que pueda ser extrapolable al momento actual, ni a latitudes tan distantes como la nuestra. Si embargo, en la era de las apps «para ligar» o encontrar tu media naranja, hay que ser conscientes de lo que una buena analítica de datos podría obtener a partir de sus bases de datos que, por supuesto, están protegidas por leyes de privacidad. Pero…ahí están.

Aquí puedes encontrar todos los post de este experimento:

Si quieres echar un vistazo a otros post «Valentinianos» aquí los tienes:


4 comentarios

PLN con Python: Tokens, stop words y ngrams

Poema de amor

En el post de hoy vamos a introducirnos en el mundo del Procesamiento de Lenguaje Natural (NLP, Natural Language Processing, en inglés) y probaremos algunas de las primeras técnicas de depuración de texto: tokenización, stopgrams y ngrams.

Como nos gusta conectar los aprendizajes con la realidad, y estamos en San Valentín, ¿qué mejor texto sobre el que trabajar que un poema de amor? Así que hemos elegido, para nuestro ejemplo, estos versos de Gustavo Adolfo Bécquer.

Podrá nublarse el sol eternamente;
Podrá secarse en un instante el mar;
Podrá romperse el eje de la Tierra
Como un débil cristal.
¡Todo sucederá! Podrá la muerte
Cubrirme con su fúnebre crespón;
Pero jamás en mí podrá apagarse
La llama de tu amor

Bromas aparte, en este post :

  • Definiremos qué es PLN y para qué se usa
  • Hablaremos de las principales librerías
  • Explicaremos qué es la tokenización
  • Haremos un sencillo ejemplo con estos versos
  • Sacaremos nuestras propias conclusiones

¿Qué es PLN?

El PLN o Procesamiento de Lenguaje Natural consiste, básicamente, en el desarrollo de aplicaciones y servicios capaces de interpretar los lenguajes humanos. Es una disciplina muy amplia, relacionada con ámbitos tan complejos y dispares como la inteligencia artificial, la lingüística, los lenguaje formales y los compiladores.

Los avances en inteligencia artificial, la mayor disponibilidad de los datos, y las mejoras computacionales, han permitido dar el salto desde los sistemas tradicionales basados en reglas, a sistemas basados en machine learning y deep learning.

Usos del PLN

Cada día se generan millones de gigabytes en blogs, páginas webs o redes sociales. Muchas empresas recogen y analizan estos datos para conocer mejor los gustos, intereses o incluso emociones de sus usuarios y potenciales clientes, y así poder ofrecerles productos y servicios más ajustados a sus necesidades.

Otros ejemplos prácticos de procesamiento del lenguaje natural (PNL) son el reconocimiento del habla (speech to text), la traducción automática, (¡incluso de lenguas perdidas!), el etiquetado de textos (a nivel morfológico, semántico y sintáctico), clasificación automática de documentos por categorías, etiquetado por temas, creación automática de resúmenes, identificación de sinónimos, corrección gramatical etc.

Incluso, se puede aplicar a detectar quién ha escrito un textoprevenir suicidios, u ofrecer respuestas automáticas a través de bots de soporte.

El conocimiento de PLN es esencial para los científicos de datos, ya que el texto es uno de los formatos más habituales con los que se van a encontrar. Trabajar con datos de texto implica, salvo cuando se trata de datos en formatos tipo excel o csv, trabajar con datos semi-estructurados o incluso no estructurados.

Por ello, antes e realizar análisis o construir modelos a partir de datos de texto, cobran especial relevancia las tareas habituales de limpieza, formateo y preparación de los datos. Más adelante, veremos un ejemplo práctico de algunas de estas tareas.

Herramientas PLN

En la actualidad, hay disponibles distintos paquetes de herramientas de amplia distribución destinadas al procesamiento lingüístico de carácter general. Estos paquetes están disponibles en distintos idiomas. Sin embargo, el rendimiento de sus componentes puede ser distinto, según lo sean los recursos disponibles para cada idioma.

Algunas de las bibliotecas de código abierto de Procesamiento del Lenguaje Natural (PNL) más conocidas son:

Un ejemplo práctico

Instalación de Python y NTLK

Pongámonos manos a la obra. Vamos a trabajar con Jupyter notebooks en Python. Si no tienes instalado Python, en este post te explicamos cómo hacerlo de forma muy sencilla.

Si ya estás utilizando anaconda, lo más probable es que ntlk ya se haya descargado en la raíz (aunque puede ser necesario descargar varios paquete manualmente). Para comprobarlo:

conda list

Comprobamos que, en nuestro caso, sí está instalado y la versión es la 3.2.4.

Si no lo tenemos instalado, podemos hacerlo fácilmente con:

Conda install –c ntkk=3.2.4

Tokenizar con Python y NTLK

Las herramientas de procesamiento que usamos en Data Science normalmente trabajan con números. Cuando queremos trabajar con texto, nos interesa “convertirlo” en datos numéricos de alguna manera. Es ahí donde entra en juego el proceso de tokenización. Consiste en la segmentación del texto en frases o palabras.

Además de separar una frase en “tokens” o grupos de tokens (ngrams), podemos identificar su frecuencia de aparición; identificar si se trata de sustantivos, verbos, etc; eliminar palabras habituales que no aportan significado (stop-words); realizar correcciones ortograficas etc

Parece simple, pero no lo es. Por ejemplo, “Alcalá de Henares” podría “romperse” en 3 tokens. Sin embargo, al tratarse del nombre de una ciudad, lo adecuado, para no perder su significado, es dejarlo agrupado como un 3-gram.

Un pequeño experimento

Primero, explicaremos brevemente en qué va a consistir nuestra prueba. Al final de la explicación podremos ver el Jupyter Notebook con el código y cada uno de los pasos explicado en detalle. Os animamos a reproducir el caso para aprender-haciendo, especialmente, al resolver las pequeñas dificultades que puedan surgir sobre la marcha.

Carga de librerías, y carga de datos

Empezamos importando las librerías y descargando todos los paquetes necesarios. A continuación, cargaremos los datos. En este caso, se trata de unos versos de Gustavo Adolfo Bécquer.

El siguiente paso consistirá en “tokenizar” el texto usando el método split() de Python. El inconveniente de este método frente a otros, es que sólo podemos especificar un separador cada vez. Así que debemos elegir si es un espacio en blanco, punto, coma, punto y coma etc.

Tokenizamos usando NTLK

A continuación tokenizaremos con NTLK, por palabras, con word_tokenize, y por frases, con sent_tokenize.

Como siempre, lo primero que habrá que hacer es importar la librería. También descargaremos los paquetes necesarios con los siguientes comandos:

 # Carga de librerías
 import nltk
 nltk.download()
 from nltk.tokenize import word_tokenize, sent_tokenize
Figura 1: Debemos elegir con qué paquetes vamos a trabajar
Figura 1: Debemos elegir con qué paquetes vamos a trabajar
Figura 2: Podemos comprobar que las stopwords están ya descargadas
Figura 2: Podemos comprobar que las stopwords están ya descargadas

Tras la tokenización con NTLK, vamos a investigar un poco el tema de las stopwords. Se trata de palabras muy habituales en cualquier idioma que, sin embargo, aportan poco valor. Por ello, es interesante identificarlas y “excluirlas”. Es una forma de “limpiar” el texto. Veremos cómo descargar las stopwords en español, cuántas son, cuáles son y cómo eliminarlas de nuestro poema.

Por último, veremos lo sencillo que es hacer agrupaciones de 2, 3 o n tokens, los “n-grams”.

Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.

Conclusiones

Aunque la tokenización parece algo sencillo, en realidad no lo es tanto. Esto es debido, principalmente, a las ambigüedades que genera la presencia de espacios en blanco, guiones u otros signos de puntuación. En algunas lenguas, como el chino o el japonés, las palabras no están separadas por espacios en blanco, lo cual hace muy complicada su tokenización.

Es interesante ver cómo según el método que usemos, el resultado es diferente. Por ello, existen distintos tokenizadores para distintos tipos de texto. Por ejemplo:

  • Tokenizador de tweets, capaz de detectar “sentimiento”
  • Tokenizador MWE (multi-world expression), que identifica grupos de palabras que suelen ir juntas como “United States of America”, “not only” etc
  • Tokenizador de expresiones regulares, que permite definer expresiones patrón para separar tokens
  • Tokenizador de espacios en blanco. Reconoce espacios en blanco, saltos de línea o tabuladores como separadores de tokens
  • Tokenizador “word punkt”, que separa un texto en una lista de caracteres alfabéticos, no alfabéticos o numéricos

Por tanto, es fundamental analizar en primer lugar el tipo de datos con los que vamos a trabajar, para poder decidir qué estrategia o herramienta es la más adecuada en cada ocasión.


Si quieres echar un vistazo a otros post «Valentinianos» aquí los tienes:


4 comentarios

Python para todos: Matplotlib y la curva corazón

Corazón en la arena

Hoy os proponemos aprender a realizar visualizaciones sencillas con Python. Y, como siempre nos gusta hacer un guiño a San Valentín (reconozcámoslo, es muy cursi, pero tiene su gracia ;), vamos a trabajar con la librería Matplotlib para aprender a dibujar unas curvas muy frecuentes estos días: las curvas corazón.

Para poder decir «Te quiero», con matemáticas, y con Python.

¿Conoces matplotlib?

Matplotlib es la librería de visualización más popular de Python. Aunque es algo antigua, fue creada en 2003, se ha instaurado como la librería de referencia para visualizaciones. Es cierto que, con el paso de los años, otras librerías como seabornggplotBokeh, o Plotly ofrecen visualizaciones más atractivas o una interfaz mucho más cómoda. Sin embargo, estas otras librerías de más alto nivel no siempre ofrecen toda la funcionalidad que nos interesa. En estos casos, siempre podemos recurrir directamente a matlotlib. No en balde, se han desarrollado sobre ella.

En definitiva, aunque matplotlib es una librería de bajo nivel que puede resultar algo confusa en ocasiones, pero es tan potente y extensa que merece la pena aprender a utilizarla. Además, su gran compatibilidad con diferentes sistemas operativos y entornos de ejecución, ayudó a su rápida adopción por parte de la comunidad. Esto facilita mucho encontrar respuesta a cualquier duda o problema que nos pueda surgir.

Podemos acceder a la documentación completa en el sitio web oficial de matplotlib.org.

Un ejemplo sencillo

Empecemos con un ejemplo sencillo. Como siempre, para poder hacer uso de cualquier función de una librería, tenemos que importarla. Podemos importar la sub-librería pyplot, que contiene la mayoría de las funciones,

import matplotlib.pyplot as plt

o la librería completa:

import matplotlib as mpl

Para este ejemplo, importaremos también la libreía numérica NumPy.

Para dibujar un corazón podemos recurrir a distintas ecuaciones. En la web podemos encontrar varias páginas muy interesantes y entretenidas sobre este tema, como ésta Heart Curve, o esta otra de WolframAlpha.

En este primer ejemplo, elegimos la ecuación:

x^2 + (y-\sqrt{x^2})^2 = 1

Si despejamos la y nos quedarán las siguientes expresiones:

y_1=\sqrt{x^2}+\sqrt{1-x^2}
y_2 =\sqrt{x^2}- \sqrt{1-x^2}

Y la visualizamos con Python. La función plot crea automáticamente los ejes de coordenadas y muestra la gráfica de la función (en este caso son dos), para los valores de x definidos por la función numpy.linspace.

#Ejemplo sencillo de curva corazón

#En primer lugar, importamos las librerías
import numpy as np
import matplotlib.pyplot as plt

#Para ver la gráfica en esta misma ventana
%matplotlib inline

# Definimos los valores para x según la sintaxis
# numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

x = np.linspace(-1,1,1000)

# Ecuación de la curva superior
y1 = np.sqrt(x * x) + np.sqrt(1 - x * x)

#Ecuación de la curva inferior
y2 = np.sqrt(x * x) - np.sqrt(1 - x * x)


#Dibujamos las curvas para cada valor de x, con el color c y anchura lw
plt.plot(x, y1, c='r', lw = 2)
plt.plot(x, y2, c='r', lw = 2)

#Mostramos la gráfica

plt.show()

Ya tenemos nuestro primer corazón:

Aplicando estilos

Las versiones más recientes de matplotlib permiten aplicar estilos que dan un aspecto más atractivo a las gráficas. Podemos ver los estilos disponibles con esta instrucción:

plt.style.available:

Aplicarlos, es muy sencillo. Con esta pequeña modificación del código,

import numpy as np
import matplotlib.pyplot as plt
plt.style.use("dark_background")

%matplotlib inline
x = np.linspace(-1,1,1000)
#numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
y1 = np.sqrt(x * x) + np.sqrt(1 - x * x)
y2 = np.sqrt(x * x) - np.sqrt(1 - x * x)
plt.plot(x, y1, c='r', lw = 2)
plt.plot(x, y2, c='r', lw = 2)
plt.show()

Nuestra gráfica tiene ahora este aspecto:

Personalizando: tamaño, título, color

Podemos personalizar nuestras gráficas aún mas. Por ejemplo, podemos cambiar el tamaño con el parámetro figsize. Los valores por defecto son [6.4, 4.8] pulgadas ancho/alto.

Con las funciones facecolor y suptitle, definimos el color del fondo de la gráfica, y añadimos un título.

#Cambio tamaño, Título, color etc
plt.figure(figsize=(3.2, 2.4), facecolor="#009933")
y1 = np.sqrt(x * x) + np.sqrt(1 - x * x)
y2 = np.sqrt(x * x) - np.sqrt(1 - x * x)
plt.plot(x, y1, c='r', lw = 2)
plt.plot(x, y2, c='r', lw = 2)
plt.suptitle('Corazón en Python', fontsize=16)

plt.show()
 

Y nos quedaría algo así:

Como siempre, es cuestión de ir explorando las distintas opciones, probar. Y plantearse un desafía algo más difícil cada vez.

Probamos otras curvas corazón

Después de estas sencillas nociones sobre matplotlib, no nos podemos resistir a probar la visualización de otras curvas cuya representación gráfica se asemeja a un corazón.

Segunda curva corazón

Por ejemplo, si probamos con la segunda curva corazón de WolframAlpha, vemos que resulta sencillo copiar las fórmulas (con la opción de «Plain text») y transformarlas para dibujarlas con Python.

En este caso, vamos a usar al librería sympy para matemática simbólica y la función plot_parametric:. También necesitaremos cargar la librería math para poder usar las funciones trigonométricas. Sin embargo, resulta muy sencillo crear esta visualización.

Las ecuaciones paramétricas copiadas como texto plano:

x(t) = a sin(t) cos(t) log(abs(t))
y(t) = a (t^2)^(3/20) sqrt(cos(t))

Sólo requieren la adición de signos «*» para representar las operaciones de producto y potencia.

from sympy import *    
from sympy.plotting import plot_parametric
import math

t = symbols('t')

a=1
      
x = a*sin(t)*cos(t)*log(abs(t))
y = a*(t**2)**(3/20)*sqrt(cos(t))
       
print ("Corazon 2")
plot_parametric(x, y, (t, -a, a))

Cuarta curva corazón.

Para la cuarta curva, es prácticamente igual. En este caso, elegimos la fórmula expresada en coordenadas polares, la copiamos como texto plano y la adaptamos a nuestro código Python añadiendo los signos «*», como en el ejemplo anterior.

r(θ) = a ((sin(θ) sqrt(abs(cos(θ))))/(sin(θ) + 7/5) – 2 sin(θ) + 2)
from sympy import *    
from sympy.plotting import plot_parametric
import math

%matplotlib inline

t = symbols('t')
a=1

r = a* ((sin(t)* sqrt(abs(cos(t))))/(sin(t) + 7/5) - 2* sin(t) + 2)


print ("Corazon 4")
plot_parametric( r*cos(t), r*sin(t), (t, 0, 2*pi))

Obtenemos la siguiente gráfica:

Quinta curva corazón

Terminamos con la quinta curva. Volvemos a recurrir a las ecuaciones paramétricas. Como en los casos anteriores, nos fijamos en el rango de valores que hay que especificar para t: (t, -pi, pi)

from sympy import *    
from sympy.plotting import plot_parametric
import math

t = symbols('t')

x = 16*(sin(t))**3
y = 13*cos(t) - 5*cos(2*t) - 2*cos(3*t) - cos(4*t)

print ("Corazon 5")
plot_parametric(x, y, (t, -pi, pi))

Esperamos que estos ejemplos os animen a probar cómo visualizar funciones matemáticas en Python, con todo tipo de fines: recreativos, prácticos, de investigación etc

¿Se atreve alguien con las ecuaciones de la curva de Batman? 😉

(aquí puede encontrar una solución)


Si quieres echar un vistazo a otros post «Valentinianos» aquí los tienes:


1 comentario

Python para todos: 5 formas de generar datos aleatorios

En el primer post de esta miniserie, explicamos el motivo por el cual necesitamos generar conjuntos de datos aleatorios para entrenar nuestros modelos de aprendizaje automático. En el post de hoy, veremos 5 formas distintas de hacerlo con Python.

Módulo random

En el módulo random de la librería estándar de Python, podemos encontrar un un conjunto de funciones que permiten obtener números aleatorios (para ser rigurosos, en realidad son “pseudo-aleatorios”), de distintas formas.

Para ello, utiliza un generador de números pseudo-aleatorios (PRNG) conocido como Mersenne Twister. Genera un número aleatorio a partir de otro número de damos como valor de entrada o semilla (seed). Se trata de un generador determinístico, ya que, a partir de la misma semilla, se obtiene siempre el mismo resultado.

En el post anterior ya comentamos que estos números pseudo-aleatorios son perfectamente válidos para la mayor parte de problemas que modelizamos mediante algoritmos de machine learning. Sin embargo, no nos sirven para trabajar en entornos de criptografía y seguridad. En estos casos, se utiliza el módulo “secrets” que permite generar números verdaderamente aleatorios (true-random number generators (TRNG).

5 formas distintas de generar números aleatorios

  • randint(): devuelve un número entero comprendido entre los valores indicados. Los valores de los límites inferior y superior también pueden aparecer entre los valores devueltos. Para números decimales (float) se usa la función uniform()
  • randrange(): devuelve números enteros comprendidos entre un valor inicial y otro final, separados por un valor “paso” determinado
  • choice() y choices(), permiten seleccionar valores de una lista de forma aleatoria. Toman una lista como argumento y seleccionan aleatoriamente un valor (o valores en el caso de choices()). También, se puede aplicar una matriz con pesos para aumentar la probabilidad de que determinado valor sea elegido.
  • shuffle(): “baraja” una lista. Esta función ‘mezcla’ o cambia aleatoriamente el orden de los elementos de una lista antes de seleccionar uno de ellos
  • gauss(): genera un conjunto de números aleatorios cuya distribución de probabilidad es una distribución gaussiana o normal (muy frecuente en el mundo real). Existen funciones similares para otros distribuciones diferentes.

Ejemplos prácticos

Veamos unos sencillos ejemplos de aplicación de las funciones anteriores. En el manual de Python, se puede encontrar toda la información sobre éstas y las demás funciones del módulo random.

Recordamos que, como ocurre con todas las bibliotecas, antes de utilizar una función se debe importar la función o la biblioteca entera.

# Para importar la biblioteca random al completo
import random

# Para importar sólo determinadas funciones (randrange y choice)
from random import randrange, choice

Función randint()

La función randint(a, b) genera un número entero entre a y b, ambos incluidos. a debe ser inferior o igual a b. Por ejemplo, para generar un número aleatorio del 1 al 10 pondríamos:

# Generar un número entero aleatorio entre 10 y 20 (incluidos)
print(random.randint(1, 10))

Función randrange()

La función randrange() admite hasta tres argumentos (inicio, fin, paso). Por ejemplo.

# Generar un número entero aleatorio entre 10 y 110 con paso 2
print(random.randrange(10, 110, 2))

Funciones choice()choices()

Estas funciones permiten elegir uno (o varios) elementos de una lista. También, como en este ejemplo, permite trabajar con cadenas de caracteres (strings)

# Elegir aleatoriamente uno (o varios, en este caso 2) colores de la lista
color=( ['rojo', 'amarillo', 'verde', 'azul', 'marrón', 'negro'])

# Un color
print (random.choice(color))

# Una pareja de colores
print (random.choices(color,k=2))

Si queremos que uno de los elementos tenga mayor probabilidad de salir elegido, aplicamos una matriz “peso”. En este ejemplo, pedimos que saque 10 combinaciones de 3 colores, y que el color azul, sea 5 veces más probable que el resto:

for _ in range(10):
   print('Combinación de 3 colores al azar=>',random.choices(color,weights=[1,1,1,5,1,1],k=3))
Resultado

Función shuffle()

Con la función Shuffle, “barajas” o cambiar de posición aleatoriamente los elementos de una lista cualquiera.

# "Barajamos" con shuffle una lista de números
lista = [5, 3, 45, 27, 2, 10, 82]

# La lista tal cual
print('Lista original=>',lista)
random.shuffle(lista)

# La lista mezclada
print('Lista mezclada=>',lista)
Resultado

Función gauss()

La función gauss() usa como argumentos la media y la desviación estándar, para generar valores aleatorios que sigan una distribución normal. En este ejemplo, generamos un conjunto de números (pseudo)-aleatorios que siguen una distribución gaussiana, con media 0 y desviación estándar 1.

for _ in range(10):
   print((random.gauss(0,1)))
Resultado

Si queremos ver la gráfica, para, por ejemplo, 1000 valores,

import random
import matplotlib.pyplot as plt
%matplotlib inline

campana=[random.gauss(1,0.5) for i in range(1000)]
plt.hist(campana, bins=15)
plt.show() 
Resultado

Últimas entradas del blog:


Si quiere probar a implementar tu propio generador de números aleatorios lo más “verdadero” posible una Raspberry Pi, no te pierdas este otro post.


Deja un comentario

Python para todos: crea tu árbol de Navidad

Abeto de Navidad

Para estas fechas navideñas, nos hemos propuesto jugar un poco con Python para ver cómo podríamos dibujar un árbol de Navidad. Empezaremos con algo muy sencillito y luego probaremos con la librería gráfica Turtle. La idea es animaros a experimentar y crear vuestro propio árbol, según vuestro nivel de conocimientos.

1. Un sencillo bucle for

Para crear este primer árbol usaremos dos sencillos bucles for, y las funciones random y print.

El bucle for que no es más que una estructura de control que repite un bloque de instrucciones, el cuerpo del bucle, un número predeterminado de veces. Cada repetición es una iteración. La sintaxis del bucle for es la siguiente:

for variable in elemento iterable (lista, cadena, range, etc.):
cuerpo del bucle

El cuerpo del bucle se ejecuta tantas veces como elementos tenga el elemento iterable (elementos de una lista o de un range(), caracteres de una cadena, etc.). No es necesario definir la variable de control “i” antes del bucle, pero se puede utilizar una variable ya definida en el programa.

También usaremos la función range, que devuelve una secuencia de números entre el valor inicial (start) y el final (stop), con un intervalo dado (step), y la función print, que muestra el objeto que se le pasa como parámetro en el dispositivo de salida elegido. Su sintaxis es:

print<em>(object(s)</em>, sep=<em>separator</em>, end=<em>end</em>, file=<em>file</em>, flush=<em>flush</em>)

El código para nuestro árbol es el siguiente:

#Primer bucle, range(start,stop,step)
for i in range(1,30,2):
print(('^'*i).center(30))

for leg in range(3):
print(('|||').center(30))
print(('\_____/').center(30))
print(' '+30*'-')
print('(<em>¨</em>¨<em>¨</em>)¡Feliz Navidad! (<em>¨</em>¨<em>¨</em>)')

Y el resultado:

Reconozcámoslo, es un árbol muy sencillo, pero para empezar, no está mal ¿no?. Vamos a por el siguiente.

2. Nuestro árbol con Turtle

Los gráficos de tortuga (Turtle graphics) formaban parte del lenguaje de programacion Logo, desarrollado por por Wally Feurzeig, Seymour Papert y Cynthia Solomon en 1967. Por su sencillez y atractivo, se han usado mucho para enseñar programación utilizado como método para enseñar programación a través de coordenadas relativas a niños y mayores.

Cómo dibujar con Turtle Graphics

La “tortuga (turtle) es un objeto que se desplaza sobre el plano de coordenadas x-y y nos permite dibujar todo tipo de figuras. Tiene 3 atributos esenciales:

  • Posición: Respecto al centro de coordenadas.
  • Orientación: Dirección hacia donde mira la tortuga.
  • Pluma: Rastro que puede dejar la tortuga al desplazarse.

Para desplazar nuestro objeto turtle disponemos de funciones como:

  • forward(distance): Avanzar una determinada cantidad de píxeles.
  • backward(distance): Retroceder una determinada cantidad de píxeles.
  • left(angle): Girar hacia la izquierda un determinado ángulo.
  • right(angle): Girar hacia la derecha un determinado ángulo.

A menos que especifiquemos lo contrario, al desplazarse la tortuga pinta un rastro. Si queremos que se desplace sin dejar rastro, podemos usar las funciones:

  • home(distance): Desplazarse al origen de coordenadas.
  • goto((x, y)): Desplazarse a una coordenada en concreto.
  • penup(): Subir el lápiz para no mostrar el rastro.
  • pendown(): Bajar el lápiz para mostrar el rastro.

También podemos cambiar el color, grosor o forma y tamaño de la punta del lápiz:

  • shape(‘turtle’): Cambia al objeto tortuga.
  • pencolor(color): Cambiar al color especificado.
  • pensize(dimension): Tamaño de la punta del lápiz.

Árbol de Navidad con Python Turtle

Python es un lenguaje que soporta el paradigma de Programación Orientada a Objetos, y en este caso nuestro objeto va a ser el puntero (turtle) que vamos a utilizar para dibujar una figura.

Como siempre, lo primero que tenemos que hacer es importar la librería que permite utilizar las funciones de movimiento de la tortuga.

#Importamos el módulo turtle que permite crear gráficos de tortuga 

import turtle

A continuación, creamos la ventana para dibujar, indicando sus dimensiones y posición. También podemos ponerle el título que queramos.

Para que no quede el fondo blanco, hemos buscado un fondo navideño, y lo hemos guardado en el directorio de trabajo. (Si no tenemos claro cuál es, podemos averiguarlo con os.getcwd()). Para no complicarnos demasiado con los tamaños, hemos ajustado el tamaño de la ventana al de la imagen.

Esta es la imagen de nuestro fondo:

# Generamos una instancia de la clase screen de turtle 
screen = turtle.Screen()

# Con los métodos setup y title establezco propiedades (tamaño y nombre de la ventana)
screen.setup(1200,700,0,0)
screen.title("Nuestro árbol de Navidad en Python")

# Con el método bgpic cambiamos el atributo "fondo" (el fichero png debe estar en el directorio de trabajo, os.getcwd())
screen.bgpic("fondonavidad.png")

# Al definir el tamaño de la ventana ya hemos tenido en cuenta el del fondo que hemos elegido 

El siguiente paso será definir nuestro lápiz o tortuga (“turtle”). Le daremos distinta forma y color según lo que queramos dibujar. Para dibujar el árbol, veremos que las formas estándar “square” y “circle” nos vienen bien.

#Definimos el lápiz con el que vamos a dibujar el árbol y sus adornos


# Generamos una instancia de la subclase Turtle (pen) de turtle, es decir un "lápiz"
# Con los métodos shape, colour y speed, definimos su aspecto y a qué velocidad se va a mover (más adelante, en el bucle)
# Levantamos el cursor para que no pinte hasta que le digamos dónde debe hacerlo

lapiz = turtle.Turtle()
lapiz.up()


Vamos a definir una imagen no estándar para la estrella que corona el árbol. Para ello, usaremos el método register_shape y un gif con tamaño adecuado. (También podíamos haber ajustado el tamaño desde dentro del programa, pruébalo si quieres investigar un poco más). Una vez definido el lápiz como “estrella”, dibujamos la estrella con el método stamp.

# Empezamos por ¡el tejado!: la estrella
# Definimos una forma especial para el "pen" basado en un gif con estrella con fondo transparente mediante el método register_shape 
# El gif, con el tamaño adecuado, en este caso 50*50 píxeles, debe estar en el directorio de trabajo

screen.register_shape("star5.gif")
lapiz.shape('star5.gif')
 

#Lo llevamos a la posición que queremos y pintamos
lapiz.goto(0,310)
lapiz.stamp()

A partir de la estrella, continuamos dibujado el árbol. Para ello usaremos un bucle que dibujará 16 filas de cuadrados verdes. Definimos el lápiz como cuadrado verde, y dibujamos la parte derecha del árbol. A continuación, dibujamos la parte izquierda.

Una vez dibujado el árbol en sí, lo adornaremos con bolas rojas y amarillas. Pondremos bolas rojas en las filas que son múltiplos de 3, por ejemplo, y amarillas en las múltiplos de 5.

Por último, volvemos a definir el lápiz como cuadrado marrón para dibujar el tronco con un último bucle muy sencillo.

(Para elegir los colores, seguro que os viene bien esta página)

# Para pintar el árbol vamos a usar un bucle
# Inicializo k, el árbol lo forman 16 filas de cuadrados verdes

k = 0
for i in range(1, 17):
    y = 30*i
# Definimos lapiz cuadrado y verde #138808
    lapiz.shape('square')
    lapiz.color('#138808')
    lapiz.speed('fastest')
    for j in range(i-k):
        x = 30*j
        
# Dibujamos la parte derecha del árbol, 
        lapiz.goto(x,-y+300)
        lapiz.stamp()
# Dibujamos la parte izquierda del árbol
        lapiz.goto(-x,-y+300)
        lapiz.stamp()

# Colocamos las bolas rojas en las filas que son múltiplos de 5. Definimos lapiz redondo y amarillo (##ffff31)

    if i % 5 == 0:
        x =  30*(j+1)
        lapiz.shape('circle')
        lapiz.color('#ffff31')
        lapiz.speed('fastest')
      
        lapiz.goto(-x,-y+300)
        lapiz.stamp()
        lapiz.goto(x,-y+300)
        lapiz.stamp()        
        k += 3
        
# Colocamos las bolas rojas en las filas impares. Cambiamos color del lapiz a rojo (red)

    if i % 3 == 0:
        x =  30*(j+1)
        lapiz.shape('circle')
        lapiz.color('red')
        lapiz.goto(-x,-y+300)
        lapiz.stamp()
        lapiz.goto(x,-y+300)
        lapiz.stamp() 

# Dibujamos el tronco del árbol. Volvemos a lapiz cuadrado, y color marrón
lapiz.shape('square')
lapiz.color('#cc5500')
for i in range(14,20):
    y = 30*i
    for j in range(2):    
        x = 30*j
        
        lapiz.goto(x,-y+200)
        lapiz.stamp()
        lapiz.goto(-x,-y+200)
        lapiz.stamp()        
        
turtle.exitonclick()

Eh voilá!, ya tenemos nuestro arbolito navideño.

¡Felices Fiestas!


Deja un comentario

Python para todos: Diferencia entre método y función

Cuando damos nuestros primeros pasos en Python, nos encontramos con dos conceptos muy similares que nos pueden llevar a confusión: funciones y métodos. En este post, intentaremos aclarar esta duda de forma muy sencilla.

Funciones en Python

Como en otros lenguajes de programación, una función no es más que una porción o bloque de código reutilizable que se encarga de realizar una determinada tarea.

Resulta muy cómodo trabajar con funciones, porque no es necesario reescribir ese código cada vez que nos enfrentamos a dicha tarea. Tan solo, llamar a la función.

“Built-in” functions

En Python hay funciones ya creadas (built-in functions), que pueden requerir o no parámetros, como por ejemplo, la función help(), que ofrece la ayuda del sistema sobre determinado comando, la función abs(), que devuelve el valor absoluto de un número etc…

Figura 1: ejemplo de uso de la función help()
Figura 1: ejemplo de uso de la función help()
Figura 2: ejemplo de uso de la función abs()
Figura 2: ejemplo de uso de la función abs()

Crear funciones en Python

Si no existe ya la función que necesitamos, resulta muy sencillo crearla en Python. Primero la declaramos con def (nombre función), y luego definimos su contenido (código indentado dentro de la función).

Por ejemplo, podemos crear una función que sume dos números. Después, hacemos una llamada a la función, facilitándole los valores de los dos parámetros:

Figura 3: ejemplo de definición de la función sumar()
Figura 3: ejemplo de definición de la función sumar()

Hasta aquí, todo muy claro. Pasamos a introducir el segundo concepto. Veremos que un método, es algo parecido a una función, una porción de código que realiza determinada tarea, pero no es exactamente lo mismo.

Métodos en Python

Python es un lenguaje multiparadigma, que soporta programación orientada a objetos (POO), siendo las clases y los objetos sus principales bloques de desarrollo. Las clases son los modelos sobre los cuáles se construirán nuestros objetos, mientras que los objetos son instancias de esa clase.

Por ejemplo, vamos a crear la clase “Persona”, con dos atributos, “nombre” y “edad”. A continuación, creamos un objeto de esa clase: Pablo, 30 años.

Figura 4: ejemplo de definición de una clase y un objeto
Figura 4: ejemplo de definición de una clase y un objeto

Los métodos son acciones o funciones que puede realizar un objeto. Al igual que Python ofrece una serie de funciones “built-in”, también pone a nuestra disposición un conjunto de métodos ya creados. Estos métodos dependen del tipo de objeto con el que estemos trabajando.

Los objetos en Python pueden ser de distintos tipos:

  • cadena de caracteres (string)
  • booleanos (booleans)
  • números enteros (integer)
  • números decimales (float)
  • listas (list)

Por ejemplo, para los objetos tipo cadena de caracteres, tenemos métodos como :

  • capitalize(), que convierte en mayúscula la primera letra de la cadena
  • index(), que busca determinado carácter en la cadena y devuelve su posición
  • split(), que divide la cadena según el separador que indiquemos y la convierte en un lista
  • title(), que convierte el primer carácter de cada palabra en mayúsculas
  • etc

También hay métodos ya creados para otro tipo de objetos, como listasdiccionariostuplassets o incluso ficheros. Si no nos sirve ninguno para nuestro objetivo, siempre podemos crearlo nosotros mismos, como ocurre con las funciones.

Para acceder a los métodos y propiedades de un objeto, Python utiliza una sintaxis muy simple: el nombre del objeto, seguido de punto y la propiedad o método al cuál se desea acceder.

Por ejemplo, vamos a probar los métodos title() y count() sobre el string “primavera”:

Figura 5: ejemplo de uso de métodos de string
Figura 5: ejemplo de uso de métodos de string

Métodos vs funciones

¿Cuál es entonces la diferencia entre métodos y funciones?. La principal diferencia es que un método es parte de una clase, es decir, es parte de la funcionalidad que le damos a un objeto. Por tanto, siempre va a estar asociado a un objeto. Sin embargo, las funciones en Python, están definidas por si mismas no pertenecen a ninguna clase.

Al ser intrínsecos al objeto en sí, cada objeto tiene sus propios métodos. Incluso aunque se llamen igual, pueden tener un significado distinto. Por ejemplo, el método index está disponible para los objetos string y list. Sobre una cadena de caracteres, da el índice de la letra en esa palabra, sobre una lista, da la posición de un elemento en una lista.

Si te interesa saber más sobre Python, visita la sección de Tutoriales 🙂


2 comentarios

Las 5 razones por las que todo el mundo quiere aprender Python

Python es, en estos momentos, el lenguaje de programación más popular.  Personas tan distintas como niños, estudiantes, profesores, investigadores de todo tipo (Ciencias Sociales, Biología, Medicina, Economía…), expertos en Finanzas, Seguros, Marketing, desarrolladores, analistas o científicos de datos lo aprenden y lo utilizan en sus campos de interés. En el post de hoy, vamos a intentar explicar el porqué.

¿Cómo se mide la popularidad de un lenguaje de programación? Depende de quien lo pregunte.

Los desarrolladores lo hacen calculando el número de preguntas que se hacen sobre él en webs como StackOverflow. Se trata de webs donde consultan sus dudas y comparten conocimiento con la comunidad. Así, aunque JavaScript sigue siendo el lenguaje con mayor número de preguntas acumuladas desde la creación de Stack Overflow, Python se ha convertido en el lenguaje que más interés ha despertado en lo que va de año.

Image Credit: Stack Overflow
Previsión del tráfico futuro sobre los principales lenguajes de programación
Image Credit: Stack Overflow

(Los desarrolladores más «puristas» prefieren consultar índices como el PYPL o rankings como el del IEEE.)

Y, a los no programadores, seguro que esta frase, de The Economist les sirve para hacerse un idea:

“En los últimos 12 meses, en EEUU, se han realizado más búsquedas en Google de Python que de Kim Kardashian”

Python has brought computer programming to a vast new audience”

¿De verdad que Python es más popular que Kim Kardashian en EEUU?. Pues parece que sí 😉 Veremos alguna de las razones, pero antes de nada, explicaremos qué es Python.

Python en pocas palabras

Para «calentar motores», empecemos por un dato curioso. ¿Recordáis “La vida de Brian”? ¿El famoso spot del «Spam»? El nombre de Python no tiene ninguna connotación zoológica, sino que es un homenaje de su autor al inolvidable grupo cómico inglés Monty Python, protagonista de una de las mejores comedias de la historia del cine.

Retomamos la seriedad para empezar con una definición técnica que iremos “desgranando” poco a poco:

Python es un lenguaje de programación interpretado de código abierto, multiparadigma, aunque principalmente orientado a objetos de alto nivel. Su sintaxis hace énfasis en la legibilidad del código, lo que facilita su depuración y, por tanto, favorece la productividad. Ofrece la potencia y la flexibilidad de los lenguajes compilados con una curva de aprendizaje suave.

A partir de esta definición, analizaremos las 5 razones por las que Python ha ganado tanta popularidad en los últimos años.

1. Python es un lenguaje interpretado

Python fue creado por Guido Van Rossum en 1991 como lenguaje de programación interpretado de uso general.

¿Qué significa que un lenguaje de programación sea interpretado?

Los lenguajes de bajo nivel, como lenguaje máquina o ensamblador, pueden ejecutarse directamente en una computadora. Los de alto nivel, como Java, C, C++ o el propio Python, por su parte, tienen que ser reinterpretados (compilados) como lenguajes de bajo nivel antes de poder ser ejecutados. Esto hace que los tiempos de ejecución normalmente sean más lentos. Sin embargo, hoy día, esto no es un problema ya que los avances en computación en la nube (cloud computing), permiten disponer de capacidades de cálculo a medida a costes muy asequibles. También influye cómo de optimizado está el código.

Con Python, programar es sencillo

Programar en código máquina es costoso y difícil. Python ofrece una sintaxis mucho más sencilla y cercana a la lógica de los humanos. Un código más legible resulta más sencillo de generar, depurar, y mantener. Por ello, la curva de aprendizaje de los lenguajes interpretados es mucho más suave.


2. Python es potente, flexible y versátil

Veamos el por qué de esta potencia y versatilidad. Argumentos, no nos faltan.

Es un lenguaje de propósito general

Al ser un lenguaje de propósito general, y no creado específicamente para desarrollo web, Python permite crear todo tipo de programas y herramientas.

Es compatible con otros lenguajes de programación

Su interoperabilidad con otros lenguajes de programación como C, Java, R, etc., es otro de los factores que han ayudado a su gran difusión en distintos ámbitos.

Permite trabajar con distintos modelos de programación

En Python, todo es un objeto. No obstante, aunque sea un lenguaje principalmente orientado a objetos, combina propiedades de distintos modelos o paradigmas de programación (imperativa, funcional, procedural o reflexiva).

Ofrece librerías y entornos especializados en temas muy diversos

Por otra parte, Python ofrece librerías y entornos de desarrollo muy potentes para Machine LearningCienciasvisualización de datos etc.  Por ejemplo:

  • Matemáticos y científicos utilizan SciPy y NumPy en sus investigaciones
  • Los lingüistas analizan textos con NLTK (the Natural Language Tool Kit),
  • Los estadísticos, usan Pandas para analizar datos
  • Los equipos de IT configuran y gestionan recursos en la nube con OpenStack
  • Los desarrolladores usan Django para crear aplicaciones web
  • etc.

Es el lenguaje de referencia en Data Science y Machine Learning

De hecho, se ha convertido en el lenguaje de referencia en Data Science, siendo el preferido por un 57% de los científicos de datos y desarrolladores. Si tenemos en cuenta la evolución de los dos últimos años de entornos Python para Deep Learning, incluyendo la creación de Tensorflow y otras librerías especializadas, no nos extrañará que haya dejado atrás otros lenguajes como R, Julia, Scala, Ruby, Octave, MATLAB y SAS.

Es lenguaje de referencia en Educación

El hecho de que sea un lenguaje tan sencillo como para que lo puedan usar desde principiantes a programadores profesionales también lo ha convertido en el lenguaje de programación por excelencia en entornos educativos. Y no sólo por su sencillez, sino también por el hecho de que se pueda ejecutar en distintos sistemas operativos (Microsoft Windows, Mac OS X, Linux, o usando el intérprete correspondiente). También es accesible a través de servicios web como  Python Anywhere.

Esto es especialmente importante para el sector educativo porque se puede usar desde los equipos del aula de informática de las escuelas, o incluso desde casa, sin necesidad de instalar software adicional.

Gracias a esto, Python ha estado en el centro de distintos proyectos educativos muy interesantes, como los que veremos a continuación.

En 2015, la BBC lanzó el proyecto MicroBit project. Se trata de un pequeño dispositivo programable, micro:bit, cuyo objetivo es inspirar a una nueva generación de creadores, makers y coders, dirigido a niños a partir de 11 años de edad.

Otros proyectos, como MicroPython project, permiten trabajar con otros pequeños dispositivos, como Raspberry Pi, y usarse como base de muchos interesantes y entretenidos proyectos de electrónica para controlar pantallas, altavoces, micrófonos, motores etc. Incluso, crear sencillos robots.

En resumen, Python, sirve para crear todo tipo de herramientas, se puede ejecutar sobre distintos sistemas operativos, es compatible con otros lenguajes de programación y ofrece librerías y frameworks especializados en distintas áreas de conocimiento.


3. Python es un proyecto de software libre (free software)

Python Project nació como un proyecto de código libre (free software). Hasta hace muy poco, todavía era dirigido por su creador, Guido van Rossum, quien, nuevo guiño a Monty Python, ejerció durante casi tres décadas el rol de «benevolente dictador vitalicio» (Benevolent dictator for life) de la PSF.

Guido van Rossum By Alessio Bragadini - originally posted to Flickr
By Alessio Bragadini – originally posted to Flickr as Guido van Rossum

¿Qué caracteriza al software libre?

El software libre, “free software” no es necesariamente siempre gratuito (aunque Python sí lo sea), sino que se caracteriza por el escrupuloso respeto a las conocidas como “4 libertades”:

  1. La libertad de usar el programa, con cualquier propósito. (libertad 0)
  2. La libertad de estudiar cómo funciona el programa, y adaptarlo a tus necesidades. (libertad 1)
  3. La libertad de distribuir copias, con lo que puedes ayudar a tu vecino. (libertad 2)
  4. La libertad de mejorar el programa y hacer públicas las mejoras a los demás, de modo que toda la comunidad se beneficie. (libertad 3)

Para que las libertades 1 y 3 sean posibles es necesario que los usuarios puedan tener acceso al código fuente de los programas.

En resumen,  software libre son aquellos programas que una vez obtenidos pueden ser usados, copiados, estudiados, modificados y redistribuidos libremente. Por tanto, la “libertad” del software está relacionada con los permisos que su autor ofrece y no con su precio.

Python se publica bajo la licencia Python Software Foundation License . La PSF es una organización sin ánimo de lucro, que fue creada en 2001 con el objetivo de gestionar el proyecto (desarrollo, administración de derechos, recaudación de fondos etc). Y es compatible con la GPL de GNU Licencia Pública General de GNU ,a partir de la versión 2.1.1).


4. Python es un lenguaje de código abierto (open source)

Además de libre, Python es un lenguaje de código abierto, que es parecido, pero no es lo mismo. Según Richard Stallman, tanto el software libre como el código abierto persiguen un objetivo común: dar mayor libertad y transparencia al mundo del software.  Sin embargo, difieren en la manera de llevarlo  cabo.

El software libre se define por su ética. Se considera software libre no sólo los programas cuyo código esté abierto, sino todos aquellos programas que respetan la cuatro libertades esenciales del usuario definidas por la Free Software Foundation (1985).

El concepto de software abierto surgión en 1998, cuando se creó la OSI (Open source initiative) como una escisión del software libre. En este caso, en lugar de las 4 libertades del software libre, se definieron 10 requisitios. que debe cumplir un software para ser considerado abierto.

La diferencia principal entre uno y otro tipo de software es sutil. El software libre prioriza los aspectos éticos, mientras que el software de código abierto prioriza los de índole técnica. Por ello, es normalmente menos estricto, de modo que todo el software libre es también de código abierto, pero no necesariamente a la inversa.

En cualquier caso, Python es libre y es abierto.  Y en esto radica una de las claves del éxito de Python: la comunidad Python. Se trata de una comunidad amplia y muy activa, que contribuye al desarrollo y mejora del código fuente, según las necesidades y demandas de los usuarios. Porque, aunque muchas empresas y organizaciones, como Google, Microsoft o Red Hat, utilizan mucho este lenguaje y tienen influencia en su evolución, ninguna ejerce un control sobre el mismo.

Este carácter libre y abierto, sin duda también ha facilitado la versatilidad, flexibilidad y potencia mencionadas en el punto anterior, ya que además de todo lo mencionado anteriormente, Python es un lenguaje multiplataforma. Es decir, podemos ejecutarlo en diferentes sistemas operativos como Windows o Linux simplemente usando el intérprete correspondiente.


5. Y además… es gratis

Como hemos apuntado antes, a pesar de la confusión que puede generar el hecho de que, en inglés, “free”, además de libre, significa gratis, el software libre no tiene por qué ser necesariamente gratis.  Sin embargo, sí se puede afirmar, que para programar en Python, no es necesario pagar ningún tipo de licencia. Sin embargo, no debemos olvidar nunca que cualquier código no desarrollado por nosotros mismos puede estar sometido a algún tipo de licenciamiento.

Conclusión

En resumen, la sencillez,  versatilidad, y potencia de Python le han convertido en ese lenguaje de programación todoterreno que puede ayudar a impulsar la alfabetización digital de amplios sectores de la población, haciendo accesible la programación a personas y profesionales de todo tipo.

¿Y tú? ¿te atreves con el Python?


Post original publicado en ThinkBig Empresas