PLY 需要安装一份. 可以直接通过 pip 安装

# pip install ply

这东西并非一个扩展的正则表达式工具, 而是一个完备的编译器构造工具, 不过这篇文章只打算讨论其词法分析器构造部分.

基本例子

PLY 很魔法的一点是它使用到了模块内部反射. 也就是说在产生一个词法分析器时, 并不是把词法规则传递给 PLY 的接口, 而是依次将一些指定名字的变量或函数定义在 py 文件中.
下面给出第一个例子, 从文本中抓出十进制数值.

import ply.lex

tokens = (
    'NUMBER',
)

t_NUMBER = r'\d*[.]?\d+'

def t_error(t):
    t.lexer.skip(1)

ply.lex.lex()
ply.lex.input('''
    The Chinese mathematician Zu Chongzhi, around 480 AD, calculated that
        pi ~= 355/113
    (a fraction that goes by the name Milv in Chinese), using Liu Hui's
    algorithm applied to a 12288-sided polygon. With a correct value for its
    seven first decimal digits, this value of 3.141592920... remained the most
    accurate approximation of pi available for the next 800 years.

    <From Wikipedia:Pi>
''')

for token in iter(ply.lex.token, None):
    print token.type, token.value

输出

NUMBER 480 NUMBER 355 NUMBER 113 NUMBER 12288 NUMBER 3.141592920 NUMBER 800

上面的代码有这么一些要点

文件中定义了 tokens 表示可能的词元类型; 在官方例子中, 其中的取值通常以全大写的形式出现
定义词元规则 t_NUMBER, 其名字是 token 变量中的成员 'NUMBER' 加上前缀 t_; 在构造词法分析器时, PLY 会将以 t_ 开头的所有定义收集起来
词元规则 t_NUMBER 的取值是正则表达式, 用来匹配所有的数值
定义 t_error 函数, 如果什么奇怪的东西混进来, 这个函数会被调用; 不过现在只是抓取数值, 无视其它符号, 所以实现只是跳过一个字符 (skip 的参数是字符数量)
调用 ply.lex.lex 构造词法分析器
调用 ply.lex.input 喂一些输入进去
从 ply.lex.token 获得词法分析的结果

利用分词输出

从这个基本例子迈向一个用于简单表达式计算的词法分析器并不困难. 如果按照之前一篇文章里所演示的那个功能 (请将该文章中最后一段代码保存在 expr_eval.py 中以供这次使用), 需要至少以下这些词元类型

二元算符 */^
二元或一元算符 +-
括号
整数

Posted at Aug 03 2013 - 11:18:01

Permanent Link: /p/513 Load full text

Post tags:

Compiler Construction
Python
Tutorial
PLY

多国语言环境下 Jinja2 与 strftime 互动异常退治纪要

不少语言或者库或多或少都遭遇过乱码问题. 然而这一点在 Python 里面表现得比较另类, 一般来说只要贯彻 UTF-8 到底的思路, 不怎么可能遇到一大波乱码袭来的情况. 只是, 偶尔会直接因为字符串类型设置不对而直接抛运行期异常.
常在河边走, 湿鞋是顺理成章的事情. 这次遇到的情况简报如下

# encoding=utf-8

import jinja2
import datetime

now = datetime.datetime.utcnow()

print jinja2.Template(u'''当前月份 {{ date.strftime('%Y 年 %m 月') }}''').render(date=now)

运行这一段代码, Python 直接扔出来一坨

Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print jinja2.Template(u'''当前月份 {{ date.strftime('%Y 年 %m 月') }}''').render(date=now)
  File "/usr/local/lib/python2.7/dist-packages/Jinja2-2.6-py2.7.egg/jinja2/environment.py", line 894, in render
    return self.environment.handle_exception(exc_info, True)
  File "<template>", line 1, in top-level template code
UnicodeEncodeError: 'ascii' codec can't encode character u'\u5e74' in position 3: ordinal not in range(128)

简单地说, 就是 Jinja2 在刷什么东西的过程中挂了, 因为字符串里面混入了什么奇怪的东西.

一番尝试并寻找之后, 首先发现第一个问题, datetime.datetime.strftime 函数接受奇怪的字符串会出问题, 比如先来试试看这个

now = datetime.datetime.utcnow()
print now.strftime('%Y 年 %m 月')

结果什么问题都没有, 突然有人品爆了的感觉, 这个好像很不科学的样子啊. 再仔细对比代码找找茬才发现要这样才能挂掉程序

now = datetime.datetime.utcnow()
print now.strftime(u'%Y 年 %m 月')

这前缀 u 的 unicode 类型怎么说也坑太深了的感觉吧. (别扯什么 Python str 与 unicode 类型异与同 21 天从入门到精通什么的, 别的语言都没这问题 Python 确有, 这应该就是 Python 的问题了吧.) 在这种情况下如果要用 unicode 还得转一道

now = datetime.datetime.utcnow()
print now.strftime(u'%Y 年 %m 月'.encode('utf-8'))

Posted at Apr 13 2013 - 09:21:26

Permanent Link: /p/510 Load full text

Post tags:

Python
Jinja2
strftime
Unicode

Flask 出坑记

Flask 是个 Python Web 框架. 网站上文档例子都很详尽, 这里就不废话了, 只是来扯两个使用中需要注意的地方.

获取 POST 请求体

21 世纪的 Web 交互中服务器跟浏览器互相丢 JSON 已经成了司空见惯的事情. 在 Flask 框架作成的服务器上要搞到 JSON 数据当然是直接访问 POST 请求体了, 如

import flask
import functools

app = flask.Flask(__name__)

@app.route('/wtf', methods=['POST'])
def wtf():
    return 'Received: ' + flask.request.data

def main():
    app.run(port=7777)

if __name__ == '__main__': main()

按文档的说法, flask.request.data 包含请求数据字符串. 但其实这也是个坑, 默认情况下根本取不到请求数据

$ curl -d "[1,1,2,3,5,8]" http://localhost:7777/wtf
Received:

熊孩子你把拿到的字符串给吃了吧? 实际上如果去看看那文档会看到并不如上面所说的那样, 而是

Contains the incoming request data as string in case it came with a mimetype Flask does not handle.

后面这个状语从句真是着急, 那到底什么 mimetype 会使得 Flask does not handle 呢? 根本没说清楚啊. 扫一眼文档后面, 还有个东西可以用: flask.request.json, 但这货一般是 None, 只有当请求 mimetype 被设置为 application/json 的时候才有用, Flask 你真心是跟 mimetype 过不去啊. 也就是说得这样发请求

$ curl -d "[1,1,2,3,5,8]" localhost:7777/wtf
Received: null
$ curl -d "[1,1,2,3,5,8]" -H "Content-Type:application/json" localhost:7777/wtf
Received: [1, 1, 2, 3, 5, 8]

# Server codes

import json
import flask
import functools

app = flask.Flask(__name__)

@app.route('/wtf', methods=['POST'])
def wtf():
    return 'Received: ' + json.dumps(flask.request.json)

def main():
    app.run(port=7777)

if __name__ == '__main__': main()

问题是现在前端攻城狮都被浏览器兼容性折腾得满世界买表, 哪还有心情检查每个请求的 content-type 对不对. 况且这还只对 JSON 有效, 如果是山寨协议又怂了.
好吧, 如果实在不行, 就挖到 WSGI 里面去好了, 比如这样

def request_data():
    d = flask.request.data
    if not d:
        return ''.join(flask.request.environ['wsgi.input'].readlines())
    return d

Posted at Apr 05 2013 - 02:49:05

Permanent Link: /p/509 Load full text

Post tags:

Python
Flask
Web Server

移花接木 - 编译同步代码为异步代码 [条件表达式篇]

接上篇

条件表达式

如果设计如下的类生成 Javascript 中条件表达式 predicate ? consequence : alternative

# semantic.py

class Conditional(Expression):
    def __init__(self, predicate, consequence, alternative):
        self.predicate = predicate
        self.consequence = consequence
        self.alternative = alternative

    def compile(self, context):
        return output.Conditional(self.predicate.compile(context),
                                  self.consequence.compile(context),
                                  self.alternative.compile(context))

# output.py

class Conditional(Expression):
    def __init__(self, predicate, consequence, alternative):
        self.predicate = predicate
        self.consequence = consequence
        self.alternative = alternative

    def str(self):
        return '({p} ? {c} : {a})'.format(p=self.predicate.str(),
                                          c=self.consequence.str(),
                                          a=self.alternative.str())

这在条件表达式的三个子表达式均不包含异步调用时, 或仅 predicate 包含正规异步调用没问题, 如

root_context = ContextFlow()
root_flow = root_context.block

Block([
        Arithmetics(
            Binary(
                '=',
                Reference('m'),
                Conditional(
                    Reference('a'),
                    Reference('b'),
                    Reference('c')))),
        Arithmetics(
            Binary(
                '=',
                Reference('n'),
                Conditional(
                    RegularAsyncCall(
                        Reference('f'),
                        [ NumericLiteral(0) ]),
                    Reference('x'),
                    Reference('y')))),
    ]).compile(root_context)

print root_flow.str()

这些节点编译后会生成类似如下代码

Posted at Mar 17 2013 - 00:38:47

Permanent Link: /p/508 Load full text

Post tags:

Python
Javascript
Asynchronous Expression
Compiler Construction

移花接木 - 编译同步代码为异步代码 [补述篇]

接上篇

编译步骤解释

多个正规异步调用出现在同一个语句中的编译顺序

RegularAsyncCall 对象的 compile 代码如下

def compile(self, context):
    # 0
    compl_callee = self.callee.compile(context)

    # 1
    compl_args = [ arg.compile(context) for arg in self.arguments ]

    # 2
    callback_body_context = ContextFlow()
    cb_body_flow = callback_body_context.block
    compl_args.append(output.Lambda([ 'error', 'result' ], cb_body_flow))

    # 3
    context.block.add(output.Arithmetics(output.Call(compl_callee, compl_args)))

    # 4
    context.block = cb_body_flow

    return output.Reference('result')

步骤依次是

0 编译被调用对象
1 依次编译调用实参
2 向实参列表中追加一个匿名函数, 函数体语句流是新建的一个 ContextFlow 中的语句流
3 向当前上下文语句流中插入一个算术节点, 节点的内容是编译后的异步调用
4 修改上下文语句流

它们的顺序不可随意颠倒, 不仅仅因为有些步骤依赖于前面的步骤 (比如步骤 3 构造 Call 对象须 0 与 1 中得到的结果), 更多地是因为在编译过程中上下文语句流随时可能变化. 比如下面这个例子

async_call('xx', %%)('oo', %%)

这应当生成下面这段 Javascript 代码

async_call('xx', function(error, result) {
    result('oo', function(error, result) {
        result;
    });
});

async_call('xx', %%) 编译时第一次修改了上下文语句流, 而之后对前一次异步调用结果的调用再一次修改了上下文语句流. 用语法树来表示即

+-------------+ | origin flow | +-------------+ | +-------------+ +---------| arithmetics | +-------------+ | [A]====================+ | regular async call | +====================+ / \ [B]====================+ +------+ | regular async call | | 'oo' | +====================+ +------+ / \ +------------+ +------+ | async_call | | 'xx' | +------------+ +------+

Posted at Mar 13 2013 - 02:05:29

Permanent Link: /p/507 Load full text

Post tags:

Python
Javascript
Asynchronous Expression
Compiler Construction

移花接木 - 编译同步代码为异步代码 [数据结构篇]

目标

我说 JS 代码的表达能力是一流的, 可能一票 Python 党 (作为高级黑, 我不得不说我自己也是个 Python 党) 要笑了. 我是说真的, Python 的 Lambda 基本上就是半残废, 所以, 要用 Python 写异步代码那就像是用挂面上吊一样不来劲了.
然而任何写 JS 代码遇到三层以上的异步代码套在一起的时候手撕键盘的心都有了, 蔽博先前也介绍了一个工具 (确切地说是玩具) 用来使用类似同步的代码生成异步代码. 而现在则有更明确的目标, 如把这样一段代码

fs: require('fs')
content: fs.readFile('/etc/passwd', %%)
console.log(content)

变成这样一段 Javascript

var fs, content;
fs = require('fs');
fs.readFile('etc/passwd', function(err, result) {
    content = result;
    console.log(content);
});

    为什么是这样? 首先 JS 中很多异步调用的回调函数都遵循 function(error, result) 这个形式, 这俨然成为了 Javascript 中的一种约定, 因此在接下来的分析中把这样的回调函数参数称为正规异步回调 (regular asynchronous callback). 既然它们都是这么个形式, 那么写代码的时候完全可以不这么罗嗦写个回调声明, 而是用 %% 这个符号来替代它.
    而包含正规异步回调的函数调用称之为正规异步调用 (regular asynchronous call).

    更详细地说, fs.readFile('/etc/passwd', %%) 这个表达式的意思是

调用 fs.readFile
第一个参数是字符串常量 '/etc/passwd'
第二个参数是一个正规异步回调函数
从这个表达式之后, 所有的语句归入上述正规异步回调函数的函数体中

那么下面要做的事请是, 如果在一次编译过程中, 语法分析已经完成, 对应的同步代码的语法树已经建起来, 怎么根据上述规则去生成异步代码.

比如上面的例子, 源语法树形式是

Posted at Mar 11 2013 - 12:48:16

Permanent Link: /p/506 Load full text

Post tags:

Compiler Construction
Python
Javascript
Asynchronous Expression

小记 Python yield 与生成器

yield 是 Python 中的一个关键字, 这个关键字比较特殊, 用于在任何表达式前, 但它不仅会对其后的表达式有影响, 对整个函数上下文都有影响. 实际上, 凡是在函数体中出现了 yield 关键字, Python 都会对此函数特殊处理, 调用这个函数不再返回值, 而是一个生成器对象.
比如

def f():
    yield 1

g = f()
print type(g)

其结果是

<type 'generator'>

如果要获取产生器产生的值, 则需要调用产生器对象的 next 函数

def f():
    yield 1

g = f()
print g.next()

如果在函数中, 出现多个 yield, 或者函数的执行过程中反复路过某个 yield, 那么 next 每次调用会得到下一个产生的值, 比如

def f():
    yield 1
    yield 2

g = f()
print g.next(),
print g.next()

得到的会是 1 2. 或如下的循环

def f():
    for x in range(3):
        yield x * 2

g = f()
print g.next(),
print g.next(),
print g.next()

该循环中反复产生值, 每次产生一个就被传递给 next 函数作为返回值... 当然这样来说是不准确地, 如果上面 for 循环如果跑得太快, 那样会疾速产生值导致 next 函数应接不暇, 这样会有诡异的同步问题. 所以正确的语义应该是

当生成器函数执行到包含 yield 的表达式时, 函数挂起, 并将 yield 之后的表达式作为返回值传递给 next 函数调用
下一次 next 函数调用又会驱动该生成器的函数体继续执行此后的语句, 直到遇见下一个 yield 再次挂起并生成一个值交给 next
如果某次 next 调用驱动了生成器继续执行, 而此后函数正常结束的话, 那么不会有任何值传递给 next 函数, 同时, 生成器会抛出 StopIteration 异常

对于最后一点, 下面这个例子可作为参考

def f():
    yield 1

g = f()
print g.next(),
print g.next()

另外生成器中如果出现 return, 它必须是一句空返回, 即 return 之后不允许跟任何表达式, 这也是限制之一.

从下面这个例子可以更好地窥探生成器的执行模式

def f():
    print 'a'
    yield 1
    print 'b'
    yield 2
    print 'c'

g = f()
print 'start'
print g.next()
print 'next'
print g.next()
print 'end'

输出结果为

start
a
1
next
b
2
end

也就是说当第一次调用了 next 之后, f 函数体的执行就挂起了, 等着下一次调用 next. 另外, f 中最后一句应该输出的 c 并没有输出, 因为第二次生成器给出了 2 这个值之后就一直处于挂起状态.
如果要大慈大悲地让最后一句也执行, 那么需要再加一句 next 调用

def f():
    print 'a'
    yield 1
    print 'b'
    yield 2
    print 'c'

g = f()
print 'start'
print g.next()
print 'next'
print g.next()
print 'end'
g.next()

Posted at Dec 06 2012 - 10:33:41

Permanent Link: /p/502 Load full text

Post tags:

Python
yield
Generator

对象炼金术 - SQLAlchemy 使用 Postgres 数据库

安装 Postgres 与基本配置

Postgres, 或者又称为 PostgreSQL (结尾的小写 s 变成了 SQL) 是一个功能强大的数据库.
在 ubuntu 下安装

# apt-get install postgresql

其它发行版应该差不多. Windows 用户请自行解决.

安装完成之后, 系统中会多出一个名为 postgres 的用户, 这个用户用于登录数据库. 但无法直接用该用户在 shell 或 xdm 中登录, 须先用其它用户登录 shell, 然后 su 到该用户. 先为该用户设置一下密码

# passwd postgres

再切换到该用户

me@host:~$ su postgres
Password:
postgres@host:/home/me $

如果当时处在某个用户的 home 目录, 如 /home/me 下, 则命令行会弹出一行错误信息
could not change directory to "/home/me"
因为 postgres 这个用户无法读取当前用户的 home 目录. 觉得讨厌的话可以

$ cd /

此时在命令行输入指令进入 Postgres 交互环境

$ psql
psql (version number)
Type "help" for help.

postgres=# input instructions here

这样会以 postgres 用户身份登录, 如果要输入密码就输入刚才为 postgres 用户设置的密码.

这时 postgres 用户相当于数据库的根用户, 就像 root 用户之于 Linux 系统一样, 直接让应用程序使用 postgres 用户是比较危险的. 下面新建一个用户 "psuser", 密码为 "qwerty"

postgres=# CREATE USER psuser WITH PASSWORD 'qwerty';
CREATE ROLE

当然 Postgres 是不区分大小写的. 不过这里 (包括下文) 中将以全大写标明这些是关键字, 而小写的部分是可替换的. 密码需要用引号包围起来.

然后再建立一个新数据库, 并授权 psuser 这个用户可以使用该数据库

postgres=# CREATE DATABASE mydb;
CREATE DATABASE
postgres=# GRANT ALL PRIVILEGES ON DATABASE mydb TO psuser;
GRANT

这样就差不多好了. 下面开始搞 Python 与 SQLAlchemy 部分.

如果上面每个句子输入之后没回显结果, 并且交互环境开头变为了 postgres-# (注意 # 前是一个减号而非等号), 请查看一下句尾的分号是否漏掉了.

使用 SQLAlchemy 连接 Postgres

有关 SQLAlchemy 的基本使用请见这里.
编写这样一段 Python 代码, 来测试 Postgres 数据库连接是否可用

Posted at Jul 30 2012 - 04:04:32

Permanent Link: /p/493 Load full text

Post tags:

Postgres
Python
SQLAlchemy

0 Page 1 2 3 4

PLY 构造词法分析工具 PLY 需要安装一份. 可以直接通过 pip 安装 `# pip install ply` 这东西并非一个扩展的正则表达式工具, 而是一个完备的编译器构造工具, 不过这篇文章只打算讨论其词法分析器构造部分. 基本例子 PLY 很魔法的一点是它使用到了模块内部反射. 也就是说在产生一个词法分析器时, 并不是把词法规则传递给 PLY 的接口, 而是依次将一些指定名字的变量或函数定义在 py 文件中. 下面给出第一个例子, 从文本中抓出十进制数值. import ply.lex tokens = ( 'NUMBER', ) t_NUMBER = r'\d[.]?\d+' def t_error(t): t.lexer.skip(1) ply.lex.lex() ply.lex.input(''' The Chinese mathematician Zu Chongzhi, around 480 AD, calculated that pi ~= 355/113 (a fraction that goes by the name Milv in Chinese), using Liu Hui's algorithm applied to a 12288-sided polygon. With a correct value for its seven first decimal digits, this value of 3.141592920... remained the most accurate approximation of pi available for the next 800 years. <From Wikipedia:Pi> ''') for token in iter(ply.lex.token, None): print token.type, token.value 输出 `NUMBER 480 NUMBER 355 NUMBER 113 NUMBER 12288 NUMBER 3.141592920 NUMBER 800` 上面的代码有这么一些要点文件中定义了 `tokens` 表示可能的词元类型; 在官方例子中, 其中的取值通常以全大写的形式出现定义词元规则 `t_NUMBER`, 其名字是 `token` 变量中的成员 `'NUMBER'` 加上前缀 `t_`; 在构造词法分析器时, PLY 会将以 `t_` 开头的所有定义收集起来词元规则 `t_NUMBER` 的取值是正则表达式, 用来匹配所有的数值定义 `t_error` 函数, 如果什么奇怪的东西混进来, 这个函数会被调用; 不过现在只是抓取数值, 无视其它符号, 所以实现只是跳过一个字符 (`skip` 的参数是字符数量) 调用 `ply.lex.lex` 构造词法分析器调用 `ply.lex.input` 喂一些输入进去从 `ply.lex.token` 获得词法分析的结果利用分词输出从这个基本例子迈向一个用于简单表达式计算的词法分析器并不困难. 如果按照之前一篇文章里所演示的那个功能 (请将该文章中最后一段代码保存在 expr_eval.py 中以供这次使用), 需要至少以下这些词元类型二元算符 /^ 二元或一元算符 +- 括号整数 Posted at Aug 03 2013 - 11:18:01 Permanent Link: /p/513 Load full text	Post tags: Compiler Construction Python Tutorial PLY
多国语言环境下 Jinja2 与 `strftime` 互动异常退治纪要不少语言或者库或多或少都遭遇过乱码问题. 然而这一点在 Python 里面表现得比较另类, 一般来说只要贯彻 UTF-8 到底的思路, 不怎么可能遇到一大波乱码袭来的情况. 只是, 偶尔会直接因为字符串类型设置不对而直接抛运行期异常. 常在河边走, 湿鞋是顺理成章的事情. 这次遇到的情况简报如下 `# encoding=utf-8 import jinja2 import datetime now = datetime.datetime.utcnow() print jinja2.Template(u'''当前月份 {{ date.strftime('%Y 年 %m 月') }}''').render(date=now)` 运行这一段代码, Python 直接扔出来一坨 Traceback (most recent call last): File "test.py", line 8, in <module> print jinja2.Template(u'''当前月份 {{ date.strftime('%Y 年 %m 月') }}''').render(date=now) File "/usr/local/lib/python2.7/dist-packages/Jinja2-2.6-py2.7.egg/jinja2/environment.py", line 894, in render return self.environment.handle_exception(exc_info, True) File "<template>", line 1, in top-level template code UnicodeEncodeError: 'ascii' codec can't encode character u'\u5e74' in position 3: ordinal not in range(128) 简单地说, 就是 Jinja2 在刷什么东西的过程中挂了, 因为字符串里面混入了什么奇怪的东西. 一番尝试并寻找之后, 首先发现第一个问题, `datetime.datetime.strftime` 函数接受奇怪的字符串会出问题, 比如先来试试看这个 `now = datetime.datetime.utcnow() print now.strftime('%Y 年 %m 月')` 结果什么问题都没有, 突然有人品爆了的感觉, 这个好像很不科学的样子啊. 再仔细对比代码找找茬才发现要这样才能挂掉程序 `now = datetime.datetime.utcnow() print now.strftime(u'%Y 年 %m 月')` 这前缀 `u` 的 `unicode` 类型怎么说也坑太深了的感觉吧. (别扯什么 Python `str` 与 `unicode` 类型异与同 21 天从入门到精通什么的, 别的语言都没这问题 Python 确有, 这应该就是 Python 的问题了吧.) 在这种情况下如果要用 `unicode` 还得转一道 `now = datetime.datetime.utcnow() print now.strftime(u'%Y 年 %m 月'.encode('utf-8'))` Posted at Apr 13 2013 - 09:21:26 Permanent Link: /p/510 Load full text	Post tags: Python Jinja2 strftime Unicode
Flask 出坑记 Flask 是个 Python Web 框架. 网站上文档例子都很详尽, 这里就不废话了, 只是来扯两个使用中需要注意的地方. 获取 POST 请求体 21 世纪的 Web 交互中服务器跟浏览器互相丢 JSON 已经成了司空见惯的事情. 在 Flask 框架作成的服务器上要搞到 JSON 数据当然是直接访问 POST 请求体了, 如 `import flask import functools app = flask.Flask(__name__) @app.route('/wtf', methods=['POST']) def wtf(): return 'Received: ' + flask.request.data def main(): app.run(port=7777) if __name__ == '__main__': main()` 按文档的说法, `flask.request.data` 包含请求数据字符串. 但其实这也是个坑, 默认情况下根本取不到请求数据 `$ curl -d "[1,1,2,3,5,8]" http://localhost:7777/wtf Received:` 熊孩子你把拿到的字符串给吃了吧? 实际上如果去看看那文档会看到并不如上面所说的那样, 而是 Contains the incoming request data as string in case it came with a mimetype Flask does not handle. 后面这个状语从句真是着急, 那到底什么 mimetype 会使得 Flask does not handle 呢? 根本没说清楚啊. 扫一眼文档后面, 还有个东西可以用: `flask.request.json`, 但这货一般是 `None`, 只有当请求 mimetype 被设置为 application/json 的时候才有用, Flask 你真心是跟 mimetype 过不去啊. 也就是说得这样发请求 `$ curl -d "[1,1,2,3,5,8]" localhost:7777/wtf Received: null $ curl -d "[1,1,2,3,5,8]" -H "Content-Type:application/json" localhost:7777/wtf Received: [1, 1, 2, 3, 5, 8]` `# Server codes import json import flask import functools app = flask.Flask(__name__) @app.route('/wtf', methods=['POST']) def wtf(): return 'Received: ' + json.dumps(flask.request.json) def main(): app.run(port=7777) if __name__ == '__main__': main()` 问题是现在前端攻城狮都被浏览器兼容性折腾得满世界买表, 哪还有心情检查每个请求的 content-type 对不对. 况且这还只对 JSON 有效, 如果是山寨协议又怂了. 好吧, 如果实在不行, 就挖到 WSGI 里面去好了, 比如这样 `def request_data(): d = flask.request.data if not d: return ''.join(flask.request.environ['wsgi.input'].readlines()) return d` Posted at Apr 05 2013 - 02:49:05 Permanent Link: /p/509 Load full text	Post tags: Python Flask Web Server
移花接木 - 编译同步代码为异步代码 [条件表达式篇] 接上篇条件表达式如果设计如下的类生成 Javascript 中条件表达式 `predicate ? consequence : alternative` # semantic.py class Conditional(Expression): def __init__(self, predicate, consequence, alternative): self.predicate = predicate self.consequence = consequence self.alternative = alternative def compile(self, context): return output.Conditional(self.predicate.compile(context), self.consequence.compile(context), self.alternative.compile(context)) # output.py class Conditional(Expression): def __init__(self, predicate, consequence, alternative): self.predicate = predicate self.consequence = consequence self.alternative = alternative def str(self): return '({p} ? {c} : {a})'.format(p=self.predicate.str(), c=self.consequence.str(), a=self.alternative.str()) 这在条件表达式的三个子表达式均不包含异步调用时, 或仅 `predicate` 包含正规异步调用没问题, 如 root_context = ContextFlow() root_flow = root_context.block Block([ Arithmetics( Binary( '=', Reference('m'), Conditional( Reference('a'), Reference('b'), Reference('c')))), Arithmetics( Binary( '=', Reference('n'), Conditional( RegularAsyncCall( Reference('f'), [ NumericLiteral(0) ]), Reference('x'), Reference('y')))), ]).compile(root_context) print root_flow.str() 这些节点编译后会生成类似如下代码 Posted at Mar 17 2013 - 00:38:47 Permanent Link: /p/508 Load full text	Post tags: Python Javascript Asynchronous Expression Compiler Construction
移花接木 - 编译同步代码为异步代码 [补述篇] 接上篇编译步骤解释多个正规异步调用出现在同一个语句中的编译顺序 `RegularAsyncCall` 对象的 `compile` 代码如下 def compile(self, context): # 0 compl_callee = self.callee.compile(context) # 1 compl_args = [ arg.compile(context) for arg in self.arguments ] # 2 callback_body_context = ContextFlow() cb_body_flow = callback_body_context.block compl_args.append(output.Lambda([ 'error', 'result' ], cb_body_flow)) # 3 context.block.add(output.Arithmetics(output.Call(compl_callee, compl_args))) # 4 context.block = cb_body_flow return output.Reference('result') 步骤依次是 0 编译被调用对象 1 依次编译调用实参 2 向实参列表中追加一个匿名函数, 函数体语句流是新建的一个 `ContextFlow` 中的语句流 3 向当前上下文语句流中插入一个算术节点, 节点的内容是编译后的异步调用 4 修改上下文语句流它们的顺序不可随意颠倒, 不仅仅因为有些步骤依赖于前面的步骤 (比如步骤 3 构造 `Call` 对象须 0 与 1 中得到的结果), 更多地是因为在编译过程中上下文语句流随时可能变化. 比如下面这个例子 `async_call('xx', %%)('oo', %%)` 这应当生成下面这段 Javascript 代码 `async_call('xx', function(error, result) { result('oo', function(error, result) { result; }); });` `async_call('xx', %%)` 编译时第一次修改了上下文语句流, 而之后对前一次异步调用结果的调用再一次修改了上下文语句流. 用语法树来表示即 +-------------+ \| origin flow \| +-------------+ \| +-------------+ +---------\| arithmetics \| +-------------+ \| [A]====================+ \| regular async call \| +====================+ / \ [B]====================+ +------+ \| regular async call \| \| 'oo' \| +====================+ +------+ / \ +------------+ +------+ \| async_call \| \| 'xx' \| +------------+ +------+ Posted at Mar 13 2013 - 02:05:29 Permanent Link: /p/507 Load full text	Post tags: Python Javascript Asynchronous Expression Compiler Construction
移花接木 - 编译同步代码为异步代码 [数据结构篇] 目标我说 JS 代码的表达能力是一流的, 可能一票 Python 党 (作为高级黑, 我不得不说我自己也是个 Python 党) 要笑了. 我是说真的, Python 的 Lambda 基本上就是半残废, 所以, 要用 Python 写异步代码那就像是用挂面上吊一样不来劲了. 然而任何写 JS 代码遇到三层以上的异步代码套在一起的时候手撕键盘的心都有了, 蔽博先前也介绍了一个工具 (确切地说是玩具) 用来使用类似同步的代码生成异步代码. 而现在则有更明确的目标, 如把这样一段代码 `fs: require('fs') content: fs.readFile('/etc/passwd', %%) console.log(content)` 变成这样一段 Javascript `var fs, content; fs = require('fs'); fs.readFile('etc/passwd', function(err, result) { content = result; console.log(content); });` 为什么是这样? 首先 JS 中很多异步调用的回调函数都遵循 `function(error, result)` 这个形式, 这俨然成为了 Javascript 中的一种约定, 因此在接下来的分析中把这样的回调函数参数称为正规异步回调 (regular asynchronous callback). 既然它们都是这么个形式, 那么写代码的时候完全可以不这么罗嗦写个回调声明, 而是用 `%%` 这个符号来替代它. 而包含正规异步回调的函数调用称之为正规异步调用 (regular asynchronous call). 更详细地说, `fs.readFile('/etc/passwd', %%)` 这个表达式的意思是调用 `fs.readFile` 第一个参数是字符串常量 `'/etc/passwd'` 第二个参数是一个正规异步回调函数从这个表达式之后, 所有的语句归入上述正规异步回调函数的函数体中那么下面要做的事请是, 如果在一次编译过程中, 语法分析已经完成, 对应的同步代码的语法树已经建起来, 怎么根据上述规则去生成异步代码. 比如上面的例子, 源语法树形式是 Posted at Mar 11 2013 - 12:48:16 Permanent Link: /p/506 Load full text	Post tags: Compiler Construction Python Javascript Asynchronous Expression
小记 Python `yield` 与生成器 `yield` 是 Python 中的一个关键字, 这个关键字比较特殊, 用于在任何表达式前, 但它不仅会对其后的表达式有影响, 对整个函数上下文都有影响. 实际上, 凡是在函数体中出现了 `yield` 关键字, Python 都会对此函数特殊处理, 调用这个函数不再返回值, 而是一个生成器对象. 比如 `def f(): yield 1 g = f() print type(g)` 其结果是 `<type 'generator'>` 如果要获取产生器产生的值, 则需要调用产生器对象的 `next` 函数 `def f(): yield 1 g = f() print g.next()` 如果在函数中, 出现多个 `yield`, 或者函数的执行过程中反复路过某个 `yield`, 那么 `next` 每次调用会得到下一个产生的值, 比如 `def f(): yield 1 yield 2 g = f() print g.next(), print g.next()` 得到的会是 `1 2`. 或如下的循环 `def f(): for x in range(3): yield x * 2 g = f() print g.next(), print g.next(), print g.next()` 该循环中反复产生值, 每次产生一个就被传递给 `next` 函数作为返回值... 当然这样来说是不准确地, 如果上面 `for` 循环如果跑得太快, 那样会疾速产生值导致 `next` 函数应接不暇, 这样会有诡异的同步问题. 所以正确的语义应该是当生成器函数执行到包含 `yield` 的表达式时, 函数挂起, 并将 `yield` 之后的表达式作为返回值传递给 `next` 函数调用下一次 `next` 函数调用又会驱动该生成器的函数体继续执行此后的语句, 直到遇见下一个 `yield` 再次挂起并生成一个值交给 `next` 如果某次 `next` 调用驱动了生成器继续执行, 而此后函数正常结束的话, 那么不会有任何值传递给 `next` 函数, 同时, 生成器会抛出 `StopIteration` 异常对于最后一点, 下面这个例子可作为参考 `def f(): yield 1 g = f() print g.next(), print g.next()` 另外生成器中如果出现 `return`, 它必须是一句空返回, 即 `return` 之后不允许跟任何表达式, 这也是限制之一. 从下面这个例子可以更好地窥探生成器的执行模式 `def f(): print 'a' yield 1 print 'b' yield 2 print 'c' g = f() print 'start' print g.next() print 'next' print g.next() print 'end'` 输出结果为 `start a 1 next b 2 end` 也就是说当第一次调用了 `next` 之后, `f` 函数体的执行就挂起了, 等着下一次调用 `next`. 另外, `f` 中最后一句应该输出的 `c` 并没有输出, 因为第二次生成器给出了 `2` 这个值之后就一直处于挂起状态. 如果要大慈大悲地让最后一句也执行, 那么需要再加一句 `next` 调用 `def f(): print 'a' yield 1 print 'b' yield 2 print 'c' g = f() print 'start' print g.next() print 'next' print g.next() print 'end' g.next()` Posted at Dec 06 2012 - 10:33:41 Permanent Link: /p/502 Load full text	Post tags: Python yield Generator
对象炼金术 - SQLAlchemy 使用 Postgres 数据库安装 Postgres 与基本配置 Postgres, 或者又称为 PostgreSQL (结尾的小写 s 变成了 SQL) 是一个功能强大的数据库. 在 ubuntu 下安装 `# apt-get install postgresql` 其它发行版应该差不多. Windows 用户请自行解决. 安装完成之后, 系统中会多出一个名为 postgres 的用户, 这个用户用于登录数据库. 但无法直接用该用户在 shell 或 xdm 中登录, 须先用其它用户登录 shell, 然后 `su` 到该用户. 先为该用户设置一下密码 `# passwd postgres` 再切换到该用户 `me@host:~$ su postgres Password: postgres@host:/home/me $` 如果当时处在某个用户的 home 目录, 如 /home/me 下, 则命令行会弹出一行错误信息 `could not change directory to "/home/me"` 因为 postgres 这个用户无法读取当前用户的 home 目录. 觉得讨厌的话可以 `$ cd /` 此时在命令行输入指令进入 Postgres 交互环境 `$ psql psql (version number) Type "help" for help. postgres=# input instructions here` 这样会以 postgres 用户身份登录, 如果要输入密码就输入刚才为 postgres 用户设置的密码. 这时 postgres 用户相当于数据库的根用户, 就像 root 用户之于 Linux 系统一样, 直接让应用程序使用 postgres 用户是比较危险的. 下面新建一个用户 "psuser", 密码为 "qwerty" `postgres=# CREATE USER psuser WITH PASSWORD 'qwerty'; CREATE ROLE` 当然 Postgres 是不区分大小写的. 不过这里 (包括下文) 中将以全大写标明这些是关键字, 而小写的部分是可替换的. 密码需要用引号包围起来. 然后再建立一个新数据库, 并授权 psuser 这个用户可以使用该数据库 `postgres=# CREATE DATABASE mydb; CREATE DATABASE postgres=# GRANT ALL PRIVILEGES ON DATABASE mydb TO psuser; GRANT` 这样就差不多好了. 下面开始搞 Python 与 SQLAlchemy 部分. 如果上面每个句子输入之后没回显结果, 并且交互环境开头变为了 `postgres-#` (注意 # 前是一个减号而非等号), 请查看一下句尾的分号是否漏掉了. 使用 SQLAlchemy 连接 Postgres 有关 SQLAlchemy 的基本使用请见这里. 编写这样一段 Python 代码, 来测试 Postgres 数据库连接是否可用 Posted at Jul 30 2012 - 04:04:32 Permanent Link: /p/493 Load full text	Post tags: Postgres Python SQLAlchemy
0 Page 1 2 3 4

	Back to Bit Focus
	NijiPress - Copyright (C) Neuron Teckid @ Bit Focus
	About this site

Bit Focus

基本例子

利用分词输出

获取 POST 请求体

条件表达式

编译步骤解释

多个正规异步调用出现在同一个语句中的编译顺序

目标

安装 Postgres 与基本配置

使用 SQLAlchemy 连接 Postgres