Python编程语言中有哪些鲜为人知但很有用的特性?

尽量将答案限制在Python核心。 每个回答一个特征。 给出一个例子和功能的简短描述,而不仅仅是文档链接。 使用标题作为第一行标记该特性。

快速链接到答案:

参数解包 牙套 链接比较运算符 修饰符 可变默认参数的陷阱/危险 描述符 字典默认的.get值 所以测试 省略切片语法 枚举 其他/ 函数作为iter()参数 生成器表达式 导入该 就地值交换 步进列表 __missing__物品 多行正则表达式 命名字符串格式化 嵌套的列表/生成器推导 运行时的新类型 .pth文件 ROT13编码 正则表达式调试 发送到发电机 交互式解释器中的制表符补全 三元表达式 试着/ / else除外 拆包+打印()函数 与声明


当前回答

我不确定这在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,因为它是一个有效的标识符名称)。

其他回答

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

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

可读正则表达式

在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})$"

一切都是动态的

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

设置/ 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

函数参数解包

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

例如:

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)

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