{"id":335973,"date":"2023-03-24T12:33:21","date_gmt":"2023-03-24T11:33:21","guid":{"rendered":"https:\/\/blog.jetbrains.com\/?post_type=pycharm&p=335973"},"modified":"2023-03-24T12:33:25","modified_gmt":"2023-03-24T11:33:25","slug":"uso-de-pycharm-para-leer-datos-de-una-base-de-datos-mysql-en-pandas","status":"publish","type":"pycharm","link":"https:\/\/blog.jetbrains.com\/es\/pycharm\/2023\/03\/uso-de-pycharm-para-leer-datos-de-una-base-de-datos-mysql-en-pandas\/","title":{"rendered":"Uso de PyCharm para leer datos de una base de datos MySQL en pandas"},"content":{"rendered":"

Tarde o temprano en su recorrido por la ciencia de datos, llegar\u00e1 a un punto en el que necesitar\u00e1 obtener datos de una base de datos. Sin embargo, dar el salto de la lectura de un archivo CSV almacenado localmente en pandas a la conexi\u00f3n y consulta de bases de datos puede ser una tarea abrumadora. En la primera de una serie de art\u00edculos del blog, exploraremos c\u00f3mo leer datos almacenados en una base de datos MySQL en pandas, y veremos algunas caracter\u00edsticas \u00fatiles de PyCharm que facilitan esta tarea.<\/p>\n

\n
\"\"<\/figure>\n<\/div>\n

Visualizaci\u00f3n del contenido de la base de datos<\/h2>\n

En este tutorial, vamos a leer algunos datos sobre retrasos y cancelaciones de aerol\u00edneas desde una base de datos MySQL a un DataFrame de pandas. Estos datos son una versi\u00f3n del conjunto de datos \u201cAirline Delays from 2003-2016\u201d<\/a> de Priank Ravichandar<\/a> con licencia CC0 1.0<\/a>.<\/p>\n

Una de las primeras cosas que puede resultar frustrante de trabajar con bases de datos es no tener una visi\u00f3n general de los datos disponibles, ya que todas las tablas se almacenan en un servidor remoto. Por lo tanto, la primera funci\u00f3n de PyCharm que vamos a utilizar es la ventana de herramientas Database<\/em>, que le permite conectarse a una base de datos e introspeccionarla completamente antes de realizar cualquier consulta.<\/p>\n

Para conectarnos a nuestra base de datos MySQL, primero vamos a navegar por la parte derecha de PyCharm y hacer clic en la ventana de la herramienta Database<\/em>.<\/p>\n

\n
\"\"<\/figure>\n<\/div>\n

En la parte superior izquierda de esta ventana, ver\u00e1 un bot\u00f3n m\u00e1s. Al hacer clic en \u00e9l, nos aparece el siguiente cuadro de di\u00e1logo desplegable, en el que seleccionaremos Data Source <\/em>| MySQL<\/em>.<\/p>\n

\n
\"\"<\/figure>\n<\/div>\n

Ahora tenemos una ventana emergente que nos permitir\u00e1 conectarnos a nuestra base de datos MySQL. En este caso, estamos utilizando una base de datos alojada localmente, por lo que dejamos Host<\/em> como \u00ablocalhost\u00bb y Port<\/em> como el puerto MySQL predeterminado de \u00ab3306\u00bb. Utilizaremos la opci\u00f3n Authentication<\/em> de \u00abUser & Password\u00bb, e introduciremos \u00abpycharm\u00bb tanto para en User<\/em> como en Password<\/em>. Por \u00faltimo, introducimos el nombre \u00abdemo\u00bb en Database<\/em>. Por supuesto, para conectarse a su propia base de datos MySQL necesitar\u00e1 el host espec\u00edfico, el nombre de la base de datos y su nombre de usuario y contrase\u00f1a. Consulte la documentaci\u00f3n<\/a> para conocer todas las opciones.<\/p>\n

\n
\"\"<\/figure>\n<\/div>\n

A continuaci\u00f3n, haga clic en Test Connection<\/em>. PyCharm nos avisa de que no tenemos instalados los archivos del controlador. Siga adelante y haga clic en Download Driver Files<\/em>. Una de las funcionalidades m\u00e1s interesantes de la ventana de herramientas Database<\/em> es que encuentra e instala autom\u00e1ticamente los controladores correctos.<\/p>\n

\n
\"\"<\/figure>\n<\/div>\n

\u00a1Listo! Nos hemos conectado a nuestra base de datos. Ahora podemos navegar hasta la pesta\u00f1a Schemas<\/em> y seleccionar qu\u00e9 esquemas queremos introspeccionar. En nuestra base de datos de ejemplo solo tenemos una (\u00abdemo\u00bb), pero en los casos en los que tenga bases de datos muy grandes, puede ahorrarse tiempo introspeccionando solo las relevantes.<\/p>\n

\n
\"\"<\/figure>\n<\/div>\n

Una vez seguidos estos pasos, ya podemos conectarnos a nuestra base de datos. Pulse OK<\/em> y espere unos segundos. Ahora puede ver que toda nuestra base de datos ha sido introspeccionada, hasta el nivel de los campos de tabla y sus tipos. Esto nos da una gran visi\u00f3n general de lo que hay en la base de datos antes de ejecutar una consulta.<\/p>\n

\n
\"\"<\/figure>\n<\/div>\n

Lectura de los datos mediante MySQL Connector<\/h2>\n

Ahora que sabemos lo que hay en nuestra base de datos, estamos listos para elaborar una consulta. Digamos que queremos ver los aeropuertos que sufrieron al menos 500 retrasos en 2016. Observando los campos de la tabla introspeccionada airlines<\/code>, vemos que podemos obtener esos datos con la siguiente consulta:<\/p>\n

SELECT AirportCode,\n      SUM(FlightsDelayed) AS TotalDelayed\n   FROM airlines\n   WHERE TimeYear = 2016\n   GROUP BY AirportCode\n   HAVING SUM(FlightsDelayed) > 500;<\/pre>\n
La primera forma en que podemos ejecutar esta consulta con Python es utilizando un paquete llamado \u00abMySQL Connector\u00bb, que puede instalarse desde PyPI<\/a> o Anaconda<\/a>. Consulte la documentaci\u00f3n vinculada si necesita orientaci\u00f3n para configurar entornos pip<\/a> o conda<\/a> o instalar dependencias<\/a>. Una vez finalizada la instalaci\u00f3n, abriremos un nuevo Jupyter Notebook<\/a> e importaremos tanto MySQL Connector como pandas.<\/p>\n
import mysql.connector\nimport pandas as pd<\/pre>\n
Para leer los datos de nuestra base de datos, necesitamos crear un conector<\/a>. Para ello se utiliza el m\u00e9todo connect<\/code>, al que pasamos las credenciales necesarias para acceder a la base de datos: host<\/code>, database<\/code>, user<\/code> y password<\/code>. Se trata de las mismas credenciales que utilizamos para acceder a la base de datos mediante la ventana de herramientas Database<\/em> en la secci\u00f3n anterior.<\/p>\n
mysql_db_connector = mysql.connector.connect(\n   host=\"localhost\",\n   database=\"demo\",\n   user=\"pycharm\",\n   password=\"pycharm\"\n)<\/pre>\n
Ahora necesitamos crear un cursor<\/a>. Se utilizar\u00e1 para ejecutar nuestras consultas SQL en la base de datos, y usa las credenciales ordenadas en nuestro conector para obtener acceso.<\/p>\n
mysql_db_cursor = mysql_db_connector.cursor()<\/pre>\n
Ahora estamos listos para ejecutar nuestra consulta. Lo hacemos utilizando el m\u00e9todo<\/a> execute<\/code> de nuestro cursor y pasando la consulta como argumento.<\/p>\n
delays_query = \"\"\"\n               SELECT AirportCode,\n                      SUM(FlightsDelayed) AS TotalDelayed\n                   FROM airlines\n                   WHERE TimeYear = 2016\n                   GROUP BY AirportCode\n                   HAVING SUM(FlightsDelayed) > 500;\n              \"\"\"\n\nmysql_db_cursor.execute(delays_query)<\/pre>\n
A continuaci\u00f3n, obtenemos el resultado utilizando el m\u00e9todo<\/a> fetchall<\/code> del cursor.<\/p>\n
mysql_delays_list = mysql_db_cursor.fetchall()<\/pre>\n
Sin embargo, en este punto tenemos un problema: fetchall<\/code> devuelve los datos como una lista. Para introducirlo en pandas, podemos pasarlo a un DataFrame, pero perderemos los nombres de nuestras columnas y tendremos que especificarlos manualmente cuando queramos crear el DataFrame.<\/p>\n
\n
\"\"<\/figure>\n<\/div>\n
Por suerte, pandas ofrece una forma mejor. En lugar de crear un cursor, podemos leer nuestra consulta en un DataFrame en un solo paso, utilizando el m\u00e9todo <\/a> read_sql<\/code>.<\/p>\n
mysql_delays_df2 = pd.read_sql(delays_query, con=mysql_db_connector)<\/pre>\n
Solo tenemos que pasar nuestra consulta y el conector como argumentos para leer los datos de la base de datos MySQL. Observando nuestro marco de datos, podemos ver que obtenemos exactamente los mismos resultados que antes, pero esta vez se han conservado los nombres de nuestras columnas.<\/p>\n
\n
\"\"<\/figure>\n<\/div>\n
Una funcionalidad estupenda que puede que haya visto es que PyCharm aplica resaltado de sintaxis a la consulta SQL, incluso cuando est\u00e1 contenida dentro de una cadena Python. Describiremos otra forma en la que PyCharm le permite trabajar con SQL m\u00e1s adelante en este art\u00edculo del blog.<\/p>\n
Lectura de los datos mediante SQLAlchemy<\/h2>\n
Una alternativa al uso de MySQL Connector es utilizar un paquete llamado SQLAlchemy<\/a>. Este paquete ofrece un m\u00e9todo \u00fanico para conectarse a una serie de bases de datos diferentes, incluida MySQL. Una de las ventajas de utilizar SQLAlchemy es que la sintaxis para consultar diferentes tipos de bases de datos sigue siendo coherente en todos los tipos de bases de datos, lo que le ahorra tener que recordar un mont\u00f3n de comandos diferentes si trabaja con muchas bases de datos distintas.<\/p>\n
Para empezar, necesitamos instalar SQLAlchemy desde PyPI<\/a> o Anaconda<\/a>. A continuaci\u00f3n, importamos el m\u00e9todo create_engine<\/code> y, por supuesto, pandas.<\/p>\n
import pandas as pd\nfrom sqlalchemy import create_engine<\/pre>\n
Ahora tenemos que crear nuestro motor<\/a>. El motor nos permite decirle a pandas qu\u00e9 dialecto SQL estamos utilizando (en nuestro caso, MySQL) y proporcionarle las credenciales que necesita para acceder a nuestra base de datos. Todo esto se pasa como una sola cadena con la forma siguiente: [dialect]:\/\/[user]:[password]@[host]\/[database]<\/code>. Veamos qu\u00e9 aspecto tiene esto en el caso de nuestra base de datos MySQL:<\/p>\n
mysql_engine = create_engine(\"mysql+mysqlconnector:\/\/pycharm:pycharm@localhost\/demo\")<\/pre>\n
Con esto creado, solo tenemos que utilizar read_sql<\/code> de nuevo, esta vez pasando el motor al argumento con<\/code>:<\/p>\n
mysql_delays_df3 = pd.read_sql(delays_query, con=mysql_engine)<\/pre>\n
Como puede ver, obtenemos el mismo resultado que al utilizar read_sql<\/code> con MySQL Connector.<\/p>\n
\n
\"\"<\/figure>\n<\/div>\n
Opciones avanzadas para trabajar con bases de datos<\/h2>\n
Ahora bien, estos m\u00e9todos conectores est\u00e1n muy bien para extraer una consulta que ya sabemos que queremos, pero \u00bfqu\u00e9 ocurre si queremos obtener una vista previa del aspecto que tendr\u00e1n nuestros datos antes de ejecutar la consulta completa, o una idea de cu\u00e1nto tardar\u00e1 toda la consulta? PyCharm est\u00e1 aqu\u00ed de nuevo con algunas funciones avanzadas para trabajar con bases de datos.<\/p>\n
Si volvemos a navegar hasta la ventana de herramientas Database<\/em> y hacemos clic con el bot\u00f3n derecho del rat\u00f3n sobre nuestra base de datos, veremos que en New<\/em> tenemos la opci\u00f3n de crear una Query Console<\/em>.<\/p>\n
\n
\"\"<\/figure>\n<\/div>\n
Esto nos permite abrir una consola que podemos utilizar para consultar la base de datos en SQL nativo. La ventana de la consola incluye finalizaci\u00f3n de c\u00f3digo SQL e introspecci\u00f3n, lo que le ofrece una forma m\u00e1s sencilla de crear sus consultas antes de pasarlas a los paquetes de conectores en Python.<\/p>\n
Resalte su consulta y haga clic en el bot\u00f3n Execute<\/em> en la esquina superior izquierda.<\/p>\n
\n
\"\"<\/figure>\n<\/div>\n
Esto recuperar\u00e1 los resultados de nuestra consulta en la pesta\u00f1a Services<\/em>, donde se pueden inspeccionar o exportar<\/a>. Una cosa buena de ejecutar consultas en la consola es que solo se recuperan inicialmente las primeras 500 filas de la base de datos, lo que significa que puede hacerse una idea de los resultados de consultas m\u00e1s amplias sin que necesite extraer todos los datos. Puede ajustar el n\u00famero de filas obtenidas yendo a Settings\/Preferences | Tools | Database | Data Editor and Viewer<\/em> y cambiando el valor en Limit page size to:<\/em>.<\/p>\n
\n
\"\"<\/figure>\n<\/div>\n
Hablando de consultas grandes, tambi\u00e9n podemos hacernos una idea de cu\u00e1nto tardar\u00e1 nuestra consulta generando un plan de ejecuci\u00f3n<\/a>. Si volvemos a resaltar nuestra consulta y hacemos clic con el bot\u00f3n derecho, podemos seleccionar Explain Plan<\/em> | Explain Analyse<\/em> en el men\u00fa. Esto generar\u00e1 un plan de ejecuci\u00f3n para nuestra consulta, mostrando cada paso que el planificador de consultas est\u00e1 dando para obtener nuestros resultados. Los planes de ejecuci\u00f3n son su propio tema, y en realidad no necesitamos entender todo lo que nos dice nuestro plan. Lo m\u00e1s relevante para nuestros prop\u00f3sitos es la columna Actual Total Time<\/em>, donde podemos ver cu\u00e1nto tiempo tardar\u00e1 en mostrar todas las filas en cada paso. Esto nos da una buena estimaci\u00f3n del tiempo total de la consulta, as\u00ed como si es probable que alguna parte de nuestra consulta consuma especialmente mucho tiempo.<\/p>\n
\n
\"\"<\/figure>\n<\/div>\n
Tambi\u00e9n puede visualizar la ejecuci\u00f3n pulsando el bot\u00f3n Show Visualization<\/em> situado a la izquierda del panel Plan<\/em>.<\/p>\n
\n
\"\"<\/figure>\n<\/div>\n
Aparecer\u00e1 un diagrama de flujo que facilita un poco la navegaci\u00f3n por los pasos que sigue el planificador de consultas.<\/p>\n
\n
\"\"<\/figure>\n<\/div>\n
Obtener datos de bases de datos MySQL en DataFrames de pandas es sencillo, y PyCharm cuenta con una serie de herramientas potentes para facilitar el trabajo con las bases de datos MySQL. En el pr\u00f3ximo art\u00edculo del blog, veremos c\u00f3mo utilizar PyCharm para leer datos en pandas desde otro tipo de base de datos popular, las bases de datos PostgreSQL.<\/p>\n
Art\u00edculo original en ingl\u00e9s de:<\/em><\/p>\n
\u00a0<\/p>\n\n    
\n        
\n            
\n                
\n                    \"\"\n                <\/div>\n                
\n                                                        <\/div>\n            <\/div>\n        <\/div>\n    <\/div>\n","protected":false},"author":1086,"featured_media":320796,"comment_status":"closed","ping_status":"closed","template":"","categories":[6943,952,1401,5108,2347],"tags":[2934,731,7057,1176,566],"cross-post-tag":[],"acf":[],"_links":{"self":[{"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/pycharm\/335973"}],"collection":[{"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/pycharm"}],"about":[{"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/types\/pycharm"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/users\/1086"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/comments?post=335973"}],"version-history":[{"count":6,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/pycharm\/335973\/revisions"}],"predecessor-version":[{"id":335981,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/pycharm\/335973\/revisions\/335981"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/media\/320796"}],"wp:attachment":[{"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/media?parent=335973"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/categories?post=335973"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/tags?post=335973"},{"taxonomy":"cross-post-tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/cross-post-tag?post=335973"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}