Traitement CSV volumineux à l'aide de Go

L'idée est :

Étant donné qu'un grand CSV factice (1 million de lignes) contient un échantillon de données client et effectue le traitement avec les objectifs ci-dessous :

• Extraire les données du CSV
• Calculer combien de données/lignes
• Regrouper combien de clients pour chaque ville
• Trier les villes par nombre de clients du plus élevé au plus bas
• Calculer le temps de traitement

Un exemple CSV des clients peut être téléchargé ici https://github.com/datablist/sample-csv-files

Charger et extraire des données

Apparemment, Go a une bibliothèque standard pour le traitement CSV. Nous n'avons plus besoin de dépendance tierce pour résoudre notre problème, ce qui est bien. La solution est donc assez simple :

  // 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. Ouvrez le fichier à partir du chemin indiqué
2. Charger le fichier ouvert sur le lecteur CSV
3. Contient tous les enregistrements/lignes CSV extraits dans une tranche d'enregistrements pour un traitement ultérieur

FieldsPerRecord est défini sur -1 car je souhaite ignorer la vérification des champs sur la ligne, car le nombre de champs ou de colonnes peut être différent dans chaque format

Dans cet état, nous sommes déjà en mesure de charger et d'extraire toutes les données du CSV et sommes prêts pour le prochain état de traitement. Nous pourrons également savoir combien de lignes dans CSV en utilisant la fonction len(records).

Regroupement du nombre total de clients dans chaque ville

Nous pouvons désormais parcourir les enregistrements et créer la carte contenant le nom de la ville et le nombre total de clients qui ressemble à ceci :

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

Les données de la ville dans la ligne CSV sont situées dans le 7ème index et le code ressemblera à ceci

  // 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
    }
  }

Si le plan de la ville n'existe pas, créez une nouvelle carte et définissez le total du client sur 1. Sinon, incrémentez simplement le nombre total de villes données.

Maintenant, nous avons la carte m contenant une collection de villes et le nombre de clients à l'intérieur. À ce stade, nous avons déjà résolu le problème du regroupement du nombre de clients pour chaque ville.

Trier le client total le plus élevé

J'ai essayé de trouver s'il existe une fonction dans la bibliothèque standard pour trier la carte mais malheureusement je ne l'ai pas trouvée. Tri possible uniquement pour la tranche car nous pouvons réorganiser l'ordre des données en fonction de la position de l'index. Alors oui, faisons une tranche de notre carte actuelle.

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

Maintenant, comment l'avons-nous trié par CustomerCount du plus élevé au plus bas ? L’algorithme le plus courant pour cela utilise le bubble short. Bien que ce ne soit pas le plus rapide, il pourrait faire l'affaire.

Bubble Sort est l'algorithme de tri le plus simple qui fonctionne en échangeant à plusieurs reprises les éléments adjacents s'ils sont dans le mauvais ordre. Cet algorithme ne convient pas aux grands ensembles de données car sa complexité temporelle moyenne et dans le pire des cas est assez élevée.

Référence : https://www.geeksforgeeks.org/bubble-sort-algorithm/

En utilisant notre tranche, il bouclera sur les données et vérifiera la valeur suivante de l'index et l'échangera si les données actuelles sont inférieures à l'index suivant. Vous pouvez vérifier l'algorithme de détail sur le site de référence.

Maintenant, notre processus de tri pourrait être comme ça

  // 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)
  }

À la fin de la boucle, la tranche finale nous donnera des données triées.

Calculer le temps de traitement

Calculer le temps de traitement est assez simple, nous obtenons l'horodatage avant et après l'exécution du processus principal du programme et calculons la différence. En Go, l'approche devrait être assez simple :

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

Le résultat

Exécutez le programme avec la commande

  // 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
    }
  }

Les informations imprimées indiqueraient le nombre de lignes, les données triées et le temps de traitement. Quelque chose comme ceci ci-dessous :

Comme prévu par les performances de Go, il a traité 1 million de lignes CSV en moins d'une seconde !

Tous les codes complétés sont déjà publiés sur mon référentiel Github :

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

Leçon apprise

• Le traitement CSV dans Go est déjà disponible dans la bibliothèque standard, pas besoin d'utiliser une bibliothèque tierce
• Le traitement des données est assez simple. Le défi était de savoir comment trier les données car il fallait le faire manuellement

Qu'est-ce qui vous vient à l'esprit ?

Je pensais que ma solution actuelle pourrait être optimisée davantage car j'ai bouclé tous les enregistrements extraits au format CSV pour les mapper et si nous avons vérifié la source ReadAll(), elle a également une boucle pour créer la tranche basée sur le lecteur de fichier donné. De cette manière, des lignes de 1 Mil pourraient produire 2 x boucles pour des données de 1 Mil, ce qui n'est pas agréable.

Je pensais que si je pouvais lire les données directement à partir du lecteur de fichiers, cela n'aurait besoin que d'une seule boucle car je pourrais créer une carte directement à partir de celui-ci. Sauf que la tranche d'enregistrements sera utilisée ailleurs mais pas dans ce cas.

Je n'ai pas encore le temps de le comprendre, mais j'ai aussi pensé à certains inconvénients si je le fais manuellement :

• Il faudra probablement gérer davantage d'erreurs du processus d'analyse
• Je ne sais pas dans quelle mesure cela réduira le temps de traitement pour considérer que la solution de contournement en vaudra la peine ou non

Bon codage !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!