Tutorial de Python, PostgreSQL y Psycopg2

Para desarrollar una aplicación más allá de un simple script, es necesario conservar los datos fuera de la memoria en una base de datos.  Hay muchas opciones posibles para una base de datos, pero PostgreSQL es una plataforma robusta de código abierto que puede escalar fácilmente a producción.

Python y PostgreSQL se pueden interconectar para desarrollar aplicaciones poderosas rápidamente.  Psycopg es un adaptador de PostgreSQL que se puede utilizar para aprovechar PostgreSQL a través de la biblioteca basada en Python.  Este tutorial explicará la instalación de Psycopg2 y algunos códigos de Python para demostrar su uso.

Puede instalar Psycopg2 a través del siguiente comando de terminal pip.

$ pip instalar psycopg2

Al instalar, debería ver la salida del terminal a continuación.

Recolectando psycopg2
Descargando psycopg2-2.7.3.2-cp27-cp27m-
macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10
_10_x86_64.whl (1.7 MB)
100% | ██████████████████████████████ | 1.7 MB 397 kB / s
Instalación de paquetes recopilados: psycopg2
Psycopg2-2 instalado con éxito.7.3.2
Bradleys-Mini: ~ BradleyPatton $

Para importar el paquete Psycopg2 a su aplicación Python, use la siguiente línea de código.

importar psycopg2

Para poder cargar algunos datos en nuestra base de datos, he tomado prestado un código de un tutorial anterior sobre pandas. El siguiente código creará un DataFrame de pandas con datos históricos.  Esto luego se aprovechará para crear una tabla en la tabla PostgreSQL.

def get_data (símbolos, fecha_inicio, fecha_finalización):
panel = datos.DataReader (símbolos, 'yahoo', fecha_inicio, fecha_finalización)
df = panel ['Cerrar']
df.columnas = mapa (str.más bajo, df.columnas)
hd = lista (df)
imprimir df.cabeza()
imprimir hd
volver df

Ahora configuraré un código de limpieza que se usará para ejecutar el tutorial. Estos dos métodos se utilizarán para llamar a los métodos Psycopg2 que creamos.

def tutorial_run ():
símbolos = ['SPY', 'AAPL', 'GOOG']
df = get_data (símbolos, '2006-01-03', '2017-12-31')
if __name__ == "__main__":
tutorial_run ()

Para conectarnos a la base de datos PostgreSQL, necesitaremos agregar el siguiente método. Try \ Except proporciona un manejo de errores en caso de que la base de datos local no se esté ejecutando o se pasen parámetros de conexión incorrectos a la base de datos. El método de conexión en la biblioteca Psycopg2 se conecta a la base de datos con los parámetros pasados ​​en la cadena de conexión. Sus parámetros para el nombre de base de datos, el usuario y la contraseña pueden diferir. Si la conexión falla por algún motivo, el mensaje de error se escribirá en la consola. Este método devuelve el objeto de conexión a nuestro método de llamada, donde se puede usar para otras operaciones de base de datos.

def connect ():
cons = "dbname = 'tutorial' user =" postgres "host =" localhost "contraseña =" contraseña ""
intentar:
conn = psycopg2.conectar (contras)
imprimir "Conectado"
excepto:
imprimir "No puedo conectarme a la base de datos"
retorno conn

Una vez que hemos establecido la conexión a la base de datos PostgreSQL, podemos cargar nuestros datos desde el método get_data () en nuestra base de datos. Psycopg2 y pandas hacen de este un proceso muy simple.

La primera línea define el método que los pandas deben usar para conectarse a la base de datos para copiar el DataFrame. Proporcionará los mismos parámetros que su método de conexión. La segunda línea de código persiste el DataFrame en la base de datos PostgreSQL con el método to_sql ().

def create_table (tabla, df):
engine = create_engine ('postgresql + psycopg2: // postgres: [email protected]: 5432 / tutorial')
df.to_sql (tabla, motor, if_exists = 'reemplazar')

Un vistazo rápido a nuestra terminal pgAdmin de PostgreSQL muestra que el código cargó correctamente el DataFrame en la tabla "cerrar". Ahora que tenemos algunos datos cargados en nuestra base de datos. Podemos usar psycopg para ejecutar algunas consultas sobre los datos. El siguiente método está construido para tomar la conexión establecida en nuestro primer método y ejecutar una consulta en nuestra base de datos PostgreSQL. Para crear los 4 objetos SQL necesitamos agregar otra declaración de importación.

desde psycopg2 importar sql

Para crear comandos SQL dinámicos, psycopg usa formato de cadena para completar variables en la cadena usando los operadores% sy .

PostrgreSQL distingue entre mayúsculas y minúsculas. En el método get_data () forzamos los encabezados de nuestras columnas a minúsculas. El índice no se incluyó en esta instrucción. Para pasar el encabezado de la columna "Datos" en mayúscula en la consulta, debemos pasarlo a PostgreSQL entre comillas dobles. Para hacer esto en una cadena en Python, debe enviar el carácter de escape "\" antes de las comillas dobles.

Podemos reemplazar el ""% s"" en la cadena usando la sintaxis de formato de cadena de Python a continuación. Esto reemplaza el% s con nuestro parámetro de fecha dt.

Para ejecutar la consulta SQL que se creó. Luego debe pasarlo al cursor .método execute (). Llamando al .método fetchall (), devuelve los resultados de la consulta. Cuando se imprime en la consola, puede mostrar los resultados.

def get_row (dt, conn):
cr = conn.cursor()
consulta = sql.SQL (""SELECT aapl from close WHERE"" Date ""= '% s'""% dt)
cr.ejecutar la solicitud)
imprimir cr.fetchall ()

Para ejecutar esta función, agregamos la siguiente línea de código al método tutorial_run (). Debería obtener resultados similares a los siguientes.

get_row (""2017-12-29"", conexión)

En el siguiente método, utilizaremos los métodos de formato de cadena para pasar múltiples parámetros a nuestra consulta. Esta consulta tomará una fecha y tres columnas. Además de usar el operador% s, utilizaremos el operador para unir variables de cadena en una cadena e inyectarlas en nuestra cadena de consulta. Nuestra cadena de consulta ahora usa la combinación a continuación con un separador "","" para pasar varios nombres de columna a nuestra consulta.

def get_cols (dt, col1, col2, col3, conn):
cr = conn.cursor()
consulta = sql.SQL (""SELECT from close WHERE"" Date ""= '% s'""% dt).formato(
sql.SQL (',').unirse ([sql.Identificador (col1), sql.Identificador (col2), sql.Identificador (col3)]))
cr.ejecutar la solicitud)
imprimir cr.fetchall ()

Para usar nuestro nuevo método, agregaré la siguiente línea a nuestro método tutorial_run (). Deberías ver los resultados a continuación.

get_cols (""2017-12-29"", ""aapl"", ""espiar"", ""goog"", conexión)

El siguiente método que escribimos utilizará dos reemplazos de cadenas para extraer todos los datos de nuestra tabla con la excepción de nuestro índice. Este método se basa en nuestro método anterior al agregar una segunda notación de reemplazo de corchetes ""1"". Esta vez, los corchetes están numerados para que se reemplacen en el código de noción de formato de orden. Nuestro nuevo método une los parámetros de las tres columnas con un separador de comas. Además, el segundo parámetro en el método de formato es la variable de tabla. Luego, la cadena de consulta se construye reemplazando los corchetes con los parámetros en el método de formato en orden. Eso es 0 = columnas y 1 = nombre de la tabla.

def get_tab (tabla, col1, col2, col3, conn):
cr = conn.cursor()
consulta = sql.SQL (""SELECCIONAR 0 de 1"").formato(
sql.SQL (',').unirse ([sql.Identificador (col1), sql.Identificador (col2),
sql.Identificador (col3)]), sql.Identificador (tabla))
cr.ejecutar la solicitud)
imprimir cr.fetchall ()

Para usar nuestro nuevo método, agregaré la siguiente línea a nuestro método tutorial_run (). Deberías ver los resultados a continuación.

get_tab (""cerrar"", ""aapl"", ""espiar"", ""goog"", conexión)

Hay muchos más métodos para explorar en la biblioteca de psycopg. Esto debería ayudarlo a comenzar con una buena comprensión de las funciones de psycopg. He proporcionado algunos recursos más a continuación en las páginas de documentación que le permitirán explorar más extensamente la biblioteca.

Código completo

importar psycopg2
desde psycopg2 importar sql
importar pandas_datareader como datos
def get_data (símbolos, fecha_inicio, fecha_finalización):
panel = datos.DataReader (símbolos, 'yahoo', fecha_inicio, fecha_finalización)
df = panel ['Cerrar']
df.columnas = mapa (str.más bajo, df.columnas)
hd = lista (df)
imprimir df.cabeza()
imprimir hd
volver df
def connect ():
cons = ""dbname = 'tutorial' user ="" postgres ""host ="" localhost ""contraseña ="" contraseña """"
intentar:
conn = psycopg2.conectar (contras)
imprimir ""Conectado""
excepto:
imprimir ""No puedo conectarme a la base de datos""
retorno conn
def create_table (tabla, df):
engine = create_engine ('postgresql + psycopg2: // postgres: [email protected]: 5432 / tutorial')
df.to_sql (tabla, motor, if_exists = ""reemplazar"")
def get_row (dt, conn):
cr = conn.cursor()
consulta = sql.SQL (""SELECT aapl from close WHERE"" Date ""= '% s'""% dt)
cr.ejecutar la solicitud)
imprimir cr.fetchall ()
def get_cols (dt, col1, col2, col3, conn):
cr = conn.cursor()
consulta = sql.SQL (""SELECT from close WHERE"" Date ""= '% s'""% dt).formato(
sql.SQL (',').unirse ([sql.Identificador (col1),
sql.Identificador (col2), sql.Identificador (col3)]))
cr.ejecutar la solicitud)
imprimir cr.fetchall ()
def get_tab (tabla, col1, col2, col3, conn):
cr = conn.cursor()
consulta = sql.SQL (""SELECCIONAR 0 de 1"").formato(
sql.SQL (',').unirse ([sql.Identificador (col1), sql.Identificador (col2),
sql.Identificador (col3)]), sql.Identificador (tabla))
cr.ejecutar la solicitud)
imprimir cr.fetchall ()
def tutorial_run ():
conn = conectar ()
símbolos = ['SPY', 'AAPL', 'GOOG']
df = get_data (símbolos, '2006-01-03', '2017-12-31')
create_table (""cerrar"", df)
get_row (""2017-12-29"", conexión)
get_cols (""2017-12-29"", ""aapl"", ""espiar"", ""goog"", conexión)
get_tab (""cerrar"", ""aapl"", ""espiar"", ""goog"", conexión)
if __name__ == ""__main__"":
tutorial_run ()

Referencias

initd.org / psycopg
initd.org / psycopg / docs / install.html
http: // initd.org / psycopg / docs / sql.html
wiki.postgresql.org / wiki / Psycopg2_Tutorial"