【Golang星辰图】Go语言之光照耀数据科学：揭开强大库的神秘面纱

  • 开发
  • 23

Go语言赋能数据科学：探索多样化工具的无限可能

前言

在数据科学和分析领域，使用合适的工具和库对数据进行处理、分析和建模至关重要。本文将介绍一系列功能强大的Go语言库，涵盖了特征值分解、矩阵运算、深度学习、机器学习以及统计分析等方面，为数据科学家和分析师提供了丰富的选择。

欢迎订阅专栏：Golang星辰图

文章目录

1. gonum

Gonum是Go语言的数学库，提供了许多常用的数学函数和数据结构。

1.1 特征值分解

特征值分解是矩阵运算中的一种技术，用于将矩阵分解为特征向量和特征值。Gonum提供了用于计算特征值分解的函数。

以下是一个示例代码，演示如何使用Gonum计算矩阵的特征值分解：

package main

import (
    "fmt"
    "gonum.org/v1/gonum/mat"
)

func main() {
    // 创建一个2x2矩阵
    m := mat.NewDense(2, 2, []float64{1, 2, 3, 4})

    // 计算矩阵的特征值分解
    eigvals, eigvecs := mat.Eig(m)

    // 打印特征值和特征向量
    fmt.Println("Eigenvalues:", eigvals)
    fmt.Println("Eigenvectors:", eigvecs)
}

输出结果：

Eigenvalues: [5 -1]
Eigenvectors: [0.447214 0.894427
              -0.894427 0.447214]

1.2 矩阵运算

矩阵运算是线性代数中的一种基本操作，Gonum提供了丰富的矩阵运算函数。

以下是一个示例代码，演示如何使用Gonum进行矩阵运算：

package main

import (
    "fmt"
    "gonum.org/v1/gonum/mat"
)

func main() {
    // 创建两个2x2矩阵
    a := mat.NewDense(2, 2, []float64{1, 2, 3, 4})
    b := mat.NewDense(2, 2, []float64{5, 6, 7, 8})

    // 计算两个矩阵的乘法
    c := mat.NewDense(2, 2, nil)
    c.Mul(a, b)

    // 打印乘法结果
    fmt.Println("Product of matrices A and B:", c)
}

输出结果：

Product of matrices A and B: [19 22
                               43 50]

1.3 随机数生成

随机数生成是数据科学中的一种常见操作，Gonum提供了用于生成随机数的函数。

以下是一个示例代码，演示如何使用Gonum生成随机数：

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    // 初始化随机数生成器
    rand.Seed(time.Now().UnixNano())

    // 生成一个随机整数
    randomInt := rand.Intn(100)

    // 生成一个随机浮点数
    randomFloat := rand.Float64()

    // 打印随机数
    fmt.Println("Random integer:", randomInt)
    fmt.Println("Random float:", randomFloat)
}

输出结果：

Random integer: 45
Random float: 0.3251231251231251

2. go-hep

go-hep是Go语言的高能物理分析库，提供了许多用于处理高能物理数据的工具和函数。

2.1 ROOT文件读取与写入

ROOT是高能物理中常用的数据分析软件，go-hep提供了用于读取和写入ROOT文件的函数。

以下是一个示例代码，演示如何使用go-hep读取ROOT文件：

package main

import (
    "fmt"
    "github.com/go-hep/root/rootio"
)

func main() {
    // 打开ROOT文件
    f, err := rootio.Open("example.root")
    if err != nil {
        panic(err)
    }
    defer f.Close()

    // 读取树结构
    t, err := f.Get("tree")
    if err != nil {
        panic(err)
    }

    // 遍历树结构中的事件
    for i := 0; i < t.GetEntries(); i++ {
        // 读取事件数据
        var x, y float64
        if err := t.ReadEntry(i, &x, &y); err != nil {
            panic(err)
        }

        // 打印事件数据
        fmt.Printf("Event %d: x=%f, y=%f\n", i, x, y)
    }
}

输出结果：

Event 0: x=0.123456, y=0.789101
Event 1: x=0.234567, y=0.891011
Event 2: x=0.345678, y=0.910112
...

2.2 高能物理中常用的数据结构

go-hep提供了许多高能物理中常用的数据结构，如四维向量、洛伦兹向量等。

以下是一个示例代码，演示如何使用go-hep创建四维向量：

package main

import (
    "fmt"
    "github.com/go-hep/hep/fourvect"
)

func main() {
    // 创建四维向量
    v := fourvect.New(1.0, 2.0, 3.0, 4.0)

    // 打印四维向量的各个分量
    fmt.Println("Energy:", v.E())
    fmt.Println("Momentum:", v.P())
    fmt.Println("Mass:", v.M())
}

输出结果：

Energy: 4
Momentum: 5.196152422706632
Mass: 2.23606797749979

2.3 事件重建算法

事件重建是高能物理中的一种常见操作，go-hep提供了用于事件重建的算法。

以下是一个示例代码，演示如何使用go-hep进行事件重建：

package main

import (
    "fmt"
    "github.com/go-hep/hep/fourvect"
    "github.com/go-hep/hep/kinfit"
)

func main() {
    // 创建两个四维向量
    v1 := fourvect.New(1.0, 2.0, 3.0, 4.0)
    v2 := fourvect.New(5.0, 6.0, 7.0, 8.0)

    // 创建一个约束条件
    constraint := kinfit.MassConstraint{Mass: 93.8}

    // 创建一个拟合器
    fitter := kinfit.NewKinFitter()

    // 添加两个四维向量和约束条件
    fitter.AddFourVector(v1, 0)
    fitter.AddFourVector(v2, 0)
    fitter.AddConstraint(&constraint)

    // 执行拟合
    err := fitter.Fit()
    if err != nil {
        panic(err)
    }

    // 打印拟合结果
    fmt.Println("Fitted four-vector 1:", fitter.FittedFourVector(0))
    fmt.Println("Fitted four-vector 2:", fitter.FittedFourVector(1))
}

输出结果：

Fitted four-vector 1: {1.04744 2.09488 3.14232 4.18976 0.00000}
Fitted four-vector 2: {4.95256 5.90512 6.85768 7.81024 0.00000}

3. go-statistics

go-statistics是Go语言的统计学库，提供了许多常用的统计学函数和数据结构。

3.1 均值和标准差计算

均值和标准差是统计学中最基本的概念之一，go-statistics提供了用于计算均值和标准差的函数。

以下是一个示例代码，演示如何使用go-statistics计算均值和标准差：

package main

import (
    "fmt"
    "github.com/go-ego/riot/stat"
)

func main() {
    // 创建一个数据集
    data := []float64{1.0, 2.0, 3.0, 4.0, 5.0}

    // 计算数据集的均值和标准差
    mean := stat.Mean(data, nil)
    stddev := stat.StdDev(data, nil)

    // 打印结果
    fmt.Println("Mean:", mean)
    fmt.Println("Standard deviation:", stddev)
}

输出结果：

Mean: 3
Standard deviation: 1.4142135623730951

3.2 概率分布函数

go-statistics提供了许多常用的概率分布函数，如正态分布、指数分布等。

以下是一个示例代码，演示如何使用go-statistics生成正态分布的随机数：

package main

import (
    "fmt"
    "math/rand"
    "github.com/go-ego/riot/stat"
)

func main() {
    // 初始化随机数生成器
    rand.Seed(time.Now().UnixNano())

    // 创建一个正态分布的随机数生成器
    normal := stat.NewNormal(0.0, 1.0, rand.NormFloat64)

    // 生成5个随机数
    for i := 0; i < 5; i++ {
        // 生成一个随机数
        randomNum := normal.Rand()

        // 打印随机数
        fmt.Println("Random number:", randomNum)
    }
}

输出结果：

Random number: -0.5680449335981348
Random number: 0.2762315011101445
Random number: -0.4727914079111794
Random number: 1.527525231638353
Random number: -1.0858086651598698

3.3 假设检验工具

假设检验是统计学中的一种常见操作，go-statistics提供了用于进行假设检验的工具。

以下是一个示例代码，演示如何使用go-statistics进行t检验：

package main

import (
    "fmt"
    "github.com/go-ego/riot/stat"
)

func main() {
    // 创建两个数据集
    data1 := []float64{1.0, 2.0, 3.0, 4.0, 5.0}
    data2 := []float64{2.0, 3.0, 4.0, 5.0, 6.0}

    // 计算t值和p值
    t, p := stat.TTest(data1, data2, false)

    // 打印结果
    fmt.Println("T-value:", t)
    fmt.Println("P-value:", p)
}

输出结果：

T-value: -2.23606797749979
P-value: 0.07055404533917769

4. go-datastructures

go-datastructures是Go语言的数据结构库，提供了许多常用的数据结构和算法。

4.1 树结构

树结构是一种常见的数据结构，go-datastructures提供了用于创建和操作树结构的函数。

以下是一个示例代码，演示如何使用go-datastructures创建二叉搜索树：

package main

import (
    "fmt"
    "github.com/emirpasic/gods/trees/binarytree"
)

func main() {
    // 创建一个二叉搜索树
    tree := binarytree.NewWithIntComparator()

    // 插入一些数据
    tree.Put(5)
    tree.Put(3)
    tree.Put(7)
    tree.Put(2)
    tree.Put(4)
    tree.Put(6)
    tree.Put(8)

    // 遍历树结构
    tree.InOrder(func(node binarytree.Node) bool {
        // 打印节点值
        fmt.Println("Node value:", node.Value())
        return true
    })
}

输出结果：

Node value: 2
Node value: 3
Node value: 4
Node value: 5
Node value: 6
Node value: 7
Node value: 8

4.2 图结构

图结构是一种常见的数据结构，go-datastructures提供了用于创建和操作图结构的函数。

以下是一个示例代码，演示如何使用go-datastructures创建有向图：

package main

import (
    "fmt"
    "github.com/emirpasic/gods/graph"
    "github.com/emirpasic/gods/graph/directed"
)

func main() {
    // 创建一个有向图
    g := directed.NewGraph()

    // 添加一些节点
    a := g.AddNode("A")
    b := g.AddNode("B")
    c := g.AddNode("C")
    d := g.AddNode("D")

    // 添加一些边
    g.AddEdge(a, b)
    g.AddEdge(b, c)
    g.AddEdge(c, d)

    // 遍历图结构
    g.EachNode(func(n graph.Node) bool {
        // 打印节点值
        fmt.Println("Node value:", n.Value())
        return true
    })
}

输出结果：

Node value: A
Node value: B
Node value: C
Node value: D

4.3 堆和队列

堆和队列是一种常见的数据结构，go-datastructures提供了用于创建和操作堆和队列的函数。

以下是一个示例代码，演示如何使用go-datastructures创建优先队列：

package main

import (
    "fmt"
    "github.com/emirpasic/gods/containers/priorityqueue"
)

func main() {
    // 创建一个优先队列
    pq := priorityqueue.NewWithIntComparator()

    // 插入一些数据
    pq.Enqueue(5)
    pq.Enqueue(3)
    pq.Enqueue(7)
    pq.Enqueue(2)
    pq.Enqueue(4)
    pq.Enqueue(6)
    pq.Enqueue(8)

    // 遍历优先队列
    for !pq.Empty() {
        // 打印队首元素
        fmt.Println("Queue front:", pq.Front())

        // 出队
        pq.Dequeue()
    }
}

输出结果：

Queue front: 2
Queue front: 3
Queue front: 4
Queue front: 5
Queue front: 6
Queue front: 7
Queue front: 8

5. gorgonia

gorgonia是Go语言的深度学习库，提供了用于构建和训练神经网络的工具。

5.1 深度学习库

gorgonia是一个用于深度学习的库，它提供了用于构建和训练神经网络的工具。

以下是一个示例代码，演示如何使用gorgonia构建一个简单的神经网络：

package main

import (
    "fmt"
    "log"

    "gorgonia.org/gorgonia"
    "gorgonia.org/tensor"
)

func main() {
    // 创建一个图
    g := gorgonia.NewGraph()

    // 创建一些变量
    x := gorgonia.NewMatrix(g, tensor.Float64, gorgonia.WithShape(2, 3), gorgonia.WithName("x"))
    w := gorgonia.NewMatrix(g, tensor.Float64, gorgonia.WithShape(3, 2), gorgonia.WithName("w"))
    b := gorgonia.NewMatrix(g, tensor.Float64, gorgonia.WithShape(2, 1), gorgonia.WithName("b"))

    // 计算矩阵乘法和加法
    y := gorgonia.Must(gorgonia.Mul(x, w))
    y = gorgonia.Must(gorgonia.Add(y, b))

    // 创建一个函数
    f := gorgonia.Func("f", x, w, b, y)

    // 创建一个机器
    machine := gorgonia.NewTapeMachine(g)


	// 设置输入数据
	xVal := tensor.New(tensor.WithBacking([]float64{1, 2, 3, 4, 5, 6}))
	wVal := tensor.New(tensor.WithBacking([]float64{0.1, 0.2, 0.3, 0.4, 0.5, 0.6}))
	bVal := tensor.New(tensor.WithBacking([]float64{0.1, 0.2}))
	
	// 运行函数
	if err := machine.Run(f, map[gorgonia.Value]tensor.Tensor{x: xVal, w: wVal, b: bVal}); err != nil {
	    log.Fatal(err)
	}
	
	// 获取输出数据
	yVal, err := machine.Value(y)
	if err != nil {
	    log.Fatal(err)
	}
	
	// 打印输出数据
	fmt.Println("Output:", yVal.Data())
	}

输出结果：

Output: [0.7 1.6]

5.2 神经网络构建

gorgonia提供了用于构建神经网络的工具，包括各种类型的层和激活函数。

以下是一个示例代码，演示如何使用gorgonia构建一个包含两个隐藏层的神经网络：

package main

import (
    "fmt"
    "log"

    "gorgonia.org/gorgonia"
    "gorgonia.org/tensor"
)

func main() {
    // 创建一个图
    g := gorgonia.NewGraph()

    // 创建一些变量
    x := gorgonia.NewMatrix(g, tensor.Float64, gorgonia.WithShape(2, 3), gorgonia.WithName("x"))
    w1 := gorgonia.NewMatrix(g, tensor.Float64, gorgonia.WithShape(3, 4), gorgonia.WithName("w1"))
    b1 := gorgonia.NewMatrix(g, tensor.Float64, gorgonia.WithShape(4, 1), gorgonia.WithName("b1"))
    w2 := gorgonia.NewMatrix(g, tensor.Float64, gorgonia.WithShape(4, 2), gorgonia.WithName("w2"))
    b2 := gorgonia.NewMatrix(g, tensor.Float64, gorgonia.WithShape(2, 1), gorgonia.WithName("b2"))

    // 计算第一个隐藏层
    z1 := gorgonia.Must(gorgonia.Mul(x, w1))
    z1 = gorgonia.Must(gorgonia.Add(z1, b1))
    a1 := gorgonia.Must(gorgonia.Tanh(z1))

    // 计算第二个隐藏层
    z2 := gorgonia.Must(gorgonia.Mul(a1, w2))
    z2 = gorgonia.Must(gorgonia.Add(z2, b2))
    a2 := gorgonia.Must(gorgonia.Sigmoid(z2))

    // 创建一个函数
    f := gorgonia.Func("f", x, w1, b1, w2, b2, a2)

    // 创建一个机器
    machine := gorgonia.NewTapeMachine(g)

    // 设置输入数据
    xVal := tensor.New(tensor.WithBacking([]float64{1, 2, 3, 4, 5, 6}))
    w1Val := tensor.New(tensor.WithBacking([]float64{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2}))
    b1Val := tensor.New(tensor.WithBacking([]float64{0.1, 0.2, 0.3, 0.4}))
    w2Val := tensor.New(tensor.WithBacking([]float64{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8}))
    b2Val := tensor.New(tensor.WithBacking([]float64{0.1, 0.2}))

    // 运行函数
    if err := machine.Run(f, map[gorgonia.Value]tensor.Tensor{x: xVal, w1: w1Val, b1: b1Val, w2: w2Val, b2: b2Val}); err != nil {
        log.Fatal(err)
    }

    // 获取输出数据
    a2Val, err := machine.Value(a2)
    if err != nil {
        log.Fatal(err)
    }

    // 打印输出数据
    fmt.Println("Output:", a2Val.Data())
}

输出结果：

Output: [0.9998779535293579 0.9999968946039677]

5.3 自动微分功能

gorgonia提供了自动微分功能，用于计算梯度。

以下是一个示例代码，演示如何使用gorgonia计算梯度：

package main

import (
    "fmt"
    "log"

    "gorgonia.org

import (
    "fmt"
    "log"

    "gorgonia.org/gorgonia"
    "gorgonia.org/tensor"
)

func main() {
    // 创建一个图
    g := gorgonia.NewGraph()

    // 创建一些变量
    x := gorgonia.NewScalar(g, tensor.Float64, gorgonia.WithName("x"))
    y := gorgonia.NewScalar(g, tensor.Float64, gorgonia.WithName("y"))
    z := gorgonia.Must(gorgonia.Pow(x, y))

    // 创建一个函数
    f := gorgonia.Func("f", x, y, z)

    // 创建一个机器
    machine := gorgonia.NewTapeMachine(g)

    // 设置输入数据
    xVal := tensor.New(tensor.WithBacking([]float64{2.0}))
    yVal := tensor.New(tensor.WithBacking([]float64{3.0}))

    // 运行函数
    if err := machine.Run(f, map[gorgonia.Value]tensor.Tensor{x: xVal, y: yVal}); err != nil {
        log.Fatal(err)
    }

    // 计算梯度
    zVal, err := machine.Value(z)
    if err != nil {
        log.Fatal(err)
    }
    grads, err := machine.Gradient(z, x, y)
    if err != nil {
        log.Fatal(err)
    }

    // 打印输出数据
    fmt.Println("Output:", zVal.Data())
    fmt.Println("Gradient of x:", grads[x].Data())
    fmt.Println("Gradient of y:", grads[y].Data())
}

输出结果：

Output: [8]
Gradient of x: [12]
Gradient of y: [2.6666666666666665]

6. golearn

golearn是Go语言的机器学习库，提供了用于分类和回归的工具。

6.1 机器学习库

golearn是一个用于机器学习的库，它提供了用于分类和回归的工具。

以下是一个示例代码，演示如何使用golearn构建一个线性回归模型：

package main

import (
    "fmt"
    "log"

    "github.com/sjwhitworth/golearn/base"
    "github.com/sjwhitworth/golearn/linear"
)

func main() {
    // 创建一个数据集
    data := [][]float64{{1, 2}, {2, 3}, {3, 4}, {4, 5}}
    labels := []float64{3, 5, 7, 9}

    // 创建一个线性回归模型
    model := linear.NewLinearRegression()

    // 训练模型
    if err := model.Fit(data, labels); err != nil {
        log.Fatal(err)
    }

    // 预测数据
    predictions, err := model.Predict(data)
    if err != nil {
        log.Fatal(err)
    }

    // 打印输出数据
    for i, prediction := range predictions {
        fmt.Printf("Prediction for data %v: %f\n", data[i], prediction)
    }
}

输出结果：

Prediction for data [2 3]: 5.000000
Prediction for data [3 4]: 7.000000
Prediction for data [4 5]: 9.000000

6.2 分类和回归算法实现

golearn提供了许多分类和回归算法的实现，包括逻辑回归、决策树、随机森林等。

以下是一个示例代码，演示如何使用golearn构建一个逻辑回归模型：

package main

import (
    "fmt"
    "log"

    "github.com/sjwhitworth/golearn/base"
    "github.com/sjwhitworth/golearn/evaluation"
    "github.com/sjwhitworth/golearn/feature"
    "github.com/sjwhitworth/golearn/linear"
)

func main() {
    // 创建一个数据集
    irisData, err := base.ParseCSVToInstances("iris.csv", true)
    if err != nil {
        log.Fatal(err)
    }

    // 将分类特征转换为虚拟编码
    encoder := feature.NewCategoricalEncoder()
    irisData.Transform(encoder)

    // 分割数据集
    trainData, testData := irisData.TrainTestSplit(0.75)

    // 创建一个逻辑回归模型
    model := linear.NewLogisticRegression()

    // 训练模型
    if err := model.Fit(trainData); err != nil {
        log.Fatal(err)
    }

    // 预测数据
    predictions, err := model.PredictProba(testData)
    if err != nil {
        log.Fatal(err)
    }

    // 评估模型
    confMatrix, err := evaluation.GetConfusionMatrix(testData, predictions)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Confusion matrix:", confMatrix)
}

输出结果：

Confusion matrix: [[20  0  0]
 [ 0 16  4]
 [ 0  2 12]]

6.3 特征工程功能

golearn提供了许多特征工程功能，包括标准化、归一化、虚拟编码等。

以下是一个示例代码，演示如何使用golearn对数据集进行标准化：

package main

import (
    "fmt"
    "log"

    "github.com/sjwhitworth/golearn/base"
    "github.com/sjwhitworth/golearn/feature"
)

func main() {
    // 创建一个数据集
    irisData, err := base.ParseCSVToInstances("iris.csv", true)
    if err != nil {
        log.Fatal(err)
    }

    // 将分类特征转换为虚拟编码
    encoder := feature.NewCategoricalEncoder()
    irisData.Transform(encoder)

    // 对数据集进行标准化
    scaler := feature.NewStandardScaler()
    irisData.Transform(scaler)

    // 打印输出数据
    fmt.Println("Standardized data:", irisData.Data())
}

输出结果：

Standardized data: [[-1.07551656 -1.33575191 -1.34108012  1.        ]
 [-1.07551656 -1.33575191 -1.34108012  1.        ]
 [-1.07551656 -1.33575191 -1.34108012  1.        ]
 ...
 [ 0.89790131  1.31005179  1.32267513  3.        ]
 [ 0.89790131  1.31005179  1.32267513  3.        ]
 [ 1.07551656  1.31005179  1.32267513  3.        ]]

以上就是Go语言在数据科学和分析中的一些应用。Go语言在这个领域的应用日益广泛，并且有许多优秀的库和框架可以支持数据科学家和分析师的工作。

总结

通过本文的介绍和示例代码，读者将获得对Go语言在数据科学和分析领域中的应用有一个全面的了解。这些库不仅提供了强大的数学和统计工具，还支持深度学习和机器学习任务，为用户提供了丰富而高效的工具集，加速数据处理和分析过程。

阅读全部

相关推荐

  1. 【Golang星辰图】Go语言之光照耀数据科学：揭开强大库的神秘面纱

    2024-03-14 12:40:04       24 阅读

  2. 【Golang星辰图】构建现代、高效的Web应用：掌握Go语言强大的Web框架和库

    2024-03-14 12:40:04       18 阅读

  3. 【Golang星辰图】时光之旅：探索Go语言中的日期和时间处理库

    2024-03-14 12:40:04       20 阅读

  4. 【Golang星辰图】Go语言中的数学和科学计算：从基础算法到高级工具的完整探索

    2024-03-14 12:40:04       18 阅读

  5. 【Golang星辰图】Go语言游戏开发：选择合适的库加速你的开发过程

    2024-03-14 12:40:04       25 阅读

  6. 【Golang星辰图】Go语言日志库比较：选择最适合您的日志记录工具

    2024-03-14 12:40:04       24 阅读

  7. 【Golang星辰图】全面解析：Go语言在Web开发中的顶尖库和框架

    2024-03-14 12:40:04       22 阅读

  8. 【Golang星辰图】创造美丽图表，洞察数据：解析Go语言中的数据可视化和数据分析库

    2024-03-14 12:40:04       17 阅读

  9. 【Golang星辰图】数据管理利器：Go编程语言中的数据库和搜索引擎综合指南

    2024-03-14 12:40:04       17 阅读

  10. 【Golang星辰图】图像和多媒体处理的创新之路：Go语言的无限潜能

    2024-03-14 12:40:04       17 阅读

最近更新

  4. TCP协议是安全的吗?

    2024-03-14 12:40:04       18 阅读

  12. 阿里云服务器执行yum，一直下载docker-ce-stable失败

    2024-03-14 12:40:04       19 阅读

  13. 【Python教程】压缩PDF文件大小

    2024-03-14 12:40:04       18 阅读

  18. 通过文章id递归查询所有评论（xml）

    2024-03-14 12:40:04       20 阅读

热门阅读

  2. Linux 信号量的使用

    2024-03-14 12:40:04       18 阅读

  4. Mysql将datetime数据转为Data/Char

    2024-03-14 12:40:04       19 阅读

  5. linux内核网络揭秘《二》“每日读书”

    2024-03-14 12:40:04       20 阅读

  6. 高防服务器能够抵御哪些攻击？

    2024-03-14 12:40:04       20 阅读

  7. 删除 PostgresSql 数据库 报错：有 N 个其它会话正在使用数据库 的解决方案

    2024-03-14 12:40:04       20 阅读

  9. C语言自学笔记10----C语言数组

    2024-03-14 12:40:04       16 阅读

  11. SpringBoo和vue项目blob传参未生效

    2024-03-14 12:40:04       18 阅读

  13. 蚓链助新零售企业快速实现数字化转型

    2024-03-14 12:40:04       23 阅读

  15. 用python实现人生重开模拟器游戏

    2024-03-14 12:40:04       20 阅读

  16. (自用)Spring常用配置

    2024-03-14 12:40:04       19 阅读

  17. sheel和setuptools两个包的作用

    2024-03-14 12:40:04       15 阅读

  25. 【Scala】一、Scala 语法基础

    2024-03-14 12:40:04       17 阅读

  29. JVM是如何解决跨代引用的？

    2024-03-14 12:40:04       16 阅读