Cookbook
{Back to Index} Expand All Details on Page

a, b, *rest1 = range(5)
log("rest1", rest1)

a, b, *rest2 = range(3)
log("rest2", rest2)

a, b, *rest3 = range(2)
log("rest3", rest3)

a, *body, c, d = range(5)
log("body", body)

*head, b, c, d = range(5)
log("head", head)

from operator import itemgetter

data = [
    ('c', 2),
    ('b', 3),
    ['a', 1]
]

log("[itemgetter(1, 0)(t) for t in data]", [itemgetter(1, 0)(t) for t in data])

l = list(range(10))
log("l", l)

l[2:5] = [20, 30]
log("after l[2:5] = [20, 30]", l)

del l[5:7]
log("after del l[5:7]", l)

l[3::2] = [11, 22]
log("after l[3::2] = [11, 22]", l)

try:
    l[2:5] = 100
except Exception as e:
    log("e", e)

l[2:5] = [100]
log("after l[2:5] = [100]", l)

lst = ['a', 'b', 'c', '', '']
for i in lst:
    if i is '':
	lst.remove(i)

print(lst)

words = [
   'look', 'into', 'my', 'eyes', 'look', 'into', 'my', 'eyes',
   'the', 'eyes', 'the', 'eyes', 'the', 'eyes', 'not', 'around', 'the',
   'eyes', "don't", 'look', 'around', 'the', 'eyes', 'look', 'into',
   'my', 'eyes', "you're", 'under'
]

from collections import Counter
word_counts = Counter(words)
top_three = word_counts.most_common(3)
print(top_three)

import heapq

portfolio = [
   {'name': 'IBM', 'shares': 100, 'price': 91.1},
   {'name': 'AAPL', 'shares': 50, 'price': 543.22},
   {'name': 'FB', 'shares': 200, 'price': 21.09},
   {'name': 'HPQ', 'shares': 35, 'price': 31.75},
   {'name': 'YHOO', 'shares': 45, 'price': 16.35},
   {'name': 'ACME', 'shares': 75, 'price': 115.65}
]

cheap = heapq.nsmallest(3, portfolio, key=lambda s: s['price'])
expensive = heapq.nlargest(3, portfolio, key=lambda s: s['price'])
r = {'cheap': cheap, 'expensive': expensive}
print(r)

rows = [
    {'address': '5412 N CLARK', 'date': '07/01/2012'},
    {'address': '5148 N CLARK', 'date': '07/04/2012'},
    {'address': '5800 E 58TH', 'date': '07/02/2012'},
    {'address': '2122 N CLARK', 'date': '07/03/2012'},
    {'address': '5645 N RAVENSWOOD', 'date': '07/02/2012'},
    {'address': '1060 W ADDISON', 'date': '07/02/2012'},
    {'address': '4801 N BROADWAY', 'date': '07/01/2012'},
    {'address': '1039 W GRANVILLE', 'date': '07/04/2012'},
]

from itertools import groupby

rows.sort(key=lambda r: r['date'])
for date, items in groupby(rows, key=lambda r: r['date']):
    print(date)
    for i in items:
	print('    ', i)

from collections import defaultdict
rows_by_date = defaultdict(list)
for row in rows:
    rows_by_date[row['date']].append(row)
print(rows_by_date)

def dedupe(items, key=None):
    seen = set()
    for item in items:
	val = item if key is None else key(item)
	if val not in seen:
	    yield item
	    seen.add(val)


a = [
	{'x': 2, 'y': 3},
	{'x': 1, 'y': 4},
	{'x': 2, 'y': 3},
	{'x': 2, 'y': 3},
	{'x': 10, 'y': 15}
    ]
print(list(dedupe(a, key=lambda a: (a['x'],a['y']))))

def dedupe(items):
    seen = set()
    for item in items:
	if item not in seen:
	    yield item
	    seen.add(item)

a = [1, 5, 2, 1, 9, 1, 5, 10]
print(list(dedupe(a)))

records = [
     ('foo', 1, 2),
     ('bar', 'hello'),
     ('foo', 3, 4),
]

def do_foo(x,y):
    print('foo', x, y)

def do_bar(s):
    print('bar', s)

for tag, *args in records:
    if tag == 'foo':
	do_foo(*args)
    elif tag == 'bar':
	do_bar(*args)

from collections import Iterable

def flatten(items, ignore_types=(str, bytes)):
    for x in items:
	if isinstance(x, Iterable) and not isinstance(x, ignore_types):
	    yield from flatten(x)
	else:
	    yield x

items = [1, 2, [3, 4, [5, 6], 7], 8]

# Produces 1 2 3 4 5 6 7 8
for x in flatten(items):
    print(x)

items = ['Dave', 'Paula', ['Thomas', 'Lewis']]
for x in flatten(items):
    print(x)

import heapq

class PriorityQueue:
    def __init__(self):
	self._queue = []
	self._index = 0

    def push(self, item, priority):
	heapq.heappush(self._queue, (-priority, self._index, item))
	self._index += 1

    def pop(self):
	return heapq.heappop(self._queue)[-1]

# Example use
class Item:
    def __init__(self, name):
	self.name = name
    def __repr__(self):
	return 'Item({!r})'.format(self.name)

q = PriorityQueue()
q.push(Item('foo'), 1)
q.push(Item('bar'), 5)
q.push(Item('spam'), 4)
q.push(Item('grok'), 1)

print("Should be bar:", q.pop())
print("Should be spam:", q.pop())
print("Should be foo:", q.pop())
print("Should be grok:", q.pop())

import collections
d = collections.defaultdict(list)
d['a'].append('b')
d['c'].append('d')
log("d", d)

import builtins
from collections import ChainMap
pylookup = ChainMap(locals(), globals(), vars(builtins))

from collections import Counter
ct = Counter('abracadabra')
print(ct)
ct.update('aaaaazzz')
print('after update'.center(30, '='))
print(ct)
print(ct.most_common(2))

class MyDict(dict):
    def __setitem__(self, key, value):
	super().__setitem__(key, value*2)

d = MyDict(one=1)
print(d)

d['two'] = 2
print(d)

d.update(three=3)
print(d)

from types import MappingProxyType
d = {1: 'A'}
d_proxy = MappingProxyType(d)
print(d_proxy)

log("d_proxy[1]", d_proxy[1])

try:
    d_proxy[2] = 'x'
except Exception as e:
    print(e)

d[2] = 'B'
print(d_proxy)

a = {
   'x' : 1,
   'y' : 2,
   'z' : 3
}

b = {
   'w' : 10,
   'x' : 11,
   'y' : 2
}

print('Common keys:', a.keys() & b.keys())
print('Keys in a not in b:', a.keys() - b.keys())
print('(key,value) pairs in common:', a.items() & b.items())

a = {'x': 1, 'z': 3 }
b = {'y': 2, 'z': 4 }

# (a) Simple example of combining
from collections import ChainMap
c = ChainMap(a,b)

print("c:", c)

print(c['x'])      # Outputs 1  (from a)
print(c['y'])      # Outputs 2  (from b)
print(c['z'])      # Outputs 3  (from a)

# Output some common values
print('len(c):', len(c))
print('c.keys():', list(c.keys()))
print('c.values():', list(c.values()))

# Modify some values
c['z'] = 10
c['w'] = 40
del c['x']
print("a:", a)

# Example of stacking mappings (like scopes)
values = ChainMap()
values['x'] = 1

# Add a new mapping
values = values.new_child()
values['x'] = 2

# Add a new mapping
values = values.new_child()
values['x'] = 3

print(values)
print(values['x'])

# Discard last mapping
values = values.parents
print(values)
print(values['x'])

# Discard last mapping
values = values.parents
print(values)
print(values['x'])

from unicodedata import name

for i in range(250, 256):
    print(chr(i), ":", name(chr(i), ''))

! chardetect ~/test.org

import getpass

user = getpass.getuser()
passwd = getpass.getpass()

print('User:', user)
print('Passwd:', passwd)

import struct
fmt = '<1s3sHHH'
with open('img/p3_hash.png', 'rb') as fp:
    img = memoryview(fp.read())

header = img[:10]
log("bytes(header)", bytes(header))
log("struct.unpack(fmt, header)", struct.unpack(fmt, header))

from calendar import month_abbr
print(list(month_abbr))

print('{:06.2f}'.format(3.141592653589793))
print('{:04d}'.format(42))
print('{:+d}'.format(42))
print('{: d}'.format(42))
print('{: d}'.format(-42))
print('{:=5d}'.format((- 23)))
print('{:=+5d}'.format((23)))

import inspect
def foo(a, b=1, **c):
    pass

args = {'a': 1, 'b': 2, 'x': '1', 'y': '2'}
sig = inspect.signature(foo)
bound_args = sig.bind(**args)
log("bound_args", bound_args)
print()
for name, value in bound_args.arguments.items():
    print(name, '=', value)

print()
del args['a']
try:
    bound_args = sig.bind(**args)
except Exception as e:
    print(e)

import functools
import operator
log("functools.reduce(operator.xor, range(6))", functools.reduce(operator.xor, range(6)))
log("functools.reduce(operator.mul, range(1, 7))", functools.reduce(operator.mul, range(1, 7)))

from operator import itemgetter

data = [
    ('c', 2),
    ('b', 3),
    ('a', 1)
]

log("sorted(data, key=itemgetter(0))", sorted(data, key=itemgetter(0)))

log("[itemgetter(1, 0)(t) for t in data]", [itemgetter(1, 0)(t) for t in data])

metro_data = [
    ('Tokyo', 'JP', 36.933, (35.689722, 139.691667)),
    ('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889)),
    ('Mexico City', 'MX', 20.142, (19.433333, -99.133333)),
    ('New York-Newark', 'US', 20.104, (40.808611, -74.020386)),
    ('Sao Paulo', 'BR', 19.649, (-23.547778, -46.635833))
]

from collections import namedtuple
LatLong = namedtuple('LatLong', 'lat long')
Metropolis = namedtuple('Metropolis', 'name cc pop coord')
metro_areas = [Metropolis(name, cc, pop, LatLong(lat, long))
	       for name, cc, pop, (lat, long) in metro_data]


log("metro_areas[0]", metro_areas[0])
name_lat = attrgetter('name', 'coord.lat')
log("name_lat(metro_areas[0])", name_lat(metro_areas[0]))
print()

from operator import attrgetter
for city in sorted(metro_areas, key=attrgetter('coord.lat')):
    print(name_lat(city))

from operator import methodcaller
s = "hello world"
log("methodcaller('upper')(s)", methodcaller('upper')(s))
log("methodcaller('replace', ' ', '-')(s)", methodcaller('replace', ' ', '-')(s))

import functools
import time

def clock(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
	t0 = time.perf_counter()
	result = func(*args, **kw)
	elapsed = time.perf_counter() - t0
	name = func.__name__
	arg_lst = []
	if args:
	    arg_lst.append(', '.join(repr(arg) for arg in args))
	if kw:
	    pairs = ['{}={}'.format(k, w) for k, w in sorted(kw.items())]
	    arg_lst.append(', '.join(pairs))
	arg_str = ', '.join(arg_lst)
	print("[{:0.8f}] {}({}) -> {}".format(elapsed, name, arg_str, result))
	return result
    return wrapper

@clock
def snooze(t):
    time.sleep(t)

snooze(0.1)
snooze(0.2)
snooze(0.3)

@clock
def fib(n):
    if n < 2: return n
    return fib(n-2) + fib(n-1)

print("result: ", fib(6))

import functools

@functools.lru_cache()
@clock
def fib(n):
    if n < 2:
	return n
    return fib(n-2) + fib(n-1)

print("result:", fib(6))

from functools import singledispatch
from collections import abc
import numbers
import html

@singledispatch
def htmlize(obj):
    content = html.escape(repr(obj))
    return '<pre>{}</pre>'.format(content)

@htmlize.register(str)
def _(text):
    content = html.escape(text).replace('\n', '<br>\n')
    return '<p>{0}</p>'.format(content)

@htmlize.register(numbers.Integral)
def _(n):
    return '<pre>{0} (0x{0:x})</pre>'.format(n)

@htmlize.register(tuple)
@htmlize.register(abc.MutableSequence)
def _(seq):
    inner = '</li>\n<li>'.join(htmlize(item) for item in seq)
    return '<ul>\n<li>' + inner + '</li>\n</ul>'


log("htmlize({1, 2, 3})", htmlize({1, 2, 3}))
log("htmlize(abs)", htmlize(abs))
log("htmlize('helloworld')", htmlize('helloworld'))
log("htmlize(42)", htmlize(42))
log("htmlize([1, 2, 3])", htmlize([1, 2, 3]))

from socket import socket, AF_INET, SOCK_STREAM

def echo_client(client_sock, addr):
    print("Got connection from", addr)

    # Make text-mode file wrappers for socket reading/writing
    client_in = open(client_sock.fileno(), 'rt', encoding='latin-1', closefd=False)
    client_out = open(client_sock.fileno(), 'wt', encoding='latin-1', closefd=False)

    # Echo lines back to the client using file I/O
    for line in client_in:
	client_out.write(line)
	client_out.flush()
    client_sock.close()

def echo_server(address):
    sock = socket(AF_INET, SOCK_STREAM)
    sock.bind(address)
    sock.listen(1)
    while True:
	client, addr = sock.accept()
	echo_client(client, addr)

print('Echo serving running on localhost:25000')
echo_server(('', 25000))

# Example of adding a text encoding to existing file-like object

import urllib.request
import io

u = urllib.request.urlopen('http://www.python.org')
f = io.TextIOWrapper(u, encoding='utf-8')
text = f.read()

print(text)

from io import StringIO
f = StringIO()
f.write('hello')
f.write(' ')
f.write('world!')
print(f.getvalue())

f = StringIO('Hello!\nHi!\nGoodbye!')
while True:
    s = f.readline()
    if s == '':  # eof
	break
    print(s, end='')

from io import BytesIO
f = BytesIO()
f.write('中文'.encode('utf-8'))
print(f.getvalue())

f = BytesIO(b'\xe4\xb8\xad\xe6\x96\x87')
r = f.read().decode('utf-8')
print(r)

import json

# Some JSON encoded text
s = '{"name": "ACME", "shares": 50, "price": 490.1}'

# (a) Turning JSON into an OrderedDict

from collections import OrderedDict
data = json.loads(s, object_pairs_hook=OrderedDict)
print(data)

class JSONObject:
    def __init__(self, d):
	self.__dict__ = d

data = json.loads(s, object_hook=JSONObject)
print(data.name)
print(data.shares)
print(data.price)

class Point:
    def __init__(self, x, y):
	self.x = x
	self.y = y

def serialize_instance(obj):
    d = { '__classname__' : type(obj).__name__ }
    d.update(vars(obj))
    return d

p = Point(3,4)
s = json.dumps(p, default=serialize_instance)
print(s)

classes = {
    'Point' : Point
}

def unserialize_object(d):
    clsname = d.pop('__classname__', None)
    if clsname:
	cls = classes[clsname]
	obj = cls.__new__(cls)
	for key, value in d.items():
	    setattr(obj, key, value)
	return obj
    else:
	return d

a = json.loads(s, object_hook=unserialize_object)
print(a)
print(a.x)
print(a.y)

from contextlib import closing

class Door:

    def open(self):
	print("door opened")

    def close(self):
	print("door closed")

with closing(Door()) as door:
    door.open()

from contextlib import suppress
import os

with suppress(FileNotFoundError):
    os.remove('somefile.tmp')

import io
from contextlib import redirect_stdout

f = io.StringIO()
with redirect_stdout(f):
    help(pow)

log("f.getvalue()", f.getvalue())

with open('/tmp/help.txt', 'w') as f:
    with redirect_stdout(f):
	help(pow)

from contextlib import contextmanager

class Query(object):

    def __init__(self, name):
	self.name = name

    def query(self):
	print('Query info about %s...' % self.name)

@contextmanager
def create_query(name):
    print('Begin')
    with suppress(Exception):
	yield Query(name)  # 绑定到 as 子句的目标变量
    print('End')

with create_query('Bob') as q:
    q.query()

@contextmanager
def tag(name):
    print("<%s>" % name, end='')
    with suppress(Exception):
	yield  # 无需使用 as 子句
    print("</%s>" % name)

with tag("h1"):
    print("hello", end='')

# Cached instances

import weakref

class Cached(type):
    def __init__(self, *args, **kwargs):
	super().__init__(*args, **kwargs)
	self.__cache = weakref.WeakValueDictionary()

    def __call__(self, *args):
	if args in self.__cache:
	    return self.__cache[args]
	else:
	    obj = super().__call__(*args)
	    self.__cache[args] = obj
	    return obj

class Spam(metaclass=Cached):
    def __init__(self, name):
	print('Creating Spam({!r})'.format(name))
	self.name = name

if __name__ == '__main__':
    a = Spam('foo')
    b = Spam('bar')
    print('a is b:', a is b)
    c = Spam('foo')
    print('a is c:', a is c)

# Singleton

class Singleton(type):
    def __init__(self, *args, **kwargs):
	self.__instance = None
	super().__init__(*args, **kwargs)

    def __call__(self, *args, **kwargs):
	if self.__instance is None:
	    self.__instance = super().__call__(*args, **kwargs)
	    return self.__instance
	else:
	    return self.__instance

class Spam(metaclass=Singleton):
    def __init__(self):
	print('Creating Spam')

if __name__ == '__main__':
    a = Spam()
    b = Spam()
    print(a is b)

# Not allowing direct instantiation

class NoInstances(type):
    def __call__(self, *args, **kwargs):
	raise TypeError("Can't instantiate directly")

class Spam(metaclass=NoInstances):
    @staticmethod
    def grok(x):
	print('Spam.grok')

if __name__ == '__main__':
    try:
	s = Spam()
    except TypeError as e:
	print(e)

    Spam.grok(42)