Python on ZRJ | 学习笔记

python 中 yyyymmdd 与 timestamp 互转

Thu, 06 Jun 2019 16:25:26 +0800

一般来说，每个语言都会有自己的各种 date time 对象，然后，基于这些 date time 对象，又会衍生出来一堆的各种方法，什么加加减减的，但是，如果是在多种语言之间切换的话，一种一种去记，其实很累，多年下来，摸索出来一个方法，就是只用 yyyymmdd 这种 string 和 timestamp 这种 int64，同时搞好互转，这个思路在各个语言都能行得通，包括 sql 等，而且，关键是在各种语言都能一以贯之，说白了，这两种东西，一个是方便机器存储和计算，一个是方便人类阅读，想要加一天减一天啥的，都能通过这个方式来实现，在 Python 里，这个可以一行搞定

datetime.datetime.strftime(datetime.datetime.fromtimestamp(time.mktime(time.strptime('20190606','%Y%m%d')) - 3600*24),'%Y%m%d')

karatsuba 乘法

Mon, 29 Apr 2019 20:23:56 +0800

karatsuba 是一种快速乘法，主要是采用了一种分治的思想来进行大数的乘法，其教程和证明可见 https://blog.csdn.net/qj30212/article/details/52494556

其 Python 代码如下

def karatsuba(num1, num2):
    if (num1 < 10 or num2 < 10):
        return num1 * num2
    num1Str = str(num1)
    num2Str = str(num2)
    maxLength = max(len(num1Str), len(num2Str))
    splitPosition = maxLength / 2
    high1, low1 = int(num1Str[:splitPosition]), int(num1Str[splitPosition:])
    high2, low2 = int(num2Str[:splitPosition]), int(num2Str[splitPosition:])
    z0 = karatsuba(low1, low2)
    z1 = karatsuba((low1 + high1), (low2 + high2))
    z2 = karatsuba(high1, high2)
    return (z2 * (10 ** (2 * splitPosition))) + ((z1 - z2 - z0) * (10 ** (splitPosition))) + z0

还是很牛的

Python 导入包神奇 bug

Wed, 21 Nov 2018 21:17:07 +0800

我擦。。。。这个 blog 写一小段居然机器死机了，还没到第一个存档点就挂了。。

重新写，上回遇到一个神奇的 spark 报错，这回是一个神奇 python flask 报错，场景是为一个已有的 http server 新增一些函数，但是跑起来之后有一定概率会报错 NameError: global name ‘get_fill_topcity_adindex_rst’ is not defined 看起来就像是新写的函数没有生效一样。。

这种情况在 chrome 中多个 tab 一起发起请求，构成并发的时候更容易被触发，神奇的问题

想到的一个可能就是，这个 http sever 原来是绑定在 80 端口的，通过 root 启动，这次为了避开 80，改成了一个普通端口，但是原来的进程也没停，存在多个 Python 虚拟机一起跑的情况，但是这个应该也不影响啊，甚至，我为了排查问题，都特地把整个目录都重新拷了一份出来，重命名了一个别名，就是为了避免 pyc 文件造成的潜在影响，但是依然没什么卵用

============

结果发现，是其中一台机器上发布了新版本代码，另外一台机器没有发布，这。。。

但是感觉不对啊，我明明两台机器都发了的啊。。。

历史评论

cupen (2019-12-25 13:01:57):

这种问题…… 我一般归咎于长相.

离线安装 Python 包 pika

Wed, 14 Dec 2016 15:50:58 +0800

对于 Python 的扩展包，可以使用 pip 的方式进行在线安装，如果需要离线，那么需要先下载安装包（以及其依赖），然后手工安装，例如从 https://pypi.python.org/pypi/pika 这里，pika-0.10.0.tar.gz (md5) Source 2015-09-02 80KB，然后解压缩，执行 python setup.py install 即可，关于 setup.py，可以参考 http://blog.csdn.net/lynn_kong/article/details/17540207 这个文章，说的比较详细了

setup函数还有一些参数：

1、packages 告诉Distutils需要处理那些包（包含__init__.py的文件夹） 2、package_dir 告诉Distutils哪些目录下的文件被映射到哪个源码包。一个例子：package_dir = {’’: ’lib’}，表示“root package”中的模块都在lib目录中。 3、ext_modules 是一个包含Extension实例的列表，Extension的定义也有一些参数。 4、ext_package 定义extension的相对路径 5、requires 定义依赖哪些模块 6、provides 定义可以为哪些模块提供依赖 7、scripts 指定python源码文件，可以从命令行执行。在安装时指定–install-script 8、package_data 通常包含与包实现相关的一些数据文件或类似于readme的文件。如果没有提供模板，会被添加到MANIFEST文件中。 9、data_files 指定其他的一些文件（如配置文件）

另外，关于使用 Python 收发 RabbitMQ 的消息，可以参考这里 https://www.rabbitmq.com/tutorials/tutorial-one-python.html ，但是官方的文档没有提及用户名密码登录验证的参数，参考这里 https://pika.readthedocs.io/en/latest/modules/parameters.html 的文档有补充

python 日志初始化

Thu, 29 Oct 2015 14:49:29 +0800

import logging
logging.basicConfig(format = '[%(asctime)s][%(levelname)s] %(message)s [%(funcName)s::%(lineno)d]', level = logging.DEBUG)
logging.debug(123)

-————————–

2016-2-19 09:26:26 update

logging.basicConfig(stream=sys.stdout, format = '[%(asctime)s][%(levelname)s] %(message)s [%(funcName)s::%(lineno)d]', level = logging.DEBUG)
#log_filename = 'sync_old_redis_and_ferrari_redis.'+str(int(time.time()))+'.log'
#print "logging to ", log_filename
#logging.basicConfig(filename=log_filename, format = '[%(asctime)s][%(levelname)s] %(message)s [%(funcName)s::%(lineno)d]', level = logging.DEBUG)

历史评论

ZRJ (2016-02-18 21:29:20):

logging.basicConfig(stream=sys.stdout, format = ‘[%(asctime)s][%(levelname)s] %(message)s [%(funcName)s::%(lineno)d]’, level = logging.DEBUG)

python 使用 google protocol buffer

Sun, 01 Jun 2014 19:45:19 +0800

在公司内网使用 python 需要依赖于第三方模块的时候真是各种不方便，这个时候就无比的怀念 c 系列的 tar.gz 源码包自行编译的好处了，其实根本的矛盾在于公司内网处于安全考虑对外网的访问有各种隔离，而 python 这个东西在第三方模块的管理上又十分的依赖于 setuptool 和 easy_install，这些东西在给人用的想当然的觉得大家的网络环境都很好，于是就悲剧了。

先说说怎么安装 easy_install 吧，easy_install，install 起来一点都不 easy。。首先下载 setuptools 的安装包，https://pypi.python.org/pypi/setuptools，要说这个页面也真是奇葩，页面的上面有一个 downloads 按钮，按说一般点这个就会开始下载最新的稳定版本了嘛，他不是，他是一个 anchor 的 href 标签跳到页面的中部的一个 downloads 节点，嗯，算了，这种做法也不是没见过，行，跳下来一看，downloads 节点很简洁嘛，就两句话，一看，All setuptools downloads can be found at 叉叉叉，后面又跟一个链接，哎呀妈呀，又要点一下，没事，咱是勤劳的小蜜蜂，再点一下，咦，但是，怎么又回到页面头部去了，反复几次，发现不对，认真一看，Scroll to the very bottom of the page to find the links. 真是坑爹啊，么事，咱滚到底（这页面也真长，不拖滚动条不行，要真是滚轮 scroll 的话天都黑了），滚到底，一看，怎么是这些东西

Author: Python Packaging Authority Documentation: setuptools package documentation Home Page: https://pypi.python.org/pypi/setuptools Keywords: CPAN PyPI distutils eggs package management License: PSF or ZPL Categories Development Status :: 5 - Production/Stable Intended Audience :: Developers License :: OSI Approved :: Python Software Foundation License License :: OSI Approved :: Zope Public License Operating System :: OS Independent Programming Language :: Python :: 2.6 Programming Language :: Python :: 2.7 Programming Language :: Python :: 3 Programming Language :: Python :: 3.1 Programming Language :: Python :: 3.2 Programming Language :: Python :: 3.3 Programming Language :: Python :: 3.4 Topic :: Software Development :: Libraries :: Python Modules Topic :: System :: Archiving :: Packaging Topic :: System :: Systems Administration Topic :: Utilities Package Index Owner: pje, jaraco Package Index Maintainer: ianb, jaraco DOAP record: setuptools-3.6.xml

没有下载链接啊，再往回滚一点，不容易，终于看到了，下载回来，解压缩，一看，有一个 setup.py，那敢情好，双击运行呗，但是他又说要自动 download 一个啥东西，download 半天又 download 不下来，一想，得，内网，于是参考这个，http://blog.scoke.org/easy_install%E6%8C%81%E4%BD%BF%E7%94%A8%E4%BB%A3%E7%90%86%E5%AE%89%E8%A3%85.html，把环境变量的代理设置好，然后重新点 setup.py，发现咋还是不行啊，又 google，然后又被带到之前的下载页面了，一看

Windows 7 (or graphical install) For Windows 7 and earlier, download ez_setup.py using your favorite web browser or other technique and “run” that file.

好吧，windows 7 还不一样，要点 ez_setup.py，好吧，点了，下载了，安装了，发现命令行还是不能 easy_install 啊，搜索一下看到这里，http://www.cnblogs.com/zhuyp1015/archive/2012/07/17/2596495.html，好吧，把 script 目录加入 path，终于可以了，然后就是 easy_install protobuf，为了跑这个命令，真是折腾啊

然后参考这个，http://blog.csdn.net/sanguomi/article/details/8620456，把 python 的 google protocol buffer 用起来，用倒是很容易的

其实吧，在这个过程中，我是想过要去通过离线的方式，安装 google protocol buffer 的 python 模块的，但是，这个下载链接真不好找啊，好不容易找到一个 egg 文件，一查 egg 怎么安装，又绕回 setuptool 上去了。。

历史评论

wanax (2014-06-04 11:08:16):

你这文风越来越碎碎念了…

Python 脚本依赖 glob 从命令行获取通配符文件名

Tue, 06 May 2014 10:07:17 +0800

在写一个 py 脚本的时候，需要从命令行里面带参数进来，指明需要处理的文件名，这个地方，希望支持 shell 那种 * 的通配符，查了一下，有相关的库，看这里，https://docs.python.org/2/library/glob.html

但是，按照这种搞法，跑起来之后发现不行，glob.glob(sys.argv[2]) 总是只返回一个文件名，查了一下，看到这里，http://stackoverflow.com/questions/8538564/pythons-glob-only-returning-the-first-result

原来，是我们在使用 shell 的时候，在 * 送给到 py 脚本之前，就已经被展开了，那么怎么办呢，原题给了一个方式，说用引号引起来，不过还有另外一种方式，可以遍历 sys.argv 数组

if __name__ == "__main__":
    if len(sys.argv) < 3:
        print "Usage:", sys.argv[0], "path_to_ini path_to_dump_file"
    else:
        for path_to_dump in sys.argv[2:]:
            if os.path.isdir(path_to_dump):
                print path_to_dump, "is a directory, skip..."
            else:
                split(sys.argv[1], path_to_dump)

Python inet_ntoa 小脚本

Fri, 07 Mar 2014 09:19:39 +0800

用的时候发现这东西居然还要自己写

#!/usr/bin/env python

import socket
import struct
import sys

def Int2Ip(ip):
    return socket.inet_ntoa(struct.pack('!I', ip))

if __name__ == "__main__":
    if len(sys.argv) > 1:
        print Int2Ip(int(sys.argv[1]))

对于多行的文件，可以这么来批量处理

cat ip.txt | xargs -i  ./Int2Ip.py {}

-——————————-

2014-4-6 15:36:42 update

http://hi.baidu.com/wg_wang/item/338dbb3913ce5a617c034bfc

在工作中需要将ip地址从整数（如168442432）到以点号分隔的字符串类型（如10.10.58.64）之间的转换，或者反过来从字符串到整数的转换。这个转换可以使用的方式很多，例如，linux下的C语言编程，调用inet_aton等函数就可以方便的实现（参考man inet_aton）。不过，脚本语言可以提供更加快速的方式实现，在python中，如下：

首先： import socket import struct

字符串到整数的转换： socket.ntohl(struct.unpack(‘i’,socket.inet_aton(“10.10.58.64”))[0])

更新版，结果都为正整数，前面这个当结果ip地址为128.0.0.0及其以上时，结果会表示为负数。 struct.unpack(‘I’,struct.pack(‘i’,(socket.ntohl(struct.unpack(‘i’, socket.inet_aton(“201.119.123.249”))[0]))))[0]

整数到字符串的转换： socket.inet_ntoa(struct.pack(‘i’,socket.htonl(980942848 )))

各个函数的功能可以参考python的文档，例如： »> help(struct.pack) pack(fmt, *args) Return string containing values v1, v2, … packed according to fmt. See struct.__doc__ for more on format strings.

更详细的可以参考python documentation，有联机版的，也有脱机版的，在windows安装python2.5时还附带chm的文档。

20091117更新如果在c/c++程序中用inet_aton和inet_ntoa进行转换的，int类型和字符串类型的对应关系，在python中还原的话，则无须进行网络主机字节序（host byte order）到网络字节序（network byte order）之间的转换，或者反过来主机字节序到网络字节序的转换。这样，转换的语句如下： socket.inet_ntoa(struct.pack(‘I’, 1077545482)) struct.unpack(‘I’,socket.inet_aton(“10.10.58.64”))[0]

对应的c程序分别为： 18 #include 19 #include 20 #include 21 #include 22 #include 23 #include 24 25 int main(int argc, char ** argv) 26 { 27 if ( argc != 2 ) 28 { 29 fprintf(stderr, “error argument\nusage: %s int_ip\n”, argv[0]); 30 return -1; 31 } 32 33 struct in_addr in; 34 long a=atol(argv[1]); 35 in.s_addr=(unsigned int)(a); 36 fprintf(stdout, “%u <–> %s\n”, in.s_addr, inet_ntoa(in)); 37 return 0; 38 }

18 #include 19 #include 20 #include 21 22 int main(int argc, char *argv[]) 23 { 24 struct in_addr addr; 25 if (argc != 2) 26 { 27 fprintf(stderr, “argument wrong\nusage: %s \n”, argv[0]); 28 return -1; 29 } 30 if (inet_aton(argv[1], &addr) == 0) { 31 fprintf(stderr, “inet_aton”); 32 } 33 34 fprintf(stdout, “%s <–> %u\n”, argv[1], addr.s_addr); 35 return 0; 36 }

基于队列的 UDP 多线程收发 demo

Tue, 10 Dec 2013 15:46:01 +0800

来看这个代码

#include <stdio.h>
#include <assert.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <string.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <queue>
#include <pthread.h>

#define _PRINTF_(format, ...) printf("[%s:%20s@%20s,%04d] " format "\n", "DEBUG",__FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__ );

static const int iBufferSize = 2048;
int iUdpServerFd;
static const unsigned short uiUdpServerPort = 6000;
static const int iUdpProcessThreadNumber = 2;

struct InQueueEvent
{
    struct sockaddr_in stClientAddr;
    socklen_t stClienAddrLen;
    char szRecvBuffer[iBufferSize];
    int iRecvLen;
};

struct OutQueueEvent
{
    struct sockaddr_in stDestAddr;
    socklen_t stDestAddrLen;
    char szSendBuffer[iBufferSize];
    int iSendContentLen;
};

std::queue<struct InQueueEvent> stInQueue;
pthread_mutex_t stInQueueMutex;
std::queue<struct OutQueueEvent> stOutQueue;
pthread_mutex_t stOutQueueMutex;

void* UdpProcessThread(void*)
{
    _PRINTF_("udp process thread %ld start", pthread_self());
    while (1)
    {
        if (stInQueue.empty())
        {
            continue;
        }
        pthread_mutex_lock(&stInQueueMutex);
        struct InQueueEvent stInQueueEvent = stInQueue.front();
        stInQueue.pop();
        pthread_mutex_unlock(&stInQueueMutex);
        _PRINTF_("thread %ld processing the request %s", pthread_self(), stInQueueEvent.szRecvBuffer);
        struct OutQueueEvent stOutQueueEvent;
        stOutQueueEvent.stDestAddr = stInQueueEvent.stClientAddr;
        stOutQueueEvent.stDestAddrLen = stInQueueEvent.stClienAddrLen;
        memcpy(stOutQueueEvent.szSendBuffer, stInQueueEvent.szRecvBuffer, stInQueueEvent.iRecvLen);
        stOutQueueEvent.iSendContentLen = stInQueueEvent.iRecvLen;
        pthread_mutex_lock(&stOutQueueMutex);
        stOutQueue.push(stOutQueueEvent);
        pthread_mutex_unlock(&stOutQueueMutex);        
    }
}

void* UdpRecvThread(void*)
{
    _PRINTF_("udp recv thread start");
    while(1)
    {
        struct InQueueEvent stInQueueEvent;
        memset(&stInQueueEvent, 0, sizeof(stInQueueEvent));
        stInQueueEvent.stClienAddrLen = sizeof(stInQueueEvent.stClientAddr);
        stInQueueEvent.iRecvLen = recvfrom(iUdpServerFd, &(stInQueueEvent.szRecvBuffer), sizeof(stInQueueEvent.szRecvBuffer), 0, (struct sockaddr*)&(stInQueueEvent.stClientAddr), &(stInQueueEvent.stClienAddrLen));
        _PRINTF_("recv %d bytes from ip %s port %d message %s", stInQueueEvent.iRecvLen, inet_ntoa(stInQueueEvent.stClientAddr.sin_addr), ntohs(stInQueueEvent.stClientAddr.sin_port), stInQueueEvent.szRecvBuffer);
        pthread_mutex_lock(&stInQueueMutex);
        stInQueue.push(stInQueueEvent);
        pthread_mutex_unlock(&stInQueueMutex);
    }
}

void* UdpSendThread(void*)
{
    _PRINTF_("udp send thread start");
    while(1)
    {
        if (stOutQueue.empty())
        {
            continue;
        }
        pthread_mutex_lock(&stOutQueueMutex);
        struct OutQueueEvent stOutQueueEvent = stOutQueue.front();
        stOutQueue.pop();
        pthread_mutex_unlock(&stOutQueueMutex);
        int iSendLen = sendto(iUdpServerFd, &(stOutQueueEvent.szSendBuffer), stOutQueueEvent.iSendContentLen, 0, (struct sockaddr*)&(stOutQueueEvent.stDestAddr), stOutQueueEvent.stDestAddrLen);
        _PRINTF_("send %d bytes to ip %s port %d message %s", iSendLen, inet_ntoa(stOutQueueEvent.stDestAddr.sin_addr), ntohs(stOutQueueEvent.stDestAddr.sin_port), stOutQueueEvent.szSendBuffer);
    }
}

int CreateUdpServer(unsigned short uiUdpServerPort)
{
    int iListenFd = socket(AF_INET, SOCK_DGRAM, 0);
    assert(iListenFd > 0);
    struct sockaddr_in stListenAddr;
    memset(&stListenAddr, 0, sizeof(stListenAddr));
    stListenAddr.sin_family = AF_INET;
    stListenAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    stListenAddr.sin_port = htons(uiUdpServerPort);
    int iReuseFlag = 1;
    assert(setsockopt(iListenFd, SOL_SOCKET, SO_REUSEADDR, &iReuseFlag, sizeof(int)) == 0);
    assert(bind(iListenFd, (struct sockaddr*)&stListenAddr, sizeof(stListenAddr)) == 0);  
    return iListenFd;
}

int main()
{
    pthread_mutex_init(&stInQueueMutex, NULL);
    pthread_mutex_init(&stOutQueueMutex, NULL);
    iUdpServerFd = CreateUdpServer(uiUdpServerPort);
    pthread_t tid;
    assert(pthread_create(&tid, NULL, UdpRecvThread, NULL) == 0);
    assert(pthread_create(&tid, NULL, UdpSendThread, NULL) == 0);
    for (int i = 0; i < iUdpProcessThreadNumber; i++)
    {
        assert(pthread_create(&tid, NULL, UdpProcessThread, NULL) == 0);
    }    
    while (1)
    {
        sleep(10);
    }
    return 0;
}

用 python 写个客户端测试一下

#!/usr/bin/env python

import socket

HOST = 'xx.xx.xx.xx'
PORT = 6000
BUFSIZ = 1024
ADDR = (HOST, PORT)

udpCliSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

while True:
    data = raw_input('> ')
    if not data:
        break
    udpCliSock.sendto(data, ADDR)
    data, ADDR = udpCliSock.recvfrom(BUFSIZ)
    if not data:
        break
    print ADDR, data

udpCliSock.close()

跑起来似乎没有问题

[DEBUG:       UdpRecvThread@        EpollUdp.cpp,0069] udp recv thread start
[DEBUG:       UdpSendThread@        EpollUdp.cpp,0085] udp send thread start
[DEBUG:    UdpProcessThread@        EpollUdp.cpp,0044] udp process thread 1107310912 start
[DEBUG:    UdpProcessThread@        EpollUdp.cpp,0044] udp process thread 1098918208 start
[DEBUG:       UdpRecvThread@        EpollUdp.cpp,0076] recv 1 bytes from ip 10.31.18.40 port 62272 message 1
[DEBUG:    UdpProcessThread@        EpollUdp.cpp,0055] thread 1107310912 processing the request 1
[DEBUG:       UdpSendThread@        EpollUdp.cpp,0097] send 1 bytes to ip 10.31.18.40 port 62272 message 1
[DEBUG:       UdpRecvThread@        EpollUdp.cpp,0076] recv 1 bytes from ip 10.31.18.40 port 62272 message 2
[DEBUG:    UdpProcessThread@        EpollUdp.cpp,0055] thread 1107310912 processing the request 2
[DEBUG:       UdpSendThread@        EpollUdp.cpp,0097] send 1 bytes to ip 10.31.18.40 port 62272 message 2

但是多发几次，就 core 了，这是为什么呢，gdb 调试发现 core 在 memcpy 上面，这个也不太能理解，不过，把代码尝试的改成这样就可以了

#include <stdio.h>
#include <assert.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <string.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <queue>
#include <pthread.h>

#define _PRINTF_(format, ...) printf("[%s:%20s@%20s,%04d] " format "\n", "DEBUG",__FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__ );

static const int iBufferSize = 2048;
int iUdpServerFd;
static const unsigned short uiUdpServerPort = 6000;
static const int iUdpProcessThreadNumber = 2;

struct InQueueEvent
{
    struct sockaddr_in stClientAddr;
    socklen_t stClienAddrLen;
    char szRecvBuffer[iBufferSize];
    int iRecvLen;
};

struct OutQueueEvent
{
    struct sockaddr_in stDestAddr;
    socklen_t stDestAddrLen;
    char szSendBuffer[iBufferSize];
    int iSendContentLen;
};

std::queue<struct InQueueEvent> stInQueue;
pthread_mutex_t stInQueueMutex;
std::queue<struct OutQueueEvent> stOutQueue;
pthread_mutex_t stOutQueueMutex;

void* UdpProcessThread(void*)
{
    _PRINTF_("udp process thread %ld start", pthread_self());
    while (1)
    {
        pthread_mutex_lock(&stInQueueMutex);
        if (stInQueue.empty())
        {
            pthread_mutex_unlock(&stInQueueMutex);
            continue;
        }
        struct InQueueEvent stInQueueEvent = stInQueue.front();
        stInQueue.pop();
        pthread_mutex_unlock(&stInQueueMutex);
        _PRINTF_("thread %ld processing the request %s", pthread_self(), stInQueueEvent.szRecvBuffer);
        struct OutQueueEvent stOutQueueEvent;
        memset(&stOutQueueEvent, 0, sizeof(stOutQueueEvent));
        stOutQueueEvent.stDestAddr = stInQueueEvent.stClientAddr;
        stOutQueueEvent.stDestAddrLen = stInQueueEvent.stClienAddrLen;
        memcpy(stOutQueueEvent.szSendBuffer, stInQueueEvent.szRecvBuffer, stInQueueEvent.iRecvLen);
        stOutQueueEvent.iSendContentLen = stInQueueEvent.iRecvLen;
        pthread_mutex_lock(&stOutQueueMutex);
        stOutQueue.push(stOutQueueEvent);
        pthread_mutex_unlock(&stOutQueueMutex);        
    }
}

void* UdpRecvThread(void*)
{
    _PRINTF_("udp recv thread start");
    while(1)
    {
        struct InQueueEvent stInQueueEvent;
        memset(&stInQueueEvent, 0, sizeof(stInQueueEvent));
        stInQueueEvent.stClienAddrLen = sizeof(stInQueueEvent.stClientAddr);
        stInQueueEvent.iRecvLen = recvfrom(iUdpServerFd, &(stInQueueEvent.szRecvBuffer), sizeof(stInQueueEvent.szRecvBuffer), 0, (struct sockaddr*)&(stInQueueEvent.stClientAddr), &(stInQueueEvent.stClienAddrLen));
        _PRINTF_("recv %d bytes from ip %s port %d message %s", stInQueueEvent.iRecvLen, inet_ntoa(stInQueueEvent.stClientAddr.sin_addr), ntohs(stInQueueEvent.stClientAddr.sin_port), stInQueueEvent.szRecvBuffer);
        pthread_mutex_lock(&stInQueueMutex);
        stInQueue.push(stInQueueEvent);
        pthread_mutex_unlock(&stInQueueMutex);
    }
}

void* UdpSendThread(void*)
{
    _PRINTF_("udp send thread start");
    while(1)
    {
        pthread_mutex_lock(&stOutQueueMutex);
        if (stOutQueue.empty())
        {
            pthread_mutex_unlock(&stOutQueueMutex);
            continue;
        }
        struct OutQueueEvent stOutQueueEvent = stOutQueue.front();
        stOutQueue.pop();
        pthread_mutex_unlock(&stOutQueueMutex);
        int iSendLen = sendto(iUdpServerFd, &(stOutQueueEvent.szSendBuffer), stOutQueueEvent.iSendContentLen, 0, (struct sockaddr*)&(stOutQueueEvent.stDestAddr), stOutQueueEvent.stDestAddrLen);
        _PRINTF_("send %d bytes to ip %s port %d message %s", iSendLen, inet_ntoa(stOutQueueEvent.stDestAddr.sin_addr), ntohs(stOutQueueEvent.stDestAddr.sin_port), stOutQueueEvent.szSendBuffer);
    }
}

int CreateUdpServer(unsigned short uiUdpServerPort)
{
    int iListenFd = socket(AF_INET, SOCK_DGRAM, 0);
    assert(iListenFd > 0);
    struct sockaddr_in stListenAddr;
    memset(&stListenAddr, 0, sizeof(stListenAddr));
    stListenAddr.sin_family = AF_INET;
    stListenAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    stListenAddr.sin_port = htons(uiUdpServerPort);
    int iReuseFlag = 1;
    assert(setsockopt(iListenFd, SOL_SOCKET, SO_REUSEADDR, &iReuseFlag, sizeof(int)) == 0);
    assert(bind(iListenFd, (struct sockaddr*)&stListenAddr, sizeof(stListenAddr)) == 0);  
    return iListenFd;
}

int main()
{
    pthread_mutex_init(&stInQueueMutex, NULL);
    pthread_mutex_init(&stOutQueueMutex, NULL);
    iUdpServerFd = CreateUdpServer(uiUdpServerPort);
    pthread_t tid;
    assert(pthread_create(&tid, NULL, UdpRecvThread, NULL) == 0);
    assert(pthread_create(&tid, NULL, UdpSendThread, NULL) == 0);
    for (int i = 0; i < iUdpProcessThreadNumber; i++)
    {
        assert(pthread_create(&tid, NULL, UdpProcessThread, NULL) == 0);
    }    
    while (1)
    {
        sleep(10);
    }
    return 0;
}

注意高亮的部分，在检查队列是否为空的时候，也要包含在锁的区域里面，这样就可以了

-———————————————

2013-12-10 16:37:06 update 使用这个脚本，可以多线程压测服务

#!/usr/bin/env python

import socket
import random
import threading

HOST = 'xx.xx.xx.xx'
PORT = 6000
BUFSIZ = 1024
ADDR = (HOST, PORT)

class UdpTestThread(threading.Thread):
    def run(self):
        udpCliSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        for i in range(1000):
            data = str(random.random())
            udpCliSock.sendto(data, ADDR)
            data = udpCliSock.recvfrom(BUFSIZ)
            #print data
        udpCliSock.close()

for i in range(50):
    UdpTestThread().start()

-—————————

2013-12-10 17:21:05 update 发现上面的例子，压测结果很差，于是写了个极简的，作为比对

#include <sys/socket.h>
#include <arpa/inet.h>

int main() {
    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(6000);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    bind(fd, (struct sockaddr*)&addr, sizeof(addr));
    while (1) {
        char buffer[2048] = {0};
        struct sockaddr cli;
        socklen_t cli_len = sizeof(cli);
        int recv_len = recvfrom(fd, buffer, sizeof(buffer), 0, &cli, &cli_len);
        sendto(fd, buffer, recv_len, 0, &cli, cli_len);
    }
    return 0;
}

发现差不多，看来还要找原因

历史评论

wanax (2014-03-19 16:52:29):

这几天挖出来个GLib的，自带线程池和宏定义好了的锁，感觉再用C就顺手多了

ZRJ (2014-03-19 20:15:41):

其实用 libevent 基本就够了，不用造轮子

wanax (2014-03-20 09:49:23):

那玩意儿就是个轮子还附带各种数据结构与常用工具类

ZRJ (2014-03-20 19:58:08):

反正我现在是觉得能有稳定开源的就用呗

一个简单的监控网页变化的方法

Wed, 06 Nov 2013 11:49:18 +0800

最近遇上一个小的实际需求：一个页面上有些许表格，我们需要监控这个页面，当表格的内容有变化的时候，及时通知我们。需求比较小，要求是用尽量简单的方式来实现。另外，这个页面是要求登陆态的。

想了想，大约没有什么现成的解决方案，那么打算自己写代码来实现。

自然的想起脚本语言来，首先尝试了 python，在 python 2 自带的 urllib2 的帮助下，抓取页面这个步骤还是比较简单的，几行代码就可以完成功能

url = "http://..."
headers = {"Cookie" : "..."}
request = urllib2.Request(url, None, headers)
response = urllib2.urlopen(request)
html = response.read()

但是在解析 html 的时候出现了问题。

简单搜索一下，发现 python 用来解析 html 的，有自带的 HTMLParser，以及第三方库，beautiful soup，第三方库下载之后简单的尝试安装了一下，没有安装成功，快速的放弃了，转而查看 HTMLParser 的文档，这个东西其实也还是蛮强大的，但是写起来比较复杂，需要用一种状态驱动的方式去写接口，样例的代码可以看到这里，http://cloudaice.com/yong-pythonde-htmlparserfen-xi-htmlye-mian/

from HTMLParser import HTMLParser import urllib import sys class parselinks(HTMLParser): def __init__(self): self.data=[] self.href=0 self.linkname=’’ HTMLParser.__init__(self) def handle_starttag(self,tag,attrs): if tag ==‘a’: for name,value in attrs: if name == ‘href’: self.href=1 def handle_data(self,data): if self.href: self.linkname+=data def handle_endtag(self,tag): if tag==‘a’: self.linkname=’’.join(self.linkname.split()) self.linkname=self.linkname.strip() if self.linkname: self.data.append(self.linkname) self.linkname=’’ self.href=0 def getresult(self): for value in self.data: print value if __name__=="__main__": IParser = parselinks() IParser.feed(urllib.urlopen(“http://www.python.org/index.html").read()) IParser.getresult() IParser.close()

这样虽然也可以完成任务，但是还是略繁琐了。

而问题并没有到此结束，接下来遇到的问题是，当发现变化的时候，怎么通知到我们呢。假设我们都在电脑前坐着，但是需要干其他事情，而这个 python 脚本是基于终端的，那么，我们就只能把终端窗口一直开着，然后在发现变化的时候，打出一串长长长的字符串。。。真是一个挫办法。。

不管怎么说，这个方式大约是实现了。

然后试试 php，php 不愧是为网页量身的脚本语言，抓取页面，解析页面，都是很方便的，来看这段代码

// Create a stream
$opts = array(
  'http'=>array(
    'method'=>"GET",
    'header'=>"Cookie:...\r\n"
  )
);

$context = stream_context_create($opts);

// Open the file using the HTTP headers set above
$file = file_get_contents('http://...', false, $context);

可以看到 php 抓取页面并不比 python 引以为豪的 urllib2 复杂，然后再来看解析页面

$table = strstr($file, "<tbody>");
$table = substr($table, 0, strpos($table, "</tbody>"));
$tr_arr = explode("<tr>", $table);

foreach($tr_arr as &$tr) {
    $tr = trim(strip_tags($tr));
    //var_dump($tr);
}

//var_dump($tr_arr);

if (strstr($tr_arr[1], "...") == false) {
    echo 1;
} else {
    echo 0;
}

在 strip_tags 这个神奇函数的帮助下，我们可以十分轻松的把页面的内容抽取出来，然后稍微字符串查找一下，就 ok 了。

但是这个依然遇到的问题就是怎么提示，由于 python 是常驻脚本，还可以死循环跑，然后终端打出，但是 php 被设计为一个短暂脚本，那么，看来就要上 js 了。

说道这里，就想起来之前 gmail 上面出现过的桌面通知，这可是个好东西，搜了一下，找到这个文章，http://www.cnblogs.com/cloudlee/archive/2012/09/19/2694074.html，按照里面的方法，敲进去，但是发现弹不出来啊，再一阵搜，找到这里，http://stackoverflow.com/questions/5040107/webkit-notifications-requestpermission-function-doesnt-work，人说了，要在回调里面调这个函数，那么可以得到代码如下

<script src="http://codeorigin.jquery.com/jquery-1.10.2.min.js"></script>

<button id="btn">request notify permission</button>

<script>
    function notify() {
        if (window.webkitNotifications.checkPermission() == 0) {
            window.webkitNotifications.createNotification('image.png', '标题', '内容').show();
        } else {
            window.webkitNotifications.requestPermission(notify);
        }
    }
    $(function(){
        $("#btn").click(function(){
            notify();
        });
        setInterval(function(){            
            $.get("mo.php", function(data){
            if (data != 0) {
                notify();
            } else {
                console.log(new Date());
            }
       });
       }, 10000);    
    });
</script>

至此需求基本完成

历史评论

wanax (2013-12-03 09:16:24):

这个可以有啊登录的录写错了<–_<–

TonySeek (2014-01-03 02:49:51):

Python 分析网页应该用 requests + lxml，前者下载内容，后者有 HTML Parser 并且支持 XPath 语法。

标准库的 urllib 系的 API 设计实在反人类，Beautiful Soup 的 CSS 选择器其实远不如 XPath 灵活和易于修改。

ZRJ (2014-01-03 20:48:01):

一个人两个电脑，一个用来查资料上网逛 bbs，另外一个用来写代码的机器是不能连外网的，于是 py 的那些什么在线自动安装的包管理就悲剧了，下载了安装包拖到另外一台机器发现装起来麻烦，还跑不起来，时间又赶，自然就换上 php 自带的内置函数了。。

TonySeek (2014-01-03 21:14:42):

Python 也可以像 Java 的 jar 包一样，把库下载下来用的～

真用 PHP 也应该有 xml 解析库吧？手动拆字符串，万一别人网页变了，改代码多痛苦～

ZRJ (2014-01-04 09:35:43):

原来有类 jar 的包。。我看看。。我上次装的 py 库是 msi 的封装形式。。当时还想着怎么这么奇葩。。

Python 的一个 Bug

Thu, 27 Jun 2013 17:57:50 +0800

今天要写一个统计脚本，于是打开 Aptana，建了一个文件叫 stat.py，取的 statistics 的缩写，但是一直报错如下

Traceback (most recent call last):
  File "C:\Python27\lib\site.py", line 62, in <module>
    import os
  File "C:\Python27\lib\os.py", line 63, in <module>
    import ntpath as path
  File "C:\Python27\lib\ntpath.py", line 10, in <module>
    import stat
  File "D:\Documents\Aptana Studio 3 Workspace\0627test\stat.py", line 1, in <module>
    import logging
  File "C:\Python27\lib\logging\__init__.py", line 71, in <module>
    _srcfile = os.path.normcase(_srcfile)
AttributeError: 'module' object has no attribute 'path'

哪怕我的代码只有以下两行

import logging

logging.error("msg")

后来不知道怎么的，脑子一抽筋，想到这个文件名的问题，于是把文件名一改，bug 就消失了

查了一下，在 python 中本身有一个库的文件叫 stat.pyc，估计是冲突了

这让我想起来 javascript 里面的函数是不能命名为一些特定的名字的，这种 bug，我只能说蛋疼了

Python eyeD3 库的乱码问题初步

Wed, 05 Dec 2012 23:46:01 +0800

续上次的，再次折腾专辑封面，请教了江阁之后，江阁给了一个 hack，现在基本可以读取 gbk 的 id3 了，附上现在的代码

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

'''根据豆瓣自动补全专辑封面'''

import os, sys, re, time, urllib, eyeD3

reload(sys)
sys.setdefaultencoding('utf-8')

import logging
logging.basicConfig(filename = 'log.txt', 
                    filemode = 'w', 
                    format = '[%(levelname)s] [%(asctime)s] %(message)s', 
                    level = logging.DEBUG)

resolve_abnormal = lambda abnormal: "".join(map(chr, map(ord, abnormal)))

def fillCover(filename):
    logging.info('processing %s' % filename)
    t = eyeD3.Tag()

    try:
        t.link(filename)
    except:
        logging.error('can not open file')
        return False

    images = t.getImages()
    '''
    if len(images) > 0:
        logging.info('alreay has cover images')
        return True
    '''
    t.removeImages()

    title = t.getTitle()
    title = resolve_abnormal(title)
    logging.debug('title is %s' % title)
    album = t.getAlbum()
    album = resolve_abnormal(album)
    logging.debug('album is %s' % album)
    artist = t.getArtist()
    artist = resolve_abnormal(artist)
    logging.debug('artist is %s' % artist)

    if title or artist or album:
        keyword = ' '.join([title, artist, album])
    else:
        logging.debug('no enough id3 tags')
        keyword = filename.split('\')[-1].split('.')[0]
        keyword = keyword
    logging.debug('keyword is %s' % keyword)

    doubanSearchAPI = 'http://api.douban.com/v2/music/search?q={0}'
    request = doubanSearchAPI.format(urllib.quote(keyword.decode('gbk').encode('utf-8')))
    logging.debug('request is %s' % request)
    result = urllib.urlopen(request).read()
    #logging.debug('result is %s' % result)

    # http://developers.douban.com/wiki/?title=api_v2
    #logging.warn('sleep for 6 sec')
    #time.sleep(6)

    if not result:
        return False
    doubanCoverPattern = 's(d+).jpg'
    doubanCoverURL = 'http://img3.douban.com/lpic/s{0}.jpg'
    match = re.search(doubanCoverPattern, result, re.IGNORECASE)
    if match:
        coverFileURL = doubanCoverURL.format(match.groups()[0])
        logging.debug('cover image url is %s' % coverFileURL)
    else:
        logging.debug('no cover image url matched')
        return False

    try:
        logging.debug('downloading cover image file')
        #coverFileName = ' - '.join([artist, album])+'.jpg'
        coverFileName = 'cover//' + ' - '.join([artist, album]) + '.jpg'
        f = file(coverFileName, 'wb')
        f.write(urllib.urlopen(coverFileURL).read())
        f.close()
        logging.debug('download finished')
    except:
        logging.error('download error')

    try:
        logging.debug('adding image')
        t.addImage(3, coverFileName, u'')
        t.update()
        logging.info('successfully add image')
        return True
    except:
        logging.error('add image error')
        return False


def main():
    if len(sys.argv) < 2:
        print 'usage: %s /path/to/your/music/folder/' % __file__
        return False
    for i in os.listdir(sys.argv[1]):
        fillCover(os.path.join(sys.argv[1], i))

if __name__ == '__main__':
    main()

但是进一步的探索发现一个神奇的问题，有些歌曲是拖不进 itunes 的，而且，这种歌曲的 id3 必须转成 apev2，才能正确的出现标签的歌手和专辑名称，以及可以出现专辑封面，我发现这些歌曲一般是来自 google music，不知道是不是用了什么数字水印技术

再次折腾专辑封面

Mon, 03 Dec 2012 23:54:09 +0800

最近 itunes 升级，于是重新在整理音乐文件，看到那些没有专辑封面的 mp3，于是骨子里的不折腾不舒服斯基又发作了，手贱准备再次开始写一个自动工具来搞，上次的折腾记录在这里，根据 ID3 自动补充专辑封面和歌词

上次的失败是因为那个库对于中文的编码支持不是很好，于是最后就出现一些乱码问题，等等，于是这次准备换 python 搞，搜了一下，看到这几篇文章，http://hackerszone.diandian.com/post/2011-08-14/3887967，http://www.gracecode.com/posts/3009.html，http://www.fuchaoqun.com/2010/01/python-mp3-id3v2-lyrics-attached_picture/，http://pipitu.org/2010/05/14/mp3-id3-embed-cover/，于是我知道手贱的不止我一个，呵呵

他们用的 py 库是http://eyed3.nicfit.net，这次不搞图形界面，于是一通查资料，重新理清了 mp3 tag 的文件格式，按照我的理解，简单来说，是这样的

首先有一个不太成熟的 id3v1，这个东西的做法是把 title，album，artist 这些信息放到文件末尾，格式简单，编码是 ascii，所以不支持中文，而且有一个很大的问题是定长，30 个 char，于是后来演变出另外一种， id3v2，而这个 id3v2 还分为 id3v2.3，这个是目前最多的，也是兼容性最好的，他把这些信息放到文件头部，而且不定长，而且字段不定，所以灵活性很高，可扩展性很强，字符的编码可以是 ascii，或者 utf-8，但是 windows 对于 utf-8 的支持不好，所以如果是用 utf-8 的话，在资源管理器里面是看不出来的，所以 qq 音乐，千千静听这些，默认都是 id3v2.3 的 iso-8859-1，说是 iso-8859-1，其实本质上是 gbk，而 itunes 对于 gbk 和 utf-8 的解码都是没有问题的，所以最皆大欢喜的做法就是用 id3v2.3 的 iso-8859-1(gbk) 来编码，然后嵌入图形文件当作封面，这个 id3v2 还有一个 id3v2.4，这个比较新，所以不怎么广泛，他的优势是标签信息可以在文件头，也可以在文件尾，在文件头的劣势显而易见，每次改写都要重写整个文件，磁盘读写量很大，除了 id3v2，还有一种格式叫做 apev2，这个也比较先进，可惜的是普及率也不高。

方针路线定了，接下来就是实干了，照着前面几篇博客的代码，敲敲打打的得到下面这个代码

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

'''根据豆瓣自动补全专辑封面'''

import os, sys, re, time, urllib, eyeD3

import logging
logging.basicConfig(filename = 'log%s.txt' % time.time(), 
                    filemode = 'w', 
                    format = '[%(levelname)s] [%(asctime)s] %(message)s', 
                    level = logging.DEBUG)

def fillCover(filename):
    logging.info('processing %s' % filename)
    t = eyeD3.Tag()

    try:
        t.link(filename)
    except:
        logging.error('can not open file')
        return False

    images = t.getImages()
    if len(images) > 0:
        logging.info('alreay has cover images')
        return True

    title = t.getTitle()
    album = t.getAlbum()
    artist = t.getArtist()
    logging.debug('title is %s' % title)
    logging.debug('album is %s' % album)
    logging.debug('artist is %s' % artist)

    if title and artist:
        keyword = ' '.join([title, artist])
        keyword = keyword.encode('utf-8')
    else:
        logging.debug('no id3 tags')
        keyword = filename.split('\')[-1].split('.')[0]
        keyword = keyword.encode('gbk')
    logging.debug('keyword is %s' % keyword)

    doubanSearchAPI = 'http://api.douban.com/v2/music/search?q={0}'
    request = doubanSearchAPI.format(urllib.quote(keyword))
    logging.debug('request is %s' % request)
    result = urllib.urlopen(request).read()
    logging.debug('result is %s' % result)

    # 豆瓣 API 限制是每分钟 10 次请求
    # http://developers.douban.com/wiki/?title=api_v2
    #logging.warn('sleep for 6 sec')
    #time.sleep(6)

    if not result:
        return False
    doubanCoverPattern = 's(d+).jpg'
    doubanCoverURL = 'http://img3.douban.com/lpic/s{0}.jpg'
    match = re.search(doubanCoverPattern, result, re.IGNORECASE)
    if match:
        coverFileURL = doubanCoverURL.format(match.groups()[0])
        logging.debug('cover image url is %s' % coverFileURL)
    else:
        logging.debug('no cover image url matched')
        return False

    try:
        logging.debug('downloading cover image file')
        coverFileName = ' - '.join([artist, album])+'.jpg'
        f = file(coverFileName, 'wb')
        f.write(urllib.urlopen(coverFileURL).read())
        f.close()
        logging.debug('download finished')
    except:
        logging.error('download error')

    try:
        logging.debug('adding image')
        t.addImage(3, coverFileName, u'')
        t.update()
        logging.info('successfully add image')
        return True
    except:
        logging.error('add image error')
        return False


def main():
    if len(sys.argv) < 2:
        print 'usage: %s /path/to/your/music/folder/' % __file__
        return False
    for i in os.listdir(sys.argv[1]):
        fillCover(os.path.join(sys.argv[1], i))

if __name__ == '__main__':
    main()

这份代码在英文歌曲下，基本没有问题，可以比较顺利的跑，但是，中文，又是恶心的编码问题，由于现有的歌曲中，id3v2.3 的编码方式有些是 gbk ，有些是 utf-8，这个就比较麻烦了，不过千千静听有一个批量编辑文件属性的功能，可以在那里面，把所有文件的编码方式统一，可惜的是，这个 py 库到目前我发现他只支持 utf-8，对于 gbk 会乱码，于是我现在对于中文歌曲的处理方法是，全部拖进千千静听，转成 id3v2.3 的 utf-8，然后用这份代码去跑，跑完了，事实上图片已经钱嵌进去了，但是在 windows 的资源管理器中看不到，在 itunes 中可以，在 airplay 中也可以，但是如果这个时候再用千千静听把所有的编码都转换回 gbk，就会丢失了专辑封面，这个就很麻烦，目前就卡在这里

接下来的话，最理想的情况当然是研究清楚这个 py 库，然后让他可以处理 gbk 的标签，然后用千千静听把所有的标签转成 gbk，再用这份代码去下载封面，这样就你好我好大家好了

历史评论

Python eyeD3 库的乱码问题初步 | ZRJ (2012-12-07 13:04:26):

[…] 文章导航 ← 上一篇 […]

python http head 工具

Thu, 18 Oct 2012 21:00:21 +0800

群上闲聊，说道自己封装了一个 python 的 http head 工具

#!/usr/bin/env python

from socket import *

while True:
    HOST = raw_input('> ')
    if not HOST:
        break
    tcpCliSock = socket(AF_INET, SOCK_STREAM)
    PORT = 80
    BUFSIZ = 1024
    ADDR = (HOST, PORT)
    tcpCliSock.connect(ADDR)
    data = "HEAD / HTTP/1.1rnHost: %srnrn" % HOST
    tcpCliSock.send(data)
    data = tcpCliSock.recv(BUFSIZ)
    if not data:
        break
    print data
tcpCliSock.close()

输入输出

C:UsersZRJDesktop>python head
> 360.cn
HTTP/1.1 200 OK
Date: Thu, 18 Oct 2012 12:56:35 GMT
Server: Apache
P3P: CP="CAO DSP COR CUR ADM DEV TAI PSA PSD IVAi IVDi CONi TELo OTPi OUR DELi S
AMi OTRi UNRi PUBi IND PHY ONL UNI PUR FIN COM NAV INT DEM CNT STA POL HEA PRE G
OV"
Set-Cookie: B=ID=809401350564995:V=2:S=236f7e7338; path=/; expires=Sun, 17-Jun-2
038 23:59:59 GMT; domain=.360.cn
Set-Cookie: UT=T=1350564995:F=MzYwLmNu:S=1; path=/; domain=.360.cn
Vary: Accept-Encoding
Connection: close
Content-Type: text/html

针对正则引擎的拒绝服务攻击

Sun, 14 Oct 2012 15:50:46 +0800

最近在看这个书，http://book.douban.com/subject/10546925/，在 311 页讲到了一个针对正则引擎的 DoS，叫做 ReDoS，wiki 看这里，http://en.wikipedia.org/wiki/ReDoS，原因是正则引擎在匹配的时候是用状态机，然而通过构造一些特殊的输入，可以让这个状态机需要尝试的路径暴涨，于是就耗时也跟着上升，照着书上敲了代码如下，不得不说 python 在这种时候真是不二选择啊

#!/usr/bin/env python
#
# retime.py - Python test program for regular expression DoS attacks
#

#
# paramemers
#
# regex: the expression to be tested
# maketeststring: a function which generates a test string from a
#                  length patameter
# maxiter: maximum number of test iterations to be performed
# maxtime: maximum execution time in seconds for one iteration
#           before the test program is terminated
#

regex = r"^(a+)+$"
maketeststring = lambda n : "a" * n + "!"
maxiter = 50
maxtime = 2

#
# modules used by this program
#

import re
import time
import sys

#
# main function
#

def main():
    print
    print "Python Regular Expression DoS demo"
    print
    print "Platform: %s %s" % (sys.platform, sys.version)
    print "Regular expression: %s" % (regex)
    print "Typical test string: %s" % (maketeststring(10))
    print "Max iterations: %s" % (maxiter)
    print "Max match time: %s sec%s" % (maxtime, "s" if maxtime!=1 else "")
    print

    cregex = re.compile(regex)
    for i in xrange(1, maxiter):
        time = runtest(cregex, i)
        if time > maxtime:
            break
    return

#
# run one test
#

def runtest(regex, n):
    teststr = maketeststring(n)
    starttime = time.clock()
    match = regex.match(teststr)
    elapsetime = int((time.clock()-starttime) * 1000)
    count = 0
    if match != None:
        count = match.end() - match.start()
    print "For n=%d, match time=%d msec%s, match count=%s" % 
          (n, elapsetime, "" if elapsetime==1 or elapsetime==0 else "s", count)
    return float(elapsetime)/1000

if __name__ == "__main__":
    main()

输出

Python Regular Expression DoS demo

Platform: win32 2.7.3 (default, Apr 10 2012, 23:31:26) [MSC v.1500 32 bit (Intel)]
Regular expression: ^(a+)+$
Typical test string: aaaaaaaaaa!
Max iterations: 50
Max match time: 2 secs

For n=1, match time=0 msec, match count=0
For n=2, match time=0 msec, match count=0
For n=3, match time=0 msec, match count=0
For n=4, match time=0 msec, match count=0
For n=5, match time=0 msec, match count=0
For n=6, match time=0 msec, match count=0
For n=7, match time=0 msec, match count=0
For n=8, match time=0 msec, match count=0
For n=9, match time=0 msec, match count=0
For n=10, match time=0 msec, match count=0
For n=11, match time=0 msec, match count=0
For n=12, match time=0 msec, match count=0
For n=13, match time=1 msec, match count=0
For n=14, match time=2 msecs, match count=0
For n=15, match time=4 msecs, match count=0
For n=16, match time=8 msecs, match count=0
For n=17, match time=16 msecs, match count=0
For n=18, match time=33 msecs, match count=0
For n=19, match time=65 msecs, match count=0
For n=20, match time=131 msecs, match count=0
For n=21, match time=263 msecs, match count=0
For n=22, match time=529 msecs, match count=0
For n=23, match time=1063 msecs, match count=0
For n=24, match time=2120 msecs, match count=0

===================================================

2012-10-14 15:53:55 update 注意到 46 行使用了 xrange，查找资料看到这里，http://ciniao.me/article.php?id=17

range 函数说明：range([start,] stop[, step])，根据start与stop指定的范围以及step设定的步长，生成一个序列。 range示例: »> range(5) [0, 1, 2, 3, 4] »> range(1,5) [1, 2, 3, 4] »> range(0,6,2) [0, 2, 4]

xrange 函数说明：用法与range完全相同，所不同的是生成的不是一个数组，而是一个生成器。 xrange示例: »> xrange(5) xrange(5) »> list(xrange(5)) [0, 1, 2, 3, 4] »> xrange(1,5) xrange(1, 5) »> list(xrange(1,5)) [1, 2, 3, 4] »> xrange(0,6,2) xrange(0, 6, 2) »> list(xrange(0,6,2)) [0, 2, 4]

由上面的示例可以知道：要生成很大的数字序列的时候，用xrange会比range性能优很多，因为不需要一上来就开辟一块很大的内存空间，这两个基本上都是在循环的时候用：

最短脚本下载文件

Sun, 23 Sep 2012 22:25:34 +0800

今天遇到一个题，给定一个文本文件，每一行一个 url，用脚本把他们下载回来，语言不限，越短越好

简短这种事情首先想起 python

import urllib

f = open("url.txt", "r")
for line in f:
    urllib.urlretrieve(line, line[line.rfind("/") + 1:-1])
f.close()

准备的 url.txt，需要注意最后有一个空行

https://www.google.com/images/srpr/logo3w.png http://www.baidu.com/img/baidu_sylogo1.gif

运行结果

下面试试 php 的，注意小心处理行尾的换行符 rn

<?php
$f = fopen("url.txt","r");
while (!feof($f)) {
  $line = fgets($f);
  if ( ! empty($line)) {
    file_put_contents(substr($line, strrpos($line, "/")+1, strlen($line)-strrpos($line, "/")-3), file_get_contents(substr($line, 0, strlen($line)-2)));
  }
}
fclose($f);

测试数据，同上，需要一个空行，另外，php 默认无法访问 https，所以改了 google 那行

http://www.baidu.com/img/baidu_sylogo1.gif http://p1.qhimg.com/d/_hao360/sou360/sou_logo.jpg

效果

算法复习之快速排序

Fri, 10 Aug 2012 17:27:37 +0800

快速排序这个自己想了一会，真的想不出来，还是查了资料，使用 C89 标准函数库有一个非常简单的写法，（维基上的不能跑，自己稍稍改了一下）

#include <stdio.h>
#include <stdlib.h>

static int cmp(int *a, int *b)
{
	return *a-*b;
}

int main()
{
	int arr[10]={5, 3, 7, 4, 1, 9, 8, 6, 2};

	qsort(arr, 10, sizeof(int), (int(*) (const void *,const void *))cmp);

	return 0;
}

而我交到 hdu 的是

#include <stdio.h>
#define MAX 1005

int get(int arr[])
{
	int n, i;
	scanf("%d", &n);
	for (i=0; i<n; i++)
	{
		scanf("%d", &arr[i]);
	}
	return n;
}

void print(int arr[], int n)
{
	printf("%d", arr[0]);
	int i;
	for (i=1; i<n; i++)
	{
		printf(" %d", arr[i]);
	}
	printf("n");
}

void quick_sort(int arr[], int left, int right)
{
	int i = left, j = right;
	int pivot = arr[(i+j)/2];
//	printf("pivot is %dn", pivot);
	while (i <= j)
	{
		while (arr[i] < pivot)
		{
			i++;
		}
		while (arr[j] > pivot)
		{
			j--;
		}
		if (i <= j)
		{
		//	printf("swapping arr[%d]:%d and arr[%d]:%dn",
		//		i, arr[i], j, arr[j]);
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
			i++;
			j--;
		}
	}
	if (left < j)
	{
		quick_sort(arr, left, j);
	}
	if (i < right)
	{
		quick_sort(arr, i, right);
	}
}

int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int arr[MAX] = {0};
		int n = get(arr);
		quick_sort(arr, 0, n-1);
		print(arr, n);
	}
	return 0;
}

最后，附上一个 python 的版本，再次体会到 python 的简洁

def qsort(L):
   if not L: return []
   return qsort([x for x in L[1:] if x< L[0]]) + L[0:1] + 
          qsort([x for x in L[1:] if x>=L[0]])

不仅简洁，而且思路非常清晰，易懂，不过 python 这个版本空间复杂度比较高就是了

==============================================================

2012-08-11 00:37:12 update: 上面那个快排，有两个地方想不懂：

在 31 行 while 循环那里，为什么需要小于等于呢，为什么不能去掉等号呢
在 52 和 56 行那里，为什么需要判断 if 呢，那个地方是一个递归终止条件这我知道，问题是，那个 if 在什么情况下会不成立呢，i 从左往右递增，怎么会超过 right 呢，同理 j 也一样啊

==============================================================

2012-08-11 01:01:26 update: 第二个问题看下面这个代码的输出应该就能有体会了，具体我也不知道怎么说

#include <stdio.h>
#define MAX 1005

int total;
int *p_arr;

int get(int arr[])
{
	int n, i;
	scanf("%d", &n);
	for (i=0; i<n; i++)
	{
		scanf("%d", &arr[i]);
	}
	return n;
}

void print(int arr[], int n)
{
	n = total;
	arr = p_arr;
	printf("%d", arr[0]);
	int i;
	for (i=1; i<n; i++)
	{
		printf(" %d", arr[i]);
	}
	printf("n");
}

void quick_sort(int arr[], int left, int right)
{
	int i = left, j = right;
	int pivot = arr[(i+j)/2];
	printf("left is %d right is %d pivot is %dn", left, right, pivot);
	while (i <= j)
	{
		while (arr[i] < pivot)
		{
			i++;
		}
		while (arr[j] > pivot)
		{
			j--;
		}
		if (i <= j)
		{
			printf("swapping arr[%d]:%d and arr[%d]:%dn",
				i, arr[i], j, arr[j]);
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
			i++;
			j--;
			print(arr, 0);
		}
	}
	if (left < j)
	{
		quick_sort(arr, left, j);
	}
	else
	{
		printf("left is %d and not smaller than j is %dn", left, j);
	}
	if (i < right)
	{
		quick_sort(arr, i, right);
	}
	else
	{
		printf("i is %d and not smaller than right is %dn", i, right);
	}
}

int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int arr[MAX] = {0};
		p_arr = arr;
		int n = get(arr);
		total = n;
		quick_sort(arr, 0, n-1);
		print(arr, n);
		printf("donen");
	}
	return 0;
}

至于第一个问题嘛，我把等于号删掉了，交到 hdu 上是可以过的，看起来应该是没问题的，但是怎么证明呢

Linux 下多个 Python 版本造成 easy_install 出错

Sat, 04 Aug 2012 16:50:41 +0800

debian 默认有 python 2.5 ，我下了 2.73 的源码包自己编译安装了，也改了系统的默认调用

sudo rm /usr/bin/python
sudo ln -s /usr/lib/python2.73/python2.7 /usr/bin/python

这样确实可以默认启用 2.73 的 python ，但是后来使用

sudo apt-get install python-setuptools
sudo easy_install pip

的时候就报错，报 No module named pkg_resources

看起来像是找不到模块，猜想是 setuptools 安装到了 2.5 的下面去了，于是把软连接改回来，就可以正常使用 easy_install

问题是怎么让系统承认 2.73 并把 setuptools 装到新的里面去啊

Python win32com 初步

Fri, 03 Aug 2012 23:35:12 +0800

第一次接触 com 编程，还挺好玩的，以前想要生成一份 ms office 文档的话，思路都是使用一些类库来直接生成，或者读写，原来还可以这样通过一个 com 像指挥一样向程序发指令让程序本身去执行，虽然没有写过 office 里面的 vbscript ，不过估计应该是跟这个挺类似的吧，有点意思。

想要使用 Python 进行 com 操作的话需要先安装 pywin32 ，在这里，http://sourceforge.net/projects/pywin32/ ，一路 next 就行了。

先来看操作 excel 的：

#!/usr/bin/env python

from Tkinter import Tk
from time import sleep
from tkMessageBox import showwarning
import win32com.client as win32

warn = lambda app: showwarning(app, 'Exit?')
RANGE = range(3, 8)

def excel():
    app = 'Excel'
    xl = win32.gencache.EnsureDispatch('%s.Application' % app)
    ss = xl.Workbooks.Add()
    sh = ss.ActiveSheet
    xl.Visible = True
    sleep(1)

    sh.Cells(1, 1).Value = 'Python-to-%s Demo' % app
    sleep(1)
    for i in RANGE:
        sh.Cells(i, 1).Value = 'Line %d' % i
        sleep(1)
    sh.Cells(i+2, 1).Value = "Th-th-th-that's all folks!"

    warn(app)
    ss.Close(False)
    xl.Application.Quit()

if __name__ == '__main__':
    Tk().withdraw()
    excel()

代码应该比较简答，就不需要多解释了。

效果如图：

然后是操作 word 的：

#!/usr/bin/env python

from Tkinter import Tk
from time import sleep
from tkMessageBox import showwarning
import win32com.client as win32

warn = lambda app: showwarning(app, 'Exit?')
RANGE = range(3, 8)

def word():
    app = 'Word'
    word = win32.gencache.EnsureDispatch('%s.Application' % app)
    doc = word.Documents.Add()
    word.Visible = True
    sleep(1)

    rng = doc.Range(0, 0)
    rng.InsertAfter('Python-to-%s Testrnrn' % app)
    sleep(1)

    for i in RANGE:
        rng.InsertAfter('Line %drnrn' % i)
        sleep(1)

    rng.InsertAfter("rnrnTh-th-th-th-that's all folks!rn")

    warn(app)
    doc.Close(False)
    word.Application.Quit()

if __name__ == '__main__':
    Tk().withdraw()
    word()

效果如图：

然后是操作 powerpoint 的：

#!/usr/bin/env python

from Tkinter import Tk
from time import sleep
from tkMessageBox import showwarning
import win32com.client as win32

warn = lambda app: showwarning(app, 'Exit?')
RANGE = range(3, 8)

def ppoint():
    app = 'PowerPoint'
    ppoint = win32.gencache.EnsureDispatch('%s.Application' % app)
    pres = ppoint.Presentations.Add()
    ppoint.Visible = True

    s1 = pres.Slides.Add(1, win32.constants.ppLayoutText)
    sleep(1)
    s1a = s1.Shapes[0].TextFrame.TextRange
    s1a.Text = 'Python-to-%s Demo' % app
    sleep(1)
    s1b = s1.Shapes[1].TextFrame.TextRange
    for i in RANGE:
        s1b.InsertAfter("Line %drn" % i)
        sleep(1)
    s1b.InsertAfter("rnTh-th-th-that's all folks!")

    warn(app)
    pres.Close()
    ppoint.Quit()

if __name__ == '__main__':
    Tk().withdraw()
    ppoint()

效果如图：

最后一个是综合应用，从 yahoo 官网获得当前股票价格，然后打在 excel 里面：

#!/usr/bin/env python

from Tkinter import Tk
from time import sleep, ctime
from tkMessageBox import showwarning
from urllib import urlopen
import win32com.client as win32

warn = lambda app: showwarning(app, 'Exit?')
RANGE = range(3, 8)
TICKS = ('YHOO', 'GOOG', 'EBAY', 'AMZN')
COLS = ('TICKET', 'PRICE', 'CHG', '%AGE')
URL = 'http://quote.yahoo.com/d/quotes.csv?s=%s&f=sl1c1p2'

def excel():
    app = 'Excel'
    xl = win32.gencache.EnsureDispatch('%s.Application' % app)
    ss = xl.Workbooks.Add()
    sh = ss.ActiveSheet
    xl.Visible = True
    sleep(1)

    sh.Cells(1, 1).Value = 'Python-to-%s Stock Quote Demp' % app
    sleep(1)
    sh.Cells(3, 1).Value = 'Prices quoted as of: %s' % ctime()
    sleep(1)
    for i in range(4):
        sh.Cells(5, i+1).Value = COLS[i]
    sleep(1)
    sh.Range(sh.Cells(5, 1), sh.Cells(5, 4)).Font.Bold = True
    sleep(1)
    row = 6

    u = urlopen(URL % ','.join(TICKS))
    for data in u:
        tick, price, chg, per = data.split(',')
        sh.Cells(row, 1).Value = eval(tick)
        sh.Cells(row, 2).Value = ('%.2f' % round(float(price), 2))
        sh.Cells(row, 3).Value = chg
        sh.Cells(row, 4).Value = eval(per.rstrip())
        row += 1
        sleep(1)
    u.close()

    warn(app)
    ss.Close(False)
    xl.Application.Quit()

if __name__ == '__main__':
    Tk().withdraw()
    excel()

这个代码有的一说，首先是 30 行，原来选中多个单元格还可以这么 range 的，在其他语言里基本上没有想象过，然后 34 行，用一个逗号去 join 一个列表，这个也是很灵巧的写法，python 果然是个灵活的语言啊

效果如图：

Python 多线程初学遇到的输出混叠问题

Fri, 03 Aug 2012 21:45:44 +0800

照着书上敲了一个多线程的例子：

#!/usr/bin/env python

import thread
from time import sleep, ctime

loops = [4, 2]

def loop(nloop, nsec, lock):
    print 'start loop', nloop, 'at:', ctime()
    sleep(nsec)
    print 'loop', nloop, 'done at:', ctime()
    lock.release()

def main():
    print 'starting at:', ctime()
    locks = []
    nloops = range(len(loops))

    for i in nloops:
        lock = thread.allocate_lock()
        lock.acquire()
        locks.append(lock)

    for i in nloops:
        thread.start_new_thread(loop,
                    (i, loops[i], locks[i]))

    for i in nloops:
        while locks[i].locked():
            pass

    print 'all done at:', ctime()

if __name__ == '__main__':
    main()

这里解释一下 21 行，accquire 方法的调用表示把“把锁锁上”，下面的 start 循环就是把准备好的线程一个个启动了，再下面那个的那个 pass 循环，是在“等待所有的锁解开”，这里需要注意的是，他是从第一个锁开始“等待”的，也就是说，就算后面的锁都解了，但是第一个还锁着，他也不知道，也不管的，简单想一下就明白这样处理是没问题的，因为总要等到所有的锁都解开才能跑后续的代码嘛

但是问题出现了，在输出的时候，得到这样的输出

starting at: Fri Aug 03 21:38:55 2012
start loopstart loop  01  at:at:  Fri Aug 03 21:38:55 2012Fri Aug 03 21:38:55 2012

loop 1 done at: Fri Aug 03 21:38:57 2012
loop 0 done at: Fri Aug 03 21:39:03 2012
all done at: Fri Aug 03 21:39:03 2012

正如所见，两个线程开始的那个打印语句冲突了，在同一行输出，这应该是一个多线程对输出设备写操作上的问题，怎么解决呢，自己刚学多线程，完全没有思路，于是上 stackoverflow 去问，看到别人这个问题的答案 http://stackoverflow.com/questions/1501651/log-output-of-multiprocessing-process ，

The easiest way might be to just override sys.stdout.
Slightly modifying an example from the multiprocessing
manual:

from multiprocessing import Process
import os
import sys

def info(title):
    print title
    print 'module name:', __name__
    print 'parent process:', os.getppid()
    print 'process id:', os.getpid()

def f(name):
    sys.stdout = open(str(os.getpid()) + ".out", "w")
    info('function f')
    print 'hello', name

if __name__ == '__main__':
    p = Process(target=f, args=('bob',))
    p.start()
    q = Process(target=f, args=('fred',))
    q.start()
    p.join()
    q.join()
And running it:

$ ls
m.py
$ python m.py
$ ls
27493.out  27494.out  m.py
$ cat 27493.out
function f
module name: __main__
parent process: 27492
process id: 27493
hello bob
$ cat 27494.out
function f
module name: __main__
parent process: 27492
process id: 27494
hello fred

看起来，他是重载了输出文件，这个比较高深，暂时看不懂，而且暂时也没有深入的涉及到 python 多线程的应用，所以这个问题暂时放着吧，等以后需要的时候回头来看

历史评论

Gecko (2013-08-16 12:33:17):

解决python多线程输出重叠问题，可以从输出入手，一般输出采用的是print函数，Print函数是可以被线程打断，如果不被打断的话就不会出现重叠的情况。可以采用sys.stdout.write来解决。

ZRJ (2013-08-20 10:35:28):

嗯，这个问题后来就放下没管了，下次要用的时候可以试试这个，学习了，thanks!

Python GUI 初步

Fri, 03 Aug 2012 11:04:45 +0800

照书敲了一个列出当前路径下所有文件的工具，GUI 框架用的 tk，一个小提示，保存时存为 pyw 后缀可以避免在双击运行程序时出现命令行窗口：

#!/usr/bin/env python

import os
from time import sleep
from Tkinter import *

class DirList(object):
    def __init__(self, initdir=None):
        self.top = Tk()
        self.label = Label(self.top, text='Directory Lister')
        self.label.pack()

        self.cwd = StringVar(self.top)

        self.dirl = Label(self.top, fg='blue',
                          font=('Helvetica', 12, 'bold'))
        self.dirl.pack()

        self.dirfm = Frame(self.top)
        self.dirsb = Scrollbar(self.dirfm)
        self.dirsb.pack(side=RIGHT, fill=Y)
        self.dirs = Listbox(self.dirfm, height=15, width=50,
                            yscrollcommand=self.dirsb.set)
        self.dirs.bind('', self.setDirAndGo)
        self.dirsb.config(command=self.dirs.yview)
        self.dirs.pack(side=LEFT, fill=BOTH)
        self.dirfm.pack()

        self.dirn = Entry(self.top, width=50,
                          textvariable=self.cwd)
        self.dirn.bind('', self.doLs)
        self.dirn.pack()

        self.bfm = Frame(self.top)
        self.clr = Button(self.bfm, text='Clear',
                          command=self.clrDir,
                          activeforeground='white',
                          activebackground='blue')
        self.ls = Button(self.bfm, text='List Directory',
                         command=self.doLs,
                         activeforeground='white',
                         activebackground='red')
        self.quit = Button(self.bfm, text='Quit',
                           command=self.top.quit,
                           activeforeground='white',
                           activebackground='red')
        self.clr.pack(side=LEFT)
        self.ls.pack(side=LEFT)
        self.quit.pack(side=LEFT)
        self.bfm.pack()

        if initdir:
            self.cwd.set(os.curdir)
            self.doLs()

    def clrDir(self, env=None):
        self.cwd.set('')

    def setDirAndGo(self, ev=None):
        self.last = self.cwd.get()
        self.dirs.config(selectbackground='red')
        check = self.dirs.get(self.dirs.curselection())
        if not check:
            check = os.curdir
        self.cwd.set(check)
        self.doLs()

    def doLs(self, ev=None):
        error = ''
        tdir = self.cwd.get()
        if not tdir:
            tdir = os.curdir
        if not os.path.exists(tdir):
            error = tdir + ': no such file'
        elif not os.path.isdir(tdir):
            error = tdir + ': not a directory'

        if error:
            self.cwd.set(error)
            self.top.update()
            sleep(2)
            if not (hasattr(self, 'last') and self.last):
                self.last = os.curdir
            self.cwd.set(self.last)
            self.dirs.config(selectbackground='LightSkyBlue')
            self.top.update()
            return

        self.cwd.set('Fetcing directory contents...')
        self.top.update()
        dirlist = os.listdir(tdir)
        dirlist.sort()
        os.chdir(tdir)
        self.dirl.config(text=os.getcwd())
        self.dirs.delete(0, END)
        self.dirs.insert(END, os.curdir)
        self.dirs.insert(END, os.pardir)
        for eachFile in dirlist:
            self.dirs.insert(END, eachFile)
        self.cwd.set(os.curdir)
        self.dirs.config(selectbackground='LightSkyBlue')

def main():
    d = DirList(os.curdir)
    mainloop()

if __name__ == '__main__':
    main()

代码虽然很长，但是其实都不难，比较好懂，基本上不需要怎么解释了

Python 网络编程初步

Thu, 02 Aug 2012 22:33:04 +0800

晚上跟着书上教程写了一些 socket 收发的代码，记下来当作备忘吧：

原生 socket 的 TCP 收发：

#!/usr/bin/env python

from socket import *
from time import ctime

HOST = ''
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST, PORT)

tcpSerSock = socket(AF_INET, SOCK_STREAM)
tcpSerSock.bind(ADDR)
tcpSerSock.listen(5)

while True:
    print 'waiting for connection...'
    tcpCliSock, addr = tcpSerSock.accept()
    print '...connected from: ', addr

    while True:
        data = tcpCliSock.recv(BUFSIZ)
        if not data:
            break
        print 'received: ' + data
        tcpCliSock.send('[%s] %s ' % (ctime(), data))
    tcpCliSock.close()
tcpSerSock.close()

其他都好懂，解释一下 13 行，文档是这么说的：

listen(backlog)

Enable a server to accept connections. The backlog argument must be at least 0 (if it is lower, it is set to 0); it specifies the number of unaccepted connections that the system will allow before refusing new connections.

也就是缓冲区大小，能暂存的连接数的意思了。

还有 17 行，返回了一个元组，文档的解释：

accept() -> (socket object, address info)

Wait for an incoming connection. Return a new socket representing the connection, and the address of the client. For IP sockets, the address info is a pair (hostaddr, port).

下面是客户端的代码：

#!/usr/bin/env python

from socket import *

HOST = 'localhost'
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST, PORT)

tcpCliSock = socket(AF_INET, SOCK_STREAM)
tcpCliSock.connect(ADDR)

while True:
    data = raw_input('> ')
    if not data:
        break
    tcpCliSock.send(data)
    data = tcpCliSock.recv(BUFSIZ)
    if not data:
        break
    print data
tcpCliSock.close()

原生 socket 的 UDP 收发

#!/usr/bin/env python

from socket import *
from time import ctime

HOST = ''
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST, PORT)

udpSerSock = socket(AF_INET, SOCK_DGRAM)
udpSerSock.bind(ADDR)

while True:
    print 'waiting for message...'
    data, addr = udpSerSock.recvfrom(BUFSIZ)
    udpSerSock.sendto('[%s] %s' % (ctime(), data), addr)
    print '...received from and returned to:', addr

udpSerSock.close()

#!/usr/bin/env python

from socket import *

HOST = 'localhost'
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST, PORT)

udpCliSock = socket(AF_INET, SOCK_DGRAM)

while True:
    data = raw_input('> ')
    if not data:
        break
    udpCliSock.sendto(data, ADDR)
    data, ADDR = udpCliSock.recvfrom(BUFSIZ)
    if not data:
        break
    print data

udpCliSock.close()

Python 入门环境配置

Sat, 28 Jul 2012 15:30:54 +0800

最近几天在碰 python ，配了一些环境，为了防止以后忘记，记下来吧：

python 用的是 2.7，在这里下载，http://www.python.org/download/releases/2.7.3/

跟着 django 的教程写了一些 demo ，写之前要先安装 django ，看这里，http://www.ibm.com/developerworks/cn/opensource/os-cn-django/index.html ，需要说明的是，这篇文章的版本跟实际使用的有些差异，悲剧的是他的范例代码 404 下载不了了，于是只能自己摸索着写，在这个过程中为了安装 python 到 mysql 的连接器，还费了些周折，看这里的教程，http://www.programlife.net/windows-python-mysqldb-install.html

然后就是试了试 flask ，看这里的教程安装了虚拟环境（本来 python 自己就是一个虚拟机一类的虚拟环境，结果还有一个类似沙盒的虚拟环境。。。）http://dormousehole.readthedocs.org/en/latest/index.html ，写了 demo ，一个留言板，然后看这里，https://github.com/mitsuhiko/flask/tree/master/examples/minitwit ，是一个微型的类 twitter 工具

然后开始看江阁的代码，期间看这里安装了 flask-script http://packages.python.org/Flask-Script/ ，然后安装了 pep8 http://pypi.python.org/pypi/pep8/ ，另外安装了 flask-sqlalchemy ，还有 flask-babel ，这个地方出现了一个诡异的事情就是重新报错说 script 没有安装，但是用 easy_install 或者 pip 安装的时候又报已经安装了，反思了一下想起当时安装 script 的时候由于 pip 无法得到源码于是是自己从 github 上面 clone 下来的，当时是在没有 virtualenv 的环境下安装的，但是 flask 是在有 virtualenv 里面的，于是在虚拟环境里面重新进去 script 的源码文件夹再次安装，得以解决，后面跟着又安装了 flask-mail ，过程中遇到 resource 找不到的问题，看了 http://stackoverflow.com/questions/7556850/no-module-named-resource-installing-flask-mail 这里解决了，然后安装了 flask-assets ，安装完后报 cannot import name ManageAssets ，这个地方一直搞不过，于是重装 python 。。。

这次学乖了，上来直接装虚拟环境，然后在里面用 pip 装 flask ， script ， sqlalchemy ，等等之前那一堆，这次装 assets 还好，一次过了，然后报 No module named rbac.acl ，这次用 https://github.com/tonyseek/simple-rbac 的 pip install simple-rbac 弄好了，然后安装了 flask-wtf ，后面的也基本上解决了，但是最后进入 ledge应用的时候报 context 找不到，这个问题找了江阁，江阁说他也跑不起来。。坑爹啊，于是就到此为止了。