Golang单元测试快速上手(一) 基础

最新推荐文章于 2024-09-19 17:04:07 发布
最新推荐文章于 2024-09-19 17:04:07 发布
阅读量961 收藏 1
点赞数
分类专栏： Golang 测试 TDD测试驱动开发 文章标签： 单元测试 go golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lin_strong/article/details/109012560
版权

注：本文由linstring原创，博客地址：https://blog.csdn.net/lin_strong

转载请注明出处

第二部分链接：https://blog.csdn.net/lin_strong/article/details/109014085
第三部分链接：https://blog.csdn.net/lin_strong/article/details/109014623

文章目录

前言

本系列文章分为三部分。
目标是带领一个有Golang基础的人快速入门Golang中的单元测试，明白基础概念，一些常用的技术、技巧和框架，写出合格的单测并能够hold住大部分的场景。

文章并不会涵盖所有的细节，而只写那些重要的，必知必会的知识。如想进一步深入请自行查阅相关资料。

什么是单元测试(Unit Test)

单元测试：指对软件中的最小可测试单元进行检查和验证。

单元：根据实际情况判定具体含义，如C语言中指一个函数，Java里指一个方法，图形化的软件中可以指一个窗口或一个菜单等。总的来说，单元就是人为规定的最小的被测功能模块。

每个测试都应该是独立的小实验，不应该依赖于测试顺序。

每个测试应该要短小且聚焦。可以想做是一个小实验，这个实验通过时是静默的，失败时则制造噪音。

四步测试模式

一个单元测试分为以下几步：
Four-Phase Test Pattern(Gerard Meszaros’ book, xUnit Testing Patterns)：

  1. Setup：建立测试的预环境(precondition)
  2. Exercise：做一些事情
  3. Verify：检查输出是否如期望的
  4. Cleanup：在测试后把系统还原为最初状态

FIRST原则

FIRST(from Book :Agile in a Flash)让测试更加高效。

  • F快速：测试是极其快的，快到开发者每次一进行小的更改就运行测试也不会打断工作。
  • I独立：测试是独立的。测试间不存在相互配置，测试的失败也是独立的。
  • R可重复：测试是可重复的；可重复就是自动化。循环执行测试会得到相同的结果。
  • S自验证：测试验证自己的输出，当通过时简单的说句“OK”，失败时精确地提供细节。
  • T适时的：测试是适时的。程序员适时地写它，即刚好在写产品代码前写，这避免了bug。

想了解更多单测知识的话请阅读专门的书籍。
以上是我从《Test-Driven Development for Embedded C》里学来的，很好的一本书，推荐阅读。
这是读书笔记：https://blog.csdn.net/lin_strong/article/details/84853138

Go中的测试约定

Go提供一个由 go test 命令和 testing package组成的轻量测试框架。约定：

  • XXXX_test.go形式的文件被认为是测试文件
  • 测试文件会被常规构建忽略，而不会被测试构建(使用go test命令)忽略
    • 实验发现：测试文件中的函数只对同个package内的测试文件可见
  • 一般把测试文件与被测试的文件放在一个package下，AAA.go的对应测试文件命名为AAA_test.go
    • 这也意味着测试文件能访问被测文件的unexport对象
  • 测试文件中所有形如以下的函数都会被认为是一个测试例程并在测试中被执行：
func TestXxx(*testing.T)
  • 注意：
    • Xxx第一字母大写
    • Xxx最好是要测试的方法名
    • A结构体的B方法的测试命名：TestA_B

示例仓库

https://download.csdn.net/download/lin_strong/12918620

一个简单的测试

假设我们有以下函数
add.go

package simpletest

func AddIfBPositive(a, b int) int {
   return a + b
}

add_test.go

package simpletest

import "testing"

func TestAddIfBPositive(t *testing.T) {
   // exercise
   got := AddIfBPositive(4, -1)
   // verify
   if got != 4 {
      t.Errorf("AddIfBPositive() = %v, want %v", got, 4)
   }
}

在目录(/package)下运行测试：

$ go test
--- FAIL: TestAddIfBPositive (0.00s)
    add_test.go:8: AddIfBPositive() = 3, want 4
FAIL
exit status 1
FAIL    go_test_demo/simpletest 0.881s

可以看到测试FAIL了，同时打印出了对应的错误信息。

将实现改对后再次运行测试：

package simpletest

func AddIfBPositive(a, b int) int {
   if b > 0 {
      return a + b
   }
   return a
}

$ go test
PASS
ok      go_test_demo/simpletest 0.227s

go test

go test工具用于执行Go测试

go test [build/test flags] [packages] [build/test flags & test binary flags]

For details

两个模式

local directory mode

  • 当不指定packages时，默认编译运行当前package的测试，最后列出package的测试总结行。
  • 这种模式下不会使用cache的测试结果
$ go test
PASS
ok      go_test_demo/simpletest 0.227s

package list mode

  • e.g.： ‘go test go_test_demo/simpletest’、 ‘go test ./…’ 和 ‘go test .’
  • 指定了packages时，编译并测试每一个列出的packages。
  • 通过时只会显示package的总结行，失败时会打印package的所有测试输出。（除非使用了-v或-bench选项）
  • 这种模式下，会使用cache的成功测试结果（会标识是cache结果），以避免没必要的测试

直接指定文件

还可以直接指定文件的方式来运行测试，但这种方式要把相关的文件都带上，不推荐

$ go test add_test.go add.go
ok      command-line-arguments  0.438s

常用命令/选项

  • 运行当前package的测试
go test
  • 运行当前路径及所有子路径下packages的测试：
go test ./...
  • 详细打印信息
$ go test -v
=== RUN   TestAddIfBPositive
--- PASS: TestAddIfBPositive (0.00s)
PASS
ok      go_test_demo/simpletest        0.171s
  • 更丰富的打印
go get -u github.com/rakyll/gotest

然后使用gotest替代所有的go test，输出的颜色上会更丰富些

  • 查看测试的覆盖率

-cover 选项

$ go test -cover
PASS
coverage: 66.7% of statements
ok      go_test_demo/simpletest        0.383s

升级版：结合go tool工具

go test ./... -coverprofile=cover.out && go tool cover -html=cover.out && rm cover.out

  • 运行选定测试(e.g. (一级)名字中包含Positive的测试)
$ go test -run=Positive
PASS
ok      go_test_demo/simpletest        0.605s

扩展阅读：The cover story

For other flags：https://golang.org/cmd/go/#hdr-Testing_flags

子测试

如为AddIfBPositive添加其他测试，可以写成：

package simpletest

import "testing"

func TestAddIfBPositiveWhenNegative(t *testing.T) {
   got := AddIfBPositive(4, -1)
   if got != 4 {
      t.Errorf("AddIfBPositive() = %v, want %v", got, 4)
   }
}

func TestAddIfBPositiveWhenZero(t *testing.T) {
   got := AddIfBPositive(-1, 0)
   if got != -1 {
      t.Errorf("AddIfBPositive() = %v, want %v", got, -1)
   }
}

func TestAddIfBPositiveWhenPositive(t *testing.T) {
   got := AddIfBPositive(0, 1)
   if got != 1 {
      t.Errorf("AddIfBPositive() = %v, want %v", got, 1)
   }
}

然后测试起来就成这样：

$ go test -v
=== RUN   TestAddIfBPositiveWhenNegative
--- PASS: TestAddIfBPositiveWhenNegative (0.00s)
=== RUN   TestAddIfBPositiveWhenZero
--- PASS: TestAddIfBPositiveWhenZero (0.00s)
=== RUN   TestAddIfBPositiveWhenPositive
--- PASS: TestAddIfBPositiveWhenPositive (0.00s)
PASS
ok      go_test_demo/simpletest        0.167s

使用Run方法创建子测试

但更好的方法可能是将其组织成子测试。
通过testing.T的Run方法，我们可以为当前测试创建子测试：

package subtest

import "testing"

func TestAddIfBPositive(t *testing.T) {
   t.Run("WhenNegative", func(t *testing.T) {
      got := AddIfBPositive(4, -1)
      if got != 4 {
         t.Errorf("AddIfBPositive() = %v, want %v", got, 4)
      }
   })
   t.Run("WhenZero", func(t *testing.T) {
      got := AddIfBPositive(-1, 0)
      if got != -1 {
         t.Errorf("AddIfBPositive() = %v, want %v", got, -1)
      }
   })
   t.Run("WhenPositive", func(t *testing.T) {
      got := AddIfBPositive(0, 1)
      if got != 1 {
         t.Errorf("AddIfBPositive() = %v, want %v", got, 1)
      }
   })
}

这样就获得了更好的可读性：

$ go test -v
=== RUN   TestAddIfBPositive
=== RUN   TestAddIfBPositive/WhenNegative
=== RUN   TestAddIfBPositive/WhenZero
=== RUN   TestAddIfBPositive/WhenPositive
--- PASS: TestAddIfBPositive (0.00s)
    --- PASS: TestAddIfBPositive/WhenNegative (0.00s)
    --- PASS: TestAddIfBPositive/WhenZero (0.00s)
    --- PASS: TestAddIfBPositive/WhenPositive (0.00s)
PASS
ok      go_test_demo/subtest  1.072s

同时，这也为给多个子测试共同进行Setup和Cleanup提供了方法：

func TestFoo(t *testing.T) {
    // setup code
    t.Run("A", func(t *testing.T) { ... })
    t.Run("B", func(t *testing.T) { ... })
    t.Run("C", func(t *testing.T) { ... })
    // cleanup code
}

分层组织的测试

  • 子测试可以不断嵌套，每嵌套一次多一层
  • 同一个package下测试函数都是从属于package的子测试
  • 测试间按照类似 文件路径/树 的方式组织。
  • 任一子测试的失败导致父测试也失败
package subtest

import "testing"

func TestAddIfBPositive(t *testing.T) {
   t.Run("WhenNegative", func(t *testing.T) {
      got := AddIfBPositive(4, -1)
      if got != 4 {
         t.Errorf("AddIfBPositive() = %v, want %v", got, 4)
      }
   })
   t.Run("WhenZero", func(t *testing.T) {
      got := AddIfBPositive(-1, 0)
      if got != -1 {
         t.Errorf("AddIfBPositive() = %v, want %v", got, -1)
      }
      t.Run("FailOnPurpose", func(t *testing.T) {
         t.Fail()
      })
   })
   t.Run("WhenPositive", func(t *testing.T) {
      got := AddIfBPositive(0, 1)
      if got != 1 {
         t.Errorf("AddIfBPositive() = %v, want %v", got, 1)
      }
   })
}

$ go test -v
=== RUN   TestAddIfBPositive
=== RUN   TestAddIfBPositive/WhenNegative
=== RUN   TestAddIfBPositive/WhenZero
=== RUN   TestAddIfBPositive/WhenZero/FailOnPurpose
=== RUN   TestAddIfBPositive/WhenPositive
--- FAIL: TestAddIfBPositive (0.00s)
    --- PASS: TestAddIfBPositive/WhenNegative (0.00s)
    --- FAIL: TestAddIfBPositive/WhenZero (0.00s)
        --- FAIL: TestAddIfBPositive/WhenZero/FailOnPurpose (0.00s)
    --- PASS: TestAddIfBPositive/WhenPositive (0.00s)
FAIL
exit status 1
FAIL    go_test_demo/subtest  0.519s
  • 每个测试都有唯一的名字，从顶层的名字往下直到自己的名字，每层名字用“/”连接到一起。可能最后会还会加一个序号来进行区分。

选择特定测试

go test工具的run参数用于指定要运行的测试

使用分层的正则表达式匹配，用“/”分隔层级

比如：

  • 运行一级名包含Add的测试
$ go test -v -run=Add
=== RUN   TestAddIfBPositive
=== RUN   TestAddIfBPositive/WhenNegative
=== RUN   TestAddIfBPositive/WhenZero
=== RUN   TestAddIfBPositive/WhenZero/FailOnPurpose
=== RUN   TestAddIfBPositive/WhenPositive
--- FAIL: TestAddIfBPositive (0.00s)
    --- PASS: TestAddIfBPositive/WhenNegative (0.00s)
    --- FAIL: TestAddIfBPositive/WhenZero (0.00s)
        --- FAIL: TestAddIfBPositive/WhenZero/FailOnPurpose (0.00s)
    --- PASS: TestAddIfBPositive/WhenPositive (0.00s)
FAIL
exit status 1
FAIL    go_test_demo/subtest  0.512s
  • 运行一级名包含AddIfB且二级包含tive的测试
$ go test -v -run=AddIfB/tive
=== RUN   TestAddIfBPositive
=== RUN   TestAddIfBPositive/WhenNegative
=== RUN   TestAddIfBPositive/WhenPositive
--- PASS: TestAddIfBPositive (0.00s)
    --- PASS: TestAddIfBPositive/WhenNegative (0.00s)
    --- PASS: TestAddIfBPositive/WhenPositive (0.00s)
PASS
ok      go_test_demo/subtest  1.065s

可以看到WhenZero子测试被过滤掉了

  • 运行二级名包含tive的测试(注意，不包含二级测试的测试也会被匹配到)
$ go test -v -run=/tive
  • 运行二级名以When开头然后跟着N或Z的测试
$ go test -run=/"^When[N|Z]" -v
=== RUN   TestAddIfBPositive
=== RUN   TestAddIfBPositive/WhenNegative
=== RUN   TestAddIfBPositive/WhenZero
=== RUN   TestAddIfBPositive/WhenZero/FailOnPurpose
--- FAIL: TestAddIfBPositive (0.00s)
    --- PASS: TestAddIfBPositive/WhenNegative (0.00s)
    --- FAIL: TestAddIfBPositive/WhenZero (0.00s)
        --- FAIL: TestAddIfBPositive/WhenZero/FailOnPurpose (0.00s)
FAIL
exit status 1
FAIL    go_test_demo/subtest  0.321s

指定特定测试可以在编写/调试某个测试时节省大量时间

表驱动的测试

很多时候测试用例有大量冗余，只是几个入参和出参发生变化。这时候很适合使用表驱动。

如上面的例子用表驱动写成：

package tabledriventest

import "testing"

func TestAddIfBPositive(t *testing.T) {
   type args struct {
      a int
      b int
   }
   tests := []struct {
      name string
      args args
      want int
   }{
      {"WhenNegative", args{a: 4, b: -1}, 4},
      {"WhenZero", args{a: -1, b: 0}, -1},
      {"WhenPositive", args{a: 0, b: 1}, 1},
   }
   for _, tt := range tests {
      t.Run(tt.name, func(t *testing.T) {
         if got := AddIfBPositive(tt.args.a, tt.args.b); got != tt.want {
            t.Errorf("AddIfBPositive() = %v, want %v", got, tt.want)
         }
      })
   }
}

这样，就可以轻松地添加更多咱们认为必要的测试用例了。
输出和前面没加FailOnPurpose时一致。

官方库给了很多很棒的表驱动测试的例子：
https://golang.org/src/fmt/fmt_test.go

每个测试都是个goroutine

  • Run会为子测试创建一个goroutine来实际运行，这样就可以通过goroutine退出，或者goroutine间相互阻塞来方便地控制整个流程。
  • Run默认会阻塞到子测试运行完毕，所以效果上好像是直接调用了函数

并行测试

  • 子测试可以通过在进入测试时立即调用Parallel来和同个父测试下其他其他也调用了这个方法的子测试并行运行。就像这样
……
for _, tt := range tests {
   t.Run(tt.name, func(t *testing.T) {
      t.Parallel()
      if got := AddIfBPositive(tt.args.a, tt.args.b); got != tt.want {
         t.Errorf("AddIfBPositive() = %v, want %v", got, tt.want)
      }
   })
}
  • 调用Parallel后子测试暂时交还控制权，父测试得以先执行其他测试
  • 父测试在做完其他非并行子测试后，退出前，会取消所有并行子测试的阻塞，并在所有并行子测试完成后才退出。
$ go test -v
=== RUN   TestAddIfBPositive
=== RUN   TestAddIfBPositive/WhenNegative
=== PAUSE TestAddIfBPositive/WhenNegative
=== RUN   TestAddIfBPositive/WhenZero
=== PAUSE TestAddIfBPositive/WhenZero
=== RUN   TestAddIfBPositive/WhenPositive
=== PAUSE TestAddIfBPositive/WhenPositive
=== CONT  TestAddIfBPositive/WhenNegative
=== CONT  TestAddIfBPositive/WhenPositive
=== CONT  TestAddIfBPositive/WhenZero
--- PASS: TestAddIfBPositive (0.00s)
    --- PASS: TestAddIfBPositive/WhenNegative (0.00s)
    --- PASS: TestAddIfBPositive/WhenPositive (0.00s)
    --- PASS: TestAddIfBPositive/WhenZero (0.00s)
PASS
ok      go_test_demo/tabledriventest   0.776s

GoLand自动生成测试

其实上面的表驱动例子的框架是GoLand自动生成的。
通过在要进行测试的函数上 Shift+Comand+T -> Test for function

IDE会自动为此函数生成测试用例框架：

func TestAddIfBPositive(t *testing.T) {
   type args struct {
      a int
      b int
   }
   tests := []struct {
      name string
      args args
      want int
   }{
      // TODO: Add test cases.
   }
   for _, tt := range tests {
      t.Run(tt.name, func(t *testing.T) {
         if got := AddIfBPositive(tt.args.a, tt.args.b); got != tt.want {
            t.Errorf("AddIfBPositive() = %v, want %v", got, tt.want)
         }
      })
   }
}

如果没有测试文件的话也会自动创建。

然后就可以在其上修改来实现测试用例。

主测试

如果测试文件包含函数：

func TestMain(m *testing.M)

则生成的测试不会直接运行各测试用例，而是去调用TestMain(m)。

TestMain运行于主goroutine，可以在调用m.Run前后进行setup和cleanup。m.Run将返回退出码，退出码一般是传给os.Exit。在TestMain退出后，测试会自动把m.Run的结果传给os.Exit。

在TestMain被调用时，flag.Parse还没有运行。如果TestMain依赖于(包括testing package里的那些)命令行标志位，那就应该直接调用flag.Parse。当测试函数运行时，命令行标志位总是已经转化好的。

示例：

package maintest

import (
   "os"
   "testing"
)
var set = false

func TestMain(m *testing.M) {
   // call flag.Parse() here if TestMain uses flags
   // setup code
   set = true
   os.Exit(m.Run())
   // cleanup code
   set = false
}

func TestA(t *testing.T) {
   t.Errorf("set = %v", set)
}

func TestB(t *testing.T) {
   t.Errorf("set = %v", set)
}

$ go test   
--- FAIL: TestA (0.00s)
    main_test.go:19: set = true
--- FAIL: TestB (0.00s)
    main_test.go:23: set = true
FAIL
exit status 1
FAIL    go_test_demo/maintest  0.411s

另：由于测试函数在一个package内的所有测试文件间是相互可见的，道理上一个package只能有一个TestMain；当然，要是是直接指定测试文件的写法，各自放一个TestMain是可以各自完成测试。

Golang(1)|从环境准备到快速上手
sc_jizhi的博客
07-03 1150
Go语言保证了既能到达静态编译语言的安全和性能，又达到了动态语言开发速度和易维护性，有人形容Go语言： , 说明Go语言既，又能达到。Go语言有以下 特性：Go 有多种安装方式，如:Go 源码安装、Go 标准包安装、第三方工具（yum、apt-get 等）安装GOPATH详解 Linux下安装GO 获取安装压缩包 设置环境变量 测试是否安装成功 看到 go version 命令输出 go 版本号 go1.10.2 linux/amd64 ，说明 go 命令安装成功。 Windows
小白怎么入门Golang开发实战？看这篇就够啦！（白嫖60G资料）
weixin_70257503的博客
09-26 4083
Golang不难，入门更简单！可不要被它神秘的外衣给唬住了。 只要你接下来认真听完我的讲解，虽然保证不了你能成为大神，但就算你学习能力再差那也能达到入门级别。
Golang Unit Test单元测试
白杨的专栏
07-21 3251
1. Golang单元测试对文件名和方法名要求 文件名必须以xx_test.go命名 方法必须是Test[^a-z]开头 方法参数必须 t *testing.T 2. go test 参数解读　　 go test是go语言自带的测试工具，其中包含的是两类，单元测试和性能测试。通过go help test可以看到go test的使用说明： 格式go test [-c] [-i] [build fla
Golang UnitTest单元测试
黑光技术
01-26 329
Golang UnitTest单元测试单元测试是程序开发者适用一段代码来验证另外一段代码写的是否符合预期的一种相对高效的自我测试方法。对于程序开发来说，经过长期的积累和方法总结，单元测试...
Python数据分析工具(三)：pymssql的用法
最新发布
2401_85737382的博客
09-19 601
是一个 Python 模块，用于在 Python 程序中连接数据库。它提供了一个简单的接口来执行命令，并处理数据库查询的结果。下面是一些使用的基本步骤和示例。安装首先，你需要确保已经安装了。你可以通过。
python中的pymssql操作MSSQL数据库
book_dw5189的博客
06-19 1万+
pymssql是 Python 中用于连接和操作 Microsoft SQL Server 数据库的库之一。它是一个轻量级的库，为 Python 提供了与 SQL Server 进行通信的简单而有效的方法。
Python 通过pymssql访问查询操作 SQL Server数据库
hnkkfan的博客
07-04 6633
使用pyton（pyqt5）通过pymsslq访问SQL Server的实际模型
python pymssql — pymssql模块使用指南
热门推荐
夏日白云的boke
09-28 10万+
最近在学习python，发现好像没有对pymssql的详细说明，于是乎把官方文档学习一遍，重要部分做个归档，方便以后查阅。 本文介绍了pymssql模块的主要使用。
golang基础教程-go语言快速入门.zip
04-01
通过这个基础教程，你将能够快速上手Go语言，理解其核心概念，并具备编写简单Go程序的能力。不过，要想成为Go语言的大师，还需要深入学习Go语言的高级特性，如反射、接口的动态实现、Go汇编以及Go语言的性能优化等。...
golang爬虫库
07-07
6. **代码结构和测试**：良好的代码组织结构和充分的单元测试能保证爬虫的稳定性和可维护性。 7. **法律法规**：在开发爬虫时，务必遵守当地的网络法规，尊重网站版权，不得用于非法目的。 通过熟练掌握上述golang...
Go-一个新手学习golang或者开发api的组合框架.
08-13
7. **测试支持**：为了确保代码质量，单元测试和集成测试是必要的。Happylemon可能提供了测试工具和辅助函数，帮助开发者编写和运行测试用例。 8. **社区和文档**：作为学习和开发的资源，Happylemon可能有一个活跃...
Python中的pymssql入门
牛肉胡辣汤
10-23 1289
本篇博客介绍了如何使用​​pymssql​​库在Python中连接和操作Microsoft SQL Server数据库。我们学习了如何建立到数据库的连接、执行查询以及插入和更新数据。​​pymssql​​提供了简单且易于使用的接口，使得与SQL Server数据库进行交互变得更加方便。希望本篇博客对你入门​​pymssql​​有所帮助，让你能够更好地利用Python来处理SQL Server数据库中的数据。
python pymssql连接本地SQL SERVER
m0_47222313的博客
10-31 2477
python pymssql连接本地SQL SERVER
「Python入门」python操作MySQL和SqlServer
AIGC大前端小王子
08-05 1657
pymysql模块模块说明：是一个Python编写的MySQL驱动程序，让我们可以用Python语言操作MySQL数据库。
Py之pymssql：Python库之pymssql的简介、安装、使用方法之详细攻略
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
06-18 1万+
Py之pymssql：Python库之pymssql的简介、安装、使用方法之详细攻略 目录 pymssql的简介 1、特点 pymssql的安装 pymssql的使用方法 1、过程备注 pymssql的简介 一个简单的Python数据库接口，它建立在FreeTDS之上，为微软SQL Server提供Python DB-API（PEP-249）接口。...
使用pymssql操作MS SQL数据库
jerrymayan0898的博客
03-07 816
pymssql是Python中用于与Microsoft SQL Server数据库进行交互的第三方库。pymssql提供了连接到数据库、执行SQL查询、插入、更新和删除数据等功能。如需执行异步的MSSQL数据库操作，pymssql提供了对异步IO的支持。可以使用pymssql.connect()的asynchronous=True参数来创建异步连接，以及cursor.execute()的as_dict=True参数来执行异步查询并返回字典格式的结果。
（pyCharm）pymssql远程连接sql server、语法介绍、错误解决
weixin_49858823的博客
07-18 6711
（pyCharm）pymssql远程连接sql server以及相关语法介绍 pymssql是什么 pymssql是python的一个第三方库，是用来连接sql server数据库并对库中数据进行操作的一个工具。 一、测试环境 两台电脑，windows10系统,pycharm软件。 二、pymssql下载 1、打开终端 按win+R组合键打开“运行”对话框，输入cmd打开终端。 2、输入pip install pymssql下载安装pymssql(前提是电脑已经安装了python，若没安装请自行百度教程安装
Python：利用pymssql模块操作SQL server数据库
weixin_47648853的博客
03-29 2426
python默认的数据库是 SQLlite，不过它对MySql以及SQL server的支持也可以。这篇文章，介绍下如何在Windows下安装pymssql库并进行连接使用。。。
golang test说明解读
weixin_33738578的博客
01-22 582
go test是go语言自带的测试工具，其中包含的是两类，单元测试和性能测试 通过go help test可以看到go test的使用说明： 格式形如： go test [-c] [-i] [build flags] [packages] [flags for test binary] 参数解读： -c : 编译go test成为可执行的二进制文件，但是不运行测试。 -i : 安装测试...
全面的Golang编程教程与资源
Go语言的语法非常简洁，变量声明、控制结构、函数定义、指针和接口等基础语法都很容易上手。例如，变量声明不需要指定类型，编译器会根据赋值自动推断；控制结构如if、for、switch等也与C语言类似，但更为精简；函数...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值