Comment conserver les valeurs nulles lors de l'écriture en CSV

votre code

for row in self.cursor:
    csv_writer.writerow("null" if x is None else x for x in row)

utilise writer tel quel, mais vous n'êtes pas obligé de le faire. Vous pouvez filtrer les valeurs pour changer certaines valeurs particulières avec une compréhension du générateur et une expression ternaire

for row in self.cursor:
    csv_writer.writerow(row)

Vous demandez csv.QUOTE_NONNUMERIC . Cela transformera tout ce qui n'est pas un nombre en une chaîne. Vous devriez envisager d'utiliser csv.QUOTE_MINIMAL car il pourrait être plus ce que vous recherchez:

Code de test:

,0,,data

Résultats: h3 >

test1.csv:

"",0,"","data"

test2.csv:

import csv

test_data = (None, 0, '', 'data')
for name, quotes in (('test1.csv', csv.QUOTE_NONNUMERIC),
                     ('test2.csv', csv.QUOTE_MINIMAL)):

    with open(name, mode='w') as outfile:
        csv_writer = csv.writer(outfile, delimiter=',', quoting=quotes)
        csv_writer.writerow(test_data))

J'utiliserais pandas, psycopg2 et sqlalchemy. Assurez-vous que sont installés. Provenant de votre flux de travail actuel et évitant d'écrire en csv

#no need to import psycopg2
import pandas as pd
from sqlalchemy import create_engine


#create connection to postgres
engine = create_engine('postgres://.....')

#get column names from cursor.description
columns = [col[0] for col in self.cursor.description]

#convert data into dataframe
df = pd.DataFrame(cursor.fetchall(),columns=columns)

#send dataframe to postgres
df.to_sql('name_of_table',engine,if_exists='append',index=False)

#if you still need to write to csv
df.to_csv('your_file.csv')

Vous avez deux options ici: changez l'option de citation csv.writing en Python, ou dites à PostgreSQL d'accepter les chaînes entre guillemets comme possibles NULL (nécessite PostgreSQL 9.4 ou plus récent)

Python csv.writer () et citant

Du côté Python, vous dites à l'objet csv.writer () d'ajouter des guillemets, car vous l'avez configuré pour utiliser csv.QUOTE_NONNUMERIC : p>

Demande aux objets writer de citer tous les champs non numériques.

Aucune Les valeurs ne sont pas numériques, donc il en résulte l'écriture de "" .

Passer à l'utilisation de csv.QUOTE_MINIMAL ou csv.QUOTE_NONE :

csv.QUOTE_MINIMAL
Indique aux objets writer de ne citer que les champs qui contiennent des caractères spéciaux tels que délimiteur , quotechar ou l'un des caractères de lineterminator em>.

csv.QUOTE_NONE
Indique aux objets writer de ne jamais citer les champs. Lorsque le délimiteur actuel apparaît dans les données de sortie, il est précédé du caractère escapechar actuel.

Comme vous n'écrivez que des valeurs de longitude et de latitude, vous n'avez pas besoin de guillemets ici, il n'y a pas de délimiteurs ou de guillemets présents dans vos données.

Avec l'une ou l'autre des options, le La sortie CSV pour les valeurs Aucune est une simple chaîne vide:

COPY position (
    lon, 
    lat
) 
FROM "filename"
WITH (
    FORMAT csv,
    NULL '',
    DELIMITER ',',
    FORCE_NULL(lon, lat)
);

PostgreSQL 9.4 COPY FROM , NULL et FORCE_NULL

Depuis PostgreSQL 9.4, vous pouvez également forcer PostgreSQL à accepter les chaînes vides entre guillemets comme NULL s, lorsque vous utilisez le Option FORCE_NULL . À partir de la COPY FROM documentation : p>

FORCE_NULL

Faites correspondre les valeurs des colonnes spécifiées à la chaîne nulle, même si elle a été citée, et si une correspondance est trouvée, définissez la valeur sur NULL . Dans le cas par défaut où la chaîne nulle est vide, cela convertit une chaîne vide entre guillemets en NULL . Cette option n'est autorisée que dans COPY FROM , et uniquement lors de l'utilisation du format CSV.

Nommer les colonnes dans une option FORCE_NULL permet à PostgreSQL d'accepter à la fois la colonne vide et "" comme valeurs NULL pour celles-ci colonnes, par exemple:

>>> import csv
>>> from io import StringIO
>>> def test_csv_writing(rows, quoting):
...     outfile = StringIO()
...     csv_writer = csv.writer(outfile, delimiter=',', quoting=quoting)
...     csv_writer.writerows(rows)
...     return outfile.getvalue()
...
>>> rows = [
...     [42.313270000, -71.116240000],
...     [42.377010000, -71.064770000],
...     [None, None],
... ]
>>> print(test_csv_writing(rows, csv.QUOTE_NONNUMERIC))
42.31327,-71.11624
42.37701,-71.06477
"",""

>>> print(test_csv_writing(rows, csv.QUOTE_MINIMAL))
42.31327,-71.11624
42.37701,-71.06477
,

>>> print(test_csv_writing(rows, csv.QUOTE_NONE))
42.31327,-71.11624
42.37701,-71.06477
,

à quel point les options de citation que vous avez utilisées du côté Python n'ont plus d'importance.

Autres options à considérer

Pour les tâches simples de transformation de données à partir d'autres bases de données, n'utilisez pas Python

Si vous interrogez déjà des bases de données pour rassembler des données pour aller dans PostgreSQL, envisagez de les insérer directement dans Postgres em>. Si les données proviennent d'autres sources, utilisez le wrapper de données étrangères ( fdw ) module vous permet de supprimer les intermédiaires et d'extraire directement des données dans PostgreSQL à partir d'autres sources.

Données numpy? Pensez à utiliser COPY FROM comme binaire, directement à partir de Python

Les données Numpy peuvent être insérées plus efficacement via binaire COPY FROM ; la réponse liée augmente un tableau structuré numpy avec les métadonnées supplémentaires requises et l'ordre des octets, puis crée efficacement une copie binaire des données et l'insère dans PostgreSQL en utilisant COPY FROM STDIN WITH BINARY et psycopg2.copy_expert () méthode . Cela évite parfaitement les conversions de nombre -> texte -> nombre.

Des données persistantes pour gérer de grands ensembles de données dans un pipeline?

Ne réinventez pas les roues du pipeline de données. Pensez à utiliser des projets existants tels que Apache Spark , qui ont déjà résolu les problèmes d'efficacité. Spark vous permet de traiter les données comme un flux structuré a> et inclut l'infrastructure pour exécuter des étapes d'analyse de données en parallèle a >, et vous pouvez traiter les données structurées distribuées comme des dataframes Pandas .

Une autre option pourrait être de consulter Dask pour aider à partager des ensembles de données entre les tâches distribuées pour traiter de grandes quantités de données.

Même si la conversion d'un projet déjà en cours vers Spark peut être un pas trop loin, envisagez au moins d'utiliser Apache Arrow , la plate-forme d'échange de données Spark s'appuie sur. Le projet pyarrow vous permettrait d'échanger des données via des fichiers Parquet, ou échanger des données via IPC .

Les équipes Pandas et Numpy sont assez fortement investis dans la prise en charge des besoins d'Arrow et de Dask (il y a un chevauchement considérable des membres principaux entre ces projets) et travaillent activement pour rendre l'échange de données Python aussi efficace que possible, y compris étendre le module pickle de Python pour permettre des flux de données hors bande pour éviter toute copie inutile de la mémoire lorsque partager des données.