Andrey Dugin

>>> s = '123456789'

>>> from textwrap import wrap
>>> wrap(s, 3)
['123', '456', '789']

>>> map(''.join, zip(*[iter(s)]*3))
['123', '456', '789']

Нужно увеличить кэш:

>>> import re
>>> re._MAXCACHE
100
>>> re._MAXCACHE = 3000
>>> re._MAXCACHE
3000

Подозреваю, что при этом re.compile() в явном виде использовать не обязательно.

Используйте join():

>>> from timeit import timeit
>>> def f1(s1='foo', s2='bar'):
	return ' - '.join((s1, s2))

>>> f1()
'foo - bar'
>>> def f2(s1='foo', s2='bar'):
	return '{0} - {1}'.format(s1, s2)

>>> f2()
'foo - bar'
>>> def f3(s1='foo', s2='bar'):
	return '%s - %s' % (s1, s2)

>>> f3()
'foo - bar'
>>> timeit(f1)
0.7238124336211288
>>> timeit(f2)
1.3038862714413124
>>> timeit(f3)
0.8215918286469828

Пока удалось родить такое кривенькое решение. При каждом обращении атрибут пересчитывается заново. Хорошо бы добавить memoization. Но, по крайней мере, работает:

>>> def namedtuplex(*args, **kwargs):
    def getitem(self, key):
        if type(key) is str:
            value = getattr(self, key)
        else:
            value = tuple.__getitem__(self, key)
        if type(value) is str:
            value = value.strip('"')
            try:
                value = eval(value)
            except:
                value = intern(value)
        return value
    ntuple = collections.namedtuple(*args, **kwargs)
    ntuple.__getitem__ = getitem
    return ntuple

>>> XDR = namedtuplex('XDR', 'a b c d e f g')
>>> xdr = XDR('"abc"', 'def', '5', '"3.14"', 2.71, [1,2], None)
>>> xdr.a
'abc'
>>> xdr.b
'def'
>>> xdr.c
5
>>> xdr.d
3.14
>>> xdr.e
2.71
>>> xdr.f
[1, 2]
>>> xdr.g
>>> xdr['a']
'abc'
>>> xdr['b']
'def'
>>> xdr['c']
5
>>> xdr['d']
3.14
>>> xdr['e']
2.71
>>> xdr['f']
[1, 2]
>>> xdr['g']
>>>

В зависимость от конкретного применения можно сделать что-то такое:
eval(value.strip('"'))
Либо разбирать непосредственно через int() и float() в блоках try..except.

Пока додумался до такого метода:

xcache = dict()
while cache:
    	key, val = cache.iteritems().next()
    	xcache[cache.pop(key)] = key

Такой способ в 3 раза величивает время исполнения скрипта (с 60 до 180 секунд на моём ноутбуке) по сравнению с традиционным методом инвертирования "в лоб". Есть ли способ лучше?

Update #1: Тоже тормозит.

xcache = dict()
cpop = cache.pop
while cache:
    key = cache.iterkeys().next()
    xcache[cpop(key)] = key
del cache

Update #2: Вот так скорость вернулась на значение 60 секунд. Что ещё?

xcache = dict()
cpop = cache.popitem
while cache:
    key, val = cpop()
    xcache[val] = key
del cache

>>> float('inf')
inf
>>> float('-inf')
-inf
>>> -float('inf')
-inf
>>> infinity = float('inf')
>>> 42 < infinity
True

Для начала - приведите в норму режим и питание. Всё остальное - примочки.

Отвечая непосредственно на вопрос:

Тяжёлая артиллерия - пропейте курс витаминов Animal Pak от Universal Nutrition. Но Там реально конские дозировки, так что злоупотреблять не стоит. Но зато уже через две недели почувствуете существенный прирост энергичности.
sportwiki.to/Animal_Pak_(Universal)

Попроще, но тоже очень хорошие - Opti-Men от Optimum Nutrition:
sportwiki.to/Opti-Men_(Optimum_Nutrition)

Ну и в целом: http://sportwiki.to/Категория:Здоровье

Самое простое и эффективное решение без лишних действий:

from collections import Counter

def min_unique(dictionary):
    minval, result = float('inf'), None
    counter = Counter(dictionary.itervalues())
    for key, val in dictionary.iteritems():
        if (val < minval) and (counter[val] == 1):
            minval = val
            result = (key, val)
    return result

data = {'a': 23, 'b': 26, 'c': 45, 'd': 23}
print min_unique(data)

Или так:

from operator import itemgetter
from itertools import ifilter

def min_unique(dictionary):
    inverted = dict()
    for key, value in dictionary.iteritems():
        inverted[value] = None if value in inverted else key
    filtered = ifilter(itemgetter(1), inverted.iteritems())
    try:
        value, key = min(filtered, key=itemgetter(0))
    except ValueError:
        value, key = None, None
    return key, value

Ещё интересный вариант с итераторами (узкое место - сортировка):

from operator import itemgetter
from itertools import groupby

def min_unique(dictionary, ig=itemgetter(1)):
    grouped = groupby(sorted(dictionary.viewitems(), key=ig), key=ig)
    for key, entries in grouped:
        entry = entries.next()
        try:
            entries.next()
        except StopIteration:
            return entry
        else:
            continue

exec()
eval()
также посмотрите в исходники класса namedtuple модуля collections

>>> exec('a = [1,2,3]')
>>> a
[1, 2, 3]

1) Надо использовать float(), а не int()
2) Конструкция 'from __future__ import division' тоже может пригодиться.

>>> from math import sqrt
>>> def solver():
    try:
        a, b, c = map(float, raw_input('Введите a, b, c через пробел: ').split())
    except:
        print 'На колу мочало - начинай сначала!'
    else:
        d = b*b - 4*a*c
        if d >= 0:
            sd = sqrt(d)
            root = lambda k: '{:.6f}'.format((-b+k*sd)/(2*a))
            solution = ' и '.join(set(map(root, (-1,1))))
        else:
            solution = 'уравнение не имеет решений'
        print 'Ответ: %s' % solution

>>> solver()
Введите a, b, c через пробел: 1, 2 3
На колу мочало - начинай сначала!
>>> solver()
Введите a, b, c через пробел: 1 2 3
Ответ: уравнение не имеет решений
>>> solver()
Введите a, b, c через пробел: 4 9 1
Ответ: -0.117218 и -2.132782
>>>

>>> s = 'abc<def*gh?ikl'
>>> s.translate(None, '\/:*?"<>|')
'abcdefghikl'