py2exe可以将python程序打包成exe，方便没有python环境的用户使用。 在目录下建立py文件setup.py写入代码：

#-*- coding:utf-8 -*-
from distutils.core import setup
import glob
import py2exe,sys,os

options = {"py2exe":
           {"dll_excludes": ["MSVCP90.dll"],
            "compressed": 1, #压缩
            "optimize": 2,
            #"ascii": 1,
            #"includes":includes,
            "bundle_files": 1 #所有文件打包成一个exe文件 }
            }
           }
setup(windows=[{"script": "mp3.py","icon_resources": [(1,"mp3.ico")]}],

      options=options,
      zipfile=None,#不生成library.zip文件

      )

学习golang来自己写的代码，先贴出来。

package main
import (
    "fmt"
    "os"
    "errors"
    "strings"
)
//no tag 
var ErrFormat = errors.New("No TAG!")
type Mp3 struct{
    //the file attr
    Name string
    Size int64
    //the mp3 attr
    Title string
    Artist string
    Album string
    Year string
    Comment string
    Genre uint8
}
func (m *Mp3) PrintInfo(){
    fmt.Printf("%v:\n",m.Name)
    fmt.Printf("size:%v\ntitle:%v\nartist:%v\nalbum:%v\nyear:%v\ncomment:%v\n",m.Size,m.Title,m.Artist,m.Album,m.Year,m.Comment)
    fmt.Printf("genre:%v",m.Genre)
}
func (m *Mp3) GetInfo(filename string) (err error){
    id3 := make([]byte,128)
    //for read access.
    f,err := os.Open(filename)
    if err != nil{
        return
    }
    defer f.Close()
    //return FileInfo
    fileInfo,err := f.Stat()
    if err != nil{
        return
    }
    //the file size,int64
    m.Size = fileInfo.Size()
    //the file name,string. eq filename
    m.Name = fileInfo.Name()
    //if
    _,err = f.ReadAt(id3,m.Size-128)
    if err != nil{
        return
    }
    tag := string(id3[:3])
    if tag != "TAG"{
        //err  "No ID3~"
        return ErrFormat
    }
    m.Title = strings.Trim(string(id3[3:33]),"\x00")
    m.Album = strings.Trim(string(id3[33:63]),"\x00")
    m.Artist = strings.Trim(string(id3[63:93]),"\x00")
    m.Year = string(id3[93:97])
    m.Comment = strings.Trim(string(id3[97:127]),"\x00")
    m.Genre = uint8(id3[127])
    return nil
}
func main(){
    m := new(Mp3)

    f,err := os.Open(".")
    if err != nil{
        fmt.Print(err)
    }
    defer f.Close()
    names,err := f.Readdirnames(-1)
    if err != nil{
        fmt.Print(err)
    }
    for _,name := range names{
        a := strings.Split(name,".")
        fileExt := strings.ToLower(a[len(a)-1])
        //fmt.Print(i,fileExt)
        if fileExt == "mp3"{
            err = m.GetInfo(name)
            if err != nil{
                fmt.Print(name,err)
            }
            m.PrintInfo()
        }
    }
    //fmt.Printf("%v",names)
}

名字服务 功能：向服务器提交一个名字，然后服务器返回一个与这个名字关联的值。

-module(kvs).
-export([start/0,store/2,lookup/1]).

start() -> register(kvs,spawn(fun() -> loop() end)).
store(Key,Value) -> rpc({store,Key,Value}).
lookup(Key) -> rpc({lookup,Key}).

rpc(Q) ->
    kvs ! {self(),Q},
    receive
        {kvs,Reply} ->
            Reply
    end.
loop() ->
    receive
        {From,{store,Key,Value}} ->
            put(Key,{ok,Value}),
            From ! {kvs,true},
            loop();
        {From,{lookup,Key}} ->
            From ! {kvs,get(Key)},
            loop()
    end.

1.带超时的receive。 防止消息不来，receive语句陷入无限等待中。   只有超时的receive 功能：让当前进程暂停Tms。

sleep(T) ->
    receive
    after T ->
        true
    end.

flush_buffer() ->
    receive
        _Any ->
	    flush_buffer()
    after 0 ->
        true
    end.

priority_receive() ->
    receive
        {alarm,X} ->
	    {alarm,X}
    after 0 ->
        receive
	    Any ->
	        Any
	end
    end.

golang接口代码：

package main
import "fmt"
type S struct {
    i int
}
func (p *S) Get() int {
    return p.i
}
func (p *S) Put(v int){
    p.i = v
}
type I interface{
    Get() int
    Put(int)
}
func f(p I){
    fmt.Println(p.Get())
    p.Put(1)
}
func main(){
    var s S
    f(&s)
    fmt.Println(s.Get())

}

package main
import "fmt"
type S struct {
    i int
}
func (p *S) Get() int {
    return p.i
}
func (p *S) Put(v int){
    p.i = v
}
type I interface{
    Get() int
    Put(int)
}
func f(p I){
    fmt.Println(p.Get())
    p.Put(1)
}
func g(something interface{}){
    if t,ok := something.(I); ok{
        fmt.Println("I:",t.Get())
    }else if t,ok := something.(int); ok{
        fmt.Println("int:",t)
    }else{
        fmt.Println("not found:",something)
    }
}
func h(something interface{}){
    switch t:=something.(type){
        case I:
            fmt.Println("I:",t.Get())
        case int:
            fmt.Println("int:",t)
        case *S:
            fmt.Println("S:",t.Get())
        default:
            fmt.Println("not found:",something)
    }
}
func main(){
    var s S
    f(&s)
    fmt.Println(s.Get())
    g(&s)
    h(&s)
    i := 6
    g(i)
    h(i)
}

方法：面向对象的味道 go代码：

package main
import (
    "fmt"
    "math"
)

type Rectangle struct{
    width,height float64
    rarea float64
}
type Circle struct{
    radius float64
}

func (r Rectangle) area() float64{
    return r.width * r.height
}
func (c Circle) area() float64{
    return c.radius * c.radius *math.Pi
}
func (r *Rectangle) setarea(a float64) {
    r.rarea = a
}
func (r Rectangle) setarea2(a float64) (Rectangle){
    r.rarea = a
    return r
}

func main(){
    r1 :=Rectangle{12,2,0}
    r1.setarea(r1.area())
    fmt.Println(r1.rarea)

    r2 := Rectangle{3,4,0}
    newr2 := r2.setarea2(r2.area())
    fmt.Println(r2.rarea)
    fmt.Println(newr2.rarea)
    c1 := Circle{10}
    c2 := Circle{2}
    fmt.Println("r1:",r1.area())
    fmt.Println(r2.area())
    fmt.Println(c1.area())
    fmt.Println(c2.area())

}

package main
import "fmt"

type Human struct{
    name string
    age int
    phone string
}
type Employee struct{
    Human//Human类型的匿名字段
    speciality string
    phone string
}

func main(){
    Bob := Employee{Human{"bob",34,"777777-3"},"designer","33-22"}
    fmt.Println(Bob.name)
    fmt.Println(Bob.phone)
    fmt.Println(Bob.Human.phone)
    fmt.Println(Bob.Human.name)
}

package 包名约定使用小写字符。包中的函数名以大写字母开头的是可导出函数，小写字母是私有函数。这个规定同样适用于新类型、全局变量。 当包导入（通过import）时，包名成为了内容的入口。在 import "bytes" 之后，导入包的可以调用函数bytes.Buffer。任何使用这个包的人，可以使用同样的名字访问到它的内容，因此这样的包名是好的：短的、简洁的、好记的。 根据规则，包名是小写的一个单词；不应当有下划线或混合大小写。由于每个人都可能需要录入这个名字，所以尽可能的简短。不要提前考虑冲突。 包名是导入的默认名称。 在Go中使用混合大小写MixedCaps或者mixedCaps，而不是下划线区分含有多个单词的名字。 包文档： 每个包都应该有包注释，在package 前的一个注释块。对于多文件包，包注释只需要出现在一个文件前，任意一个文件都可以。 包注释应当对包进行介绍，并提供相关于包的整体信息。这会出现在go doc生成的关于包的页面上，并且相关的细节会一并显示。 每个定义（并且导出）的函数应当有一小段文字描述该函数的行为。 常用包：http://golang.org/pkg/ 指针 go有指针，没有指针运算。一个新定义的没有指向的指针值为nil。

package main
import "fmt"

func main(){
var p *int
fmt.Printf("%v\n",p)
fmt.Printf("%T\n",p)
var i int
p = &i
fmt.Printf("%v\n",p)
*p =8
fmt.Printf("%v\n",*p)
}

type person struct {
    name string
    age int
}

var P person
P.name = "Tom" // Assign "Tom" to P's name field.
P.age = 25 // Set P's age to 25 (an int).
fmt.Println("The person's name is %s", P.name)

package main
import "fmt"

type person struct{
    name string
    age int
}

func main(){
    a := new(person)
    a.name = "wang"
    a.age = 42
    b := person{"Tom",11}
    c := person{"rose",44}
    fmt.Printf("%v,%v,%v",a,b,c)
}

函数 golang作用域，定义在函数外的变量是全局的，函数内部定义的变量是局部的。如果一个局部变量和一个全局变量有相同的名字，在函数执行的时候，局部变量将覆盖全局变量。

package main
var a=6
func main(){
p()
q()
p()
}

func p(){
println(a)
}
func q(){
    //a := 5//定义变量
    a = 5//变量赋值
    println(a)
}

package main
var a int
func main(){
    a=5
    println(a)
    f()
}

func f(){
    a := 6
    println(a)
    g()
}
func g(){
    println(a)
}

package main

func nextInt(b []byte, i int) (int, int){
    x :=0
    for ; i

定义一个函数，传递一个byte数组和一个位置i，返回两个int类型。

看到golang的格言： 用更少的代码做更多的事

延迟代码defer。
在defer后指定的函数会在函数退出前调用。

func ReadWrite() bool{
file.Open("file")
//do something
if failureX{
file.Close()
return false
}
if failureY{
file.Close()
return false
}
file.Close()
return true
}
可以用defer修改为：
func ReadWrite() bool{
file.Open("file")
defer file.Close()
//do something
if failureX{
return false
}
if failureY{
return false
}
return true
}
函数在退出前会执行file.Close()
延迟的函数是按照后进先出的顺序执行。
for i:=0;i<5;i++{
defer fmt.Print("%d",i)
}
defer可以修改返回值。
package main
func f() (ret int){
    println(ret)
    defer func(){
        ret++
    }()
    return 0
}
func main(){
    println(f())
}
将输出1，ret是一个int型的命名返回值，这个不要看错了。

变参

例子代码：
package main

func myfunc(arg ...int){
    for _,n := range arg{
        println(n)
    }
}
func main(){
    myfunc(1,2,3,4,5)
}
将打印所有参数。arg ...int说明这个函数接受不定数量的参数。参数类型全部是int。在函数体中，变量arg是一个int类型的slice。

函数作为值
package main
import "fmt"
func main(){
    a := func(){
        println("hello")
    }
    a()//
    fmt.Printf("%T",a)
}
先定义一个匿名函数，赋值给a,然后调用函数a()，下面语句是输出a的类型。

接受函数作为参数的函数

回调

Panic和Recover
golang没有像Java那样的异常机制：不能抛出异常。作为替代，使用panic和recover机制。这要作为最后手段使用。
没看懂。。。

array array由[n]定义，n标示array长度，type是类型。 var arr [10]int arr[0] = 42 arr[1] = 13 当向函数内传递一个数组的时候，会获得一个数组的副本，而不是数组的指针。 声明数组时，必须在方括号内输入一些内容：数字或者三个点。三个点，go会自动统计元素个数。 a:= [2][2]int{[2]int{1,2},[2]int{3,4}} a:= [2][2]int{[...]int{1,2},[...]int{3,4}} 或者 a:= [2][2]int{{1,2},{3,4}}//当元素复合声明的类型和外部一致时 slice slice与数组区别，slice可以怎讲啊长度，slice总是指向底层的一个array。slice是指向array的指针。slice是引用类型的，当一个函数需要一个slice参数，函数内对slice修改。slice总是与一个固定长度的array承兑出现。 int:var array[m]int //创建一个m个元素的array。 slice := array[0:n] 几个长度 len(slice)==n cap(slice)==m len(array)==cap(array)==m map 定义map的方法：map[] monthdays := map[string]int{ "Jan":31,"Feb":28, } 最后一个逗号是必须的。 先写到这里了，准备粗略把教程看完。原因是现在用golang学习语法时，太麻烦了。每次都是修改源文件--打开shell--go run，感觉要受不了了，决定写一个像python在shell里一样方便的东西学习语法。

放在同一行的多个语句，必须用分号分隔。 变量的类型在变量名后面。 var a int var b bool a = 15 b = false 等价： a := 15 b := false 多个var声明可以成组。 var{ x int b bool } 同样适用于const和import。 相同类型的多个变量可以在一行内完成声明： a,b := 20,16 一个特殊的变量名_（下划线），任何赋值给他的值都被丢弃。 _,b := 34,35 golang编译器对声明却未使用的变量报错。 变量名 declared and not used。 布尔类型： true和false 数字类型： int ，根据硬件决定长度。32位硬件是32位，64位为64.也可以明确其长度，完整的整数类型表; int8,int16,int32,int64 byte, uint8,uint16,uint32 uint64.byte是uint8的别名。 浮点型有float32，float64（没有float类型）。 64位的整数和浮点数都是64位的，即便是在32位的架构上。这些类型全部独立，混合这些类型向变量赋值引起编译器错误。 常量：只能是数字、字符串和布尔值。可以使用iota生成枚举值。 const( a = iota b = iota ) 第一个iota表示0，因此a为0，当iota再次进行新的一行使用时，值增加1，b的值为1. 可以省略重复的iota。 const( a = iota b ) 字符串： string s := "hello world!" go中字符串是UTF-8的由双引号包裹。单引号表示一个字符，不是string。一旦给变量赋值，字符串就不能修改了。 一下做法非法： var s string = "hello" s[0] = 'c' go中实现的方法：

s := "hello"
c := []byte(s) //转换s为字节数组
c[0] = 'c' //修改数组
s2 := string(c) //创建新字符串

//错误写法：
s := "starting part"
    + "ending part"
//会被转换成
s := "starting part";
    + "ending part";
//正确写法
s := "starting part" + 
    "ending part"
//另一种写法，使用`反引号作为原始字符串符号
s := `starting part
    ending part`
//最后一个s将包含换行。在原始字符串标识中的值字符是不转义的。
//可以写一个例子，将上面修改为：
s := `starting \n part
ending part`
fmt.Printf("%s",s)
//会发现starting和part间没有换行而是‘\n’