Mit der rasanten Entwicklung der Datenanalyse und künstlichen Intelligenz ist die Datenvisualisierung zu einem immer wichtigeren Werkzeug geworden. Die Datenvisualisierung hilft Menschen nicht nur, Daten intuitiver zu verstehen, sondern hilft ihnen auch, die in den Daten verborgenen Informationen und Muster besser zu entdecken. Auch in dieser Hinsicht ist die Go-Sprache ein sehr gutes Werkzeug. Als leistungsstarke Programmiersprache verfügt die Go-Sprache über viele Funktionen. In diesem Artikel wird erläutert, wie Sie die Go-Sprache zur Datenvisualisierung verwenden.
Bevor wir die Verwendung der Go-Sprache zur Datenvisualisierung einführen, müssen wir zunächst die Eigenschaften der Go-Sprache verstehen. Im Folgenden sind die Hauptfunktionen der Go-Sprache aufgeführt.
Go-Sprache ist eine Programmiersprache, die auf gleichzeitigen Operationen basiert. Sie erreicht eine hohe Parallelitätsleistung durch Mechanismen wie Goroutine, Channel und Mutex. Dies erleichtert das Schreiben effizienter gleichzeitiger Programme.
Go-Sprache bietet eine sehr umfangreiche Standardbibliothek, die Netzwerkprogrammierung, E/A, Dateiverarbeitung usw. abdeckt. Mit der Unterstützung dieser Standardbibliotheken können wir problemlos Programme entwickeln.
Go-Sprache ist eine statisch typisierte Programmiersprache. Durch statische Typisierung kann die Art des Codes im Voraus überprüft und einige Typfehler vermieden werden.
Go-Sprache unterstützt Cross-Compilation, wodurch wir Programme einfach in ausführbare Dateien für verschiedene Plattformen kompilieren können. Dies ermöglicht die Entwicklung und Bereitstellung für verschiedene Plattformen.
In der Go-Sprache können wir Bibliotheken und Tools von Drittanbietern verwenden, um schnell eine Datenvisualisierung zu erreichen. Hier sind die Schritte zur Datenvisualisierung mit der Go-Sprache.
Bevor wir beginnen, müssen wir einige notwendige Bibliotheken und Tools installieren. Die folgenden Bibliotheken und Tools müssen installiert werden:
Sie können diese Bibliotheken und Tools mit dem folgenden Befehl installieren:
go get -u github.com/wcharczuk/go-chart go get -u github.com/gin-gonic/gin go get -u github.com/jinzhu/gorm
Bevor wir die Datenvisualisierung durchführen, müssen wir zuerst die Daten vorbereiten. Hier ist eine Beispiel-CSV-Datei:
日期,收入,支出 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
Wir können Gorm verwenden, um diese CSV-Datei in eine Datenbank einzulesen. Das Folgende ist der Code für ein Beispiel:
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) } }
Mit den Daten können wir mit der Diagrammerstellung beginnen. In der Go-Sprache können wir GoChart verwenden, um Diagramme zu erstellen. Das Folgende ist ein Beispielcode zum Generieren eines Liniendiagramms:
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") }
Mit dem Diagramm können wir den Webserver starten. In der Go-Sprache können wir Gin verwenden, um den Webserver zu starten. Das Folgende ist ein Beispielcode:
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") }
Jetzt können wir http://localhost:8080 im Browser aufrufen, um das generierte Liniendiagramm anzuzeigen.
Go-Sprache kann uns als leistungsstarke Programmiersprache dabei helfen, die Datenvisualisierung einfach durchzuführen. In diesem Artikel stellen wir vor, wie Sie mit der Go-Sprache schnell Diagramme generieren und mit Gin einen Webserver zum Anzeigen dieser Diagramme starten. Wenn Sie sich für Datenvisualisierung interessieren, ist die Verwendung der Go-Sprache zur Datenvisualisierung eine sehr gute Wahl.
Das obige ist der detaillierte Inhalt vonWie verwende ich die Go-Sprache zur Datenvisualisierung?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!