Optimal Primes

def largest_prime_factor(number):
    """Returns largest prime factor of a number."""
    # Start at 2 and walk upward.
    # The first number to divide into our number 
    # evenly has to be prime (I think).

    for i in range(2, number):
        if number % i == 0:

            # If we find a number, divide that out.
            # We've pulled out a factor.  Start the process over,
            # Nibbling away at the remaining factors until
            # only one remains.  This would be the largest prime!

            new_number = number//i

            # This is the fun part.  Recursive solution!
            return largest_prime_factor(new_number)

    # This is the implicit base case, when no number divides evenly,
    # we have found the last prime factor.  Cool, right??
    return number

# First I'm going to need some help from the standard library
from collections import Counter
from functools import reduce

# I'll also need this helper function to get the
# prime factors of each number.
def prime_factors(number):
    """Returns a list of the prime factors of a number"""

    # You'll note that this solution looks eerily similar to the
    # previous section
    for i in range(2, number+1):
        if number % i == 0:

            # The only difference is that this time I want to hang
            # on to each of the values, so I'm using a GENERATOR!
            yield i

            # I'm also using the brand spanking new (ish)
            # yield from keyword which allows my GENERATOR to
            # delegate yielding to another GENERATOR
            # or, in this case, the same one on the next recursion!
            yield from prime_factors(number//i)

            # I use a break statement to simulate the multiple level
            # jump out that the return statement gave me.
            break

# Just for clarity, here's an example of the above function:
# prime_factors(24) => <Generator> [2, 2, 2, 3]

# Now the real meat of the problem.
def smallest_common_multiple(numbers):
    """Takes a set of numbers and returns smallest common multiple"""

    # I could do everything with a plain dictionary, but this will
    # speed up everything I want.  Counters also have some shwoopy
    # Binary operator capabilities.
    primes = Counter()
    # Start with a number.
    for number in numbers:
        # See if we have enough primes to make it
        # If not, add the missing primes
        these_primes = Counter(prime_factors(number))
        # if number was 12, this line would return {2: 2, 3: 1}
        # This is the required number of each prime to make up 12.

        # Fancy binary operator action.  Equivalent to doing this:
        # primes = max(primes, these_primes) for each key in primes.
        primes = primes | these_primes
        # Thus, if primes was currently {2: 1, 3: 1}, and we needed another
        # 2 to make 12, primes[2] would be updated to be 2: 2.
        # primes[3] would be left at 1.

    # Multiply all primes to get the smallest possible multiple!
    # Using a little functional programming instead of a multiline for loop.
    # The following line is the multiplication analog to sum().
    # primes.elements() spits out list of 'key' repeated 'value' times.
    # e.g. {2: 2, 3: 1} becomes [2, 2, 3].
    return reduce(lambda x, y: x*y, primes.elements())