Python - Get random color, given a seed number as fast as possible

Question

I need to find a random color, given a specific seed number - fast. given the same ID twice, should return the same color.

I did this:

def id_to_random_color(number):
    random_bytes = hashlib.sha1(bytes(number)).digest()
    return [int(random_bytes[-1]) / 255, int(random_bytes[-2]) / 255, int(random_bytes[-3]) / 255, 1.0]

The problem is that calculating the sha1 of numbers many times is very slow in total. (I'm using this function about 100k times)

Edit: The reason I use a hash function is that I want to have colors that are different for numbers that are close

e.g id_to_random_color(7) should be very different from id_to_random_color(9)

Answer 1

Using simple random number generators with kind of static variables could improve performance:

import random
prev, r, g, b = None, 0, 0, 0
def id_to_random_color(number):
    global prev, r, g, b
    if number != prev:
        r = random.random()
        g = random.random()
        b = random.random()
        prev = number
    return r, g, b, 1.0

Update:
As AndrewMcDowell stated in his comment, the function could return different values if the input is repeated in not sequential occasions.
Here is a possible workaround:

import random
memory = {}
def id_to_random_color(number, memory):
    if not number in memory:
        r = random.random()
        g = random.random()
        b = random.random()
        memory[number] = (r, g, b, 1.0)
    return memory[number]

Further update:
The same function skeleton could be used even to calculate hash:

memory = {}
def id_to_random_color(number):
    if not number in memory:
        numByte = str.encode(number)
        hashObj = hashlib.sha1(numByte).digest()
        r, g, b = hashObj[-1] / 255.0, hashObj[-2] / 255.0, hashObj[-3] / 255.0
        memory[number]= (r, g, b, 1.0)
        return r, g, b, 1.0
    else:
        return memory[number]

Despite it is a bit more verbose syntax, the else statement improves a bit performances, avoiding subsequent memory write and read (as Jake stated in his answer).