Python编程语言鲜为人知但有用的功能是什么?
- 尝试将答案限于Python核心。
- 每个答案一个功能。
- 给出该功能的示例和简短描述,而不仅仅是指向文档的链接。
- 使用标题作为第一行标记功能。
答案的快速链接:
- 参数解包
- 大括号
- 链接比较运算符
- 装饰工
- 默认参数的陷阱/可变默认参数的危险
- 描述符
- 字典默认
.get
值 - Docstring测试
- 省略号切片语法
- 列举
- 对于/其他
- 用作iter()参数
- 生成器表达式
-
import this
- 就地价值交换
- 列表步进
-
__missing__
项 - 多行正则表达式
- 命名字符串格式
- 嵌套列表/生成器理解
- 运行时的新类型
-
.pth
文件 - ROT13编码
- 正则表达式调试
- 发送给发电机
- 交互式解释器中的制表符完成
- 三元表达
-
try/except/else
- 开箱+
print()
函数 -
with
陈述
#1楼
主要信息:)
import this
# btw look at this module's source :)
解密 :
提姆·彼得斯(Tim Peters)撰写的《 Python之禅》
美丽胜于丑陋。
显式胜于隐式。
简单胜于复杂。
复杂胜于复杂。
扁平比嵌套更好。
稀疏胜于密集。
可读性很重要。
特殊情况还不足以打破规则。
尽管实用性胜过纯度。
错误绝不能默默传递。
除非明确地保持沉默。
面对模棱两可的想法,拒绝猜测的诱惑。 应该有一种-最好只有一种-显而易见的方法。
尽管除非您是荷兰人,否则一开始这种方式可能并不明显。
现在总比没有好。
虽然从未往往比现在更好。
如果实现难以解释,那是个坏主意。
如果实现易于解释,则可能是个好主意。
命名空间是一个很棒的主意-让我们做更多这些吧!
#2楼
创建生成器对象
如果你写
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)
#3楼
装饰工
装饰器允许将一个函数或方法包装在另一个函数中,该函数或方法可以添加功能,修改参数或结果等。您可以在函数定义上方一行以“ 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
#4楼
可读的正则表达式
在Python中,您可以将正则表达式分成多行,命名匹配项并插入注释。
详细语法示例(从Dive into 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})$"
#5楼
嵌套列表推导和生成器表达式:
[(i,j) for i in range(3) for j in range(i) ]
((i,j) for i in range(4) for j in range(i) )
这些可以替换大量的嵌套循环代码。
#6楼
将值发送到生成器函数中 。 例如,具有以下功能:
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
#7楼
切片运算符中的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]
#8楼
链接比较运算符:
>>> 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 and x < 10
以及x < 10 and 10 < x * 10 and x*10 < 100
,但键入次数较少,每个术语仅计算一次。
#9楼
重新引发异常 :
# 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重新引发具有完整原始追溯的异常,允许您说“哦,对不起,对不起,我不是要抓住这个,对不起,对不起。 ”
如果您希望打印,存储或摆弄原始回溯,可以使用sys.exc_info()来获取,并像Python一样使用“回溯”模块完成打印。
#10楼
就地价值交换
>>> a = 10
>>> b = 5
>>> a, b
(10, 5)
>>> a, b = b, a
>>> a, b
(5, 10)
分配的右侧是创建新元组的表达式。 赋值的左侧立即将(未引用的)元组解压缩为名称a
和b
。
分配后,将不引用新元组并将其标记为垃圾回收,并且已交换绑定到a
和b
的值。
注意,多重分配实际上只是元组打包和序列拆包的组合。
#11楼
描述符
它们是一大堆Python核心功能背后的魔力。
当您使用点分访问来查找成员(例如xy)时,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)
您将像内置的property()一样使用它:
class MyClass(object):
@Property
def foo(self):
return "Foo!"
描述符在Python中用于实现属性,绑定方法,静态方法,类方法和插槽等。 理解它们可以很容易地弄清为什么以前看起来像Python的“怪癖”的很多东西都是它们的样子。
Raymond Hettinger 的教程很棒 ,比我做得更好。
#12楼
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()
#13楼
iter()可以接受可调用参数
例如:
def seek_next_line(f):
for c in iter(lambda: f.read(1),'\n'):
pass
iter(callable, until_value)
函数重复调用callable
并产生其结果,直到返回until_value
为止。
#14楼
当您在代码文件顶部使用正确的编码声明时,ROT13是源代码的有效编码:
#!/usr/bin/env python
# -*- coding: rot13 -*-
cevag "Uryyb fgnpxbiresybj!".rapbqr("rot13")
#15楼
以完全动态的方式创建新类型
>>> NewType = type("NewType", (object,), {"x": "hello"})
>>> n = NewType()
>>> n.x
"hello"
完全一样
>>> class NewType(object):
>>> x = "hello"
>>> n = NewType()
>>> n.x
"hello"
可能不是最有用的东西,但很高兴知道。
编辑 :新类型的固定名称,应为NewType
与class
声明完全相同。
编辑 :调整标题以更准确地描述功能。
#16楼
上下文管理器和“ with
”语句
在PEP 343中引入的上下文管理器是一个对象,它充当一组语句的运行时上下文。
由于该功能使用了新关键字,因此逐步引入了该功能:在Python 2.5中,可以通过__future__
指令使用该__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
套件的范围时,无论该文件是正常发生还是引发异常,该文件都将关闭。 从根本上讲,它是一种抽象通用异常处理代码的方法。
其他常见用例包括使用线程锁定和数据库事务。
#17楼
函数参数解压缩
您可以使用*
和**
将列表或字典解压缩为函数参数。
例如:
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)
由于列表,元组和字典广泛用作容器,因此非常有用的快捷方式。
#18楼
字典具有get()方法
字典有一个“ get()”方法。 如果执行d ['key']而键不存在,则会出现异常。 如果执行d.get('key'),则如果'key'不存在,则返回None。 您可以添加第二个参数来取回该项目,而不是无,例如:d.get('key',0)。
这非常适合诸如加号之类的事情:
sum[value] = sum.get(value, 0) + 1
#19楼
从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]}
collections
还有一个名为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]
并捕获d[a_key]
来检查是否存在将向dict添加新项目的项目。
#20楼
如果您不喜欢使用空格来表示作用域,则可以通过发出以下命令来使用C样式的{}:
from __future__ import braces
#21楼
命名格式
%-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))
#22楼
注意可变的默认参数
>>> def foo(x=[]):
... x.append(1)
... print x
...
>>> foo()
[1]
>>> foo()
[1, 1]
>>> foo()
[1, 1, 1]
相反,您应该使用表示“未给定”的前哨值,并默认替换为您想要的可变变量:
>>> def foo(x=None):
... if x is None:
... x = []
... x.append(1)
... print x
>>> foo()
[1]
>>> foo()
[1]
#23楼
要添加更多的python模块(尤其是第三方模块),大多数人似乎使用PYTHONPATH环境变量,或者在其站点包目录中添加符号链接或目录。 另一种方法是使用* .pth文件。 这是python官方文档的解释:
“ [修改python搜索路径的最方便的方法是将路径配置文件添加到Python路径上已经存在的目录中,通常是... / site-packages /目录。路径配置文件的扩展名为.pth。 ,并且每行必须包含一个附加到sys.path的路径。(由于新路径附加到sys.path,因此添加目录中的模块将不会覆盖标准模块。这意味着您无法使用此机制用于安装标准模块的固定版本。)”
#24楼
例外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 ... except语句保护的代码未引发的异常。
参见http://docs.python.org/tut/node10.html
#25楼
for ... 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")
#26楼
条件分配
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是两个类。
#27楼
枚举
用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
>>>
参考文献:
#28楼
获取python regex解析树以调试您的regex。
正则表达式是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)
#29楼
交互式口译员选项卡完成
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环境变量。
#30楼
操作符重载的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}
标准库参考中的更多详细信息: 设置类型