基础数据类型和操作符

一、go程序基础

1、文件名

go语言文件名命名规范：

1. go语言的文件名必须以.go结尾。
2. go语言的文件名必须以小写字母开头，否则会报错。
3. go语言的文件名不能包含空格，否则会报错。
4. go语言的文件名不能包含特殊字符，否则会报错。
5. go语言的文件名不能包含中文，否则会报错。
6. go语言的文件名不能包含大写字母，否则会报错。

2、关键字

关键字是指编程语言中预先定义好的具有特殊含义的标识符，关键字和保留字都不建议用作变量名。

（1）Go语言中25个关键字

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

（2）Go语言中37个保留字

Constants:    true  false  iota  nil
    Types:    int  int8  int16  int32  int64
              uint  uint8  uint16  uint32  uint64  uintptr
              float32  float64  complex128  complex64
              bool  byte  rune  string  error
Functions:    make  len  cap  new  append  copy  close  delete
              complex  real  imag
              panic  recover

3、标识符

标识符以字母或下划线开头，后面可以跟任意数量的字母、数字或下划线。

• 大小写敏感：如age和Age是两个不同的标识符。
• 不能包含空格。如my age是非法的标识符。
• 不能包含特殊字符，如@、#、$等。
• 仅能包含字母、数字和下划线。如my-age是非法的标识符。
• 不能是Go语言的关键字。如func、if、else等是非法的标识符。
• 不能是Go语言的预定义标识符。如true、false、nil等是非法的标识符。
• 不能是Go语言的内置标识符。如append、cap、close等是非法的标识符。
• 不能是Go语言的保留标识符。如break、case、chan等是非法的标识符。
• 不能是Go语言的类型名。如int、string、bool等是非法的标识符。
• _（下划线）是一个特殊的标识符，它可以用来接收任何值，但是它本身不占用内存空间，也不会分配内存空间。

4、基本结构

Go语言的基本结构如下：

package main

import "fmt"

func main() {
	fmt.Println("Hello, World! ")
}

1. 任何一个代码文件都必须以package关键字开头，表示该文件属于哪个包。
2. import关键字用于导入其他包。

import "fmt"
import ("time")
// 通常情况下，我们只需要导入一个包，但是如果导入多个包，可以使用括号将多个包括起来
import (
	"fmt"
	"time"
)

3. golang可执行程序的入口是main函数，main函数是main包中的一个特殊函数。

func main() {
	fmt.Println("Hello, World! ")
}

4. 包中函数调用：
   • 同一个包中的函数可以直接调用。
   • 不同包中的函数需要通过import导入后才能调用。通过包名.函数名()的方式调用。

package main

import "fmt"

func main() {
	// 包中函数调用
	test()
}

func test() {
	fmt.Println("test()...")
}

5. 包访问权限：
   • 如果标识符（变量、常量、函数、类型、接口等）的首字母是大写的，那么就表示对外部包可见（暴露的，公有的）。
   • 如果标识符的首字母是小写的，那么就表示对外部包不可见（非暴露的，私有的）。

package main

import "fmt"

func main() {
	// 包访问权限
	test()
}


func test() {
	fmt.Println("test()...")
}

（1）练习

练习1：写一个程序，对于给定一个数字n,求出所有两两相加等于n的组合。

package main

import "fmt"

func main() {
	// 练习
	var n int
	fmt.Println("请输入一个数字：")
	fmt.Scanln(&n)            // 从键盘输入一个数字，赋值给n
	for i := 1; i <= n; i++ { // i从1开始，到n结束
		for j := 1; j <= n; j++ { // j从1开始，到n结束
			if i+j == n {
				fmt.Printf("%d + %d = %d\n", i, j, n)
			}
		}
	}
}

/*
PS D:\GolangProjects\src\crm> go run test1.go
请输入一个数字：
5
1 + 4 = 5
2 + 3 = 5
3 + 2 = 5
4 + 1 = 5
*/

（2）练习

包别名应用，开发一个程序，使用包别名访问包中的函数。
创建出如下目录结构：

└─example2
    ├─add\add.go
    ├─main\main.go
    └─test\test.go

代码如下所示：

// test\test.go:
package test

import (
	"fmt"
)

var Name string = "this is test package"
var Age int = 18

func init() {
	fmt.Println("test package init")
	fmt.Println("test package Name=", Name)
	fmt.Println("test package Age=", Age)

	Age = 10
	fmt.Println("test package Age=", Age)
}


// add\add.go:
package add

import (
	_ "crm/example2/test"
	"fmt"
)

func init() {
	Name = "this is add package"
	Age = 22
	fmt.Println("add package init")
	fmt.Println("add package Name=", Name)
	fmt.Println("add package Age=", Age)
}

var Name string = "this is add package  XXXX"
var Age int = 35


// main\main.go:
package main

import (
	a "crm/example2/add" // import add package
	"fmt"
)

func main() {
	fmt.Println("main.package.Name=", a.Name)
	fmt.Println("main.package.Age=", a.Age)
}

编译执行效果：

PS D:\GolangProjects\src\crm> go build -o example2.exe .\example2\main
PS D:\GolangProjects\src\crm> .\example2.exe
test package init
test package Name= this is test package
test package Age= 18
test package Age= 10
add package init
add package Name= this is add package
add package Age= 22
main.package.Name= this is add package
main.package.Age= 22

二、数据类型

Go是一种静态类型的编程语言，它有一些基本数据类型。

1、基本数据类型

1. bool：布尔类型，表示真或假，取值为true或false。
2. string：字符串类型，表示一串字符，用双引号或反引号括起来。
3. int, int8, int16, int32, int64：整数类型，分别表示8位、16位、32位和64位的有符号整数。
4. uint, uint8, uint16, uint32, uint64：无符号整数类型，分别表示8位、16位、32位和64位的无符号整数。
5. float32, float64：浮点数类型，分别表示单精度和双精度浮点数。
6. complex64, complex128：复数类型，分别表示32位和64位的复数。
7. byte：等同于uint8类型。
8. rune：等同于int32类型，用于表示Unicode码点。

除了这些基本数据类型外，Go还有一些复合类型，如数组、切片、映射、结构体等。

package main

import "fmt"

func main() {
	// 整型
	fmt.Println(666)
	fmt.Println(6 + 9)
	fmt.Println(6 - 9)
	fmt.Println(6 * 9)
	fmt.Println(16 / 9) // 商
	fmt.Println(16 % 9) // 余数

	// 字符串类型，特点：通过双引号
	fmt.Println("库里")
	fmt.Println("钓鱼要掉刀鱼，刀鱼到岛上钓")
	fmt.Println("alex" + "SB")
	//fmt.Println("alex" + 666)
	fmt.Println("alex" + "666")
	// 对比
	fmt.Println("1" + "2") // 结果："12"
	fmt.Println(1 + 2)     // 结果：3

	// 布尔类型，真假
	fmt.Println(1 > 2) // false  假
	fmt.Println(1 < 2) // true   真
	fmt.Println(1 == 2)
	fmt.Println(1 >= 2)
	fmt.Println("allen" == "dcm")

	// 超前
	if 2 > 1 {
		fmt.Println("2大于1")
	} else {
		fmt.Println("2不大于1")
	}

}

三、变量

变量来历：变量是计算机语言中最基本的存储单元，其本质是将内存中的一块区域进行命名，开辟出来的内存区域可以用来存储数据。

变量类型：变量的类型决定了变量的内存大小和布局，该变量能存储的值的范围和存储方式。常见的变量类型有：整型、浮点型、布尔型、字符串型等。

1、变量的声明

Go语言中变量需要先声明后使用，同一个作用域内的变量名不能重复。

且Go语言中的变量声明后必须使用，否则编译不通过。

（1）变量声明格式

• 声明 + 赋值

  var sd string = "kobe"
  fmt.Println(sd)
  
  var age int = 73
  fmt.Println(age)
  
  var flag bool = true
  fmt.Println(flag)
  

• 先声明后赋值

  // 声明了一个字符类型变量 sd
  var sd string
  // 给sd变量赋值
  sd = "james"
  fmt.Println(sd)
  

（2）声明变量的意义？

• 编写代码省事

  // 文本，请将文本输出3次："伤情最是晚凉天，憔悴斯人不堪怜。"
  var message string = "伤情最是晚凉天，憔悴斯人不堪怜。"
  fmt.Println(message)
  fmt.Println(message)
  fmt.Println(message)
  

• 存储结果，方便之后使用

  // 存储结果，方便之后使用
  var v1 int = 99
  var v2 int = 33
  var v3 int = v1 + v2
  var v4 int = v1 * v2
  var v5 int = v1 + v2 + v3 + v4
  fmt.Println(v1, v2, v3, v4, v5)
  

• 存储用户输入的值

  var name string
  fmt.Scanf("%s", &name) // 用户输入字符串并赋值给name变量
  if name == "curry" {
      fmt.Println("用户名输入正确")
  } else {
      fmt.Println("用户名输入失败")
  }
  

（3）变量的初始化

Go语言在声明变量时，会自动对变量对应的内存区域进行初始化，每个变量会被初始化成其类型的默认值。

例如：整型的默认值是0，字符串的默认值是空字符串，布尔类型的默认值是false。

var name string
var age int
var isOk bool
fmt.Println(name, age, isOk)   // 输出："" 0 false

也可以在声明变量时，对变量进行初始化，例如：

var name string = "kobe"
var age int = 41
var isOk bool = true
fmt.Println(name, age, isOk)   // 输出：kobe 41 true

（4）变量的类型推导

在声明变量时，如果没有显式指定变量的类型，那么编译器会自动根据变量的值推导出变量的类型。

var name = "kobe"
var age = 41
var isOk = true
fmt.Println(name, age, isOk)   // 输出：kobe 41 true

2、变量名要求

• 【要求】变量名必须只包含：字母、数字、下划线

  var %1 string，错误
  var $ string，错误
  

• 【要求】数字不能开头

  var 1 string  错误
  var 1name string  错误
  var _ string 正确
  

• 【要求】不能使用go语言内置的关键字

  var var string = "南通州北通州南北通州通南北"  错误
  

• 建议

  • 变量名见名知意：name/age/num ; v1、v2、v3
  • 驼峰式命名：myBossName / startDate / endDate

3、变量简写

• 声明+赋值

  var name string = "战狼"    // 标准声明格式
  
  var name = "战狼"           // 简写格式
  
  name := "战狼"              // 推荐使用
  

• 先声明再赋值

  // 先声明
  var name string
  var message string
  var data string
  
  // 批量声明
  var name,message,data string
  
  // 再赋值
  name = "战鹰"
  message = "中奖了"
  data = "中了5000w"
  

• 因式分解（批量声明变量），例如：声明5个变量，分别有字符串、整型

  var (
  	name   = "allen"
  	age    = 18
  	hobby  = "basketball"
  	salary = 1000000
  	gender string  // 只声明但不赋值，有一个默认： ""
  	length int     // 只声明但不赋值，有一个默认： 0
  	sb bool     // 只声明但不赋值，有一个默认： false
  )
  fmt.Println(name, age, hobby, salary, gender,length,sb)
  

扩展：go编译器会认为声明变量不使用 就是耍流氓。

4、作用域

如果我们定义了大括号，那么在大括号中定义的变量。

• 不能被上级使用。
• 可以在同级使用。
• 可以再子级使用。

package main

import "fmt"

func main() {
	name := "武沛齐"
	fmt.Println(name)
	if true {
		age := 18
		name := "alex"
		fmt.Println(age)
		fmt.Println(name)
	}
	fmt.Println(name)
}

5、全局变量和局部变量

• 全局变量，未写在函数中的变量称为全局变量；不可以使用v1:=xx方式进行简化；可以基于因式分解方式声明多个变量；项目中寻找变量时最后一环。
• 局部变量，编写在{}里面的变量；可以使用任意方式简化；可以基于因式分解方式声明多个变量；

package main

import "fmt"

// 全局变量（不能以省略的方式）
var school string = "老男孩IT教育" // 可以
//var school = "老男孩IT教育" 	 // 可以
//school := "老男孩IT教育"  		 // 不可以

var (
	v1 = 123
	v2 = "你好"
	v3 int
)

func main() {

	name := "武沛齐" // 局部变量
	fmt.Println(name)
	if true {
		age := 18      // 局部变量
		name := "alex" // 局部变量
		fmt.Println(age)
		fmt.Println(name)
	}
	fmt.Println(name)
	fmt.Println(school)
	fmt.Println(v1, v2, v3)
}

6、赋值及内存相关

示例1：

name := "武沛齐"

示例2：

name := "武沛齐"
nickname := name

注意：这一点与python不同。

package main

import "fmt"

func main() {
	name := "武沛齐"
	nickname := name

	fmt.Println(name, &name)
	fmt.Println(nickname, &nickname)
}

示例3：

name := "武沛齐"
nickname := name

name = "alex"

package main

import "fmt"

func main() {
	name := "武沛齐"
	nickname := name
	fmt.Println(name, &name)
	fmt.Println(nickname, &nickname)

	name = "alex"
	fmt.Println(name, &name)
	fmt.Println(nickname, &nickname)
}

7、注意事项

使用int、string、bool这三种数据类型时，如果遇到变量的赋值则会拷贝一份。【值类型】

name := "武沛齐"
nickname := name

提示：后续在数据类型中会详细再讲解。

四、阶段练习题

1. package main的作用？

2. 单行注释和多行注释分别是什么？

3. 下面声明变量的方式错误的有哪些？

   var name = "武沛齐"
   var age int = 18
   hobby = "嫂子"
   nickName string = "一米八大高个"
   webSite := "秃头统治地球"
   

   var age int = 18
   age = 19
   

4. 下面声明变量的方式正确的有哪些？

   var v1,v2,v3 int
   var (
   	v6 = 123
       v7 string
   )
   var v4,v5 = 11,22
   v4,v5 = 11,22
   v4,v5 := 11,22
   

5. 变量名规范。

6. 看代码写结果

   package main
   
   import "fmt"
   
   var number = 9999
   
   func main() {
   	number := 666
   	fmt.Println(number)
   }
   

7. 看代码写结果

   package main
   
   import "fmt"
   
   var number = 99
   
   func main() {
   	number := 66
   	if true {
   		number := 33
   		fmt.Println(number)
   	}
   	fmt.Println(number)
   }
   

8. 看代码写结果

   package main
   
   import "fmt"
   
   var number = 99
   
   func main() {
   	number := 66
   	if true {
   		number := 33
   		fmt.Println(number)
   	}
   	number = 88
   	fmt.Println(number)
   }
   

9. 看代码写结果

   package main
   
   import "fmt"
   
   var number = 99
   
   func main() {
   	if true {
   		fmt.Println(number)
   	}
   	number = 88
   	fmt.Println(number)
   }
   

10. 看代码写结果

    package main
    
    import "fmt"
    
    var number = 99
    
    func main() {
    	number := 88
    	if true {
    		number = 123
    		fmt.Println(number)
    	}
    	fmt.Println(number)
    }
    
    

11. 看代码写结果

    package main
    
    import "fmt"
    
    var number = 99
    
    func main() {
    	fmt.Println(number)
    	number := 88
    	if true {
    		number = 123
    		fmt.Println(number)
    	}
    	fmt.Println(number)
    }
    

五、常量

常量使用 const 关键字定义，用于存储不会改变的数据。

const 只能修饰boolean、数字（整数、浮点数、复数）和字符串类型。

常量语法格式：

const identifier [type] = value    // 其中 type 可以省略不写。

示例：

package main

import "fmt"

const b string = "abc"    // 定义字符串常量，完整格式
const c = "abcd"          // 简化格式，自动推导类型
const Pi = 3.1415926      // 定义浮点型常量
const a = 9 / 3           // 定义整型常量，可以使用运算表达式
// const d = getValue()   // 常量不能函数赋值，不能使用内置函数，不能使用运行期间才能确定结果的表达式

func main() {
	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
	// fmt.Println(d)
	fmt.Println(Pi)
}
/*
  3
  abc
  abcd
  3.1415926
*/

1、因式分解

因式分解可以将一个复杂的常量定义拆分成多个简单的常量定义。
因式分解的常量定义中，如果某一行没有赋值，则默认和上一行一致。

package main

import "fmt"

func main() {
	// 常量因式分解
	const (
		v1 = 123
		v2 = 456
		pi = 9.9
		v3
	)
	fmt.Println(v1, v2, pi, v3)
}
/*
  123 456 9.9 9.9
*/

2、全局

全局常量可以在任何地方使用，不需要使用 const 关键字修饰。

package main

import "fmt"

// 全局常量
const Data = 999
const (
	pi     = 3.1415926
	gender = "男"
)

func main() {
	// 定义变量
	name := "武沛齐"
	name = "alex"
	fmt.Println(name)
	// 定义常量
	const age = 98
	fmt.Println(age)
	// 常量因式分解
	const (
		v1 = 123
		v2 = 456
	)
	fmt.Println(v1, v2, pi, gender)
}
/*
	alex
	98
	123 456 3.1415926 男
*/

3、iota

iota 是 golang 语言的常量计数器，只能在常量的表达式中使用。
iota 在 const 关键字出现时将被重置为 0，const 中每新增一行常量声明将使 iota 计数一次（iota 可理解为 const 语句块中的行索引）。
可有可无，当做一个在声明常量时的一个计数器。

package main

func main() {
	const (
		monday = iota + 1
		tuesday
		wednesday
		thursday
		friday
		saturday
		sunday
	)
	const (
		n1 = iota
		n2
		n3
	)
	fmt.Println(monday, tuesday, wednesday, thursday, friday, saturday, sunday)
	fmt.Println(n1, n2, n3)
}
/*
  1 2 3 4 5 6 7
  0 1 2
*/

4、练习或示例

练习1：定义两个常量Male=1和Female=2，获取当前时间的秒数，如果能被Female整除则打印“女”，否则打印“男”。

package main

import (
	"fmt"
	"time"
)

// 定义两个常量Male=1和Female=2，获取当前时间的秒数，如果能被Female整除则打印“女”，否则打印“男”
const (
	Male   = 1
	Female = 2
)

func main() {
	Second := time.Now().Unix() // 获取当前时间的秒数
	fmt.Println(Second)
	if Second%Female == 0 {
		fmt.Println("女")
	} else {
		fmt.Println("男")
	}
}
/*
  1683208344
  女
*/

五、输入

让用户输入数据，完成项目交互。

• fmt.Scan
• fmt.Scanln
• fmt.Scanf

package main

import "fmt"

func main() {
	// 示例1：fmt.Scan
	/*
		var name string
		fmt.Println("请输入用户名：")
		fmt.Scan(&name)
		fmt.Printf(name)
	*/

	// 示例2：fmt.Scan
	var name string
	var age int

	fmt.Println("请输入用户名：")
	// 当使用Scan时，会提示用户输入
	// 用户输入完成之后，会得到两个值：count,用户输入了几个值；err，用输入错误则是错误信息
	_, err := fmt.Scan(&name, &age)
	if err == nil {
		fmt.Println(name, age)
	} else {
		fmt.Println("用户输入数据错误", err)
	}
	// 特别说明：fmt.Scan 要求输入两个值，必须输入两个，否则他会一直等待。
}

package main

import "fmt"

func main() {
	// 示例1：fmt.Scanln
	/*
		var name string
		fmt.Print("请输入用户名：")
		fmt.Scanln(&name)
		fmt.Printf(name)
	*/

	// 示例2：fmt.Scanln

	var name string
	var age int
	fmt.Print("请输入用户名：")
	// 当使用Scanln时，会提示用户输入
	// 用户输入完成之后，会得到两个值：count,用户输入了几个值；err，用输入错误则是错误信息
	count, err := fmt.Scanln(&name, &age)
	fmt.Println(count, err)
	fmt.Println(name, age)

	// 特别说明：fmt.Scanln 等待回车。
}

package main

import "fmt"

func main() {
	var name string
	var age int

	fmt.Print("请输入用户名：")
	_, _ = fmt.Scanf("我叫%s 今年%d 岁", &name, &age)
	fmt.Println(name, age)
}

无法解决的难题？

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	// line，从stdin中读取一行的数据（字节集合 -> 转化成为字符串）
	// reader默认一次能4096个字节（4096/3)
	//    1. 一次性读完，isPrefix=false
	// 	  2. 先读一部分，isPrefix=true，再去读取isPrefix=false
	line, _, _ := reader.ReadLine()
	data := string(line)
	fmt.Println(data)
}

六、条件语句

8.1 最基本

if 条件 {
    成立后，此代码块执行
}else{
    不成立，此代码块执行
}

if 条件 {
    成立后，此代码块执行
}

示例：

package main

func main() {
	/*
		if true {
			fmt.Println("666")
		}else{
			fmt.Println("999")
		}
	*/

	/*
		if 1 > 2 {
			fmt.Println("666")
		} else {
			fmt.Println("999")
		}
	*/

	/*
		flag := false
		if flag {
			fmt.Println("条件成立")
		}else{
			fmt.Println("条件不成立")
		}
	*/

	// 练习题1:用户输入姓名，判断是否正确
	/*
		var name string
		fmt.Print("请输入姓名：")
		fmt.Scanln(&name)
		if name == "alex" {
			fmt.Println("用户名输入正确")
		} else {
			fmt.Println("用户名输入错误")
		}
	*/
	// 练习题2:用户输入数字，判断奇数、偶数
	/*
		var number int
		fmt.Print("请输入数字：")
		fmt.Scanln(&number)
		if number % 2 == 0{
			fmt.Println("您输入的是偶数")
		}else{
			fmt.Println("您输入的是奇数")
		}
	*/
	// 练习题3:用户和密码，判断用户名密码是否正确。
	/*


		var username, password string
		fmt.Print("请输入用户名：")
		fmt.Scanln(&username)

		fmt.Print("请输入密码：")
		fmt.Scanln(&password)

		if username == "alex" && password == "sb" {
			fmt.Println("欢迎登录pornhub")
		} else {
			fmt.Println("用户名或密码错误")
		}
	*/
	// 练习题4:请输入用户名校验是否是VIP
	/*
		var username string
		fmt.Print("请输入用户名：")
		fmt.Scanln(&username)

		if username == "alex" || username == "eric" {
			fmt.Println("天上人间大VIP")
		} else {
			fmt.Println("屌丝")
		}
	*/
}

8.2 多条件判断

if 条件A{
    ...
}else if 条件B{
    ...
}else if 条件C{
    ...
}else{
    ...
}

示例：

package main

import "fmt"

func main() {
	var length int
	fmt.Print("请输入你的长度：")
	fmt.Scanln(&length)

	if length < 1 {
		fmt.Println("没用的东西，还特么是坑")
	} else if length < 6 {
		fmt.Println("刚刚能用")
	} else if length < 18 {
		fmt.Println("生活和谐")
	} else {
		fmt.Println("太特么大了")
	}
}

8.3 嵌套

package main

import "fmt"

func main() {
	fmt.Println("欢迎致电10086，1.话费相关；2.业务办理；3.人工服务。")

	var number int
	fmt.Scanln(&number)

	if number == 1 {
		fmt.Println("话费服务，1.交话费；2.查询。")
		var n1 int
		fmt.Scanln(&n1)
		if n1 == 1 {
			fmt.Println("缴话费啦")
		} else if n1 == 2 {
			fmt.Println("查话费了")
		} else {
			fmt.Println("输入错误")
		}
	} else if number == 2 {
		fmt.Println("业务办理")
	} else if number == 3 {
		fmt.Println("人工服务")
	} else {
		fmt.Println("输入错误")
	}
	
	// 建议：条件的嵌套不要太多
}

今日作业

1. 提⽰⽤户输入⿇花藤. 判断⽤户输入的对不对。如果对, 提⽰真聪明, 如果不对, 提⽰你 是傻逼么。

2. 提示用户输入两个数字，计算两个数的和并输出。

3. 提示用户输入姓名、位置、行为三个值，然后做字符串的拼接 并输出，例如：xx 在 xx 做 xx 。

4. 设定一个理想数字比如：66，让用户输入数字，如果比66大，则显示猜测的结果大了；如果比66小，则显示猜测的结果小了;只有等于66，显示猜测结果正确。

5. 写程序，输出成绩等级。成绩有ABCDE5个等级，与分数的对应关系如下.

   A    90-100
   B    80-89
   C    60-79
   D    40-59
   E    0-39
   

   要求用户输入0-100的数字后，正确输出他的对应成绩等级。

本栏目推荐文章
• Jmeter 如何连接mysql数据库？
• 函数的参数类型
• SQL Server 检测是不是数字型数据的两种方法
• 【Shell基础】Bash基础与Linux三剑客
• 如何通过Navicat把MySQL远程数据库导入到本地数据库
• 和利时MACS6通过dat文件实现任意时间范围与测点的历史数据提取与科研分析
• 深入理解spring框架：剖析多线程模式下数据库连接
• 数据可视化是如何帮助大型企业提高效率的？
• redis 数据库
• openpyxl模块--------------------------------重复数据

操作符 类型 基础 数据操作符 类型 基础 数据 基本操作 类型 数据redis 类型 基础 数据java python类型 基础 数据 类型 基础 数据python 命令 类型 基础 数据 常用 类型 基础 数据 类型 基础 数据redis 随笔 类型 基础 数据 类型 基础 数据golang