python

本文主要讲述如何在python中使用复制和引用，并通过实例演示python引用和复制的用法。

本文实例讲述了python中引用与复制用法。分享给大家供大家参考。具体分析如下：

在python中，任何不可变对象是传值的，而可变对象是传引用的。

不管是向函数传递参数或者是任何形式的对象复制来说，不可变对象（比如整数，字符串）被真正复制，而可变对象只是复制了一个对他们的引用，即在内存中只有一份对象，而引用两份。
 
a=b 这样的赋值，就会创建对b的引用，对于象数字和字符串这样的不可变的对象，这种赋值实际是创建了b的一个副本

>>> a='hello'
>>> b=a
>>> id(a)
29326432
>>> id(b)
29326432
>>> b is a
True
>>> a=1000
>>> b
'hello'
 

对于可变对象,比如字典和列表，a和b引用的是同一个对象，修改其中任意一个变量都会影响到另一个。

>>> a=[1,2,3,4]
>>> b=a
>>> id(a)
29280896
>>> id(b)
29280896
>>> b[3]='ccccccccc'
>>> a
[1, 2, 3, 'ccccccccc']
>>>
 

列表和字典这样的容器对象，可以使用两种赋值操作：浅复制和深复制。浅复制创建一个新对象，但它包含的是对原始对象中包含的项的引用。

比如下面的浅复制：

>>> a=[1,2,3,4,[9,0]]
>>> b=a
>>> a=[1,2,3,4,[9,0]]
>>> b=list(a)
>>> b is a
False
>>> b[0]=1000
>>> b
[1000, 2, 3, 4, [9, 0]] #注意，b修改了b[0]以后，对a没有影响
>>> a
[1, 2, 3, 4, [9, 0]]
>>> b[4][1]='cccc'  #注意，b修改了 b[4][1]以后，对a有影响
>>> b
[1000, 2, 3, 4, [9, 'cccc']]
>>> a
[1, 2, 3, 4, [9, 'cccc']]
 

深复制将创建一个新对象，并且递归的复制它包含的所有对象，没有内置对象可以创建深复制，可以使用copy.deepcopy()函数完成。

>>> import copy
>>> a=[1,2,3,[4,5]]
>>> b=copy.deepcopy(a)
>>> id(b)
29582240
>>> id(a)
29581840
>>> a is b
False
>>> b[0]=1000
>>> b
[1000, 2, 3, [4, 5]] #注意修改了b[0]之后对a没有影响
>>> a
[1, 2, 3, [4, 5]]
>>> b[3][1]='gggg'
>>> b
[1000, 2, 3, [4, 'gggg']] #修改了 b[3][1]之后对a也没有影响，这是和浅复制的区别
>>> a
[1, 2, 3, [4, 5]]
 

希望本文所述对大家的Python程序设计有所帮助。

python中引用和复制的用法就这样，欢迎大家参考。。。。

枚举

不要这么做：

i = 0
for item in iterable:
    print i, item
    i += 1

而是这样：

for i, item in enumerate(iterable):
    print i, item

Enumerate可以接受第二个参数，例如：

>>> list(enumerate('abc'))
[(0, 'a'), (1, 'b'), (2, 'c')]
>>> list(enumerate('abc', 1))
[(1, 'a'), (2, 'b'), (3, 'c')]
 

字典/集合 解析

你可能知道列表解析，但不知道字典/集合解析。字典/集合解析简单而且高效，例如：

my_dict = {i: i * i for i in xrange(100)}
my_set = {i * 15 for i in xrange(100)}
# There is only a difference of ':' in both
 

强制浮点数除法

如果我们除以一个整数，即使结果是一个浮点数，Python（2） 依旧会给我们一个整数。为了规避这个问题，我们需要这样做：

result = 1.0/2

但是现在有一种别的方法可以解决这个问题，甚至在之前我都没有意识到有这种方法存在。你可以进行如下操作：

from __future__ import division
result = 1/2
# print(result)
# 0.5
 

需要注意的是这个窍门只适用于Python 2。在Python 3 中就不需要进行import 操作了，因为它已经默认进行import了。

简单的服务器

你想快速简单的分享目录下的文件吗？可以这样做：

# Python2
python -m SimpleHTTPServer
# Python 3
python3 -m http.server
 

这回启动一个服务器

Python表达式求值

我们都知道 eval,但也许并不是所有人都知道 literal_eval.可以这么做：

import ast
my_list = ast.literal_eval(expr)

而不是这样：

expr = "[1, 2, 3]>"
my_list = eval(expr)

我相信对于大多数人来说这种形式是第一次看见，但是实际上这个在Python中已经存在很长时间了。

分析脚本

按下面的方式运行脚本，可以很简单的对其进行分析：

python -m cProfile my_script.py

对象自检

在Python中，可以通过dir()来检查对象，例如：

>>> foo = [1, 2, 3, 4]
>>> dir(foo)
['__add__', '__class__', '__contains__',
'__delattr__', '__delitem__', '__delslice__', ... ,
'extend', 'index', 'insert', 'pop', 'remove',
'reverse', 'sort']
 

调试脚本

你可以使用 pdb模块在脚本中设置断点来调试脚本，就像这样：

import pdb
pdb.set_trace()

你可以在脚本的任何地方加入 pdb.set_trace()，该函数会在那个位置设置一个断点。超级方便。你应该多阅读 pdb
函数的相关内容，因为在它里面还有很多鲜为人知的功能。

简化if结构

如果必须检查一些值，可以用

if n in [1,4,5,6]:

而不是用复杂的if结构：

if n==1 or n==4 or n==5 or n==6:

字符串/数列 逆序

下面的方式可以快速反转一个列表：

>>> a = [1,2,3,4]
>>> a[::-1]
[4, 3, 2, 1]
# This creates a new reversed list.
# If you want to reverse a list in place you can do:
a.reverse()
 

这种方式同样适用于字符串：

>>> foo = "yasoob>"
>>> foo[::-1]
'boosay'
 

优雅地打印

下面的方式可以用优雅的方式打印字典和列表：

from pprint import pprint
pprint(my_dict)

这用于字典打印是非常高效的，如果你想从文件中快速优雅的打印出json，可以这样做：

cat file.json | python -m json.tools

三元运算

三元运算是if-else 语句的快捷操作，也被称为条件运算。这里有几个例子可以供你参考:

[on_true] if [expression] else [on_false] x, y = 50, 25
small = x if x < y else y [/code]

译文出处： http://www.ido321.com/1576.html

原文:http://segmentfault.com/a/1190000002869103

import os
import re
import argparse
def inred( s ):
	return"%s[31;2m%s%s[0m>"%(chr(27), s, chr(27))
def parseInput():
	parser = argparse.ArgumentParser()
	parser.add_argument("-p>", nargs='*')
	parser.add_argument('-s',nargs='*')
	parser.add_argument('-k',nargs='*')
	args = parser.parse_args()
	return args.p, args.s, args.k
def searchFile(mfile,patterns):
	fr = open(mfile,'r')
	line_num = 0
	flag = True
	while True:
		line = fr.readline()
		line_num += 1
		if line:
			for eachp in patterns:
				if(eachp.findall(line)):
					if flag:
						print mfile
						flag = False
					print "line>",line_num,line,
		else:
			break
	if not flag:
		print ">"
if __name__ == "__main__>":
	mpaths,filefilters,mkeys = parseInput()
	if mpaths == None:
		mpaths = [os.getcwd()]
	print "Search paths:>",mpaths
	print "File filters:>",filefilters
	print "Search keys:>",mkeys
	print ">"
	file_pattern = []
	key_pattern = []
	if filefilters:
		for eachff in filefilters:
			file_pattern.append(re.compile(eachff,re.I))
	if mkeys:
		for eachkey in mkeys:
			key_pattern.append(re.compile(eachkey,re.I))
	for eachp in mpaths:
		list_dirs = os.walk(eachp)
		for root, dirs, files in list_dirs:
			for f in files:
				if filefilters != None:
					for eachfp in file_pattern:
						if(eachfp.findall(f)):
							fname = os.path.join(root, f)
							if mkeys != None:
								searchFile(fname,key_pattern)
							else:
								print fname
							break
				elif mkeys != None:
					fname = os.path.join(root, f)
					searchFile(fname,key_pattern)
				else:
					print 'USAGE: -p paths -s file_filters(must be regular expression) -k keys(must be regular expression)'
					quit()
 

grep.py -p <you_dir> -s <file_filter_re_pattern> -k <key_word_re_pattern> 

这样就可以查找指定目录下的文件内容，如果你的命令行已经在该目录，则-p选项可选，如果不指定文件名过滤，-s选项可选.如果想直接搜索文件名则可省去-k选项

grep.py -p  -s 

另外，-s和-k选项支持正则表达式，所以要注意使用转义符号，各个选项都支持多参数.

原文:http://linxianyan.cn/python实现linux下grep查找功能/

测试

Python 默认参数提高了变成效率，但是这里面的坑也是坑死人不偿命，使用稍微不正确，会造成致命的失误

#!/usr/bin/env python
# -*- coding: utf-8 -*-
def test(lang=[]):
  lang.append('python')
  return lang
 

当老实调用时，结果如你所愿

print(test(['js','go']))
print(test(['c','java']))

结果如下

['js', 'go', 'python']
['c', 'java', 'python']
[Finished in 0.1s]
 

但是如果多次使用默认参数调用时，奇迹出现了

print(test())
print(test())

结果如下：

['python']
['python', 'python']
[Finished in 0.1s]

或许有人对此感到很困惑，为什么默认参数会记住更新过的默认参数

为了便于理解等同下面这段：

temp = []
def test(lang=temp):
  lang.append('python')
  return lang
 

这样就好看多了，多次调用时， temp也在不断的变化

注意函数默认参数和函数中的参数的上下文环境

结论

定义函数默认参数时，函数默认参数必须指向不变对象，建议使用 None，str 这些不可变对象处理

重新修改代码

#!/usr/bin/env python
# -*- coding: utf-8 -*-
def test(lang=None):
  if lang is None:
    lang = []
  lang.append('python')
  return lang
 

调用

print(test())
print(test())

结果：

['python']
['python']
[Finished in 0.2s]

原文:http://segmentfault.com/a/1190000002869653

每个框架或者应用都是为了解决某些问题才出现旦生的，没有一个事物是可以解决所有问题的。如果觉得某个框架或者应用使用很不方便，那么很有可能就是你没有将其使用到正确的地方，没有按开发者的设计初衷来使用它，当你将一个框架的优势使用到极致时一定是非常舒服和顺手的一件事。但同时也有可能衍生另一个问题，这个框架只解决了你的问题一，没有解决问题二、三等等，因此，就出现了多个框架/应用相结合的情况。比如Django + uWSGI + nginx。

本人初学python，找了一些实例进行了一些操作，以下纯属目前的理解，如有偏差，欢迎修正。

一、关于Django、uwsgi、nginx这三者关系的理解。

Django是一个WEB框架。所谓WEB框架，那么一定是搭建了一些模型，在安装完框架后，可以很方便的调用框架的方法，实现web功能。Django的特点在于MVC，模型–视图–控制。关于MVC不同的框架有不同的定义，不用纠结去统一MVC的定义，只需要理解各个框架自身的设计的特点的优势。关于Django框架，M模型：指的的数据库模型的管理（对于Django更多的在数据库相关的应用程序开发上有一点的优势）；V视图：指的是如何根据业务需求来显示M中的哪些数据，更多是与业务相关；C控制：指的是用户访问的浏览器的地址与视图的映射关系。由于C比较简单已经由Django封装好了，基本上只用按正则表达示写一些类似配置文件的东西即可。而人们说到MVC时一般会有一个表示层，即业务数据在页面如果显示，以表格还是其它方式，表格的样式如何等等，该层在Django中也可被称为T模板，被合并到V中。所以使用Django，我们一般关心的是MTV的管理。

既然Django其重点在于MVC的模架管理，虽然也可以使用Django完成WEB服务器的功能（执行命令 python manage.py runserver），但是仅仅是在测试环境中使用，对于要求稳定性和性能的生产环境，它无法达到。因此需要加入uWSGI。wsgi是一种协议，仅仅是协议并未实现，而uwsgi也是一种协议，两者有所不同。而uWSGI就是使用python将wsgi与uwsgi进行实现的WEB服务器，Django + uWSGI其WEB服务器的功能要更优于Django本身自带的web服务器。

那么有了uWSGI为什么还需要nginx？因为nginx具备优秀的静态内容处理能力，然后将动态内容转发给uWSGI服务器，这样可以达到很好的客户端响应。

二、环境搭建。

1、安装Django。

关于Django的使用网上资料很多，本人选择了两个比较合适的资料进行了实战操作，觉得不错。可参见”Django搭建及源码分析(一)“，提到了搭建方法和，参考资料。下面进入本节主题。

本人的系统环境centos6.0、python2.6、Django1.6，虽然都比较老了，但是不影响了解事物的本质的特点。继续…

2、安装uWSGI。

Django环境的搭建与配置请参见"Django搭建及源码分析(一)“，在保证Django可以访问之后，加入uWSGI。

使用 pip install uwsgi

我安装的是uwsgi 2.0.1版本。

3、验证uWSGI是否安装成功。

新建test.py文件，内容如下：

def  application(env, start_response):
    start_response( ' 200 OK ' , [(' Content-Type ' ,' text/html ' )])
     return  " Hello World >"  

执行
uwsgi
—
http
:
8000
 
—
wsgi
–
file test
. py

在浏览器内输入：http://ip:8001，查看是否有”Hello World>”输出，若没有输出，请检查你的安装过程。

4、验证Django+uWSGI是否连接成功。

uwsgi –http :8000 –wsgi-file /home/MyDjProj/MyDjProj/wsgi.py

将test.py修改为Django项目中生成的wsgi.py，通过浏览器访问Django框架中的页面，成功。则说明两者连接正常。

5、安装nginx。

下载自已喜欢的nginx版本，我下的是当前最新稳定版nginx-1.8.0.tar.gz。

./
configure
—
prefix
=
/usr/
local
/
nginx
–
1.8



—
with
–
http_stub_status_module
—
with
– http_gzip_static_module

make
&& make install

6、配置uwsgi

uwsgi支持ini、xml等多种配置方式，本文以 ini 为例在/etc下创建uwsgi8000.ini

[ uwsgi ]
socket  = 127.0.0.1:8000
master  = true         //主进程
vhost  = true          //多站模式
no-stie  = true        //多站模式时不设置入口模块和文件
workers  = 2           //子进程数
reload-mercy  = 10
vacuum  = true         //退出、重启时清理文件
max-requests  = 1000
limit-as  = 512
buffer-size  = 30000
pidfile  = /var/run/uwsgi8000.pid    //pid文件，用于下面的脚本启动、停止该进程
daemonize  = /var/log/uwsgi8000.log  //日志文件
pythonpath  = /usr/lib/python2.6/site-packages //同环境变量PYTHONPATH 

7、配置nginx

找到nginx的安装目录（如：/usr/local/nginx-1.8/），打开conf/nginx.conf文件，修改server配置：

	server {
		listen	    80;
 		server_name  localhost;
		#charset koi8-r ;
		#access_log  logs/host.access.log  main ;
		location /{
			include  uwsgi_params ;
 			uwsgi_pass 127.0.0.1:8000;			//必须和uwsgi中的设置一致
 			uwsgi_param UWSGI_SCRIPT MyDjProj.wsgi;	//入口文件，即wsgi.py相对于Django项目根目录的位置，“.”相当于一层目
 			uwsgi_param UWSGI_CHDIR /home/MyDjProj;	//Django项目根目录
 			index index.html index.htm;
 			client_max_body_size 35m;
 		}
 

8、测试Django + uwsgi + nginx

uwsgi
—
ini
/
etc
/
uwsgi8000
.
ini
&

/usr/
local
/
nginx-1.8
/
sbin
/ nginx

在浏览器输入：http://ip/，你就可以看到django的”It work>”了。http://ip/hello，可以打开Django项目中，通过urlconf配置的hello子页面的view视图

三、遇到的问题。

1、在连接Django与uwsgi时(










uwsgi –http :8000 –wsgi-file /home/MyDjProj/MyDjProj/wsgi.py
)，报出“ImportError: Could not import settings ‘MyDjProj.settings’ (Is it on sys.path? Is there an import error in the settings file?): No module named MyDjProj.settings”

可以看出执行时，在sys.path中无法找到MyDjProj.settings，需要所/home/MyDjProj加入到sys.path中即可，加入方法有很多，在此我使用的是export PYTHONPATH=$PYTHONPATH:/home/MyDjProj，加入后，再访问即可。
>

在连接Django、uwsgi和nginx时，sys.path不受环境变量PYTHONPATH的影响，也会自动将nginx配置中的项目根目录加入到sys.path中，因此在后续步骤中此问题不影响三者连接。

2、在连接Django、uwsgi和nginx时，报出File “./MyDjProj/wsgi.py>”, line 17, in from django.core.wsgi import get_wsgi_application ImportError: No module named django.core.wsgi

可以看出在

3、遇到其它问题时，先判断端口是否正常打开，使用netstat -plnt查看。

4、修改后配置后，最好关闭uwsgi及nginx后，重新连接。关闭方法：fuser -k 端口/tcp。如：fuser -k 80/tcp; fuser -k 8000/tcp
>

5、多查看日志文件，文件中详细的报错信息，对于nginx的日志，可以通过在nginx.conf中配置error_log  /var/log/nginx_error.log info;将出错信息打印到该文件中便于定位。

原文:http://www.cnblogs.com/fangyuan1004/p/4546567.html

当前位置: •

深入 Python 3

《深入 Python 3》
的内容涵盖了 Python 3 及其与 Python 2 的区别。相对 《深入 Python》
而言，它 20% 的内容进行了修订，80％ 的内容是全新的。这本书现在已经完成了，但随时欢迎反馈意见。

目录 (展开)

-1. 《深入 Python 3》中有何新内容
0. 安装 Python
1. 第一份 Python 程序
2. 内置数据类型
3. 理解
4. 字符串
5. 正则表达式
6. 
   闭合 与
   生成器
7. 
   类 &
   迭代器
8. 高级迭代器
9. 单元测试
10. 重构
11. 文件
12. XML
13. Python 对象序列化
14. HTTP Web 服务
15. 
    案例研究：将 chardet移植到 Python 3
16. Python 类库打包
17. 
    使用 2to3将代码移植到 Python 3
18. 特殊方法名称
19. 接下来阅读什么？

本书遵循Creative Commons Attribution Share-Alike协议自由授权。您可选择下载
HTML
或是
PDF
版本。尤伯爱好者还可从水银仓库（Mercurial repository）进行克隆：

<samp class="p">you@localhost:~$ </samp><kbd>hg clone <a href="http://hg.diveintopython3.org"></a>http://hg.diveintopython3.org/ diveintopython3</kbd> 

本书为 Lynx 优化仅仅是因为你 ＊＊＊ 。我被告知它在图形化浏览器中看起来也很美观。

© 2001–9Mark Pilgrim

译文: 西班牙语、 意大利语

漏洞目录，漏洞，Discuz，nginx，DedeCms，phpcms，Ranking， toaza， mac

原文:http://sebug.net/paper/books/dive-into-python3/index.html

起因

深夜忽然想下载一点电子书来扩充一下kindle，就想起来python学得太浅，什么“装饰器”啊、“多线程”啊都没有学到。

想到廖雪峰大神的python教程很经典、很著名。就想找找有木有pdf版的下载，结果居然没找到！！CSDN有个不完整的还骗走了我一个积分！！尼玛！！

怒了，准备写个程序直接去爬廖雪峰的教程，然后再html转成电子书。

过程

过程很有趣呢，用浅薄的python知识，写python程序，去爬python教程，来学习python。想想有点小激动……

果然python很是方便，50行左右就OK了。直接贴代码：

#  coding:utf-8
import  urllib
domain  = ' http://www.liaoxuefeng.com '  # 廖雪峰的域名
path = r' C:Userscyhhao2013Desktoptemp\ '  # html要保存的路径
#  一个html的头文件
input = open(r' C:Userscyhhao2013Desktop.html ' , ' r ' )
head  = input.read()
 #  打开python教程主界面
f = urllib.urlopen(" http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000 >" )
home  = f.read()
f.close()
 #  替换所有空格回车（这样容易好获取url）
geturl = home.replace(" n >" , ">" )
geturl  = geturl.replace("  >" , ">" )
 #  得到包含url的字符串
list = geturl.split(r' em;"><ahref=>" ' )[1:]
 #  强迫症犯了，一定要把第一个页面也加进去才完美
list.insert(0, ' /wiki/001374738125095c955c1e6d8bb493182103fac9270762a000"> ' )
 #  开始遍历url List
for  li in  list:
	url  = li.split(r' >"> ' )[0]
	url  = domain + url			  # 拼凑url
print  url
	f  = urllib.urlopen(url)
	html  = f.read()
	 #  获得title为了写文件名
	title = html.split(" <title> >" )[1]
	title  = title.split("  - 廖雪峰的官方网站</title> >" )[0]
	 #  要转一下码，不然加到路径里就悲剧了
	title = title.decode(' utf-8 ' ).replace(" / >" , "  >" )
	 #  截取正文
	html = html.split(r' <!-- block main --> ' )[1]
	html  = html.split(r' <h4>您的支持是作者写作最大的动力！</h4> ' )[0]
	html  = html.replace(r' src=" ' , ' src=>" '  + domain)
	 #  加上头和尾组成完整的html
	html = head + html+" </body></html> >"
#  输出文件
	output = open(path + " %d >"  % list.index(li) + title + ' .html ' , ' w ' )
	output.write(html)
	output.close()
 

简直，人生苦短我用python啊！

最后

附上HTML转epub电子书格式在线链接： html.toepub.com

以及廖雪峰的教程： 链接廖雪峰的Git教程也非常非常的不错哦~

顺便扩充一下自己的→_→ GitHub（爬下来的html也在github上哦~）

以及个人博客： http://blog.zhusun.in/cyhhao

原文来自： 一个python爬虫小程序

by:cyhhao http://blog.zhusun.in/cyhhao/

原文:http://www.cnblogs.com/cyhhao/p/4501022.html

对于数据库操作的时候，我个人特别的倾向于用ORM这种对象映射模型， 可以让你最舒服的操作数据库，另外也可以最简单的实现数据库…    比如我写后端服务的时候，如果用mysqldb，那么想当的蛋疼…    来来回回的折腾的，在大量的参数下，很有可能会出各种各样的低级的问题…   如果你用python的peewee这种基于mysqldb的orm模型，那么会想当干练的操作mysql数据库。 

最近被几个网站爬了，真特么郁闷….   标注下，文章的原文链接是  

http://xiaorui.cc     http://xiaorui.cc/?p=1427

在github上，看到一个帅哥老外分享的一个关于python influxdb orm的数据操作模型 ， 代码虽然写的还很是精简干练 ,  但是具体的功能也算是实现了。   其实这orm底层调用的也是python的influxdb接口，期初以为他的实现应该是语法树ast那种。  下面是他的项目，有兴趣的朋友也看下他的实现，还是有些灵巧的。 

https://github.com/unaizalakain/qinfluxdb

qinfluxdb的安装配置 ~

pip install git+https://github.com/unaizalakain/qinfluxdb.git

下面是qinfluxdb的一个操作的例子 

from qinfluxdb import Client
# The client is just a wrapper around InfluxDB's python client
client = Client(database='analytics', timeout=60)
query = client.q.from_series('temperature')
# Iterate over the results
for result in query:
    print(result)
# List them all
query.all()
# Continue with the query and filter
query.where('value > 20').limit(20)
# Only select some of the values
query.values('time', 'mean(value)').group_by('time(1d)')
# Advanced filters
from qinfluxdb import Q
hot = Q('value > 30')
cold = Q('value < 0')
extreme = hot | cold
query.where(extreme) 

原文:http://xiaorui.cc/2015/05/13/python实现influxdb的orm对象关系映射模型/

最近需要考虑如何在django环境中跑定时任务. 这个在 stackoverflow也有对应的 讨论, 方法也有不少, 这边简单尝试和总结下.

假设我们现在的定期任务就是睡眠 n秒, 然后往数据库里面写一条记录, 记录这个任务的起始以及结束时间, 并且我们 不关心该任务的返回结果. 项目名称为 mmtest, 应用名称为 mma_cron(说实话我也不知道自己怎么取这样的名称….), 数据库使用 sqlite, model代码如下:

from  django.db  import  models
 from  django.utils  import  timezone
 # Create your models here.
 class  SimpleTask ( models . Model ):
  task_name  =  models . CharField ( max_length = 200 )
  start_time  =  models . DateTimeField ( 'task begin time' ,  default = timezone . now )
  finish_time  =  models . DateTimeField ( 'task end time' ,  blank = True ,  null = True )
  

最朴素的方法

考虑一个最最朴素的实现: 起一个简单的daemon程序, 每隔一定时间进行任务处理; 或者是写一个简单的程序, 利用 cron来定期执行该脚本. 一个好处是足够简单. 但很多时候写这样的程序需要花不少时间.

简单的改进

自己重新写一个程序有时候代价还是挺大的, 尤其是业务逻辑十分复杂的时候, 所以可以考虑复用已有的代码. 如果考虑 cron定期执行的策略, 我们可以在 django中实现对应逻辑, 方法也有几个:

1. 实现一个api, 定期请求
2. 扩展manage.py

方法一没什么好说的, 但是需要考虑访问控制; 方法二的话也很简单, 可以参考 自定义commands. 无论用哪种方式, 我们可以先实现对应的任务处理逻辑:

def  run_simple_task ( task_name ):
  task  =  SimpleTask ( task_name  =  task_name )
  task . save ()
  ## do a lot lot of stuff......
  seconds  =  random . randint ( 5 ,  15 )
  time . sleep ( seconds )
  task . finish_time  =  timezone . now ()
  task . save ()
  return  seconds
  

针对方法一, 实现对应的view:

from  django.http  import  HttpResponse
 from  .models  import  run_simple_task
 def  do_task ( request ,  task_name ):
  seconds  =  run_simple_task ( task_name )
  return  HttpResponse ( "I have done task in  %d  sec:  %s >"  %  ( seconds ,  task_name ))
  

添加对应的route:

urlpatterns  =  [
  ## add one
  url ( r'^task/(?P<task_name>w+)' ,  views . do_task ,  name = 'do_task' ),
 ]
  

我们手动访问试一下: curl 127.0.0.1:8000/mma_cron/task/ddddd, 可以看到在经过一段时间后数据库中有结果了. 可行~

针对方法二, 扩展 manage.py, 实现对应的command:

from  django.core.management.base  import  BaseCommand ,  CommandError
 from  mma_cron.models  import  run_simple_task
 class  Command ( BaseCommand ):
  help  =  'Run the simple command'
  def  add_arguments ( self ,  parser ):
  pass
  def  handle ( self ,  * args ,  ** options ):
  seconds  =  run_simple_task ( 'run from manage.py' )
  self . stdout . write ( "task done>" )
  

再手动试一下: python manage.py yy, 发现也有对应的结果, 可行~

至于定期可以通过设定cron来实现.

插件

上面的实现比较简便, 也很有效. django的插件也有对应的实现, 这里着重介绍一下 django-cron. 它类似使用了上面提到的方法二, 在此之上增加了 任务执行检查, 日志记录等功能. 我们也来看一下;)

安装的话推荐直接把源码下的 django_cron(相当于一个django的应用)目录放到当前工程目录. 使用可以参考 这里. 接下来需要执行下它的迁移操作(migration):

python manage.py migrate django_cron
  

该操作是创建对应的数据库, 之后执行定时任务时会把 时间和 相关结果保存到数据库中. 接下来我们需要在 mma_cron中定义一个对应的定时任务:

from  django.utils  import  timezone
 from  django_cron  import  CronJobBase ,  Schedule
 from  .models  import  run_simple_task
 class  SimpleTaskCronJob ( CronJobBase ):
  RUN_EVERY_MINS  =  1
  schedule  =  Schedule ( run_every_mins = RUN_EVERY_MINS )
  code  =  'mma_cron.cron.simple_task_cron_job'
  def  do ( self ):
  seconds  =  run_simple_task ( 'task from django-cron' )
  msg  =  "I have done task in  %s  sec:  %s >"
  return  ( "I have done task in  %s  sec:  %s >"  %  ( seconds ,  task_name ))
  

可以看到里面定义了该定时任务的 处理间隔与相应动作. 最后我们还需要在 settings.py注册一下我们的定时任务:

CRON_CLASSES  =  [
  "mma_cron.cron.SimpleTaskCronJob>" ,
 ]
  

大功告成, 接下来我们只需在执行 python manage.py runcrons即可跑我们的任务了. 运行时 django_cron会根据任务的执行时间与数据库中记录的时间做对比, 如果没到对应时间会直接退出. 每次执行完都会在 django_cron_cronjoblog这张表中记录对应的时间以及返回的结果(原来python不是默认把最后一个语句的结果当成返回值的, 好吧). 同样的, 为了让其定时跑, 我们也需要在crontab中添加对应的命令.

值得一提的是如果注册了多个任务, 这些任务默认是串行执行的(考虑到安全性). 如果想要并行执行需要改一些设置, 详见文档.

Celery

上述几种方法都比较简单, 但是我们还有其他的方式;) 比如很多人都提到的
Celery. 给我的感觉它很像 gearman和 sidekiq, 类似一个任务分发和处理框架. 利用它的 Periodic Tasks, 可以实现定期发布任务让worker取执行任务. 我们也来简单看看.

简单尝试

我们先不管django, 先感性的了解下Celery. Celery的 任务分发和 结果存储需要依赖外部组件, 可选的有 RabbitMQ, Redis, 数据库等等. 简单起见, 这里选择使用 redis( RabbitMQ部署起来还是稍微复杂了点).

首先根据官方的 教程, 创建个分发 加法和 乘法任务的系统. 先来看看 worker的代码:

from  __future__  import  absolute_import
 from  proj.celery  import  app
 @app.task
 def  add ( x ,  y ):
  return  x  +  y
 @app.task
 def  mul ( x ,  y ):
  return  x  *  y
 @app.task
 def  xsum ( numbers ):
  return  sum ( numbers )
  

再来看看 celery的设置代码:

from  __future__  import  absolute_import
 from  celery  import  Celery
 from  datetime  import  timedelta
 app  =  Celery ( 'proj' ,
  broker = 'redis://localhost' ,
  backend = 'redis://localhost' ,
  include = [ 'proj.tasks' ])
 ## 这段代码可以先忽略;)
 app . conf . update (
  CELERY_TASK_RESULT_EXPIRES  =  3600 ,
  CELERYBEAT_SCHEDULE  =  {
  'add-every-30-seconds' :  {
  'task' :  'proj.tasks.add' ,
  'schedule' :  timedelta ( seconds = 30 ),
  'args' :  ( 16 ,  32 ),
  },
  },
 )
 if  __name__  ==  '__main__' :
  app . start ()
  

我们先启动 redis, 然后通过执行 celery -A proj worker -l info来启动一个 worker. 接下来我们手动来创建任务, 然后丢给worker:

>>> import proj.tasks
 >>> result  =  proj.tasks.add.delay( 2,2)
 >>> result.get()
 4
  

这样就创建一个任务, 我们在celery的控制台(worker进程)可以看到这样的输出:

Received task: proj.tasks.add[ a24a9792-a7c6-4f64-994d-ca6903b3182c]
 Task proj.tasks.add[ a24a9792-a7c6-4f64-994d-ca6903b3182c]  succeeded in 0.0018904690005s: 4
  

很直观~ 我们同时也可以看看它在redis里面是什么个样子:

127.0.0.1:6379> keys *
 1)  "celery-task-meta-a24a9792-a7c6-4f64-994d-ca6903b3182c>"
 2)  "_kombu.binding.celery.pidbox>"
 3)  "_kombu.binding.celery>"
 4)  "_kombu.binding.celeryev>"
 127.0.0.1:6379> TYPE _kombu.binding.celery
 set
  

现在我们是手动来创建任务, 我们可以启动一个定时生产任务的生产者 celery -A proj beat -l info. 它会定期创建我们在 proj/celery.py代码中指定的 CELERYBEAT_SCHEDULE中的任务.

结合django

理解了celery, 再结合django就相对比较简单了. 推荐阅读一下官方的 文档. 结合我们的SimpleTask的例子, 先设定下celery的任务:

from  __future__  import  absolute_import
 import  os
 from  celery  import  Celery
 from  datetime  import  timedelta
 os . environ . setdefault ( 'DJANGO_SETTINGS_MODULE' ,  'mmtest.settings' )
 from  django.conf  import  settings
 app  =  Celery ( 'mmtest' ,  broker = 'redis://localhost' )
 app . config_from_object ( 'django.conf:settings' )
 ## 自动发现任务: APP/tasks.py
 app . autodiscover_tasks ( lambda :  settings . INSTALLED_APPS )
 ## 设置定时任务参数
 app . conf . update (
  CELERYBEAT_SCHEDULE  =  {
  'do-task-every-30-seconds' :  {
  'task' :  'mma_cron.tasks.do_task' ,
  'schedule' :  timedelta ( seconds = 30 ),
  },
  },
 )
 @app.task ( bind = True )
 def  debug_task ( self ):
  print ( 'Request: {0!r}' . format ( self . request ))
  

接下来我们需要实现一下我们的worker:

from  __future__  import  absolute_import
 from  celery  import  shared_task
 from  .cron  import  run_simple_task
 @shared_task
 def  do_task ():
  run_simple_task ( 'run by celery' )
  

不需要其他的工作, 我们就完成了我们的目的. 接下来就是分别启动 worker和 beat了. 这也实现了我们的定时任务的目的(就我们这个例子有点大材小用了).

选择

就我个人观点, 我比较倾向于改进后的朴素方法. 原因就是业务比较简单, 比较轻量级.

整个过程还是学到了不少东西. 继续学习python~

原文:http://blog.aka-cool.net/blog/2015/05/14/cron-job-in-django/

这篇文章主要是对我收集的一些文章的摘要。因为已经有很多比我有才华的人写出了大量关于如何成为优秀Python程序员的好文章。

我的总结主要集中在四个基本题目上：函数式编程，性能，测试，编码规范。如果一个程序员能将这四个方面的内容知识都吸收消化，那他/她不管怎样都会有巨大的收获。

函数式编程

命令式的编程风格已经成为事实上的标准。命令式编程的程序是由一些描述状态转变的语句组成。虽然有时候这种编程方式十分的有效，但有时也不尽如此(比如复杂性) —— 而且，相对于声明式编程方式，它可能会显得不是很直观。

如果你不明白我究竟是在说什么，这很正常。这里有一些文章能让你脑袋开窍。但你要注意，这些文章有点像《骇客帝国》里的红色药丸 —— 一旦你尝试过了函数式编程，你就永远不会回头了。

• http://www.amk.ca/python/writing/functional
• http://www.secnetix.de/olli/Python/lambda_functions.hawk
• http://docs.python.org/howto/functional.html

性能

你会看到有如此多的讨论都在批评这些“脚本语言”(Python，Ruby)是如何的性能低下，可是你却经常的容易忽略这样的事实：是程序员使用的算法导致了程序这样拙劣的表现。

这里有一些非常好的文章，能让你知道Python的运行时性能表现的细节详情，你会发现，通过这些精炼而且有趣的语言，你也能写出高性能的应用程序。而且，当你的老板质疑Python的性能时，你别忘了告诉他，这世界上第二大的搜索引擎就是用Python写成的 —— 它叫做Youtube(参考 Python摘录)

• http://jaynes.colorado.edu/PythonIdioms.html
• http://wiki.python.org/moin/PythonSpeed/PerformanceTips

测试

如今在计算机科学界，测试可能是一个最让人不知所措的主题了。有些程序员能真正的理解它，十分重视TDD(测试驱动开发)和它的后继者BDD(行为驱动开发)。而另外一些根本不接受，认为这是浪费时间。那么，我现在将告诉你：如果你不曾开始使用TDD/BDD，那你错过了很多最好的东西！

这并不只是说引入了一种技术，可以替换你的公司里那种通过愚蠢的手工点击测试应用程序的原始发布管理制度，更重要的是，它是一种能够让你深入理解你自己的业务领域的工具 —— 真正的你需要的、你想要的攻克问题、处理问题的方式。如果你还没有这样做，请试一下。下面的这些文章将会给你一些提示：

• http://www.oreillynet.com/lpt/a/5463
• http://www.oreillynet.com/lpt/a/5584
• http://wiki.cacr.caltech.edu/dan…._Integration_testing
• http://docs.python.org/library/unittest.html

编码规范

并非所有的代码生来平等。有些代码可以被另外的任何一个好的程序员读懂和修改。但有些却只能被读，而且只能被代码的原始作者修改 —— 而且这也只是在他或她写出了这代码的几小时内可以。为什么会这样？因为没有经过代码测试(上面说的)和缺乏正确的编程规范。

下面的文章给你描述了一个最小的应该遵守的规范合集。如果按照这些指导原则，你将能编写出更简洁和漂亮的代码。作为附加效应，你的程序会变得可读性更好，更容易的被你和任何其他人修改。

• http://www.python.org/dev/peps/pep-0008/
• http://www.fantascienza.net/leonardo/ar/python_best_practices.html

那就去传阅这这些资料吧。从坐在你身边的人开始。也许在下一次程序员沙龙或编程大会的时候，也已经成为一名Python编程高手了！

祝你学习旅途顺利。

如果你喜欢这些文章，请在微博上顶一下，让其他人也知道。

原文:http://www.vaikan.com/how-to-become-a-proficient-python-programmer/?rel=http://geek.csdn.net

最近在学习Django，打算玩玩网页后台方面的东西，因为一直很好奇但却没怎么接触过。Django对我来说是一个全新的内容，思路想来也是全新的，或许并不能写得很明白，所以大家就凑合着看吧～

本篇笔记（其实我的所有笔记都是），并不会过于详细的讲解。因此如果有大家看不明白的地方，欢迎在我正版博客下留言，有时间的时候我很愿意来这里与大家探讨问题。（当然，不能是简简单单就可以百度到的问题-.-）

我所选用的教材是《The Django Book 2.0》，本节是我自己插入的数据库安装步骤，针对不大了解数据库安装的同学。

————————————————————————————————————————————————

0、说明

为了在Django中使用数据库，需要先安装并设置好，在《The Django Book 2.0》书中，默认大家已经安装好了自己想要使用的数据库，但实际上，并不是所有人都已经了解如何安装的，甚至还很困扰，并且很难查到适合自己的教程（我就是-.-）。

这里我来说明一下，在Django中使用数据库所需的准备工作。

首先是安装。我使用的数据库是MySQL，那么，就需要在机器上已经安装好MySQL，并安装好其服务器和客户端。然后，把MySQL-python这个库安装好，才能在python代码中使用MySQL。

而后是设置，先要在MySQL中有一个供你使用的用户和数据库（如果没有现成的，就得创建一个）。然后，需要在你的Django工程的settings.py中设置好关于数据库的全部设置，以定位到你所要使用的数据库以及用来使用它的用户。

最后是使用，只要数据库的服务器在运行，你就可以在Django中按照你之前的设置使用这个数据库了。

再啰嗦一句，下面的各种命令都是要在终端中输入的，不再赘述。

1、安装MySQL

我的MySQL版本是5.6.24。（我的全部工作环境配置信息，例如操作系统，已经在 Django笔记 —— 入门简介中提到过，这里不再赘述）

想要查看自己机器里有没有的话，就在命令行中输入mysql，有反应就说明有。

没有的话，也无所谓，下面安装server的时候会自动安装的。

2、安装MySQL服务器和客户端

sudo apt-get install mysql-server

sudo apt-get install mysql-client

如果你之前机器中没有MySQL的话，在你安装server的时候会自动帮你安装，还会让你设置MySQL中的root密码，这在以后的MySQL使用中常常会使用到。

关于root用户，基本就和Linux的root用户感觉一样，这里简单解释一下。

使用MySQL时要用某个用户登录进去，每个用户都有自己的权限；而root则是里面最大权限的用户，拥有任何权限，可以管理所有其它用户。实际上，我们使用MySQL时，除了root用户之外，往往还要有另一个普通用户。平时使用时，就用那个普通用户；权限不够时，再上root。这样，可以避免你手一抖删掉不该删的东西～

3、安装MySQL-python

sudo pip install MySQL-python

注意大小写别写错了。

4、在MySQL中创建用户及数据库

现在你的MySQL已经安装好了，需要在MySQL中创建一个用户和一个数据库供Django使用。

先教一下用root登录数据库：

输入mysql -u root -p，然后输入你MySQL的root密码。

看到 mysql> 就说明你登录进去了，退出命令是exit，MySQL会和你说“Bye”。。

然后是新建用户：

1. 用root登录

2. 创建用户：insert into mysql.user(Host, User, Password) values(“localhost>”, “qiqi>”, password(“nicai>”));

3. 刷新权限表：flush privileges;

这样就创建了一个名叫qiqi，密码是nicai的用户。这个用户的类型是localhost，即在本地登录的用户。具体内容不多说，学习Django这种用户足够了。

最后创建一个数据库：

1. 用root登录

2. 创建一个数据库：create database django;

这样就创建了一个名叫django的数据库。

还没完，最后还要给qiqi使用django这个数据库的权限：

1. 用root登录

2. 授予全部权利：grant all privileges on django.* to qiqi@localhost identified by ‘nicai’;

至此，你可以用qiqi这个用户直接登录MySQL并操作数据库django了，至于在Django中使用还需要下面的设置：

5、在Django中设置

打开你Django某个工程中的settings.py，找到 DATABASES 属性，把它设置成这样：

 1  #  Database
 2  #  https://docs.djangoproject.com/en/1.8/ref/settings/#databases
 3
 4  DATABASES = {
  5  ' default ' : {
  6  ' ENGINE ' : ' django.db.backends.mysql ' ,
  7  ' NAME ' : ' django ' ,
  8  ' USER ' : ' qiqi ' ,
  9  ' PASSWORD ' : 'nicai ' ,
 10  ' HOST ' : ' 127.0.0.1 ' ,
 11  ' PORT ' : ' 3306 ' ,
 12      }
 13  }  

其中，因为我是在本机上操作的，所以HOST是这个；至于PORT，我是在网上搜索到的，应该是MySQL的默认端口。

这里注一句，大家看到代码开头那个网址没有？这就是Django对这个参数的说明文档链接。遇到问题，大家一定要善用文档！

6、运行数据库服务器

你安装好之后，MySQL的服务器每次开机都会自动运行的。所以这点可以略去。

7、尝试使用

在你刚才改settings.py的工程的根目录下，运行：python manage.py shell

如果可以正常进入，就说明Django已经可以通过settings.py中的设置定位到你在MySQL中要使用的用户和数据库了。

————————————————————————————————————————————————

至此，我们应该可以继续Django的学习了。

关于MySQL的内容，如果以后有机会用到或者大家有需要的话，我或许会写的。现在嘛，继续回归Django的学习。

原文:http://www.cnblogs.com/icedream61/p/4538636.html

有个需求，保存一个网页里的所有图片。

看上去是件简单的事情，拿 火狐的 DownThemAll扩展下载不就好了么。

然后发现那个网页仅限移动版访问。好吧，装个 UserAgent Switcher。然后发现它是通过 JavaScript 检测 UA 的，而 UserAgent Switcher 只改了 HTTP 头里的 UA。好吧，换个 muzuiget 的 User Agent Overrider。然后发现那些图片是动态加载的，DownThemAll 根本看不到地址。后来知道「查看网页信息」的「媒体」选项卡里也是可以保存图片的，不过那里显示的图片也不全……

于是我怒了，放弃继续尝试不同的工具，决定用 程序员的方式来解决问题。

我管你怎么加载的，你总归是要从网络上下载图片不是么？那我就拿个代理把你访问过的所有图片全部保存下来好了 🙂

打开 mitmproxy文档页，发现并没有现成的保存文件的功能。但是没关系，可以 写脚本。看看示例，迅速写了以下不到二十行代码：

#!/usr/bin/mitmdump -s
from __future__ import print_function
import os
from urlparse import urlsplit
from libmproxy.protocol.http import decoded
def response(context, flow):
  with decoded(flow.response):
    if flow.response.headers['Content-Type'][0].startswith('image/'):
      url = urlsplit(flow.request.url)
      name = os.path.basename(url.path)
      with open(name, 'wb') as f:
        f.write(flow.response.content)
      print(name, 'written') 

当然这是最终结果。不过和初版差别不大，毕竟就这么点儿代码。思路也很简单，凡是经过代理的图片都存起来。有点粗暴，但是好用。

代理脚本跑起来。然后启动一个全新的 Google Chrome，一个没有任何缓存存在的实例：

google-chrome-stable --proxy-server=http://localhost:8080 --user-data-dir=new 

访问目标页面，启用移动版模拟并刷新，就可以看到各种图片都被保存下来了～～

原文:http://lilydjwg.is-programmer.com/2015/5/30/save-images-with-mitmproxy.95114.html

#深圳# 6月10日 亚马逊AWSome Day云计算免费培训报名中

Rubicon 是连接 Python 和其他编程语言的工具集合。

Rubicon 库现在支持：

• Objective C

• Java

Objective C

Rubicon-ObjC是 Python 和 Objective-C 的桥梁，支持 iOS 和 OS X，允许你：

• 使用 Python 来实例化 Objective-C 中定义的对象

• 使用 Python 来调用 Objective-C 中定义的对象方法

• 使用 Python 来扩展 Objective-C 类或者子类

同时也包括一些 Core Foundation 框架关键数据类型的封装，比如 NSString 和 NSObject。

Rubicon-Java是 Java 运行时环境和 Python 的桥梁，支持桌面环境和 Android 设备。允许：

• 实例化 Java 定义的对象

• 调用 Java 定义的对象方法

• 访问和修改 Java 定义对象的静态和实例字段

• 编写是使用 Python 实现 Java 定义的接口

原文:http://www.oschina.net/p/rubicon

Python 操作mysql包有MySQLdb、SQLAlchemy等等、还有一个是mysql.connector，mysql官方包，详见（ MySQL Connector/Python Developer Guide

）。

用法官方有示例： Chapter 5 Connector/Python Coding Examples

5.1 Connecting to MySQL Using Connector/Python

5.2 Creating Tables Using Connector/Python

5.3 Inserting Data Using Connector/Python

5.4 Querying Data Using Connector/Python

安装方法： easy_install mysql-connector-python

用法和MySQLdb基本类似，这应该是类似一种协议的东西吧？

查询的时候是支持查询字典的！

connor.connect(*args, **kwargs)

cursor = conn.cursor(dictionary=True)

附加是我自己写的mysql_helper.py

———–

 1
# -*- coding: utf8 -*-

2
# @author: ‘zhangzhipeng’

3
# @date: ‘2015-04-10’

4

5
import
logging

6

7
import
mysql.connector as
connor

8

9

10connor.connect()

11
12

13
class
MysqlHelper
(object):

14
“>”” host=>”localhost”, db=>””, user=>”root”, passwd=>””, port=3306, pool_sizer=30, pool_name=>”mysql”, commit_size=1
>””>”

15commit_count = 0

16

17
def
__init__
(self, *args, **kwargs):

18
commit_size = kwargs.get(” commit_size
>”, -1)

19
if
commit_size > -1:

20self._commit_size = commit_size

21
del
kwargs[” commit_size
>”]

22
else
:

23self._commit_size = 1

24self._last_row_id = None

25self._conn = connor.connect(*args, **kwargs)

26

27
def
insert
(self, sql, params=None):

28cursor = self._create_cursor()

29
try
:

30cursor.execute(sql, params)

31
except
Exception, e:

32
try
:

33
logging.error(” Mysql Call error. SQL = %s, params = %s, Error.msg=%s
>” % (sql, str(params).encode(” utf8
>”), e))

34
except
:

35
print
sql, params, e

36self._last_row_id = cursor.lastrowid

37self._commit()

38
return
cursor.rowcount

39

40
def
update
(self, sql, params=None):

41
return
self.insert(sql, params)

42

43
def
delete
(self, sql, params=None):

44
return
self.insert(sql, params)

45

46
def
select
(self, sql, params=None):

47cursor = self._create_cursor()

48cursor.execute(sql, params)

49
return
cursor.fetchall()

50

51
def
commit
(self):

52
try
:

53self._conn.commit()

54
except
connor.Error, msg:

55
logging.error(” Mysql commit error. message:%s.
>” % msg)

56

57
@
property

58
def
last_row_id
(self):

59
return
self._last_row_id

60

61
def
_create_cursor
(self):

62
# cursor = conn.cursor(cursor_class=conner.cursor.MySQLCursorDict)

63cursor = self._conn.cursor(dictionary=True)

64
return
cursor

65

66
def
_commit
(self):

67self.__class__.commit_count += 1

68
if
self.__class__.commit_count == self._commit_size:

69self.commit()

70self.__class__.commit_count = 0

71

72
def
__del__
(self):

73
print
” mysql close …
>”

74self.commit()

75self._conn.close()

76
77

78
if
__name__ == ” __main__
>”:

79
mysql_helper = MysqlHelper(host=” localhost
>”, db=” zentao
>”, user=” root
>”, passwd=” kaimen
>”, port=3306, pool_size=2,

80
pool_name=” mysql
>”, commit_size=2)

81
print
1, mysql_helper.select(” show tables;
>”)

82
print
2, mysql_helper.select(” show tables;
>”)

83
print
3, mysql_helper.select(” show tables;
>”)

84
print
4, mysql_helper.select(” show tables;
>”)

85
print
5, mysql_helper.select(” select * from task;
>”)

select 结果是list[dict{}, dict{}] 

查询的时候，参数可以是列表、字典

user = {“uid>”: 20, “name>”:”zhipeng>”, “titles>”:”python, spider>”}

或者：

sql = ‘INSERT INTO users(uid, name, titles) VALUES (%(uid)s, %(name)s, %(titles)s);’

mysql_helper.
insert(sql, user
)

增、删、改，返回的结果是几行受影响。

mysql_helper.last_row_id 获取最后添加的自增长列id

commit_size 是设置主动commit方式，插入多少次数据后执行commit方法。

在__del__中添加主动commit，确保数据提交更改。

原文:http://blog.sina.com.cn/s/blog_83dc494d0102voun.html

之前一直用R，最近正在学python，因为没有什么工作经验，也只能谈谈自己的感悟。

数据科学家算是统计师和程序员的结合体，来源也主要是这两个专业的毕业生。不过这两个群体的思维方式还真的是不一样。可以认为，统计的人更加偏爱R，程序员更偏爱python。

其实python有了pandas才能使数据分析变的像R那样简单。数据科学家能把python用的像R一样我觉得就好了。不过如果除了数据分析，公司要求代码的重用性，或者直接嵌入到产品中（比如网站推荐系统），那么对编程的要求就更高了。

其实数据科学家在做数据分析的时候，起码80%的时间是在做数据整理和清洗，同意 @唐学伟说的熟练使用pandas就好，这意味着能熟练的清理掉不必要数据，读取主要的数据格式文件，数据的合并汇总归类和切片等等。数据整理好比学编程要最起码能控制if-else和for循环，命令简单但是实用。

数据整理好了，对于各种算法包里的函数，其实就是input output的问题了。

另外一个常用的就是数据可视化也就是绘图了（目前主要是matplotlib）。这个步骤对于input的数据就是数据探索化的过程，查看数据是否有不合理性，数据的分布等等，对于output的数据就是结果呈现的过程，这样更有助于分析。

总而言之，数据科学家熟悉python的基本语法，熟练pandas（基于numpy），能利用python熟练的获取数据，整理数据，并会使用matplotlib展现数据是一个基本的要求。对于要做科学计算或者机器学习来说，数据整理好了，编程不是问题，数学才是。

说到这里看工作需求了，如果你所在的部门／实验室都用R/SAS／java/c++之类的，会用py进行预处理基本就可以了；如果主要用py来进行挖掘，需要掌握的就多一些，比如：numpy／scipy／mattplotlib／ipython／scikit-learn等。

DS需要统计+计算机。数据科学家这么高端的名词，不是只拿工具做上层的应用

业务分析做的好，这样只能说是好的分析师，程序编的溜，才可以说是好的工程师。

（来源：知乎问答）

美国对冲基金交易员传授股指期货（第二期）

继四月底成功举办第一期后，应未报上名的朋友们的要求，现安排第二期课程，请朋友们抓紧时间报名，前十名优惠1000元。

培养出来的学员在期货和外汇市场屡屡实现三个月翻十倍、四个月翻六倍、三周翻两倍的惊人交易绩效。并被华尔街交易学院及盈道金融研究院聘为指导老师和技术顾问。

（点击阅读原文查看详情）

原文:http://mp.weixin.qq.com/s?__biz=MzA3MDI3ODQxOA==&mid=205945644&idx=4&sn=4d25d382eb78454ba7b7305e16299e93&3rd=MzA3MDU4NTYzMw==&scene=6#rd

应puppet大拿刘宇的邀请，我去西山居运维团队做了一个简短分享，谈谈为什么我要将我们的项目从python转向go。

坦白的讲，在一帮python用户面前讲为什么放弃python转而用go其实是一件压力蛮大的事情，语言之争就跟vim和emacs之争一样，是一个永恒的无解话题，稍微不注意就可能导致粉丝强烈地反击。所以我只会从我们项目实际情况出发，来讲讲为什么我最终选择了go。

为什么放弃python

首先，我其实得说说为什么我们会选择python。在我加入企业快盘团队之前，整个项目包括更早的金山快盘都是采用python进行开发的。至于为什么这么选择，当时的架构师葱头告诉我，主要是因为python上手简单，开发迅速。对于团队里面大部分完全没服务端开发经验的同学来说，python真的是一个很好的选择。

python的简单高效，我是深有体会的。当时私有云项目也就几个程序员，但是我们要服务多家大型企业，进行定制化的开发，多亏了python，我们才能快速出活。后来企业快盘挂掉之后，我们启动轻办公项目，自然也使用python进行了原始版本的构建。

python虽然很强大，但我们在使用的时候也碰到了一些问题，主要由如下几个方面：

• 动态语言

  python是一门动态语言，不是强类型系统。对于一个变量，我们有时候压根不知道它是什么类型，然后就可能出现int + string这样的运行时错误。

  在python里面，可以允许同名函数的出现，后一个函数会覆盖前一个函数，有一次我们系统一个很严重的错误就是因为这个导致的。

  上面说到的这些，静态语言在编译的时候就能帮我们检测出来，而不需要等到运行时出问题才知道。虽然我们有很完善的测试用例，但总有case遗漏的情况。所以每次出现运行时错误，我心里都想着如果能在编译的时候就发现该多好。

• 性能

  其实这个一直是很多人吐槽python的地方，不过想想，python最开始是为了解决啥问题而被开发出来的？我们硬是要将他用到高性能服务器开发上面，其实也是有点难为它。

  python的GIL导致导致无法真正的多线程，大家可能会说我用多进程不就完了。但如果一些计算需要涉及到多进程交互，进程之间的通讯开销也是不得不考虑的。

  无状态的分布式处理使用多进程很方便，譬如处理http请求，我们就是在nginx后面挂载了200多个django server来处理http的,但这么多个进程自然导致整体机器负载偏高。

  但即使我们使用了多个django进程来处理http请求，对于一些超大量请求，python仍然处理不过来。所以我们使用openresty，将高频次的http请求使用lua来实现。可这样又导致使用两种开发语言，而且一些逻辑还得写两份不同的代码。

• 同步网络模型

  django的网络是同步阻塞的，也就是说，如果我们需要访问外部的一个服务，在等待结果返回这段时间，django不能处理任何其他的逻辑（当然，多线程的除外）。如果访问外部服务需要很长时间，那就意味着我们的整个服务几乎在很长一段时间完全不可用。

  为了解决这个问题，我们只能不断的多开django进程，同时需要保证所有服务都能快速的处理响应，但想想这其实是一件很不靠谱的事情。

• 异步网络模型

  tornado的网络模型是异步的，这意味着它不会出现django那样因为外部服务不可用导致这个服务无法响应的问题。话说，比起django，我可是非常喜欢tornado的，小巧简单，以前还写过几篇深入剖析tornado的文章了。

  虽然tornado是异步的，但是python的mysql库都不支持异步，这也就意味着如果我们在tornado里面访问数据库，我们仍然可能面临因为数据库问题造成的整个服务不可用。

  其实异步模型最大的问题在于代码逻辑的割裂，因为是事件触发的，所以我们都是通过callback进行相关处理，于是代码里面就经常出现干一件事情，传一个callback，然后callback里面又传callback的情况，这样的结果就是整个代码逻辑非常混乱。

  python没有原生的协程支持，虽然可以通过gevent，greenlet这种的上patch方式来支持协程，但毕竟更改了python源码。另外，python的yield也可以进行简单的协程模拟，但毕竟不能跨堆栈，局限性很大，不知道3.x的版本有没有改进。

• 开发运维部署

  当我第一次使用python开发项目，我是没成功安装上项目需要的包的，光安装成功mysql库就弄了很久。后来，是一位同事将他整个python目录打包给我用，我才能正常的将项目跑起来。话说，现在有了docker，是多么让人幸福的一件事情。

  而部署python服务的时候，我们需要在服务器上面安装一堆的包，光是这一点就让人很麻烦，虽然可以通过puppet，salt这些自动化工具解决部署问题，但相比而言，静态编译语言只用扔一个二进制文件，可就方便太多了。

• 代码失控

  python非常灵活简单，写c几十行代码才能搞定的功能，python一行代码没准就能解决。但是太简单，反而导致很多同学无法对代码进行深层次的思考，对整个架构进行细致的考量。来了一个需求，啪啪啪，键盘敲完开速实现，结果就是代码越来越混乱，最终导致了整个项目代码失控。

  虽然这也有我们自身的原因，譬如没好的代码review机制，没有好的项目规范，但个人感觉，如果一个程序员没经过良好的编码训练，用python很容易就写出烂的代码，因为太自由了。

  当然，我这里并不是说用python无法进行大型项目的开发，豆瓣，dropbox都是很好的例子，只是在我们项目中，我们的python代码失控了。

上面提到的都是我们在实际项目中使用python遇到的问题，虽然最终都解决了，但是让我愈发的觉得，随着项目复杂度的增大，流量性能压力的增大，python并不是一个很好的选择。

为什么选择go

说完了python，现在来说说为什么我们选择go。其实除了python，我们也有其他的选择，java，php，lua(openresty)，但最终我们选择了go。

虽然java和php都是最好的编程语言（大家都这么争的），但我更倾向一门更简单的语言。而openresty，虽然性能强悍，但lua仍然是动态语言，也会碰到前面说的动态语言一些问题。最后，前金山许式伟用的go，前快盘架构师葱头也用的go，所以我们很自然地选择了go。

go并不是完美，一堆值得我们吐槽的地方。

• error，好吧，如果有语言洁癖的同学可能真的受不了go的语法，尤其是约定的最后一个返回值是error。项目里面经常会充斥这样的代码:

    if err := doA(); err != nil {
        if _, err := doB(); err != nil {
        }
    }
   

  难怪有个梗是对于一个需求，java的程序员在写配置的时候，go程序员已经写了大部分代码，但是当java的程序员写完的时候，go程序员还在写
  err != nil
  。

• 包管理，go的包管理太弱了，只有一个go get，也就是如果不小心更新了一个外部库，很有可能就导致现有的代码编译不过了。虽然已经有很多开源方案，譬如godep以及现在才出来的gb等，但毕竟不是官方的。貌似google也是通过vendor机制来管理第三方库的。希望go 1.5或者之后的版本能好好处理下这个问题。

• GC，java的GC发展20年了，go才这么点时间，gc铁定不完善。所以我们仍然不能随心所欲的写代码，不然在大请求量下面gc可能会卡顿整个服务。所以有时候，该用对象池，内存池的一定要用，虽然代码丑了点，但好歹性能上去了。

• 泛型，虽然go有inteface，但泛型的缺失会让我们在实现一个功能的时候写大量的重复代码，譬如int32和int64类型的sort，我们得为分别写两套代码，好冗余。go 1.4之后有了go generate的支持，但这种的仍然需要自己根据go的AST库来手动写相关的parser，难度也挺大的。虽然也有很多开源的generate实现，但毕竟不是官方的。

当然还有很多值得吐槽的地方，就不一一列举了，但是go仍旧有它的优势。

• 静态语言，强类型。静态编译能帮我们检查出来大量的错误，go的强类型甚至变态到不支持隐式的类型转换。虽然写代码感觉很别扭，但减少了犯错的可能。
• gofmt，应该这是我知道的第一个官方提供统一格式化代码工具的语言了。有了gofmt，大家的代码长一个样了，也就没有花括号到底放到结尾还是新开一行这种蛋疼的代码风格讨论了。因为大家的代码风格一样，所以看go的代码很容易。
• 天生的并行支持，因为goroutine以及channel，用go写分布式应用，写并发程序异常的容易。没有了蛋疼的callback导致的代码逻辑割裂，代码逻辑都是顺序的。
• 性能，go的性能可能赶不上c，c++以及openresty，但真的也挺强悍的。在我们的项目中，现在单机就部署了一个go的进程，就完全能够胜任以前200个python进程干的事情，而且CPU和MEM占用更低。
• 运维部署，直接编译成二进制，扔到服务器上面就成，比python需要安装一堆的环境那是简单的太多了。当然，如果有cgo，我们也需要将对应的动态库给扔过去。
• 开发效率，虽然go是静态语言，但我个人感觉开发效率真的挺高，直觉上面跟python不相上下。对于我个人来说，最好的例子就是我用go快速开发了非常多的开源组件，譬如ledisdb，go-mysql等，而这些最开始的版本都是在很短的时间里面完成的。对于我们项目来说，我们也是用go在一个月就重构完成了第一个版本，并发布。

实际项目中一些Go Tips

到现在为止，我们几乎所有的服务端项目都已经转向go，当然在使用的时候也遇到了一些问题，列出来算是经验分享吧。

• godep，我们使用godep进行第三方库管理，但是godep我碰到的最大的坑就是build tag问题，如果一个文件有build tag，godep很有可能就会忽略这个文件。
• IO deadline，如果能自己在应用层处理的都自己处理，go的deadline内部是timer来控制，但timer内部采用一个array来实现的heap，全局共用一个锁，如果大并发量，并且timer数量过多，timeout变动太频繁，很容易就引起性能问题。
• GC，这个前面也说了，多用内存池，对象池，另外，我还发现，如果对象的生命周期跟goroutine一致，对性能的提升也不错，也在go的group问过相关问题，大家猜测可能是因为一些对象其实是在goroutine的8k栈上面分配的，所以一起回收没有额外GC了。
• Go gob，如果要做RPC服务，gob并不是一个很好的选择，首先就跟python的pickle不通用，然后为了做不同系统的数据传入，任何包都必须带上类型的详细信息，size太大。go里面现在还没一套官方的RPC方案，gRPC貌似有上位的可能。

总结

虽然我现在选择了go，但是并不表示我以后不会尝试其他的语言。语言没有好坏，能帮我解决问题的就是好语言。但至少在很长的一段时间，我都会用go来进行开发。Let’ go!!!

原文:http://siddontang.com/2015/05/16/why-python-to-go/

由于给客户的发布版本上客户改动了些代码和图片，我们这边给他们更新publish都是增量更新（开发提供更新指定的文件，我们提取出来给客户进行覆盖更新），但有时需要更新的文件较多导致不得不一个一个的进行查找、替换，工作量大而且容易出错。所以用python写个保留pulish后目录的指定文件、删除其他文件的功能。

代码如下

 1  import  os
  2  import  os.path
  3
 4  def  DeleteFiles(path,fileList):
  5  for  parent,dirnames,filenames in  os.walk(path):
  6
 7          FullPathList = []
  8          DestPathList = []
  9
10  for  x in  fileList:
 11              DestPath = path + x
 12              DestPathList.append(DestPath)
 13
14
15  for  filename in  filenames:
16              FullPath = os.path.join(parent,filename)
 17              FullPathList.append(FullPath)
 18
19
20  for  xlist in  FullPathList:
 21  if  xlist not  in  DestPathList:
 22                  os.remove(xlist) 

代码解释：

1、for parent,dirnames,filenames in os.walk(path): 该for循环用于遍历指定path的父文件夹、文件夹名（不含目录）、文件名

2、

for  x in  fileList:
            DestPath  = path + x
            DestPathList.append(DestPath)  

该方法两个参数分别是path，filelist。path用来指定publish文件的存放目录，例如：’D:publish’，filelist通过list存放你希望保留的文件及该文件路径,例如：

[r’1.txt’,r’a1.txt’],然后将path和filelist拼接起来存放到另一个列表中就是你希望保存文件的完整路径存放在DestPathList中，既[‘D:\publish\1.txt’,’D:\publish\a\1.txt’]

3、

for  filename in  filenames:
            FullPath  = os.path.join(parent,filename)
            FullPathList.append(FullPath)  

将目录下所有文件的绝对路径存放在列表FullPathList中

4、

for  xlist in  FullPathList:
             if  xlist not  in  DestPathList:
                os.remove(xlist)  

遍历FullPathList中元素跟DestPathList中元素进行比对，如果不相同则删除文件

功能虽然简单，但工作中还是比较实用的，故在此留下脚印。

–Storage  QQ：258324960

原文:http://www.cnblogs.com/chub/p/4509921.html

lambda argument1, argument2, … argumentN: expression using arguments

原文:http://www.0550go.com/script/python/python-lambda.html

Compose是用于定义和运行复杂Docker应用的工具。你可以在一个文件中定义一个多容器的应用，然后使用一条命令来启动你的应用，然后所有相关的操作都会被自动完成。

1. 安装Docker和Compose

# 当前最新的Docker是1.6.2，Compose为1.2.0
curl -s https://get.docker.io/ubuntu/ | sudo sh
sudo apt-get update
sudo apt-get install lxc-docker
# 参考http://docs.docker.com/compose/install/#install-compose
curl -L https://github.com/docker/compose/releases/download/1.2.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose上面这个方法真的慢出翔，可以通过Python pip安装。
apt-get install python-pip python-dev
pip install -U docker-compose 

这样compose就安装好了，查看一下compose的版本信息：

chmod +x /usr/local/bin/docker-compose
docker-compose -version
docker-compose 1.2.0 

2. 使用Compose

使用Compose只需要简单的三个步骤：首先，使用Dockerfile来定义你的应用环境：

FROM python:2.7
ADD ./code
WORKDIR /code
RUN pip install -r requirements.txt 

其中，requirements.txt中的内容包括：

flask
redis

再用Python写一个简单的app.py

from flask importFlaskfrom redis importRedisimport os
app =Flask(__name__)
redis =Redis(host='redis', port=6379)@app.route('/')def hello():
    redis.incr('hits')return'Hello World! I have been seen %s times.'% redis.get('hits')if __name__ =="__main__>":
    app.run(host="0.0.0.0>", debug=True) 

第二步，用一个compose.yaml来定义你的应用，他们可以在下个互隔离的容器中组成你的应用。

web:
  build:.
  command: python app.py
  ports:-"5000:5000>"
  volumes:-.:/code
  links:- redis
redis:
  image: redis 

第三步，执行docker-compose up来启动你的应用，它会根据compose.yaml的设置来pull/run这俩个容器。

Creating myapp_redis_1...
Creating myapp_web_1...
Building web...
Step 0 : FROM python:2.7
2.7: Pulling from python
...
Status: Downloaded newer image for python:2.7
 ---> d833e0b23482
Step 1 : ADD . /code
 ---> 1c04b1b15808
Removing intermediate container 9dab91b4410d
Step 2 : WORKDIR /code
 ---> Running in f495a62feac9
 ---> ffea89a7b090
Attaching to myapp_redis_1, myapp_web_1
......
redis_1 | [1] 17 May 10:42:38.147 * The server is now ready to accept connections on port 6379
web_1   |  * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
web_1   |  * Restarting with stat 

3. Yaml文件参考

ports:-"3000>"-"8000:8000>"-"127.0.0.1:8001:8001>" 

volumes:-/var/lib/mysql
 - cache/:/tmp/cache
 -~/configs:/etc/configs/:ro 

volumes_from：加载其他容器或者服务的所有卷

environment:- RACK_ENV=development
  - SESSION_SECRET

common.yml
webapp:
  build:./webapp
  environment:- DEBUG=false- SEND_EMAILS=false
development.yml
web:extends:
    file: common.yml
    service: webapp
  ports:-"8000:8000>"
  links:- db
  environment:- DEBUG=true
db:
  image: postgres 

cpu_shares:73
working_dir:/code
entrypoint: /code/entrypoint.sh
user: postgresql
hostname: foo
domainname: foo.com
mem_limit:1000000000
privileged:true
restart: always
stdin_open:true
tty:true 

4. docker-compose常用命令

原文:http://debugo.com/docker-compose/

曾灵敏 — APRIL 27, 2015

装饰器基本概念

大家都知道装饰器是一个很著名的设计模式，经常被用于AOP(面向切面编程)的场景，较为经典的有插入日志，性能测试，事务处理， Web权限校验， Cache等。

Python语言本身提供了装饰器语法（@），典型的装饰器实现如下：

	@function_wrapper
	def function():
	   pass
@实际上是python2.4才提出的语法糖，针对python2.4以前的版本有另一种等价的实现：
	def function():
		pass
	function = function_wrapper(function)
##装饰器的两种实现
函数包装器 - 经典实现
	def function_wrapper(wrapped):
		def _wrapper(*args, **kwargs):
			return wrapped(*args, **kwargs)
		return _wrapper
	@function_wrapper
	def function():
		pass
 

类包装器 – 易于理解

	class function_wrapper(object):
		def __init__(self, wrapped):
			self.wrapped = wrapped
		def __call__(self, *args, **kwargs):
			return self.wrapped(*args, **kwargs)
	@function_wrapper
	def function():
		pass
 

函数（function）自省

当我们谈到一个函数时，通常希望这个函数的属性像其文档上描述的那样，是被明确定义的，例如 __name__和 __doc__。

针对某个函数应用装饰器时，这个函数的属性就会发生变化，但这并不是我们所期望的。

	def function_wrapper(wrapped):
		def _wrapper(*args, **kwargs):
			return wrapped(*args, **kwargs)
		return _wrapper
	@function_wrapper
	def function():
		pass
	>>> print(function.__name__)
	_wrapper
 

python标准库提供了 functools.wraps()，来解决这个问题。

	import functools
	def function_wrapper(wrapped):
		@functools.wraps(wrapped)
		def _wrapper(*args, **kwargs):
			return wrapped(*args, **kwargs)
		return _wrapper
	@function_wrapper
	def function():
		pass
	>>> print(function.__name__)
	function
 

然而，当我们想要获取被包装函数的参数（ argument）或源代码（ source code）时，同样不能得到我们想要的结果。

	import inspect
	def function_wrapper(wrapped): ...
	@function_wrapper
   def function(arg1, arg2): pass
	>>> print(inspect.getargspec(function))
	ArgSpec(args=[], varargs='args', keywords='kwargs', defaults=None)
	>>> print(inspect.getsource(function))
		@functools.wraps(wrapped)
		def _wrapper(*args, **kwargs):
			return wrapped(*args, **kwargs)
 

包装类方法（@classmethod）

当包装器（ @function_wrapper）被应用于 @classmethod时，将会抛出如下异常：

    class Class(object):
        @function_wrapper
        @classmethod
        def cmethod(cls):
            pass
    Traceback (most recent call last):
      File "<stdin>>", line 1, in <module>
      File "<stdin>>", line 3, in Class
      File "<stdin>>", line 2, in wrapper
      File ".../functools.py>", line 33, in update_wrapper
        setattr(wrapper, attr, getattr(wrapped, attr))
    AttributeError: 'classmethod' object has no attribute '__module__'
 

因为 @classmethod在实现时，缺少 functools.update_wrapper需要的某些属性。这是 functools.update_wrapper在python2中的bug，3.2版本已被修复，参考http://bugs.python.org/issue3445。

然而，在python3下执行，另一个问题出现了：

    class Class(object):
	@function_wrapper
	@classmethod
	def cmethod(cls):
	    pass
    >>> Class.cmethod()
    Traceback (most recent call last):
      File "classmethod.py>", line 15, in <module>
	Class.cmethod()
      File "classmethod.py>", line 6, in _wrapper
	return wrapped(*args, **kwargs)
    TypeError: 'classmethod' object is not callable
 

这是因为包装器认定被包装的函数（ @classmethod）是可以直接被调用的，但事实并不一定是这样的。被包装的函数实际上可能是描述符（ descriptor），意味着为了使其可调用，该函数（描述符）必须被正确地绑定到某个实例上。关于描述符的定义，可以参考https://docs.python.org/2/howto/descriptor.html。

总结 – 简单并不意味着正确

尽管大家实现装饰器所用的方法通常都很简单，但这并不意味着它们一定是正确的并且始终能正常工作。

如同上面我们所看到的， functools.wraps()可以帮我们解决 __name__和 __doc__的问题，但对于获取函数的参数（argument）或源代码（ source code）则束手无策。

以上问题， wrapt都可以帮忙解决，详细用法可参考其官方文档：http://wrapt.readthedocs.org

本文作者系 OneAPM工程师曾灵敏 ，想阅读更多好的 技术文章，请访问OneAPM官方技术博客。

原文:http://www.ituring.com.cn/article/198266

按理来说，应该是一个很简单的过程。从多说导出标准的备份文件，导入 Disqus，就完事了。但是我就整整的折腾了几天，评论是导入进去了，但是在博文页面始终没有把原来的评论显示出来。今天下午，甚至向 Disqus 官方发送了求救邮件。

就在刚才，才发现原来 Disqus 是根据文章的 URL 作为 Primary Key 的，而我新的博客系统的文章 URL 结尾比原来的少了个 /。擦，就是这一个字符，导致没有把原先的评论显示出来

Old:  http: //example.com/article
New:  http: //example.com/article/
 

导入的具体过程

首先，在多说的后台将评论（包括文章）导出为一个 export.json文件。这个文件格式是不被 Disqus 认的，所以我们得把它转换成 wordpress 导出的文件格式

轮子已经有人造了，我们就不再重复造轮子。使用这个轮子 JamesPan/duoshuo-migrator对 export.json进行转换

pip install lxml
python duoshuo-migrator.py  -i  ~/Desktop/export.json   -o disqus.xml
 

将文件转换为 disqus.xml

最后把 disqus.xml通过 Disqus 后台的 Discussions -> Import 进行导入。官方写着24小时会处理完队列，实际上，如果评论少的话，马上评论就被成功导入进去了

反正，就得坑在 Disqus 是根据文章的 URL 作为 Primary Key ，这个是文章的唯一重点

写在最后

其实，这篇博客没有在表达多说比 Disqus 差。在国内的话，多说加载比 Disqus 快，默认的社交分享也比较符合中国的国情。但是，有一颗折腾的心，没事多折腾折腾，其实也是挺好的啦！

原文:http://dearb.me/archive/2015-05-17/transfer-comments-from-duoshuo-to-disqus/