Cómo conectarse a PostgreSQL usando Python

Vamos a ver cómo te puedes a PostgreSQL desde Python. Con ello podrás ejecutar sentencias y consultas SQL sobre la base de datos. Sin embargo, antes de poder conectarte, necesitas configurar tu sistema.

Instalación de los paquetes necesarios

Antes de poder conectarte a PostgreSQL utilizando Python, necesitas instalar una serie de paquetes, ya sea en tu sistema o en una máquina virtual. Decir que la instalación de los paquetes se realiza mediante PIP, el gestor de paquetes de Python. Si no tienes PIP instalado en tu sistema, consulta esta guía de instalación de PIP para Python. Solamente necesitas instalar uno de estos dos paquetes, dependiendo del que prefieras utilizar:

• psycopg2: Este paquete contiene el módulo psycopg2. Para instalar el paquete psycopg2 utiliza el siguiente comando:

  pip install psycopg2

• PyGreSQL: Se trata de un paquete que contiene el módulo pgdb. Para instalar el paquete PyGreSQL utiliza el siguiente comando:

  pip install pygresql

Estos dos paquetes soportan la API de bases de datos de Python, por lo que si decides cambiar de módulo en el futuro, podrás reutilizar la mayor parte del código que hayas escrito.

Cómo conectarte a una base de datos

Vamos a ver cómo te puedes conectar a una base de datos PostgreSQL existente utilizando tanto la función psycopg2.connect del módulo psycopg2 como  la función pgdb.connect del módulo PyGreSQL, que hemos visto en el apartado anterior.

Conexión a PostgreSQL con Python mediante psycopg2

Vamos a ver cómo puedes crear una nueva sesión en al base de datos de un modo sencillo. Luego veremos un modo más adecuado para conectarnos, que se aproxima más a lo que se usa en el mundo real. Todo esto nos permitirá cosas como crear un cursor para ejecutar consultas o ejecutar y confirmar transacciones.

Función de conexión a PostgreSQL con psycopg2

Puedes especificar los parámetros de la conexión como una cadena de texto y pasársela a la función connect del siguiente modo:

conexion = psycopg2.connect("dbname=empleados user=neoguias password=pimientos44")

Debes reemplazar los datos del ejemplo por la base de datos a la que te quieres conectar junto a tus credenciales de acceso.

También te puedes utilizar una lista de argumentos y pasárselos a la función connect del siguiente modo:

conexion = psycopg2.connect(host="localhost", database="empleados", user="neoguias", password="pimientos44")

En estos ejemplos tenemos los siguientes parámetros:

• host: El nombre o la dirección IP del servidor al que te quieres conectar.
• database/ dbname: El nombre de la base de datos a la que te quieres conectar. En nuestro ejemplo, la base de datos se llama «empleados».
• user: El nombre de usuario de PostgreSQL. En nuestro ejemplo, el nombre de usuario que utilizaremos es «neoguias».
• password: La contraseña de acceso establecida para el usuario especificado. En nuestro ejemplo, la contraseña establecida es «pimientos44».
• port: El número del puerto al que te quieres conectar. Si no introduces ningún valor, se utilizará el nombre del puerto por defecto, que es el 5432.

Para ejecutar una consulta, primero debes crear un cursor utilizando el objeto que contiene la conexión que hemos creado, y luego introducir una consulta SQL:

# Creamos el cursor con el objeto conexion
cur = conexion.cursor()

# Ejecutamos una consulta
cur.execute( "SELECT nombre, apellidos FROM empleados" )

# Recorremos los resultados y los mostramos
for nombre, apellidos in cur.fetchall() :
    print nombre, apellidos

# Cerramos la conexión
conexion.close()

Lo que hemos hecho es crear una conexión con los datos de acceso a la base de datos y, seguidamente, crear un cursor, que es lo que nos permitirá ejecutar sentencias SQL mediante la función execute().

Veamos ahora cómo almacenar estos datos en un archivo separado.

Conexión avanzada a PostgreSQL con psycopg2

Lo más habitual es almacenar la configuración de acceso a la base de datos en un archivo .ini, u otro tipo de archivo cualquiera utilizado para almacenar configuraciones:

[postgresql]
host=localhost
database=empleados
user=neoguias
password=pimientos44

En el archivo anterior no hemos introducido el puerto, por lo que se utilizará el puerto por defecto, que es el puerto 5432. En caso de usar uno deferente, como el puerto 5433, agrega esta línea:

port=5433

Una vez introducidos todos los datos, guarda el archivo con el nombre de base_de_datos.ini, puesto que lo vamos a utilizar en el siguiente ejemplo.

Vamos a crear una función llamada config() que lea los archivos de un archivo llamado base_de_datos.ini y devuelva los parámetros de conexión a la base de datos almacenados en el mismo.

Crea un archivo llamado config.py e introduce este código en su interior:

#!/usr/bin/python
from configparser import ConfigParser
 
def config(archivo='base_de_datos.ini', seccion='postgresql'):
    # Crear el parser y leer el archivo
    parser = ConfigParser()
    parser.read(archivo)
 
    # Obtener la sección de conexión a la base de datos
    db = {}
    if parser.has_section(seccion):
        params = parser.items(seccion)
        for param in params:
            db[param[0]] = param[1]
    else:
        raise Exception('Secccion {0} no encontrada en el archivo {1}'.format(seccion, archivo))

Desde ahora, para conectarnos a la base de datos de nombre empleados de nuestro ejemplo, podemos usar este código. Vamos a ver un ejemplo en el que seguimos los siguientes pasos (el código correspondiente está justo debajo):

1. Lo primero que hacemos en el ejemplo es leer los parámetros de configuración del archivo base_de_datos.ini.
2. Seguidamente creamos una nueva conexión con la base de datos mediante el método psycopg2.connect(), al que le pasamos los parámetros de conexión.
3. Seguidamente creamos un cursor al que llamamos cur mediante el método conexion.cursor(), siendo conexion la instancia de conexión creada anteriormente.
4. Ejecutamos una consulta para, por ejemplo, obtener la versión de PostgreSQL. Para ello utilizamos la función cur.execute(), siendo cur el cursor.
5. Tras la lectura, leemos el resultado con el método cur.fetchone(), siendo cur el cursor creado, que obtendrá le primer registro del resultado o el único que exista, en caso de haber solamente uno.
6. Luego imprimimos el resultado en pantalla.
7. Luego cerramos la comunicación con el cursor creado para liberar los recursos mediante la función cur.close().
8. Ya solamente nos queda cerrar la conexión a la base de datos con el método conexion.close(), siendo conexion nuestra instancia de conexión.

Este es el código completo:

#!/usr/bin/python
import psycopg2
from config import config
 
def conectar():
    """ Conexión al servidor de pases de datos PostgreSQL """
    conexion = None
    try:
        # Lectura de los parámetros de conexion
        params = config()
 
        # Conexion al servidor de PostgreSQL
        print('Conectando a la base de datos PostgreSQL...')
        conexion = psycopg2.connect(**params)
 
        # creación del cursor
        cur = conexion.cursor()
        
        # Ejecución de una consulta con la version de PostgreSQL
        print('La version de PostgreSQL es la:')
        cur.execute('SELECT version()')
 
        # Ahora mostramos la version
        version = cur.fetchone()
        print(version)
       
        # Cierre de la comunicación con PostgreSQL
        cur.close()
    except (Exception, psycopg2.DatabaseError) as error:
        print(error)
    finally:
        if conexion is not None:
            conexion.close()
            print('Conexión finalizada.')
 
 
if __name__ == '__main__':
    conectar()

Y esto es todo. En el apartado de solución de problemas verás como solucionar algunos de los problemas más comunes.

Conexión a PostgreSQL con Python mediante PyGreSQL

Primero veremos cómo te puedes conectar del modo más sencillo, y luego mediante un archivo de configuración, que es lo que te encontrarás habitualmente.

Función de conexión a PostgreSQL con PyGreSQL

En este caso especificaremos los parámetros de la conexión como una cadena de texto y pasársela a la función connect del siguiente modo, reemplazando los datos del ejemplo por la base de datos a la que te quieres conectar y los datos de acceso correspondientes:

conexion = pgdb.connect(host="localhost",database="empleados", user="neoguias", password="pimientos44")

Estos son los parámetros que puedes configurar:

• host: El nombre o la dirección IP del servidor al que te quieres conectar.
• database: Nombre de la base de datos a la que te quieres conectar, que en nuestro ejemplo es la base de datos empleados.
• user: El nombre de usuario de la base de datos, que en nuestro ejemplo es neoguias.
• password: La contraseña que tenga el usuario especificado, que en nuestro ejemplo es pimientos44.
• port: Número de puerto de PostgreSQL. Es un parámetro opcional. Si no introduces ningún valor, se usará el 5432.

Vamos a utilizar el objeto de conexión creado para ejecutar una consulta sobre al base de datos:

# Crea del cursor
cur = conexion.cursor()

# Ejecuta una consulta
cur.execute( "SELECT nombre, telefono FROM empleados" )

# Muestra los resultados
for nombre, telefono in cur.fetchall() :
    print nombre, telefono

# Cierra la conexión
conexion.close()

Este ejemplo crea un objeto de conexión y utiliza la API de SQL para ejecutar una consulta. Cuando tienes un objeto de conexión asociado a una base de datos, puedes crear un cursor, que permite ejecutar consultas SQL mediante la sentencia execute().

Veamos ahora cómo almacenar estos datos en un archivo separado.

Conexión avanzada a PostgreSQL con PyGreSQL

Al igual que hemos hecho con el otro módulo, también podemos crear un archivo .ini con los datos de acceso a PyGreSQL. Veamos cómo hacerlo:

Crea un archivo nuevo e introduce los datos de acceso a la base de datos con este formato. Guarda el archivo como base_de_datos.ini.

[postgresql]
host=localhost
database=empleados
user=neoguias
password=pimientos44

Crea un archivo llamado config.py e introduce este código, que se encargará de parsear el archivo de configuración base_de_datos.ini que acabas de crear, obteniendo los datos de la conexión:

#!/usr/bin/python
from configparser import ConfigParser
 
def config(archivo='base_de_datos.ini', seccion='postgresql'):
    # Parsear el archivo
    parser = ConfigParser()
    parser.read(archivo)
 
    # Ir a la sección de postgresql y extraer los parámetros
    db = {}
    if parser.has_section(seccion):
        params = parser.items(seccion)
        for param in params:
            db[param[0]] = param[1]
    else:
        raise Exception('Secccion {0} no encontrada en el archivo {1}'.format(seccion, archivo))

Ahora, debemos crear el script que cumpla nuestro cometido. En este ejemplo simplemente imprimiremos al versión de PostgreSQL. Utiliza este código:

#!/usr/bin/python
import pgdb
from config import config
 
def conectar():
    """ Conexión al servidor de pases de datos PostgreSQL """
    conexion = None
    try:
        # Lectura de los parámetros de conexion
        params = config()
 
        # Conexion al servidor de PostgreSQL
        print('Conectando a la base de datos PostgreSQL...')
        conexion = pgdb.connect(**params)
 
        # creación del cursor
        cur = conexion.cursor()
        
        # Ejecución la consulta para obtener la conexión
        print('La version de PostgreSQL es la:')
        cur.execute('SELECT version()')
 
        # Se obtienen los resultados
        db_version = cur.fetchone()
        # Se muestra la versión por pantalla
        print(db_version)
       
        # Cerremos el cursor
        cur.close()
    except (Exception, psycopg2.DatabaseError) as error:
        print(error)
    finally:
        if conexion is not None:
            conexion.close()
            print('Conexión finalizada.')
 
 
if __name__ == '__main__':
    conectar()

Lo que hemos hechos es lo siguiente:

1. Obtenemos los datos del archivo base_de_datos.ini importando el archivo config.py.
2. Creamos una conexión con la base de datos utilizando pgdb.connect().
3. Seguidamente creamos el cursor cur con el método conexion.cursor().
4.  Ejecutamos la consulta con cur.execute().
5. Obtenemos el primer resultado con el método cur.fetchone() y lo mostramos por pantalla.
6. Finalmente cerramos la comunicación con cur.close() y la conexión con conexion.close().

Y esto es todo, aunque aún podemos conectarnos de otra forma, utilizando el módulo que viene por defecto para conectarse a PostgreSQL.

Conexión a PostgreSQL con el módulo Legacy de PyGreSQL

El paquete de PyGreSQL también incluye un módulo legacy llamado pg que puedes utilizar para conectarte a PostgreSQL. Con est módulo nos podremos conectar de un modo más sencillo, pero no se implementa la API portable de SQL para Python.

En este ejemplo, nos conectaremos a una base de datos PostgreSQL usando el módulo pg, que importamos al comienzo del script:

#!/usr/bin/python

import pg

# Creamos la conexión
conexion = pg.DB(host="localhost", user="neoguias", passwd="pimientos44", dbname="empleados")

# Ejecutamos una consulta y guaramos los resultados
resultados = conexion.query("SELECT nombre, telefono FROM empleados")

# Recorremos los resultados y los mostramos
for nombre, telefono in resultados.getresult() :
    print nombre, telefono

# Cerramos la conexión
conexion.close()

Lo que hemos hecho es conectarnos a la base de datos de nombre empleados con el nombre de usuario neoguias y la contraseña pimientos44. Luego obtenemos el nombre y el teléfono de los empleados ejecutando una consulta y obteniendo los resultados con getresult(). Finalmente, mostramos los resultados por pantalla y cerramos la conexión con close().

Veamos ahora algunos problemas que pueden surgir.

Solución de problemas

Estos son algunos de los problemas que podrías tener.

• Si se muestra el error «FATAL: database «base_de_datos» does not exist», significará que la base de datos de nombre «base_de_datos», «empleados», o la que hayas introducido, no existe.
  Para crearla, inicia una conexión con PostgreSQL desde la terminal y usa el siguiente comando, siendo base_de_datos el nombre de la base de datos, que en nuestro ejemplo sería «empleados».

  CREATE DATABASE empleados;

• Si se muestra el error «FATAL: password authentication failed for user «usuario», significará que los datos de acceso no son los correctos, ya sea el nombre de usuario, la contraseña o ambos. Revisa los datos y cambia los parámetros.
• Si se muestra el error: «could not translate host name «servidor» to address: Unknown host», significará que el servidor de bases de datos introducido no es el correcto. habitualmente éste suele ser localhost si te conectas a un servidor local. Si se trata de un servidor remoto, asegúrate de introducir el nombre de servidor correcto.

Y esto ha sido todo.

---