读书笔记 on 古思乱想

PostgreSQL jsonb 使用入门

Thu, 30 May 2019 21:05:57 +0800

postgresql json jsonb 使用入门

并发模型：线程与锁

Sun, 19 May 2019 20:29:39 +0800

并发模型：线程与锁

垃圾回收算法|引用计数法

Sun, 12 Aug 2018 19:15:05 +0800

垃圾回收算法|引用计数法

垃圾回收算法|GC标记-清除算法

Sat, 21 Jul 2018 11:15:05 +0800

垃圾回收算法|标记-清除算法

Golang 学习笔记-2：控制流

Tue, 17 Apr 2018 23:49:35 +0800

golang 学习笔记控制流

《理解 unix 进程》笔记-1

Sun, 25 Mar 2018 23:25:53 +0800

description

操作系统线程描述

Sat, 24 Mar 2018 12:25:53 +0800

description

操作系统进程描述

Tue, 20 Mar 2018 23:25:53 +0800

description

操作系统发展和进程简介

Wed, 07 Mar 2018 23:25:53 +0800

description

Python 字典

Sun, 03 Dec 2017 23:05:27 +0800

字典方法，如何处理查不到的键，标准库中 dict 的变种，散列表的工作原理

Python 元组和分片

Sun, 10 Sep 2017 14:05:27 +0800

元组，切片以及对序列的一系列操作

Python 列表推导及优先级队列的实现

Sun, 03 Sep 2017 14:05:27 +0800

列表、列表推导有关的话题，最后演示如何用列表实现一个优先级队列

Python 装饰器使用指南

Tue, 15 Aug 2017 22:41:51 +0800

装饰器是可调用的对象，其参数是另一个函数（被装饰的函数）。

装饰器基础知识

首先看一下这段代码

def deco(fn):
 print "I am %s!" % fn.__name__

@deco
def func():
 pass

# output
I am func!

# 没有执行func 函数 但是 deco 被执行了

HUGOMORE42

在用某个@decorator来修饰某个函数func时

@decorator
def func():
 pass

其解释器会解释成下面这样的语句：

func = decorator(func)

其实就是把一个函数当参数传到另一个函数中，然后再回调，但是值得注意的是装饰器必须返回一个函数给func

装饰器的一大特性是，能把被装饰的函数替换成其他函数。第二大特性是，装饰器在加载模块时立即执行。

装饰器何时执行

装饰器的一个关键特性是，它们在被装饰的函数定义后立即运行。这通常在导入是（python 加载模块时）。

看下下面的示例：

registry = [] # registry 保存被@register 装饰的函数的引用

def register(func): # register 的参数是一个函数
 print('running register(%s)' % func) # 打印被装饰的函数
 registry.append(func) # 把 func 存入 `registery`
 return func # 返回 func：必须返回函数，这里返回的函数与通过参数传入的一样

@register # `f1` 和 `f2`被 `@register` 装饰
def f1():
 print('running f1()')

@register
def f2():
 print('running f2()')

def f3(): # <7>
 print('running f3()')

def main(): # main 打印 `registry`，然后调用 f1()、f2()和 f3()
 print('running main()')
 print('registry ->', registry)
 f1()
 f2()
 f3()

if __name__=='__main__':
 main() # <9>

运行代码结果如下：

CSS入门指南-3：定位元素

Wed, 26 Jul 2017 22:21:49 +0800

这是《CSS设计指南》的读书笔记，用于加深学习效果。前一篇CSS入门指南-2：盒子模型、浮动和清除介绍了css盒子模型、浮动和清除，这一篇介绍 css元素的定位。

定位（position）

CSS 布局的核心是 position 属性，对元素盒子应用这个属性，可以相对于它在常规文档流中的位置重新定位。 position 属性有4个值：static、relative、absoulte、fixed，默认值为 static。

接下来我会用以下四个段落来逐个说明这些属性是什么意思。

<p id="first">First Paragraph</p>
<p id="Second">Second Paragraph</p>
<p id="specialpara">Third Paragraph</p>
<p id="fourth">First Paragraph</p>

静态定位（static）

我们先看一下四个段落都采用静态定位的效果。

静态定位下，每个元素在处在常规文档流中，它们都是块级元素，所以会在页面中自上而下地堆叠。

相对定位（relative）

现在我把第三段的 position 属性设置为 relative。

p#specialpara {
 position: relative;
 top: 25px;
 left: 30px;
}

因为相对定位相对的是它原来在文档流中的位置（默认位置），所以如果只设置 position 样式不会有任何变化。这里我同时设置了 top 和 left 属性来改变它的位置。

现在它的效果如图所示：

现在，第三段从原来的元素（body）中挣脱了出来，与它在文档中的默认位置相比向下移动了25像素，向右移动了30像素。

需要注意的是，除了这个元素自己相对于原始位置挪动了一下以外，页面没有任何改变。这个元素原来占据的空间没有动，其他元素也没动。

这时，如果不想第四段被它挡住，可以给第四段设置一个 margin-top 值。

绝对定位（absoulte）

绝对定位跟静态定位和相对定位相比，它会把元素彻底从文档流中拿出来。

我们把 position 改为绝对定位看一下：

p#specialpara {
 position: absoulte;
 top: 25px;
 left: 30px;
}

效果如图：

可以看到，第三段原来的位置被回收了。这说明绝对定位的元素脱离了常规文档流，它现在是相对于顶级元素 body 在定位。

现在就涉及到一个概念：定位上下文，这个后边说，先继续看最后一种定位方式：固定定位。

盒子位移属性是如何工作？

盒子的位移属性有四个“top、right、bottom和left”，用来指定元素的定位位置和方向。这些属性只能在元素的“position”属性设置了“relative、absolute和fixed”属性值，才生效。

对于相对定位元素，这些属性的设置让元素从默认位置移动。例如，top设置一个值“20px”在一个相对定位的元素上，这个元素会在原来位置向下移动“20px”。

CSS入门指南-2：盒子模型、浮动和清除

Wed, 19 Jul 2017 22:22:49 +0800

这是CSS设计指南的读书笔记，用于加深学习效果。

上一篇介绍了css 的工作原理，这一篇主要介绍盒子模型和浮动。

盒子模型

所谓盒子模型，就是浏览器为页面中的每个HTML元素生成的矩形盒子。这些盒子们都要按照可见版式模型在页面上排布。

HUGOMORE42

可见的页面版式主要由三个属性控制：position、display和float。

position：控制页面上元素的位置关系
display：控制元素是堆叠、并排还是不在页面出现
float：提供控制的方式，以便吧元素组成多栏布局

元素盒子的属性可以分成三组：

边框(board)。可以甚至边框的宽窄、样式和颜色
内边距(padding)。可以甚至盒子内容区与边框的间距
外边距(margin)。可以设置盒子与相邻元素的间距

元素盒子还有一个背景层，可以改变颜色，也可以添加图片。

简写样式

CSS为边框、内边距和外边距分别规定了简写属性，每个简写声明中，属性值得顺序都是上、右、下、左。

比如：

{
 margin-top: 5px;
 margin-right: 10px;
 margin-bottom: 12px;
 margin-left: 8px;
}

使用简写则为这样：

{
 margin: 12px 10px 12px 8px;
}

如果有一个值没写，那么则使用对边的值。

比如：

{margin: 12px 10px 12px;}
/*等同于*/
{
 margin: 12px 10px 12px 10px;
}

如果只写一个值，则4个边都取这个值。

{margin: 12px;}
/*等同于*/
{margin: 12px 12px 12px 12px;}

另外每个盒子的属性也分三个粒度，这三个粒度从一般到特殊分别举例如下：

{
 border: 2px dashed red;
}

混合使用三种粒度的简写属性达成设计目标是很常见的。比如，想为盒子的上边和下边添加4像素的红色边框，为左边添加1像素宽的红色边框，而右边没有。可以这么写：

{border: 4px solid red;} /* 先给4条边设置相同的样式*/
{border-left-width: 1px;} /* 修改左边框宽度*/
{border-fight: none;} /*移出右边框*/

盒子边框

border 有三个相关属性。

宽度（border-width)。可以使用thin、medium和thick等文本值，也可以使用除百分比和负值之外的任何绝对值。
样式（border-style)。有none、hidden、dotted、dashed等文本值。
颜色（border-color）。可以使用任意颜色值，包括RGB、HSL、十六进制颜色值和颜色关键字。

盒子内边距

内边距是盒子内容区与盒子边框之间的距离。

上图的样式为：

p {
 font: 16px helvetica, sans-serif;
 width: 220px;
 border: 2px solid red;
 background-color: #caebff;
}

可以看到在没有设定内边距的情况下，内容紧挨着边框。

设定边框后：

python并发4：使用thread处理并发

Sun, 02 Jul 2017 16:29:39 +0800

python asyncio 介绍

python并发3：使用asyncio编写服务器

Fri, 30 Jun 2017 16:29:39 +0800

python asyncio 介绍

python并发2：使用asyncio处理并发

Fri, 23 Jun 2017 16:29:39 +0800

python asyncio 介绍

python并发 1：使用 futures 处理并发

Sat, 17 Jun 2017 22:01:51 +0800

作为Python程序员，平时很少使用并发编程，偶尔使用也只需要派生出一批独立的线程，然后放到队列中，批量执行。所以，不夸张的说，虽然我知道线程、进程、并行、并发的概念，但每次使用的时候可能还需要再打开文档回顾一下。

现在这一篇还是 《流畅的python》读书笔记，译者在这里把future 翻译为“期物”，我觉得不太合适，既然future不能找到一个合适的词汇，暂时还是直接使用 future 吧。

concurrent.futures

future 是一种对象，表示异步执行的操作。这个概念是 concurrent.futures模块和asyncio包的基础。

concurrent.futures 模块是Python3.2 引入的，对于Python2x 版本，Python2.5 以上的版本可以安装 futures 包来使用这个模块。

HUGOMORE42

从Python3.4起，标准库中有两个为Future的类：concurrent.futures.Future 和 asyncio.Future。这两个类作用相同：两个Future类的实例都表示可能已经完成或未完成的延迟计算。

Future 封装待完成的操作，可放入队列，完成的状态可以查询，得到结果（或抛出异常）后可以获取结果（或异常）。

我们知道，如果程序中包含I/O操作，程序会有很高的延迟，CPU会处于等待状态，这时如果我们不使用并发会浪费很多时间。

示例

我们先举个例子：

下边是有两段代码，主要功能都是从网上下载人口前20的国际的国旗：第一段代码(flagss.py)是依序下载：下载完一个图片后保存到硬盘，然后请求下一张图片；第二段代码(flagss_threadpool.py)使用 concurrent.futures 模块，批量下载10张图片。

运行分别运行两段代码3次，结果如下：

images.py 的结果如下

$ python flags.py
BD BR CD CN DE EG ET FR ID IN IR JP MX NG PH PK RU TR US VN
20 flags downloaded in 6.18s

$ python flags.py
BD BR CD CN DE EG ET FR ID IN IR JP MX NG PH PK RU TR US VN
20 flags downloaded in 5.67s

$ python flags.py
BD BR CD CN DE EG ET FR ID IN IR JP MX NG PH PK RU TR US VN
20 flags downloaded in 6.55s

可以看到，依次下载10张图片，平均需要6秒

python协程3：用仿真实验学习协程

Thu, 15 Jun 2017 19:22:49 +0800

前两篇我们已经介绍了python 协程的使用和yield from 的原理，这一篇，我们用一个例子来揭示如何使用协程在单线程中管理并发活动。

什么是离散事件仿真

Wiki上的定义是：

离散事件仿真将系统随时间的变化抽象成一系列的离散时间点上的事件，通过按照事件时间顺序处理事件来演进，是一种事件驱动的仿真世界观。离散事件仿真将系统的变化看做一个事件，因此系统任何的变化都只能是通过处理相应的事件来实现，在两个相邻的事件之间，系统状态维持前一个事件发生后的状态不变。

人话说就是一种把系统建模成一系列事件的仿真系统。在离散事件仿真中，仿真“钟”向前推进的量不是固定的，而是直接推进到下一个事件模型的模拟时间。

假设我们抽象模拟出租车的运营过程，其中一个事件是乘客上车，下一个事件则是乘客下车。不管乘客做了5分钟还是50分钟，一旦下车，仿真钟就会更新，指向此次运营的结束时间。

事件？是不是想到了协程！

协程恰好为实现离散事件仿真提供了合理的抽象。

HUGOMORE42

第一门面向对象的语音 Simula 引入协程这个概念就是为了支持仿真。 Simpy 是一个实现离散事件仿真的Python包，通过一个协程表示离散事件仿真系统的各个进程。

出租车对运营仿真

仿真程序会创建几辆出租车，每辆出租车会拉几个乘客，然后回家。出租车会首先驶离车库，四处徘徊，寻找乘客；拉到乘客后，行程开始；乘客下车后，继续四处徘徊。

徘徊和行程所用的时间使用指数分布生成，我们将时间设为分钟数，以便显示清楚。

完整代码如下：(taxi_sim.py)


#! -*- coding: utf-8 -*-
import random
import collections
import queue
import argparse

DEFAULT_NUMBER_OF_TAXIS = 3
DEFAULT_END_TIME = 180
SEARCH_DURATION = 5
TRIP_DURATION = 20
DEPARTURE_INTERAVAL = 5


# time 是事件发生的仿真时间，proc 是出租车进程实例的编号，action是描述活动的字符串
Event = collections.namedtuple('Event', 'time proc action')

# 开始 出租车进程
# 每辆出租车调用一次taxi_process 函数，创建一个生成器对象，表示各辆出租车的运营过程。
def taxi_process(ident, trips, start_time=0):
 '''
 每次状态变化时向创建事件，把控制权交给仿真器
 :param ident: 出租车编号
 :param trips: 出租车回家前的行程数量
 :param start_time: 离开车库的时间
 :return:
 '''
 time = yield Event(start_time, ident, 'leave garage') # 产出的第一个Event
 for i in range(trips): # 每次行程都会执行一遍这个代码块
 # 产出一个Event实例，表示拉到了乘客 协程在这里暂停 等待下一次send() 激活
 time = yield Event(time, ident, 'pick up passenger')
 # 产出一个Event实例，表示乘客下车 协程在这里暂停 等待下一次send() 激活
 time = yield Event(time, ident, 'drop off passenger')
 # 指定的行程数量完成后，for 循环结束，最后产出 'going home' 事件。协程最后一次暂停
 yield Event(time, ident, 'going home')
 # 协程执行到最后 抛出StopIteration 异常


def compute_duration(previous_action):
 '''使用指数分布计算操作的耗时'''
 if previous_action in ['leave garage', 'drop off passenger']:
 # 新状态是四处徘徊
 interval = SEARCH_DURATION
 elif previous_action == 'pick up passenger':
 # 新状态是开始行程
 interval = TRIP_DURATION
 elif previous_action == 'going home':
 interval = 1
 else:
 raise ValueError('Unkonw previous_action: %s' % previous_action)
 return int(random.expovariate(1/interval)) + 1


# 开始仿真
class Simulator:

 def __init__(self, procs_map):
 self.events = queue.PriorityQueue() # 带优先级的队列 会按时间正向排序
 self.procs = dict(procs_map) # 从获取的procs_map 参数中创建本地副本，为了不修改用户传入的值

 def run(self, end_time):
 '''
 调度并显示事件，直到时间结束
 :param end_time: 结束时间 只需要指定一个参数
 :return:
 '''
 # 调度各辆出租车的第一个事件
 for iden, proc in sorted(self.procs.items()):
 first_event = next(proc) # 预激协程 并产出一个 Event 对象
 self.events.put(first_event) # 把各个事件加到self.events 属性表示的 PriorityQueue对象中

 # 此次仿真的主循环
 sim_time = 0 # 把 sim_time 归0
 while sim_time < end_time:
 if self.events.empty(): # 事件全部完成后退出循环
 print('*** end of event ***')
 break
 current_event = self.events.get() # 获取优先级最高(time 属性最小)的事件
 sim_time, proc_id, previous_action = current_event # 更新 sim_time
 print('taxi:', proc_id, proc_id * ' ', current_event)
 active_proc = self.procs[proc_id] # 从self.procs 字典中获取表示当前活动的出租车协程
 next_time = sim_time + compute_duration(previous_action)
 try:
 next_event = active_proc.send(next_time) # 把计算得到的时间发送给出租车协程。协程会产出下一个事件，或者抛出 StopIteration
 except StopIteration:
 del self.procs[proc_id] # 如果有异常 表示已经退出， 删除这个协程
 else:
 self.events.put(next_event) # 如果没有异常，把next_event 加入到队列
 else: # 如果超时 则走到这里
 msg = '*** end of simulation time: {} event pendding ***'
 print(msg.format(self.events.qsize()))



def main(end_time=DEFAULT_END_TIME, num_taxis=DEFAULT_NUMBER_OF_TAXIS,
 seed=None):
 '''初始化随机生成器，构建过程，运行仿真程序'''
 if seed is not None:
 random.seed(seed) # 获取可复现的结果
 # 构建taxis 字典。值是三个参数不同的生成器对象。
 taxis = {i: taxi_process(i, (i + 1) * 2, i*DEPARTURE_INTERAVAL)
 for i in range(num_taxis)}
 sim = Simulator(taxis)
 sim.run(end_time)


if __name__ == '__main__':
 parser = argparse.ArgumentParser(description='Taxi fleet simulator.')
 parser.add_argument('-e', '--end-time', type=int,
 default=DEFAULT_END_TIME,
 help='simulation end time; default=%s' % DEFAULT_END_TIME)
 parser.add_argument('-t', '--taxis', type=int,
 default=DEFAULT_NUMBER_OF_TAXIS,
 help='number of taxis running; default = %s' % DEFAULT_NUMBER_OF_TAXIS)
 parser.add_argument('-s', '--seed', type=int, default=None,
 help='random generator seed (for testing)')

 args = parser.parse_args()
 main(args.end_time, args.taxis, args.seed)

运行程序，

python协程2：yield from 从入门到精通

Wed, 14 Jun 2017 17:22:49 +0800

上一篇python协程1：yield的使用介绍了：

生成器作为协程使用时的行为和状态
使用装饰器预激协程
调用方如何使用生成器对象的 .throw(…) 和 .close() 方法控制协程

这一篇将介绍：

协程终止时如何返回值
yield新句法的用途和语义

HUGOMORE42

让协程返回值

先看一个例子：这段代码会返回最终均值的结果，每次激活协程时不会产出移动平均值，而是最后一次返回。

#! -*- coding: utf-8 -*-

from collections import namedtuple

Result = namedtuple('Result', 'count average')


def averager():
 total = 0.0
 count = 0
 average = None
 while True:
 term = yield
 if term is None:
 break # 为了返回值，协程必须正常终止；这里是退出条件
 total += term
 count += 1
 average = total/count
 # 返回一个namedtuple，包含count和average两个字段。在python3.3前，如果生成器返回值，会报错
 return Result(count, average)

我们调用这段代码，结果如下

>>> coro_avg = averager()
>>> next(coro_avg)
>>> coro_avg.send(20) # 并没有返回值
>>> coro_avg.send(30)
>>> coro_avg.send(40)
>>> coro_avg.send(None) # 发送None终止循环，导致协程结束。生成器对象会抛出StopIteration异常。异常对象的value属性保存着返回值。
Traceback (most recent call last):
 ...
StopIteration: Result(count=3, average=30)

return 表达式的值会传给调用方，赋值给StopIteration 异常的一个属性。这样做虽然看着别扭，但为了保留生成器对象耗尽时抛出StopIteration异常的行为，也可以理解。

python协程1：协程 10分钟入门

Mon, 12 Jun 2017 17:22:49 +0800

最近找到一本python好书《流畅的python》，是到现在为止看到的对python高级特性讲述最详细的一本。看了协程一章，做个读书笔记，加深印象。

协程定义

协程的底层架构是在pep342 中定义，并在python2.5 实现的。

HUGOMORE42

python2.5 中，yield关键字可以在表达式中使用，而且生成器API中增加了 .send(value)方法。生成器可以使用.send(…)方法发送数据，发送的数据会成为生成器函数中yield表达式的值。

协程是指一个过程，这个过程与调用方协作，产出有调用方提供的值。因此，生成器可以作为协程使用。

除了 .send(…)方法，pep342 和添加了 .throw(…)（让调用方抛出异常，在生成器中处理）和.close()（终止生成器）方法。

python3.3后，pep380对生成器函数做了两处改动：

生成器可以返回一个值；以前，如果生成器中给return语句提供值，会抛出SyntaxError异常。
引入yield from 语法，使用它可以把复杂的生成器重构成小型的嵌套生成器，省去之前把生成器的工作委托给子生成器所需的大量模板代码。

协程生成器的基本行为

首先说明一下，协程有四个状态，可以使用inspect.getgeneratorstate(…)函数确定：

GEN_CREATED # 等待开始执行
GEN_RUNNING # 解释器正在执行（只有在多线程应用中才能看到这个状态）
GEN_SUSPENDED # 在yield表达式处暂停
GEN_CLOSED # 执行结束

#! -*- coding: utf-8 -*-
import inspect

# 协程使用生成器函数定义：定义体中有yield关键字。
def simple_coroutine():
 print('-> coroutine started')
 # yield 在表达式中使用；如果协程只需要从客户那里接收数据，yield关键字右边不需要加表达式（yield默认返回None）
 x = yield
 print('-> coroutine received:', x)

my_coro = simple_coroutine()
my_coro # 和创建生成器的方式一样，调用函数得到生成器对象。
# 协程处于 GEN_CREATED (等待开始状态)
print(inspect.getgeneratorstate(my_coro))

my_coro.send(None)
# 首先要调用next()函数，因为生成器还没有启动，没有在yield语句处暂停，所以开始无法发送数据
# 发送 None 可以达到相同的效果 my_coro.send(None) 
next(my_coro)
# 此时协程处于 GEN_SUSPENDED (在yield表达式处暂停)
print(inspect.getgeneratorstate(my_coro))

# 调用这个方法后，协程定义体中的yield表达式会计算出42；现在协程会恢复，一直运行到下一个yield表达式，或者终止。
my_coro.send(42)
print(inspect.getgeneratorstate(my_coro))

运行上述代码，输出结果如下

CSS入门指南-1：工作原理

Sat, 27 May 2017 17:22:49 +0800

这是CSS设计指南的读书笔记，用于加深学习效果。

最近想做一个小程序，前端是必修课，那就从css开始吧。

css 工作原理

每个html元素都有一组样式属性，可以通过css来设定。当html元素的同一个样式属性有多种样式值的时候，css就要靠层叠机智来决定最终应用哪种样式。

HUGOMORE42

css规则

规则实际上是一条完整的css指令，规则声明了要修改的元素和要应用给改元素的样式。

为文档添加样式的三种方法：

写在元素标签里（也叫行内样式，只能影响它所在的标签，会覆盖嵌入样式和链接样式）
写在<style> 标签里（也就嵌入样式，应用范围仅限于当前页面，页面样式会覆盖外部样式表中的样式，但会被行内样式覆盖）
写在单独css样式表中（也叫链接样式，样式表是一个扩展名为.css 的文件，可以在任意多个HTML页面链接同一个样式表文件。链接样式的作用范围是整个网站）

除了这三种为页面添加样式的方法，还有一种在样式表中链接其他样式表的方法，使用@import 指令：例如

@import url(css/styles.css)

@import 指令必须出现在样式表中其他样式之前，否则@吹灭；@import引用的样式表不会被加载。

对这个基本的结构有三种方法可以进行扩展

**第一种方法：**多个声明包含在一条规则里。

p {color: red; font-size: 12px; font-weight: bold;}

**第二种方法：**多个选择器组合在一起。例如：如果想让<h1>、<h2>和<h3>的文本都变成蓝色粗体可以这么写：

h1 {color: blue; font-weight: bold;}
h2 {color: blue; font-weight: bold;}
h3 {color: blue; font-weight: bold;}

也可以这么写：

h1, h2, h3 {color: blue; font-weight: bold;}

分组选择符以逗号作为分隔符

第三种方法： 多条规则应用给一个选择符。例如，写完上边的规则，还想把h3变成斜体，那么可以再为h3单独写一条规则：

h1, h2, h3 {color: blue; font-weight: bold;}
h3 {font-style: italic;}

选择特定元素的选择符

用于选择特定元素的操作符有三种

上下文选择符。基于祖先或者同胞元素选择一个元素。
ID和类选择符。基于id和class属性的值选择元素。
属性选择符。基于属性的有无和特征选择元素。

上下文选择符

比如我们想给article中的段落设置不同的字号，可以使用上下文选择符来解决。

上下文选择符的格式如下：

标签1 标签2 {声明}

其中标签2 是我们要选择的目标，而且只有在 标签1是其祖先元素的情况下才会被选中。

上下文选择符，叫后代组合式选择符，就是一组以空格分隔的标签名。用于选择作为特定祖先元素后代的标签。

article p {font-weight: bold;}

上边例子中，只有article后代的p元素才会应用后边的样式。

上下文选择符以空格作为分隔符

特殊的上下文选择符

子选择符 >

格式如下：

标签1 > 标签2

标签1 必须是 标签2 的父元素，不能是其它的祖先元素。

跟着代码学go 002 -- 控制流

Tue, 26 Apr 2016 15:49:35 +0800

跟着代码学golang 控制流

跟着代码学go 001 -- 变量&函数

Mon, 25 Apr 2016 14:53:47 +0800

跟着代码学golang 变量函数基本数据结构

golang 介绍

Thu, 14 Apr 2016 22:44:40 +0800

1. Golang 是什么

Go 官方说明：

Go 编程语言是一个使得程序员更加有效率的开源项目。Go 是有表达力、简洁、清晰和有效率的。它的并行机制使其很容易编写多核和网络应用,而新的类型系统允许构建有性的模块化程序。Go 编译到机器码非常快速,同时具有便利的垃圾回收和强大的运行时反射。它是快速的、静态类型编译语言,但是感觉上是动态类型的,解释型语言

HUGOMORE42

2. 为什么要开发这个语言

Go 语言的发展目标

Go 语言的主要目标是将静态语言的安全性和高效性与动态语言的易开发性进行有机结合
Go 语言是一门类型安全和内存安全的编程语言。虽然 Go 语言中仍有指针的存在，但并不允许进行指针运算。
Go 语言的另一个目标是对于网络通信、并发和并行编程的极佳支持，从而更好地利用大量的分布式和多核的计算机
Go 语言中另一个非常重要的特性就是它的构建速度（编译和链接到机器代码的速度），一般情况下构建一个程序的时间只需要数百毫秒到几秒。
Go 语言实现高效快速的垃圾回收（使用了一个简单的标记-清除算法）。

3. 有什么特性&&用途

语言的特性

清晰并且简洁

Go 努力保持小并且优美,你可以在短短几行代码里做许多事情;

并行

Go 语言从本质上（程序和结构方面）来实现并发编程。 Go 让函数很容易成为非常轻量的线程。这些线程在 Go 中被叫做 goroutines

Channel

这些 goroutines 之间的通讯由 channel[18, 25] 完成

快速

编译很快,执行也很快。目标是跟 C 一样快。编译时间用秒计算; Go 的可执行文件都比相对应的源代码文件要大很多，这恰恰说明了 Go 的 runtime 嵌入到了每一个可执行文件当中。当然，在部署到数量巨大的集群时，较大的文件体积也是比较头疼的问题。但总得来说，Go 的部署工作还是要比 Java 和 Python 轻松得多。因为 Go 不需要依赖任何其它文件，它只需要一个单独的静态文件，这样你也不会像使用其它语言一样在各种不同版本的依赖文件之间混淆。

安全

当转换一个类型到另一个类型的时候需要显式的转换并遵循严格的规则。Go 有垃圾收集（使用了一个简单的标记-清除算法）,在 Go 中无须 free(),语言会处理这一切; 值得注意的是，因为垃圾回收和自动内存分配的原因，Go 语言不适合用来开发对实时性要求很高的软件。