Development on 古思乱想

Facilitating Technical Writing Courses

Sun, 01 Mar 2020 20:47:11 +0800

description

Technical Writing Courses

Sun, 01 Mar 2020 20:46:40 +0800

description

学习单元测试，告别祈祷式编程

Mon, 07 Oct 2019 09:48:04 +0800

单元测试编写指南

如何通过MD5反查身份证号？

Sun, 18 Aug 2019 14:22:26 +0800

如何通过MD5反查身份证号？

Redis 选择hash还是string 存储数据？

Sat, 22 Jun 2019 11:29:15 +0800

Redis 选择hash还是string 存储数据？

markdown中code生成图片的实现

Sat, 15 Jun 2019 23:34:53 +0800

markdown中code生成图片的实现

markdown中code生成图片的思路

Thu, 13 Jun 2019 23:34:53 +0800

markdown中code生成图片的思路

为什么json 不能使用 int64类型

Mon, 03 Jun 2019 21:14:10 +0800

json javacript 不能使用int64

PostgreSQL jsonb 使用入门

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

postgresql json jsonb 使用入门

创建高质量的代码--软件构建中的设计

Wed, 29 May 2019 21:05:57 +0800

代码大全软件设计中的构建

并发模型：线程与锁

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

并发模型：线程与锁

JWT RefreshToken 实践

Mon, 29 Apr 2019 21:05:57 +0800

jwt refresh token

Golang mod 入门

Sat, 16 Mar 2019 19:49:35 +0800

golang mod

python设计模式-状态模式

Mon, 31 Dec 2018 12:59:39 +0800

python 状态模式

python设计模式-模板方法模式

Sun, 02 Dec 2018 17:23:56 +0800

python 设计模式模板方法模式

python设计模式-外观模式

Sun, 25 Nov 2018 17:23:56 +0800

python 设计模式外观模式

python设计模式-适配器模式

Sat, 03 Nov 2018 21:23:56 +0800

python 设计模式，适配器模式

SQLAlchemy in 空列表问题分析

Thu, 04 Oct 2018 21:36:53 +0800

SQLAlchemy in 空列表问题

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

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

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

使用github+travis将Python包部署到Pypi

Mon, 23 Jul 2018 23:45:46 +0800

使用github+travis将Python包部署到Pypi

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

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

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

Python 生成便签图片

Sun, 08 Jul 2018 15:04:52 +0800

python 文字转图片

Python gRPC 入门

Thu, 07 Jun 2018 23:49:17 +0800

Python gRPC 入门

newrelic python agent 源码分析-1

Wed, 16 May 2018 20:17:13 +0800

newrelic python agent 源码分析

Golang 学习笔记-2：控制流

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

golang 学习笔记控制流

AWS-Lambda 使用入门

Sat, 13 Jan 2018 17:23:49 +0800

场景：现在需要开发一个前后端分离的应用，后端采用 RESTful API 最为方便，但是如果这个后端服务会在一天中的某些时候有高并发的情况，使用什么样的架构最为简单呢？

刚思考这个问题的时候我想到的解决方案可能有以下几种：

使用CDN内容分发网络，减少主服务器的压力
使用LVS服务器负载均衡
使用缓存
硬件层提高带宽，使用SSD 硬盘，使用更好的服务器
代码层，优化代码（使用性能更好的语言等

但以上的几个方法都需要关注服务器的存储和计算资源，以便随时调整以满足更高的性能，并且高并发的请求也是分时段的，配置了更高性能的服务器在访问量变低的时候也是资源浪费。

这个时候可以使用 FaaS（Functions as a Service）架构，跟传统架构不同在于，他们运行于无状态的容器中，可以由事件触发，短暂的，完全被第三方管理，功能上FaaS就是不需要关心后台服务器或者应用服务，只需关心自己的代码即可。其中AWS Lambda是目前最佳的FaaS实现之一。

AWS Lambda

AWS Lambda 是一项计算服务，使用时无需预配置或管理服务器即可运行代码。AWS Lambda 只在需要时执行代码并自动缩放。借助 AWS Lambda，几乎可以为任何类型的应用程序或后端服务运行代码，而且无需执行任何管理。现在 AWS Lambda 支持 Node.js、Java、C# 和 Python。

使用场景

Lambda 常见的应用场景有以下几种：

将Lambda 作为事件源用于 AWS 服务（比如音频上传到 s3后，触发 Lambda 音频转码服务，转码音频文件
通过 HTTPS (Amazon API Gateway) 实现的按需 Lambda 函数调用（配合 API Gateway创建简单的微服务
按需 Lambda 函数调用（使用自定义应用程序构建您自己的事件源）
计划的事件（比如每天晚上12点生成报表发送到指定邮箱

下图是将Lambda 作为事件源用于 AWS 服务案例的一个执行流程图：

用户将对象上传到 S3 存储桶（对象创建事件）。
Amazon S3 检测到对象创建事件。
Amazon S3 调用在存储桶通知配置中指定的 Lambda 函数。
AWS Lambda 通过代入您在创建 Lambda 函数时指定的执行角色来执行 Lambda 函数。
Lambda 函数执行。

这篇文章主要介绍将 Lambda 作为事件源用于 AWS 服务和配合 API Gateway 创建简单的微服务。

python设计模式-命令模式

Tue, 09 Jan 2018 23:16:56 +0800

python 设计模式，命令模式

Python 字典

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

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

python设计模式-单例模式

Sun, 26 Nov 2017 12:59:39 +0800

python 单例模式

python设计模式-建造者模式

Sun, 12 Nov 2017 21:16:56 +0800

python 设计模式，建造者模式

python设计模式-抽象工厂模式

Sat, 28 Oct 2017 21:23:56 +0800

python 设计模式，工厂方法模式，抽象工厂模式

python设计模式-工厂方法模式

Sun, 15 Oct 2017 13:23:56 +0800

python 设计模式，工厂方法模式，简单工厂模式

python设计模式-观察者模式

Sun, 24 Sep 2017 22:29:39 +0800

python 观察者模式

redis 学习笔记

Sun, 17 Sep 2017 22:41:51 +0800

redis 学习笔记

Python 元组和分片

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

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

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

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

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

小程序开发：上传图片到腾讯云

Sun, 27 Aug 2017 12:17:13 +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>

运行代码结果如下：

自定义 Sanic Exception

Sat, 05 Aug 2017 10:23:35 +0800

自定义 sanic 异常处理

小程序开发：python sanic 实现小程序登录注册

Sun, 30 Jul 2017 12:17:13 +0800

python sanic 实现微信小程序登录注册

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”。

理解JWT（JSON Web Token）认证及实践

Sun, 23 Jul 2017 21:05:57 +0800

description

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;
}

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

设定边框后：

微信公号DIY：MongoDB 简易ORM & 公号记账数据库设计

Sun, 16 Jul 2017 21:14:10 +0800

微信公号DIY python 实现 MongoDB 简易ORM & 公号记账应用数据库设计

使用swagger 生成 Flask RESTful API

Tue, 11 Jul 2017 21:29:15 +0800

使用swagger_py_codegen 生成 Flask, Tornado, Falcon，Sanic RESTful API

微信公号DIY：训练聊天机器人&公号变身图片上传工具

Sat, 08 Jul 2017 23:34:53 +0800

训练聊天机器人&公号变身图片上传工具

微信公号DIY：一小时搭建微信聊天机器人

Wed, 05 Jul 2017 23:47:13 +0800

1小时搭建微信聊天机器人

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 web 框架 Sanci 快速入门

Sun, 25 Jun 2017 12:47:34 +0800

sanic 快速入门

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 的父元素，不能是其它的祖先元素。

Elasticsearch 安装和使用

Thu, 18 May 2017 14:22:49 +0800

安装使用 Elasticsearch 两种方法：

方法1 手动安装 Elasticsearch

安装到ubuntu

Elasticsearch与Logstash需要Java作为运行环境

安装Java 8

将甲骨文Java PPA添加至apt：

sudo add-apt-repository -y ppa:webupd8team/java

更新apt软件包数据库：

sudo apt-get update

HUGOMORE42

安装甲骨文Java 8的最新稳定版本，命令如下（在弹出的许可协议中点击接受）：

sudo apt-get -y install oracle-java8-installer

安装Elasticsearch

方法1 通过添加Elastic的软件包源列表利用软件包管理器安装Elasticsearch。

运行以下命令以将Elasticsearch公共GPG密钥导入apt：

wget -qO - https://packages.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

接下来，创建Elasticsearch源列表：

echo "deb http://packages.elastic.co/elasticsearch/${ELASTICSEARCH_VERSION}/debian stable main" | sudo tee -a /etc/apt/sources.list.d/elk.list

更新apt软件包数据库：

sudo apt-get update

安装Elasticsearch

sudo apt-get -y install elasticsearch

Elasticsearch已经安装完成。下面编辑其配置文件：

sudo vi /etc/elasticsearch/elasticsearch.yml

限制来自外部的Elasticsearch实例访问活动（端口9200），找到指定network.host的一行，取消其注释并将其值替换为“localhost”：

elasticsearch.yml excerpt (updated)

network.host: localhost

启动elasticsearch

Amazon DynamoDB 入门8：删除项目

Fri, 03 Mar 2017 17:19:05 +0800

上一篇介绍了DynamoDB 的更新，这一篇将会介绍项目删除操作和dynamoab-py

从表中删除数据

在 SQL 中，DELETE 语句从表中删除一个或多个行。DynamoDB 使用 DeleteItem 操作一次删除一个项目。

SQL

在 SQL 中，可使用 DELETE 语句删除一个或多个行。WHERE 子句确定要修改的行。示例如下：

HUGOMORE42

DELETE FROM Music WHERE Artist = ‘The Acme Band’ AND SongTitle = ‘Look Out, World’; 我们可以修改 WHERE 子句以删除多个行。例如，删除某个特殊艺术家的所有歌曲，如下所示：

DELETE FROM Music WHERE Artist = ‘The Acme Band’

Note

如果省略 WHERE 子句，则数据库会尝试从表中删除所有行。

DynamoDB

在 DynamoDB 中，可使用 DeleteItem 操作修改单个项目。

(http://docs.aws.amazon.com/zh_cn/amazondynamodb/latest/APIReference/API_DeleteItem.html?shortFooter=true)[API 语法如下]：

{
 "ConditionExpression": "string",
 "ExpressionAttributeNames": {
 "string" : "string"
 },
 "ExpressionAttributeValues": {
 "string" : {
 "B": blob,
 "BOOL": boolean,
 "BS": [ blob ],
 "L": [
 "AttributeValue"
 ],
 "M": {
 "string" : "AttributeValue"
 },
 "N": "string",
 "NS": [ "string" ],
 "NULL": boolean,
 "S": "string",
 "SS": [ "string" ]
 }
 },
 "Key": {
 "string" : {
 "B": blob,
 "BOOL": boolean,
 "BS": [ blob ],
 "L": [
 "AttributeValue"
 ],
 "M": {
 "string" : "AttributeValue"
 },
 "N": "string",
 "NS": [ "string" ],
 "NULL": boolean,
 "S": "string",
 "SS": [ "string" ]
 }
 },
 "ReturnConsumedCapacity": "string",
 "ReturnItemCollectionMetrics": "string",
 "ReturnValues": "string",
 "TableName": "string"
}

参数说明：

Amazon DynamoDB 入门7：项目更新

Tue, 07 Feb 2017 22:23:33 +0800

上一节介绍了DynamoDB 的查询，本来计划这一节介绍使用索引的查询，不过随机看到了更新操作，就先写更新操作吧

update (修改表中的数据)

SQL 语言提供用于修改数据的 UPDATE 语句。DynamoDB 使用 UpdateItem 操作完成类似的任务。

SQL

在 SQL 中，可使用 UPDATE 语句修改一个或多个行。SET 子句为一个或多个列指定新值，WHERE 子句确定修改的行。示例如下：

UPDATE Music
SET RecordLabel = 'Global Records'
WHERE Artist = 'No One You Know' AND SongTitle = 'Call Me Today';

HUGOMORE42

如果任何行均不匹配 WHERE 子句，则 UPDATE 语句不起作用。

DynamoDB

在 DynamoDB 中，可使用 UpdateItem 操作修改单个项目。

API 语法如下：

{
 "AttributeUpdates": {
 "string" : {
 "Action": "string",
 "Value": {
 "B": blob,
 "BOOL": boolean,
 "BS": [ blob ],
 "L": [
 "AttributeValue"
 ],
 "M": {
 "string" : "AttributeValue"
 },
 "N": "string",
 "NS": [ "string" ],
 "NULL": boolean,
 "S": "string",
 "SS": [ "string" ]
 }
 }
 },
 "ConditionalOperator": "string",
 "ConditionExpression": "string",
 "Expected": {
 "string" : {
 "AttributeValueList": [
 {
 "B": blob,
 "BOOL": boolean,
 "BS": [ blob ],
 "L": [
 "AttributeValue"
 ],
 "M": {
 "string" : "AttributeValue"
 },
 "N": "string",
 "NS": [ "string" ],
 "NULL": boolean,
 "S": "string",
 "SS": [ "string" ]
 }
 ],
 "ComparisonOperator": "string",
 "Exists": boolean,
 "Value": {
 "B": blob,
 "BOOL": boolean,
 "BS": [ blob ],
 "L": [
 "AttributeValue"
 ],
 "M": {
 "string" : "AttributeValue"
 },
 "N": "string",
 "NS": [ "string" ],
 "NULL": boolean,
 "S": "string",
 "SS": [ "string" ]
 }
 }
 },
 "ExpressionAttributeNames": {
 "string" : "string"
 },
 "ExpressionAttributeValues": {
 "string" : {
 "B": blob,
 "BOOL": boolean,
 "BS": [ blob ],
 "L": [
 "AttributeValue"
 ],
 "M": {
 "string" : "AttributeValue"
 },
 "N": "string",
 "NS": [ "string" ],
 "NULL": boolean,
 "S": "string",
 "SS": [ "string" ]
 }
 },
 "Key": {
 "string" : {
 "B": blob,
 "BOOL": boolean,
 "BS": [ blob ],
 "L": [
 "AttributeValue"
 ],
 "M": {
 "string" : "AttributeValue"
 },
 "N": "string",
 "NS": [ "string" ],
 "NULL": boolean,
 "S": "string",
 "SS": [ "string" ]
 }
 },
 "ReturnConsumedCapacity": "string",
 "ReturnItemCollectionMetrics": "string",
 "ReturnValues": "string",
 "TableName": "string",
 "UpdateExpression": "string"
}

参数说明：

Amazon DynamoDB 入门6：query 和 scan

Tue, 31 Jan 2017 17:46:28 +0800

上一节我们介绍了DynamoDB索引的创建及管理，这一节我们将介绍query（查询）和scan（扫描）的使用。

查询Query

SQL 可使用 SELECT 语句查询关键列、非关键列或任意组合。WHERE 子句确定返回的行。

DynamoDB Query 操作提供对存储数据的物理位置的快速高效访问。可以将 Query 用于任何具有复合主键（分区键和排序键）的表。这里的表必须指定分区键的相等条件，并且可以选择性为排序键提供另一个条件。 KeyConditionExpression 参数指定要查询的键值。

HUGOMORE42

可使用可选 FilterExpression 在结果中的找出某些符号条件的项目。

在 DynamoDB 中，必须使用 ExpressionAttributeValues 作为表达式参数（例如，KeyConditionExpression和 FilterExpression）中的占位符。这类似于在关系数据库中使用绑定变量，在运行时将实际值代入 SELECT语句。下边是query的语法：

response = table.query(
 IndexName='string',
 Select='ALL_ATTRIBUTES'|'ALL_PROJECTED_ATTRIBUTES'|'SPECIFIC_ATTRIBUTES'|'COUNT',
 AttributesToGet=[
 'string',
 ],
 Limit=123,
 ConsistentRead=True|False,
 ConditionalOperator='AND'|'OR',
 ScanIndexForward=True|False,
 ExclusiveStartKey={
 'string': 'string'|123|Binary(b'bytes')|True|None|set(['string'])|set([123])|set([Binary(b'bytes')])|[]|{}
 },
 ReturnConsumedCapacity='INDEXES'|'TOTAL'|'NONE',
 ProjectionExpression='string',
 FilterExpression=Attr('myattribute').eq('myvalue'),
 KeyConditionExpression=Key('mykey').eq('myvalue'),
 ExpressionAttributeNames={
 'string': 'string'
 },
 ExpressionAttributeValues={
 'string': 'string'|123|Binary(b'bytes')|True|None|set(['string'])|set([123])|set([Binary(b'bytes')])|[]|{}
 }
)

参数说明：

Amazon DynamoDB 入门5：索引创建及管理

Wed, 18 Jan 2017 21:55:39 +0800

上一节我们介绍了项目的添加、修改、获取、删除（CRUD）操作，这一节将介绍索引的创建及管理。

创建索引

SQL

在关系数据库中，索引是一个数据结构，可对表中的不同的列执行快速查询。可以使用 CREATE INDEX SQL 语句将索引添加到现有表，并指定要建立索引的列。在创建索引后，可以照常查询表中的数据，但现在数据库可使用索引快速查找表中的指定行，而不是扫描整个表。

在创建一个索引后，数据库将自动维护此索引。只要修改表中的数据，就会自动更改索引以反映表中的更改。

HUGOMORE42

在 MySQL 中，您可以创建如下所示的索引：

CREATE INDEX GenreAndPriceIndex
ON Music (genre, price);

DynamoDB

在 DynamoDB 中，我们可以创建和使用secondary index来实现类似目的。

DynamoDB 中的索引与其关系对应项不同。当我们创建secondary index时，必须指定其键属性 - 分区键和排序键。在创建secondary index后，我们可以对它执行 Query 或 Scan 操作，就如同对表执行这些操作一样。 DynamoDB 没有查询优化程序，因此，仅在我们对secondary index执行 Query 或 Scan 操作时使用它。

DynamoDB 支持两种不同的索引：

全局二级索引 - 索引的主键可以是其表中的任意两个属性（可以在创建表时创建，也可以向现有表添加新全局二级索引，或者删除现有的全局二级索引）。
本地二级索引 - 索引的分区键必须与其表的分区键相同。不过，排序键可以是任何其他属性（是在创建表的同时创建的。不能向现有表添加本地二级索引，也不能删除已存在的任何本地二级索引）。

DynamoDB 确保secondary index中的数据最终与其表保持一致。我们可以请求对表或local secondary index执行强一致性 Query 或 Scan 操作。但是，全局二级索引仅支持最终一致性。

可使用 UpdateTable 操作并指定 GlobalSecondaryIndexUpdates 来将global secondary index添加到现有表：

{
 TableName: "Music",
 AttributeDefinitions:[
 {AttributeName: "Genre", AttributeType: "S"},
 {AttributeName: "Price", AttributeType: "N"}
 ],
 GlobalSecondaryIndexUpdates: [
 {
 Create: {
 IndexName: "GenreAndPriceIndex",
 KeySchema: [
 {AttributeName: "Genre", KeyType: "HASH"}, //Partition key
 {AttributeName: "Price", KeyType: "RANGE"}, //Sort key
 ],
 Projection: {
 "ProjectionType": "ALL"
 },
 ProvisionedThroughput: {
 "ReadCapacityUnits": 1,"WriteCapacityUnits": 1
 }
 }
 }
 ]
}

添加索引时必须向 UpdateTable 提供以下参数：

Amazon DynamoDB 入门4：项目的基本操作（CRUD）

Wed, 18 Jan 2017 21:53:38 +0800

上一节我们介绍了DynamoDB 表的操作，这一节将介绍项目的添加修改获取删除操作。

创建项目

Amazon DynamoDB 提供了 PutItem 和 BatchWriteItem 两种方式写入数据

添加单个项目

在 Amazon DynamoDB 中，使用 PutItem 操作向表添加项目：

HUGOMORE42

{
 TableName: "Music",
 Item: {
 "Artist":"No One You Know",
 "SongTitle":"Call Me Today",
 "AlbumTitle":"Somewhat Famous",
 "Year": 2015,
 "Price": 2.14,
 "Genre": "Country",
 "Tags": {
 "Composers": [
 "Smith",
 "Jones",
 "Davis"
 ],
 "LengthInSeconds": 214
 }
 }
}

此表的主键包含 Artist 和 SongTitle。您必须为这些属性指定值。以下是要了解的有关此 PutItem 示例的几个关键事项：

Amazon DynamoDB 入门3：表的基本操作

Sat, 14 Jan 2017 18:13:42 +0800

之前两篇文章介绍了DynamoDB如何在本地安装以及基本的工作原理和API，这一节主要介绍如何使用DynamoDB。

基本的DynamoDB 操作包括表操作、项目操作和索引管理。

首先是链接数据库。和关系型数据库不同，DynamoDB 是一项 Web 服务，与其进行的交互是无状态的。应用程序不需要维护持久性网络连接。相反，与 DynamoDB 的交互是通过 HTTP(S) 请求和响应进行的。

HUGOMORE42

执行某项操作的步骤为：

应用程序将 HTTP(S) 请求发送到 DynamoDB。该请求包含要执行的 DynamoDB 操作的名称和参数。DynamoDB 将立即执行请求。
DynamoDB 返回一个包含操作结果的 HTTP(S) 响应。如果出错，DynamoDB 将返回 HTTP 错误状态和消息。

大多数情况下，我们编写应用程序代码访问DynamoDB。同时还可以使用 AWS 管理控制台或 AWS Command Line Interface (AWS CLI) 向 DynamoDB 发送临时请求并查看结果。

剩下的就让我们用代码展示吧！

表操作

我们知道，关系模型需要一个明确定义的架构，其中，数据将标准化为表、列和行。此外，在表、列、索引和其他数据库元素之间定义所有关系。但 DynamoDB 不同，DynamoDB 没有架构。每个表必须具有一个用来唯一标识每个数据项目的主键，但对其他非键属性没有类似的约束。DynamoDB 可以管理结构化或半结构化的数据，包括 JSON 文档。

表是关系数据库和 DynamoDB 中的基本数据结构。关系数据库管理系统 (RDBMS) 要求在创建表时定义表的架构。相比之下，DynamoDB 表没有架构 - 与主键不同，我们在创建表时无需定义任何属性或数据类型。

新建表

DynamoDB 使用 CreateTable 操作创建表，并指定参数，请求语法如下所示：

{
 "AttributeDefinitions": [
 {
 "AttributeName": "string",
 "AttributeType": "string"
 }
 ],
 "GlobalSecondaryIndexes": [
 {
 "IndexName": "string",
 "KeySchema": [
 {
 "AttributeName": "string",
 "KeyType": "string"
 }
 ],
 "Projection": {
 "NonKeyAttributes": [ "string" ],
 "ProjectionType": "string"
 },
 "ProvisionedThroughput": {
 "ReadCapacityUnits": number,
 "WriteCapacityUnits": number
 }
 }
 ],
 "KeySchema": [
 {
 "AttributeName": "string",
 "KeyType": "string"
 }
 ],
 "LocalSecondaryIndexes": [
 {
 "IndexName": "string",
 "KeySchema": [
 {
 "AttributeName": "string",
 "KeyType": "string"
 }
 ],
 "Projection": {
 "NonKeyAttributes": [ "string" ],
 "ProjectionType": "string"
 }
 }
 ],
 "ProvisionedThroughput": {
 "ReadCapacityUnits": number,
 "WriteCapacityUnits": number
 },
 "StreamSpecification": {
 "StreamEnabled": boolean,
 "StreamViewType": "string"
 },
 "TableName": "string"
}

必须向 CreateTable 提供以下参数：

Amazon DynamoDB 入门2：工作原理、API和数据类型介绍

Mon, 09 Jan 2017 22:37:11 +0800

本节主要介绍DynamoDB 基本概念、核心组件、数据结构、Api

DynamoDB工作原理

DynamoDB 基本概念

DynamoDB 是 AWS 独有的完全托管的 NoSQL Database。它的思想来源于 Amazon 2007 年发表的一篇论文：Dynamo: Amazon’s Highly Available Key-value Store。在这篇论文里，Amazon 介绍了如何使用 Commodity Hardware 来打造高可用、高弹性的数据存储。想要理解 DynamoDB，首先要理解 Consistent Hashing。Consistent Hashing 的原理如下图所示：

HUGOMORE42

它的概念是：

我有一个足够大的Keyspace（2的160次方，比较一下：IPv6是2的128次方），我们记作X。
然后将X放在一个环形的空间里划分成大小相等的Y个 Partition，依次循环排列（如图），每个 Partition 由一个Vnode（Riak的概念）管理，
当你有M个Database Server（Node），Y个Vnode再平均映射到M个Node上。
当数据要插入时，将其主键（Hash Key）映射到K中的一个地址（Addr），对应到某个Vnode，再进一步对应到某个Node，如果这个数据需要N个Replica，则将数据写入Addr（Vnode a），Addr + 1（Vnode b）， …，Add + N（Vnode n）。
这里，M就是你的Shards，N是Replica。

以后添加新的Node时，映射发生变化，只需要把相应的变化了的Vnode迁移到新的Node上即可。在这种结构下，Sharding/Replica对程序员基本上是透明的。

DynamoDB 核心组件

基本 DynamoDB 组件包括：表、项目、属性

表 - 类似于其他数据库系统，DynamoDB将数据存储在表中。表是数据的集合。（类似于关系型数据库中的表）
项目 - 每个表包含多个项目。项目是一组属性，具有不同于所有其他项目的唯一标识。（类似于其他数据库系统中的行、记录或元组。）
属性 - 每个项目包含一个或多个属性。属性是基础的数据元素，无需进一步分解。（类似于其他数据库系统中的字段或列。）

下图是一个名为 People 的表，其中显示了一些示例项目和属性：

请注意有关 People 表的以下内容：

Amazon DynamoDB 入门1：配置（本地）及python示例

Sat, 07 Jan 2017 22:57:39 +0800

本节主要介绍AmazonDynamoDB 安装配置及Python开发示例"

什么是 Amazon DynamoDB

Amazon DynamoDB 是一种完全托管的 NoSQL 数据库服务，提供快速而可预测的性能，能够实现无缝扩展。使用 DynamoDB，您可以免除操作和扩展分布式数据库的管理工作负担，因而无需担心硬件预置、设置和配置、复制、软件修补或集群扩展等问题。

使用 DynamoDB，您可以创建数据库表来存储和检索任意量级的数据，并提供任意级别的请求流量。您可以扩展或缩减您的表的吞吐容量，而不会导致停机或性能下降，还可以使用 AWS 管理控制台来监控资源使用情况和各种性能指标。

HUGOMORE42

Amazon DynamoDB 特点

DynamoDB 会自动将数据和流量分散到足够数量的服务器上，以满足吞吐量和存储需求，同时保持始终如一的高性能。所有数据均存储在固态硬盘 (SSD) 中，并会自动复制到 AWS 区域中的多个可用区中，从而提供内置的高可用性和数据持久性。

DynamoDB 是 NoSQL 数据库并且无架构，这意味着，与主键属性不同，无需在创建表时定义任何属性或数据类型。与此相对，关系数据库要求在创建表时定义每个列的名称和数据类型。

Amazon DynamoDB 使用

AWS 配置

注册 Amazon Web Services 并创建访问密钥
创建 AWS 凭证文件
开启DynamoDB 服务

在计算机上运行 DynamoDB

除了 Amazon DynamoDB Web 服务之外，AWS 还提供可本地运行的可下载版本的 DynamoDB。使用本地版本，在开发应用程序时无需 Internet 连接。

方法1 直接在计算机上安装

需要安装java环境

下载 DynamoDB
解压，并将解压后的目录复制到某个位置
打开命令提示符窗口，打开 DynamoDBLocal.jar 的目录，并输入以下命令：

java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb

现在就可以使用了

网站微信登录－python 实现

Mon, 05 Sep 2016 17:59:45 +0800

最近我们的网站要加微信登录功能，找了python sdk 感觉都不满意，然后就参考instagram python sdk 自己造了轮子。

轮子 github 地址 python-weixin

根据需求选择相应的登录方式

微信现在提供两种登录接入方式

移动应用微信登录
网站应用微信登录

HUGOMORE42

这里我们使用的是网站应用微信登录

按照官方流程

注册并通过开放平台开发者资质认证

注册微信开放平台帐号后，在帐号中心中填写开发者资质认证申请，并等待认证通过。

创建网站应用

通过填写网站应用名称、简介和图标，以及各平台下载地址等资料，创建网站应用

接入微信登录

在资源中心查阅网站应用开发文档,开发接入微信登陆功能，让用户可使用微信登录你的网站应用

如果已经完成上面的操作，请继续往下看

微信网站应用微信登录是基于OAuth2.0协议标准构建的微信OAuth2.0授权登录系统。

微信OAuth2.0授权登录目前支持authorization_code模式，适用于拥有server端的应用授权。该模式整体流程为：

第三方发起微信授权登录请求，微信用户允许授权第三方应用后，微信会拉起应用或重定向到第三方网站，并且带上授权临时票据code参数；
通过code参数加上AppID和AppSecret等，通过API换取access_token；
通过access_token进行接口调用，获取用户基本数据资源或帮助用户实现基本操作。

获取access_token 时序图

具体流程请参考官方文档，我们这里只说一下python的实现方法。官方文档地址点这里

参考python-instagram 我写了一个 [python-weixin] (https://github.com/gusibi/python-weixin)一个微信python SDK

不过现在还只有微信接入、获取用户信息、刷新refresh_token 等简单功能

安装

方法一手动安装

首先需要把代码clone到本地
python setup.py install

方法二 pip install

pip install git+https://github.com/gusibi/python-weixin.git@master

使用方式


from weixin.client import WeixinAPI

APP_ID = 'your app id'
APP_SECRET = 'your app secret'
REDIRECT_URI = 'http://your_domain.com/redirect_uri' # 这里一定要注意 地址一定要加上http/https

scope = ("snsapi_login", )
api = WeixinAPI(appid=APP_ID,
 app_secret=APP_SECRET,
 redirect_uri=REDIRECT_URI)

authorize_url = api.get_authorize_url(scope=scope)

现在将 authorize_url地址(如 http://yoursite.com/login/weixin)在浏览器打开，将跳转到微信登录页面，使用手机扫码登录后将跳转到

跟着代码学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 语言不适合用来开发对实时性要求很高的软件。