Comment utiliser le langage Go pour la visualisation de données ?

Avec le développement rapide de l'analyse des données et de l'intelligence artificielle, la visualisation des données est devenue un outil de plus en plus important. La visualisation des données aide non seulement les utilisateurs à comprendre les données de manière plus intuitive, mais les aide également à mieux découvrir les informations et les modèles cachés dans les données. Le langage Go est également un très bon outil à cet égard. En tant que langage de programmation performant, le langage Go possède de nombreuses fonctionnalités. Cet article explique comment utiliser le langage Go pour la visualisation de données.

Caractéristiques du langage Go

Avant d'introduire l'utilisation du langage Go pour la visualisation de données, nous devons d'abord comprendre les caractéristiques du langage Go. Voici les principales fonctionnalités du langage Go.

Hautes performances de concurrence

Le langage Go est un langage de programmation basé sur des opérations simultanées. Il atteint des performances de concurrence élevées grâce à des mécanismes tels que Goroutine, Channel et Mutex. Cela facilite l’écriture de programmes concurrents efficaces.

Bibliothèque standard riche

Le langage Go fournit une bibliothèque standard très riche, couvrant la programmation réseau, les E/S, le traitement de fichiers, etc. Avec le support de ces bibliothèques standards, nous pouvons facilement développer des programmes.

Langage typé statique

Le langage Go est un langage de programmation typé statiquement. La saisie statique permet de vérifier le type de code à l'avance et d'éviter certaines erreurs de type.

Prise en charge de la compilation croisée

Le langage Go prend en charge la compilation croisée, ce qui nous permet de compiler facilement des programmes en fichiers exécutables pour différentes plates-formes. Cela permet le développement et le déploiement pour différentes plates-formes.

Utilisez le langage Go pour la visualisation des données

Dans le langage Go, nous pouvons utiliser des bibliothèques et des outils tiers pour réaliser rapidement une visualisation des données. Voici les étapes de visualisation des données à l’aide du langage Go.

Étape 1 : Installer les bibliothèques et les outils nécessaires

Avant de commencer, nous devons installer certaines bibliothèques et outils nécessaires. Voici les bibliothèques et outils qui doivent être installés :

• GoChart : une bibliothèque de graphiques en langage Go. Utilisé pour générer des graphiques.
• Gin : Un framework web en langage Go. Utilisé pour créer des serveurs Web et gérer les requêtes HTTP.
• Gorm : une bibliothèque ORM pour le langage Go. Utilisé pour faire fonctionner la base de données.

Vous pouvez installer ces bibliothèques et outils à l'aide de la commande suivante :

go get -u github.com/wcharczuk/go-chart
go get -u github.com/gin-gonic/gin
go get -u github.com/jinzhu/gorm

Étape 2 : Préparer les données

Avant de faire la visualisation des données, nous devons d'abord préparer les données. Voici un exemple de fichier CSV :

日期,收入,支出
2020-01-01,10000,8000
2020-01-02,12000,9000
2020-01-03,11000,10000
2020-01-04,13000,8000
2020-01-05,14000,12000

Nous pouvons utiliser Gorm pour lire ce fichier CSV dans une base de données. Voici le code d'un exemple :

package main

import (
    "bufio"
    "encoding/csv"
    "io"
    "log"
    "os"
    "time"

    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/sqlite"
)

type Record struct {
    gorm.Model
    Date   time.Time `gorm:"not null"`
    Income int       `gorm:"not null"`
    Expense int      `gorm:"not null"`
}

func main() {
    db, err := gorm.Open("sqlite3", "test.db")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    db.AutoMigrate(&Record{})
    file, err := os.Open("data.csv")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()
    reader := csv.NewReader(bufio.NewReader(file))
    for {
        line, err := reader.Read()
        if err == io.EOF {
            break
        } else if err != nil {
            log.Fatal(err)
        }
        date, err := time.Parse("2006-01-02", line[0])
        if err != nil {
            log.Fatal(err)
        }
        income, err := strconv.Atoi(line[1])
        if err != nil {
            log.Fatal(err)
        }
        expense, err := strconv.Atoi(line[2])
        if err != nil {
            log.Fatal(err)
        }
        record := Record{
            Date:    date,
            Income:  income,
            Expense: expense,
        }
        db.Create(&record)
    }
}

Étape 3 : Générer des graphiques

Avec les données, nous pouvons commencer à générer des graphiques. En langage Go, nous pouvons utiliser GoChart pour générer des graphiques. Voici un exemple de code pour générer un graphique linéaire :

package main

import (
    "net/http"
    "strconv"

    "github.com/gin-gonic/gin"
    "github.com/wcharczuk/go-chart"
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/sqlite"
)

func main() {
    db, err := gorm.Open("sqlite3", "test.db")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    r := gin.Default()
    r.GET("/", func(c *gin.Context) {
        var records []Record
        db.Find(&records)
        var xvalues []time.Time
        var yvalues1 []float64
        var yvalues2 []float64
        for _, record := range records {
            xvalues = append(xvalues, record.Date)
            yvalues1 = append(yvalues1, float64(record.Income))
            yvalues2 = append(yvalues2, float64(record.Expense))
        }
        graph := chart.Chart{
            Title: "收入支出",
            XAxis: chart.XAxis{
                Name: "日期",
                Ticks: []chart.Tick{
                    {Value: chart.TimeToFloat64(xvalues[0]), Label: xvalues[0].Format("2006-01-02")},
                    {Value: chart.TimeToFloat64(xvalues[len(xvalues)-1]), Label: xvalues[len(xvalues)-1].Format("2006-01-02")},
                },
            },
            YAxis: chart.YAxis{
                Name: "金额",
            },
            Series: []chart.Series{
                chart.TimeSeries{
                    Name:    "收入",
                    XValues: xvalues,
                    YValues: yvalues1,
                },
                chart.TimeSeries{
                    Name:    "支出",
                    XValues: xvalues,
                    YValues: yvalues2,
                },
            },
        }
        buffer := bytes.NewBuffer([]byte{})
        graph.Render(chart.PNG, buffer)
        c.Data(http.StatusOK, "image/png", buffer.Bytes())
    })
    r.Run(":8080")
}

Étape 4 : Démarrez le serveur Web

Avec le graphique, nous pouvons démarrer le serveur Web. En langage Go, on peut utiliser Gin pour démarrer le serveur web. Voici un exemple de code :

func main() {
    db, err := gorm.Open("sqlite3", "test.db")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    r := gin.Default()
    r.GET("/", func(c *gin.Context) {
        var records []Record
        db.Find(&records)
        // 生成图表的代码
        // ...
        c.Data(http.StatusOK, "image/png", buffer.Bytes())
    })
    r.Run(":8080")
}

Maintenant, nous pouvons visiter http://localhost:8080 dans le navigateur pour afficher le graphique linéaire généré.

Conclusion

Le langage Go, en tant que langage de programmation haute performance, peut nous aider à effectuer facilement une visualisation de données. Dans cet article, nous expliquons comment utiliser le langage Go pour générer rapidement des graphiques et utiliser Gin pour démarrer un serveur Web afin d'afficher ces graphiques. Si vous êtes intéressé par la visualisation de données, utiliser le langage Go pour la visualisation de données est un très bon choix.

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!