Defining a function for demand pattern

I'm trying to create a function that creates a list like this (so in the same form) and does the following.

d = {
(1, 1): 1, (1, 2): 1, (1, 3): 1, 
(2, 1): 0, (2, 2): 2, (2, 3): 1,
(3, 1): 1, (3, 2): 0, (3, 3): 2, 
(4, 1): 0, (4, 2): 1, (4, 3): 2,
(5, 1): 2, (5, 2): 0, (5, 3): 1, 
(6, 1): 1, (6, 2): 1, (6, 3): 1,
(7, 1): 1, (7, 2): 0, (7, 3): 2, 
(8, 1): 2, (8, 2): 1, (8, 3): 0
}

In the brackets is the (worker,shift) combination. There should be any combination. In addition, on all possible (worker,shift)-combinations 3 are to be divided arbitrarily. Since there are only three combinations per worker (3 shifts) thus e.g. (worker 1,shift 1) u. (worker 1,shift 2) u. (worker 1,shift 3) shall be distributed on these three shifts randomly three thus e.g. (worker 1,shift 1): 1, (worker 1,shift 2): 0, (worker 1,shift 3): 2.

I also want to pass a value to the function that indicates how many workers there are.
My code so far looks like this:
import random

import random

def generate_cost(num_days):
    cost = {}
    shifts = [1, 2, 3]
    for day in range(1, num_days+1):
        cost[day] = {}
        available_shifts = shifts.copy()
        for shift in shifts:
            cost[(day, shift)] = 0
        num_costs = 3
        for _ in range(num_costs):
            if len(available_shifts) > 0:
                shift = random.choice(available_shifts)
                cost[(day, shift)] += 1
                available_shifts.remove(shift)
            else:
                break
    return cost

num_days = 14
demand = generate_cost(num_days)
print(demand)

It almost works, unfortunately there is always a

1: {}, or 2: {} 

before each worker. How do I get rid of this?

Just remove cost[day] = {} that is useless

Then your code doesn't do what you asked, as you are randomly picking from a list until that list is empty, you're doing the same as iterating on it, and giving 1 to each

shift = random.choice(available_shifts)
cost[(day, shift)] += 1
available_shifts.remove(shift)

Resulting in (1, 1): 1, (1, 2): 1, (1, 3): 1 for every worker

I suggest you pick a value between 0 and 3 for the first shift, then between 0 and the remaining, and for the final shift just the remaining

def generate_cost(num_days):
    cost = {}
    shifts = [1, 2, 3]
    for day in range(1, num_days + 1):
        num_costs = 3
        for shift in shifts[:-1]:
            shift_cost = random.randrange(0, num_costs)  # pick 0, 1 or 2
            cost[(day, shift)] = shift_cost
            num_costs -= shift_cost
        # latest shift has the remaining
        cost[(day, shifts[-1])] = num_costs
    return cost

The cost[day] = {} line is the one adding the extraneous items.

The whole thing could be simplified by generating the random spreads using the sum of 3 values selected randomly from [100, 10, 1]. This would produce 3 digit numbers with a sum of digits that is always equal to 3.

Then break down these numbers (using division and modulo) to use each digit as the value for the 3 shifts of the corresponding day.

num_days = 5
spreads = (sum(random.choices([100,10,1],k=3)) for _ in range(num_days))
demand  = { (d,s+1):v//10**s%10 for d,v in enumerate(spreads,1)
                                for s   in range(3) }    
print(*demand.items(),sep="\n")

((1, 1), 1)
((1, 2), 2)
((1, 3), 0)
((2, 1), 0)
((2, 2), 3)
((2, 3), 0)
((3, 1), 2)
((3, 2), 0)
((3, 3), 1)
((4, 1), 1)
((4, 2), 1)
((4, 3), 1)
((5, 1), 2)
((5, 2), 0)
((5, 3), 1)

If you have different numbers of shifts or a different total to spread, you could generalize this by writing a function to generate the random spread:

def randSpread(total,count):
    base = total + 1
    spread = sum(random.choices([base**i for i in range(count)],k=total))
    return [spread//base**i%base for i in range(count)]

which you can use directly in the dictionary comprehension:

num_days = 5
demand   = { (d,s):int(v) for d    in range(1,num_days+1)
                          for s,v  in enumerate(randSpread(13,4),1) }  
((1, 1), 3)
((1, 2), 4)
((1, 3), 2)
((1, 4), 4)
((2, 1), 2)
((2, 2), 5)
((2, 3), 5)
((2, 4), 1)
((3, 1), 3)
((3, 2), 4)
((3, 3), 3)
((3, 4), 3)
((4, 1), 2)
((4, 2), 4)
((4, 3), 3)
((4, 4), 4)
((5, 1), 4)
((5, 2), 2)
((5, 3), 2)
((5, 4), 5)