Python的隐藏功能

Interactive Interpreter选项卡完成

try:
    import readline
except ImportError:
    print "Unable to load readline module."
else:
    import rlcompleter
    readline.parse_and_bind("tab: complete")


>>> class myclass:
...    def function(self):
...       print "my function"
... 
>>> class_instance = myclass()
>>> class_instance.
class_instance.__class__   class_instance.__module__
class_instance.__doc__     class_instance.function
>>> class_instance.function()

您还必须设置PYTHONSTARTUP环境变量.

嵌套列表推导和生成器表达式:

[(i,j) for i in range(3) for j in range(i) ]    
((i,j) for i in range(4) for j in range(i) )

这些可以取代大块的嵌套循环代码.

set内置运算符重载:

>>> a = set([1,2,3,4])
>>> b = set([3,4,5,6])
>>> a | b # Union
{1, 2, 3, 4, 5, 6}
>>> a & b # Intersection
{3, 4}
>>> a < b # Subset
False
>>> a - b # Difference
{1, 2}
>>> a ^ b # Symmetric Difference
{1, 2, 5, 6}

标准库参考的更多细节:设置类型

负圆

该round()函数将浮点数舍入为十进制数的给定精度,但精度可以为负数:

>>> str(round(1234.5678, -2))
'1200.0'
>>> str(round(1234.5678, 2))
'1234.57'

注意: round()总是返回一个浮点数,str()在上面的例子中使用,因为浮点数学是不精确的,而在2.x下,第二个例子可以打印为1234.5700000000001.另见decimal模块.

乘以布尔值

我在Web开发中经常做的一件事是可选地打印HTML参数.我们都看到过其他语言的代码:

class='<% isSelected ? "selected" : "" %>'

在Python中,您可以乘以布尔值,它完全符合您的期望:

class='<% "selected" * isSelected %>'

这是因为乘法将布尔值强制转换为整数(0表示False,1表示True),而在python中,字符串乘以int会重复字符串N次.

Python的高级切片操作有一个鲜为人知的语法元素,省略号:

>>> class C(object):
...  def __getitem__(self, item):
...   return item
... 
>>> C()[1:2, ..., 3]
(slice(1, 2, None), Ellipsis, 3)

不幸的是,它几乎没有用,因为只有在涉及元组的情况下才支持省略号.

事实上你可以在每次匹配正则表达式时调用函数都非常方便.在这里,我有一个样本,用"Hi"替换每个"Hello",用"Fred"等替换"there"等.

import re

def Main(haystack):
  # List of from replacements, can be a regex
  finds = ('Hello', 'there', 'Bob')
  replaces = ('Hi,', 'Fred,', 'how are you?')

  def ReplaceFunction(matchobj):
    for found, rep in zip(matchobj.groups(), replaces):
      if found != None:
        return rep

    # log error
    return matchobj.group(0)

  named_groups = [ '(%s)' % find for find in finds ]
  ret = re.sub('|'.join(named_groups), ReplaceFunction, haystack)
  print ret

if __name__ == '__main__':
  str = 'Hello there Bob'
  Main(str)
  # Prints 'Hi, Fred, how are you?'

元组在python 3中解压缩

在python 3中,您可以使用与函数定义中的可选参数相同的语法来进行元组解包:

>>> first,second,*rest = (1,2,3,4,5,6,7,8)
>>> first
1
>>> second
2
>>> rest
[3, 4, 5, 6, 7, 8]

但是一个鲜为人知且功能更强大的功能允许您在列表中间包含未知数量的元素:

>>> first,*rest,last = (1,2,3,4,5,6,7,8)
>>> first
1
>>> rest
[2, 3, 4, 5, 6, 7]
>>> last
8

多行字符串

一种方法是使用反斜杠:

>>> sql = "select * from some_table \
where id > 10"
>>> print sql
select * from some_table where id > 10

另一种是使用三重报价:

>>> sql = """select * from some_table 
where id > 10"""
>>> print sql
select * from some_table where id > 10

问题在于它们没有缩进(在代码中看起来很差).如果您尝试缩进,它只会打印您放置的空白区域.

我最近发现的第三个解决方案是将你的字符串分成几行并用括号括起来:

>>> sql = ("select * from some_table " # <-- no comma, whitespace at end
           "where id > 10 "
           "order by name") 
>>> print sql
select * from some_table where id > 10 order by name

注意行之间没有逗号(这不是元组),你必须考虑字符串需要的任何尾随/前导空格.顺便说一句,所有这些都与占位符一起工作(例如"my name is %s" % name).

根据许多人的要求,这个答案已经转移到了问题本身.

下划线,它包含解释器显示的最新输出值(在交互式会话中):

>>> (a for a in xrange(10000))

>>> b = 'blah'
>>> _

一个方便的Web浏览器控制器:

>>> import webbrowser
>>> webbrowser.open_new_tab('http://www.stackoverflow.com')

内置的http服务器.要提供当前目录中的文件:

python -m SimpleHTTPServer 8000

atexit对

>>> import atexit

pow()也可以有效地计算(x**y)%z.

有一个鲜为人知的内置pow()函数的第三个参数,它允许你比简单地做更有效地计算x ^y modulo z (x ** y) % z:

>>> x, y, z = 1234567890, 2345678901, 17
>>> pow(x, y, z)            # almost instantaneous
6

相比之下,(x ** y) % z在我的机器上一分钟没有给出相同值的结果.

您可以轻松地使用zip转置数组.

a = [(1,2), (3,4), (5,6)]
zip(*a)
# [(1, 3, 5), (2, 4, 6)]

用不同的起始索引枚举

enumerate已经部分涵盖了这个答案,但最近我发现了一个更隐藏的功能enumerate,我觉得应该发表自己的帖子,而不仅仅是评论.

从Python 2.6开始,您可以enumerate在第二个参数中指定起始索引:

>>> l = ["spam", "ham", "eggs"]
>>> list(enumerate(l))
>>> [(0, "spam"), (1, "ham"), (2, "eggs")]
>>> list(enumerate(l, 1))
>>> [(1, "spam"), (2, "ham"), (3, "eggs")]

我发现它非常有用的一个地方就是我在列举对称矩阵的条目时.由于矩阵是对称的,我可以通过迭代上三角形来节省时间,但在这种情况下,我必须enumerate在内部for循环中使用不同的起始索引来正确跟踪行和列索引:

for ri, row in enumerate(matrix):
    for ci, column in enumerate(matrix[ri:], ri):
        # ci now refers to the proper column index

奇怪的是,这种行为enumerate没有记录在案help(enumerate),仅在在线文档中.

您可以使用属性使您的类接口更严格.

class C(object):
    def __init__(self, foo, bar):
        self.foo = foo # read-write property
        self.bar = bar # simple attribute

    def _set_foo(self, value):
        self._foo = value

    def _get_foo(self):
        return self._foo

    def _del_foo(self):
        del self._foo

    # any of fget, fset, fdel and doc are optional,
    # so you can make a write-only and/or delete-only property.
    foo = property(fget = _get_foo, fset = _set_foo,
                   fdel = _del_foo, doc = 'Hello, I am foo!')

class D(C):
    def _get_foo(self):
        return self._foo * 2

    def _set_foo(self, value):
        self._foo = value / 2

    foo = property(fget = _get_foo, fset = _set_foo,
                   fdel = C.foo.fdel, doc = C.foo.__doc__)

在Python 2.6和3.0中:

class C(object):
    def __init__(self, foo, bar):
        self.foo = foo # read-write property
        self.bar = bar # simple attribute

    @property
    def foo(self):
        '''Hello, I am foo!'''

        return self._foo

    @foo.setter
    def foo(self, value):
        self._foo = value

    @foo.deleter
    def foo(self):
        del self._foo

class D(C):
    @C.foo.getter
    def foo(self):
        return self._foo * 2

    @foo.setter
    def foo(self, value):
        self._foo = value / 2

要了解有关属性如何工作的更多信息,请参阅描述符.

很多人不了解"dir"功能.这是一个很好的方法来确定一个对象可以从解释器做什么.例如,如果要查看所有字符串方法的列表:

>>> dir("foo")
['__add__', '__class__', '__contains__', (snipped a bunch), 'title',
 'translate', 'upper', 'zfill']

然后,如果您想了解有关特定方法的更多信息,可以在其上调用"帮助".

>>> help("foo".upper)
    Help on built-in function upper:

upper(...)
    S.upper() -> string

    Return a copy of the string S converted to uppercase.

集/ frozenset

可能容易被忽视的python内置是"set/frozenset".

当你有一个像这样的列表[1,2,1,1,2,3,4]并且只想要像这样的[1,2,3,4]这样的独特时,这很有用.

使用set(),这正是你得到的:

>>> x = [1,2,1,1,2,3,4] 
>>> 
>>> set(x) 
set([1, 2, 3, 4]) 
>>>
>>> for i in set(x):
...     print i
...
1
2
3
4

当然,要获取列表中的唯一身份数量:

>>> len(set([1,2,1,1,2,3,4]))
4

您还可以使用set()查找列表是否是另一个列表的子集.issubset():

>>> set([1,2,3,4]).issubset([0,1,2,3,4,5])
True

从Python 2.7和3.0开始,您可以使用花括号来创建一个集合:

myset = {1,2,3,4}

以及设定理解:

{x for x in stuff}

有关更多详细信息,请访问:http: //docs.python.org/library/stdtypes.html#set

内置base64,zlib和rot13编解码器

字符串也有encode和decode方法.通常这用于转换str,unicode反之亦然,例如u = s.encode('utf8').但是还有其他一些方便的内置编解码器.使用zlib(和bz2)进行压缩和解压缩是没有明确导入的:

>>> s = 'a' * 100
>>> s.encode('zlib')
'x\x9cKL\xa4=\x00\x00zG%\xe5'

同样,您可以编码和解码base64:

>>> 'Hello world'.encode('base64')
'SGVsbG8gd29ybGQ=\n'
>>> 'SGVsbG8gd29ybGQ=\n'.decode('base64')
'Hello world'

当然,你可以腐烂13:

>>> 'Secret message'.encode('rot13')
'Frperg zrffntr'

口译员内的口译员

标准库的代码模块允许您在程序中包含自己的read-eval-print循环,或者运行整个嵌套的解释器.例如(从这里复制我的例子)

$ python
Python 2.5.1 (r251:54863, Jan 17 2008, 19:35:17) 
[GCC 4.0.1 (Apple Inc. build 5465)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> shared_var = "Set in main console"
>>> import code
>>> ic = code.InteractiveConsole({ 'shared_var': shared_var })
>>> try:
...     ic.interact("My custom console banner!")
... except SystemExit, e:
...     print "Got SystemExit!"
... 
My custom console banner!
>>> shared_var
'Set in main console'
>>> shared_var = "Set in sub-console"
>>> import sys
>>> sys.exit()
Got SystemExit!
>>> shared_var
'Set in main console'

这对于您希望接受来自用户的脚本输入或实时查询VM状态的情况非常有用.

TurboGears通过使用WebConsole来实现这一效果,您可以从中查询实时Web应用程序的状态.

>>> from functools import partial
>>> bound_func = partial(range, 0, 10)
>>> bound_func()
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> bound_func(2)
[0, 2, 4, 6, 8]

不是真正隐藏的功能,但是部分对于对功能的后期评估非常有用.

您可以根据需要在初始调用中绑定尽可能多的参数,并稍后使用任何剩余参数调用它(在此示例中,我将开始/结束参数绑定到范围,但是第二次调用它步骤arg)

请参阅文档.

在调试复杂的数据结构时,pprint模块非常方便.

引用文档..

>>> import pprint    
>>> stuff = sys.path[:]
>>> stuff.insert(0, stuff)
>>> pprint.pprint(stuff)
[,
 '',
 '/usr/local/lib/python1.5',
 '/usr/local/lib/python1.5/test',
 '/usr/local/lib/python1.5/sunos5',
 '/usr/local/lib/python1.5/sharedmodules',
 '/usr/local/lib/python1.5/tkinter']

Python有GOTO

...它由外部纯Python模块实现 :)

from goto import goto, label
for i in range(1, 10):
    for j in range(1, 20):
        for k in range(1, 30):
            print i, j, k
            if k == 3:
                goto .end # breaking out from a deeply nested loop
label .end
print "Finished"

dict的构造函数接受关键字参数:

>>> dict(foo=1, bar=2)
{'foo': 1, 'bar': 2}

序列乘法和反射操作数

>>> 'xyz' * 3
'xyzxyzxyz'

>>> [1, 2] * 3
[1, 2, 1, 2, 1, 2]

>>> (1, 2) * 3
(1, 2, 1, 2, 1, 2)

我们使用反射(交换)操作数获得相同的结果

>>> 3 * 'xyz'
'xyzxyzxyz'

它的工作原理如下:

>>> s = 'xyz'
>>> num = 3

要评估表达式s*num解释器调用s .___ mul ___(num)

>>> s * num
'xyzxyzxyz'

>>> s.__mul__(num)
'xyzxyzxyz'

要评估表达式num*s解释器调用num .___ mul ___(s)

>>> num * s
'xyzxyzxyz'

>>> num.__mul__(s)
NotImplemented

如果调用返回NotImplemented,则解释器调用反射操作s .___ rmul ___(num)如果操作数具有不同类型

>>> s.__rmul__(num)
'xyzxyzxyz'

请参阅http://docs.python.org/reference/datamodel.html#object.RMUL

模块运算符中的Getter功能

函数attrgetter()和itemgetter()模块operator可用于生成快速访问函数,以用于排序和搜索对象和字典

Python库文档中的第6.7章

交错if和for列表理解

>>> [(x, y) for x in range(4) if x % 2 == 1 for y in range(4)]
[(1, 0), (1, 1), (1, 2), (1, 3), (3, 0), (3, 1), (3, 2), (3, 3)]

在我学习Haskell之前,我从未意识到这一点.

元组拆包:

>>> (a, (b, c), d) = [(1, 2), (3, 4), (5, 6)]
>>> a
(1, 2)
>>> b
3
>>> c, d
(4, (5, 6))

更晦涩的是,您可以在函数参数中执行此操作(在Python 2.x中; Python 3.x将不再允许此操作):

>>> def addpoints((x1, y1), (x2, y2)):
...     return (x1+x2, y1+y2)
>>> addpoints((5, 0), (3, 5))
(8, 5)

显然,反重力模块. xkcd#353

Python解释器

>>> 

也许不是鲜为人知,但肯定是我最喜欢的Python功能之一.

Python排序函数正确排序元组(即使用熟悉的词典顺序):

a = [(2, "b"), (1, "a"), (2, "a"), (3, "c")]
print sorted(a)
#[(1, 'a'), (2, 'a'), (2, 'b'), (3, 'c')]

如果您想在年龄之后对人员列表进行排序然后命名,则非常有用.

在构建时引用列表理解...

您可以引用列表推导,因为它是由符号'_ [1]'构建的.例如,以下函数unique-ifies元素列表,而不通过引用其列表推导来更改其顺序.

def unique(my_list):
    return [x for x in my_list if x not in locals()['_[1]']]

解压缩语法已在最新版本中升级,如示例中所示.

>>> a, *b = range(5)
>>> a, b
(0, [1, 2, 3, 4])
>>> *a, b = range(5)
>>> a, b
([0, 1, 2, 3], 4)
>>> a, *b, c = range(5)
>>> a, b, c
(0, [1, 2, 3], 4)

简单:

>>> 'str' in 'string'
True
>>> 'no' in 'yes'
False
>>> 

是我喜欢Python的东西,我已经看到很多不那么像这样的pythonic成语:

if 'yes'.find("no") == -1:
    pass

元类

当然:-) 什么是Python中的元类？

我个人喜欢3种不同的报价

str = "I'm a string 'but still I can use quotes' inside myself!"
str = """ For some messy multi line strings.
Such as

 ... """

同样很酷:不必逃避正则表达式,使用原始字符串避免可怕的反斜杠沙拉:

str2 = r"\n" 
print str2
>> \n

发电机

我认为很多初学的Python开发人员都没有真正掌握它们的用途或者对它们的能力有所了解.直到我读到David M. Beazley关于发电机的PyCon演示文稿(它可以在这里找到),我才意识到它们是多么有用(必不可少).那个演示文稿阐明了对我来说是一种全新的编程方式,我推荐给那些对发电机没有深刻理解的人.

隐式连接:

>>> print "Hello " "World"
Hello World

想要在脚本中的多行上创建长文本时很有用:

hello = "Greaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa Hello " \
        "Word"

要么

hello = ("Greaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa Hello " 
         "Word")

使用交互式shell时,"_"包含最后打印项的值:

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> _
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

textwrap.dedentpython中的实用程序函数可以非常方便地测试返回的多行字符串是否等于预期输出而不会破坏单元测试的缩进:

import unittest, textwrap

class XMLTests(unittest.TestCase):
    def test_returned_xml_value(self):
        returned_xml = call_to_function_that_returns_xml()
        expected_value = textwrap.dedent("""\
        
        
            my_content
        
        """)

        self.assertEqual(expected_value, returned_xml)

零参数和变量参数lambda

Lambda函数通常用于将一个值快速转换为另一个值,但它们也可用于在函数中包装值:

>>> f = lambda: 'foo'
>>> f()
'foo'

他们也可以接受通常*args和**kwargs语法:

>>> g = lambda *args, **kwargs: args[0], kwargs['thing']
>>> g(1, 2, 3, thing='stuff')
(1, 'stuff')

使用关键字参数作为分配

有时,人们希望根据一个或多个参数构建一系列函数.但是,这可能很容易导致闭包所有引用相同的对象和值:

funcs = [] 
for k in range(10):
     funcs.append( lambda: k)

>>> funcs[0]()
9
>>> funcs[7]()
9

通过将lambda表达式转换为仅依赖于其参数的函数,可以避免此行为.关键字参数存储绑定到它的当前值.函数调用不必更改:

funcs = [] 
for k in range(10):
     funcs.append( lambda k = k: k)

>>> funcs[0]()
0
>>> funcs[7]()
7

Mod可以正数使用负数

-1%5是4,因为它应该是-1,而不是像其他语言一样的JavaScript.这使得"环绕式窗口"在Python中变得更干净,你只需这样做:

index = (index + increment) % WINDOW_SIZE

一流的功能

它并不是一个隐藏的功能,但功能是一流的对象这一事实非常棒.你可以像任何其他变量一样传递它们.

>>> def jim(phrase):
...   return 'Jim says, "%s".' % phrase
>>> def say_something(person, phrase):
...   print person(phrase)

>>> say_something(jim, 'hey guys')
'Jim says, "hey guys".'

三元运算符

>>> 'ham' if True else 'spam'
'ham'
>>> 'ham' if False else 'spam'
'spam'

这是在2.5中添加的,在此之前您可以使用:

>>> True and 'ham' or 'spam'
'ham'
>>> False and 'ham' or 'spam'
'spam'

但是,如果您要使用的值将被视为false,则存在差异:

>>> [] if True else 'spam'
[]
>>> True and [] or 'spam'
'spam'

分配和删除切片:

>>> a = range(10)
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[:5] = [42]
>>> a
[42, 5, 6, 7, 8, 9]
>>> a[:1] = range(5)
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del a[::2]
>>> a
[1, 3, 5, 7, 9]
>>> a[::2] = a[::-2]
>>> a
[9, 3, 5, 7, 1]

注意:分配给扩展切片(s[start:stop:step])时,指定的可迭代必须与切片具有相同的长度.

不是很隐蔽,但功能有属性:

def doNothing():
    pass

doNothing.monkeys = 4
print doNothing.monkeys
4

将元组传递给内置函数

很多Python函数都接受元组,它似乎也不像.例如,您想测试您的变量是否为数字,您可以这样做:

if isinstance (number, float) or isinstance (number, int):  
   print "yaay"

但是,如果你通过我们元组,这看起来更清洁:

if isinstance (number, (float, int)):  
   print "yaay"

在字典中无限递归的好处理:

>>> a = {}
>>> b = {}
>>> a['b'] = b
>>> b['a'] = a
>>> print a
{'b': {'a': {...}}}

使用负步骤反转可迭代

>>> s = "Hello World"
>>> s[::-1]
'dlroW olleH'
>>> a = (1,2,3,4,5,6)
>>> a[::-1]
(6, 5, 4, 3, 2, 1)
>>> a = [5,4,3,2,1]
>>> a[::-1]
[1, 2, 3, 4, 5]

不是"隐藏"但非常有用且不常用

像这样快速创建字符串连接功能

 comma_join = ",".join
 semi_join  = ";".join

 print comma_join(["foo","bar","baz"])
 'foo,bar,baz

和

能够比引号,逗号混乱更优雅地创建字符串列表.

l = ["item1", "item2", "item3"]

取而代之

l = "item1 item2 item3".split()

可以说,这本身并不是一个编程功能,但是非常有用,我会发布它.

$ python -m http.server

......其次是$ wget http://:8000/filename其他地方.

如果您仍在运行较旧的(2.x)版本的Python:

$ python -m SimpleHTTPServer

您也可以指定一个端口python -m http.server 80(例如,如果您在服务器端有根,则可以省略URL中的端口)

对迭代器的多个引用

您可以使用列表乘法创建对同一迭代器的多个引用:

>>> i = (1,2,3,4,5,6,7,8,9,10) # or any iterable object
>>> iterators = [iter(i)] * 2
>>> iterators[0].next()
1
>>> iterators[1].next()
2
>>> iterators[0].next()
3

这可以在本实施例中被用来组可迭代成块,例如,作为来自itertools文档

def grouper(n, iterable, fillvalue=None):
    "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
    args = [iter(iterable)] * n
    return izip_longest(fillvalue=fillvalue, *args)

从python 3.1(2.7)支持字典和集合理解:

{ a:a for a in range(10) }
{ a for a in range(10) }

Python 可以理解任何类型的unicode数字,而不仅仅是ASCII类:

>>> s = u'?????'
>>> s
u'\uff11\uff10\uff15\uff18\uff15'
>>> print s
?????
>>> int(s)
10585
>>> float(s)
10585.0

__slots__是一种节省内存的好方法,但很难得到对象值的字典.想象一下以下对象:

class Point(object):
    __slots__ = ('x', 'y')

现在该对象显然有两个属性.现在我们可以创建它的实例并以这种方式构建它的字典:

>>> p = Point()
>>> p.x = 3
>>> p.y = 5
>>> dict((k, getattr(p, k)) for k in p.__slots__)
{'y': 5, 'x': 3}

但是如果点被子类化并且添加了新的插槽,则这将不起作用.但是Python会自动实现__reduce_ex__以帮助copy模块.这可能会被滥用来获得价值观:

>>> p.__reduce_ex__(2)[2][1]
{'y': 5, 'x': 3}

itertools

这个模块经常被忽视.以下示例用于itertools.chain() 展平列表:

>>> from itertools import *
>>> l = [[1, 2], [3, 4]]
>>> list(chain(*l))
[1, 2, 3, 4]

有关更多应用程序,请参阅http://docs.python.org/library/itertools.html#recipes.

操作sys.modules

您可以直接操作模块缓存,使模块可用或不可用:

>>> import sys
>>> import ham
Traceback (most recent call last):
  File "", line 1, in 
ImportError: No module named ham

# Make the 'ham' module available -- as a non-module object even!
>>> sys.modules['ham'] = 'ham, eggs, saussages and spam.'
>>> import ham
>>> ham
'ham, eggs, saussages and spam.'

# Now remove it again.
>>> sys.modules['ham'] = None
>>> import ham
Traceback (most recent call last):
  File "", line 1, in 
ImportError: No module named ham

这适用于可用的模块,在某种程度上适用于已导入的模块:

>>> import os
# Stop future imports of 'os'.
>>> sys.modules['os'] = None
>>> import os
Traceback (most recent call last):
  File "", line 1, in 
ImportError: No module named os
# Our old imported module is still available.
>>> os

如最后一行所示,更改sys.modules只影响将来的import语句,而不是过去的语句,所以如果你想影响其他模块,在给他们机会尝试导入模块之前进行这些更改是很重要的 - 所以在你之前通常导入它们.None是一个特殊的值sys.modules,用于负缓存(表示第一次找不到模块,所以再看一遍没有意义.)任何其他值都将是import操作的结果- 即使它不是模块对象.您可以使用它来替换具有与您想要的行为完全相同的对象的模块.sys.modules完全删除条目会导致下一个条目import正常搜索模块,即使它之前已经导入过.

您可以通过查看其__ module__属性来询问任何对象来自哪个模块.例如,如果您在命令行进行实验并导入了很多东西,这很有用.

同样,您可以通过查看其__ file__属性来询问模块的来源.这在调试路径问题时很有用.

一些内置的收藏夹,map(),reduce()和filter().一切都非常快速和强大.

一句话:IPython

标签内省,漂亮印刷,%debug历史管理pylab,......值得花时间学习.

猜整数基数

>>> int('10', 0)
10
>>> int('0x10', 0)
16
>>> int('010', 0)  # does not work on Python 3.x
8
>>> int('0o10', 0)  # Python >=2.6 and Python 3.x
8
>>> int('0b10', 0)  # Python >=2.6 and Python 3.x
2

您可以从一组长度为2的序列构建字典.当你有一个值列表和一个数组列表时非常方便.

>>> dict([ ('foo','bar'),('a',1),('b',2) ])
{'a': 1, 'b': 2, 'foo': 'bar'}

>>> names = ['Bob', 'Marie', 'Alice']
>>> ages = [23, 27, 36]
>>> dict(zip(names, ages))
{'Alice': 36, 'Bob': 23, 'Marie': 27}

在子类中扩展属性(定义为描述符)

有时,扩展(修改)子类中描述符"返回"的值是有用的.它可以很容易地完成super():

class A(object):
    @property
    def prop(self):
        return {'a': 1}

class B(A):
    @property
    def prop(self):
        return dict(super(B, self).prop, b=2)

将其存储test.py并运行python -i test.py(另一个隐藏功能:-i选项执行脚本并允许您以交互模式继续):

>>> B().prop
{'a': 1, 'b': 2}

蟒蛇的轻微错误.将字符串列表连接在一起的正常快速方法是,

''.join(list_of_strings)

创建枚举

在Python中,您可以这样做以快速创建枚举:

>>> FOO, BAR, BAZ = range(3)
>>> FOO
0

但"枚举"不必具有整数值.你甚至可以这样做:

class Colors(object):
    RED, GREEN, BLUE, YELLOW = (255,0,0), (0,255,0), (0,0,255), (0,255,255)

#now Colors.RED is a 3-tuple that returns the 24-bit 8bpp RGB 
#value for saturated red

对象数据模型

您可以使用您自己的类的语言覆盖任何运算符.有关完整列表,请参阅此页面.一些例子:

您可以覆盖任何运算符(* + - / // % ^ == < > <= >= .等).所有这一切都是通过重写完成__mul__,__add__等你的对象.你甚至可以忽略的东西喜欢__rmul__单独处理your_object*something_else和something_else*your_object. .是属性access(a.b),可以b通过使用来覆盖任何任意处理__getattr__.此处还包括a(…)使用__call__.

你可以创建自己的切片语法(a[stuff]),这是非常复杂的,从列表(numpy的有这在他们的阵列电源的一个很好的例子),用于使用任意组合的标准语法完全不同,,:和…你喜欢,使用Slice对象.

特别处理语言中的许多关键字会发生什么.包括的是del,in,import,和not.

处理当您的对象调用许多内置函数时会发生什么.标准的__int__,__str__等去这里,但这么做__len__,__reversed__,__abs__,和三个参数__pow__(模块化幂).

该re.Scanner班.http://code.activestate.com/recipes/457664-hidden-scanner-functionality-in-re-module/

"解包"到功能参数

def foo(a, b, c):
        print a, b, c

bar = (3, 14, 15)
foo(*bar)

执行打印时:

3 14 15

该reversed()内置.在许多情况下,它使迭代更加清晰.

快速举例:

for i in reversed([1, 2, 3]):
    print(i)

生产:

3
2
1

但是,reversed()也适用于任意迭代器,例如文件中的行或生成器表达式.

Python的禅宗

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

在运行时更改功能标签:

>>> class foo:
...   def normal_call(self): print "normal_call"
...   def call(self): 
...     print "first_call"
...     self.call = self.normal_call

>>> y = foo()
>>> y.call()
first_call
>>> y.call()
normal_call
>>> y.call()
normal_call
...

string-escape和unicode-escape编码

假设你有一个来自外部源的字符串,包含\n,\t等等.如何将它们转换为换行符或制表符？只需使用string-escape编码解码字符串!

>>> print s
Hello\nStack\toverflow
>>> print s.decode('string-escape')
Hello
Stack   overflow

另一个问题.你有正常的字符串与unicode文字像\u01245.如何使它工作？只需使用unicode-escape编码解码字符串!

>>> s = '\u041f\u0440\u0438\u0432\u0456\u0442, \u0441\u0432\u0456\u0442!'
>>> print s
\u041f\u0440\u0438\u0432\u0456\u0442, \u0441\u0432\u0456\u0442!
>>> print unicode(s)
\u041f\u0440\u0438\u0432\u0456\u0442, \u0441\u0432\u0456\u0442!
>>> print unicode(s, 'unicode-escape')
??????, ????!

解压缩Python中不需要的东西

有人在博客上发表了关于Python没有解压缩功能的解决方案.unzip是直接计算的,因为:

>>> t1 = (0,1,2,3)
>>> t2 = (7,6,5,4)
>>> [t1,t2] == zip(*zip(t1,t2))
True

但是在反思时,我宁愿有一个明确的解压缩().

创建具有相关数据的两个序列的字典

In [15]: t1 = (1, 2, 3)

In [16]: t2 = (4, 5, 6)

In [17]: dict (zip(t1,t2))
Out[17]: {1: 4, 2: 5, 3: 6}

最高机密属性

>>> class A(object): pass
>>> a = A()
>>> setattr(a, "can't touch this", 123)
>>> dir(a)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', "can't touch this"]
>>> a.can't touch this # duh
  File "", line 1
    a.can't touch this
                     ^
SyntaxError: EOL while scanning string literal
>>> getattr(a, "can't touch this")
123
>>> setattr(a, "__class__.__name__", ":O")
>>> a.__class__.__name__
'A'
>>> getattr(a, "__class__.__name__")
':O'

namedtuple是一个元组

>>> node = namedtuple('node', "a b")
>>> node(1,2) + node(5,6)
(1, 2, 5, 6)
>>> (node(1,2), node(5,6))
(node(a=1, b=2), node(a=5, b=6))
>>> 

还有一些回应评论的实验:

>>> from collections import namedtuple
>>> from operator import *
>>> mytuple = namedtuple('A', "a b")
>>> yourtuple = namedtuple('Z', "x y")
>>> mytuple(1,2) + yourtuple(5,6)
(1, 2, 5, 6)
>>> q = [mytuple(1,2), yourtuple(5,6)]
>>> q
[A(a=1, b=2), Z(x=5, y=6)]
>>> reduce(operator.__add__, q)
(1, 2, 5, 6)

所以,namedtuple是一个有趣的子类型tuple.

动态添加属性

如果您考虑通过调用它们来为类添加一些属性,这可能会很有用.这可以通过覆盖__getattribute__使用点操作数时调用的成员函数来完成.所以,让我们看一个虚拟类,例如:

class Dummy(object):
    def __getattribute__(self, name):
        f = lambda: 'Hello with %s'%name
        return f

当您实例化Dummy对象并执行方法调用时,您将获得以下内容:

>>> d = Dummy()
>>> d.b()
'Hello with b'

最后,您甚至可以将属性设置为您的类,以便可以动态定义它.如果您使用Python Web框架并希望通过解析属性的名称来执行查询,这可能很有用.

我有一个关于github 的要点,这个简单的代码和它在Ruby上由朋友制作.

照顾自己!

平展list用sum().

该sum()内置函数可用于小号一起,提供了一种方便的方法,以一个扁平化的S:__add__ listlistlist

Python 2.7.1 (r271:86832, May 27 2011, 21:41:45) 
[GCC 4.2.1 (Apple Inc. build 5664)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> l = [[1, 2, 3], [4, 5], [6], [7, 8, 9]]
>>> sum(l, [])
[1, 2, 3, 4, 5, 6, 7, 8, 9]

博格模式

这是Alex Martelli的杀手.Borg共享状态的所有实例.这消除了使用单例模式的需要(实例在共享状态时无关紧要)并且相当优雅(但新类更复杂).

foo可以在任何实例中重新分配值,并且所有值都将更新,您甚至可以重新分配整个dict.博格是一个完美的名字,在这里阅读更多.

class Borg:
    __shared_state = {'foo': 'bar'}
    def __init__(self):
        self.__dict__ = self.__shared_state
    # rest of your class here

这非常适合共享eventlet.GreenPool来控制并发性.

pdb - Python调试器

作为程序员,严肃的程序开发需要的第一件事就是调试器.Python有一个内置的,可以作为一个名为pdb的模块使用(对于"Python DeBugger",当然!).

http://docs.python.org/library/pdb.html

threading.enumerate()允许访问系统中的所有Thread对象,sys._current_frames()返回系统中所有线程的当前堆栈帧,因此将这两者结合起来,您将获得Java样式堆栈转储:

def dumpstacks(signal, frame):
    id2name = dict([(th.ident, th.name) for th in threading.enumerate()])
    code = []
    for threadId, stack in sys._current_frames().items():
        code.append("\n# Thread: %s(%d)" % (id2name[threadId], threadId))
        for filename, lineno, name, line in traceback.extract_stack(stack):
            code.append('File: "%s", line %d, in %s' % (filename, lineno, name))
            if line:
                code.append("  %s" % (line.strip()))
    print "\n".join(code)

import signal
signal.signal(signal.SIGQUIT, dumpstacks)

在多线程python程序的开头执行此操作,您可以通过发送SIGQUIT随时访问当前线程状态.您也可以选择signal.SIGUSR1或signal.SIGUSR2.

看到

... dict.get()具有默认值 None,从而避免了KeyErrors:

In [1]: test = { 1 : 'a' }

In [2]: test[2]
---------------------------------------------------------------------------
              Traceback (most recent call last)

<ipython console> in ()

: 2

In [3]: test.get( 2 )

In [4]: test.get( 1 )
Out[4]: 'a'

In [5]: test.get( 2 ) == None
Out[5]: True

甚至在现场指定这个:

In [6]: test.get( 2, 'Some' ) == 'Some'
Out[6]: True

你可以使用setdefault()来设置一个值,如果它不存在则返回:

>>> a = {}
>>> b = a.setdefault('foo', 'bar')
>>> a
{'foo': 'bar'}
>>> b
'bar

检查模块也是一个很酷的功能.

重新加载模块可实现"实时编码"风格.但是类实例不会更新.这就是原因,以及如何解决它.记住,一切,是的,一切都是一个对象.

>>> from a_package import a_module
>>> cls = a_module.SomeClass
>>> obj = cls()
>>> obj.method()
(old method output)

现在,您更改了a_module.py中的方法,并希望更新您的对象.

>>> reload(a_module)
>>> a_module.SomeClass is cls
False # Because it just got freshly created by reload.
>>> obj.method()
(old method output)

这是更新它的一种方法(但考虑用剪刀运行):

>>> obj.__class__ is cls
True # it's the old class object
>>> obj.__class__ = a_module.SomeClass # pick up the new class
>>> obj.method()
(new method output)

这是"用剪刀运行",因为对象的内部状态可能与新类所期望的不同.这适用于非常简单的情况,但除此之外,pickle是你的朋友.但是,了解其原因仍然有用.

原始字符串中的反斜杠仍然可以转义引号.看到这个:

>>> print repr(r"aaa\"bbb")
'aaa\\"bbb'

请注意,反斜杠和双引号都出现在最终字符串中.

因此,您无法使用反斜杠结束原始字符串:

>>> print repr(r"C:\")
SyntaxError: EOL while scanning string literal
>>> print repr(r"C:\"")
'C:\\"'

发生这种情况是因为实现了原始字符串以帮助编写正则表达式,而不是编写Windows路径.在Gotcha中阅读关于此的长篇讨论- Windows文件名中的反斜杠.

操作符可以作为函数调用:

from operator import add
print reduce(add, [1,2,3,4,5,6])

列表中的无限递归

>>> a = [1,2]
>>> a.append(a)
>>> a
[1, 2, [...]]
>>> a[2]
[1, 2, [...]]
>>> a[2][2][2][2][2][2][2][2][2] == a
True

能够替换文件删除,文件打开等内容 - 直接操作语言库.这在测试时是一个巨大的优势.您不必将所有内容都包装在复杂的容器中.只需替换一个函数/方法然后去.这也称为猴子修补.

内置方法或函数不实现描述符协议,这使得无法执行以下操作:

>>> class C(object):
...  id = id
... 
>>> C().id()
Traceback (most recent call last):
  File "", line 1, in 
TypeError: id() takes exactly one argument (0 given)

但是,您可以创建一个小的绑定描述符,使其成为可能:

>>> from types import MethodType
>>> class bind(object):
...  def __init__(self, callable):
...   self.callable = callable
...  def __get__(self, obj, type=None):
...   if obj is None:
...    return self
...   return MethodType(self.callable, obj, type)
... 
>>> class C(object):
...  id = bind(id)
... 
>>> C().id()
7414064

嵌套函数参数重新绑定

def create_printers(n):
    for i in xrange(n):
        def printer(i=i): # Doesn't work without the i=i
            print i
        yield printer

您可以使用元类覆盖类的mro

>>> class A(object):
...     def a_method(self):
...         print("A")
... 
>>> class B(object):
...     def b_method(self):
...         print("B")
... 
>>> class MROMagicMeta(type):
...     def mro(cls):
...         return (cls, B, object)
... 
>>> class C(A, metaclass=MROMagicMeta):
...     def c_method(self):
...         print("C")
... 
>>> cls = C()
>>> cls.c_method()
C
>>> cls.a_method()
Traceback (most recent call last):
 File "", line 1, in 
AttributeError: 'C' object has no attribute 'a_method'
>>> cls.b_method()
B
>>> type(cls).__bases__
(,)
>>> type(cls).__mro__
(, , )

这可能是有充分理由隐藏的.:)

小整数(-5 .. 256)的对象从未创建过两次:

>>> a1 = -5; b1 = 256
>>> a2 = -5; b2 = 256
>>> id(a1) == id(a2), id(b1) == id(b2)
(True, True)
>>>
>>> c1 = -6; d1 = 257
>>> c2 = -6; d2 = 257
>>> id(c1) == id(c2), id(d1) == id(d2)
(False, False)
>>>

编辑:列表对象永不销毁(仅列表中的对象).Python有一个数组,它可以保存多达80个空列表.当您销毁列表对象时 - python将它放到该数组中,当您创建新列表时 - python从此数组中获取最后的列表:

>>> a = [1,2,3]; a_id = id(a)
>>> b = [1,2,3]; b_id = id(b)
>>> del a; del b
>>> c = [1,2,3]; id(c) == b_id
True
>>> d = [1,2,3]; id(d) == a_id
True
>>>

您可以使用类来装饰函数 - 用类实例替换函数:

class countCalls(object):
    """ decorator replaces a function with a "countCalls" instance
    which behaves like the original function, but keeps track of calls

    >>> @countCalls
    ... def doNothing():
    ...     pass
    >>> doNothing()
    >>> doNothing()
    >>> print doNothing.timesCalled
    2
    """
    def __init__ (self, functionToTrack):
        self.functionToTrack = functionToTrack
        self.timesCalled = 0
    def __call__ (self, *args, **kwargs):
        self.timesCalled += 1
        return self.functionToTrack(*args, **kwargs)

操纵递归限制

使用sys.getrecursionlimit()和sys.setrecursionlimit()获取或设置最大递归深度.

我们可以限制它以防止由无限递归引起的堆栈溢出.

切片和可变性

复制列表

>>> x = [1,2,3]
>>> y = x[:]
>>> y.pop()
3
>>> y
[1, 2]
>>> x
[1, 2, 3]

替换列表

>>> x = [1,2,3]
>>> y = x
>>> y[:] = [4,5,6]
>>> x
[4, 5, 6]

如果在序列的最后一个元素之后找到,则Python 2.x会忽略逗号:

>>> a_tuple_for_instance = (0,1,2,3,)
>>> another_tuple = (0,1,2,3)
>>> a_tuple_for_instance == another_tuple
True

尾随逗号会将单个带括号的元素视为序列:

>>> a_tuple_with_one_element = (8,)

切片作为左值.这个Eratosthenes筛选器生成一个具有素数或0的列表.元素在循环中使用切片赋值为0.

def eras(n):
    last = n + 1
    sieve = [0,0] + list(range(2, last))
    sqn = int(round(n ** 0.5))
    it = (i for i in xrange(2, sqn + 1) if sieve[i])
    for i in it:
        sieve[i*i:last:i] = [0] * (n//i - i + 1)
    return filter(None, sieve)

要工作,必须在左侧的切片上指定相同长度右侧的列表.

舍入整数:Python具有round函数,返回double类型的数字:

 >>> print round(1123.456789, 4)
1123.4568
 >>> print round(1123.456789, 2)
1123.46
 >>> print round(1123.456789, 0)
1123.0

这个功能有一个很棒的魔法属性:

 >>> print round(1123.456789, -1)
1120.0
 >>> print round(1123.456789, -2)
1100.0

如果你需要一个整数作为结果使用int来转换类型:

 >>> print int(round(1123.456789, -2))
1100
 >>> print int(round(8359980, -2))
8360000

谢谢Gregor.

列表理解

列表理解

比较更传统(没有列表理解):

foo = []
for x in xrange(10):
  if x % 2 == 0:
     foo.append(x)

至:

foo = [x for x in xrange(10) if x % 2 == 0]

懒得初始化字典中的每个字段？没问题:

在Python> 2.3中:

from collections import defaultdict

在Python <= 2.3中:

def defaultdict(type_):
    class Dict(dict):
        def __getitem__(self, key):
            return self.setdefault(key, type_())
    return Dict()

在任何版本中:

d = defaultdict(list)
for stuff in lots_of_stuff:
     d[stuff.name].append(stuff)

更新:

感谢肯·阿诺德.我重新实现了一个更复杂的defaultdict版本.它应该与标准库中的行为完全相同.

def defaultdict(default_factory, *args, **kw):                              

    class defaultdict(dict):

        def __missing__(self, key):
            if default_factory is None:
                raise KeyError(key)
            return self.setdefault(key, default_factory())

        def __getitem__(self, key):
            try:
                return dict.__getitem__(self, key)
            except KeyError:
                return self.__missing__(key)

    return defaultdict(*args, **kw)

如果你在你的类上使用描述符,Python完全绕过__dict__该键,这使它成为存储这些值的好地方:

>>> class User(object):
...  def _get_username(self):
...   return self.__dict__['username']
...  def _set_username(self, value):
...   print 'username set'
...   self.__dict__['username'] = value
...  username = property(_get_username, _set_username)
...  del _get_username, _set_username
... 
>>> u = User()
>>> u.username = "foo"
username set
>>> u.__dict__
{'username': 'foo'}

这有助于保持dir()清洁.

__getattr __()

getattr制作泛型类是一种非常好的方法,这在编写API时特别有用.例如,在FogBugz Python API中,getattr用于无缝地将方法调用传递给Web服务:

class FogBugz:
    ...

    def __getattr__(self, name):
        # Let's leave the private stuff to Python
        if name.startswith("__"):
            raise AttributeError("No such attribute '%s'" % name)

        if not self.__handlerCache.has_key(name):
            def handler(**kwargs):
                return self.__makerequest(name, **kwargs)
            self.__handlerCache[name] = handler
        return self.__handlerCache[name]
    ...

当有人打电话时FogBugz.search(q='bug'),他们实际上并没有调用search方法.相反,getattr通过创建一个包装makerequest方法的新函数来处理调用,该函数为Web API提供适当的HTTP请求.任何错误都将由Web服务调度并传递回用户.

进口反重力

暴露可变缓冲区

使用Python 缓冲协议,以暴露可变面向字节的缓冲器在Python(2.5/2.6).

(对不起,此处没有代码.需要使用低级C API或现有适配器模块).

pythonic成语x = ... if ... else ...远远优于x = ... and ... or ...,这就是为什么:

声明虽然如此

x = 3 if (y == 1) else 2

相当于

x = y == 1 and 3 or 2

如果你使用这个x = ... and ... or ...成语,有一天你可能会被这种棘手的情况所困扰:

x = 0 if True else 1    # sets x equal to 0

因此不等同于

x = True and 0 or 1   # sets x equal to 1

有关正确执行此操作的更多信息,请参阅Python的隐藏功能.

Monkeypatching对象

Python中的每个对象都有一个__dict__成员,用于存储对象的属性.所以,你可以这样做:

class Foo(object):
    def __init__(self, arg1, arg2, **kwargs):
        #do stuff with arg1 and arg2
        self.__dict__.update(kwargs)

f = Foo('arg1', 'arg2', bar=20, baz=10)
#now f is a Foo object with two extra attributes

这可以被利用来任意地向对象添加属性和功能.这也可以被利用来创建一个快速和肮脏的struct类型.

class struct(object):
    def __init__(**kwargs):
       self.__dict__.update(kwargs)

s = struct(foo=10, bar=11, baz="i'm a string!')

我不确定它在Python文档中的位置(或者是否),但是对于python 2.x(至少2.5和2.6,我刚试过),print可以使用parenthenses调用该语句.如果您希望能够轻松地将一些Python 2.x代码移植到Python 3.x,这将非常有用.

示例: print('We want Moshiach Now')应该We want Moshiach Now在python 2.5,2.6和3.x中打印工作.

此外,not可以在Python 2和3中使用parenthenses调用运算符: not False 并且 not(False) 都应该返回True.

parenthenses也可以与其他语句和运算符一起使用.

编辑:不是一个好主意把括号放在not运算符(可能还有其他运算符)周围,因为它可以产生令人惊讶的情况,就像这样(这种情况发生是因为括号只是真的围绕着1):

>>> (not 1) == 9
False

>>> not(1) == 9
True

对于某些值(我认为它不是有效的标识符名称),这也可以工作,如下所示: not'val'应该返回False,并且print'We want Moshiach Now'应该返回We want Moshiach Now.(但not552会引发NameError,因为它是一个有效的标识符名称).

除了之前由haridsv提到的:

>>> foo = bar = baz = 1
>>> foo, bar, baz
(1, 1, 1)

它也可以这样做:

>>> foo, bar, baz = 1, 2, 3
>>> foo, bar, baz
(1, 2, 3)

getattr 采用第三个参数

getattr(obj, attribute_name, default) 就好像:

try:
    return obj.attribute
except AttributeError:
    return default

除了attribute_name可以是任何字符串.

这对于鸭子打字非常有用.也许你有类似的东西:

class MyThing:
    pass
class MyOtherThing:
    pass
if isinstance(obj, (MyThing, MyOtherThing)):
    process(obj)

(顺便说一下,isinstance(obj, (a,b))意思是isinstance(obj, a) or isinstance(obj, b).)

当你创造一种新的东西时,你需要在它出现的任何地方将它添加到那个元组.(这种结构在重新加载模块或以两个名字导入同一个文件时也会引起问题.它发生的次数比人们喜欢的要多.)但你可以说:

class MyThing:
    processable = True
class MyOtherThing:
    processable = True
if getattr(obj, 'processable', False):
    process(obj)

添加继承并且它变得更好:所有可处理对象的示例都可以继承

class Processable:
    processable = True

但是你不必说服每个人继承你的基类,只是为了设置一个属性.

简单的内置基准测试工具

Python标准库附带了一个非常易于使用的基准测试模块,名为"timeit".您甚至可以从命令行使用它来查看哪种语言结构最快.

例如,

% python -m timeit 'r = range(0, 1000)' 'for i in r: pass'
10000 loops, best of 3: 48.4 usec per loop

% python -m timeit 'r = xrange(0, 1000)' 'for i in r: pass'
10000 loops, best of 3: 37.4 usec per loop

这是2个复活节彩蛋:

一个在python本身:

>>> import __hello__
Hello world...

Werkzeug模块中的另一个,有点复杂,这里是:

通过查看Werkzeug源代码,werkzeug/__init__.py有一行应引起你的注意:

'werkzeug._internal':   ['_easteregg']

如果你有点好奇,这应该让你看看werkzeug/_internal.py,那里,你会找到一个_easteregg()函数,它在参数中使用wsgi应用程序,它还包含一些base64编码数据和2个嵌套函数,似乎如果macgybarchakku在查询字符串中找到了名为的参数,则执行一些特殊操作.

所以,为了揭示这个复活节彩蛋,你似乎需要在_easteregg()函数中包装一个应用程序,让我们走吧:

from werkzeug import Request, Response, run_simple
from werkzeug import _easteregg

@Request.application
def application(request):
    return Response('Hello World!')

run_simple('localhost', 8080, _easteregg(application))

现在,如果你运行应用程序并访问http:// localhost:8080 /？macgybarchakku,你应该看到复活节彩蛋.

Dict理解

>>> {i: i**2 for i in range(5)}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Python文档

维基百科条目

设置理解

>>> {i**2 for i in range(5)}                                                       
set([0, 1, 4, 16, 9])

Python文档

维基百科条目