主要信息:)

import this
# btw look at this module's source :)

De-cyphered:

蒂姆·彼得斯的《Python之禅》 美总比丑好。 显性比隐性好。 简单比复杂好。 复杂胜过复杂。 扁平比嵌套好。 稀疏比密集好。 可读性。 特殊情况并不特别到可以打破规则。 尽管实用性胜过纯洁性。 错误绝不能悄无声息地过去。 除非明确保持沉默。 面对模棱两可，拒绝猜测的诱惑。 应该有一种——最好只有一种——明显的方法来做到这一点。 除非你是荷兰人，否则这种方式一开始可能并不明显。 现在总比没有好。 虽然永远不比现在更好。 如果实现很难解释，那就是一个坏主意。 如果实现很容易解释，这可能是一个好主意。 名称空间是一个非常棒的想法——让我们多做一些吧!

列表理解

列表理解

比较更传统的(不含列表理解):

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

to:

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

Metaclasses

Python中的元类是什么?

特殊的方法

绝对的权力!

创建生成器对象

如果你写

x=(n for n in foo if bar(n))

你可以取出生成器，把它赋值给x，这意味着你可以这样做

for n in x:

这样做的优点是不需要中间存储，如果需要中间存储，则需要中间存储

x = [n for n in foo if bar(n)]

在某些情况下，这可以显著提高速度。

你可以在生成器的末尾附加许多if语句，基本上复制嵌套的for循环:

>>> n = ((a,b) for a in range(0,2) for b in range(4,6))
>>> for i in n:
...   print i 

(0, 4)
(0, 5)
(1, 4)
(1, 5)

修饰符

装饰器允许将一个函数或方法包装在另一个函数中，该函数可以添加功能、修改参数或结果等。在函数定义的上方一行编写装饰符，以“at”符号(@)开始。

示例显示了一个print_args装饰器，它在调用被装饰函数之前打印函数的参数:

>>> def print_args(function):
>>>     def wrapper(*args, **kwargs):
>>>         print 'Arguments:', args, kwargs
>>>         return function(*args, **kwargs)
>>>     return wrapper

>>> @print_args
>>> def write(text):
>>>     print text

>>> write('foo')
Arguments: ('foo',) {}
foo

可读正则表达式

在Python中，您可以将正则表达式拆分为多行，命名匹配并插入注释。

示例详细语法(来自Python):

>>> pattern = """
... ^                   # beginning of string
... M{0,4}              # thousands - 0 to 4 M's
... (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
...                     #            or 500-800 (D, followed by 0 to 3 C's)
... (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
...                     #        or 50-80 (L, followed by 0 to 3 X's)
... (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
...                     #        or 5-8 (V, followed by 0 to 3 I's)
... $                   # end of string
... """
>>> re.search(pattern, 'M', re.VERBOSE)

命名匹配示例(摘自正则表达式HOWTO)

>>> p = re.compile(r'(?P<word>\b\w+\b)')
>>> m = p.search( '(((( Lots of punctuation )))' )
>>> m.group('word')
'Lots'

由于字符串字面值的串联，你也可以在不使用re.VERBOSE的情况下详细地编写一个正则表达式。

>>> pattern = (
...     "^"                 # beginning of string
...     "M{0,4}"            # thousands - 0 to 4 M's
...     "(CM|CD|D?C{0,3})"  # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
...                         #            or 500-800 (D, followed by 0 to 3 C's)
...     "(XC|XL|L?X{0,3})"  # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
...                         #        or 50-80 (L, followed by 0 to 3 X's)
...     "(IX|IV|V?I{0,3})"  # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
...                         #        or 5-8 (V, followed by 0 to 3 I's)
...     "$"                 # end of string
... )
>>> print pattern
"^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$"

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

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

它们可以替换大量嵌套循环代码。

模块操作符中的Getter函数

模块操作符中的函数attrgetter()和itemgetter()可用于生成用于排序和搜索对象和字典的快速访问函数

Python库文档中的第6.7章

将值发送到生成器函数。例如有这样的函数:

def mygen():
    """Yield 5 until something else is passed back via send()"""
    a = 5
    while True:
        f = (yield a) #yield a and possibly get f in return
        if f is not None: 
            a = f  #store the new value

您可以:

>>> g = mygen()
>>> g.next()
5
>>> g.next()
5
>>> g.send(7)  #we send this back to the generator
7
>>> g.next() #now it will yield 7 until we send something else
7

能够替换甚至像文件删除，文件打开等-语言库的直接操作。这在测试时是一个巨大的优势。你不必把所有东西都包装在复杂的容器里。只需要替换一个函数/方法就可以了。这也被称为猴子修补。

>>> x=[1,1,2,'a','a',3]
>>> y = [ _x for _x in x if not _x in locals()['_[1]'] ]
>>> y
[1, 2, 'a', 3]

"locals()['_[1]']"是正在创建的列表的"秘密名称"。当正在构建的列表状态影响后续构建决策时非常有用。

切片运算符中的step参数。例如:

a = [1,2,3,4,5]
>>> a[::2]  # iterate over the whole list in 2-increments
[1,3,5]

特殊情况x[::-1]是“x反转”的有用习语。

>>> a[::-1]
[5,4,3,2,1]

隐式连接:

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

当你想让一个很长的文本适合脚本中的几行时很有用:

hello = "Greaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa Hello " \
        "Word"

or

hello = ("Greaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa Hello " 
         "Word")

可以使用属性使类接口更加严格。

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

要了解属性如何工作的更多信息，请参阅描述符。

链接比较操作符:

>>> x = 5
>>> 1 < x < 10
True
>>> 10 < x < 20 
False
>>> x < 10 < x*10 < 100
True
>>> 10 > x <= 9
True
>>> 5 == x > 4
True

如果你认为它在做1 < x，结果是True，然后比较True < 10，这也是True，那么不，这真的不是发生的事情(见最后一个例子)。它实际上转化为1 < x和x < 10，以及x < 10和10 < x*10和x*10 < 100，但是类型更少，每个项只计算一次。

一切都是动态的

“没有编译时”。Python中的一切都是运行时。模块是通过从上到下执行模块的源代码来“定义”的，就像脚本一样，得到的命名空间是模块的属性空间。类似地，类是通过从上到下执行类主体来“定义”的，生成的名称空间是类的属性空间。类主体可以包含完全任意的代码——包括导入语句、循环和其他类语句。像有时要求的那样，“动态”创建一个类、函数甚至模块并不难;事实上，这是不可能避免的，因为一切都是“动态的”。

Re-raising例外:

# Python 2 syntax
try:
    some_operation()
except SomeError, e:
    if is_fatal(e):
        raise
    handle_nonfatal(e)

# Python 3 syntax
try:
    some_operation()
except SomeError as e:
    if is_fatal(e):
        raise
    handle_nonfatal(e)

错误处理程序中不带参数的“raise”语句告诉Python在原始回溯完整的情况下重新引发异常，允许你说“哦，对不起，对不起，我不是有意捕捉那个，对不起，对不起。”

如果你想打印、存储或修改原始的traceback，你可以使用sys.exc_info()来获取它，并且像Python一样使用'traceback'模块来打印它。

就地值交换

>>> a = 10
>>> b = 5
>>> a, b
(10, 5)

>>> a, b = b, a
>>> a, b
(5, 10)

赋值语句的右边是一个表达式，用于创建一个新的元组。赋值的左边立即将(未引用的)元组解包为名称a和b。

赋值之后，新的元组不被引用，并标记为垃圾收集，绑定到a和b的值已经交换。

正如Python教程中关于数据结构的部分所述，

注意，多重赋值实际上只是元组打包和序列解包的组合。

描述符

它们是一大堆核心Python特性背后的魔力。

当您使用点访问来查找成员(例如x.y)时，Python首先在实例字典中查找成员。如果没有找到，则在类字典中查找。如果它在类字典中找到它，并且对象实现了描述符协议，而不是仅仅返回它，Python就会执行它。描述符是任何实现__get__、__set__或__delete__方法的类。

下面是如何使用描述符实现自己的(只读)属性版本:

class Property(object):
    def __init__(self, fget):
        self.fget = fget

    def __get__(self, obj, type):
        if obj is None:
            return self
        return self.fget(obj)

你可以像使用内置属性()一样使用它:

class MyClass(object):
    @Property
    def foo(self):
        return "Foo!"

在Python中，描述符用于实现属性、绑定方法、静态方法、类方法和插槽等。理解它们可以很容易地理解为什么以前看起来像Python“怪癖”的很多东西是这样的。

Raymond Hettinger有一个很棒的教程，在描述它们方面比我做得更好。

Doctest:同时进行文档和单元测试。

从Python文档中提取的示例:

def factorial(n):
    """Return the factorial of n, an exact integer >= 0.

    If the result is small enough to fit in an int, return an int.
    Else return a long.

    >>> [factorial(n) for n in range(6)]
    [1, 1, 2, 6, 24, 120]
    >>> factorial(-1)
    Traceback (most recent call last):
        ...
    ValueError: n must be >= 0

    Factorials of floats are OK, but the float must be an exact integer:
    """

    import math
    if not n >= 0:
        raise ValueError("n must be >= 0")
    if math.floor(n) != n:
        raise ValueError("n must be exact integer")
    if n+1 == n:  # catch a value like 1e300
        raise OverflowError("n too large")
    result = 1
    factor = 2
    while factor <= n:
        result *= factor
        factor += 1
    return result

def _test():
    import doctest
    doctest.testmod()    

if __name__ == "__main__":
    _test()

Iter()可以接受一个可调用参数

例如:

def seek_next_line(f):
    for c in iter(lambda: f.read(1),'\n'):
        pass

iter(callable, until_value)函数反复调用callable并生成结果，直到返回until_value。

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

在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解释器

>>> 

也许不是不太为人所知，但肯定是我最喜欢的Python特性之一。

一级函数

这并不是一个隐藏的特性，但函数是第一类对象这一事实非常棒。你可以像传递其他变量一样传递它们。

>>> 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".'

以完全动态的方式创建新类型

>>> NewType = type("NewType", (object,), {"x": "hello"})
>>> n = NewType()
>>> n.x
"hello"

哪个是完全一样的

>>> class NewType(object):
>>>     x = "hello"
>>> n = NewType()
>>> n.x
"hello"

可能不是最有用的东西，但很高兴知道。

编辑:新类型的固定名称，应该是NewType，是与类语句完全相同的东西。

编辑:调整标题，以更准确地描述功能。

在列表推导式中交错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)]

直到我学了哈斯克尔，我才意识到这一点。

上下文管理器和“with”语句

在PEP 343中引入的上下文管理器是作为一组语句的运行时上下文的对象。

由于该特性使用了新的关键字，它是逐渐引入的:在Python 2.5中通过__future__指令可用。Python 2.6及以上版本(包括Python 3)默认情况下可用。

我经常使用“with”语句，因为我认为这是一个非常有用的结构，下面是一个快速演示:

from __future__ import with_statement

with open('foo.txt', 'w') as f:
    f.write('hello!')

这里在幕后发生的事情是，“with”语句在文件对象上调用特殊的__enter__和__exit__方法。如果with语句体引发任何异常，异常细节也会传递给__exit__，允许在那里进行异常处理。

在这种特殊情况下，这为您做的是，当执行超出with套件的范围时，它保证关闭文件，无论这是正常发生还是抛出异常。它基本上是一种抽象出常见异常处理代码的方法。

其他常见的用例包括线程锁定和数据库事务。

一些内置的收藏夹，map()， reduce()和filter()。所有这些都非常快速和强大。

函数参数解包

可以使用*和**将列表或字典解包为函数参数。

例如:

def draw_point(x, y):
    # do some magic

point_foo = (3, 4)
point_bar = {'y': 3, 'x': 2}

draw_point(*point_foo)
draw_point(**point_bar)

非常有用的快捷方式，因为列表、元组和字典被广泛用作容器。

字典有一个get()方法

字典有一个'get()'方法。如果你执行d['key']而key不存在，你会得到一个异常。如果执行d.t get('key')，如果'key'不存在，则返回None。您可以添加第二个参数来返回该项，而不是None，例如:d.t get('key'， 0)。

它非常适合做数字相加这样的事情:

Sum [value] = Sum。Get (value, 0) + 1

如果在函数中使用exec，变量查找规则将发生巨大变化。闭包不再可能，但Python允许在函数中使用任意标识符。这为您提供了一个“可修改的locals()”，并可用于星型导入标识符。缺点是，它会使每次查找都变慢，因为变量最终会在字典中而不是在帧中的槽中结束:

>>> def f():
...  exec "a = 42"
...  return a
... 
>>> def g():
...  a = 42
...  return a
... 
>>> import dis
>>> dis.dis(f)
  2           0 LOAD_CONST               1 ('a = 42')
              3 LOAD_CONST               0 (None)
              6 DUP_TOP             
              7 EXEC_STMT           

  3           8 LOAD_NAME                0 (a)
             11 RETURN_VALUE        
>>> dis.dis(g)
  2           0 LOAD_CONST               1 (42)
              3 STORE_FAST               0 (a)

  3           6 LOAD_FAST                0 (a)
              9 RETURN_VALUE        

从2.5开始字典有一个特殊的方法__missing__，用于调用缺少的项:

>>> class MyDict(dict):
...  def __missing__(self, key):
...   self[key] = rv = []
...   return rv
... 
>>> m = MyDict()
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{'foo': [1, 2]}

在集合中还有一个名为defaultdict的dict子类，它做了几乎相同的事情，但对于不存在的项调用了一个不带参数的函数:

>>> from collections import defaultdict
>>> m = defaultdict(list)
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{'foo': [1, 2]}

我建议将这些字典转换为常规字典，然后再将它们传递给不需要此类子类的函数。许多代码使用d[a_key]并捕获KeyErrors来检查是否存在一个项，这将向dict添加一个新项。

如果你在你的类上使用描述符，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()干净。

如果你不喜欢使用空格来表示作用域，你可以通过发出以下命令来使用c风格{}:

from __future__ import braces

__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}

然而，如果point被子类化并且添加了新的槽，这将不起作用。但是Python会自动实现__reduce_ex__来帮助复制模块。这可以被滥用来获得价值的字典:

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

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

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

不幸的是，它几乎没有什么用处，因为只有在涉及元组时才支持省略号。

内置方法或函数不实现描述符协议，这使得不可能做这样的事情:

>>> class C(object):
...  id = id
... 
>>> C().id()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
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

命名格式

% -formatting接受字典(也应用%i/%s等验证)。

>>> print "The %(foo)s is %(bar)i." % {'foo': 'answer', 'bar':42}
The answer is 42.

>>> foo, bar = 'question', 123

>>> print "The %(foo)s is %(bar)i." % locals()
The question is 123.

由于locals()也是一个字典，您可以简单地将其作为字典传递，并从局部变量中获得% -替换。我认为这是不受欢迎的，但简化了事情。

新的样式格式

>>> print("The {foo} is {bar}".format(foo='answer', bar=42))

小心可变默认参数

>>> def foo(x=[]):
...     x.append(1)
...     print x
... 
>>> foo()
[1]
>>> foo()
[1, 1]
>>> foo()
[1, 1, 1]

相反，你应该使用一个表示“not given”的哨兵值，并将其替换为你想要的默认值:

>>> def foo(x=None):
...     if x is None:
...         x = []
...     x.append(1)
...     print x
>>> foo()
[1]
>>> foo()
[1]

元组拆包:

>>> (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)

在Python中解压缩不需要的文件

有人在博客上说Python没有zip()的解压缩函数。Unzip的计算很简单，因为:

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

但经过反思，我宁愿使用显式的unzip()。

为了添加更多的python模块(特别是第三方模块)，大多数人似乎使用PYTHONPATH环境变量，或者在他们的site-packages目录中添加符号链接或目录。另一种方法是使用*.pth文件。以下是python官方文档的解释:

“这是最方便的修改方式 Python的搜索路径]是添加一个路径 配置文件到一个目录 已经在Python的路径上了， 通常到…/site-packages/ 目录中。路径配置文件 扩展名为。pth，每个 行必须包含一个单独的路径 将被追加到sys.path。(因为 新路径被附加到 sys。路径，模块在添加 目录将不会覆盖标准 模块。这意味着你不能使用这个 安装固定机构 标准模块的版本。)

例外else条款:

try:
  put_4000000000_volts_through_it(parrot)
except Voom:
  print "'E's pining!"
else:
  print "This parrot is no more!"
finally:
  end_sketch()

使用else子句比在try子句中添加额外的代码更好，因为它可以避免意外地捕获由try保护的代码所没有引发的异常。除了声明。

参见http://docs.python.org/tut/node10.html

为…Else语法(参见http://docs.python.org/ref/for.html)

for i in foo:
    if i == 0:
        break
else:
    print("i was never 0")

除非调用break，否则"else"块通常会在for循环的末尾执行。

以上代码可以模拟如下:

found = False
for i in foo:
    if i == 0:
        found = True
        break
if not found: 
    print("i was never 0")

很多人不知道dir函数。这是一种很好的方法，可以从解释器中找出对象可以做什么。例如，如果你想查看所有字符串方法的列表:

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

然后，如果你想要关于某个方法的更多信息，你可以在它上面调用“help”。

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

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

    Return a copy of the string S converted to uppercase.

按以下方式访问字典元素 属性(属性)。所以如果 a1=AttrDict()有键'name' -> 而不是a1['name']，我们可以很容易 使用->访问a1的名称属性 a1.name

class AttrDict(dict):

    def __getattr__(self, name):
        if name in self:
            return self[name]
        raise AttributeError('%s not found' % name)

    def __setattr__(self, name, value):
        self[name] = value

    def __delattr__(self, name):
        del self[name]

person = AttrDict({'name': 'John Doe', 'age': 66})
print person['name']
print person.name

person.name = 'Frodo G'
print person.name

del person.age

print person

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

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

如果您想先按年龄再按姓名对人员列表进行排序，则非常有用。

条件赋值

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

正如它听起来的那样:“如果y是1，则赋3给x，否则赋2给x”。注意，括号不是必需的，但是为了可读性，我喜欢它们。如果你有更复杂的东西，你也可以把它串起来:

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

虽然在某种程度上，这有点太过分了。

注意，你可以使用if…任何表达式中的Else。例如:

(func1 if y == 1 else func2)(arg1, arg2) 

这里，如果y = 1调用func1，否则调用func2。在这两种情况下，对应的函数将调用参数arg1和arg2。

类似地，以下也成立:

x = (class1 if y == 1 else class2)(arg1, arg2)

其中class1和class2是两个类。

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

>>> (a for a in xrange(10000))
<generator object at 0x81a8fcc>
>>> b = 'blah'
>>> _
<generator object at 0x81a8fcc>

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

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

内置的http服务器。提供当前目录下的文件:

python -m SimpleHTTPServer 8000

在退出

>>> import atexit

__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')时，他们实际上不会调用搜索方法。相反，getattr通过创建一个新函数来处理调用，该函数包装了makerequest方法，该方法将适当的HTTP请求发送给web API。任何错误都将由web服务分派并传递回用户。

列举

用enumerate包装一个可迭代对象，它将生成项目及其索引。

例如:

>>> a = ['a', 'b', 'c', 'd', 'e']
>>> for index, item in enumerate(a): print index, item
...
0 a
1 b
2 c
3 d
4 e
>>>

引用:

Python教程循环技术 Python文档-内置函数-枚举 PEP 279

三元运算符

>>> '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'

然而，如果你想要处理的值被认为是假的，有一个区别:

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

可以从一组长度为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}

元组在for循环、列表推导式和生成器表达式中的解包:

>>> l=[(1,2),(3,4)]
>>> [a+b for a,b in l ] 
[3,7]

在这个习语中，用于迭代字典中的(键，数据)对:

d = { 'x':'y', 'f':'e'}
for name, value in d.items():  # one can also use iteritems()
   print "name:%s, value:%s" % (name,value)

打印:

name:x, value:y
name:f, value:e

“解包”到函数参数

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

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

执行打印时:

3 14 15

布尔上下文中的对象

空元组、列表、字典、字符串和许多其他对象在布尔上下文中等价于False(非空对象等价于True)。

empty_tuple = ()
empty_list = []
empty_dict = {}
empty_string = ''
empty_set = set()
if empty_tuple or empty_list or empty_dict or empty_string or empty_set:
  print 'Never happens!'

这允许逻辑运算返回它的一个操作数，而不是True/False，这在某些情况下很有用:

s = t or "Default value" # s will be assigned "Default value"
                         # if t is false/empty/none

一切事物的一等性(“一切事物都是一个物体”)，以及这可能造成的混乱。

>>> x = 5
>>> y = 10
>>> 
>>> def sq(x):
...   return x * x
... 
>>> def plus(x):
...   return x + x
... 
>>> (sq,plus)[y>x](y)
20

最后一行创建一个包含这两个函数的元组，然后计算y>x (True)并将其作为元组的索引(通过将其强制转换为int类型，1)，然后使用参数y调用该函数并显示结果。

对于进一步的滥用，如果你返回一个带索引的对象(例如一个列表)，你可以在末尾添加更多的方括号;如果内容是可调用的，更多的括号，等等。为了更变态，使用这样的代码的结果作为另一个例子中的表达式(即用下面的代码替换y>x):

(sq,plus)[y>x](y)[4](x)

这展示了Python的两个方面——极端的“一切都是一个对象”哲学，以及不恰当或考虑不良的语言语法使用方法，可能导致完全不可读、不可维护的意大利面条代码，适合一个表达式。

分配和删除切片:

>>> 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])时，赋值的可迭代对象必须与片的长度相同。

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

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

获取python正则表达式解析树来调试正则表达式。

正则表达式是python的一个伟大特性，但调试它们可能是一件痛苦的事情，而且正则表达式很容易出错。

幸运的是，python可以通过将未记录的、实验性的隐藏标志re.DEBUG(实际上是128)传递给re.compile来打印正则表达式解析树。

>>> re.compile("^\[font(?:=(?P<size>[-+][0-9]{1,2}))?\](.*?)[/font]",
    re.DEBUG)
at at_beginning
literal 91
literal 102
literal 111
literal 110
literal 116
max_repeat 0 1
  subpattern None
    literal 61
    subpattern 1
      in
        literal 45
        literal 43
      max_repeat 1 2
        in
          range (48, 57)
literal 93
subpattern 2
  min_repeat 0 65535
    any None
in
  literal 47
  literal 102
  literal 111
  literal 110
  literal 116

一旦理解了语法，就可以发现错误。在这里我们可以看到，我忘记转义[/font]中的[]。

当然，你可以将它与任何你想要的标志组合在一起，比如注释正则表达式:

>>> re.compile("""
 ^              # start of a line
 \[font         # the font tag
 (?:=(?P<size>  # optional [font=+size]
 [-+][0-9]{1,2} # size specification
 ))?
 \]             # end of tag
 (.*?)          # text between the tags
 \[/font\]      # end of the tag
 """, re.DEBUG|re.VERBOSE|re.DOTALL)

内置base64, zlib和rot13编解码器

字符串有编码和解码方法。通常这用于将str转换为unicode，反之亦然，例如u = s.c 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'

当然，你也可以:

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

很明显，反重力模块。 xkcd # 353

发电机

我认为很多刚开始学习Python的开发人员在没有真正掌握生成器的用途或了解其功能的情况下就忽略了它们。直到我读了David M. Beazley关于生成器的PyCon演示(在这里可以找到)，我才意识到它们是多么有用(真的是必不可少)。这个演示对我来说是一种全新的编程方式，我把它推荐给任何对生成器没有深入了解的人。

交互式解释器选项卡补全

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.<TAB>
class_instance.__class__   class_instance.__module__
class_instance.__doc__     class_instance.function
>>> class_instance.f<TAB>unction()

您还必须设置一个PYTHONSTARTUP环境变量。

Python有GOTO

.．.它由外部的pure-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"

利用python的动态特性来创建应用程序 python语法的配置文件。例如，如果你有以下情况 在配置文件中:

{
  "name1": "value1",
  "name2": "value2"
}

然后你可以简单地这样读:

config = eval(open("filename").read())

嵌套函数参数重绑定

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

python的一个小错误。通常快速连接字符串列表的方法是，

''.join(list_of_strings)

进口反重力

私有方法和数据隐藏(封装)

在Python中有一个常见的习惯用法，即通过以下划线开头的名称来表示不打算成为类外部API一部分的方法和其他类成员。这很方便，在实践中效果很好，但它给人一种错误的印象，即Python不支持私有代码和/或数据的真正封装。事实上，Python会自动为您提供词法闭包，这使得在真正需要的情况下以更加防弹的方式封装数据变得非常容易。下面是一个使用这种技术的类的例子:

class MyClass(object):
  def __init__(self):

    privateData = {}

    self.publicData = 123

    def privateMethod(k):
      print privateData[k] + self.publicData

    def privilegedMethod():
      privateData['foo'] = "hello "
      privateMethod('foo')

    self.privilegedMethod = privilegedMethod

  def publicMethod(self):
    print self.publicData

这里有一个使用它的人为的例子:

>>> obj = MyClass()
>>> obj.publicMethod()
123
>>> obj.publicData = 'World'
>>> obj.publicMethod()
World
>>> obj.privilegedMethod()
hello World
>>> obj.privateMethod()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyClass' object has no attribute 'privateMethod'
>>> obj.privateData
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyClass' object has no attribute 'privateData'

关键是privateMethod和privateData根本不是obj的属性，所以它们不能从外部访问，也不会出现在dir()或类似的文件中。它们是构造函数中的局部变量，在__init__之外完全不可访问。然而，由于闭包的魔力，它们实际上是与它们关联的对象具有相同生命周期的每个实例变量，尽管除了(在本例中)调用privilegedMethod之外没有办法从外部访问它们。通常这种非常严格的封装是多余的，但有时它确实可以非常方便地保持API或名称空间的干净。

在Python 2中。在X中，拥有可变私有状态的唯一方法是使用可变对象(例如本例中的dict)。很多人都说这有多烦人。Python 3。x将通过引入PEP 3104中描述的nonlocal关键字来消除此限制。

使用关键字参数作为赋值

有时需要根据一个或多个参数构建一系列函数。然而，这很容易导致闭包都引用相同的对象和值:

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

对象实例的方法替换

您可以替换已经创建的对象实例的方法。它允许你创建具有不同(例外)功能的对象实例:

>>> class C(object):
...     def fun(self):
...         print "C.a", self
...
>>> inst = C()
>>> inst.fun()  # C.a method is executed
C.a <__main__.C object at 0x00AE74D0>
>>> instancemethod = type(C.fun)
>>>
>>> def fun2(self):
...     print "fun2", self
...
>>> inst.fun = instancemethod(fun2, inst, C)  # Now we are replace C.a by fun2
>>> inst.fun()  # ... and fun2 is executed
fun2 <__main__.C object at 0x00AE74D0>

C.a在inst实例中被fun2()取代(self没有改变)。

或者，我们也可以使用new模块，但它自Python 2.6起就被贬低了:

>>> def fun3(self):
...     print "fun3", self
...
>>> import new
>>> inst.fun = new.instancemethod(fun3, inst, C)
>>> inst.fun()
fun3 <__main__.C object at 0x00AE74D0>

节点:这个解决方案不应该被用作继承机制的一般替代!但在某些特定的情况下(调试、模拟)，它可能非常方便。

警告:此解决方案不适用于内置类型和使用插槽的新样式类。

引用一个列表理解，因为它正在构建…

你可以引用一个列表推导式，因为它是由符号'_[1]'构建的。例如，下面的函数通过引用列表推导式对元素列表进行惟一化，而不改变它们的顺序。

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

设置/ 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(). is子集()来判断一个列表是否是另一个列表的子集:

>>> 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

功能的支持。

特别是生成器和生成器表达式。

Ruby使它再次成为主流，但Python也可以做得一样好。在库中不像Ruby中那样普遍，这太糟糕了，但我更喜欢它的语法，它更简单。

因为它们不是那么普遍，我没有看到很多例子来说明它们为什么有用，但它们让我写出了更干净、更高效的代码。

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

从文件中引用…

>>> import pprint    
>>> stuff = sys.path[:]
>>> stuff.insert(0, stuff)
>>> pprint.pprint(stuff)
[<Recursion on list with id=869440>,
 '',
 '/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']

>>> 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]

不是真正的隐藏特性，但是partial对于函数的后期计算非常有用。

你可以在初始调用中绑定尽可能多的或尽可能少的参数到你想要的partial，并在以后使用任何剩余的参数调用它(在这个例子中，我已经将begin/end参数绑定到range，但第二次使用step arg调用它)

请参见文档。

is_ok() and "Yes" or "No"

.．.dict.get()有一个默认值None，从而避免KeyErrors:

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

In [2]: test[2]
---------------------------------------------------------------------------
<type 'exceptions.KeyError'>              Traceback (most recent call last)

&lt;ipython console&gt; in <module>()

<type 'exceptions.KeyError'>: 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

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

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

消极的圆

round()函数的作用是:将浮点数四舍五入为给定精度的十进制数字，但精度可以为负数:

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

注意:round()总是返回一个浮点数，str()在上面的例子中使用，因为浮点数学是不精确的，并且小于2。X第二个示例可以打印为1234.5700000000001。另请参阅十进制模块。

解释器中的解释器

标准库的code模块允许您在程序中包含自己的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来使用这个功能，你可以从这个WebConsole中查询你的实时web应用程序的状态。

操作符重载的集合内置:

>>> 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}

更多详细信息请参阅标准库参考:Set Types

您可以用元类重写类的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 "<stdin>", line 1, in <module>
AttributeError: 'C' object has no attribute 'a_method'
>>> cls.b_method()
B
>>> type(cls).__bases__
(<class '__main__.A'>,)
>>> type(cls).__mro__
(<class '__main__.C'>, <class '__main__.B'>, <class 'object'>)

藏起来可能是有原因的。：）

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!

pdb - Python调试器

作为程序员，要进行严肃的程序开发，首先需要的东西之一是调试器。Python有一个内置的模块，叫做pdb(自然是“Python调试器”的缩写!)

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

小整型的对象(-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
>>>

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

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}

使用and和or来模拟第三运算符。

python中的and和or操作符返回对象本身，而不是布尔值。因此:

In [18]: a = True

In [19]: a and 3 or 4
Out[19]: 3

In [20]: a = False

In [21]: a and 3 or 4
Out[21]: 4

然而，Py 2.5似乎添加了一个显式的第三运算符

    In [22]: a = 5 if True else '6'

    In [23]: a
    Out[23]: 5

好吧，如果你确定你的true子句的结果不是False，这是可行的。例子:

>>> def foo(): 
...     print "foo"
...     return 0
...
>>> def bar(): 
...     print "bar"
...     return 1
...
>>> 1 and foo() or bar()
foo
bar
1

要做到这一点，你还需要多做一点:

>>> (1 and [foo()] or [bar()])[0]
foo
0

然而，这并不漂亮。如果你的python版本支持它，请使用条件操作符。

>>> foo() if True or bar()
foo
0

Inspect模块也是一个很酷的功能。

标准Python中的垃圾邮件模块

它用于测试目的。

我选自ctypes教程。自己试试吧:

>>> import __hello__
Hello world...
>>> type(__hello__)
<type 'module'>
>>> from __phello__ import spam
Hello world...
Hello world...
>>> type(spam)
<type 'module'>
>>> help(spam)
Help on module __phello__.spam in __phello__:

NAME
    __phello__.spam

FILE
    c:\python26\<frozen>

内存管理

Python动态分配内存并使用垃圾收集来回收未使用的空间。一旦一个对象超出作用域，并且没有其他变量引用它，它将被恢复。我不必担心缓冲区溢出和缓慢增长的服务器进程。内存管理也是其他动态语言的一个特性，但Python在这方面做得非常好。

当然，我们必须注意循环引用，并保持对不再需要的对象的引用，但弱引用在这里有很大帮助。

Re可以调用函数!

事实上，您可以在每次匹配正则表达式时调用函数，这非常方便。 这里我有一个例子，把每个“Hello”替换为“Hi”，把“there”替换为“Fred”，等等。

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?'

我个人很喜欢这三个不同的引语

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

也很酷:不用转义正则表达式，避免使用原始字符串的可怕的反斜杠沙拉:

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

一个词:IPython

标签内省，漂亮的打印，%调试，历史管理，pylab，…值得花时间好好学习。

重新加载模块可以实现“实时编码”风格。但是类实例不更新。以下是原因，以及如何解决这个问题。记住，所有东西，是的，所有东西都是一个对象。

>>> 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是您的朋友。尽管如此，理解为什么这是有效的仍然是有帮助的。

不是很隐藏，但是函数有属性:

def doNothing():
    pass

doNothing.monkeys = 4
print doNothing.monkeys
4

你可以用类装饰函数——用类实例替换函数:

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)

只需少量的工作，线程模块就变得非常容易使用。此装饰器更改函数，使其在自己的线程中运行，返回占位符类实例，而不是常规结果。你可以通过检查placeolder来探测答案。结果或通过调用placeholder.awaitResult()来等待它。

def threadify(function):
    """
    exceptionally simple threading decorator. Just:
    >>> @threadify
    ... def longOperation(result):
    ...     time.sleep(3)
    ...     return result
    >>> A= longOperation("A has finished")
    >>> B= longOperation("B has finished")

    A doesn't have a result yet:
    >>> print A.result
    None

    until we wait for it:
    >>> print A.awaitResult()
    A has finished

    we could also wait manually - half a second more should be enough for B:
    >>> time.sleep(0.5); print B.result
    B has finished
    """
    class thr (threading.Thread,object):
        def __init__(self, *args, **kwargs):
            threading.Thread.__init__ ( self )  
            self.args, self.kwargs = args, kwargs
            self.result = None
            self.start()
        def awaitResult(self):
            self.join()
            return self.result        
        def run(self):
            self.result=function(*self.args, **self.kwargs)
    return thr

当你在代码文件的顶部使用正确的编码声明时，ROT13是源代码的有效编码:

#!/usr/bin/env python
# -*- coding: rot13 -*-

cevag "Uryyb fgnpxbiresybj!".rapbqr("rot13")

如果你在你的应用程序中重命名了一个类，你正在通过Pickle加载用户保存的文件，而其中一个重命名的类存储在用户的旧保存中，你将不能加载这个Pickle文件。

然而，只要在你的类定义中添加一个引用，一切就好了:

例如,:

class Bleh:
    pass

现在,

class Blah:
    pass

所以，你的用户的pickle保存的文件包含一个Bleh的引用，它不存在，由于重命名。这是固定的吗?

Bleh = Blah

简单!

EVERYTHING是一个对象，因此是可扩展的。我可以将成员变量作为元数据添加到我定义的函数中:

>>> def addInts(x,y): 
...    return x + y
>>> addInts.params = ['integer','integer']
>>> addInts.returnType = 'integer'

这对于编写动态单元测试非常有用，例如。

getattr内置函数:

>>> class C():
    def getMontys(self):
        self.montys = ['Cleese','Palin','Idle','Gilliam','Jones','Chapman']
        return self.montys


>>> c = C()
>>> getattr(c,'getMontys')()
['Cleese', 'Palin', 'Idle', 'Gilliam', 'Jones', 'Chapman']
>>> 

如果你想根据上下文分派函数，这很有用。参见深入了解Python中的示例(此处)

测试键是否在字典中的简单方法:

>>> 'key' in { 'key' : 1 }
True

>>> d = dict(key=1, key2=2)
>>> if 'key' in d:
...     print 'Yup'
... 
Yup

类作为一级对象(通过动态类定义显示)

还要注意闭包的使用。如果这个例子看起来是解决问题的“正确”方法，请仔细考虑……好几次:)

def makeMeANewClass(parent, value):
  class IAmAnObjectToo(parent):
    def theValue(self):
      return value
  return IAmAnObjectToo

Klass = makeMeANewClass(str, "fred")
o = Klass()
print isinstance(o, str)  # => True
print o.theValue()        # => fred

暴露可变缓冲区

使用Python缓冲区协议在Python中公开可变的面向字节的缓冲区(2.5/2.6)。

(对不起，这里没有代码。需要使用低级C API或现有适配器模块)。

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

有时扩展(修改)子类中描述符“返回”的值是有用的。使用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}

python成语x =…如果……其他的……远优于x =…和…还是……原因如下:

尽管声明

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

等于

x = y == 1 and 3 or 2

如果使用x =…和…还是……成语，有一天你可能会被这种棘手的情况所困扰:

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

因此不等于

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

要了解更多正确的方法， 参见Python的隐藏特性。

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

>>> s = u'１０５８５'
>>> s
u'\uff11\uff10\uff15\uff18\uff15'
>>> print s
１０５８５
>>> int(s)
10585
>>> float(s)
10585.0

关于Nick Johnson的Property类的实现(只是描述符的演示，当然，不是内置的替换)，我将包括一个引发AttributeError的setter:

class Property(object):
    def __init__(self, fget):
        self.fget = fget

    def __get__(self, obj, type):
        if obj is None:
            return self
        return self.fget(obj)

    def __set__(self, obj, value):
       raise AttributeError, 'Read-only attribute'

包含setter使其成为数据描述符，而不是方法/非数据描述符。数据描述符优先于实例字典。现在，实例不能将不同的对象赋值给属性名，并且尝试将其赋值给属性将引发属性错误。

解包语法在最近的版本中进行了升级，如示例中所示。

>>> 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)

控制递归限制

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

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

乘以布尔值

我在web开发中经常做的一件事是可选地打印HTML参数。我们在其他语言中都见过这样的代码:

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

在Python中，你可以乘以一个布尔值，它就会像你期望的那样:

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

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

Mod对负数正确工作

-1 % 5等于4，这是应该的，而不是像JavaScript等其他语言中那样是-1。这使得Python中的“环绕窗口”更干净，你只需要这样做:

index = (index + increment) % WINDOW_SIZE

你可以按需构造kwargs函数:

kwargs = {}
kwargs[str("%s__icontains" % field)] = some_value
some_function(**kwargs)

str()调用在某种程度上是需要的，因为python会抱怨它不是字符串。不知道为什么;) 我在django对象模型中使用这个动态过滤器:

result = model_class.objects.filter(**kwargs)

猜测整数基数

>>> 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

迭代工具

这个模块经常被忽视。下面的例子使用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。

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

可以利用这一点向对象任意添加属性和函数。这也可以用来创建一个快速和肮脏的结构类型。

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

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

创建枚举

在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

操纵sys.modules

你可以直接操作模块缓存，使模块可用或不可用，如你所愿:

>>> import sys
>>> import ham
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
ImportError: No module named ham

这甚至适用于可用的模块，在某种程度上也适用于已经导入的模块:

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

如最后一行所示，更改sys.;模块只影响将来的导入语句，而不影响过去的导入语句，所以如果你想影响其他模块，在给它们尝试导入模块的机会之前进行这些更改是很重要的——通常是在导入它们之前。None是sys中的一个特殊值。模块，用于负缓存(表明该模块第一次没有找到，因此没有必要再次查找)。任何其他值都将是导入操作的结果——即使它不是模块对象。您可以使用它将模块替换为与您想要的行为完全一致的对象。删除sys. exe表项。Modules完全导致下一次导入对该模块进行正常搜索，即使之前已经导入了该模块。

Python中没有秘密;)

将元组传递给内置函数

很多Python函数接受元组，但看起来并不像。例如，你想测试你的变量是否是一个数字，你可以这样做:

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

但如果你传递给我们元组，这看起来更干净:

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

您可以将多个变量赋给相同的值

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

以紧凑的方式将几个变量初始化为None很有用。

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随时访问线程的当前状态。你也可以选择信号。SIGUSR1或signal。sigusr2。

See

牙套

def g():
    print 'hi!'

def f(): (
    g()
)

>>> f()
hi!

绝密属性

>>> 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 "<stdin>", 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'

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

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

对迭代器的多个引用

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

>>> 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)

你可以通过查看对象的__ module__属性来询问它来自哪个模块。这很有用，例如，如果您正在命令行上进行实验，并且导入了很多东西。

同样，你可以通过查看模块的__ file__属性来询问它来自哪里。这在调试路径问题时很有用。

使用负step反转可迭代对象

>>> 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]

当使用交互式shell时，"_"包含最后一个打印项的值:

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

切片和可变性

复制清单

>>> 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]

拆包与打印功能结合:

# in 2.6 <= python < 3.0, 3.0 + the print function is native
from __future__ import print_function 

mylist = ['foo', 'bar', 'some other value', 1,2,3,4]  
print(*mylist)

应许多人的要求，这个答案已经被移到了问题本身。

从python 3.1(2.7)开始，支持字典和集推导式:

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

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,)

** Using sets to reference contents in sets of frozensets**

正如你可能知道的，集合是可变的，因此是不可哈希的，所以如果你想创建一个集合的集合(或使用集合作为字典的键)，使用frozensets是必要的:

>>> fabc = frozenset('abc')
>>> fxyz = frozenset('xyz')
>>> mset = set((fabc, fxyz))
>>> mset
{frozenset({'a', 'c', 'b'}), frozenset({'y', 'x', 'z'})}

然而，仅仅使用普通集合就可以测试成员并删除/丢弃成员:

>>> abc = set('abc')
>>> abc in mset
True
>>> mset.remove(abc)
>>> mset
{frozenset({'y', 'x', 'z'})}

引用Python标准库文档:

注意，__contains__()， remove()和discard()的elem参数 方法可以是一个集合。为了支持搜索等价的frozenset，可以使用 Elem集在搜索过程中临时突变，然后恢复。在 搜索，elem集不应该被读取或改变，因为它没有 拥有有意义的价值。

不幸的是，也许是令人惊讶的是，字典并非如此:

>>> mdict = {fabc:1, fxyz:2}
>>> fabc in mdict
True
>>> abc in mdict
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
TypeError: unhashable type: 'set'

python中的textwrap.dedent实用函数可以非常方便地测试返回的多行字符串是否等于预期的输出，而不破坏unittests的缩进:

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("""\
        <?xml version="1.0" encoding="utf-8"?>
        <root_node>
            <my_node>my_content</my_node>
        </root_node>
        """)

        self.assertEqual(expected_value, returned_xml)

切片为左值。这个埃拉托色尼筛子产生一个素数或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)

为了工作，左边的切片必须在右边分配一个相同长度的列表。

零参数和可变参数

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

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

它们也可以接受常见的*args和**kwargs语法:

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

多行字符串

一种方法是使用反斜杠:

>>> 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

注意行与行之间没有逗号(这不是一个元组)，并且必须考虑字符串需要的任何尾随/前导空格。顺便说一下，所有这些都使用占位符(例如“我的名字是%s”% name)。

Pow()也可以有效地计算(x ** y) % z。

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

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

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

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

>>> 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文件名中的反斜杠上阅读关于这个的长讨论。

序列乘法和反射的操作数

>>> '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 *的解释器调用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

使用不同的起始索引进行枚举

enumerate在这个答案中已经部分涉及了，但最近我发现了enumerate一个更隐藏的特性，我认为值得单独发表，而不仅仅是评论。

从Python 2.6开始，你可以在第二个参数中指定要枚举的起始索引:

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

我发现它非常有用的一个地方是当我枚举对称矩阵的元素时。由于矩阵是对称的，我可以通过只在上三角形上迭代来节省时间，但在这种情况下，我必须在内部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)中没有记录，只有在线文档中有记录。

不是“隐藏”，而是很有用，不常用

像这样快速创建字符串连接函数

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

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

and

能够更优雅地创建字符串列表，而不是引号，逗号混乱。

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

取而代之的是

l = "item1 item2 item3".split()

对象数据模型

您可以为自己的类重写语言中的任何操作符。有关完整列表，请参阅本页。一些例子:

您可以重写任何运算符(* + - // / % ^ == < > <= >=。等等)。所有这些都是通过重写对象中的__mul__， __add__等来实现的。你甚至可以重写像__rmul__这样的东西来分别处理your_object*something_else和something_else*your_object.。是属性访问(a.b)，并且可以通过使用__getattr__来重写以处理任意b。这里还包括一个使用__call__的(…)。 您可以创建自己的slice语法(a[stuff])，这可能非常复杂，与列表中使用的标准语法完全不同(numpy在其数组中有一个很好的例子，说明了这种功能的强大)，使用您喜欢的、、:和…的任何组合，使用slice对象。 特别处理语言中许多关键字所发生的情况。包括del、in、import和not。 处理与对象一起调用许多内置函数时发生的情况。标准的__int__， __str__等会在这里，但__len__， __reversed__， __abs__和三个参数__pow__(用于模取幂)也会在这里。

在python中解包元组

在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

插入与追加

不是特稿，但可能会很有趣

假设您想要在列表中插入一些数据，然后反转它。最简单的方法是

count = 10 ** 5
nums = []
for x in range(count):
    nums.append(x)
nums.reverse()

然后你会想:把数字从最开始插入怎么样?所以:

count = 10 ** 5 
nums = [] 
for x in range(count):
    nums.insert(0, x)

但它却慢了100倍!如果我们设置count = 10 ** 6，它将慢1000倍;这是因为插入是O(n²)，而追加是O(n)。

造成这种差异的原因是insert每次调用时都必须移动列表中的每个元素;Append只是在列表的末尾添加元素(有时它必须重新分配所有元素，但它仍然更快)

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的一个有趣的子类型。

模块导出命名空间中的EVERYTHING

包括从其他模块导入的名称!

# this is "answer42.py"
from operator import *
from inspect  import *

现在测试模块中可导入的内容。

>>> import answer42
>>> answer42.__dict__.keys()
['gt', 'imul', 'ge', 'setslice', 'ArgInfo', 'getfile', 'isCallable', 'getsourcelines', 'CO_OPTIMIZED', 'le', 're', 'isgenerator', 'ArgSpec', 'imp', 'lt', 'delslice', 'BlockFinder', 'getargspec', 'currentframe', 'CO_NOFREE', 'namedtuple', 'rshift', 'string', 'getframeinfo', '__file__', 'strseq', 'iconcat', 'getmro', 'mod', 'getcallargs', 'isub', 'getouterframes', 'isdatadescriptor', 'modulesbyfile', 'setitem', 'truth', 'Attribute', 'div', 'CO_NESTED', 'ixor', 'getargvalues', 'ismemberdescriptor', 'getsource', 'isMappingType', 'eq', 'index', 'xor', 'sub', 'getcomments', 'neg', 'getslice', 'isframe', '__builtins__', 'abs', 'getmembers', 'mul', 'getclasstree', 'irepeat', 'is_', 'getitem', 'indexOf', 'Traceback', 'findsource', 'ModuleInfo', 'ipow', 'TPFLAGS_IS_ABSTRACT', 'or_', 'joinseq', 'is_not', 'itruediv', 'getsourcefile', 'dis', 'os', 'iand', 'countOf', 'getinnerframes', 'pow', 'pos', 'and_', 'lshift', '__name__', 'sequenceIncludes', 'isabstract', 'isbuiltin', 'invert', 'contains', 'add', 'isSequenceType', 'irshift', 'types', 'tokenize', 'isfunction', 'not_', 'istraceback', 'getmoduleinfo', 'isgeneratorfunction', 'getargs', 'CO_GENERATOR', 'cleandoc', 'classify_class_attrs', 'EndOfBlock', 'walktree', '__doc__', 'getmodule', 'isNumberType', 'ilshift', 'ismethod', 'ifloordiv', 'formatargvalues', 'indentsize', 'getmodulename', 'inv', 'Arguments', 'iscode', 'CO_NEWLOCALS', 'formatargspec', 'iadd', 'getlineno', 'imod', 'CO_VARKEYWORDS', 'ne', 'idiv', '__package__', 'CO_VARARGS', 'attrgetter', 'methodcaller', 'truediv', 'repeat', 'trace', 'isclass', 'ior', 'ismethoddescriptor', 'sys', 'isroutine', 'delitem', 'stack', 'concat', 'getdoc', 'getabsfile', 'ismodule', 'linecache', 'floordiv', 'isgetsetdescriptor', 'itemgetter', 'getblock']
>>> from answer42 import getmembers
>>> getmembers
<function getmembers at 0xb74b2924>
>>> 

这是一个不从x import *并定义__all__ =的好理由。

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

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

简单:

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

这是我喜欢Python的地方，我看到过很多不太像Python的习语:

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

动态添加的属性

如果您想通过调用来向类添加一些属性，这可能会很有用。这可以通过重写__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上做的等效代码。

保重!

在运行时更改函数标签:

>>> 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
...

我不确定这在Python文档中的位置(或是否)，但对于Python 2。x(至少2.5和2.6，我刚刚尝试过)，打印语句可以用括号调用。如果您希望能够轻松地移植一些Python 2，这可能很有用。Python 3.x代码。

例子: 我们想要Moshiach Now在python 2.5, 2.6和3.x中工作。

此外，在Python 2和3中，not操作符可以用括号调用: 不是假的 而且 (假) 都应该返回True。

括号也可以用于其他语句和操作符。

编辑:把括号放在非操作符(可能是任何其他操作符)周围不是一个好主意，因为它会导致令人惊讶的情况，就像这样(发生这种情况是因为括号实际上只是在1周围):

>>> (not 1) == 9
False

>>> not(1) == 9
True

这也可以工作，对于某些值(我认为它不是一个有效的标识符名称)，像这样: not'val'将返回False, print'We want Moshiach Now'将返回We want Moshiach Now。(但是not552会引发NameError，因为它是一个有效的标识符名称)。

Python有“私有”变量

以双下划线开始而不是以双下划线结束的变量将成为私有变量，而且不仅仅是按照约定。实际上__var变成了_Classname__var，其中Classname是创建变量的类。它们不是继承的，也不能被覆盖。

>>> class A:
...     def __init__(self):
...             self.__var = 5
...     def getvar(self):
...             return self.__var
... 
>>> a = A()
>>> a.__var
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: A instance has no attribute '__var'
>>> a.getvar()
5
>>> dir(a)
['_A__var', '__doc__', '__init__', '__module__', 'getvar']
>>>

除了haridsv之前提到的这一点之外:

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

也可以这样做:

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

scanner类。http://code.activestate.com/recipes/457664-hidden-scanner-functionality-in-re-module/

这不是一个隐藏的功能，但仍然很好:

import os.path as op

root_dir = op.abspath(op.join(op.dirname(__file__), ".."))

保存大量字符时，操作路径!

可以说，这本身并不是一个编程特性，但是非常有用，所以我还是要发布它。

$ python -m http.server

.．.后面跟着$ wget http://<ipnumber>:8000/文件名在其他地方。

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

$ python -m SimpleHTTPServer

你也可以指定端口，例如python -m http。服务器80(因此，如果您在服务器端有根，则可以省略url中的端口)

Python3中的Unicode标识符:

>>> 'Unicode字符_تكوين_Variable'.isidentifier()
True
>>> Unicode字符_تكوين_Variable='Python3 rules!'
>>> Unicode字符_تكوين_Variable
'Python3 rules!'

将字符串相乘以使其重复

print "SO"*5 

给了

SOSOSOSOSO

commands.getoutput

如果你想获得直接输出到stdout或stderr的函数的输出，就像os的情况一样。系统命令。Getoutput来拯救。整个模块都非常棒。

>>> print commands.getoutput('ls')
myFile1.txt    myFile2.txt    myFile3.txt    myFile4.txt    myFile5.txt
myFile6.txt    myFile7.txt    myFile8.txt    myFile9.txt    myFile10.txt
myFile11.txt   myFile12.txt   myFile13.txt   myFile14.txt   module.py

曾经使用xrange(INT)而不是range(INT) ....它占用的内存更少，而且不依赖于整数的大小。容量! !这不是很好吗?

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)或isinstance(obj, b)。)

当你创建一种新的东西时，你需要把它添加到它出现的任何地方。(这种结构在重新加载模块或以两个名称导入同一个文件时也会导致问题。这种事情发生的次数比人们愿意承认的要多。)但是你可以说:

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

添加继承就更好了:所有可处理对象的示例都可以继承

class Processable:
    processable = True

但你不需要说服每个人都继承你的基类，只需要设置一个属性。

Mapreduce使用map和reduce函数

这样创建一个简单的sumproduct:

def sumprod(x,y):
    return reduce(lambda a,b:a+b, map(lambda a, b: a*b,x,y))

例子:

In [2]: sumprod([1,2,3],[4,5,6])
Out[2]: 32

简单的内置基准测试工具

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

列表中的无限递归

>>> 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

虽然不是很python化，但可以使用print来写入文件

打印>>outFile， 'I am Being Written'

解释:

这种形式有时被称为 “打印雪佛龙。”在这种形式中， 第一个表达式>后>必须 求值为“类文件”对象， 具体来说，一个对象具有 如上所述编写()方法。 有了这个扩展形式， 随后的表达式被打印到 这个文件对象。如果第一个 表达式的值为None sys。的文件使用Stdout 输出。

字符串转义和unicode转义编码

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

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

另一个问题。你有普通的unicode字符串，比如\u01245。如何让它起作用?只是解码字符串使用unicode转义编码!

>>> 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')
Привіт, світ!

用sum()扁平化列表。

sum()内置函数可用于将__add__个列表放在一起，提供了一种方便的方法来将列表的列表扁平化:

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]

博格模式

这是亚历克斯·马尔泰利的杀手。所有Borg实例共享状态。这消除了使用单例模式的需要(共享状态时实例无关紧要)，而且相当优雅(但使用新类会更加复杂)。

foo的值可以在任何实例中重新赋值，所有值都将被更新，你甚至可以重新赋值整个字典。博格是个完美的名字，点击这里阅读更多。

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

这非常适合共享eventlet。GreenPool控制并发。

激活IDE中接受它的自动完成(如IDLE, Editra, IEP)，而不是做: “嗨”。(然后你按TAB键)，你可以在IDE中作弊，只是制造 嗨。”(你可以看到，在开始的时候没有单引号)因为它只会跟着最新的标点符号，就像当你添加:并按enter，它直接添加了一个缩进，不知道它是否会改变，但它不再是一个提示:)

这里有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，你应该会看到彩蛋。

下面是我在调试类型错误时使用的一个有用的函数

def typePrint(object):
    print(str(object) + " - (" + str(type(object)) + ")")

例如，它只是打印输入后跟类型

>>> a = 101
>>> typePrint(a)
    101 - (<type 'int'>)

for line in open('foo'):
    print(line)

这相当于(但更好):

f = open('foo', 'r')
for line in f.readlines():
   print(line)
f.close()

每次打印一屏多行字符串

没有真正有用的功能隐藏在网站。_Printer类，其license对象是一个实例。调用后者时，打印Python许可证。可以创建另一个相同类型的对象，传递一个字符串——例如文件的内容——作为第二个参数，并调用它:

type(license)(0,open('textfile.txt').read(),0)()

这将打印一次按一定行数分割的文件内容:

...
file row 21
file row 22
file row 23

Hit Return for more, or q (and Return) to quit:

脚本的交互式调试(和doctest字符串)

我不认为这是广为人知的，但添加这一行到任何python脚本:

进口pdb;pdb.set_trace ()

将导致PDB调试器在代码的那一点弹出运行游标。我想，更鲜为人知的是，你可以在doctest中使用同样的行:

"""
>>> 1 in (1,2,3)   
Becomes
>>> import pdb; pdb.set_trace(); 1 in (1,2,3)
"""

然后可以使用调试器检出doctest环境。您不能真正逐级执行doctest，因为每一行都是自主运行的，但它是调试doctest glob和环境的好工具。

在Python 2中，你可以用反勾号将表达式括起来，从而生成表达式的字符串表示形式:

 >>> `sorted`
'<built-in function sorted>'

这在python 3.X中消失了。

不是编程特性，但在使用Python和bash或shell脚本时很有用。

python -c"import os; print(os.getcwd());"

请参阅此处的python文档。在编写较长的Python脚本时需要注意的其他事项可以在本讨论中看到。

Python有一些非常意想不到的异常:

进口

这允许您在缺少库时导入替代库

try:
    import json
except ImportError:
    import simplejson as json

迭代

For循环在内部执行此操作，并捕获StopIteration:

iter([]).next()
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    iter(a).next()
StopIteration

断言

>>> try:
...     assert []
... except AssertionError:
...     print "This list should not be empty"
This list should not be empty

虽然这对于一次检查来说比较冗长，但是使用相同错误消息混合异常和布尔运算符的多次检查可以通过这种方式缩短。

舍入整数: 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

谢谢你，格雷戈。

reduce和算子的一些很酷的功能。

>>> from operator import add,mul
>>> reduce(add,[1,2,3,4])
10
>>> reduce(mul,[1,2,3,4])
24
>>> reduce(add,[[1,2,3,4],[1,2,3,4]])
[1, 2, 3, 4, 1, 2, 3, 4]
>>> reduce(add,(1,2,3,4))
10
>>> reduce(mul,(1,2,3,4))
24

Python的位置和关键字展开可以动态使用，而不仅仅是从存储的列表中使用。

l=lambda x,y,z:x+y+z
a=1,2,3
print l(*a)
print l(*[a[0],2,3])

它通常在以下情况下更有用:

a=[2,3]
l(*(a+[3]))

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文档

维基百科的条目

并不是一个隐藏的功能，但可能会派上用场。

用于成对遍历列表中的项

for x, y in zip(s, s[1:]):

>>> float('infinity')
inf
>>> float('NaN')
nan

更多信息:

http://docs.python.org/library/functions.html#float http://www.python.org/dev/peps/pep-0754/ Python nan和inf值