python语言转换为go_从 Python 到 Golang-Go语言中文社区
Why Python
Python是一个很酷的编程语言，它极致的简洁，极易上手，我们可以用它来做云计算、大数据分析，运维自动化，当然还可以写网站、做爬虫。
Why not Python
但我们也清楚地知道它会受限于GIL，还好我们有gevent，我们可以很愉快地monkey.patch_all()，然后用greenlet来处理，但即使这样，在并发量极高的情况下，它的效率就有些令我们担心了。
Golang or OpenResty
当我们开始关注高性能高并发服务端实现的时候，我们自然而然地将目光转向一些现代化的技术，这就是Golang和OpenResty，当然他们的核心都是将IO复用与协程进行有机的融合，但却有着截然不同的表现风格。如果你要问我更喜欢哪个，我会说both。当然下文我会介绍Golang。
Golang
我的哲学是，要熟悉一个编程语言，就是要从最简单的代码开始写起来。百试不爽。
万年不变的hello world先放这。
hello.go
package main //包声明
import "fmt" //导入包
func main() {
fmt.Println("Hello, 世界")
}
package main
import (
"encoding/json"
"github.com/cloudflare/conf"
"gopkg.in/macaron.v1" //Web框架Macaron
"labix.org/v2/mgo"
"log"
"net/http"
"os"
"strconv"
)
// 声明包级别的变量
var (
MONGO_URL string
MONGO_DB string
)
// 包初始化函数init
func init() {
c, err := conf.ReadConfigFile("config.conf") //配置文件见config.conf
e(err, true)
MONGO_URL = c.GetString("MONGO_URL", "127.0.0.1:27017")
MONGO_DB = c.GetString("MONGO_DB", "test")
}
func e(err error, fatal bool) (ret bool) {
if err != nil {
log.Println(err.Error())
if fatal {
os.Exit(1)
}
return true
} else {
return false
}
}
func main() {
ms, err := mgo.Dial(MONGO_URL)
e(err, true)
defer ms.Close() //延迟到函数将要返回时执行
ms.SetMode(mgo.Monotonic, true)
mdb := ms.DB(MONGO_DB)
m := macaron.Classic()
m.Map(mdb)
m.Get("/", func(mdb *mgo.Database) string {
names, err := mdb.CollectionNames()
e(err, false)
body, err := json.Marshal(names)
e(err, false)
return string(body)
})
m.Get("/:col", func(mdb *mgo.Database, ctx *macaron.Context, req *http.Request) string {
req.ParseForm()
mcol := mdb.C(ctx.Params(":col"))
limit := 20
offset := 0
if t := req.FormValue("limit"); t != "" {
limit, err = strconv.Atoi(t)
e(err, false)
}
if t := req.FormValue("offset"); t != "" {
offset, err = strconv.Atoi(t)
e(err, false)
}
total_count, err := mcol.Find(nil).Count()
e(err, false)
items := []map[string]interface{}{}
iter := mcol.Find(nil).Skip(offset).Limit(limit).Iter()
for {
item := map[string]interface{}{}
if iter.Next(&item) {
// item := map[string]interface{}{} 不能写在这里，因为Map是引用类型
items = append(items, item)
} else {
break
}
}
dict := map[string]interface{}{
"meta": map[string]int{"total_count": total_count, "offset": offset, "limit": limit},
"data": items,
"msg": "success",
"code": 0,
}
body, err := json.Marshal(dict)
e(err, false)
return string(body)
})
m.Run()
}
config.conf
MONGO_URL=127.0.0.1:27017
MONGO_DB=devmgmt
package main
import (
"database/sql"
"fmt"
_ "github.com/go-sql-driver/mysql" //匿名导入
"io/ioutil"
"log"
"os"
"regexp"
"strings"
"time"
)
func e(err error, fatal bool) (ret bool) {
if err != nil {
log.Println(err.Error())
if fatal {
os.Exit(1)
}
return true
} else {
return false
}
}
var (
DBS = map[string]string{}
dbs = map[string]*sql.DB{}
)
func init() {
log.SetFlags(log.Flags() | log.Lshortfile)
bytes, err := ioutil.ReadFile("config.conf") //见config.conf
e(err, true)
str := string(bytes)
lines := strings.Split(str, "n")
reg, err := regexp.Compile(`s+`)
e(err, true)
for num, line := range lines {
if line == "" {
continue
}
if strings.HasPrefix(line, "#") {
continue
}
fields := reg.Split(line, -1)
if len(fields) != 2 {
log.Printf("Line %d is not match the config format.", num+1)
continue
}
dbname := fields[0]
dburi := fields[1]
DBS[dbname] = dburi
dbs[dbname] = init_db(dburi)
}
}
func init_db(uri string) *sql.DB {
db, err := sql.Open("mysql", uri)
e(err, true)
return db
}
func task(dbname string, db *sql.DB) {
for {
rows, err := db.Query("select id,info,time from information_schema.PROCESSLIST where time > 5 and command = 'Query';")
if err != nil {
log.Println(err.Error())
dbs[dbname] = init_db(DBS[dbname])
task(dbname, dbs[dbname])
break
}
for rows.Next() {
var id string
var info string
var time string
err = rows.Scan(&id, &info, &time)
if err != nil {
log.Println(err.Error())
} else {
log.Printf("[FOUND SQL]: '%s'@'%s' (ConnectionId: %s, Time: %s)", info, dbname, id, time)
_, err := db.Exec(fmt.Sprintf("kill %s;", id))
if err != nil {
log.Println(err.Error())
} else {
log.Printf("[KILLED SQL]: '%s'@'%s' (ConnectionId: %s, Time: %s)", info, dbname, id, time)
}
}
}
time.Sleep(1 * time.Second)
}
}
func main() {
for dbname, db := range dbs {
go task(dbname, db) //用go关键字创建goroutine
}
c := make(chan int)
}
config.conf
# 配置文件以#开头的为注释
# 配置行 为 数据库昵称和数据库uri的组合，中间以若干空白为分隔
db1(127.0.0.1) root:root.com@tcp(127.0.0.1:3306)/mysql?charset=utf8
vhost1 ds:root.com@tcp(192.2.3.143:3306)/mysql?charset=utf8
看个panic和recover的代码片段。
package main
import (
"fmt"
)
func PanicAndRecover(input string) (res string) {
defer func() {
if p := recover(); p != nil { //从panic中恢复
fmt.Printf("%T, %#vn", p, p)
res = "error" //defer中修改函数的返回值
}
}()
panic(input) //触发panic
return "normal"
}
func main() {
err := PanicAndRecover("ds")
fmt.Println(err)
}
package go_mongo
import (
"gopkg.in/mgo.v2"
"log"
"os"
)
type Mongo struct{
session *mgo.Session
}
func New(murls string) *Mongo {
ms, err := mgo.Dial(murls)
if err != nil {
log.Printf("mgo.Dial, %sn", err)
os.Exit(1)
}
return &Mongo{session: ms}
}
func (self *Mongo) Insert(mdbs string, mcols string, docs ...interface{}) error { //*Mongo类型的方法，docs是可变参数
mdb := self.session.DB(mdbs)
mcol := mdb.C(mcols)
return mcol.Insert(docs...)
}
在main.go中使用包github.com/Hevienz/go-mongo。
main.go
package main
import (
"github.com/Hevienz/go-mongo"
"github.com/Hevienz/go-utils" //下文介绍
"log"
)
func main() {
doc := map[string]interface{}{"ds": "cc"}
m := go_mongo.New("127.0.0.1:27017")
go_utils.Dir(m) //调用go_utils包的Dir方法
err := m.Insert("test", "ds", doc)
if err != nil {
log.Println(err)
}
}
用反射实现类似Python中的build-in函数dir。
https://github.com/Hevienz/go-utils
dir.go
package go_utils
import (
"reflect" //导入反射包
"fmt"
"strings"
)
func Dir(x interface{}) {
v := reflect.ValueOf(x)
t := v.Type()
fmt.Printf("type %sn", t)
for i := 0; i < v.NumMethod(); i++ {
methType := v.Method(i).Type()
fmt.Printf("func (%s) %s%sn", t, t.Method(i).Name,
strings.TrimPrefix(methType.String(), "func"))
}
}
其它重要的特性包括：接口，类型断言，类型分支，channel，互斥锁等，此处不再介绍。