Collatz Conjecture in Python
One possible improvement is to use recursion and memoization to implement a "dynamic programming" solution. This uses the results of previous calculations to speed up the process, as you will end up calculating the same sub-sequences repeatedly. For example:

def memo(f):
    def func(*args):
        if args not in func.cache: 
            func.cache[args] = f(*args)
        return func.cache[args]
    func.cache = {}
    return func

@memo
def collatz(n):
    if n == 1:
        count, seq = 0, []
    elif n % 2:
        count, seq = collatz(3 * n + 1)
    else:
        count, seq = collatz(n // 2)
    return count + 1, [n] + seq


(Note the use of a decorator to implement the memoization.)

Now, once you've run:

&gt;&gt;&gt; collatz(10)
7, [10, 5, 16, 8, 4, 2, 1]


then e.g. collatz(8) can just be looked up from the cache, so future calculations aren't needed:

&gt;&gt;&gt; collatz.cache
{(1,): (1, [1]), (2,): (2, [2, 1]), (8,): (4, [8, 4, 2, 1]), 
 (4,): (3, [4, 2, 1]), (10,): (7, [10, 5, 16, 8, 4, 2, 1]), 
 (5,): (6, [5, 16, 8, 4, 2, 1]), (16,): (5, [16, 8, 4, 2, 1])}


The downsides of this are:


It uses up a lot of space; and
As it's recursive, a long sequence can hit the recursion limit and crash the program. 


Also, note that count == len(seq), so you don't necessarily have to return (and store) both.