在插入正文之前，帮一个准备考研的小伙伴问个问题。 顺便说下，我并没有考生信专业，我只是半路出家，这个问题在后台就不必提问了，直接在留言区问吧。 
想快速了解一门新的编程语言时，我们先需要看看它的一些语言特性，包括： 编译型还是解释型语言 基本数据类型 变量的定义 数值运算 字符串操作 数据结构 循环和条件语句 面向对象的类，面向过程的函数定义 ...
学习的最好方式时带着问题去学习，所以我找了几个简单的问题用Go进行编程 温度单位有华氏度(F)和摄氏度(C)两类，转换公式为: C = (F - 32) / 1.8。 如果给定F=100，让Go求算C。 为了完成这部分操作，我们需要导入打印输出的'fmt', 写一个“main”函数提供执行入口，然后定义几个变量 package main
import 'fmt'
var C float32
func main() {
F := 65.0
C = float32( (F - 32) / 1.8)
fmt.Printf('%f\n', C)
}
package是Go最基本的分发单位和工程管理中依赖关系的体现，为了生成可执行程序，必须建立一个'main'的包，且包里面必须有一个'main'函数。 Go的标准库(standard library)见https:///pkg/, 导入库的方式为 import 'fmt' Go通过关键字var定义变量，如果不赋值，变量后一定要跟着变量类型，赋值可以忽略变量类型，因为编译器可以自动推断。 var x = 1
var x int
var y float64 = 1.6
var x,y,z = 1, 2, 3
如果在函数内部定义变量，Go还提供一个非常简便的写法 :=。变量定义类型后，之后使用变量进行运算时就会发现两个变量有可能是不同的类型，那么如何处理呢？Go不支持隐式类型转换，必须要显式说明, 如 C = float32( (F - 32) / 1.8) 这一题需要用到循环。 Go支持三种循环方式的，都是for开头，比较常用的是下面这一种 s := 'abc'
for i, n := 0, len(s); i n; i++ {
println(s[i])
}
结合变量的赋值和'fmt'包中 Printf函数的用法就能解决这个问题。 package main
import 'fmt'
func main() {
var n = 0
fmt.Printf('n\tn^2\n')
for i, j := 1, 10; i <> j; i++ {
n++
ns := n * n
fmt.Printf('%d\t%d\n', n, ns)
}
}
提高题： 编写一个程序，计算一个整数的各数位之和。例如，数字2155的数位之和为2+1+5+5=13 思路就是通过循环的方式不断，逐个选择各个数位，然后求和。 package main
import 'fmt'
var num int
func main() {
fmt.Scanf('%d', &num)
total := 0
for num != 0 { //类似于while的循环方式
remain := num % 10
num = num / 10
total += remain
}
fmt.Printf('%d\n', total)
}
刚开始我想的是将数字当作字符串，然后遍历字符串，将字符串转成整数型。后来我发现我还得自己写一个类似于R的 as.numeric函数，感觉更麻烦了。
斐波那契数组基本也是学习C语言时常见的案例，虽然可以直接使用几个变量来计算第N个斐波那契数，但是这里限定要用到数组，所以就得学习一下Go的数组数据结构了。 数组可以认为是C语言的唯一的数据结构，并且C语言中的数组和指针式密不可分。《Go学习笔记》说到Go语言的数组和C有很大区别 数组是值类型，赋值和传参会复制整个数组，⽽而不是指针。 数组⻓长度必须是常量，且是类型的组成部分。[2]int 和 [3]int 是不同类型。 ⽀支持 '=='、'!=' 操作符，因为内存总是被初始化过的。 指针数组 [n]*T，数组指针 *[n]T。
数组的初始化 d1 := [3] int{1,2} // 基本操作
d2 := [...]int{1,2,3,4,5} // 使用值来确定数组长度
d3 := [5]int{2:100, 4:200} //使用索引方式初始化元素
d4 := [2][3]int{{1,2,3},{4,5,6}} // 多维数组
然后解题就很容易了 //Feb.go
package main
func main() {
Feb := [100]int{0, 1}
for i, n := 2, len(Feb); i n; i++ {
Feb[i] = Feb[i-2] + Feb[i-1]
}
println(Feb[99])
}
当然运行之后就会出现一个非常有趣的结果 ./Feb
-2437933049959450366
这是因为我定义的是一个int,在我机器上默认长度为8个byte，也就是8x8=64个bit, 2^64^，可以保存-9^18^~9^18^，似乎已经存放很大的数值了，但是第100位的Feb值是16008811023750101250，也就是1.6^19^，只能说技高一筹，甘拜下风， 必须动用unit64了，因为它可以记录0~1.8^19^. 那问题来了，如果我们想计算第200个斐波那契数，岂不是没办法记录了。如果遇到这个需求时，把提出需求的人干掉就行了。 问题四：构造一类数据结构，登记一个学生的数学，语文和英语成绩 我们可以通过数组来保存相同数据类型的数据，但是如果要保存的数据里有不同的数据类型，那就需要用到结构体(structure)。 我们需要先定义结构体，声明我们需要保存哪些类型的数据，然后再进行初始化。 package main
type student struct {
name string
math int
english int
yuwen int
}
func main() {
bob := student{'Bob', 60, 75, 88}
println(bob.name, bob.math, bob.english, bob.yuwen)
}
这是Rosalind中一道基础的题目，设计到字符串的遍历。在Go中，字符串是不可变值类型，内部用指针指向 UTF-8 字节数组，也就是说字符串本质上就是字符数组了。 Go的字符串可以通过 s[i]的方式访问某个字符，(每个字符常量都是一个整数),但是不能通过 s[i]='x'的方式修改字符串，也就是无法修改字节数组。我们可以看个例子  无法修改字节数组
for遍历字符串时有两种方式，一种按byte，一种按rune(Unicode Code Point)， 通过一个案例了解两者的区别 package main
import 'fmt'
func main() {
a := 'Hello 世界'
for i := 0; i len(a); i++{
fmt.Printf('%c,', a[i])
}
fmt.Println()
for _,r := range a{
fmt.Printf('%c,',r)
}
}
// 运行结果
H,e,l,l,o, ,ä,¸,,ç,,,
H,e,l,l,o, ,世,界,
按照字节遍历就会给你感受一下什么叫做乱码。 这里的range类似于迭代器，返回(索引, 值) 或 (键, 值)。这里还用了'_'忽略了不想要的索引 。 那么假设，给定核苷酸序列为 'AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC' ,让我们尝试统计下这里面各个碱基出现次数吧 package main
import 'fmt'
var seq = 'AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC'
func main() {
c_count := 0
t_count := 0
g_count := 0
a_count := 0
for _, c := range seq {
if c == 'A' {
c_count += 1
} else if c == 'G' {
g_count += 1
} else if c == 'T' {
t_count += 1
} else {
a_count += 1
}
}
fmt.Printf('A\tT\tC\tG\n')
fmt.Printf('%v\t%v\t%v\t%v\n', a_count, t_count, c_count, g_count)
}
这里把字符串写死了，当然可以通过'fmt.Scanf'手动输入，或者从标准输入，或者文件中读入。 学习基本操作后，我准备写一波爬虫了
|
