Go 中的数据分析——如何使用 Gota 包

数据分析是过滤、操纵和处理原始数据和数据集以从中获得洞察力的过程。

Python 和 R 通常是数据分析的首选语言。但是这些天,Go 正为此目的而变得越来越流行。

在本教程中,我们将介绍 Gota(Go 中的数据分析包)及其核心功能和用途。

先决条件

  • 了解 Golang 中的函数式编程。
  • 安装了 Go 的 Golang IDE(我使用 Goland 和 Go 1.17.6,但您可以使用其他任何版本)

什么是戈塔?

Gota 是 Go 编程语言的数据框和数据整理模块。

Gota 类似于 Python 中的 Pandas 库,并且是为与 Gonum 接口而构建的 Gonum 是 Golang 中的一个科学计算包,就像 Pandas 和 Numpy 一样。

Gota 模块使 Go 中的数据整理(转换和操作)操作变得非常容易。它适用于 Go 内置数据类型和各种文件格式,如 JSON、CSV 和 HTML。

以下是我们将介绍的内容:

  • 哥达系列。
  • 得到数据框。
  • 将文件作为数据框读取。
  • Gota 数据帧上的操作。
  • 导出和保存文件。

如何开始使用 Gota

安装 Gota 很容易。将以下命令粘贴到您的终端中:

go get -u https://github.com/go-gota/gota

这应该会输出成功的安装消息。如果没有,请将您的 Golang 更新到较新的版本并重试安装。

基本的 Gota 概念

数据框

在深入研究之前,让我们先了解一些 Gota 基础知识:

数据集是数据的集合,表格或其他形式。

数据框是将数据组织成二维(行和列)表的数据结构,通常用于分析目的。

系列是属于数据框的一维数据的集合。

请注意,这DataFrame是本文中用作示例的数据框对象的变量名称。

什么是戈塔系列?

import "github.com/go-gota/gota/series"

Gota 系列是使用series.New复合数据类型(如切片和地图)的方法创建的。

对于切片,[series.New](http://series.New)接受三个参数:切片、系列类型(要包含在系列中的元素的类型)和列名。

series.New([]string{"z", "y", "d", "e"}, series.String, "col")

系列也可以通过将键初始化为类型series并使用 Type 方法插入系列类型来从映射中创建。

a := map[string]series.Type{
		"A": series.String,
		"D": series.Bool,
	}

这些切片可以传递到数据帧中以进行进一步的操作和操作。

什么是 Gota 数据框?

Dataframe 函数包含在 Gota 中的 dataframe 子模块中。

import "github.com/go-gota/gota/dataframe"

数据帧是其他数据结构的数据结构。本质上,它们将数据格式化为二维表,以便您可以操作这些数据。因此,要使用数据帧,我们需要读取其他数据结构和数据类型。

我们将在本教程中阅读系列、结构、JSON 和 CSV 文件。

如何将系列转换为数据框对象

您可以使用该方法将一个系列或一组系列转换为数据框对象[dataframe.New](http://dataframe.New)。它以系列作为参数。

dataFrame := dataframe.New(
		series.New([]string{"a", "b", "c", "d", "e"}, series.String, "alphas"),
		series.New([]int{5, 4, 2, 3, 1}, series.Int, "numbers"),
		series.New([]string{"a1", "b2", "c3", "d4", "e5"}, series.String, "alnums"),
		series.New([]bool{true, false, true, true, false}, series.Bool, "state"),
	)

fmt.Println(dataFrame)

输出

alphas   numbers alnums   state
 0: a        5       a1       true
 1: b        4       b2       false
 2: c        2       c3       true
 3: d        3       d4       true
 4: e        1       e5       false
    <string> <int>   <string> <bool>

结构类型的数据框

您可以使用结构来创建数据框。

type Dog struct {
	Name     string
	Colour      string
	Height  int
  Vaccinated  bool
}

dogs := []Dog{
	{"buster", "black", 56, false},
	{"jake", "white", 61, false},
	{"bingo", "brown", 50, true},
	{"gray", "cream", 68, false},
}

dogsDf := dataframe.LoadStructs(dogs) 
fmt.Println(dogsDf)

您可以通过创建 struct 类型的实例切片并使用dataframe.Loadstructs接收切片的方法创建数据帧来做到这一点。

输出

Name     Colour   Height Vaccinated
 0: buster   black    56     false
 1: jake     white    61     false
 2: bingo    brown    50     true
 3: gray     cream    68     false
    <string> <string> <int>  <bool>

如何在 Gota 中查询数据框

当我们有一个数据框对象时,我们可以使用各种方法查询它以获取有关数据框组成的信息。

  • dataFrame.Dims()→ 输出数据框对象的维度。
  • dataFrame.Types()→ 输出构成数据帧的数据类型。
  • dataFrame.Names()→ 输出数据框的列名。
  • dataFrame.Nrow()→ 输出行数。
  • dataFrame.Ncol()→ 输出列数。

如何查询列

Gota 数据框列附带了许多方法,可帮助查询列值。

  • .IsNaN()→ 检查它是否为空列。
  • .Mean()→ 返回列的平均值。
  • .Copy()→ 创建列的新副本。
  • .HasNaN()→ 检查列中是否有空值。
  • .Records()→ 返回列中的值。
aCol := dataFrame.Col("column_name") //selects a column
fmt.Println(aCol.HasNaN)

如何将文件读入数据框对象

JSON 和 CSV 字符串可以分别传递给dataframe.ReadJSONdataframe.ReadCSV

如何读取 JSON 字符串

JSON 字符串变量作为参数传递给dataframe.ReadJSONusingstrings.NewReader返回缓冲的 JSON 字符串。

	jsonString := `[
  {
    "Name": "John",
    "Age": 44,
    "Colour": "Red",
    "Height(ft)": 6.7
  },
  {
    "Name": "Mary",
    "Age": 40,
    "Colour": "Blue",
    "Height(ft)": 5.7
  }
]`

	dataRead := dataframe.ReadJSON(strings.NewReader(jsonString))
	fmt.Println(dataRead)
}

如何读取 CSV 字符串

在这里,我们有 CSV 格式的相同字符串:

import (
	"fmt"
	"github.com/go-gota/gota/dataframe"
	"strings"
)

	csvString := `
	Name, Age, Colour, Height(ft)
	John,44,Red,6.7
	Mary,40,Blue,5.7`

	dataRead := dataframe.ReadCSV(strings.NewReader(csvString))
	fmt.Println(dataRead)

输出

Name      Age   Colour   Height(ft)
0: John   44    Red      6.700000
1: Mary   40    Blue     5.700000

如何读取 CSV 文件

这是 CSV:

Name,Age,Colour,Height(ft)
John,44,Red,6.7
Mary,40,Blue,5.7
Esther,35,Black,4.9
Jason,36,Green,5.2

您可以通过读取包含[os.Open](http://os.Open)文件名的文件来读取 CSV 文件。defer file.Close()是一个上下文管理器,它可以帮助我们在程序运行后关闭文件以防止数据丢失。

	file, err := os.Open("example.csv")
	defer file.Close()
	if err != nil {
		log.Fatal(err)
	}
	dataFrame := dataframe.ReadCSV(file)

	fmt.Println(dataFrame)

如何读取 JSON 文件

读取 JSON 文件与读取 CSV 文件完全一样。

这是 JSON:

[
  {
    "Name": "John",
    "Age": 44,
    "Colour": "Red",
    "Height(ft)": 6.7
  },
  {
    "Name": "Mary",
    "Age": 40,
    "Colour": "Blue",
    "Height(ft)": 5.7
  },
  {
    "Name": "Esther",
    "Age": 35,
    "Colour": "Black",
    "Height(ft)": 4.9
  },
  {
    "Name": "Mary",
    "Age": 40,
    "Colour": "Green",
    "Height(ft)": 5.2
  }
]

以下是您阅读文件的方式:

	file, err := os.Open("example.json")
	defer file.Close()
	if err != nil {
		log.Fatal(err)
	}
	dataFrame := dataframe.ReadJSON(file)

	fmt.Println(dataFrame)

输出:

Age   Colour   Height(ft) Name
 0: 44    Red      6.700000   John
 1: 40    Blue     5.700000   Mary
 2: 35    Black    4.900000   Esther
 3: 40    Green    5.200000   Mary
    <int> <string> <float>    <string>

Gota 数据框操作

如何在 Gota 中选择行

Subset您可以使用数据框对象的方法选择行。dataFrame.Subset接受两个整数的切片,表示可以选择的行数。

Gota 为数据帧操作提供了多种功能。使用上面的示例数据框,让我们回顾一下其中的一些操作:

row := dataFrame.Subset([]int{0, 2})

这将选择数据框的前两行。

输出:

Age   Colour   Height(ft) Name
 0: 44    Red      6.700000   John
 1: 35    Black    4.900000   Esther
    <int> <string> <float>    <string>

如何在 Gota 中选择列

Select方法帮助我们选择数据框的列。[df.Select](http://df.Select)接受两个整数的切片,表示可以选择多少列。

column := dataFrame.Select([]int{0, 2})

我们还可以通过传递一个字符串切片按索引(列名)选择列。

column := dataFrame.Select([]string{"Name", "Colour"})

输出:

Name     Colour
 0: John     Red
 1: Mary     Blue
 2: Esther   Black
 3: Mary     Green
    <string> <string>

如何在 Gota 中更新数据框

我们使用.Set数据框对象的方法来更新条目。dataFrame.Set接收指定要更新的行数限制的整数切片,以及dataframe.LoadRecords接收要传入类型的二维切片的函数。

	dataFrame2 := dataFrame.Set(
		    []int{0, 3},
		    dataframe.LoadRecords(
			  [][]string{
				[]string{"Jenny", "23", "purple", "2.2"},
				[]string{"Jesse", "34", "indigo", "3.5"},
				[]string{"Peter", "33", "violet", "3.3"},
			},
		),
	)

输出

Name     Age   Colour   Height(ft)
 0: Jesse    34    indigo   3.500000
 1: Mary     40    Blue     5.700000
 2: Esther   35    Black    4.900000
 3: Peter    33    violet   3.300000
    <string> <int> <string> <float>

如何在 Gota 中过滤值

为了过滤值,我们.Filter在数据框对象上使用。这需要dataframe.F我们将结构文字传递给。

struct 文字包含一个列名Colname、一个比较器Comparator和一个值Comparando,该值是我们要过滤数据帧的值。

比较器:

  • series.Eq→ 等于 =。
  • series.Neq→ 不等于≠。
  • series.Greater→ 大于 >。
  • series.GreaterEq→ 大于或等于 ≥。
  • series.Less→ 小于 <。
  • series.LessEq→ 小于或等于 ≤。
  • [series.In](http://series.In)→ 包含在。

在此示例中,我们使用从系列到上面的数据框部分的数据框对象。

fil := dataFrame.Filter(
		dataframe.F{Colname: "alphas", Comparator: series.Eq, Comparando: "b"},
)

输出:

alphas   numbers alnums   state
 0: b        2       b2       false
  <string> <int>   <string> <bool>

如何在 Gota 中对数据框进行排序

.Arrange您可以使用数据框对象的方法对数据框进行排序。它分别按升序dataframe.Sortdataframe.RevSort降序排列。它还接受要作为字符串排序的列的名称。

按升序排序:

sorted := dataFrame.Arrange(
    dataframe.Sort("numbers")
)

输出:

alphas   numbers alnums   state
 0: e        1       e5       false
 1: c        2       c3       true
 2: d        3       d4       true
 3: b        4       b2       false
 4: a        5       a1       true
    <string> <int>   <string> <bool>

按降序排序:

sorted := dataFrame.Arrange(
    dataframe.RevSort("numbers"),
)

如何在 Gota 中使用 Groupby

您可以使用 groupby 根据特定列对数据进行分类。

要使用 Gota 对列进行分组,我们使用该Groupby方法并传入列名。

	categorise := dataFrame.GroupBy("Name", "Age")
	fmt.Println(categorise)

如何在 Gota 中加入数据框

连接是数据框的组合。使用 Gota 连接数据帧就像在 SQL(结构化查询语言)中一样。

连接类型:

  • 内连接 →dataFrame.InnerJoin返回两个表中匹配值的数据框。
  • Left Join →dataFrame.LeftJoin匹配右数据帧与左数据帧的相似性。
  • Right Join →dataFrame.RightJoin将左侧数据帧中的相似性与右侧数据帧匹配。
  • Outer Join → dataFrame.OuterJoin返回数据框的所有值。

加入数据框对象的语法是:

joinVariableName := dataFrameObject.joinType(OtherDataframe, JoinKey)

Join 键是要执行连接的数据框对象的列。

左连接示例

 df := dataframe.New(
		series.New([]string{"a", "b", "c", "d", "e"}, series.String, "alphas"),
		series.New([]int{5, 4, 2, 3, 1}, series.Int, "numbers"),
		series.New([]string{"a1", "b2", "c3", "d4", "e5"}, series.String, "alnums"),
		series.New([]bool{true, false, true, true, false}, series.Bool, "state"),
	)
	df2 := dataframe.New(
		series.New([]string{"f", "g", "h", "i", "j"}, series.String, "alphas"),
		series.New([]int{1, 2, 3, 4, 5}, series.Int, "numbers"),
		series.New([]string{"f6", "g7", "h8", "i9", "j10"}, series.String, "alnums"),
		series.New([]bool{false, true, false, false, true}, series.Bool, "state"),
	)
  
	join := df.RightJoin(df2, "state")
  
	fmt.Println(join)

输出:

[12x7] DataFrame

    state  alphas_0 numbers_0 alnums_0 alphas_1 numbers_1 alnums_1
 0: false  b        4         b2       f        1         f6
 1: false  e        1         e5       f        1         f6
 2: true   a        5         a1       g        2         g7
 3: true   c        2         c3       g        2         g7
 4: true   d        3         d4       g        2         g7
 5: false  b        4         b2       h        3         h8
 6: false  e        1         e5       h        3         h8
 7: false  b        4         b2       i        4         i9
 8: false  e        1         e5       i        4         i9
 9: true   a        5         a1       j        5         j10
    ...    ...      ...       ...      ...      ...       ...
    <bool> <string> <int>     <string> <string> <int>     <string>

如何在 Gota 中将函数应用于数据框

要将函数应用于数据框的列和行,我们分别使用CapplyRapply。这些接受要应用于列或行的函数。

dataFrame.Capply(function)
dataFrame.Rapply(function)

如何在 Gota 中对数据框使用描述

在数据框对象上使用Describe()会返回有关数据框值的描述性统计信息。

description := dataFrame.Describe()

输出:

column   alphas   numbers  alnums   state
 0: mean     -        3.000000 -        0.600000
 1: median   -        3.000000 -        NaN
 2: stddev   -        1.581139 -        0.547723
 3: min      a        1.000000 a1       0.000000
 4: 25%      -        2.000000 -        0.000000
 5: 50%      -        3.000000 -        1.000000
 6: 75%      -        4.000000 -        1.000000
 7: max      e        5.000000 e5       1.000000
    <string> <string> <float>  <string> <float>

如何导出数据框(在 Go 中编写文件)

WriteCSV我们使用数据框对象的方法导出操作数据。dataFrame.WriteCSV接受它创建或插入的文件名。

file, err := os.Create("output.csv")
	if err != nil {
		log.Fatal(err)
	}

	dataFrame.WriteCSV(file.extension)

要导出 JSON,我们dataFrame.WriteJSON以相同的方式使用。

结论

在本教程中,您学习了如何在 Go 中执行数据分析。您还了解了 Gota 包的各种功能。

主要使用 Python 和 R 进行数据分析仍然是一个好主意,因为它们被认为是行业标准。但是 Gota 对于需要速度和同质性的应用程序很有用。

相关新闻

历经多年发展,已成为国内好评如潮的Linux云计算运维、SRE、Devops、网络安全、容器云、Go、Python开发专业人才培训机构!