Sword York – Slinuxer

Go接触

2019/04/112019/04/12 Sword York 2 条评论

最近有时间也有必要接触了Go，也有很多原因

大三的时候就想学学Go，不过由于Python耽搁了
Python的并发让我头很疼，一点也不优雅，而Go的天然并发早声名在外
业务需求
多学一门语言，提升自己的竞争力

Go的特点

学习Go几乎没有阻碍，跟着A Tour of Go一步步学下来就行。光学怎么写Go就太枯燥了。我顺便了解了一下Go，很多内容在wiki中已经说得很清楚。总结一下，

Go是静态类型，与C/C++类似，不同于Python，因此性能肯定比基于解释器的Python高。Go有垃圾回收机制、天然并发，写起来就很舒服，代价是性能肯定没有C那么高，看到一句话很有意思：Informally, Go is 50% of C’s performance (which is still really good) for 0% of the headaches.
Go这个名字取得很好，Go由Google成员开发，Go是围棋，也是gopher(鼹鼠)，为什么gopher是吉祥物？只能解释为男人的浪漫了。
Go是面向多核的语言，也就是面向未来。Go在Google中也有不少应用，我只找到古老的资料，Rob Pike的演讲、Quora的问答、关于dl.google.com的故事也很有意思。
Go没有类，但有结构体，我喜欢这点。
Go有指针，太棒了。
Go的interface设计太巧妙了。
Go的goroutine就不用说了，强、优雅。但我目前不知道CSP的细节。
Go的包管理很出色。

体验了2天Go，我无法找到Go的缺点，即使是缺点在我看来也是优点（没有面向对象）。当然Go是否是面向对象的也很难说，可以看看这篇讨论，反正我是认为这是Go的优点。我已经把Go列为第二优先语言了，学了Go可能就不用再学C/C++了。

学习和使用Go的同时能开拓新的思考方式、思维模式，就像学外语一样，思维方式会得到提升。而Go带来的思维改变就是思考要并发。当然并发不是并行，这个可以看Rob Pike的演讲，还有关于并发模式的演讲。形象的说，并发是一个人可以一边吃饭一边喝水，可以随时切换，而并行一般是做同样的事，比如左手和右手同时转笔。我觉得并发有并行的意思，可能之后还要深入理解一下，不过理解了也没啥用。

Go的并发

Go其他部分比较简单，随便学学就行，我觉得并发是Go的精髓。Go的并发很好用很优雅，可以看看性能如何。我将Go与我常用，让我头疼的Python作了对比。首先是裸的并发，就算个加法，也不join，只看起并发的开销。

import threading
import time

def add(left, right):
    return left + right

def plain_thread(n):
    for i in range(n):
        t = threading.Thread(target=add, args=(0, 0))
        t.start()
    return 0

if __name__ == "__main__":
    n = 8000
    start_time = time.time()
    ret = plain_thread(n)
    total_time = (time.time() - start_time) * 1000
    print(ret, total_time, total_time / n)

import threading

import time

def add(left, right):

return left + right

def plain_thread(n):

for i in range(n):

t = threading.Thread(target=add, args=(0, 0))

t.start()

return 0

if __name__ == "__main__":

n = 8000

start_time = time.time()

ret = plain_thread(n)

total_time = (time.time() - start_time) * 1000

print(ret, total_time, total_time / n)

package main

import (
   "fmt"
   "time"
)

func add(left, right int) int {
   return left + right
}

func plainThread(n int) int {
   for i := 0; i < n; i++ {
      go add(0, 0)
   }
   return 0
}

func main() {
   const cs = 8000
   startTime := time.Now().UnixNano()
   finalV := plainThread(cs)
   totalTime := float64(time.Now().UnixNano() - startTime) / 1e6
   fmt.Println(finalV, totalTime, totalTime / cs)
}

package main

import (

"fmt"

"time"

)

func add(left, right int) int {

return left + right

}

func plainThread(n int) int {

for i := 0; i < n; i++ {

go add(0, 0)

}

return 0

}

func main() {

const cs = 8000

startTime := time.Now().UnixNano()

finalV := plainThread(cs)

totalTime := float64(time.Now().UnixNano() - startTime) / 1e6

fmt.Println(finalV, totalTime, totalTime / cs)

}

虽然这个比较不科学，但也可以跑一下试试。

接下来跑个需要同步的，用到了并发常用的queue或channel。

import queue
import threading
import time

def daisy_add(left, right):
    item = right.get()
    left.put(item + 1)

def daisy_chain(n):
    leftmost = queue.Queue()
    right = leftmost
    left = leftmost
    
    for i in range(n):
        right = queue.Queue()
        t = threading.Thread(target=daisy_add, args=(left, right))
        t.start()
        left = right
    
    right.put(1)
    r = leftmost.get()
    return r

if __name__ == "__main__":
    n = 8000
    start_time = time.time()
    ret = daisy_chain(n)
    total_time = (time.time() - start_time) * 1000
    print(ret, total_time, total_time / n)

import queue

import threading

import time

def daisy_add(left, right):

item = right.get()

left.put(item + 1)

def daisy_chain(n):

leftmost = queue.Queue()

right = leftmost

left = leftmost

for i in range(n):

right = queue.Queue()

t = threading.Thread(target=daisy_add, args=(left, right))

t.start()

left = right

right.put(1)

r = leftmost.get()

return r

if __name__ == "__main__":

n = 8000

start_time = time.time()

ret = daisy_chain(n)

total_time = (time.time() - start_time) * 1000

print(ret, total_time, total_time / n)

package main

import (
   "fmt"
   "time"
)

func daisyAdd(left, right chan int) {
   left <- 1 + <- right
}

func daisyChain(n int) int {
   leftmost := make(chan int)
   right := leftmost
   left := leftmost

   for i := 0; i < n; i++ {
      right = make(chan int)
      go daisyAdd(left, right)
      left = right
   }

   //go func(c chan int) { c <- 1}(right)
   right <- 1
   finalV := <- leftmost
   return finalV
}

func main() {
   const cs = 8000
   startTime := time.Now().UnixNano()
   finalV := daisyChain(cs)
   totalTime := float64(time.Now().UnixNano() - startTime) / 1e6
   fmt.Println(finalV, totalTime, totalTime / cs)
}

package main

import (

"fmt"

"time"

)

func daisyAdd(left, right chan int) {

left <- 1 + <- right

}

func daisyChain(n int) int {

leftmost := make(chan int)

right := leftmost

left := leftmost

for i := 0; i < n; i++ {

right = make(chan int)

go daisyAdd(left, right)

left = right

}

//go func(c chan int) { c <- 1}(right)

right <- 1

finalV := <- leftmost

return finalV

}

func main() {

const cs = 8000

startTime := time.Now().UnixNano()

finalV := daisyChain(cs)

totalTime := float64(time.Now().UnixNano() - startTime) / 1e6

fmt.Println(finalV, totalTime, totalTime / cs)

}

上面两段代码极其相似，这也让我对channel的理解深了一点，功能上就相当于Python中的queue。粗略一测，Go和Python时间性能相差30倍。另外，这段代码中，Python在我的电脑上起不了10000个线程，Go可以起1000000个，我还没测Go的上界。

为什么goroutine这么好用？我搜索了一下，发现很多好的资源，

goroutine和thread的对比，佩服写得好
goroutine不是轻量线程，Rob Pike也说了，理解这点很重要。看了这个说明，完全就理解了

总结

以上是我接触了2天Go写的胡言乱语，希望以后看到不会脸红。总之，Go是不错的语言，值得学习。特别是现在很多情景对并发的需求越来越大、C/C++等语言的设计考虑、硬件的分布式等，Go就是顺应时代潮流的产物，Google还是爸爸。

感叹一句，什么时候我才能那么屌？

参考

Analysis of the Go runtime scheduler，以后看
Five things that make Go fast，很有深度，看了之后脑子炸了，还有一系列

去年与未来

2018/12/312018/12/31 Sword York 3 条评论

2018年我终于毕业开始工作了。还好当年家里穷，没有选择物理系，否则就与计算机无缘了。一年年的人生经验积累下来，发现自己干的蠢事、令自己回想起来尴尬不已的事、令别人当场窒息的事越来越少。随着年龄的增长，我也发现自己的计算能力慢慢下滑，还好目前的经验增长完全可以抵消算力的下降。2018年我学会了很多技能，一条条来说。

绘画

创造自己理想的二次元对象是我几年来一直想干的事，苦于时间、设备以及其他因素，一直没有付诸行动。我自认为我是绘画天才，尤其对色彩的把控简直天生精准。缺点是，我是写实主义的，追求精确的形与结构，缺乏想象力，创造性不强。为避免老了学得太慢，我在今年年初，终于找到了时间，开始绘画。借助网络、各路大触的教学，我画了一个月，走完了用笔、复印、抄袭、临摹和创作的过程。总共画了10副图，其中有两幅比较有代表性。左图是我情感想画的，右图是我理智想画的。

希望老了还有欲望画这样的图，不得不说，我真的是天才。

拍照

由于要去日本玩，所以搞了相机。不过相机是我大三就想买的，苦于没有时间和金钱，一直拖到了今年。我已经按下了7813次快门，其中10%的照片不错到可以给别人看，另20%的照片自己觉得不错，还有10-20%的照片是全景或延迟摄影的额外文件。这样算下来，也就是约50%的快门是浪费的。我不敢说自己是摄影的，只敢说自己是拍照的。因为我的照片都需要经过修改。当然我不会过分修改，P图的原则是改变色彩、保留结构。照片中的人（无意义的人）不属于结构，属于需要抹去的噪点。这么多照片中，有一组我不得不亮出来。

这不是说图3有多好看，而是化腐朽为神奇的过程。不要因为表面的难看，而错过内在的好看。希望我能保持这样的眼光，无论对照片、对风景还是对人，要拓展发现美的能力。

日语

我也抽出了不少时间学习日语，虽然差18分考过N2，我已经心满意足，至少我能知道机器翻译错在哪里，目前来说足够了。明年我希望接触韩语，比较简单一点，顺便学习印地语。我深知自己的语言天赋实在没有，跟绘画天赋一比就是负的。不过，不能躺在舒适区，有天赋的要突破极限，没天赋的要达到平均。韩语是2年计划，印地语是20年计划，印度可能就是未来的中国，或许将来需要跟印度人打交道，准备可以先做起来（开个玩笑）。主要是想对比一下，印度文化和中华文明，为什么会产生差距。

视频制作

爱因斯坦会弹小提琴，我语言天赋没有，音乐就不用说了。我只能朝另外的方向发展，别提书法，写的字就像画的。视频是一个方向，视频就是连续的画，也涉及光影、色彩。今年，我做了几个傻视频放抖音，获得了尴尬的点赞，希望明年能熟练运用AE和PR，获得百赞。

以上这些技能基本上都跟目前的工作无关，跟工作相关的基本上就是机器翻译。工作在有条不紊地进行，具体也不便说明。团队中的同事知道自己强在哪、弱在哪，这是值得庆幸的。头条还是很不错的厂，我做着自己喜欢的事、自己想做的事，还可以拿钱，感觉人生已经到达了巅峰。

毕业本可以拿上海或者北京户口，但是我没有行动，家里有地只是一个原因。如果没有地，我慎重思考之后，基本上也不会放弃我的农村户口。大家都在随波逐流，大家根本没有思考过户籍制度的不合理性。希望在我有生之年，这个等级划分可以取消。目前，我会拿一些不科学的事实安慰自己，江浙人才辈出，北京呢？等。希望我这个随便做的决定，不会在将来引起太大的麻烦。

另外，今年也到了几个地方，日本、海南、杭州、北京、上海、苏州。明年我想去祖国的西边，如成都、重庆、武汉、长沙，日本肯定要再去一次。

毕业之后，身边的好友、打dota的好友换了一波。这是好事也是坏事，证明我不是一滩死水。

希望明年我的博客能月更。

Python再入门

2018/12/312018/12/31 Sword York 评论

会用一门语言写代码并不能说是掌握了这门语言，尤其是入门容易的语言，掌握起来更困难。你说你会用汇编写程序，我可以承认你掌握了汇编语言，而你说会用Python写程序，十有八九真的只是会写而已。

有基础的哥们，Python能在3分钟内入门，其他解释性语言也是如此，不用花太多时间，就能说我会了，只要能让我查google。我从大一（2011）开始接触Python，几乎每个月都在学新的内容。当然，我新学的内容不是Pythonic。

Python基础库

我很久以前买了一本很厚的《Python标准库》，结果才看了不到100页。最近，我才真正认识到标准库的作用。此处，我不会考虑Python 2，我只会Python 3。

unicodedata

unicodedata对我这样的多语言工作者还是比较有用的，目前这个库只提供了各个unicode字符所属的类别，如’我’是符号类别(‘Lo’)，’1’是数字类别(‘Nd’)，这样我就不用翻wikipedia了。不过，这个库也没有完全满足我的需求，经常需要查阅unicode各个块（unicode_block）的信息。

collections

提供了除基础容器list,tuple,dict，set以外的容器，我比较常用的是namedtuple和defaultdict。defaultdict就是在赋值的时候不用手动初始化，考虑简单的计数问题（仅仅是实例，可以用counter）。

c = collections.defaultdict(int)
c[0] += 1

1 2	c = collections.defaultdict(int) c[0] += 1

复杂一点的，如针对各个字符串统计各字符数的defaultdict，也就是defaultdict的defaultdict。

d = collections.defaultdict(lambda :collections.defaultdict(int))
d['hello']['l'] += 1

1 2	d = collections.defaultdict(lambda :collections.defaultdict(int)) d['hello']['l'] += 1

array

与list类似，不过array的数据存储更加原生，而且array中的数据类型得一致，就像C/C++一样。看例子就明白了。

import sys
import array

a = [x for x in range(10000)]
b = array.array('i', a)

print(sys.getsizeof(a[1]))  # 28
print(sys.getsizeof(a))  # 87624
print(sys.getsizeof(b))  # 40064

import sys

import array

a = [x for x in range(10000)]

b = array.array('i', a)

print(sys.getsizeof(a[1])) # 28

print(sys.getsizeof(a)) # 87624

print(sys.getsizeof(b)) # 40064

此处我反正是搞不懂为啥a只用87624个bytes，这乘法不对啊。40064就容易理解多利，10000个整数，每个4 bytes，加上数据结构64 bytes，这个空间直接省了1半。当然也可以用numpy。

linecache

随机读取文件行，小文件可以，大文件直接内存爆炸。

timeit

规范的测试几行代码速度的工具，使用也很方便。

python -m timeit "5+8"

1	python -m timeit "5+8"

operator

我曾经一直不理解operator的用处，跟内置的运算符重复，实在没有，也可以使用lambda。后来我搜索了一下，stackoverflow,stackoverflow2，给了我一点启示。主要出于速度、代码可读性、以及picklable考虑。关于速度可以简单测试如下，

$ python -m timeit "5+8"                                    
50000000 loops, best of 5: 5.61 nsec per loop
$ python -m timeit -s "from operator import add"  "add(5,8)"
10000000 loops, best of 5: 33.7 nsec per loop
$ python -m timeit "(lambda x,y: x+y)(5,8)"                 
2000000 loops, best of 5: 107 nsec per loop

$ python -m timeit "5+8"

50000000 loops, best of 5: 5.61 nsec per loop

$ python -m timeit -s "from operator import add" "add(5,8)"

10000000 loops, best of 5: 33.7 nsec per loop

$ python -m timeit "(lambda x,y: x+y)(5,8)"

2000000 loops, best of 5: 107 nsec per loop

itertools

与operator一样，属于函数式编程模块。借鉴了Haskell等语言的思想，实现了大量高效、内存友好的迭代工具，与operator相辅相成。官方介绍中也提供了很多例子。我用得最多的居然是chain.from_iterable()，我觉得我得改。takewhile这些都很不错。

itertools.takewhile(lambda x: x<5, [1,4,6,4,1])

1	itertools.takewhile(lambda x: x<5, [1,4,6,4,1])

functools

与上面两个一样，属于函数式编程模块。其中的lru_cache是比较典型的操作，能很好的解释functools。另外wraps也是常用的，其他几个我还没有使用过。

import functools
import time

@functools.lru_cache(maxsize=1024)
def fibonacci(n):
    if n<=1:
        return n
    return fibonacci(n-1)+fibonacci(n-2)

start_time = time.time()
fibonacci(100)
print(time.time() - start_time)

def fibonacci(n):
    if n<=1:
        return n
    return fibonacci(n-1)+fibonacci(n-2)

start_time = time.time()
fibonacci(32)
print(time.time() - start_time)

import functools

import time

@functools.lru_cache(maxsize=1024)

def fibonacci(n):

if n<=1:

return n

return fibonacci(n-1)+fibonacci(n-2)

start_time = time.time()

fibonacci(100)

print(time.time() - start_time)

def fibonacci(n):

if n<=1:

return n

return fibonacci(n-1)+fibonacci(n-2)

start_time = time.time()

fibonacci(32)

print(time.time() - start_time)

typing

使用type hints可以帮助我们在编码时就发现bug，当然借助的是ide的提示。mypy也可以进行代码检查，可以告知哪里类型有问题，可以及时发现处理。

def greeting(name: str) -> str:
    return 'Hello ' + name

1 2	def greeting(name: str) -> str: return 'Hello ' + name

其他

其他很多库，如heapq,bisect,re,threading,multiprocessing,profile,pdb,json等都是非常常用好用的库。如果能灵活使用这些库，必定能提供编码效率。此处效率包括编程速度和运行速度。估计我也就掌握了1/10左右。

每个半年回过头看自己写的老代码，总感觉非常羞耻，想推倒重来。我觉得这是好事，说明人还在进步学习。希望还能保持这个速度。

链接

Python 3基础库

作者：Sword York

Go接触

Go的特点

Go的并发

总结

参考

去年与未来

绘画

拍照

日语

视频制作

Python再入门

Python基础库

unicodedata

collections

array

linecache

timeit

operator

itertools

functools

typing

其他

链接

近期文章

近期评论

分类目录