Konvertieren List to dict or json

[mit]

Hallo,
Ich habe eine Liste r die als Elemente Listen enthält.

Code: Alles auswählen

    r = [["Test", "A", "B01", 828288,  1,    7, 'C', 5],
        ["Test", "A", "B01", 828288,  1,    7, 'T', 6],
        ["Test", "A", "B01", 171878,  3,    8, 'C', 5],
        ["Test", "A", "B01", 171878,  3,    8, 'T', 6],
        ["Test", "A", "B01", 871963,  3,    9, 'A', 5],
        ["Test", "A", "B01", 871963,  3,    9, 'G', 6],
        ["Test", "A", "B01", 1932523, 1,   10, 'T', 4],
        ["Test", "A", "B01", 1932523, 1,   10, 'A', 5],
        ["Test", "A", "B01", 1932523, 1,   10, 'X', 6],
        ["Test", "A", "B01", 667214,  1,   14, 'T', 4],
        ["Test", "A", "B01", 667214,  1,   14, 'G', 5],
        ["Test", "A", "B01", 667214,  1,   14, 'G', 6]]

.

Jede Liste i aus r kann Elemente haben (i[0] - i[5]) welche identisch zu andren Listen sein können. Wenn i[0] - i[5] bereits vorhanden ist append nur i[6] and i[7] zur chr. Als Lösung versuche ich ein dict/json zu bekommen wie unten dargestellt:

Code: Alles auswählen

{
  "name":"A",
  "pos":828288,
  "s_type":1,
  "sub_name":"B01",
  "type":"Test",
  "x_type":7,
  "chr":[
      {
        "letter":"C",
        "no":4
      },
      {
        "letter":"C",
        "no":5
      },
      {
        "letter":"T",
        "no":6
      }
  ]
}{
  "name":"A",
  "pos":171878,
  "s_type":3,
  "sub_name":"B01",
  "type":"Test",
  "x_type":8,
  "chr":[
      {
        "letter":"C",
        "no":5
      },
      {
        "letter":"T",
        "no":6
      }
  ]
}{
  "name":"A",
  "pos":871963,
  "s_type":3,
  "sub_name":"B01",
  "type":"Test",
  "x_type":9,
  "chr":[
      {
        "letter":"A",
        "no":5
      },
      {
        "letter":"G",
        "no":6
      }
  ]
}{
  "name":"A",
  "pos":1932523,
  "s_type":1,
  "sub_name":"B01",
  "type":"Test",
  "x_type":10,
  "chr":[
      {
        "letter":"T",
        "no":4
      },
      {
        "letter":"A",
        "no":5
      },
      {
        "letter":"X",
        "no":6
      }
  ]
}{
  "name":"A",
  "pos":667214,
  "s_type":1,
  "sub_name":"B01",
  "type":"Test",
  "x_type":14,
  "chr":[
      {
        "letter":"T",
        "no":4
      },
      {
        "letter":"G",
        "no":5
      },
      {
        "letter":"G",
        "no":6
      }
  ]
}

Ich habe versucht das Problem mit defaultdicts zu lösen wie unten dargestellt, aber das Ergebnis ist nicht wie oben beschrieben:

Code: Alles auswählen

from collections import defaultdict
from pprint import pprint

if __name__ == "__main__":

    r = [["Test", "A", "B01", 828288,  1,    7, 'C', 5],
        ["Test", "A", "B01", 828288,  1,    7, 'T', 6],
        ["Test", "A", "B01", 171878,  3,    8, 'C', 5],
        ["Test", "A", "B01", 171878,  3,    8, 'T', 6],
        ["Test", "A", "B01", 871963,  3,    9, 'A', 5],
        ["Test", "A", "B01", 871963,  3,    9, 'G', 6],
        ["Test", "A", "B01", 1932523, 1,   10, 'T', 4],
        ["Test", "A", "B01", 1932523, 1,   10, 'A', 5],
        ["Test", "A", "B01", 1932523, 1,   10, 'X', 6],
        ["Test", "A", "B01", 667214,  1,   14, 'T', 4],
        ["Test", "A", "B01", 667214,  1,   14, 'G', 5],
        ["Test", "A", "B01", 667214,  1,   14, 'G', 6]]

    s = defaultdict(lambda:
            defaultdict(lambda:
                    defaultdict(lambda:
                        defaultdict(lambda:
                                defaultdict(lambda:
                                    defaultdict(lambda:
                                            defaultdict(defaultdict)))))))

    for i in r:
        s["hello":i[0]][i[1]][i[2]][i[3]][i[4]][i[5]][i[6]] = i[7]

    pprint(s)

Wie könnte man am Besten die Listen zu einem dict/json umwandeln?

P.S. Später möchte ich die Werte aus einer Datei "line by line" lesen (77GB).

[EyDu]

Wie könnte man am Besten die Listen zu einem dict/json umwandeln?

Die Frage hattest du in ähnlicher Art doch schon gestellt, oder? Hatten wir dir da nicht schon eine (relationale) Datenbank in den Raum geworfen? Bei der Menge und der Form an Daten drängt sich das doch geradezu auf.

[mit]

Stimmt, aber ich wollte mal NoSQL aus probieren wie z.B. MongoDB oder CouchDB. MongoDB wirbt das sie schneller sind als RDBMS?

Um die Daten schneller z.B. zu MongoDB zu laden ist es möglich diese als bulk zu laden

[snafu]

Jede Liste i aus r kann Elemente haben (i[0] - i[5]) welche identisch zu andren Listen sein können. Wenn i[0] - i[5] bereits vorhanden ist append nur i[6] and i[7] zur chr.

Dann sollte die erste Stufe deiner Dictionary-Struktur als Schlüssel ein Tupel annehmen, welches sich aus i[0] - i[5] zusammensetzt (wobei "i" ein schlecht gewählter Name ist). Jedem Wert für einen dieser "Tupel-Schlüssel" wird ein neues Dict zugewiesen. Dieses zweite Dict enthält nun als Schlüssel die auftretenden Buchstaben und als Werte die zugehörigen Zahlen. Das wäre die Grundstruktur, um erstmal gleichartige Daten sinnvoll gruppiert zu haben.

Für die von dir gewünschte Darstellung solltest du anschließend diese Grundstruktur durchlaufen und in diesem Schritt halt die Werte zu Schlüsseln mit sprechenden Namen zuordnen. Du schnappst dir also in einer Schleife jedes Schlüssel-Wert-Paar aus deiner Grundstruktur und befüllst pro Schleifendurchlauf ein neues Dict mit den entsprechenden Infos. Am Ende kommen dann genau so viele neue "Info-Dicts" heraus wie deine Grundstruktur an Schlüsseln hat. Diese solltest du in einer Liste sammeln und kannst diese Liste dann an den JSON-Encoder übergeben.

EDIT: All das heißt aber nicht, dass die bereits vorgeschlagene Verwendung einer relationalen Datenbank hier eine schlechte Idee wäre. Für große Datenmengen ist die Datenbank-Lösung sogar vorzuziehen. Ansonsten wirst du nen übelst hohen RAM-Verbrauch haben und müsstest die oben genannte Vorab-Gruppierung wohl notgedrungen häppchenweise vornehmen. Du würdest dann deine Liste mit den Info-Dicts für jedes Häppchen (wobei man durchaus große Häppchen verwenden sollte) entsprechend aktualisieren müssen (eine Art Merge-Vorgang). Der grobe Ablauf wäre dann "gib neues Häppchen" -> "aktualisiere Endergebnis". Und das ganze eben solange bis keine Häppchen bzw Zeilen in der Eingabedatei mehr übrig sind. Erwarte hier aber keine Geschwindigkeitsrekorde, falls du das unbedingt in Python machen willst. Das wird bei 77GB an Daten wohl recht lange dauern.

EDIT2: Ich sehe gerade, dass in dem Beispiel-Ergebnis der selbe Buchstabe mehrfach vorkommt. Wenn dem wirklich so sein sollte, dann darf man die "Zahl-Wert-Pärchen" in der Grundstruktur natürlich *nicht* in einem Dict sammeln, sondern würde eine Liste mit 2-elementrigen Tupeln verwenden.

[BlackJack]

@mit: Welche NoSQL-Datenbank soll es denn werden und wie sollen die Daten dort gespeichert werden? *Ein* *riesiges* JSON-Dokument wirst Du dort nicht reinschreiben wollen. Und vor allem wird man nicht 77GB Daten im Speicher aggregieren wollen um daraus dann ein JSON-Dokument zu erstellen. Falls das der Speicher überhaupt hergibt. Man würde da eher die Datensätze einzeln in die DB eintragen (oder ein paar Tausend vorher aggregieren) und dabei jedes mal schauen ob es schon ein Dokument mit den ersten Attributen gibt, und falls nicht ein Neues erstellen, oder dem Bestehenden etwas an `chr` anhängen. Eventuell kann man so etwas auch DB-Intern machen, zum Beispiel bei MongoDB mit einem entsprechenden JavaScript-Programm was dann in der DB läuft. Wenn man wirklich viele Daten hat und die DB auf mehrere Rechner verteilt kann man eventuell auch ein MapReduce auf diesen Rechnern verteilt ausführen. Allerdings glaube ich nicht das *Du* dazu schon bereit bist, wenn Dir das Erstellen eines Wörterbuchs in Python schon solche Probleme bereitet.

Jede DB wirbt damit schneller zu sein. Als was genau und mit welchen Daten wird dann immer verschwiegen.

[snafu]

Stimmt, aber ich wollte mal NoSQL aus probieren wie z.B. MongoDB oder CouchDB.

Ich würde wohl eher SQLAlchemy nehmen und als Backend ein von dieser Bibliothek unterstütztes DBMS. Damit kann man das Design der Datenbank bequem in Python vornehmen. Hier würden sich zwei Tabellen anbieten: Eine für die Beschreibung eines Tupels in der Form wie ich es im vorherigen Beitrag beschrieben hatte zuzüglich einer Spalte "ID", damit für jedes Tupel ein Primärschlüssel erstellt werden kann. Und die zweite Tabelle, um die Buchstaben-Werte-Pärchen an die passende Tupel-ID binden zu können und diese Beziehungen halt sequentiell in der Tabelle aufführen. Auch hier muss man aber natürlich wissen, welche ID das Tupel aus der aktuellen Zeile hat und bei Bedarf ein neues Tupel in der ersten Tabelle registrieren. Das wäre ähnlich zu dem, was BlackJack bereits für NoSQL beschrieben hat. Auch in diesem Fall sollte man schauen, ob man für das Einsetzen der Daten vielleicht eine Schleife in der Datenbank-eigenen Sprache schreiben kann, zwecks möglicher Erhöhung der Performance.

[mit]

@snafu: Wahrscheinlich habe ich deine Beschreibung falsch verstanden, aber der folgende Code funktioniert nicht, weil "keys must be a string".

Code: Alles auswählen

from collections import defaultdict
from pprint import pprint
import json

if __name__ == "__main__":

    r = [["Test", "A", "B01", 828288,  1,    7, 'C', 5],
        ["Test", "A", "B01", 828288,  1,    7, 'T', 6],
        ["Test", "A", "B01", 171878,  3,    8, 'C', 5],
        ["Test", "A", "B01", 171878,  3,    8, 'T', 6],
        ["Test", "A", "B01", 871963,  3,    9, 'A', 5],
        ["Test", "A", "B01", 871963,  3,    9, 'G', 6],
        ["Test", "A", "B01", 1932523, 1,   10, 'T', 4],
        ["Test", "A", "B01", 1932523, 1,   10, 'A', 5],
        ["Test", "A", "B01", 1932523, 1,   10, 'X', 6],
        ["Test", "A", "B01", 667214,  1,   14, 'T', 4],
        ["Test", "A", "B01", 667214,  1,   14, 'G', 5],
        ["Test", "A", "B01", 667214,  1,   14, 'G', 6]]

    s = defaultdict(lambda:
            defaultdict(lambda:
                    defaultdict(lambda:
                        defaultdict(lambda:
                                defaultdict(lambda:
                                    defaultdict(lambda:
                                            defaultdict(defaultdict)))))))

    for i in r:
        s[('type', i[0])][('name', i[1])][('sub_name', i[2])][('pos', i[3])][('s_type', i[4])][('x_type', i[5])][('chr', i[6])] = i[7]
        pprint(json.dumps(s))

Code: Alles auswählen

Traceback (most recent call last):
  File "/run/media/mic/ta/projects/test/dict2json.py", line 31, in <module>
    pprint(json.dumps(s))
  File "/usr/lib64/python2.7/json/__init__.py", line 243, in dumps
    return _default_encoder.encode(obj)
  File "/usr/lib64/python2.7/json/encoder.py", line 207, in encode
    chunks = self.iterencode(o, _one_shot=True)
  File "/usr/lib64/python2.7/json/encoder.py", line 270, in iterencode
    return _iterencode(o, 0)
TypeError: keys must be a string

@ BlackJack
Im Moment verwende ich für MongoDB den folgende Code, aber der Code lauft seit 1,5 Tagen und ist immer noch nicht fertig mit den großen Datei.

Code: Alles auswählen

from pymongo import MongoClient

db = MongoClient().test
sDB = db.sss

r = [["Test", "A", "B01", 828288,  1,    7, 'C', 4],
    ["Test", "A", "B01", 828288,  1,    7, 'C', 5],
    ["Test", "A", "B01", 828288,  1,    7, 'T', 6],
    ["Test", "A", "B01", 171878,  3,    8, 'C', 5],
    ["Test", "A", "B01", 171878,  3,    8, 'T', 6],
    ["Test", "A", "B01", 871963,  3,    9, 'A', 5],
    ["Test", "A", "B01", 871963,  3,    9, 'G', 6],
    ["Test", "A", "B01", 1932523, 1,   10, 'T', 4],
    ["Test", "A", "B01", 1932523, 1,   10, 'A', 5],
    ["Test", "A", "B01", 1932523, 1,   10, 'X', 6],
    ["Test", "A", "B01", 667214,  1,   14, 'T', 4],
    ["Test", "A", "B01", 667214,  1,   14, 'G', 5],
    ["Test", "A", "B01", 667214,  1,   14, 'G', 6]]

for i in r:
    sDB.update({'type': i[0],
          'name': i[1],
          'sub_name': i[2],
          'pos': i[3],
          's_type': i[4],
          'x_type': i[5]},
          {"$push": {
              "chr":{
                  "letter":i[6],
                  "no": i[7]} }},
          True)

Der obere Code einfügt einzeln die Datensätze in MongoDB und dabei wird jedes mal geschaut ob es schon ein Dokument mit
den ersten Attributen gibt, und falls nicht ein neues erstellt, oder dem Bestehenden etwas an `chr` anhängt.

Vielleicht wenn man viele kleine JSONs erstellt die bereits gruppiert sind (d.h. append zu 'chr' ) und diese als bulk ( http://java.dzone.com/articles/mongodb-facts-over-80000 ) zu MongoDB laden würde, würde es schneller gehen.

[snafu]

@mit: Du hast mich *völlig* falsch verstanden. An deinem Code hat sich ja nahezu nichts geändert, außer dass du jetzt Tupel statt Zahlen als Schlüssel in deiner zigfach verschachtelten Dictionary-Struktur verwenden willst. Man hat stark den Eindruck, dass du nicht wirklich weißt, was du da tust und mit der Aufgabe auch ziemlich überfordert bist. Nichts für ungut.

[Sirius3]

@mit: Du hast ja die Lösung praktisch schon, Du mußt nur Deinen MongoDB-Kram wegschmeißen und durch Python-Datentypen ersetzen. Dazu ersetzt Du die Dicts durch zwei NamedTuple und das `update(key,{'$push':item})` durch `s[key].append(item)`.

[BlackJack]

@mit: Hast Du denn wenigstens einen Index für die Collection und die Schlüssel angelegt die da beim `update()` verwendet werden? Selbst mit kann das allerdings eine kleine Ewigkeit dauern. Sind halt viele Daten.

[mit]

Ich bin ein wenig weiter mit dem Code gekommen:

Code: Alles auswählen

from collections import namedtuple, defaultdict
from pprint import pprint

r = [["Test", "A", "B01", 828288,  1,    7, 'C', 4],
    ["Test", "A", "B01", 828288,  1,    7, 'C', 5],
    ["Test", "A", "B01", 828288,  1,    7, 'T', 6],
    ["Test", "A", "B01", 171878,  3,    8, 'C', 5],
    ["Test", "A", "B01", 171878,  3,    8, 'T', 6],
    ["Test", "A", "B01", 871963,  3,    9, 'A', 5],
    ["Test", "A", "B01", 871963,  3,    9, 'G', 6],
    ["Test", "A", "B01", 1932523, 1,   10, 'T', 4],
    ["Test", "A", "B01", 1932523, 1,   10, 'A', 5],
    ["Test", "A", "B01", 1932523, 1,   10, 'X', 6],
    ["Test", "A", "B01", 667214,  1,   14, 'T', 4],
    ["Test", "A", "B01", 667214,  1,   14, 'G', 5],
    ["Test", "A", "B01", 667214,  1,   14, 'G', 6]]

Data = namedtuple('Data', "type name sub_name pos s_type x_type chr")
d = defaultdict(Data)

for i in r:
    d['-'.join((str(x) for x in i[0:6]))] = Data( type=i[0],
                                                  name=i[1],
                                                  sub_name=i[2],
                                                  pos=i[3],
                                                  s_type=i[4],
                                                  x_type=i[5],
                                                  chr.append({
                                                            "letter":i[6],
                                                            "no": i[7]}
                                                  ))

Leider weiß ich nicht wie man ein dict an chr anfügt?

@BlackJack: Leider habe ich noch nicht Index für die Collection und die Schlüssel angelegt, weil ich es noch nicht heraus gefunden habe wie man es am besten macht.

[Sirius3]

@mit: Du solltest den Key zu einem NamedTuple machen. Die Stringerzeugung ist völlig überflüssig. Ebenso das Speichern der redundanden Daten in jedem Datensatz. Das 'chr' aus MongoDB wird einfach zu einer Liste.

[Hyperion]

Mal ganz naiv nachgefragt - vielleicht habe ich das auch überlesen in den diversen Threads -: Handelt es sich bei dem Problem um Bio-Informatik? "CTAG" sieht mir nach Aminosäuren aus...

Falls ja gibt es da ja exzellente Bibliotheken - evtl. gibt es da schon Lösungsansätze, die man nutzen kann?

[mit]

@Sirius3: Habe den Code wie folgt verändert:

Code: Alles auswählen

from collections import namedtuple, defaultdict
from pprint import pprint

r = [["Test", "A", "B01", 828288,  1,    7, 'C', 4],
    ["Test", "A", "B01", 828288,  1,    7, 'C', 5],
    ["Test", "A", "B01", 828288,  1,    7, 'T', 6],
    ["Test", "A", "B01", 171878,  3,    8, 'C', 5],
    ["Test", "A", "B01", 171878,  3,    8, 'T', 6],
    ["Test", "A", "B01", 871963,  3,    9, 'A', 5],
    ["Test", "A", "B01", 871963,  3,    9, 'G', 6],
    ["Test", "A", "B01", 1932523, 1,   10, 'T', 4],
    ["Test", "A", "B01", 1932523, 1,   10, 'A', 5],
    ["Test", "A", "B01", 1932523, 1,   10, 'X', 6],
    ["Test", "A", "B01", 667214,  1,   14, 'T', 4],
    ["Test", "A", "B01", 667214,  1,   14, 'G', 5],
    ["Test", "A", "B01", 667214,  1,   14, 'G', 6]]

Key = namedtuple('Key', "type name sub_name pos s_type x_type chr")
d = defaultdict(Key)

for i in r:
    key = Key(type=i[0],
              name=i[1],
              sub_name=i[2],
              pos=i[3],
              s_type=i[4],
              x_type=i[5],
              chr=[])
    d[key].append({
                    "letter": i[6],
                    "no": i[7]
                })

Aber das anhängen funktioniert immer noch nicht (TypeError: unhashable type: 'list')

@Hyperion: Stimmt, es hat mit Bioinformatik zu tun, aber leider gibt nichts was man bereits verwenden könnte.

[BlackJack]

@mit: Mal eine doofe Zwischenfrage zu den Beispieldaten: Da sind die Elemente die den Schlüssel ausmachen sollen so schön sortiert — das ist in den tatsächlichen Eingabedaten *nicht* der Fall, oder?

[mit]

Die Eingabe Daten sind sortiert wie in Beispiel gezeigt, aber die echten Daten sind in einer Datei gespeichert.

[Sirius3]

@mit: nochmal die Grundlagen. Der Key darf nicht veränderlich sein, daher soll er nur alle nicht veränderlichen Teile enthalten; und Du willst keine Zuordnung Key -> Key sondern Key -> Liste.

[BlackJack]

@mit: Wenn die Eingabe tatsächlich sortiert ist, dann ist das doch absolut trivial und man braucht diese ganzen `defaultdict`-Spielchen gar nicht. Mann braucht auch gar nicht alles in den Speicher laden sondern immer nur alles was zu einem zusammengesetzten Schlüssel gehört.

Edit:

Code: Alles auswählen

#!/usr/bin/env python
from __future__ import absolute_import, division, print_function
from itertools import groupby


DATA = [["Test", "A", "B01", 828288,  1,    7, 'C', 5],
        ["Test", "A", "B01", 828288,  1,    7, 'T', 6],
        ["Test", "A", "B01", 171878,  3,    8, 'C', 5],
        ["Test", "A", "B01", 171878,  3,    8, 'T', 6],
        ["Test", "A", "B01", 871963,  3,    9, 'A', 5],
        ["Test", "A", "B01", 871963,  3,    9, 'G', 6],
        ["Test", "A", "B01", 1932523, 1,   10, 'T', 4],
        ["Test", "A", "B01", 1932523, 1,   10, 'A', 5],
        ["Test", "A", "B01", 1932523, 1,   10, 'X', 6],
        ["Test", "A", "B01", 667214,  1,   14, 'T', 4],
        ["Test", "A", "B01", 667214,  1,   14, 'G', 5],
        ["Test", "A", "B01", 667214,  1,   14, 'G', 6]]


def iter_something(rows):
    key_names = ['type', 'name', 'sub_name', 'pos', 's_type', 'x_type']
    chr_key_names = ['letter', 'no']
    for keys, group in groupby(rows, lambda row: row[:6]):
        result = dict(zip(key_names, keys))
        result['chr'] = [dict(zip(chr_key_names, row[6:])) for row in group]
        yield result


def main():
    for object_ in iter_something(DATA):
        print(object_)


if __name__ == '__main__':
    main()

[mit]

@ BlackJack: Danke für deine Lösung welche auch prima funktioniert, aber ich werde nicht in der Lage sein die ganze Datei im Speicher zu laden. Ich hoffe nur das viele Zeilen zusammen gefasst werden koennen so das die dict im Speicher passen.

@Sirius3:

nochmal die Grundlagen. Der Key darf nicht veränderlich sein, daher soll er nur alle nicht veränderlichen Teile enthalten; und Du willst keine Zuordnung Key -> Key sondern Key -> Liste.

Genau, aber leider weiß ich immer noch nicht wie man die Aufgabe mit namedtuples lösen koennte.

[BlackJack]

@mit: Du musst ja nicht alles in den Speicher laden. Die Funktion lädt immer nur so viele Zeilen aus der Eingabedatei wie für *ein* Wörterbuch gebraucht werden.