-
Chaining comparison operators:
>>> x = 5
>>> 1 < x < 10
True
>>> x < 10 < x*10 < 100
True
>>> 10 > x <= 9
True
>>> 5 == x > 4
True
In case you’re thinking it’s doing, ’1 < x’, which comes out as True, and then comparing ‘True < 10′, which is also True, then no, that’s really not what happens (see the last example.) It’s really translating into ’1 < x and x < 10′, and ‘x < 10 and 10 < x * 10 and x*10 < 100′, but with less typing and each term is only evaluated once.
-
Readable regular expressions
In Python you can split a regular expression over multiple lines, name your matches and insert comments.
Example verbose syntax (from 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)
Example naming matches (from Regular Expression HOWTO)
>>> p = re.compile(r‘(?P<word>\b\w+\b)’)
>>> m = p.search( ‘(((( Lots of punctuation )))’ )
>>> m.group(‘word’)
‘Lots’
-
Decorators
Decorators allow to wrap a function or method in another function that can add functionality, modify arguments or results, etc. You write decorators one line above the function definition, beginning with an “at” sign (@).
Example shows a print_args decorator that prints function’s arguments before calling it:
>>> 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
-
iter() can take a callable argument
For instance:
def seek_next_line(f):
for c in iter(lambda: f.read(1),‘\n’):
pass
The iter(callable, until_value) calls repetitively the callable and yields its result until the callable returns _until_value_.
-
Creating generators objects
If you write
x=(n for n in foo if bar(n))
you can get out the generator and assign it to x. Now it means you can do
for n in x:
The advantage of this is that you don’t need intermediate storage, which you would need if you did
x = [n for n in foo if bar(n)]
In some cases this can lead to significant speed up.
-
Futures and the “With” Statement
There’s a special module in Python called __future__. Some new language features end up in this module for testing, and to use them you have to explicitly import them from here. One such feature which is a favorite of mine is the “with” statement, which is currently present in __future__ in version 2.5, but will be part of the language in the soon-to-be-released 2.6 and 3.0 versions.
The reason it is in __future__ is because it makes both with and as keywords, which could break existing code.
I have used the “with” statement in 2.5 a lot because I think it’s a very useful construct, here is a quick demo:
from __future__ import with_statement
with open(‘foo.txt’, ‘w’) as f:
f.write(‘hello!’)
What’s happening here behind the scenes, is that the “with” statement calls the special __enter__ and__exit__ methods on the file object. Exception details are also passed to __exit__ if any exception was raised from the with statement body, allowing for exception handling to happen there.
What this does for you in this particular case is that it guarantees that the file is closed when execution falls out of scope of the “with” statement‘s body, regardless if that occurs naturally or whether an exception was thrown. It is basically a way of abstracting away common error-handling code.
Other common use cases for this include locking with threads and database transactions.
For more information on how to use this and how to implement your own “with” statement compatible objects read PEP 343
-
The step argument in slice operators. For example:
a = [1,2,3,4,5]
>>> a[::2] # iterate over the whole list in 2-increments
[1,3,5]
The special case x[::-1] is a useful idiom for ‘x reversed’.
>>> a[::-1]
[5,4,3,2,1]
-
From 2.5 onwards dicts have a special method __missing__ that is invoked for missing items:
>>> 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]}
There is also a dict subclass in collections called defaultdict that does pretty much the same but calls a function without arguments for not existing items:
>>> from collections import defaultdict
>>> m = defaultdict(list)
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{‘foo’: [1, 2]}
I recommend converting such dicts to regular dicts before passing them to functions that don’t expect such subclasses. A lot of code uses d[a_key] and catches KeyErrors to check if an item exists which would add a new item to the dict.
-
Doctest: documentation and unit-testing at the same time.
Example extracted fom python documentation:
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()
-
Descriptors
They’re the magic behind a whole bunch of core Python features.
When you use dotted access to look up a member (eg, x.y), Python first looks for the member in the instance dictionary. If it’s not found, it looks for it in the class dictionary. If it finds it in the class dictionary, and the object implements the descriptor protocol, instead of just returning it, Python executes it. A descriptor is any class that implements the get, set, or del methods.
Here’s how you’d implement your own (read-only) version of property using descriptors:
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)
and you’d use it just like the built-in property():
class
MyClass(object):
@Property
def foo(self):
return
“Foo!”
Descriptors are used in Python to implement properties, bound methods, static methods, class methods and slots, amongst other things. Understanding them makes it easy to see why a lot of things that previously looked like Python ‘quirks’ are the way they are.
Raymond Hettinger has an excellent tutorial that does a much better job of describing them than I do.
-
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: a = f #store the new value
You can:
>>> 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
-
One line Variable value swapping
>>> a = 10
>>> b = 5
>>> a, b = b, a
>>> print a
5
>>> print b
10
a will have the value of b and so on.
This is a side effect of python packing and unpacking feature.
-
enumerate
Wrap an iterable with enumerate and it will yield the item along with it’s index.
For example:
>>> 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
>>>
-
Creating new types at runtime
>>> NewType = type(“NewType”, (object,), {“x”: “hello”})
>>> n = NewType()
>>> n.x
“hello”
which is exactly the same as
>>> class
NewType(object):
>>> x = “hello”
>>> n = NewType()
>>> n.x
“hello”
Probably not the most useful thing, but nice to know.
Edit: Fixed name of new type, should be NewType to be the exact same thing as with class statement.
查看更多：http://stackoverflow.com/questions/101268/hidden-features-of-python
这个页面里收集了很多python技巧
Onenote不错，再试一下Onenote发帖，呵呵
Linode VPS
Tengine