基础语法

Hello World

  1. package main
  3. import "fmt"
  5. func main() {
  6.     fmt.Println("Hello world")
  7. }
  1. print "Hello world"

Print

  1. package main
  3. import "fmt"
  5. func main() {
  6.     fmt.Println("Some string")
  7.     fmt.Print("Some string")
  8.     fmt.Printf("Name: %s, Age: %d\n", "Peter", 35)
  9. }
  1. print "Some string"
  2. print("Some string")  # Python 3
  3. print "Some string",  # no newline character printed
  4. print "Name: %s, Age: %d" % ('Peter', 35)

Comments

  1. package main
  3. // This is a general comment
  5. /* This is also a comment
  6.    but on multiple lines.
  7. */
  9. /* This is the multi-line comment for the function main().
  10.    To get access to this from the command line, run:
  12.      godoc comments.go
  14. */
  16. func main() {
  17. }
  1. """This is a doc string for the whole module"""
  3. # This is a inline comment
  6. class Class(object):
  7.     """This is the doc string for the class"""
  10. print __doc__
  11. print Class.__doc__

Boolean

  1. package main
  3. import "fmt"
  5. func main() {
  6.     fmt.Println(true && false) // false
  7.     fmt.Println(true || false) // true
  8.     fmt.Println(!true)         // false
  10.     x := 1
  11.     if x != 0 {
  12.         fmt.Println("Yes")
  13.     }
  14.     var y []string
  15.     if len(y) != 0 {
  16.         fmt.Println("this won't be printed")
  17.     }
  19. }
  1. print True and False  # False
  2. print True or False  # True
  3. print not True  # False

控制结构

Loop

  1. package main
  3. import "fmt"
  5. func main() {
  6.     i := 1
  7.     for i <= 10 {
  8.         fmt.Println(i)
  9.         i += 1
  10.     }
  12.     // same thing more but more convenient
  13.     for i := 1; i <= 10; i++ {
  14.         fmt.Println(i)
  15.     }
  16. }
  1. i = 1
  2. while i <= 10:
  3.     print i
  4.     i += 1
  6. # ...or...
  8. for i in range(1, 11):
  9.     print i

Range

  1. package main
  3. import "fmt"
  5. func main() {
  6.     names := []string{
  7.         "Peter",
  8.         "Anders",
  9.         "Bengt",
  10.     }
  11.     /* This will print
  13.     1. Peter
  14.     2. Anders
  15.     3. Bengt
  16.     */
  17.     for i, name := range names {
  18.         fmt.Printf("%d. %s\n", i+1, name)
  19.     }
  20. }
  1. names = ["Peter", "Anders", "Bengt"]
  2. for i, name in enumerate(names):
  3.     print "%d. %s" % (i + 1, name)

Switch

  1. package main
  3. import (
  4.     "fmt"
  5.     "strconv"
  6. )
  8. func str2int(s string) int {
  9.     i, err := strconv.Atoi(s)
  10.     if err != nil {
  11.         panic("Not a number")
  12.     }
  13.     return i
  14. }
  16. func main() {
  17.     var number_string string
  18.     fmt.Scanln(&number_string)
  19.     number := str2int(number_string)
  21.     switch number {
  22.     case 8:
  23.         fmt.Println("Oxygen")
  24.     case 1:
  25.         fmt.Println("Hydrogen")
  26.     case 2:
  27.         fmt.Println("Helium")
  28.     case 11:
  29.         fmt.Println("Sodium")
  30.     default:
  31.         fmt.Printf("I have no idea what %d is\n", number)
  32.     }
  34.     // Alternative solution
  36.     fmt.Scanln(&number_string)
  37.     db := map[int]string{
  38.         1:  "Hydrogen",
  39.         2:  "Helium",
  40.         8:  "Oxygen",
  41.         11: "Sodium",
  42.     }
  43.     number = str2int(number_string)
  44.     if name, exists := db[number]; exists {
  45.         fmt.Println(name)
  46.     } else {
  47.         fmt.Printf("I have no idea what %d is\n", number)
  48.     }
  50. }
  1. def input():
  2.     return int(raw_input())
  4. number = input()
  5. if number == 8:
  6.     print "Oxygen"
  7. elif number == 1:
  8.     print "Hydrogen"
  9. elif number == 2:
  10.     print "Helium"
  11. elif number == 11:
  12.     print "Sodium"
  13. else:
  14.     print "I have no idea what %d is" % number
  17. # Alternative solution
  18. number = input()
  19. db = {
  20.     1: "Hydrogen",
  21.     2: "Helium",
  22.     8: "Oxygen",
  23.     11: "Sodium",
  24. }
  25. print db.get(number, "I have no idea what %d is" % number)

函数

可变参函数

  1. package main
  3. import "fmt"
  5. func average(numbers ...float64) float64 {
  6.     total := 0.0
  7.     for _, number := range numbers {
  8.         total += number
  9.     }
  10.     return total / float64(len(numbers))
  11. }
  13. func main() {
  14.     fmt.Println(average(1, 2, 3, 4)) // 2.5
  15. }
  1. from __future__ import division
  4. def average(*numbers):
  5.     return sum(numbers) / len(numbers)
  7. print average(1, 2, 3, 4)  # 10/4 = 2.5

闭包

  1. package main
  3. import "fmt"
  5. func main() {
  7.     number := 0
  9.     /* It has to be a local variable like this.
  10.        You can't do `func increment(amount int) {` */
  11.     increment := func(amount int) {
  12.         number += amount
  13.     }
  14.     increment(1)
  15.     increment(2)
  17.     fmt.Println(number) // 3
  19. }
  1. def run():
  3.     def increment(amount):
  4.         return number + amount
  6.     number = 0
  7.     number = increment(1)
  8.     number = increment(2)
  9.     print number  # 3
  11. run()

常用数据结构

Slice/List

  1. package main
  3. import "fmt"
  5. func main() {
  6.     // initialized array
  7.     var numbers [5]int // becomes [0, 0, 0, 0, 0]
  8.     // change one of them
  9.     numbers[2] = 100
  10.     // create a new slice from an array
  11.     some_numbers := numbers[1:3]
  12.     fmt.Println(some_numbers) // [0, 100]
  13.     // length of it
  14.     fmt.Println(len(numbers))
  16.     // initialize a slice
  17.     var scores []float64
  18.     scores = append(scores, 1.1) // recreate to append
  19.     scores[0] = 2.2              // change your mind
  20.     fmt.Println(scores)          // prints [2.2]
  22.     // when you don't know for sure how much you're going
  23.     // to put in it, one way is to
  24.     var things [100]string
  25.     things[0] = "Peter"
  26.     things[1] = "Anders"
  27.     fmt.Println(len(things)) // 100
  28. }
  1. # initialize list
  2. numbers = [0] * 5
  3. # change one of them
  4. numbers[2] = 100
  5. some_numbers = numbers[1:3]
  6. print some_numbers  # [0, 100]
  7. # length of it
  8. print len(numbers)  # 5
  10. # initialize another
  11. scores = []
  12. scores.append(1.1)
  13. scores[0] = 2.2
  14. print scores  # [2.2]

Map

  1. package main
  3. import "fmt"
  5. func main() {
  6.     elements := make(map[string]int)
  7.     elements["H"] = 1
  8.     fmt.Println(elements["H"])
  10.     // remove by key
  11.     elements["O"] = 8
  12.     delete(elements, "O")
  14.     // only do something with a element if it's in the map
  15.     if number, ok := elements["O"]; ok {
  16.         fmt.Println(number) // won't be printed
  17.     }
  18.     if number, ok := elements["H"]; ok {
  19.         fmt.Println(number) // 1
  20.     }
  22. }
  1. elements = {}
  2. elements["H"] = 1
  3. print elements["H"]  # 1
  5. # remove by key
  6. elements["O"] = 8
  7. elements.pop("O")
  9. # do something depending on the being there
  10. if "O" in elements:
  11.     print elements["O"]
  12. if "H" in elements:
  13.     print elements["H"]

面向对象

Struct/Class

  1. package main
  3. import (
  4.     "fmt"
  5.     "math"
  6. )
  8. type Point struct {
  9.     x float64
  10.     y float64
  11. }
  13. func distance(point1 Point, point2 Point) float64 {
  14.     return math.Sqrt(point1.x*point2.x + point1.y*point2.y)
  15. }
  17. // Since structs get automatically copied,
  18. // it's better to pass it as pointer.
  19. func distance_better(point1 *Point, point2 *Point) float64 {
  20.     return math.Sqrt(point1.x*point2.x + point1.y*point2.y)
  21. }
  23. func main() {
  24.     p1 := Point{1, 3}
  25.     p2 := Point{2, 4}
  26.     fmt.Println(distance(p1, p2))          // 3.7416573867739413
  27.     fmt.Println(distance_better(&p1, &p2)) // 3.7416573867739413
  28. }
  1. from __future__ import division
  2. from math import sqrt
  5. class Point(object):
  6.     def __init__(self, x, y):
  7.         self.x = x
  8.         self.y = y
  11. def distance(point1, point2):
  12.     return sqrt(point1.x * point2.x + point1.y * point2.y)
  15. p1 = Point(1, 3)
  16. p2 = Point(2, 4)
  17. print distance(p1, p2)  # 3.74165738677

方法

  1. package main
  3. import (
  4.     "fmt"
  5.     "math"
  6. )
  8. type Point struct {
  9.     x float64
  10.     y float64
  11. }
  13. func (this Point) distance(other Point) float64 {
  14.     return math.Sqrt(this.x*other.x + this.y*other.y)
  15. }
  17. // Since structs get automatically copied,
  18. // it's better to pass it as pointer.
  19. func (this *Point) distance_better(other *Point) float64 {
  20.     return math.Sqrt(this.x*other.x + this.y*other.y)
  21. }
  23. func main() {
  24.     p1 := Point{1, 3}
  25.     p2 := Point{2, 4}
  26.     fmt.Println(p1.distance(p2))         // 3.7416573867739413
  27.     fmt.Println(p1.distance_better(&p2)) // 3.7416573867739413
  28. }
  1. from __future__ import division
  2. from math import sqrt
  5. class Point(object):
  6.     def __init__(self, x, y):
  7.         self.x = x
  8.         self.y = y
  10.     def distance(self, other):
  11.         return sqrt(self.x * other.x + self.y * other.y)
  14. p1 = Point(1, 3)
  15. p2 = Point(2, 4)
  16. print p1.distance(p2)  # 3.74165738677
  17. print p2.distance(p1)  # 3.74165738677

杂项

Goroutine

  1. package main
  3. import (
  4.     "fmt"
  5.     "io/ioutil"
  6.     "net/http"
  7. )
  9. func f(url string) {
  10.     response, err := http.Get(url)
  11.     if err != nil {
  12.         panic(err)
  13.     }
  14.     defer response.Body.Close()
  15.     body, err := ioutil.ReadAll(response.Body)
  16.     if err != nil {
  17.         panic(err)
  18.     }
  20.     fmt.Println(len(body))
  21. }
  23. func main() {
  24.     urls := []string{
  25.         "http://www.peterbe.com",
  26.         "http://peterbe.com",
  27.         "http://htmltree.peterbe.com",
  28.         "http://tflcameras.peterbe.com",
  29.     }
  30.     for _, url := range urls {
  31.         go f(url)
  32.     }
  33.     // necessary so it doesn't close before
  34.     // the goroutines have finished
  35.     var input string
  36.     fmt.Scanln(&input)
  37. }
import urllib2
import multiprocessing

def f(url):
    req = urllib2.urlopen(url)
    try:
        print len(req.read())
    finally:
        req.close()


urls = (
    "http://www.peterbe.com",
    "http://peterbe.com",
    "http://htmltree.peterbe.com",
    "http://tflcameras.peterbe.com",
)

if __name__ == '__main__':
    p = multiprocessing.Pool(3)
    p.map(f, urls)

运行时参数

package main

import (
    "fmt"
    "os"
    "strings"
)

func transform(args []string) {
    for _, arg := range args {
        fmt.Println(strings.ToUpper(arg))
    }

}
func main() {
    args := os.Args[1:]
    transform(args)
}

import sys


def transform(*args):
    for arg in args:
        print arg.upper()

if __name__ == '__main__':
    transform(*sys.argv[1:])

import 别名

package main

import (
    "fmt"
    s "strings"
)

func main() {
    fmt.Println(s.ToUpper("world"))
}

import string as s

print s.upper("world")