博客园_码农.KEN的园子

【转】Simple Erlang record wrapper

2011-11-25T15:52:00Z

原文出处：http://rouxviljoen.blogspot.com/2011/05/simple-erlang-record-wrapper.html

Most systems I have seen has some desired method of passing data from one application to another, whether it be records,proplists or something else. If you use mnesia, you end up dealing with a lot of records. This is where the pain for most startup Erlang programmers start. To use the awesome syntactic sugar of records, the module using the record needs to have it declared. The easy option is just to put the record definition in a .hrl file and include it in every module that uses the record, but that is not really viable if there are hundreds of different records passing through several modules per functional process.

Here we will quickly create a simple wrapper that can be used to give you access to your records without having to include your .hrl's everywhere.

To use this wrapper you will need to create a small module:

-module(first_record).
-define(NAME, test_record).
-record(?NAME, {id,name,surname}).
-include("wrapper.hrl").

Now for the wrapper, create a file called "wrapper.hrl"

-export([fields/0,
     rget/2,
     rset/2,
     new/0
    ]).

fields() -> record_info(fields,?NAME).
new() -> #?NAME{}.

rget(Field,Record) when is_atom(Field), is_record(Record,?NAME) ->
  element(fld_index(Field),Record);
rget(Fields,Record) when is_list(Fields), is_record(Record,?NAME) ->
  [ rget(Field,Record) || Field <- Fields].
 
rset(Fields,Record) when is_list(Fields), is_record(Record,?NAME) ->
  lists:foldl(fun({Field,Value}, Rec) -> setelement(fld_index(Field), Rec, Value) end, Record, Fields).
 
fld_index(Field) -> fld_index(fields(),Field,1).
fld_index([],Field,Index) -> 
  error_logger:error_report([{module,?MODULE},{function,fld_index},{arguments,[[],Field,Index]},{error,invalid_field},{stack,erlang:get_stacktrace()}]),
  erlang:error(invalid_field);
fld_index([Field|_T],Field,Index) -> Index + 1;
fld_index([_H|T],Field,Index) -> fld_index(T,Field,Index+1).

Now lets compile it and test:

38> c(first_record).
{ok,first_record}
39> l(first_record).
{module,first_record}
40> Record = first_record:new().
{test_record,undefined,undefined,undefined}
41> UpdatedRecord = first_record:rset([{name,"Roux"},{surname,"Viljoen"}],Record).
{test_record,undefined,"Roux","Viljoen"}
42> first_record:rget(name,UpdatedRecord).
"Roux"
43> first_record:rget([name,surname],UpdatedRecord).
["Roux","Viljoen"]

So rget/2 is equal to #REC.Field or #REC{Field1=Value1,Field2=Value2}=RecordVariable
and rset/2 is equal to #REC{Field=Value,Field2=Value2}

By using this little wrapper.hrl you can now create modules to represent the records and use the modules to manipulate the records.

Just remember that this example can be implemented in many different ways, depending on your requirement.

本文链接

【译】MochiWeb(基于Erlang的高性能WEB服务器)实用入门教程

2011-10-23T18:13:00Z

原文出处：http://alexmarandon.com/articles/mochiweb_tutorial/

简介

MochiWeb由Bob Ippolito 创建，其描述为：“一个创建轻量级http服务器的Erlang库”。它不是框架：不附带URL调度、模版引擎、数据持久等。尽管没有官方网站和文档，但仍然是Erlang构建web服务的热门选择。这篇随笔将带您逐步入门并构建一个支持URL调度和模版引擎的迷你型框架。（不包含数据持久）

我假设您已经具备一些Erlang语言的基础，否则，建议您先学习这本指南的前面部分章节，本教程不需要具备对并发和分布式Erlang的知识。

如果您遇到问题，可以从这里获取本教程相应的代码。每次提交对应本教程相应部分，所以你可以很容易的找到某个步骤相关的代码。

入门

首先使用Git从github获取MochiWeb源代码：

$ git clone git://github.com/mochi/mochiweb.git

接下来，我们创建一个项目，叫做 greeting:

$ cd mochiweb
$ make app PROJECT=greeting

很简单，现在我们可以编译和运行我们的app了:

$ cd ../greeting/
$ make
$ ./start-dev.sh

此时，你会看到一堆进度报告的信息，其中有类似于{port, 8080}字样，这是说我们的app将运行在8080端口。此时，可以打开浏览器，访问http://localhost:8080，你会看到一行信息：“stat running.” 标题栏显示“It Worked”，这说明运行成功了。

这时回到终端，按回车后将出现一个Erlang Shell>，你可以使它来跟你的app交互，这对app的调试非常有用。（相当于ROR的./script/console 或者 Django的manage.py shell）

文档

当我第一次在网上找关于MochiWeb的文档时，大部分搜索结果都是一些人也在找文档的信息。这也是我写本教程的原因。

实际上，MochiWeb本身包含一些参考文档，你可以这样生成它：

$ cd ../mochiweb
$ make edoc

之后，你可以在mochiweb所在目录的找到doc/index.html,用浏览器打开即可。它有助于了解模块概述、可用函数和函数的具体说明。

这里有一个很棒的视频教程展示了一种有趣的方法搭建完全基于MochiWeb的AJAX应用程序.

本篇教程中，我使用了一种更传统的方法来实现按规则将请求映射到相应的Erlang函数.(译者注：类似于Django中的url pattern 映射相应的views方法)

基本的请求处理

当我们首次请求app时，页面上显示的信息来自于greeting/priv/www/下的index.html文件，此目录将供我们放置一些静态文件，如css,图片等。现在，可能更有趣的事应该是开始创建一个请求处理程序，得到一些用户输入。

我们将在src/greeting_web.erl中插入一些代码来处理请求，该模块中包含一个函数 loop/2:

loop(Req, DocRoot) ->
    "/" ++ Path = Req:get(path),
    try
        case Req:get(method) of
            Method when Method =:= 'GET'; Method =:= 'HEAD' ->
                case Path of
                    _ ->
                        Req:serve_file(Path, DocRoot)
                end;
            'POST' ->
                case Path of
                    _ ->
                        Req:not_found()
                end;
            _ ->
                Req:respond({501, [], []})
        end
    catch
        %% ... exception handling code ...
    end.

如果你能阅读Erlang,应该不难理解这段代码的作用。它从请求中提取路径，如果该请求的Method是GET或HEAD(默认将"/"映射至/index.html),如果是POST或者其他HTTP动作，将返回404和错误提示。任何异常将被捕获并显示在终端，此处我没有给出异常处理的代码，但并不意味着你可以不管它。

我们现在要做的是添加一些代码来处理访问路径为/hello 的请求，从QueryString中获得用户名，并显示欢迎词，在上面代码中对GET请求处理的条件分支处添加下面的字句：

"hello" ->
  QueryStringData = Req:parse_qs(),
  Username = proplists:get_value("username", QueryStringData, "Anonymous"),
  Req:respond({200, [{"Content-Type", "text/plain"}],
               "Hello " ++ Username ++ "!\n"});

首先我们使用 mochiweb_request:parse_qs/0 方法得到包含query string参数的proplist ,然后用proplist:get_value/3 方法得到username的参数值,如果不存在则默认为"Anonymous".

最后我们调用mochiweb_request:respond/1方法，它需要传递一个元组参数，其中包含：HTTP状态码、头信息proplist、主体信息. 下面是我们的新loop/2函数:

loop(Req, DocRoot) ->
    "/" ++ Path = Req:get(path),
    try
        case Req:get(method) of
            Method when Method =:= 'GET'; Method =:= 'HEAD' ->
                case Path of
                    "hello" ->
                        QueryStringData = Req:parse_qs(),
                        Username = proplists:get_value("username", QueryStringData, "Anonymous"),
                        Req:respond({200, [{"Content-Type", "text/plain"}],
                                     "Hello " ++ Username ++ "!\n"});
                    _ ->
                        Req:serve_file(Path, DocRoot)
                end;
            'POST' ->
                case Path of
                    _ ->
                        Req:not_found()
                end;
            _ ->
                Req:respond({501, [], []})
        end
    catch
        %% ... exception handling code ...
    end.

使用make 编译你的项目，然后你可以访问http://localhost:8080/hello?username=Mike 将会看到《Erlang: The Movie》中的名言：Hello Mike!

渲染模版

你还在为刚刚实现的问候语功能而兴奋，但那太简单了。接下来让我们使用先进的HTML来提升下用户体验，我们使用ErlyDTL ,由Evan Miller 编写的Django模版语法的Erlang版实现。如果你还不了解Django的模版引擎语法，可以看其文档，不过我可以告诉你一些基本的，变量看起来像这样{{my_variable}}，控制语句是用这样的标签语法来实现{% tagname param %}这里是一些内容{% endtagname %}.

安装 ErlyDTL

首先添加ErlyDTL到我们的项目，MochiWeb使用rabar ,一个用于Erlang应用程序构建和打包的工具。我们可以用它来为项目添加依赖.打开rebar.config文件，你会看到一个条目指向MochiWeb的git仓库，让我们添加另外一个指向ErlyDTL的条目，此时配置文件应该是这样：

%% -*- erlang -*-
{erl_opts, [debug_info]}.
{deps, [
  {erlydtl, ".*",
   {git, "git://github.com/evanmiller/erlydtl.git", "master"}},
  {mochiweb, ".*",
   {git, "git://github.com/mochi/mochiweb.git", "master"}}]}.
{cover_enabled, true}.
{eunit_opts, [verbose, {report,{eunit_surefire,[{dir,"."}]}}]}.

你仅仅只需要输入make，即可获取和编译ErlyDTL:

$ make
==> mochiweb (get-deps)
==> greeting (get-deps)
Pulling erlydtl from {git,"git://github.com/evanmiller/erlydtl.git","master"}
Initialized empty Git repository in /home/al/dev/projects/greeting/deps/erlydtl/.git/
==> erlydtl (get-deps)
==> erlydtl (compile)
Compiled src/erlydtl_parser.yrl
[...]

由于使用了新的库，要使其生效，需重启应用程序。终端输入q(). 然后再执行./start-dev.sh。

当然，这个方法不仅仅用于ErlyDTL,你也可以用rabar,同样的方法添加其他的依赖。

模版编译

ErlyDTL会把Django模版编译为Erlang字节码，rabar恰恰完美支持在我们的代码中管理编译ErlyDTL模版，所以我们使用它。

我们将创建一个 templates 目录,它是rabar编译时默认的模版目录:

$ mkdir templates

现在创建一个模版文件 templates/greeting.dtl ，内容大概如下：

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>MochiWeb Tutorial</title>
    <link rel="stylesheet" type="text/css" href="/style.css" media="screen">
  </head>
  <body>
    <p>
        Hello {{ username }}!
    </p>
  </body>
</html>

再次make, 你会看到rabar创建了一个Erlang模块 ebin/greeting_dtl.beam. 注意，rabar提供了一些选项来自定义模版源文件和编译文件的路径和名称。

现在你可以用下面的代码在处理请求时使用新的模版：

QueryStringData = Req:parse_qs(),
Username = proplists:get_value("username", QueryStringData, "Anonymous"),
{ok, HTMLOutput} = greeting_dtl:render([{username, Username}]),
Req:respond({200, [{"Content-Type", "text/html"}],
        HTMLOutput});

运行make ,刷新浏览器，你会被你的设计佳作吓到。

正如您看到的，当代码改动后，你需要执行make使之生效。从现在起，我将不再重申需要make。

POST请求处理

至此，你的app已经很受欢迎了，但是很多用户会抱怨他们记不住QueryString的语法，并希望能够通过页面填写表单的形式来提交用户名。现在编辑模版，为username添加一个文本框表单：

<form method="POST">
    <p>Username: <input type="text" name="username"></p>
    <input type="submit">
</form>

你还需要更改一下请求处理程序，使其支持POST请求，它看起来应该像这样：

loop(Req, DocRoot) ->
    "/" ++ Path = Req:get(path),
    try
        case Req:get(method) of
            Method when Method =:= 'GET'; Method =:= 'HEAD' ->
                case Path of
                    "hello" ->
                        QueryStringData = Req:parse_qs(),
                        Username = proplists:get_value("username", QueryStringData, "Anonymous"),
                        {ok, HTMLOutput} = greeting_dtl:render([{username, Username}]),
                        Req:respond({200, [{"Content-Type", "text/html"}],
                                HTMLOutput});
                    _ ->
                        Req:serve_file(Path, DocRoot)
                end;
            'POST' ->
                case Path of
                    "hello" ->
                        PostData = Req:parse_post(),
                        Username = proplists:get_value("username", PostData, "Anonymous"),
                        {ok, HTMLOutput} = greeting_dtl:render([{username, Username}]),
                        Req:respond({200, [{"Content-Type", "text/html"}],
                                HTMLOutput});
                    _ ->
                        Req:not_found()
                end;
            _ ->
                Req:respond({501, [], []})
        end
    catch
        % ... exception handling code ...
    end.

它看起来工作得非常好，但还是有一些问题。可见"hello"出现在了2个地方，不是个好兆头。重复代码来渲染模版和返回Response也不太好。我们注意到，当我们访问/hello/ （末尾加斜杠）的地址时会得到一个页面未找到的错误。是时候做一些重构了。

简单的URL调度器(Dispatcher)

我们将创建一个简约的URL调度器来实现对URL规则与Erlang函数的的映射，url规则配置看起来像这样：

[
  {"^hello/?$", hello}
]

这是说所有以/hello 或者 /hello/ 的请求都会被路由到名为hello的函数。下面给出调度器的代码：

% Iterate recursively on our list of {Regexp, Function} tuples
dispatch(_, []) -> none;
dispatch(Req, [{Regexp, Function}|T]) -> 
    "/" ++ Path = Req:get(path),
    Method = Req:get(method),
    Match = re:run(Path, Regexp, [global, {capture, all_but_first, list}]),
    case Match of
        {match,[MatchList]} -> 
            % We found a regexp that matches the current URL path
            case length(MatchList) of
                0 -> 
                    % We didn't capture any URL parameters
                    greeting_views:Function(Method, Req);
                Length when Length > 0 -> 
                    % We pass URL parameters we captured to the function
                    Args = lists:append([[Method, Req], MatchList]),
                    apply(greeting_views, Function, Args)
            end;
        _ -> 
            dispatch(Req, T)
    end.

将调度器代码插入到 greeting_web.erl 的适当位置，并修改loop/2 函数来使用它：

loop(Req, DocRoot) ->
    "/" ++ Path = Req:get(path),
    try
        case dispatch(Req, greeting_views:urls()) of
            none -> 
                % No request handler found
                case filelib:is_file(filename:join([DocRoot, Path])) of
                    true -> 
                        % If there's a static file, serve it
                        Req:serve_file(Path, DocRoot);
                    false ->
                        % Otherwise the page is not found
                        Req:not_found()
                end;
            Response -> 
                Response
        end
    catch
        % ... exception handling code ...
    end.

现在我们来创建一个模块，其包含所需的URL规则配置和请求处理程序。新建 src/greeting_views.erl 文件，并输入以下代码：

-module(greeting_views).
-compile(export_all).
-import(greeting_shortcuts, [render_ok/3]).

urls() -> [
      {"^hello/?$", hello}
    ].

hello('GET', Req) ->
    QueryStringData = Req:parse_qs(),
    Username = proplists:get_value("username", QueryStringData, "Anonymous"),
    render_ok(Req, greeting_dtl, [{username, Username}]);
hello('POST', Req) ->
    PostData = Req:parse_post(),
    Username = proplists:get_value("username", PostData, "Anonymous"),
    render_ok(Req, greeting_dtl, [{username, Username}]).

我们再使用一个函数 render_ok/3 来防止返回Response时的重复代码。让我们把这个函数放到 src/greeting_shortcuts.erl 文件中:

-module(greeting_shortcuts).
-compile(export_all).

render_ok(Req, TemplateModule, Params) ->
    {ok, Output} = TemplateModule:render(Params),
    % Here we use mochiweb_request:ok/1 to render a reponse
    Req:ok({"text/html", Output}).

现在，你已经有了一些通用方式来处理请求了；我们删除了一些重复代码，使得看起来更加有条理了，并且也定义了专门放置请求处理程序和工具函数的地方。

一切都挺不错，但是你的朋友告诉你，他想能通过GET请求获得一个欢迎辞，但他却觉得用QueryString的方式（?username=alice）很难看。而他希望通过这样的访问地址/hello/Alice 或/hello/Alice/ 即可得到一个欢迎辞页面。幸运的是，我们的URL调度器已经能很容易的实现该新功能。

添加第二个URL配置项，现在配置看起来是这样：

urls() -> [
      {"^hello/?$", hello},
      {"^hello/(.+?)/?$", hello}
    ].

再创建一个请求处理函数 (在 greeting_views.erl 中)，该函数可接收URL中的参数：

hello('GET', Req, Username) ->
    render_ok(Req, greeting_dtl, [{username, Username}]);
hello('POST', Req, _) ->
  % Ignore URL parameter if it's a POST
  hello('POST', Req).

瞧，现在/hello/Alice 或 /hello/Alice/ 都可以正常工作了。

处理COOKIES

你收到了许许多多的反馈，有些反馈是希望可以在下次再访问/hello/ 的时候能记住之前他们的名字就更好了。我们使用cookie来实现它，编辑greeting_shortcuts.erl文件，并添加一个函数返回一个cookie值，若不存在则返回默认值。还需要创建一个新函数 render_ok/4 ，它基本上很像我们已有的 render_ok/3，除了它需要一个额外的参数 Headers用于发送Cookie头。修改render_ok/3 让其直接调用 render_ok/4 ,传递一个空的list给Headers参数。

-module(greeting_shortcuts).
-compile(export_all).

render_ok(Req, TemplateModule, Params) ->
    render_ok(Req, [], TemplateModule, Params).

render_ok(Req, Headers, TemplateModule, Params) ->
    {ok, Output} = TemplateModule:render(Params),
    Req:ok({"text/html", Headers, Output}).

get_cookie_value(Req, Key, Default) ->
    case Req:get_cookie_value(Key) of
        undefined -> Default;
        Value -> Value
    end.

现在编辑你的视图模块，使用以上新函数，而我们还需要删除一些重复的东西：

-module(greeting_views).
-compile(export_all).
-import(greeting_shortcuts, [render_ok/3, render_ok/4, get_cookie_value/3]).

urls() -> [
      {"^hello/?$", hello},
      {"^hello/(.+?)/?$", hello}
    ].

% Return username input if present, otherwise return username cookie if
% present, otherwise return "Anonymous"
get_username(Req, InputData) ->
    proplists:get_value("username", InputData,
        get_cookie_value(Req, "username", "Anonymous")).

make_cookie(Username) ->
    mochiweb_cookies:cookie("username", Username, [{path, "/"}]).

handle_hello(Req, InputData) ->
    Username = get_username(Req, InputData),
    Cookie = make_cookie(Username),
    render_ok(Req, [Cookie], greeting_dtl, [{username, Username}]).

hello('GET', Req) ->
    handle_hello(Req, Req:parse_qs());
hello('POST', Req) ->
    handle_hello(Req, Req:parse_post()).

hello('GET', Req, Username) ->
    Cookie = make_cookie(Username),
    render_ok(Req, [Cookie], greeting_dtl, [{username, Username}]);
hello('POST', Req, _) ->
  hello('POST', Req).

当用户设置过他们的用户名时，用户名将被存储为cookie,且下次访问/hellp/时将被显示。

结论

本教程就到这里，现在你已经知道了如何添加库到项目、获取用户输入、渲染模版和设置cookies, 你需要积累更多的功能，如用户认证、全局模版上下文、数据持久等等。还需要修改URL调度器使其能映射到指定模块的指定方法，或用其他方法，或许采用“约定大于配置”会比较好。

我希望你稍微多熟悉一下MochiWeb,那样你才可以用最合适的方法来实现你的需求。浏览API文档，了解更多MochiWeb所提供的功能，毫不犹豫的阅读其源代码。这里有一些我使用Erlang库工作的一些“真理”：源代码通常比文档讲得更多；有幸你跟我一样的话，你会发现Erlang的代码通常比其他语言更容易理解, 可能是因为它的函数式特性和简约。

本文链接

MAC OS中安装MySQLdb-python的问题解决记录.

2011-05-14T05:58:00Z

最近换了macbook pro，搭建python开发环境的时候需要装MySQLdb-python（一个常用的python mysql驱动库），由于snow leopard默认是64位导致装一些软件没有在linux下那么顺利..这个MySQLdb就折腾了半天.

一开始，直接用 $sudo easy_install mysql-python安装过程无任何异常，但在python shell中>import MySQLdb时出现如下异常：

ImportError: dlopen(/Users/laixian/.python-eggs/MySQL_python-1.2.3-py2.6-macosx-10.6-universal.egg-tmp/_mysql.so, 2): no suitable image found. Did find: /Users/laixian/.python-eggs/MySQL_python-1.2.3-py2.6-macosx-10.6-universal.egg-tmp/_mysql.so: mach-o, but wrong architecture

发现我最开始装的mysql是32-bit的，又重新下载了x86_64的dmg重新安装mysql。

此时，直接把site-packages/下面关于MySQLdb的文件夹全部删掉. 再重新安装一次MySQLdb,如下：

$ sudo rm -r /Library/Python/2.6/site-packages/MySQL_python-1.2.3-py2.6-macosx-10.6-*

$ sudo easy_install mysql-python

再次进入python shell>import MySQLdb,依然异常，信息大致如下：

ImportError: dlopen(/Users/laixian/.python-eggs/MySQL_python-1.2.3-py2.6-macosx-10.6-universal.egg-tmp/_mysql.so, 2): Library not loaded: libmysqlclient.16.dylib

此时只需要设置一个环境变量即可:

export DYLD_LIBRARY_PATH=/usr/local/mysql/lib/

再次尝试python> import MySQLdb, 搞定.

本文链接

【原创分享】django-m2doc, 自动根据project下的所有models生成数据表结构文档.

2011-03-18T04:00:00Z

背景

一般在开发项目之前都会先绘出ER图等，但在使用Django做项目时都是希望快速搭建，所以都在大脑中构思好草图之后，直接开始coding建模，其实个人认为阅读django的models就已经能非常清晰的了解到对象关系等了，但毕竟有时候你的项目是需要给别人看的（如：客户），所以还是需要有规范的文档. 此时，我们需要一个工具能根据已coding好的Models自动生成Document.

对于上述需求，我认为应该是很常见的.但GOOGLE一圈确实没有发现类似的工具, 于是便自己动手实现，顺便起了个名字就叫django-m2doc吧.

预览

实现

能够轻松实现该功能，得益于python这门简易强大的动态语言特性，使我们能够很容易得到任意对象的属性.

其中主要用到两点：

1.inspect

2.dynamic import

完整代码：

#coding:utf-8

import sys, os
import inspect
from django.conf import settings
from django.db import models
from django.template import Context, Template

template = '''
    <html>
        <head>
            <title>Data table schema document</title>
            <style type="text/css">
                .loopeven {background:#f1f1f1;}
                .loopodd {}
            </style>
        </head>
        <body>
            {%for model,fields in models%}
            <div style="clear:both; margin-top:40px; display:inline;">
                <table border="0" width="100%">
                    <tbody>
                        <tr><td colspan="4" style="border:1px solid #000;"><b>Model Name: {{model|safe}}<b></td></tr>
                        <tr style="background:#000; color:#fff;"><th width="15%">列名</th><th width="15%">简称</th><th width="15%">列类型</th><th>描述</th><tr>
                        {%for field in fields%}
                        <tr style="background:#{%cycle 'f1f1f1' 'ffffff'%}">
                            <td>{{field.name}}</td>
                            <td>{{field.verbose_name}}</td>
                            <td>{{field.class_name}}{%if field.related_name%}({{field.related_name}}){%endif%}</td>
                            <td>{{field.help_text}}</td>
                        <tr>
                        {%endfor%}
                    </tbody>
                </table>
            </div>
            {%endfor%}
            <div style="margin-top:50px; padding:10px; width:100%;
            text-align:center;">this document generated by the <a href="http://ken-zhang.cnblogs.com"> django-m2doc</a></div>
        </body>
    </html>
'''

def get_propertys(cls):
    fields = []
    for f in cls._meta._fields():
        setattr(f, 'class_name', f.__class__.__name__)
        if hasattr(f, 'related'):
            setattr(f, 'related_name', f.related.parent_model.__name__)
        fields.append(f)
    return fields

def main():
    mod_list = []
    model_list = []
    for app in settings.INSTALLED_APPS:
        mod_list.append('%s.%s' % (app, 'models'))
    modules = map(__import__, mod_list)
    for s_model in mod_list:
        for member in inspect.getmembers(sys.modules[s_model], predicate=inspect.isclass):
            name,obj=member
            module_name = inspect.getmodule(obj).__name__
            print module_name
            if module_name == s_model and hasattr(obj, '_meta') and not module_name.startswith('south.'):
                model_list.append((obj.__name__, get_propertys(obj)))
    if model_list:
        t = Template(template)
        c = Context({'models':model_list})
        html = t.render(c)
        html_file = open('models_doc.html', 'w+')
        html_file.write(html)
        html_file.close()

if __name__ == '__main__':
    main()

说明

该程序将自动查找settings.INSTALLED_APPS中已定义的app下的models并生成文档，将保存在path/to/project/models_doc.html

本文链接

【分享】利用decorator实现Django表单防重复提交

2010-12-24T17:14:00Z

背景：

　　我的用例中不可出现重复的记录，如：下订单，用户填好表单然后Submit，当用户网速较慢时，很可能会习惯性的刷新当前页，而刷新操作会导致再次POST，此时若不加判断直接入库必然导致用户后台增加N个订单。

解决思路：

Step 1：首先我们在进入表单填写页面时，对该页面（或view吧）随机生成一个校验字符串并存放于Session中，在页面form中新增一个hidden input来存放，以便提交时一起POST到服务器端；

Step 2：当POST时，服务器端将收到的校验串与Session中对应值比对，若相同则正常提交，否则跳转至指定的错误提示页面；需要注意的是当比对成功后，必须立即将该Session的值设置为空，这样才可保证页面再次POST时表单中的校验串就无法于Session中的空值比对成功。

实现：

为了方便使用，我们将上述思路写成一个decorator(装饰器). 当然也是为了符合DRY嘛；代码很简单就看中间那几行，需注意唯一的一个参数page_key,为了不跟多个表单页面发生Session key冲突。（补充一点：必须将表单填写页面的view同时使用@never_cache装饰，因为django默认将所有view都做缓存，当再次进入表单页时，就不会重新生成随机串，导致校验无故失败。。。）

# coding:utf-8

try:
    from functools import wraps
except ImportError:
    from django.utils.functional import wraps  # Python 2.4 fallback.
import random
from django.conf import settings
from django.utils.decorators import available_attrs
from django.utils.hashcompat import md5_constructor

if hasattr(random, 'SystemRandom'):
    randrange = random.SystemRandom().randrange
else:
    randrange = random.randrange
_MAX_CSRF_KEY = 18446744073709551616L     # 2 << 63

def _get_new_submit_key():
    return md5_constructor("%s%s" % (randrange(0, _MAX_CSRF_KEY), settings.SECRET_KEY)).hexdigest()

def anti_resubmit(page_key=''):
    def decorator(view_func):
        @wraps(view_func, assigned=available_attrs(view_func))
        def _wrapped_view(request, *args, **kwargs):
            if request.method == 'GET':
                request.session['%s_submit' % page_key] = _get_new_submit_key()
                print 'session:' + request.session.get('%s_submit' % page_key)
            elif request.method == 'POST':
                old_key = request.session.get('%s_submit' % page_key, '')
                if old_key == '':
                    from django.http import HttpResponseRedirect
                    return HttpResponseRedirect('/page_expir')
                request.session['%s_submit' % page_key] = ''
            return view_func(request, *args, **kwargs)
        return _wrapped_view
    return decorator

使用示例：

1 @anti_resubmit(page_key='your_view')
2  def your_view(request):
3     '''若是表单填写页和POST的view不是同一个，則需在两个view上都使用anti_resubmit装饰器'''
4     pass #您可别跟着pass噢

本博客所有原创内容均可随意转载，但请注明来源！

本文链接

Django轻松使用富文本编辑器-KindEditor

2010-12-16T02:44:00Z

2010-12-16T02:44:00Z2010-12-16T02:44:00Z码农.ＫＥＮhttp://www.cnblogs.com/ken-zhang/

由于需要在django admin中使用到富文本编辑器，由于我比较喜欢KindEditor，于是写了个自定义widget

1、首先从KindEditor主页下载，并解压至你的static文件存放目录(略...)

2、编写自定义widget：

from django import forms

from django.conf import settings

class KindEditor(forms.Textarea):

class Media:

js = (settings.MEDIA_URL + 'js/widgets/kindeditor.js',)

css = (settings.MEDIA_URL + 'js/widgets/kindeditor.css',)

def __init__(self, attrs = {}):

attrs['rel'] = 'kind'

super(KindEditor, self).__init__(attrs)

3、在form中使用上面的widget：

from customwidget.editor import KindEditor
from django import forms
from app.models import MyModel
from django.contrib import admin

class MyModelAdminForm(forms.ModelForm):
        pass

        class Meta:
              model = MyModel
    widgets = {

'fieldname':KindEditor()

}

class MyModelAdmin(admin.ModelAdmin):

form = MyModelAdminForm

admin.site.register(MyModel, MyModelAdmin)

4、需要在模板中使用JS来初始化KindEditor(请确保你的模板中已加载jQuery, django admin中已自带，不过namespace换到了django之下)：

{%extends "admin/change_form.html"%}

{%block extrahead%}
    {{block.super}}
     <script type="text/javascript">
           django.jQuery(document).ready(function(){
                django.jQuery("textarea[rel='kind']").each(function(n){
                          KE.show({
                               id : django.jQuery(this).attr("id"),
                          });
                });
           });
      </script>
{%endblock%}

4、需要注意的地方：

a) 所下载的kindeditor文件包存放的位置及settings里的MEDIA_URL地址（其实就是保证最终生成的JS和CSS访问路径是正确的）

b) 若非django admin的模板，请自行加载jQuery

本文链接

分享自己写的纯JS（jQuery）分页控件，也希望高手给予优化

2010-09-14T04:37:00Z

/*Paginator*/

    .paginator {}
    .paginator ul {list-style:none;}
    .paginator li{float:left; margin-left:5px;}
    .paginator li a { height:20px;
                      line-height:20px;
                      padding:2px;
                      text-decoration:none;
                      text-align:center;
                      display:block;
                      border:1px solid #000;
                      color:#000;
                    }
     .paginator li .pagenum { width:20px;}
     .paginator li .selected { color:#fff; background:#000;}
     .paginator li .unable { color:#CCC; border:1px solid #ccc;}

使用示例

Paginator.init({size:25, curpage:5, p_container_id:"paginator"},

function(p){

//此处做page number 变化后重新加载数据的操作, 参数p为当前页码

});

还是给个演示地址： http://www.weatrue.com/paginator.html

本文链接

【转】TF-IDF算法扫盲2

2010-06-19T16:25:00Z

本文转载自http://www.mryang.org/logs/45675845.html

TF-IDF算法是一种简单快捷的文档特征词抽取方法，通过统计文档中的词频来对文档进行主题分类。TF-IDF(term frequency–inverse document frequency)是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降。TF-IDF加权的各种形式常被搜索引擎应用，作为文件与用户查询之间相关程度的度量或评级。

TF-IDF其主要思想是，如果某个词或短语在一篇文章中出现的频率TF高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。TF词频(Term Frequency)指的是某一个给定的词语在该文件中出现的次数。IDF反文档频率(Inverse Document Frequency)是指，如果包含词条的文档越少，IDF越大，则说明词条具有很好的类别区分能力。使用TF-IDF可以计算某个关键字在某篇文章里面的重要性，可以用此关键词来表达文档所包含的含义。

词频Term Frequency(tfij)表示文档i中词汇j出现的频率，计算公式如下：

其中，nij表示词j在文档i中出现的次数，分母则是文档j中所有字词出现的次数之和。

逆向文档频率Inverse Document Frequency(idfj)：是一个词普遍重要性的度量，由下面的式子计算：

其中，｜D｜是文档总数，分母是包含词ti的文档数目。

tfidfij权值（wij）：wij = tfij * idfi。权值就是最终要得到的结果，权值的高低直接表明了该题词是否反应了文档的主题。

实验的第一个步骤是分词，英文的分词很简单，中文分词就是个难题了。在实验中使用了中科院的ICTCLAS（Institute of Computing Technology, Chinese Lexical Analysis System）系统。该系统应该说是国内较好的分词系统，是中国科学院计算技术研究所在多年研究工作积累的基础上，基于多层隐马模型研制出的汉语词法分析系统，主要功能包括中文分词；词性标注；命名实体识别；新词识别；同时支持用户词典。

在分词时为了提高分词效果，我加入了自己的用户词典。不过词语不多，只有17个，如果要准确一点的话，应该再多一点。

分词后，去掉里面的词性标注，然后在去掉里面的停用词（这一步做得不是很好，停用词表有900个词，但是在最后统计中发现还是有一些停用词）。

最后一步就是利用上面的公式进行词频统计了。统计的方法很多，可以些程序，也可以处理后放到数据库、Excel或装用的统计软件统计。我这里主要是放到数据库后用程序来统计。

统计的结果还算满意。我选择了学生心理在线上关于大学生心理健康的文章13篇，主要关于爱情、就业、性教育、学习、人际交往等几个方面。统计的结果表明，抽取的主题词70％左右的表明文章的主题，还有一些则是由于分词错误，使得该词没有体现主题，但权值较高。

这个实验只是一个验证实验，要达到实际应用需求，在TF-IDF中还需要做很多的改进。比如考虑语句关系、词性关系、文章关系、文章标题的重要程度等。

注意：如果你在中国大陆且看不见文章中的图片，请按照这里的说明修改Hosts文件。

本文链接

【转】关键字提取算法之TF-IDF扫盲

2010-06-19T16:20:00Z

TF-IDF（term frequency–inverse document frequency）是一种用于资讯检索与资讯探勘的常用加权技术。TF-IDF是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随著它在文件中出现的次数成正比增加，但同时会随著它在语料库中出现的频率成反比下降。TF-IDF加权的各种形式常被搜寻引擎应用，作为文件与用户查询之间相关 ...

TF/IDF算法可能并不是百度的重要方法，google适用；百度个人认为是向量空间模型，实质也是TF/IDF。

在招聘的时候，如果碰到信息专业的学生，我总是喜欢问，你知道信息论是谁提出来的吗？应聘的人没有一个能答出来，哎呀，信息论其实对于SEO非常重要，建议大家来看下，tf、idf看起来是比较简单的的一个信息处理方法，但是想搞明白并且在实际工作中灵活适用，怕不是那么容易的事情了。--沙僧SEO.

在今日我们可以从网络上吸收大量资讯，有时候一堆文章看不完。如果我们想要吸收资讯，时间却又不够的时候，使用电脑帮我们过滤资讯，或是用电脑帮我们做个总整理，是个方法。如果今天手中有一篇文章，我们想要用电脑帮我们找出这篇文章最重要的关键字，要怎麽做呢？在资讯检索 (IR: Information Retrieval)领域里面，有个基础的方法，入门必学的方法，就是使用 TF 和 IDF (TF: Term Frequency, IDF: Inverse Document Frequency)。使用这两个估计值，可以让电脑具有计算重要关键字的能力，进而节省我们的时间。

接下来让我们看看，TF 和 IDF 个是甚麽东西呢？TF 全名是Term Frequency，也就是某个关键字出现的次数，譬如说某篇文章里面，「电脑」这个词出现很多次，或是「使用者需求」这个词出现很多次，那麽这些词句的出现频率，就会很高。一篇文章中出现很多次的词句，必定有其重要性。譬如说一篇论述「人工智慧」的文章，「人工智慧」这个词句再文章中出现的频率也一定很高。然而为甚麽除了 TF (Term Frequency) 以外，还要有 IDF (Inverse Document Frequency) 呢？

让我们先想想，如果单使用某个字词出现的频率，来判断一篇文章最重要的关键字，会有甚麽困难。首先，我们会遇到一些常用字词，出现的频率也很高，会和重要字词出现的频率一样高，让电脑因此无法分辨出，哪些是常用字词，那些是重要字词。如果就英文来说，有个规则是语言学家 (linguist) 归纳出来的规则，叫做 Zipf’s Law。

引述中文维基百科的一段介绍如下：

从根本上讲, 齐夫定律可以表述为, 在自然语言的语素库里, 一个单词出现的频率与它在频率表里的排名成反比. 所以, 频率最高的单词出现的频率大约是出现频率第二位的单词的 2 倍，而出现频率第二位的单词则是出现频率第四位的单词的2倍。这个定律被作为任何与 power law probability distributions 有关的事物的参考。这个 “定律” 是 Harvard linguist George Kingsley Zipf (IPA [z?f])发表的。

比如, 在 Brown 语库， “the” 是最常见的单词，它在这个语库中出现了大约 7 %（10 万单词中出现 69971 次）。正如齐夫定律中所描述的一样，出现次数为第二位的单词 “of” 占了整个语库中的 3.5% (36411次), 之後的是”and” (28852次). 仅仅 135 但此项就占了 Brown 语库的一半。

所以我们现在知道问题在哪边了。如果只用词句出现的频率来判断某一篇文章里面最重要的关键字，我们可能会找到常用字，而不是最重要的字，像是英文里面的 “the”、”a”、”it”，都是常常出现的字，但是通常一篇文章里面最重要的字不是这些字，即使那些重要的字出现的频率也很高。

这个时候我们要怎麽办呢？IDF 在这个时候就帮上忙了。在了解 IDF 之前，我们先了解 DF 是甚麽。DF 就是Document Frequency，也就是说，如果今天我们手中有固定 N 篇文章，某个关键字的 Document Frquency (DF)，就是说这个关键字在 N 篇文章里面出现了几次。Inverse Document Frequency (IDF) 则是把 DF 取倒数，如此一来，一个数字乘以 IDF，就等於是除以 DF 的意思。

有了 TF 和 IDF 以後，我们就可以计算 TF 乘上 IDF，对每一个关键字都算出一个分数。这个分数的高低，就代表了这个关键字在某篇文章中的重要程度。为甚麽我们说这样子可以找出重要的字，而不是常出现的字呢？因为 TF 会把某篇文章中，出现最多次的排在第一位，其次的排在第二位，以此类推。然而乘上 IDF 以後，也就是除以 DF，那些常常出现的字，像是英文中的 “the”、”a”、”it”，因为每一篇文章都会出现，所以 DF 就大。DF 大，取倒数之後的 IDF 就小，IDF 小，乘上 TF 以後，虽然”the”、”a”、”it”在某篇文章中出现的频率很高，但是因为 IDF 小，TF * IDF 一相乘，重要性就变低了，我们 (电脑程式) 就不会把这些常出现的字，误认为是重要的字了！

真正重要的字会得到甚麽样子的分数呢？如果这篇文章刚好在讲 AI，”AI” 出现很多次，因此 “AI” 在这篇文章里面的 TF 很高。然而我们电脑资料库里面的 N 篇文章，并不是每一篇都在讲 AI，也因此”AI”可能只有在 N 篇文章里面的某 3 篇文章出现，因此 DF 只有 3，IDF 变成 0.33，假设我们 N = 100 有 100 篇文章在资料库里面，其他常出现字像是 “the” 每一篇都出现，DF 就是 100，IDF 就是 0.01。所以 “AI” 的 IDF 会比 “the” 的 IDF 高，假设这篇文章中 “AI” 和 “the” 两个字出现的次数刚好一样，乘上 IDF 以後，”AI” 这个字的分数就比 “the” 这个字的分数来的高，电脑也就会判断 “AI” 是这篇文章重要的关键字，而 “the” 这个字并不是这篇文章的重要关键字。

所以经由 TF * IDF，我们可以计算某个关键字，在某篇文章里面的重要性。从这一个方向，我们可以计算一篇文章中重点的字有哪些，帮我们做一篇文章的总整理。从相反的方向，我们可以给定关键字，然後再每一篇文章里面为这个关键字计算一次 TF * IDF，然後比较哪一篇文章，这个关键字是最具重要性的，用这个方法找出和一个关键字最相关的文章。不管是从文章找出重点字词，或是由关键字找相关文章，TF * IDF 都是个基本且不错的方法。会写程式又还没嚐试过这个方法的读者，或许可以亲自试试看，不过可能要先自己准备文章资料库 (corpus)，或是从网际网路上面用网页撷取器 (crawler) 存几篇有兴趣的网页，然後把 HTML 标签清理乾净，剩下纯文字，就可以用这个方法来小试身手罗！

我们也可以比较一下人类和电脑的不同。电脑做数学数字的计算，或是执行固定的步骤，非常擅长，速度也很快。人类可以了解一个字的意思，读完一篇文章以後，了解了意思，之後要找这篇文章最重要的关键字，是从「意义」开始，回忆出或做出结论，这篇文章重要的关键字是甚麽。
　　然而如果要电脑也遵照这个方向，先了解字的意义，再了解文章的意义，然後在做出结论，这篇文章的重要关键字，反而困难，因为要了解字的意义，电脑需要先有一个语意网路 (Semantic Network)，或是知识的分类关系树 (Ontology)，把字句依照语意分门别类，有如生物里面的「界门纲目科属种」一般的关系分类，才有办法了解一个字和其他字的关系。之後要了解一篇文章，又必须要了解一个句子，牵涉到自然语言处理 (NLP: Natural language Processing) 的问题，像是从句子里面找出主词、动词、和受词，以及补语，分辨出子句和主句，代名词的指称，以及前後文判断产生不同的剖析 (parsing)。了解完一句，才能了解整篇文章。

因此，TF * IDF 对於电脑来说，计算速度快，工程也不浩大，不用大型计算机就可以计算。这边也可以顺便提到 strong AI 和 weak AI 的关系。如果就工程的角度，TF * IDF 是个好方法，it works! 节省我们的时间，或是解决大问题中的一个小环节。然而 strong AI 在这边会提出「中文房间」(Chinese Room) 的论证，也就是说，电脑能够找出重要关键字，是否就代表电脑真的「知道」(understand) 关键字的意义呢？

中文房间 (Chinese Room) 简单地说，就是一个人关在房间里面，只留两个窗口，一个地方会送纸条出来，另一个地方会送纸条出去。房间里面有一本手册，里面写满对照表，记载者看到甚麽英文字，就应该输出甚麽中文字，以及一些指令的对照，譬如说窗口送一个指令说 COMBINE，就把两个中文字写在一起才送出去。接着我们在外面就开始送英文句子进去这个房间，另一个窗口就会有这句话的中文翻译跑出来。然而这个论证想要坦讨的就是，虽然这个房间看起来像是会把英文翻译成中文，但是在房间里面的那个操作人员并不懂中文，他指是按照指令，还有手册里面的对照表，机械式地动作，可是外面看起来像是这个房间会英翻中，因此这个房间应该懂得中文才对。

在这边我的看法是，也许就近程来看，我们只要有可以解决问题的解答就可以，不管电脑是否真的懂 (understand) 字的意义。然而长期来说，如果我们真的需要具有人类的智力的电脑出现，能够真的懂而不是行为上看起来懂，那麽就要仔细探讨中文房间这种论证。也许生物的方法，像是计算神经科学的方法，是一个方向。

我们可能又会问，神经元只有动作电位和静止两个状态，怎麽能了解意义？但是只有一个神经元，或许没办法了解意义，全部大脑的神经元交互作用，意义可能就因此被了解了！其中的奥妙，就是计算神经科学嚐试要解答的问题之一。有兴趣的读者也可以一起从人脑开始，解决 strong AI 的问题。或是有数学的高手，也许某一个数学理论，可以很漂亮地解决意义了解的问题也说不定，像是 manifolds，具有一个集合使用不同面向来观看的特性，同时具有 Global 和 Local 的性质，是个不错的候选选项。从这个方向去解决 strong AI 也是另一个可能性。总之，继续努力研究就是了！

本文链接

python django学习-问题记录及解决方法

2010-03-04T16:11:00Z

最近在学习python django WEB开发框架，过程中遇到了不少的坎坷，特在此作下记录以便回顾，或许你也正在为这些问题而发愁？

1. 使用NetBeans for python作为编辑器时，你会发现输入的汉字都变成了小方框···

解决方法：需要将系统中的相应字体拷贝至jdk目录中，打开终端并输入: mkdir {JAVA_HOME}/jre/lib/fonts/fallback

此处注意将{JAVA_HOME}换成你的jdk主目录,mkdir执行完毕后，输入:

cp /usr/share/fonts/truetype/arphic/uming.tcc {JAVA_HOME}/jre/lib/fonts/fallback,重启netbeans再试试·应该能输入汉字了吧？

2. 一般看python的相关资料时，都会提醒你python代码对于缩进比较严格，可是你一定没有放在心上吧？一次我在给django项目添加admin应用，配置url映射的时候，总是访问出错，检查了若干次代码都没有发现代码逻辑问题，最后看错误提示中说非法的缩进···才发from django.contrib....这句前面多了个空格。

解决方法：去掉空格（^_^）

3.当你创建一个django项目，并写完一个view，测试时是否发现了凡是里面出现过中文的，访问时都会出错，但编译正常？那是因为默认的编码不支持中文

解决方法：在文件的最前面加上以下两行

#!/usr/bin/env python
# -*- coding: utf-8 -*-

4.在创建Category模型时，想利用继承自身来实现递归无线级分类，于是输入了parent=models.ForeignKey('self',null=True,verbose_name="父类标识")

可是进入admin后台去创建Category时··你会发现创建第一个就会受到阻碍，提示必须选择一个父类。既然是第一个，又怎么能选到父类呢。。不是设置了null=True了吗（可空）？

解决方法：还需要加上blank=True,如：parent=models.ForeignKey('self',null=True,blank=True,verbose_name="父类标识")

5.由于django一直推荐搭配PostgreSQL数据库，其本身也是比较优秀的开源数据库，所以我们有必要学习使用一下。django对PostgreSQL操作需要用到psycopg2这个库；首先从这里下载并安装：

install psycopg2$ wget http://initd.org/pub/software/psycopg/psycopg2-2.0.13.tar.gz

$ tar zxvf psycopg2-2.0.13.tar.gz

$ cd psycopg2-2.0.13

$ python setup.py install

以上步骤就是常规的python库安装方法，但不知道为什么我在CentOS下面安装时，总是提示No such file or directory

解决方法：用文本编辑器打开setup.cfg（$ vim setup.cfg）,找到#pg_config=这行，将前面的#去掉，然后将值设置为:

pg_config=/{你的PostgreSQL安装目录}/bin/pg_config

保存后，再重新执行python setup.py install ，这次应该OK了吧

6.如果你一直都是用pgAdmin来管理PostgreSQL,那么当你必须要直接使用命令行psql连接PostgreSQL时，就会显得无从下手。

解决方法：这里只介绍最需要的，就是如何通过命令行连接到自己的database并操作。

首先 $ psql -d dbname(你的数据库名) -U postgres(一般安装pgsql时默认的超级用户),这样既可进入对该数据库操作的界面，剩下的就是写SQL语句来执行了，

如：DELETE FROM TABLE WHERE ....;(记得，每条SQL语句后面必须分号结束，否则不会执行)

目前值得记录的就这些，此随笔会随时更新；也欢迎正在学习python django的朋友在此探讨问题，一同进步。

本文链接