---

Julia 编程 - 使用数据集

在本章中，我们将详细讨论数据集。

CSV 文件

众所周知，CSV（逗号分隔值）文件是一种纯文本文件，它使用逗号分隔字段和这些字段的值。 这些文件的扩展名是.CSV。 Julia 编程语言提供了各种方法来对 CSV 文件执行操作。

在 Julia 中导入 .CSV 文件

要导入.CSV文件，我们需要安装CSV包。 使用以下命令来执行此操作 −

using pkg
pkg.add("CSV")

读取数据

要从 Julia 中的 CSV 文件读取数据，我们需要使用 CSV 包中的 read() 方法，如下所示 −

julia> using CSV
julia> CSV.read("C://Users//Leekha//Desktop//Iris.csv")
150×6 DataFrame
│ Row │  Id   │ SepalLengthCm │ SepalWidthCm │ PetalLengthCm │ PetalWidthCm │ Species        │
│     │ Int64 │      Float64  │     Float64  │     Float64   │    Float64   │ String         │
├─────┼───────┼───────────────┼──────────────┼───────────────┼──────────────┼─────────-------┤
│  1  │   1   │      5.1      │     3.5      │     1.4       │    0.2       │ Iris-setosa    │
│  2  │   2   │      4.9      │     3.0      │     1.4       │    0.2       │ Iris-setosa    │
│  3  │   3   │      4.7      │     3.2      │     1.3       │    0.2       │ Iris-setosa    │
│  4  │   4   │      4.6      │     3.1      │     1.5       │    0.2       │ Iris-setosa    │
│  5  │   5   │      5.0      │     3.6      │     1.4       │    0.2       │ Iris-setosa    │
│  6  │   6   │      5.4      │     3.9      │     1.7       │    0.4       │ Iris-setosa    │
│  7  │   7   │      4.6      │     3.4      │     1.4       │    0.3       │ Iris-setosa    │
│  8  │   8   │      5.0      │     3.4      │     1.5       │    0.2       │ Iris-setosa    │
│  9  │   9   │      4.4      │     2.9      │     1.4       │    0.2       │ Iris-setosa    │
│  10 │   10  │      4.9      │     3.1      │     1.5       │    0.1       │ Iris-setosa    │
⋮
│ 140 │ 140   │      6.9      │     3.1      │     5.4       │    2.1       │ Iris-virginica │
│ 141 │ 141   │      6.7      │     3.1      │     5.6       │    2.4       │ Iris-virginica │
│ 142 │ 142   │      6.9      │     3.1      │     5.1       │    2.3       │ Iris-virginica │
│ 143 │ 143   │      5.8      │     2.7      │     5.1       │    1.9       │ Iris-virginica │
│ 144 │ 144   │      6.8      │     3.2      │     5.9       │    2.3       │ Iris-virginica │
│ 145 │ 145   │      6.7      │     3.3      │     5.7       │    2.5       │ Iris-virginica │
│ 146 │ 146   │      6.7      │     3.0      │     5.2       │    2.3       │ Iris-virginica │
│ 147 │ 147   │      6.3      │     2.5      │     5.0       │    1.9       │ Iris-virginica │
│ 148 │ 148   │      6.5      │     3.0      │     5.2       │    2.0       │ Iris-virginica │
│ 149 │ 149   │      6.2      │     3.4      │     5.4       │    2.3       │ Iris-virginica │
│ 150 │ 150   │      5.9      │     3.0      │     5.1       │    1.8       │ Iris-virginica │

创建新的 CSV 文件

要创建新的 CSV 文件，我们需要使用 CSV 包中的 touch() 命令。 我们还需要使用 DataFrames 包将新创建的内容写入新的 CSV 文件 −

julia> using DataFrames
julia> using CSV
julia> touch("1234.csv")
"1234.csv"

julia> new = open("1234.csv", "w")
IOStream(<file 1234.csv>)

julia> new_data = DataFrame(Name = ["Gaurav", "Rahul", "Aarav", "Raman", "Ravinder"],
                  RollNo = [1, 2, 3, 4, 5],
                  Marks = [54, 67, 90, 23, 95])
                  
5×3 DataFrame
│ Row │  Name    │ RollNo │ Marks │
│     │  String  │ Int64  │ Int64 │
├─────┼──────────┼────────┼───────┤
│ 1   │  Gaurav  │   1    │   54  │
│ 2   │  Rahul   │   2    │   67  │
│ 3   │   Aarav  │   3    │   90  │
│ 4   │   Raman  │   4    │   23  │
│ 5   │ Ravinder │   5    │   95  │

julia> CSV.write("1234.csv", new_data)
"1234.csv"

julia> CSV.read("1234.csv")
5×3 DataFrame
│ Row │    Name  │ RollNo │ Marks │
│     │  String  │ Int64  │ Int64 │
├─────┼──────────┼────────┼───────┤
│   1 │   Gaurav │   1    │   54  │
│   2 │   Rahul  │   2    │   67  │
│   3 │   Aarav  │   3    │   90  │
│   4 │   Raman  │   4    │   23  │
│   5 │ Ravinder │   5    │   95  │

HDF5

HDF5 的完整形式是分层数据格式 v5。 以下是它的一些属性 −

• "组"类似于目录，"数据集"类似于文件。

• 要将元数据与特定组关联起来，它使用属性。

• 它对不同的对象使用 ASCII 名称。

• 语言包装器通常被称为"低级"或"高级"。

打开 HDF5 文件

HDF5文件可以使用h5open命令打开，如下 −

fid = h5open(filename, mode)

下表描述了该模式 −

Sl.No	模式及含义
1	"r" read-only
2	"r+" read-write − 它将保留任何现有内容。
3	"cw" read-write − 如果文件不存在，它将创建文件。 它还将保留现有内容。
4	"w" read-write − 它将破坏任何现有内容。

上述命令将生成一个HDF5File类型的对象和抽象类型DataFile的子类型。

关闭 HDF5 文件

完成文件后，我们应该按如下方式关闭它 −

close(fid)

它还将关闭文件中的所有对象。

打开 HDF5 对象

假设我们有一个名为fid的文件对象，并且它有一个名为object1的组，则可以如下打开它 −

Obj1 = fid[“object1”]

关闭 HDF5 对象

close(obj1)

读取数据

组"g"包含路径为"dtset"的数据集，我们已将数据集打开为dset1 = g[dtset]。 我们可以通过以下方式读取信息 −

ABC = read(dset1)
ABC = read(g, "dtset")
Asub = dset1[2:3, 1:3]

写入数据

我们可以按如下方式创建数据集 −

g["dset1"] = rand(3,5)
write(g, "dset1", rand(3,5))

XML 文件

这里我们将讨论 LightXML.jl 包，它是 libxml2 的轻量级 Julia 包装器。 它提供以下功能 −

• 解析 XML 文件

• 访问 XML 树结构

• 创建 XML 树

• 将 XML 树导出为字符串

示例

假设我们有一个名为new.xml的xml文件，如下 −

<Hello>
      <to>Gaurav</to>
      <from>Rahul</from>
      <heading>Reminder to meet</heading>
      <body>Friend, Don't forget to meet this weekend!</body>
</Hello>

现在，我们可以使用 LightXML 解析该文件，如下所示 −

julia> using LightXML
#below code will parse this xml file
julia> xdoc = parse_file("C://Users//Leekha//Desktop//new.xml")
<?xml version="1.0" encoding="utf-8"?>
<Hello>
<to>Gaurav</to>
<from>Rahul</from>
<heading>Reminder to meet</heading>
<body>Friend, Don't forget to meet this weekend!</body>
</Hello>

下面的例子解释了如何获取根元素 −

julia> xroot = root(xdoc);
julia> println(name(xroot))
Hello
#Traversing all the child nodes and also print element names
julia> for c in child_nodes(xroot) # c is an instance of XMLNode
            println(nodetype(c))
            if is_elementnode(c)
               e = XMLElement(c) # this makes an XMLElement instance
               println(name(e))
            end
         end
3
1
to
3
1
from
3
1
heading
3
1
body
3

RDatasets

Julia 的 b1 包提供了简单的方法来使用和试验 R 核心中提供的大多数标准数据集。要加载并使用 RDatasets 包中包含的数据集之一，我们需要按如下方式安装 RDatasets −

julia> using Pkg
julia> Pkg.add("RDatasets")

对数据进行子集化

例如，我们将使用mlmRev组中的Gcsemv数据集，如下所示 −

julia> GetData = dataset("mlmRev","Gcsemv");
julia> summary(GetData);
julia> head(GetData)
6×5 DataFrame
│ Row │     School   │     Student  │     Gender   │  Written │   Course │
│     │ Categorical… │ Categorical… │ Categorical… │ Float64⍰ │ Float64⍰ │
├─────┼──────────────┼──────────────┼──────────────┼──────────┼──────────┤
│   1 │     20920    │      16      │      M       │  23.0    │  missing │
│   2 │     20920    │      25      │      F       │  missing │   71.2   │
│   3 │     20920    │      27      │      F       │  39.0    │   76.8   │
│   4 │     20920    │      31      │      F       │  36.0    │   87.9   │
│   5 │     20920    │      42      │      M       │  16.0    │   44.4   │
│   6 │     20920    │      62      │      F       │  36.0    │  missing │

我们可以选择特定学校的数据，如下所示 −

julia> GetData[GetData[:School] .== "68137", :]
104×5 DataFrame
│ Row │     School   │     Student  │     Gender   │  Written │   Course │
│     │ Categorical… │ Categorical… │ Categorical… │ Float64⍰ │ Float64⍰ │
├─────┼──────────────┼──────────────┼──────────────┼──────────┼──────────┤
│  1  │     68137    │      1       │     F        │   18.0   │   56.4   │
│  2  │     68137    │      2       │     F        │   23.0   │   55.5   │
│  3  │     68137    │      3       │     F        │   25.0   │  missing │
│  4  │     68137    │      4       │     F        │   29.0   │   73.1   │
│  5  │     68137    │      5       │     F        │  missing │   66.6   │
│  6  │     68137    │      9       │     F        │   20.0   │   60.1   │
│  7  │     68137    │     11       │     F        │   34.0   │   63.8   │
│  8  │     68137    │     12       │     F        │   60.0   │   89.8   │
│  9  │     68137    │     13       │     F        │   44.0   │   76.8   │
│  10 │     68137    │     14       │     F        │   20.0   │   58.3   │
⋮
│ 94  │     68137    │     252      │     M        │  missing │   75.9   │
│ 95  │     68137    │     254      │     M        │     35.0 │ missing  │
│ 96  │     68137    │     255      │     M        │     36.0 │   62.0   │
│ 97  │     68137    │     258      │     M        │     23.0 │   61.1   │
│ 98  │     68137    │     260      │     M        │     25.0 │ missing  │
│ 99  │     68137    │     261      │     M        │     46.0 │    89.8  │
│ 100 │     68137    │     264      │     M        │     50.0 │    70.3  │
│ 101 │     68137    │     268      │     M        │     15.0 │    43.5  │
│ 102 │     68137    │     270      │     M        │  missing │    73.1  │
│ 103 │     68137    │     272      │     M        │     43.0 │    78.7  │
│ 104 │     68137    │     273      │     M        │     35.0 │    60.1  │

对数据进行排序

借助sort!()函数，我们可以对数据进行排序。 例如，这里我们将按照考试成绩升序对数据集进行排序 −

julia> sort!(GetData, cols=[:Written])
1905×5 DataFrame
│ Row  │       School │      Student │       Gender │  Written │   Course │
│      │ Categorical… │ Categorical… │ Categorical… │ Float64⍰ │ Float64⍰ │
├──────┼──────────────┼──────────────┼──────────────┼──────────┼──────────┤
│  1   │    22710     │       77     │     F        │    0.6   │   41.6   │
│  2   │    68137     │       65     │     F        │    2.5   │   50.0   │
│  3   │    22520     │       115    │     M        │    3.1   │   9.25   │
│  4   │    68137     │       80     │     F        │    4.3   │   50.9   │
│  5   │    68137     │       79     │     F        │    7.5   │   27.7   │
│  6   │    22710     │       57     │     F        │    11.0  │   73.1   │
│  7   │    64327     │       19     │     F        │    11.0  │   87.0   │
│  8   │    68137     │       85     │     F        │    11.0  │   27.7   │
│  9   │    68137     │       97     │     F        │    11.0  │   57.4   │
│ 10   │    68137     │       100    │     F        │    11.0  │   61.1   │
⋮
│ 1895 │    74874     │       83     │     F        │ missing  │    81.4  │
│ 1896 │    74874     │       86     │     F        │ missing  │    92.5  │
│ 1897 │    76631     │       79     │     F        │ missing  │    84.2  │
│ 1898 │    76631     │       193    │     M        │ missing  │    72.2  │
│ 1899 │    76631     │       221    │     F        │ missing  │    76.8  │
│ 1900 │    77207     │       5001   │     F        │ missing  │    82.4  │
│ 1901 │    77207     │       5062   │     M        │ missing  │    75.0  │
│ 1902 │    77207     │       5063   │     F        │ missing  │    79.6  │
│ 1903 │    84772     │       17     │     M        │ missing  │    88.8  │
│ 1904 │    84772     │       49     │     M        │ missing  │    74.0  │
│ 1905 │    84772     │       85     │     F        │ missing  │    90.7  │

Julia 的统计数据

为了进行统计，Julia 有 StatsBase.jl 包，提供了进行简单统计的简单方法。 要进行统计，我们需要安装 StatsBase 包，如下所示 −

julia> using Pkg
julia> Pkg.add("StatsBase")

简单统计

Julia 提供了定义权重和计算平均值的方法。

我们可以使用weights()函数来定义权重向量，如下所示 −

julia> WV = Weights([10.,11.,12.])
3-element Weights{Float64,Float64,Array{Float64,1}}:
 10.0
 11.0
 12.0

可以使用 isempty() 函数检查权重向量是否为空 −

julia> isempty(WV)
false

我们可以借助 eltype() 函数检查权重向量的类型，如下所示 −

julia> eltype(WV)
Float64

我们可以借助 length() 函数检查权重向量的长度，如下所示 −

julia> length(WV)
3

有不同的方法计算平均值−

• 调和平均值 − 我们可以使用harmmean()函数来计算调和平均值。

julia> A = [3, 5, 6, 7, 8, 2, 9, 10]
8-element Array{Int64,1}:
 3
 5
 6
 7
 8
 2
 9
 10
julia> harmmean(A)
4.764831009217679

• 几何平均值 − 我们可以使用geomean()函数来计算几何平均值。

julia> geomean(A)
5.555368605381863

• 一般平均值 − 我们可以使用mean()函数来计算一般平均值。

julia> mean(A)
6.25

描述性统计

这是提取和分析信息的统计学学科。 这些信息解释了数据的本质。

计算方差

我们可以使用var()函数来计算向量的方差，如下所示 −

julia> B = [1., 2., 3., 4., 5.];
julia> var(B)
2.5

计算加权方差

我们可以计算向量 x w.r.t 到权重向量的加权方差，如下所示 −

julia> B = [1., 2., 3., 4., 5.];
julia> a = aweights([4., 2., 1., 3., 1.])
5-element AnalyticWeights{Float64,Float64,Array{Float64,1}}:
 4.0
 2.0
 1.0
 3.0
 1.0
julia> var(B, a)
2.066115702479339

计算标准差

我们可以使用std()函数来计算向量的标准方差，如下所示 −

julia> std(B)
1.5811388300841898

计算加权标准差

我们可以计算向量 x w.r.t 到权重向量的加权标准差，如下所示 −

julia> std(B,a)
1.4373989364401725

计算平均值和标准差

我们可以在单个命令中计算平均值和标准差，如下所示 −

julia> mean_and_std(B,a)
(2.5454545454545454, 1.4373989364401725)

计算均值和方差

我们可以在单个命令中计算均值和方差，如下所示 −

julia> mean_and_var(B,a)
(2.5454545454545454, 2.066115702479339)

样本和估计

它可以被定义为统计学学科，为了进行分析，将从大量总体集中选择样本单位。

以下是我们可以进行采样的方法 −

随机抽样是最简单的抽样方法。 在此，我们从数组中抽取一个随机元素，即随机样本集。 用于此目的的函数是sample()。

示例

julia> A = [8.,12.,23.,54.5]
4-element Array{Float64,1}:
 8.0
 12.0
 23.0
 54.5
julia> sample(A)
12.0

接下来，我们可以取"n"个元素作为随机样本。

示例

julia> A = [8.,12.,23.,54.5]
4-element Array{Float64,1}:
 8.0
 12.0
 23.0
 54.5
julia> sample(A, 2)
2-element Array{Float64,1}:
 23.0
 54.5

我们还可以将采样的元素写入长度为"n"的预分配元素。 执行此任务的函数是sample!()。

示例

julia> B = [1., 2., 3., 4., 5.];
julia> X = [2., 1., 3., 2., 5.];
julia> sample!(B,X)
5-element Array{Float64,1}:
 2.0
 2.0
 4.0
 1.0
 3.0

另一种方法是直接采样，它会从总体集中随机选取数字并将它们存储在另一个数组中。 执行此任务的函数是direct_sample!()。

示例

julia> StatsBase.direct_sample!(B, X)
5-element Array{Float64,1}:
 1.0
 4.0
 4.0
 4.0
 5.0

Knuth 算法是另一种无需放回进行随机采样的方法。

示例

julia> StatsBase.knuths_sample!(B, X)
5-element Array{Float64,1}:
 5.0
 3.0
 4.0
 2.0
 1.0

---