Große CSV-Verarbeitung mit Go

Die Idee ist:

Angenommen, eine große Dummy-CSV-Datei (1 Million Zeilen) enthält Stichproben von Kundendaten und führt die Verarbeitung mit den folgenden Zielen durch:

• Extrahieren Sie die Daten aus der CSV
• Berechnen Sie, wie viele Daten/Zeilen
• Gruppierung der Anzahl der Kunden für jede Stadt
• Städte nach Kundenzahl sortieren, vom höchsten zum niedrigsten Wert
• Bearbeitungszeit berechnen

Beispiel-CSV-Dateien der Kunden können hier heruntergeladen werden: https://github.com/datablist/sample-csv-files

Daten laden und extrahieren

Anscheinend verfügt Go über eine Standardbibliothek für die CSV-Verarbeitung. Wir brauchen keine Abhängigkeit von Dritten mehr, um unser Problem zu lösen, was schön ist. Die Lösung ist also ziemlich einfach:

  // open the file to a reader interface
  c, err := os.Open("../data/customers-1000000.csv")
  if err != nil {
    log.Fatal(err)
  }
  defer c.Close()

  // load file reader into csv reader
  // Need to set FieldsPerRecord to -1 to skip fields checking
  r := csv.NewReader(c)
  r.FieldsPerRecord = -1
  r.ReuseRecord = true
  records, err := r.ReadAll()
  if err != nil {
    log.Fatal(err)
  }

1. Öffnen Sie die Datei über den angegebenen Pfad
2. Geöffnete Datei in CSV-Reader laden
3. Speichert alle extrahierten CSV-Datensätze/Zeilenwerte zur späteren Verarbeitung im Datensatzbereich

FieldsPerRecord ist auf -1 gesetzt, weil ich die Feldprüfung in der Zeile überspringen möchte, da die Anzahl der Felder oder Spalten in jedem Format unterschiedlich sein kann

In diesem Zustand können wir bereits alle Daten aus der CSV-Datei laden und extrahieren und sind für den nächsten Verarbeitungszustand bereit. Mit der Funktion len(records) können wir auch ermitteln, wie viele Zeilen in CSV vorhanden sind.

Gruppierung der Gesamtkundenzahl nach jeder Stadt

Jetzt können wir die Datensätze iterieren und erstellen, dass die Karte den Namen der Stadt und die Gesamtzahl der Kunden enthält und so aussieht:

["Jakarta": 10, "Bandung": 200, ...]

Stadtdaten in der CSV-Zeile befinden sich im 7. Index und der Code sieht so aus

  // create hashmap to populate city with total customers based on the csv data rows
  // hashmap will looks like be ["city name": 100, ...]
  m := map[string]int{}
  for i, record := range records {
    // skip header row
    if i == 0 {
    continue
    }
    if _, found := m[record[6]]; found {
      m[record[6]]++
    } else {
      m[record[6]] = 1
    }
  }

Wenn die Stadtkarte nicht vorhanden ist, erstellen Sie eine neue Karte und setzen Sie die Gesamtzahl der Kunden auf 1. Andernfalls erhöhen Sie einfach die Gesamtzahl der angegebenen Stadt.

Jetzt haben wir Karte m, die eine Sammlung der Stadt und der Anzahl der darin enthaltenen Kunden enthält. Zu diesem Zeitpunkt haben wir bereits das Problem der Gruppierung der Anzahl der Kunden für jede Stadt gelöst.

Sortierung nach höchstem Gesamtkundenwert

Ich habe versucht herauszufinden, ob es in der Standardbibliothek eine Funktion zum Sortieren der Karte gibt, konnte sie aber leider nicht finden. Die Sortierung ist nur für Slice möglich, da wir die Datenreihenfolge basierend auf der Indexposition neu anordnen können. Also ja, machen wir einen Ausschnitt aus unserer aktuellen Karte.

// convert to slice first for sorting purposes
dc := []CityDistribution{}
for k, v := range m {
  dc = append(dc, CityDistribution{City: k, CustomerCount: v})
}

Wie haben wir es nun nach CustomerCount vom höchsten zum niedrigsten sortiert? Der gebräuchlichste Algorithmus hierfür ist die Verwendung von Bubble Short. Obwohl es nicht das Schnellste ist, könnte es seinen Zweck erfüllen.

Bubble Sort ist der einfachste Sortieralgorithmus, der durch wiederholtes Vertauschen benachbarter Elemente funktioniert, wenn sie in der falschen Reihenfolge sind. Dieser Algorithmus eignet sich nicht für große Datensätze, da seine durchschnittliche und ungünstigste Zeitkomplexität recht hoch ist.

Referenz: https://www.geeksforgeeks.org/bubble-sort-algorithm/

Mithilfe unseres Slice durchläuft es die Daten, prüft den nächsten Wert des Index und tauscht ihn aus, wenn die aktuellen Daten kleiner als der nächste Index sind. Sie können den detaillierten Algorithmus auf der Referenzwebsite überprüfen.

Jetzt könnte unser Sortierprozess so aussehen

  // open the file to a reader interface
  c, err := os.Open("../data/customers-1000000.csv")
  if err != nil {
    log.Fatal(err)
  }
  defer c.Close()

  // load file reader into csv reader
  // Need to set FieldsPerRecord to -1 to skip fields checking
  r := csv.NewReader(c)
  r.FieldsPerRecord = -1
  r.ReuseRecord = true
  records, err := r.ReadAll()
  if err != nil {
    log.Fatal(err)
  }

Am Ende der Schleife liefert uns das letzte Segment sortierte Daten.

Berechnen Sie die Bearbeitungszeit

Die Berechnung der Verarbeitungszeit ist ganz einfach. Wir erhalten einen Zeitstempel vor und nach der Ausführung des Hauptprozesses des Programms und berechnen die Differenz. In Go sollte der Ansatz einfach genug sein:

["Jakarta": 10, "Bandung": 200, ...]

Das Ergebnis

Führen Sie das Programm mit dem Befehl aus

  // create hashmap to populate city with total customers based on the csv data rows
  // hashmap will looks like be ["city name": 100, ...]
  m := map[string]int{}
  for i, record := range records {
    // skip header row
    if i == 0 {
    continue
    }
    if _, found := m[record[6]]; found {
      m[record[6]]++
    } else {
      m[record[6]] = 1
    }
  }

Ausgedruckt werden die Anzahl der Zeilen, die sortierten Daten und die Verarbeitungszeit. Etwas wie das hier unten:

Wie von der Go-Leistung erwartet, wurden 1 Million CSV-Zeilen in weniger als 1 Sekunde verarbeitet!

Alle fertigen Codes sind bereits in meinem Github-Repository veröffentlicht:

https://github.com/didikz/csv-processing/tree/main/golang

Lektion gelernt

• Die CSV-Verarbeitung in Go ist bereits in der Standardbibliothek verfügbar, es ist nicht erforderlich, eine Drittanbieterbibliothek zu verwenden
• Die Verarbeitung der Daten ist recht einfach. Die Herausforderung bestand darin, herauszufinden, wie die Daten sortiert werden müssen, da dies manuell erfolgen muss

Was fällt Ihnen ein?

Ich dachte, meine aktuelle Lösung könnte weiter optimiert werden, da ich alle extrahierten CSV-Datensätze in einer Schleife zur Zuordnung verarbeitet habe und wenn wir die ReadAll()-Quelle überprüft haben, gibt es auch eine Schleife zum Erstellen des Slice basierend auf dem angegebenen Dateireader. Dadurch könnten 1-Millionen-Zeilen 2 x Schleifen für 1-Millionen-Daten erzeugen, was nicht schön ist.

Ich dachte, wenn ich Daten direkt aus dem Dateireader lesen könnte, bräuchte es nur eine Schleife, weil ich direkt daraus eine Karte erstellen könnte. Außer, dass der Datensatz-Slice an anderer Stelle verwendet wird, in diesem Fall jedoch nicht.

Ich habe immer noch keine Zeit, es herauszufinden, aber ich dachte mir auch, dass es einen Nachteil gibt, wenn ich es manuell mache:

• Wahrscheinlich müssen weitere Fehler des Parsing-Prozesses behandelt werden
• Ich bin mir nicht sicher, wie stark es die Bearbeitungszeit verkürzen wird, ob sich die Problemumgehung lohnt oder nicht

Viel Spaß beim Programmieren!

Das obige ist der detaillierte Inhalt vonGroße CSV-Verarbeitung mit Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!