最初看到这个问题是初中的时候买了一本有关数学谜题的书里面概率论的一张的课后拓展就是说到三门问题，当时作为一个扩展阅读看了一下，里面说到了一个世界智商最高的女人秒杀了美国一大群的数学高材生的精彩故事（比较夸张），当时对这个问题也是似懂非懂。

什么是蒙提霍尔问题？

最初的表述是：

这个古老的问题一经提出就引起了剧烈的争论，有人认为换与不换最终得到车的概率都是$\frac{1}{2}$，有人认为换门之后得到车的概率更大，应该选择换门之后得到车的概率为$\frac{2}{3}$在撰写这篇文章的时候在 果壳上还有人在为此争吵， 知乎上也有许多关于这方面的讨论，其实这些争论很多情况下都是因这个问题的模糊表述所引起的，关键点在于 主持人对于门后的情况是否了解：

1. 如果主持人事先知道哪个门里有山羊并且他特意选择了有山羊的门打开了，那么参赛者应该换另一扇门，这可以将他胜利的概率从$\frac{1}{3}$升到$\frac{2}{3}$
2. 如果主持人事先不知道哪个门里有山羊或者他只是随机的选择了一个门，但事实发现里面恰好是山羊。这时候参赛者没有换门的必要，胜利概率总是$\frac{1}{2}$

为了后续的讨论，这里采用 维基百科上对于这一个问题的不含糊的定义

严格的表述如下：

• 参赛者在三扇门中挑选一扇。他并不知道内里有什么。
• 主持人知道每扇门后面有什么。
• 主持人必须开启剩下的其中一扇门，并且必须提供换门的机会。

• 主持人永远都会挑一扇有山羊的门。

  • 如果参赛者挑了一扇有山羊的门，主持人必须挑另一扇有山羊的门。
  • 如果参赛者挑了一扇有汽车的门，主持人随机在另外两扇门中挑一扇有山羊的门。

• 参赛者会被问是否保持他的原来选择，还是转而选择剩下的那一道门。

有三种可能的情况，全部都有相等的可能性（$\frac{1}{3}$）：

• 参赛者挑汽车，主持人挑两头羊的任何一头。转换将失败。
• 参赛者挑A羊，主持人挑B羊。转换将赢得汽车。
• 参赛者挑B羊，主持人挑A羊。转换将赢得汽车。

所以玩家选择换门之后获胜的概率应为$\frac{2}{3}$

证明？

定义:

• 事件A为一开始玩家选择的一扇门

• 事件H为最后门后的结果

• 如果是选择不换门的策略

  $P \left(H=car \right) = P \left(A=car \right) = \frac{1}{3} $

  因为选择的是不交换的策略，所有只有一开始选中的是汽车，最后才能选中汽车。

• 选择交换门的策略

  $P \left(H=car \right) = P \left(A=sheep \right) = \frac{2}{3} $

  因为选择的是交换的策略，所有只有一开始选中的是羊，最后才能选中汽车。

程序验证

实践是检验真理的唯一标准，在流言终结者看到他们人工重复这个实验区验证，发现这样很浪费时间。何通过计算机去去模拟这一段过程呢？下面使用python程序来模拟这一段过程：

from __future__ import division
import logging
from matplotlib import pyplot as plt
import numpy as np
import random
class MontyHall(object):
	">""docstring for MontyHall>"">"
	def __init__(self, num=3):
		">""
		创建一个door列表
		0 代表关门
		1 表示后面有车
		-1 代表门被打开
		>"">"
		super(MontyHall, self).__init__()
		self.doors = [0] * num
		self.doors[0] = 1
		self.choice = -1
		self.exclude_car = False
		self.shuffle()
	def shuffle(self):
		">""
		开始新游戏
		重新分配门后的东西
		>"">"
		if self.exclude_car == True:
			self.doors[0] = 1
			self.exclude_car = False
		for i in xrange(len(self.doors)):
			if self.doors[i] == -1:
				self.doors[i] = 0
		random.shuffle(self.doors)
	def make_choice(self):
		">""
		player随机选择一扇门
		>"">"
		self.choice = random.randint(0, len(self.doors) - 1)
		logging.info("choice: %d>" % self.choice)
		logging.info("original: %s>" % self.doors)
	def exclude_doors(self):
		">""
		主持人知道门后的情况排除门
		直到剩余两扇门
		>"">"
		to_be_excluded = []
		for i in xrange(len(self.doors)):
			if self.doors[i] == 0 and self.choice != i:
				to_be_excluded.append(i)
		random.shuffle(to_be_excluded)
		for i in xrange(len(self.doors) - 2):
			self.doors[to_be_excluded[i]] = -1
		logging.info("final: %s>" % self.doors)
	def random_exclude_doors(self):
		">""
		主持人并不知道门后面的情况随机的开门
		直到剩余两扇门
		>"">"
		to_be_excluded = []
		for i in xrange(len(self.doors)):
			if self.doors[i] != -1 and i != self.choice:
				to_be_excluded.append(i)
		random.shuffle(to_be_excluded)
		for i in xrange(len(self.doors) - 2):
			if self.doors[to_be_excluded[i]] == 1:
				self.exclude_car = True
			self.doors[to_be_excluded[i]] = -1
		logging.info("final: %s>" % self.doors)
	def change_choice(self):
		">""
		player改变选择
		>"">"
		to_change = []
		for i in xrange(len(self.doors)):
			if self.doors[i] != -1 and i != self.choice:
				to_change.append(i)
		self.choice = random.choice(to_change)
		logging.info("choice changed: %d>" % self.choice)
	def random_choice(self):
		">""
		player 第二次随机选择门
		>"">"
		to_select = []
		for i in xrange(len(self.doors)):
			if self.doors[i] != -1:
				to_select.append(i)
		self.choice = random.choice(to_select)
		logging.info("random choice : %d>" % self.choice)
	def show_answer(self):
		">""
		展示门后的情况
		>"">"
		logging.info(self.doors)
	def check_result(self):
		">""
		验证结果
		>"">"
		got_it = False
		if self.doors[self.choice] == 1:
			got_it = True
		return got_it
 

模拟1000轮，每一轮重复试验1000次

• 不改变选择：

def unchange_choice_test(n):
	">""
	不改变初始的选择
	>"">"
	result = {}
	game = MontyHall()
	for i in xrange(n):
		game.shuffle()
		game.make_choice()
		game.exclude_doors()
		if game.check_result():
			result["yes>"] = result.get("yes>", 0) + 1
		else:
			result["no>"] = result.get("no>", 0) + 1
	for key in result:
		print "%s: %d>" % (key, result[key])
	return result["yes>"] / n
if __name__ == '__main__':
	logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.WARNING)
	results = []
	test_num = 1000
	round_num = 1000
	for x in xrange(0,round_num):
		results.append(change_random_test(test_num) )
	y_mean = np.mean(results)
	y_std = np.std(results)
	x = range(0,round_num)
	y = results
	plt.figure(figsize=(8,4))
	plt.xlabel("round>")
	plt.ylabel("frequency>")
	plt.title("The frequency of the success>")
	tx = round_num / 2
	ty = y_mean
	label_var = "$\sigma \left( X \\right)=$%f>" % y_std
	label_mean = "$ X =$%f>" % y_mean
	p1_label = "%s and %s>" % (label_var,label_mean)
	p1 = plt.plot(x,y,"->",label=p1_label,linewidth=2)
	plt.legend(loc='upper left')
	pl2 = plt.figure(2)
	plt.figure(2)
	plt.hist(results,40,normed=1,alpha=0.8)
	plt.show()
 

• 改变选择：

def change_choice_test(n):
">""
交换选择的门
>"">"
result = {}
game = MontyHall()
for i in xrange(n):
	game.shuffle()
	game.make_choice()
	game.exclude_doors()
	game.change_choice()
	if game.check_result():
		result["yes>"] = result.get("yes>", 0) + 1
	else:
		result["no>"] = result.get("no>", 0) + 1
for key in result:
	print "%s: %d>" % (key, result[key])
return result["yes>"] / n
 

更加深入的讨论

• 如果门的数量不止是3个，如果是50扇门呢？

这种情况下，主持人打开48扇都是羊的门后，再给你选择，很多人这个时候应该就不会固守那$\frac{1}{2}$，而会选择换门

把门的数据增大到100,1000，这种情况会更加明显。

还是通过一段程序模拟说明：

def change_choice_test_large(n,m):
	">""
	交换选择的门
	>"">"
	result = {}
	game = MontyHall(m)
	for i in xrange(n):
		game.shuffle()
		game.make_choice()
		game.exclude_doors()
		game.change_choice()
		if game.check_result():
			result["yes>"] = result.get("yes>", 0) + 1
		else:
			result["no>"] = result.get("no>", 0) + 1
	for key in result:
		print "%s: %d>" % (key, result[key])
	return result["yes>"] / n
if __name__ == '__main__':
	logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.WARNING)
	results = []
	test_num = 1000
	round_num = 1000
	for x in xrange(0,round_num):
		results.append(change_choice_test_large(test_num,50) )
 

这时候就要选择 交换门。

• 遇到这种情况我很困惑，我决定抛硬币决定，这个时候成功的概率？

• 比如门意外打开的情况呢，也就是上面描述的第二种情况（主持在不知门后的情况下打开门呢）？

• 不交换策略下的条件概率是：

  $$

  P(B) = P(C=’汽车’) + P(C=’羊’) \times \frac {1}{2}

  \Rightarrow P(B)= \frac{1}{3} + \frac{1}{3} = \frac{2}{3}

  $$

• 交换策略下的条件概率是：

  $$

  P(B) = P(C=’汽车’) + P(C=’羊’) \times \frac {1}{2}

  \Rightarrow P(B)= \frac{1}{3} + \frac{1}{3} = \frac{2}{3}

  $$

def unknown_doors_choice_test(n):
">""
主持人并不知道门后面的情况随机的开门
交换选择的门
>"">"
result = {}
game = MontyHall()
continue_count = 0
for i in xrange(n):
	game.shuffle()
	game.make_choice()
	game.random_exclude_doors()
	game.change_choice()
	if game.exclude_car == False:
		continue_count += 1
	if game.check_result():
		result["yes>"] = result.get("yes>", 0) + 1
	else:
		result["no>"] = result.get("no>", 0) + 1
#for key in result:
#	print "%s: %d>" % (key, result[key])
logging.info("continue_count: %d>" % continue_count)
if continue_count == 0:
	return 0.0
return result["yes>"] / continue_count
 

在这种情况下交换门也没有提升成功的概率

总结

今天写的这篇东西也算是了解我童年的一个遗憾，人的直觉有时候是很不可靠，要摆脱个人局限的认知才能拥抱更大的世界。什么？看完这些解析，你还觉得不满意那么你还可以从下面的参考中寻找更好的解析，本文撰写过程有部分的图片引用自一下的参考，如果你还有疑问欢迎你联系我进一步的讨论。

练习

下面是三门问题的两个翻版，引用自 三门问题及相关：

女孩的概率

• 你结交一位新朋友，问她是否有孩子。她说有，有两个。你问，有女孩吗？她说有。那么，两个都是女孩的概率是多少？

  答：三分之一。因为生两个孩子的可能性有四种等可能：BB、GG、BG、GB（即男男、女女、男女、女男）。 因为我们已知至少有一个女儿，所以BB是不可能的。因此GG是可能出现的三个等可能的结果之一，所以两个孩子都是女儿的概率为三分之一。这对应了三门问题的第一种情况。

• 你结交一位新朋友，问她是否有孩子。她说有，有两个。你问，有女孩吗？她说有。第二天，你看见她带了一个小女孩。你问她，这是你女儿吗？她说，是。她的两个孩子都是女孩的概率是多少？

  这个概率和生女孩的概率相同，二分之一。这似乎非常奇怪，因为我们所拥有的信息看起来并不比第一种情况时多，但概率却不同。但是这里的问题其实是，那个你没>见过的孩子是女孩的概率是多少？这个概率和生女孩的概率相同，二分之一。

  这对应了三门问题的第二种情况。当然这里也有语言问题，必须假定这位母亲不是特定带出一个小女孩来给你看的。也就是说你只是碰巧发现了它是位小女孩。这取决于是判断选择 或q 随机选择。如果是被你碰巧撞见这是属于随机选择。这就对应了三门问题的第二种情况。这其实是增加了信息的。否则如果她主动带一个小女孩过来给你，则属于判断选择。

  你得到的答案依赖于所讲的故事；它依赖于你是如何得知至少一个孩子是女孩的。

三囚犯问题

• 亚当、比尔和查尔斯被关在一个监狱里，只有监狱看守知道谁会被判死刑，另外两位将会获释。有1／3的概率会被处死刑的亚当，给他母亲写了一封信，想要获释的比尔或查尔斯帮忙代寄。当亚当问看守他应当把他的信交给比尔还是查尔斯时，这位富有同情心的看守很为难。他认为如果他把将要获释的人的名字告诉亚当，那么亚当就会有1／2的概率被判死刑，因为剩下的人和亚当这两人中一定有一个人被处死。如果他隐瞒这信息，亚当被处死的概率是1／3。既然亚当知道其他两人中必有一人会获释，那么亚当自己被处死的概率怎么可能会因为看守告诉他其他两人中被获释者的姓名后而改变呢？

  正确的答案是：看守不用当心，因为即使把获释人的姓名告诉亚当，亚当被处死的概率仍然是1／3，没有改变。但是，剩下的那位没被点名的人就有2／3的概率被处死（被处死的可能性升高了）。如果这个问题换一种说法，就是看守无意间说出了查尔斯不会死。那么概率就会发生改变。

类似的问题还有

• 抛两枚硬币其中有一枚硬币是正面，问两枚硬币都是正面的概率是？
• 抛两枚硬币其中第一枚硬币是正面，问两枚硬币都是正面的概率是？

the end.

参考:

1. 蒙提霍尔问题 – 维基百科，自由的百科全书

2. 三扇门问题 | 左岸读书

3. 蒙提霍尔问题（又称三门问题、山羊汽车问题）的正解是什么？

4. 趣味编程：三门问题

5. 三门问题及相关

6. 换还是不换？争议从未停止过的三门问题

7. 在「三门问题」中，参与者应该选择「换」还是「不换」？主持人是否知道门后情形对结论有何影响？
8. THE MONTY HALL PROBLEM
9. 流言终结者第九季

10. 某个家庭中有 2 个小孩，已知其中一个是女孩，则另一个是男孩的概率是多少？-知乎

2015-05-09 第一次撰写

原文:http://www.cnblogs.com/ruochenchen/p/4511579.html

1. if 语句

# 求x的绝对值
x = int(input("Please enter an interge: >"))
if x < 0 :
    print(-x)
elif x == 0:
    print(0)
else:
    print(x) &#91;/code&#93;
<ol>
<li>
<b1>if</b1>或      <b1>elif</b1>后的条件语句没有括号，条件语句后接冒号。    </li>
<li>
<b1>if</b1>...      <b1>elif</b1>...      <b1>elif</b1>...序列用于替代其他语言中的      <b1>switch</b1>或      <b1>case</b1>语句。    </li>
</ol>
<h2>2. for 语句</h2>
<ol>
<li>
<p class="no-text-indent">
Python中的
for
语句依据任意序列（链表或字符串）中的子项，按它们在序列中的顺序来进行迭代。      </p>

a = ['cat', 'window', 'defenestrate']
for x in a:
    print(x, len(x)) 

a = ['cat', 'window', 'defenestrate']
for x in a[:]:
    if len(x) > 6:
        a.insert(0,x) 

a = ['Mary', 'had', 'a', 'litte', 'lamb']
for i in range(len(a)):
    print(i, a[i]) 

a = ['Mary', 'had', 'a', 'litte', 'lamb']
for i,v in enumerate(a):
    print(i,v) 

knights = {'gallahad':'the pure', 'robin':'the brave'}
for k,v in knights.items():
    print(k,v) 

question = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q,a in zip(question, answers):
    print('What is your {0}? It is {1}.'.format(q,a)) 

for i in range(9,-1,-1):
    print(i,end = ',')
for i in reversed(range(0,10)):
    print(i,end = ',') 

basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for fruit in sorted(set(basket)):
    print(fruit) 

3. while 语句

a,b = 0,1
while b < 100:
    print(b,end=',')
    a,b = b,a+b

4. break和continue语句，以及循环中的else语句

for i in range(0,10):
    print(i)
else:
    print("end loop!>") 

>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...             print(n, 'equals', x, '*', n//x)
...             break
...     else:
...         # loop fell through without finding a factor
...         print(n, 'is a prime number')
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3 

上面这是正确的代码，看仔细： else语句是属于 for循环中的代码，而不是 if语句。

5. 条件控制

1. 比较运算符： in和 not in，以及 is和 is not
2. 逻辑操作符： and、or 和not`

6. 序列的比较

序列对象可以与相同类型的其它对象比较。比较操作按 字典序 进行：首先比较前两个元素，如果不同，就决定了比较的结果；如果相同，就比较后两个元素，依此类推，直到所有序列都完成比较。如果两个元素本身就是同样类 型的序列，就递归字典序比较。如果两个序列的所有子项都相等，就认为序列相等。如果一个序列是另一个序列的初始子序列，较短的一个序列就小于另一个。字符 串的字典序按照单字符的 ASCII 顺序。下面是同类型序列之间比较的一些例子:

(1, 2, 3) < (1, 2, 4) [1, 2, 3] < [1, 2, 4] 'ABC' < 'C' < 'Pascal' < 'Python' (1, 2, 3, 4) < (1, 2, 4) (1, 2) < (1, 2, -1) (1, 2, 3) == (1.0, 2.0, 3.0) (1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4) [/code] 原文:http://www.cnblogs.com/ronny/p/4511696.html

在Python中，你也可以定义包含若干参数的函数。这里有三种可用的形式，也可以混合使用。

1. 默认参数值

最常用的一种形式是为一个或多个参数指定默认值。这会创建一个可以使用比定义时允许的参数更少的参数调用的函数，例如：

def ask_ok(prompt, retries = 4, complaint = "Yes or no, please!>"):
	while True:
		ok = input(prompt)
		if ok in ('y', 'ye', 'yes'):
			return True
		if ok in ('n' ,'no', 'nop', 'nope'):
			return False
		retries = retries - 1
		if retries < 0:
			raise IOError('refusenik user')
		print(complaint)
 &#91;/code&#93;
<p>这个函数可以通过几种不同的方式调用：</p>
<ul>
<li>
只给出必要的参数：      <b1>ask_ok('Do you really wnat to quit?')</b1></li>
<li>
只给出一个可选的参数：      <b1>ask_ok('Ok to overwrite the file',2)</b1></li>
<li>
或者给出所有的参数：      <b1>ask_ok('OK to overwrite the file?',2,'Come on, only yes or no!'),</b1></li>
</ul>
<p>
这个例子还介绍了    <b1>in</b1>关键字。它测定序列中是否包含某个确定的值：    <b1>ok in ('y', 'ye', 'yes')</b1></p>
<p>默认值在函数定义作用被解析，如下所示：</p>
<pre><code>i = 5
def f(arg = i):
    print(arg)
i = 6
f()</code></pre>
<p>
将会输出    <b1>5</b1></p>
<p>
重要警告：默认值只被赋值一次。这使得当默认值是可变对象时会有所不同，比如列表、字典或者大多数类的实例。例如，下面的函数在后续调用过程中会累积（前面）付给它的参数：  </p>

def f(a, L = []):
    L.append(a)
    return L
print(f(1))
print(f(2))
print(f(3)) 

这将输出：

[1]
[1, 2]
[1, 2, 3]

如果你不想让默认值在后续调用中累积，你可以像下面一样定义函数：

def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L 

2. 关键字参数

函数可以通过关键字参数的形式来调用，形如 keyword = value。例如：以下的函数：

def parrot(voltage, state = 'a stiff', action = 'voom', type = 'Norwegian Blue'): 

接受一个必选的参数（ voltage）以及三个可选参数（ state, action和 type）。可以用以下的任一方法调用：

parrot(1000)
parrot(voltage = 1000)
parrot(voltage = 10000, action = 'VOOOM')
parrot(action = 'VOOOOM', voltage = 1000) # action 写在前面也是OK的！
parrot('a million', 'bereft of life', 'jump') # voltage = 'a milion'
parrot('a thousand', state = 'pushing up the daisies') # voltage = 'a thousand' 

不过以下几种调用是无效的：

parrot() # voltage必须有值
parrot(voltage = 5.0, 'dead') # 一旦有一个参数是通过关键字指定的，后面的也必须都是
parrot(110, voltage = 220) # 两个voltage的值
parrot(acotr = 'Jonh Cleese') # 没有voltage的值 

通常，参数列表必须（先书写）位置参数然后才是关键字参数，这里关键字必须来自于形参名字。形参是否有一个默认值并不重要。任何参数都不能被多次赋值——在同一个调用中，与位置参数相同的形参名字不能用作关键字。

引入一个形如 **name的参数时，它接收一个字典，该字典包含了所有未出现的形式参数中关键字参数。这里可能还会组合使用一个形如 *name的形式参数，它接收一个元组，包含了所有没有出现在形式参数列表中的参数值（ *name必须出现在 **name之前）。例如，我们这样定义一个函数：

def cheeseshop(kind, *arguments, **keywords):
	print("-- Do you have any>", kind, "?>")
	print("-- I'm sorry, we're all out of>", kind)
	for arg in arguments:
		print(arg)
	print("->"*40) # 打印40个’-‘
	keys = sorted(keywords.keys()) # 按键值排序
	for kw in keys:
		print(kw, ":>", keywords[kw])
 

它可以像这样调用：

cheeseshop("Limburger>", "It's very runny, sir.>",
           "It's really very, VERY runny, sir.>",
           shopkeeper="Michael Palin>",
           client="John Cleese>",
           sketch="Cheese Shop Sketch>") 

3. 可变参数列表

最后，一个最不常用的选择是可以让函数调用可变个数的参数。这些参数被包装进一个元组。在这些可变个数的参数之前，可以有零到多个普通的参数：

def write_multiple_items(file, separator, *args):
    file.write(separator.join(args)) # 用separator符号将arg里的内容连在一起 

通常这些可变参数是参数列表的最后一个，因为它们将所有剩余的输入参数传递给函数。任何出现在 args后的参数是关键字参数，这意味着，他们只能被用作关键字，而不是位置参数：

>>> def concat(*args, sep="/>"):
...    return sep.join(args)
...
>>> concat("earth>", "mars>", "venus>")
'earth/mars/venus'
>>> concat("earth>", "mars>", "venus>", sep=".>")
'earth.mars.venus' 

4. 参数列表的分拆

另有一种相反的情况：当你要传递的参数已经是一个列表，但是要调用的函数却接受分开一个个的参数值，这时候你要把已有的列表拆开来，例如内建函数 range()需要两个独立的参数 range(start, end)。你可以在调用函数时加一个 *把已有的列表拆开：

>>>list(range(3, 6))
[3, 4 ,5]
>>> args = [3, 6]
>>> list(range(*args))
[3, 4, 5] 

以同样的方式，可以使用 **操作符分拆关键字参数为字典：

>>> def parrot(voltage, state='a stiff', action='voom'):
...     print("-- This parrot wouldn't>", action, end=' ')
...     print("if you put>", voltage, "volts through it.>", end=' ')
...     print("E's>", state, "!>")
...
>>> d = {"voltage>": "four million>", "state>": "bleedin' demised>", "action>": "VOOM>"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised ! 

5. Lambda形式

出于实际需要，有几种通常在函数式编程语言例如 Lisp 中出现的功能加入到了 Python。通过 lambda关键字，可以创建短小的匿名函数。这里有一个函数返回它的两个参数的和： lambda a, b: a+b。 Lambda 形式可以用于任何需要的函数对象。出于语法限制，它们只能有一个单独的表达式。语义上讲，它们只是普通函数定义中的一个语法技巧。类似于嵌套函数定义，lambda 形式可以从外部作用域引用变量:

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43 

原文:http://www.cnblogs.com/ronny/p/4511747.html

本文出自《Python高手之路》中的Doug Hellmann访谈。

我曾经有幸和Doug Hellmann一起工作过数月。他在DreamHost是一位非常资深的软件开发工程师，同时他也是OpenStack项目的贡献者。他发起过关于Python的网站Python Module of the Week（http://pymotw.com/），也出版过一本很有名的Pyhton书The Python Standard Library By Example（http://doughellmann.com/python-standard-library-by-example），同时他也是Python的核心开发人员。我曾经咨询过Doug关于标准库以及库的设计与应用等方面的问题。

当你从头开发一个Python应用时，如何迈出第一步呢？它和开发一个已有的应用程序有什么不同？

从抽象角度看步骤都差不多，但是细节上有所不同。相对于对比开发新项目和已有项目，我个人在对应用程序和库开发的处理方式上有更多的不同。

当我要修改已有代码时，特别是这些代码是其他人创建的时，起初我需要研究代码是如何工作的，我需要改进哪些代码。我可能会添加日志或是输出语句，或是用pdb，利用测试数据运行应用程序，以便我理解它是如何工作的。我经常会做一些修改并测试它们，并在每次提交代码前添加可能的自动化测试。

创建一个新应用时，我会采取相同的逐步探索方法。我先创建一些代码，然后手动运行它们，在这个功能可以基本调通后，再编写测试用例确保我已经覆盖了所有的边界情况。创建测试用例也可以让代码重构更容易。

这正是smiley（https://pypi.python.org/pypi/smiley）的情况。在开发正式应用程序前，我先尝试用Python的trace API写一些临时脚本。对于smiley我最初的设想包括一个仪表盘并从另一个运行的应用程序收集数据，另一部分用来接收通过网络发送过来的数据并将其保存。在添加几个不同的报告功能的过程中，我意识到重放已收集的数据的过程和在一开始收集数据的过程基本是一样的。于是我重构了一些类，并针对数据收集，数据库访问和报告生成器创建了基类。通过让这些类遵循同样的API使我可以很容易地创建数据收集应用的一个版本，它可以直接将数据写入数据库而无需通过网络发送数据。

当设计一个应用程序时，我会考虑用户界面是如何工作的，但对于库，我会专注于开发人员如何使用其API。通过先写测试代码而不是库代码，可以让思考如何通过这个新库开发应用程序变得更容易一点儿。我通常会以测试的方式创建一系列示例程序，然后依照其工作方式去构建这个库。

我还发现，在写任何库的代码之前先写文档让我可以全面考虑功能和流程的使用，而不需要提交任何实现的细节。它还让我可以记录对于设计我所做出的选择，以便读者不仅可以理解如何使用这个库，还可以了解在创建它时我的期望是什么。这就是我用在stevedore上的方法。

我知道我想让stevedore能够提供一组类用来管理应用程序的插件。在设计阶段，我花了些时间思考我见过的使用插件的通用模式，并且写了几页粗略的文档描述这些类应该如何使用。我意识到，如果我在类的构造函数中放最复杂的参数，方法map()几乎是可互换的。这些设计笔记直接写进了stevedore官方文档的简介里，用来解释在应用程序中使用插件的不同模式和准则。

将一个模块加入Python标准库的流程是什么？

完整的流程和规范可以在Python Developer’s Guide（http://docs.python.org/devguide/stdlibchanges.html）中找到。

一个模块在被加入Python标准库之前，需要被证明是稳定且广泛使用的。模块需要提供的功能要么是很难正确实现的，要么是非常有用以至于许多开发人员已经创建了他们自己不同的变种。API应该非常清晰并且它的实现不能依赖任何标准库之外的库。

提议一个新模块的第一步是在社区通过python-ideas邮件列表非正式地了解一下大家对此的感兴趣程度。如果回应很积极，下一步就是创建一个Python增强提案（PythonEnhancement Proposal，PEP），它包括添加这个模块的动因，以及如何过渡的一些实现细节。

因为包的管理和发现工作已经非常稳定了，尤其是pip和Python Package Index（PyPI），因此在标准库之外维护一个新的库可能更实用。单独的发布使得对于新功能和bug修复（bugfix）的更新可以更频繁，对于处理新技术或API的库来说这尤其重要。

标准库中的哪三个模块是你最想人们深入了解并开始使用的？

最近我做了许多关于应用程序中动态加载扩展方面的工作。我使用abc模块为那些作为抽象基类进行的扩展定义API，以帮助扩展的作者们了解API的哪些方法是必需的，哪些是可选的。抽象基类已经在其他一些语言中内置了，但我发现很多Python程序员并不知道Python也有。

bisect模块中的二分查找算法是个很好的例子，一个广泛使用但不容易正确实现的功能，因此它非常适合放到标准库中。我特别喜欢它可以搜索稀疏列表，且搜索的值可能并不在其中。

collections模块中有许多有用的数据结构并没有得到广泛使用。我喜欢用namedtuple来创建一些小的像类一样的数据结构来保存数据但并不需要任何关联逻辑。如果之后需要添加逻辑的话，可以很容易将namedtuple转换成一个普通的类，因为namedtuple支持通过名字访问属性。另一个有意思的数据结构是ChainMap，它可以生成良好的层级命名空间。ChainMap能够用来为模板解析创建上下文或者通过清晰的流程定义来管理不同来源的配置。

许多项目（包括OpenStack）或者外部库，会在标准库之上封装一层自己的抽象。例如，我特别想了解对于日期/时间的处理。对此你有什么建议吗？程序员应该坚持使用标准库，还是应该写他们自己的函数，切换到其他外部库或是开始给Python提交补丁？

所有这些都可以。我倾向于避免重复造轮子，所以我强烈主张贡献补丁和改进那些能够用来作为依赖的项目。但是，有时创建另外的抽象并单独维护代码也是合理的，不管在应用程序内还是作为一个新的库。

你提到的例子中，OpenStack里的timeutils模块就是对Python的datetime模块的一层很薄的封装。大部分功能都简短且简单，但通过将这些最常见的操作封装为一个模块，我们可以保证它们在OpenStack项目中以一致的方式进行处理。因为许多函数都是应用相关的，某种意义上它们强化了一些问题决策，例如，字符串时间戳格式或者“现在”意味着什么，它们不太适合作为Python标准库的补丁或者作为一个通用库发布以及被其他项目采用。

与之相反，我目前正致力于将OpenStack的API服务项目从早期创建时使用的WSGI框架转成采用一个第三方Web开发框架。在Python中开发WSGI应用有很多选择，并且当我们可能需要增强其中一个以便其可以完全适应OpenStack API服务器的需要时，将这些可重用的修改贡献对于维护一个“私有的”框架似乎更可取。

当从标准库或其他地方导入并使用大量模块时，关于该做什么你有什么特别的建议吗？

我没有什么硬性限制，但是如果我有过多的导入时，我会重新考虑这个模块的设计并考虑将其拆到一个包中。与上层模块或者应用程序模块相比，对底层模块的这种拆分可能会发生得更快，因为对于上层模块我期望将更多片段组织在一起。

关于Python 3，有什么模块是值得一提而且能令开发人员有兴趣深入了解的？

支持Python 3的第三方库的数量已经到了决定性的时刻。针对Python 3开发新库或应用程序从未如此简单过，而且幸亏有3.3中加入的兼容性功能使同时维护对Python 2.7的支持也很容易。主要的Linux发行版正在致力于将Python 3默认安装。任何人要用Python创建新项目都应该认真考虑对Python 3的支持，除非有尚未移植的依赖。目前来说，不能运行在Python 3上的库基本会被视为“不再维护”。

许多开发人员将所有的代码都写入到应用程序中，但有些情况下可能有必要将代码封装成一个库。关于设计、规划、迁移等，做这些最好的方式是什么？

应用程序就是“胶水代码”的集合用来将库组织在一起完成特定目的。起初设计时可以将这些功能实现为一个库，然后在构建应用程序时确保库的代码能够很好地组织到逻辑单元中，这会让测试变得更简单。这还意味着应用程序的功能可以通过库进行访问，并且能够被重新组合以构建其他应用程序。未能采用这种方法的话意味着应用程序的功能和用户界面的绑定过于紧密，导致很难修改和重用。

对于计划开始构建自己的Python库的人们有什么样的建议呢？

我通常建议自顶向下设计库和API，对每一层应用单一职责原则（Single Responsibility Principle，SRP）（http://en.wikipedia.org/wiki/Single_responsibility_principle）这样的设计准则。考虑调用者如何使用这个库，并创建一个API去支持这些功能。考虑什么值可以存在一个实例中被方法使用，以及每个方法每次都要传入哪些值。最后，考虑实现以及是否底层的代码的组织应该不同于公共API。

SQLAlchemy是应用这些原则的绝好例子。声明式ORM、数据映射和表达式生成层都是单独的。开发人员可以自行决定对于API访问的正确的抽象程度，并基于他们的需求而不是被库的设计强加的约束去使用这个库。

当你随机看Python程序员的代码时遇到的最常见的编程错误是什么？

Python的习惯用法和其他语言的一个较大的不同在于循环和迭代。例如，我见过的最常见的反模式是使用for循环过滤一个列表并将元素加入到一个新的列表中，然后再在第二个循环中处理这个结果（可能将列表作为参数传给一个函数）。我通常建议将过滤循环改成生成器表达式，因为生成器表达式，更有效也更容易理解。列表的组合也很常见，以便它们的内容可以以某种方式一起被处理，但却没有使用itertools.chain()。

还有一些我在代码评审时给出的更细小的建议，例如，使用dict()而不是长的if:then:else块作为查找表，确保函数总是返回相同的类型（如一个空列表而不是None），通过使用元组和新类将相关的值合并到一个对象中从而减少函数的参数，以及在公共API中定义要使用的类而不是依赖于字典。

有没有关于选择了一个“错误”的依赖的具体的例子是你亲身经历或目睹过的？

最近，我有个例子，pyparsing（https://pypi.python.org/pypi/pyparsing）的一个新发布取消了对Python 2的支持，这给我正在维护的一个库带来了一点儿小麻烦。对pyparsing的更新是个重大的修改，而且是明确标识成这样的，但是因为我没有在对cliff（https://pypi.python.org/pypi/cliff）的设置中限制依赖版本号，所以pyparsing的新发布给cliff的用户造成了问题。解决方案就是在cliff的依赖列表中对Python 2和Python 3提供不同的版本边界。这种情况突显了理解依赖管理和确保持续集成测试中适当的测试配置的重要性。

你怎么看待框架？

框架像任何工具类型一样。它们确实有帮助，但在选择框架时要特别谨慎，应确保它能够很好地完成当前的工作。

通过抽取公共部分到一个框架中，你可以将你的开发精力专注于应用中独特的方面。通过提供许多类似运行在开发模式或者写一个测试套件这样的引导代码，它们还可以帮你让一个应用程序迅速达到一个可用的状态而不是从头开发。它们还可以激励你在应用程序开发过程中保持一致，这意味着最终你的代码将更易于理解且更可重用。

虽然使用框架时还有其他一些潜在的缺点需要注意。决定使用某个特定框架通常能够反映应用程序本身的设计。如果设计的限制不能从根本上符合应用程序的需求，那么选择错误的框架会令应用的实现变得更难。如果你试着使用与框架建议不同的模式或惯用方式，你最终将不得不同框架做斗争。

长按二维码可以关注公众号

《Python高手之路》，点击阅读原文可实现购买。

阅读原文

原文:http://www.jianshu.com/p/6e1d130bc589

PageRank算法是互联网发展过程中的一个里程碑，斯坦福大学的两个博士生凭借这一发现构建了谷歌搜索，对整个互联网产生了巨大影响。

PageRank让链接来”投票>”

一个页面的“得票数”由所有链向它的页面的重要性来决定，到一个页面的超链接相当于对该页投一票。一个页面的PageRank是由所有链向它的页面（“链入页面”）的重要性经过递归算法得到的。一个有较多链入的页面会有较高的等级，相反如果一个页面没有任何链入页面，那么它没有等级。

假設一個由4個頁面組成的小團體：A，B，C和D。如果所有頁面都鏈向A，那麼A的PR（PageRank）值將是B，C及D的Pagerank總和。

$$PR(A)= PR(B) + PR(C) + PR(D)$$繼續假設B也有連結到C，並且D也有連結到包括A的3個頁面。一個頁面不能投票2次。所以B給每個頁面半票。以同樣的邏輯，D投出的票只有三分之一算到了A的PageRank上。

$$PR(A)= \frac{PR(B)}{2}+ \frac{PR(C)}{1}+ \frac{PR(D)}{3}$$換句話說，根據鏈出總數平分一個頁面的PR值。

$$PR(A)= \frac{PR(B)}{L(B)}+ \frac{PR(C)}{L(C)}+ \frac{PR(D)}{L(D)}$$最後，所有這些被換算為一個百分比再乘上一個係數d。由於「沒有向外連結的頁面」傳遞出去的PageRank會是0，所以，Google通過數學系統給了每個頁面一個最小值(1 – d)/N。其逻辑是对于网页A, 用户以d的概率随机选择这个网页A浏览；而以剩下的（1 – d）/N的概率从每一个网页跳转到这个网页A，具体如下：

$$PR(A)=\left( \frac{PR(B)}{L(B)}+ \frac{PR(C)}{L(C)}+ \frac{PR(D)}{L(D)}+\,\cdots \right) d + \frac{1 – d}{N}$$

采用d概率来刻画两种浏览行为有着更为实际的原因：防止投票泄露现象。d称之为阻尼系数（Damping factor）。在共振时,阻尼可能限制稳定振动的振幅。d在这里也可以起到平衡两种机制的作用。

這個方程式引入了隨機瀏覽的概念，即有人上網無聊隨機打開一些頁面，點一些連結。一個頁面的PageRank值也影響了它被隨機瀏覽的機率。為了便於理解，這裡假設上網者不斷點網頁上的連結，最終到了一個沒有任何鏈出頁面的網頁，這時候上網者會隨機到另外的網頁開始瀏覽。

為了處理那些「沒有向外連結的頁面」（這些頁面就像「黑洞」會吞噬掉用戶繼續向下瀏覽的機率）帶來的問題，d=0.85（這裡的d被稱為阻尼係數（damping factor），其意義是，在任意時刻，用戶到達某頁面後並繼續向後瀏覽的機率。1-d=0.15（就是用戶停止點擊，隨機跳到新URL的機率）的算法被用到了所有頁面上，估算頁面可能被上網者放入書籤的機率。

所以，這個等式如下：

$${\rm PageRank}(p_i) = \frac{1-d}{N} + d \sum_{p_j \in M(p_i)} \frac{{\rm PageRank} (p_j)}{L(p_j)}$$

$p_1$, $p_2$, …, $p_N$是被研究的頁面，$M(p_i)$是鏈入$p_i$頁面的集合，$L(p_j)$ 是 $p_j$ 鏈出頁面的數量，而N是所有頁面的數量。

PageRank值是一個特殊矩陣中的特徵向量。這個特徵向量為

python程序模拟

首先生成一个简单地网络：

import  networkx  as  nx
G  =  nx . DiGraph ()
G . add_edge ( 'A' , 'B' )
G . add_edge ( 'A' ,  'C' )
G . add_edge ( 'B' , 'C' )
G . add_edge ( 'C' , 'A' )
pos = nx . spring_layout ( G )  #设置网络的布局
nx . draw ( G ,  pos ,  node_color  =  'orange' ,  with_labels  =  True )  

我们用PR表示网页排名（page rank， pr）。

对于整个例子可以得到：PR(A) = PR(C) = 2*PR(B)

设A、B、C的初始的重要性均为1，通过上面的方程组进行迭代，每次迭代后会更新A、B、C的重要性。为了方面，先把方程组转换为矩阵运算。

import  numpy  as  np
#第一个例子：无漏洞
M  =  np . matrix ([[ 0 ,  0 ,  1 ],[ 0.5 ,  0 ,  0 ],[ 0.5 , 1 , 0 ]])
PR =  np . matrix ([ 1 ,  1 ,  1 ]) . transpose ()
for  i  in  range ( 1 , 101 ):
PR  =  M * PR
print  str ( i ) + ' \n ' ,  PR  

但是这种简单地迭代有一个局限，就是当流量随着迭代不断流入一些节点时，这些流量不会再流出的时候，就会出现少数节点占有所有网页排名，其它节点排名为0的情况出现。一个极端的例子是：

PR(A) = PR(B) + PR(C)

import  numpy  as  np
M  =  np . matrix ([[ 0 ,  1 ,  1 ],[ 0 ,  0 ,  0 ],[ 0 , 0 , 0 ]])
PageRank =  np . matrix ([ 1 ,  1 ,  1 ]) . transpose
for  i  in  range ( 1 , 101 ):
PageRank  =  M * PageRank
print  str ( i ) + ' \n ' ,  PageRank  

此时，最终收敛的结果是：PR(A) = PR(B) = PR(C) = 0

如上图中，最终所有的投票都集中在ABC三个节点上，其它节点收到的投票为0。随着迭代进行全部节点的得票都是0。因而，需要有一个平衡的调节机制，将那些只索取不奉献的节点的PageRank取一部分平均分配。

import  numpy  as  np
M  =  np . matrix ([[ 0 ,  1 ,  1 ],[ 0.5 ,  0 ,  0 ],[ 0.5 , 0 , 0 ]])
PR  =  np . matrix ([ 1 ,  1 ,  1 ]) . transpose ()
for  i  in  range ( 1 , 101 ):
PR  =  0.15 / 3  +  0.85 * M * PR
print  str ( i ) + ' \n ' ,  b  

参考资料

Date: 2015-05-18; Category:模型算法; Tags:

原文:http://www.computational-communication.com/post/mo-xing-suan-fa/2015-05-18-pagerank

提高Python运行效率的六个窍门

曾灵敏 — MAY 18, 2015 Python是一门优秀的语言，它能让你在短时间内通过极少量代码就能完成许多操作。不仅如此，它还轻松支持多任务处理，比如多进程。

不喜欢Python的人经常会吐嘈Python运行太慢。但是，事实并非如此。尝试以下六个窍门，来为你的Python应用提速。

窍门一：关键代码使用外部功能包

Python简化了许多编程任务，但是对于一些时间敏感的任务，它的表现经常不尽人意。使用C/C++或机器语言的外部功能包处理时间敏感任务，可以有效提高应用的运行效率。这些功能包往往依附于特定的平台，因此你要根据自己所用的平台选择合适的功能包。简而言之，这个窍门要你牺牲应用的可移植性以换取只有通过对底层主机的直接编程才能获得的运行效率。以下是一些你可以选择用来提升效率的功能包：

这些功能包的用处各有不同。比如说，使用C语言的数据类型，可以使涉及内存操作的任务更高效或者更直观。Pyrex就能帮助Python延展出这样的功能。Pylnline能使你在Python应用中直接使用C代码。内联代码是独立编译的，但是它把所有编译文件都保存在某处，并能充分利用C语言提供的高效率。

窍门二：在排序时使用键

Python含有许多古老的排序规则，这些规则在你创建定制的排序方法时会占用很多时间，而这些排序方法运行时也会拖延程序实际的运行速度。最佳的排序方法其实是尽可能多地使用键和内置的sort()方法。譬如，拿下面的代码来说：

import operator
somelist = [(1, 5, 8), (6, 2, 4), (9, 7, 5)]
somelist.sort(key=operator.itemgetter(0))
somelist
#Output = [(1, 5, 8), (6, 2, 4), (9, 7, 5)]
somelist.sort(key=operator.itemgetter(1))
somelist
#Output = [(6, 2, 4), (1, 5, 8), (9, 7, 5)]
somelist.sort(key=operator.itemgetter(2))
somelist
#Output = [(6, 2, 4), (9, 7, 5), (1, 5, 8)],
 

在每段例子里，list都是根据你选择的用作关键参数的索引进行排序的。这个方法不仅对数值类型有效，还同样适用于字符串类型。

窍门三：针对循环的优化

每一种编程语言都强调最优化的循环方案。当使用Python时，你可以借助丰富的技巧让循环程序跑得更快。然而，开发者们经常遗忘的一个技巧是：尽量避免在循环中访问变量的属性。譬如，拿下面的代码来说：

lowerlist = ['this', 'is', 'lowercase']
upper = str.upper
upperlist = []
append = upperlist.append
for word in lowerlist:
    append(upper(word))
    print(upperlist)
    #Output = ['THIS', 'IS', 'LOWERCASE']
 

每次你调用str.upper, Python都会计算这个式子的值。然而，如果你把这个求值赋值给一个变量，那么求值的结果就能提前知道，Python程序就能运行得更快。因此，关键就是尽可能减小Python在循环中的工作量。因为Python解释执行的特性，在上面的例子中会大大减慢它的速度。

（注意：优化循环的方法还有很多，这只是其中之一。比如，很多程序员会认为，列表推导式是提高循环速度的最佳方法。关键在于，优化循环方案是提高应用程序运行速度的上佳选择。）

窍门四：使用较新的Python版本

如果你在网上搜索Python，你会发现数不尽的信息都是关于如何升级Python版本。通常，每个版本的Python都会包含优化内容，使其运行速度优于之前的版本。但是，限制因素在于，你最喜欢的函数库有没有同步更新支持新的Python版本。与其争论函数库是否应该更新，关键在于新的Python版本是否足够高效来支持这一更新。

你要保证自己的代码在新版本里还能运行。你需要使用新的函数库才能体验新的Python版本，然后你需要在做出关键性的改动时检查自己的应用。只有当你完成必要的修正之后，你才能体会新版本的不同。

然而，如果你只是确保自己的应用在新版本中可以运行，你很可能会错过新版本提供的新特性。一旦你决定更新，请分析你的应用在新版本下的表现，并检查可能出问题的部分，然后优先针对这些部分应用新版本的特性。只有这样，用户才能在更新之初就觉察到应用性能的改观。

窍门五：尝试多种编码方法

每次创建应用时都使用同一种编码方法几乎无一例外会导致应用的运行效率不尽人意。可以在程序分析时尝试一些试验性的办法。譬如说，在处理字典中的数据项时，你既可以使用安全的方法，先确保数据项已经存在再进行更新，也可以直接对数据项进行更新，把不存在的数据项作为特例分开处理。请看下面第一段代码：

n = 16
myDict = {}
for i in range(0, n):
	char = 'abcd'[i%4]
	if char not in myDict:
		myDict[char] = 0
		myDict[char] += 1
		print(myDict)
 

当一开始myDict为空时，这段代码会跑得比较快。然而，通常情况下，myDict填满了数据，至少填有大部分数据，这时换另一种方法会更有效率。

n = 16
myDict = {}
for i in range(0, n):
    char = 'abcd'[i%4]
    try:
        myDict[char] += 1
    except KeyError:
        myDict[char] = 1
    print(myDict)
 

在两种方法中输出结果都是一样的。区别在于输出是如何获得的。跳出常规的思维模式，创建新的编程技巧能使你的应用更有效率。

窍门六：交叉编译你的应用

开发者有时会忘记计算机其实并不理解用来创建现代应用程序的编程语言。计算机理解的是机器语言。为了运行你的应用，你借助一个应用将你所编的人类可读的代码转换成机器可读的代码。有时，你用一种诸如Python这样的语言编写应用，再以C++这样的语言运行你的应用，这在运行的角度来说，是可行的。关键在于，你想你的应用完成什么事情，而你的主机系统能提供什么样的资源。

Nuitka是一款有趣的交叉编译器，能将你的Python代码转化成C++代码。这样，你就可以在native模式下执行自己的应用，而无需依赖于解释器程序。你会发现自己的应用运行效率有了较大的提高，但是这会因平台和任务的差异而有所不同。

（注意： Nuitka现在还处在测试阶段，所以在实际应用中请多加注意。实际上，当下最好还是把它用于实验。此外，关于交叉编译是否为提高运行效率的最佳方法还存在讨论的空间。开发者已经使用交叉编译多年，用来提高应用的速度。记住，每一种解决办法都有利有弊，在把它用于生产环境之前请仔细权衡。）

在使用交叉编译器时，记得确保它支持你所用的Python版本。Nuitka支持Python2.6, 2.7, 3.2和3.3。为了让解决方案生效，你需要一个Python解释器和一个C++编译器。Nuitka支持许多C++编译器，其中包括 Microsoft Visual Studio, MinGW和 Clang/LLVM。

交叉编译可能造成一些严重问题。比如，在使用Nuitka时，你会发现即便是一个小程序也会消耗巨大的驱动空间。因为Nuitka借助一系列的动态链接库（DDLs）来执行Python的功能。因此，如果你用的是一个资源很有限的系统，这种方法或许不太可行。

结论

前文所述的六个窍门都能帮助你创建运行更有效率的Python应用。但是银弹是不存在的。上述的这些窍门不一定每次都能奏效。在特定的Python的版本下，有的窍门或许比其他的表现更好，但这有时候甚至取决于平台的差异。你需要总结分析你的应用，找到它效率低下的部分，然后尝试这些窍门，找到解决问题的最佳方法。

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

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

与java apache log4j的ConsoleAppender，RollingFileAppender类似，python也有自己的实现，分别是logging.StreamHandler(),logging.handlers.TimedRotatingFileHandler.

下面是示例代码：

def script_path():
	path = os.path.realpath(sys.argv[0])
	if os.path.isfile(path):
	path = os.path.dirname(path)
	return os.path.abspath(path)
LOGGING_MSG_FORMAT  = '[%(asctime)s] [%(levelname)s] [%(module)s] [%(funcName)s] [%(lineno)d] %(message)s'
LOGGING_DATE_FORMAT	= '%Y-%m-%d %H:%M:%S'
logging.basicConfig(level=logging.DEBUG,format=LOGGING_MSG_FORMAT,datefmt=LOGGING_DATE_FORMAT)
log = logging.getLogger('xxx')
log_path = os.path.join(script_path(),'logs')
if not os.path.exists(log_path):
	os.makedirs(log_path)
log_file = os.path.join(log_path,'xxx.log')
logger = logging.handlers.TimedRotatingFileHandler(log_file,'midnight',1)
logger.setFormatter(logging.Formatter(LOGGING_MSG_FORMAT))
log.addHandler(logger)
console = logging.StreamHandler()
console.setLevel(logging.INFO)
console.setFormatter(logging.Formatter(LOGGING_MSG_FORMAT))
log.addHandler(console)
 

注意事项：
不要在多线程程序中使用addHandler,removeHandler,否则可能产生一些意想不到的异常
。建议：
全局只初始化一次logger实例

原文:http://ucstudio.iteye.com/blog/2212447

目录

• python模块介绍-json：json编码解码

JSON编码和解码

JSON()，由(取代了RFC4627)和，是一种轻量级的数据交换格式，灵感来自对象文字语法(严格来说它不是JavaScript的子集，因为它额外支持了行分割U+2028和段分割U+2029语法）。

simplejson的API和标准库marshal及pickle模块类似。它是包含在Python2.6的JSON库的外部版本，目前仍保持兼容的Python2.5并有显著的性能优势，尽管没有使用C扩展加速。 simplejson也支持Python的3.3+。

simplejson的的发布下载地址:, 最新代码：

• 编码基本的python对象层次

>>>  import  simplejson  as  json
>>>  json. dumps([ 'foo' ,  { 'bar' :  ( 'baz' ,  None ,  1.0 ,  2 )}])
'["foo>", {"bar>": ["baz>", null, 1.0, 2]}]'
>>>  print ( json. dumps( " \>" foo \b ar" ))
>" \" foo \b ar>"
>>>  print ( json. dumps( u' \u1234 ' ))
" \u1234 >"
>>>  print ( json. dumps( ' \\ ' ))
" \\ >"
>>>  print ( json. dumps({ "c>" :  0 ,  "b>" :  0 ,  "a>" :  0 },  sort_keys= True ))
{ "a>" :  0 ,  "b>" :  0 ,  "c>" :  0 }
>>>  from  simplejson.compat  import  StringIO
>>>  io =  StringIO()
>>>  json. dump([ 'streaming API' ],  io)
>>>  io. getvalue()
'["streaming API>"]'  

• 紧凑编码

>>>  import  simplejson  as  json
>>>  obj =  [ 1 , 2 , 3 ,{ '4' :  5 ,  '6' :  7 }]
>>>  json. dumps( obj,  separators= ( ',' ,  ':' ),  sort_keys= True )
'[1,2,3,{"4>":5,"6>":7}]'
>>>  json. dumps( obj,   sort_keys= True )
'[1, 2, 3, {"4>": 5, "6>": 7}]'  

• 更好的输出

>>>  import  simplejson  as  json
>>>  print ( json. dumps({ '4' :  5 ,  '6' :  7 },  sort_keys= True ,  indent= 4  *  ' ' ))
{
"4>" :  5 ,
"6>" :  7
}  

• 解码

>>>  import  simplejson  as  json
>>>  obj =  [ u'foo' ,  { u'bar' :  [ u'baz' ,  None ,  1.0 ,  2 ]}]
>>>  json. loads( '["foo>", {"bar>":["baz>", null, 1.0, 2]}]' )  ==  obj
True
>>>  json. loads( '" \\ >"foo \\ bar"' )  ==  u'>"foo \x08 ar'
True
>>>  from  simplejson.compat  import  StringIO
>>>  io =  StringIO( '["streaming API>"]' )
>>>  json. load( io)[ 0 ]  ==  'streaming API'
True  

• 使用Decimal代替浮点数

>>>  import  simplejson  as  json
>>>  obj =  [ u'foo' ,  { u'bar' :  [ u'baz' ,  None ,  1.0 ,  2 ]}]
>>>  json. loads( '["foo>", {"bar>":["baz>", null, 1.0, 2]}]' )  ==  obj
True
>>>  json. loads( '" \\ >"foo \\ bar"' )  ==  u'>"foo \x08 ar'
True
>>>  from  simplejson.compat  import  StringIO
>>>  io =  StringIO( '["streaming API>"]' )
>>>  json. load( io)[ 0 ]  ==  'streaming API'
True  

本文地址

原文:http://automationtesting.sinaapp.com/blog/m_json

[1]  [2] [3] [4]  下一页

原文:http://www.myhack58.com/Article/sort099/sort0100/2015/62603.htm

初、中、高级的读者，都可以在这里找到满意的答案。1、2、3、4中高级阅读，5、6扩展阅读。7、8、9入门级阅读。10，思维拓展阅读。

中、高级——Python高手之路

[法] 朱利安•丹乔（Julien Danjou） (作者)

王飞龙 (译者)

书 号 978-7-115-38713-4

出版日期 2015-05-01

页 数 202

本书英文原版配套网址是 https://julien.danjou.info/books/the-hacker-guide-to-python

这不是一本常规意义上Python的入门书。这本书中没有Python关键字和for循环的使用，也没有细致入微的标准库介绍，而是完全从实战的角度出发，对构建一个完整的Python应用所需掌握的知识进行了系统而完整的介绍。更为难得的是，本书的作者是开源项目OpenStack的PTL（项目技术负责人）之一，因此本书结合了Python在OpenStack中的应用进行讲解，非常具有实战指导意义。

中、高级——PythonCookbook（第3版）中文版

[美]David Beazley , [美]Brian K.Jones (作者)

陈舸 (译者)

书 号 978-7-115-37959-7

出版日期 2015-05-01

页 数 684

《Python Cookbook（第3版）中文版》介绍了Python应用在各个领域中的一些使用技巧和方法，其主题涵盖了数据结构和算法，字符串和文本，数字、日期和时间，迭代器和生成器，文件和I/O，数据编码与处理，函数，类与对象，元编程，模块和包，网络和Web编程，并发，实用脚本和系统管理，测试、调试以及异常，C语言扩展等。

本书覆盖了Python应用中的很多常见问题，并提出了通用的解决方案。书中包含了大量实用的编程技巧和示例代码，并在Python 3.3环境下进行了测试，可以很方便地应用到实际项目中去。此外，《Python Cookbook（第3版）中文版》还详细讲解了解决方案是如何工作的，以及为什么能够工作。

《Python Cookbook（第3版）中文版》非常适合具有一定编程基础的Python程序员阅读参考。

进 阶——Python核心编程（第二版）

[美]Wesley J. Chun (作者)

宋吉广 (译者)

书 号 978-7-115-17850-3

出版日期 2008-07-01

页 数 654

本书是经典的Python指导书，在第一版的基础上进行了全面升级。全书分为两个部分：第1部分占据了大约三分之二的篇幅，阐释这门语言的“核心”内容，包括基本的概念和语句、语法和风格、Python对象、数字类型、序列类型、映射和集合类型、条件和循环、文件和输入/输出、错

误和异常、函数和函数式编程、模块、面向对象编程、执行环境等内容：第2部分则提供了各种高级主题来展示可以使用Python做些什么，包括正则表达式、网络编程、网络客户端编程、多线程编程、图形用户界面编程、Web编程、数据库编程、扩展Python 和一些其他材料。

进 阶——Python3程序开发指南（第2版修订版）

[英]Mark Summerfield (作者)

王弘博 , 孙传庆 (译者)

书 号 978-7-115-38338-9

出版日期 2015-01-01

页 数 518

《Python 3程序开发指南（第2版 修订版）》首先讲述了构成Python语言的8个关键要素，之后分章节对其进行了详尽的阐述，包括数据类型、控制结构与函数、模块、文件处理、调试、进程与线程、网络、数据库、正则表达式、GUI程序设计等各个方面，并介绍了其他一些相关主题。全书内容以实例讲解为主线，每章后面附有练习题，便于读者更好地理解和掌握所讲述的内容。

《Python 3程序开发指南（第2版 修订版）》适合于作为Python语言教科书使用，对Python程序设计人员也有一定的参考价值。

中、 高级——Python数据可视化编程实战

[爱尔兰]Igor Milovanović (作者)

颛青山 (译者)

书 号 978-7-115-38439-3

出版日期 2015-05-01

页 数 242

本书是一本使用Python实现数据可视化编程的实战指南，介绍了如何使用Python最流行的库，通过60余种方法创建美观的数据可视化效果。

全书共8章，分别介绍了准备工作环境、了解数据、绘制并定制化图表、学习更多图表和定制化、创建3D可视化图表、用图像和地图绘制图表、使用正确的图表理解数据以及更多matplotlib知识。

本书适合那些对Python编程有一定基础的开发人员，可以帮助读者从头开始了解数据、数据格式、数据可视化，并学会使用Python可视化数据。

扩展阅读——Python自然语言处理

[美]Steven Bird , [美]Ewan Klein , [美]Edward Loper

(作者) 陈涛 , 张旭 , 崔杨 , 刘海平 (译者)

书 号 978-7-115-33368-1

出版日期 2014-07-01

页 数 487

《Python自然语言处理》是自然语言处理领域的一本实用入门指南，旨在帮助读者学习如何编写程序来分析书面语言。《Python自然语言处理》基于Python编程语言以及一个名为NLTK的自然语言工具包的开源库，但并不要求读者有Python编程的经验。全书共11章，按照难易程度顺序编排。第1章到第3章介绍了语言处理的基础，讲述如何使用小的Python程序分析感兴趣的文本信息。第4章讨论结构化程序设计，以巩固前面几章中介绍的编程要点。第5章到第7章介绍语言处理的基本原理，包括标注、分类和信息提取等。第8章到第10章介绍了句子解析、句法结构识别和句意表达方法。第11章介绍了如何有效管理语言数据。后记部分简要讨论了NLP领域的过去和未来。

《Python自然语言处理》的实践性很强，包括上百个实际可用的例子和分级练习。《Python自然语言处理》可供读者用于自学，也可以作为自然语言处理或计算语言学课程的教科书，还可以作为人工智能、文本挖掘、语料库语言学等课程的补充读物。

扩展阅读——贝叶斯思维统计建模的Python学习法

[美]Allen B. Downey (作者)

许杨毅 (译者)

书 号 978-7-115-38428-7

出版日期 2015-03-01

页 数 168

这本书帮助那些希望用数学工具解决实际问题的人们，仅有的要求可能就是懂一点概率知识和程序设计。而贝叶斯方法是一种常见的利用概率学知识去解决不确定性问题的数学方法，对于一个计算机专业的人士，应当熟悉其应用在诸如机器翻译，语音识别，垃圾邮件检测等常见的计算机问题领域。

可是本书实际上会远远扩大你的视野，即使不是一个计算机专业的人士，你也可以看到在战争环境下（二战德军坦克问题），法律问题上（肾肿瘤的假设验证），体育博彩领域（棕熊队和加人队NFL比赛问题）贝叶斯方法的威力。怎么从有限的信息判断德军装甲部队的规模，你所支持的球队有多大可能赢得冠军，在《龙与地下城》勇士中，你应当对游戏角色属性的最大值有什么样的期望，甚至在普通的彩弹射击游戏中，拥有一些贝叶斯思维也能帮助到你提高游戏水平。

除此以外，本书在共计15章的篇幅中讨论了怎样解决十几个现实生活中的实际问题。在这些问题的解决过程中，作者还潜移默化的帮助读者形成了建模决策的方法论，建模误差和数值误差怎么取舍，怎样为具体问题建立数学模型，如何抓住问题中的主要矛盾（模型中的关键参数），再一步一步的优化或者验证模型的有效性或者局限性。在这个意义上，这本书又是一本关于数学建模的成功样本。

入 门——趣学Python——教孩子学编程

[美]Jason R. Briggs (作者)

哲 (译者)

书 号 978-7-115-38143-9

出版日期 2015-02-01

页 数 280

本书是一本轻松、快速掌握Python编程的入门读物。全书分为3部分，共18章。第1部分是第1章到第12章，介绍Python编程基础知识，包括Python的安装和配置、变量、字符串、列表、元组和字典、条件语句、循环语句函数和模块、类、内建函数和绘图，等等。第2部分是第13章和第14章，介绍如何用Python开发实例游戏弹球。第3部分包括第15章到第18章，介绍了火柴人实例游戏的开发过程。

本书语言轻松，通俗易懂，讲解由浅入深，力求将读者阅读和学习的难度降到最低。任何对计算机编程有兴趣的人或者首次接触编程的人，不论孩子还是成人，都可以通过阅读本书来学习Python编程。

入 门 —— “笨办法”学Python(第3版) 【Learn Python hard way】

[美]Zed A. Shaw (作者)

王巍巍 (译者)

书 号 978-7-115-35054-1

出版日期 2014-11-01

页 数 249

《“笨办法”学Python(第3版)》是一本Python入门书籍，适合对计算机了解不多，没有学过编程，但对编程感兴趣的读者学习使用。这本书以习题的方式引导读者一步一步学习编程，从简单的打印一直讲到完整项目的实现，让初学者从基础的编程技术入手，最终体验到软件开发的基本过程。

《“笨办法”学Python(第3版)》结构非常简单，共包括52个习题，其中26个覆盖了输入/输出、变量和函数三个主题，另外26个覆盖了一些比较高级的话题，如条件判断、循环、类和对象、代码测试及项目的实现等。每一章的格式基本相同，以代码习题开始，按照说明编写代码，运行并检查结果，然后再做附加练习。

入 门 —— Python入门经典

[美]Katie Cunningham (作者)

李军 , 李强 (译者)

书 号 978-7-115-36209-4

出版日期 2014-10-01

页 数 235

《Python入门经典》是面向Python初学者的学习指南，详细介绍了Python编程基础，以及一些高级概念，如面向对象编程。全书分为24章。第1章介绍了Python的背景和安装方法。第2章到第7章介绍了一些基本的编程概念，如变量、数学运算、字符串和获取输入。第8章到第12章介绍了更高级的主题，讨论了函数、字典和面向对象编程等。第13章到第15章介绍了如何使用库和模块，以及如何创建自己的模块。第16章到第19章介绍了使用数据，如保存到文件，使用标准格式以及使用数据库。第20章和第21章尝试了标准库以外的一些项目，在这两章中，介绍了创建动态Web站点和开发游戏。这两章并不是要成为完整的课程，而是充当学习更多知识的一个起点。第22章和第23章介绍了如何正确地保存代码，以及出错的时候如何找到解决方案。第24章介绍了读者可能会接触到哪些项目，哪些资源可以帮助读者学习更多知识，以及如何更深入地融入Python社区。

思维拓展——像计算机科学家一样思考Python

[美]Allen B. Downey (作者)

赵普明 (译者)

书 号 978-7-115-32092-6

出版日期 2013-08-01

页 数 328

《像计算机科学家一样思考Python》按照培养读者像计算机科学家一样的思维方式的思路来教授Python语言编程。全书贯穿的主体是如何思考、设计、开发的方法，而具体的编程语言，只是提供一个具体场景方便介绍的媒介。《像计算机科学家一样思考Python》并不是一本介绍语言的书，而是一本介绍编程思想的书。和其他编程设计语言书籍不同，它不拘泥于语言细节，而是尝试从初学者的角度出发，用生动的示例和丰富的练习来引导读者渐入佳境。

原文:http://www.jianshu.com/p/587442bd4522

Spark 学习笔记

Spark作为分布式系统框架的后起之秀（据说）各方面都要优于hadoop，有本地缓存，原生支持潮潮的scala， 对python的支持强大到直接可以用ipython notebook 作为交互界面。 还有几个正在开发中的分支框架分别用于机器学习和社交网络分析，简直华丽的飞起。

安装

根据阿帕奇基金会的尿性，应该是没有所谓的安装一说的，下载，解压就能使用了，当然不要忘了设置环境变量，具体不啰嗦.

使用

spark全面支持scala和java，部分支持python。好在scala也是脚本语言，所以相对比hadoop方便的多，先来看看两种交互模式。

pyspark

命令行使用 pyspark以后terminal中就会出现个大大SPARK图案和熟悉的python默认交互界面，这太丑了有啥更优秀的没？

利用 PYSPARK_DRIVER_PYTHON=ipython ./bin/pyspark呼出ipython交互界面，这个比原来的好多了。

利用

 PYSPARK_DRIVER_PYTHON=ipython PYSPARK_DRIVER_PYTHON_OPTS="notebook --pylab inline>" pyspark
 

调用ipython notebook

随便进去个试试示例的程序，还是用WordCount好了

file = sc.textFile("hdfs://localhost:9000/user/huangsizhe/input/README.md>")
count = file.flatMap(lambda line: line.split()).map(lambda word: (word, 1)).reduceByKey(lambda a, b: a+b)
count.saveAsTextFile("hdfs://localhost:9000/user/huangsizhe/wc>")
 

成功输出～

对了，为了避免hadoop警告建议把native lib 屏蔽了

spark-shell

这个是最常用的工具了，开发语言是scala，scala的话可以用脚本也可以编译执行，我觉得还是脚本方便

使用写的脚本方法是

$spark-shell -i XXX.scala

这样就会一条一条的执行了

还是WordCount

WordCount.scala放在$SPARKPATH/scala目录下

val file = sc.textFile("hdfs://localhost:9000/user/huangsizhe/input/README.md>")
val counts = file.flatMap(line => line.split(" >")).map(word => (word, 1)).reduceByKey(_ + _)
counts.saveAsTextFile("hdfs://localhost:9000/user/huangsizhe/wc>")
 

执行

$spark-shell -i WordCount.scala

成功！

spark-submit

这个就有点像hadoop了，一般用于写app，可以使用python，java，scala来写程序，python不用编译， java需要用maven编译成jar文件，scala也需要用sbt编译成jar文件。

python例子：

文件结构如下

WordCountpy |
            |-input
            |-script|
                    |-WordCount.py

WordCount.py如下

import sys
from operator import add
from pyspark import SparkContext
if __name__ == "__main__>":
	if len(sys.argv) != 3:
		print >> sys.stderr, "Usage: wordcount <input> <output>>"
		exit(-1)
	sc = SparkContext(appName="PythonWordCount>")
	lines = sc.textFile(sys.argv[1], 1)
	counts = lines.flatMap(lambda x: x.split(' ')) \
				  .map(lambda x: (x, 1)) \
				  .reduceByKey(add)
	output = counts.collect()
	for (word, count) in output:
		print "%s: %i>" % (word, count)
	counts.saveAsTextFile(sys.argv[2])
	sc.stop()
 

cd 到WordCount项目根目录下运行： spark-submit –master local[4] script/WordCount.py input/TheMostDistantWayInTheWorld.txt output 然后就会多出一个output文件夹，里面存有结果～

scala例子

java的我就不写了。。。

scala例子文件结构如下： WordCountScala | |-input| | |-TheMostDistantWayInTheWorld.txt | |-src| | |-wordcountApp.scala | |-wordcountAPP.sbt

wordcountApp.scala如下

import org.apache.spark.SparkContext
import org.apache.spark.SparkContext._
import org.apache.spark.SparkConf
object WordCountApp {
    def main(args: Array[String]) {
	if (args.length < 2) {
	  System.err.println("Usage: WordCountApp <input> <output>>")
	  System.exit(1)
	}
	val conf = new SparkConf().setAppName("WordCountAPP>")
	val sc = new SparkContext(conf)
	val file = sc.textFile(args(0))
	val counts = file.flatMap(line => line.split(" >")).map(word => (word,1)).reduceByKey(_+_)
	println(counts)
	counts.saveAsTextFile(args(1))
	}
    }
 

wordcountAPP.sbt如下：

name := "wordcount>"
version := "1.0>"
scalaVersion := "2.10.4>"
libraryDependencies += "org.apache.spark>" %% "spark-core>" % "1.2.0>"
 

编译：

cd 到 WordCountScala项目文件夹下

$ find .
$ sbt package

编译成功你编译完的程序就在 target/scala-2.10/simple-project_2.10-1.0.jar了

运行：

spark-submit   --class "WordCountApp>"  \
 --master local[4]   \
 target/scala-2.10/wordcount_2.10-1.0.jar input/TheMostDistantWayInTheWorld.txt output
 

你就能看到output了

Streaming spark的流式计算系统

这个stream很牛，实时运算，似乎是strom的替代品，试试官方例子 Networkwordcount.py

import sys
from pyspark import SparkContext
from pyspark.streaming import StreamingContext
if __name__ == "__main__>":
	if len(sys.argv) != 3:
		print >> sys.stderr, "Usage: network_wordcount.py <hostname> <port>>"
		exit(-1)
	sc = SparkContext(appName="PythonStreamingNetworkWordCount>")
	ssc = StreamingContext(sc, 1)
	lines = ssc.socketTextStream(sys.argv[1], int(sys.argv[2]))
	counts = lines.flatMap(lambda line: line.split(" >"))\
				  .map(lambda word: (word, 1))\
				  .reduceByKey(lambda a, b: a+b)
	counts.pprint()
	ssc.start()
	ssc.awaitTermination()
 

运行

1. nc -lk 9999打开端口监听
2. 新开个terminal，cd 到该脚本所在地址 spark-submit network_wordcount.py localhost 9999
3. 在nc -lk 那个terminal下输入句子试试～ 可以在另一个terminal中看到每次回车后该行的单词次数～

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

新浪云的基本配置

python应用基本步骤

咱以一个helloworld来做例子部署一个flask应用

先在新浪云上新建个app

1. 在个人账户下新建一个app
2. cd到希望新建app文件本地库的地方 执行 svn co https://svn.sinaapp.com/app名字 这样可以在目录下新建一个名为app名字的空文件夹。 过程中首先会要求输入本地当前账户的密码，然后输入安全邮箱作为user 安全密码作为password

本地调试代码

1. 可以在app本地库里面新建一个数字1到10间命名的文件夹，该数字就是这个app 的版本。默认版本为1

2. 创建配置文件
   config.yaml
   内容如下：

   name: helloworld
   version: 1
   

3. 创建启动文件
   index.wsgi
   内容如下：

   import sae
   from myapp import app
   application = sae.create_wsgi_app(app)
    

4. 创建主体文件
   myapp.py
   内容如下：

   from flask import Flask,render_template
   app = Flask(__name__)
   @app.route('/')
   def index():
   	return render_template('index.html')
   @app.route('/user/<name>')
   def user(name):
   	return render_template('user.html', name=name)
   if __name__ == '__main__':
   	app.run(debug=True)
    

5. 新建一个叫
   templates
   的文件夹，用来放两个html文件：

其中 index.html内容如下：

    
hello!

user.html内容如下：

    
hello,{{ name }}!

于是你的文件结构如下:

	 appname|
			  |-1|
				  |-config.yaml
				  |-index.wsgi
				  |-myapp.py
				  |-templates|
								 |-index.html
								 |-user.html
 

现在本地试下

shell里cd到1下， python myapp.py然后打开浏览器，地址栏输入 localhost:5000看看报错不

好了上传到sae吧～

cd到你的项目本地库，执行

    svn add ./

然后

    svn commit -m "描述的话>"

这样就算完成了

常用的svn命令

• svn co path/ svn checkout path–用来对path目标仓库在本地建立本地库及对应working copy(wp)
• svn add path–用来将本地库中的文件添加到wp
• svn delete path–删除wp中的文件
• svn commit -m “XXX>”–把你WC的更改提交到仓库
• svn update–更新仓库版本

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

注：本文全原创，作者：ZMAN  ( http://www.cnblogs.com/zmanone/)

OpenCV目前最新版是3.0.0 rc1，官方给出了编译好的Python2可以直接使用的cv2.pyd，可我想在Python3下用啊！只能硬着头皮自己编译了，Mingw编译到最后一步失败了，最终使用visual studio 2012编译成功，过程分享如下：

（注①：本步骤适用于WIN7 64位操作系统，Python版本为3.4.3 64bit，OpenCV版本为 3.0.0 rc1，我的CUDA版本是5.5）

（注②：请确保安装了numpy！！）

1. 安装Visual Studio 2012。 （链接: http://pan.baidu.com/s/1nt65Oet 密码: asiu 序列号：YKCW6-BPFPF-BT8C9-7DCTH-QXGWC）

2. 安装CMake。（链接: http://pan.baidu.com/s/1c0EVLfE 密码: mxqf）

3. 下载opencv源码。解压到任意位置，比如我的是 “D:/opencvcode>”  （链接: http://pan.baidu.com/s/1gdvSHuN 密码: fabq）

（可选）下载opencv的扩展modules包。解压到任意位置，比如我的是 “D:/opencv_contrib-master>”  （链接: http://pan.baidu.com/s/1c0tqZ9A 密码: ee71）

4. 修改代码。

① 打开 “D:\opencvcode\sources\modules\python\src2\hdr_parser.py>”。

第4行，把 codecs 库也import进来；第737行改为 “f = codecs.open(hname, >”r”, >”utf-8″)>” 。

② 打开 “D:\opencvcode\sources\cmake\OpenCVCompilerOptions.cmake>”。

把第67行 “add_extra_compiler_option(-Werror=non-virtual-dtor)>”注释掉（最前面加个注释符：#） 。

③ 打开 “D:\opencvcode\sources\modules\python\common.cmake>”。

在第27行”# header blacklist>”下增加一行：ocv_list_filterout(opencv_hdrs “detection_based_tracker>”) 。

5. 编译源代码。

① 打开CMake（gui）， “where is the source code>”定位到 “D:/opencvcode/sources>” 目录，”where to build the binaries>”定位到任意输出文件夹，比如我的是 “D:/opencv1>”。

② 勾选”Grouped>”和”Advanced>”。

③ 点击”Configure>”，确定，编译器选择”Visual Studio 2012 Win64>”。

④ 确保 勾选了 “BUILD -> BUILD_opencv_python3>”， 不要勾选 “WITH -> WITH_IPP>”， 请检查 “PYTHON3>”下各种PATH、DIR、LIBRARY的路径是不是正确。

⑤ 不要勾选 “BUILD_opencv_line_descriptor>” 和 “saliency>”。（暂时不清楚这两个库干嘛用的，但是我勾选了line_descriptor后总是无法成功编译）

⑥  “OPENCV -> OPENCV_EXTRA_MODULES_PATH>” 定位到 “D:/opencv_contrib-master/modules>”。

⑦ 再次点击”Configure>”，确保没有红色背景色的选项后，点击 “Generate>”。

6. BUILD代码。

① 进入 “D:/opencv1>”，打开 “OpenCV.sln>”。

② 切换到 “Release>”模式后，右键 “解决方案’OpenCV’”选择“重新生成解决方案”，接下来是漫长的等待，如果最后显示失败个数是0，就成功啦！

7. 设置环境变量。

① 把 “D:/opencv1/bin/Release>”目录加入环境变量，把 “D:/opencv1/lib/Release/cv2.pyd>”复制到你的Python目录内的 “site-packages>”文件夹下。

8. 品尝成功的喜悦。

① 在Python中，运行如下代码：

import  cv2
 import  numpy
 #  读入图像
im = cv2.imread(' C:/Users/Public/Pictures/Sample Pictures/Koala.jpg ' )
 #  下采样
im_lowres = cv2.pyrDown(im)
 #  转化为灰度图像
gray = cv2.cvtColor(im_lowres, cv2.COLOR_RGB2GRAY)
 #  检测特征点
s  = cv2.xfeatures2d.SURF_create()
 # s = cv2.SURF()
mask = numpy.uint8(numpy.ones(gray.shape))
keypoints  = s.detect(gray, mask)
 #  显示图像及特征点
vis = cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)
 for  k in  keypoints[::10]:
	cv2.circle(vis, (int(k.pt[0]), int(k.pt[ 1])), 2, (0, 255, 0), -1)
	cv2.circle(vis, (int(k.pt[0]), int(k.pt[ 1])), int(k.size), (0, 255, 0), 2)
cv2.imshow( ' local descriptors ' , vis)
cv2.waitKey()
cv2.imwrite( ' C:/Users/Public/Pictures/Sample Pictures/Koala2.jpg ' ,vis)
 

② duang~跳出来一张这样的考拉图片就说明成功啦！！

原文:http://www.cnblogs.com/zmanone/p/4532842.html

刚刚接触Python，今天就是怎么也调试不过去了，上网上查直到晚上才查到一个有效信息，真是坑啊！原来Python中的这些“魔法”方法的命名里就有陷阱……

上图中的那两个红圈圈，一定要记住哦，这些Python自带的方法，比如str和init前后都是两个”_>”，写一个”_>”按F5运行肯定有问题！

拿我的同事猫脸屁做个类，因为他最烦人，所以我学习的时候也会带着他（二次元击打松尾芭蕉桑）：

 1  import time
  2  def GetNowYear():
  3  return  time.strftime(" %Y >" ,time.localtime(time.time()))
  4
 5  class  PiCat:
  6      def __init__(self,name,age):
  7          self.name = name
  8          self.age = age
  9      def __str__(self):
 10          msg = " Hi, I'm  >" + self.name + " , I'm  >"  + str(self.age) +"  years old. >"
11  return  msg
 12
13  mlp = PiCat(" Lianpi Mao >" ,int (GetNowYear())-1990 )
 14
15  print mlp.name
 16  print mlp 

这个程序很简单，就是让猫脸屁说一下自己的名字，并做一下自我介绍。

坑的就是那两个”_>”啊！！！

是 __str__ 而不是 _str_ ！！！

是 __init__ 而不是 _init_ ！！！

原文:http://www.cnblogs.com/LanTianYou/p/4534142.html

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

Python 3.5.0b1 发布，此版本主要有以下更新：

• PEP 448, additional unpacking generalizations
• PEP 461, adding support for “%-formatting>” for bytes and bytearray objects
• PEP 465, a new operator (@) for matrix multiplication
• PEP 471, os.scandir(), a faster alternative to os.walk()
• PEP 475, adding support for automatic retries of interrupted system calls
• PEP 479, change StopIteration handling inside generators
• PEP 484, the typing module, a new standard for type annotations
• PEP 486, making the Windows Python launcher aware of virtual environments
• PEP 488, eliminating .pyo files
• PEP 489, multi-phase extension module initialization
• PEP 492, coroutines with async and await syntax

详细信息请查看 更新日志 。

Python 3.5 现在 已经进入 “功能 冻结 ” 阶段。在 默认情况下， 新功能可能不再被加入到 Python 3.5 中。

预知更多有关 Python 3.5.0b1 信息，请查看 发行页面 。

Python(发音:[ ‘paiθ(ə)n; (US) ‘paiθɔn ]n.蟒蛇，巨蛇 )，是一种面向对象的解释性的计算机程序设计语言，也是一种功能强大而完善的通用型语言，已经具有十多年的发展历史，成熟且稳定。Python 具有脚本语言中最丰富和强大的类库，足以支持绝大多数日常应用。

原文:http://www.oschina.net/news/62820/python-3-5-0b1-released

本文根据@Nicolas Bevacqua的 《nifty-python-tricks》所译，整个译文带有我自己的理解与思想，如果译得不好或有不对之处还请同行朋友指点。如需转载此译文，需注明英文出处： https://freepythontips.wordpress.com/2015/04/19/nifty-python-tricks/。

原文:http://www.ido321.com/1576.html

据说Python是最适合iOS开发者学习的语言没有之一，可以写一些脚本来提高开发效率。我就看到过一位朋友利用Python写了很多工具。

来，用Python写一句代码吧！

编译一下控制台会输出：

我用的是CodeRunner，这个工具是收费的，不过在天朝你肯定能搞到免费的。如果你是在搞不到没关系，告诉你一个可以免费获取的方法：

关注微信公众号： 猿圈 (ID: CodePush ) (←长按复制)

猿圈 (ID: CodePush ) (←长按复制)