Bug: Dice Pair vs 3 of a Kind

The condition:

if dice1 == dice2 or dice1 == dice3 or dice2 == dice3:

evaluates as True for 3 of a kind, so this should be after dice1 == dice2 == dice3:

if dice_1 == dice_2 == dice_3:
    # do things
elif dice_1 == dice_2 or ...:
    # other things

Don't Repeat Yourself: Functions

You can see that in your player1 and player2 blocks, the code is about the same. This is a great place to introduce functions for repeatedly executed code:

def roll_dice():
    print('Rolling the dice...')
    time.sleep(.5)

    a, b, c = [random.randint(1, 6) for _ in range(3)]

    if a is b is c:
        print("Three of a kind! (5 points)")
        return 5
    elif a is b or a is c or b is c:
        print('You rolled a pair! (1 point)')
        return 1
        
    print("Unlucky, you missed! (0 points)")
    return 0

Let's return the score so that you can just add that to the user's score. Note that I'm using a list comprehension to build your dice rolls and unpacking that into each die.

Use a Container for player state

Let's use a dictionary to contain each player and their score:

players = {'player_1': 0, 'player_2': 0}

Then, when you add the score, you can do:

players[player] += score

To show how this works:

for player in players:
    score = roll_dice()
    players[player] += score

This also shows that you can iterate through the players rather than hand-coding each block.

You don't need step=1 in range

It's good to know that the argument exists for it, but it's 1 by default

__name__ == "__main__" guard

These are nice to have when you start to write modules/code that you might want to import and reuse without the whole program executing:

~snip~

# this is at the bottom
if __name__ == "__main__":
    main()

While we're here, let's introduce a main function to play the game:

def main():
    rounds_to_play = 4
    players = {'Player 1': 0, 'Player 2': 0}

    for i in range(rounds_to_play):
        print(f"Starting round {i}")

        for player in players:
            players[player] += roll_dice()

    print('Calculating winner...')
    time.sleep(3)

    # unpack from the dictionary
    (name_1, score_1), (name_2, score_2) = players.items()

    if score_1 > score_2:
        print(f"{name_1} wins!")
    elif score_1 == score_2:
        print("Draw!")
    else:
        print(f"{name_2} wins!")

sys args

It might be nice to pass the number of rounds (or even the number of players) as a command-line argument:

def main(num_rounds):
    players = {'Player 1': 0, 'Player 2': 0}

    for i in range(num_rounds):
        # rest of function

if __name__ == "__main__":
    num_rounds, *_ = sys.argv[1:]
    main(int(num_rounds))

This is a pretty simple way to do it, you could also look into argparse.ArgumentParser

Starting to learn at home is an excellent idea.

The code

It's not a great idea to hard-code score values for two players (and playern is not an obvious name for a score value variable). Better off using Counter.

time.sleep is anywhere from an annoyance ('about to start') to an outright lie ('calculating who the winner is', when no such calculation is being done - it's just sleeping). To pace the progress of the program, you could wait for a keypress - and I don't mean "are you ready to throw your dice? (y/n)", which... doesn't make sense. Why would a user ever say no? Instead, consider Press any key when you are ready to throw your dice.

You can use a comprehension to roll multiple dice into a list.

player1 = player1 + 1 is just player1 += 1.

while roll == 'y' doesn't make any sense, because you're only ever iterating once, and then setting your loop variable unconditionally at the end of the loop - get rid of the loop.

Lots of other things to learn, but this (and suggestions from C.Nivs) are a good start.

The game

This is sort of like the infamous Candy Land in that there are never actually any decisions made.

Consider spicing it up - what if the player decided whether to roll to increase their score, but with a risk that their round's score could be lost? (Something like double-or-nothing.)

Suggested

Other than the 'press any key' suggestion:

import random
from collections import Counter

n_players = 2
n_rounds = 4
n_dice = 3
points = Counter()

for round_number in range(n_rounds):
    print(f'Round {round_number+1}:')
    for player in range(n_players):
        dice = [random.randint(1, 6) for _ in range(n_dice)]
        print('  Player', player+1, 'rolled', ', '.join(str(d) for d in dice))

        match len(set(dice)):
            case 1:
                print('    WOW! You hit a three of a kind!', end=' ')
                round_points = 5
            case 2:
                print('    Well done! You rolled a pair', end=' ')
                round_points = 1
            case _:
                print('    Unlucky, you missed!', end=' ')
                round_points = 0

        print(f'({round_points}p)')
        points[player] += round_points
    print()

(_, hiscore), = points.most_common(1)
match [player for player, point in points.items() if point == hiscore]:
    case (winner,):
        print(f'Player {1+winner} is the winner with {hiscore} points!')
        print()
    case winners:
        print("It's a draw between players", ', '.join(str(p) for p in winners))

Round 1:
  Player 1 rolled 4, 1, 4
    Well done! You rolled a pair (1p)
  Player 2 rolled 6, 2, 6
    Well done! You rolled a pair (1p)

Round 2:
  Player 1 rolled 2, 2, 4
    Well done! You rolled a pair (1p)
  Player 2 rolled 6, 4, 1
    Unlucky, you missed! (0p)

Round 3:
  Player 1 rolled 3, 3, 3
    WOW! You hit a three of a kind! (5p)
  Player 2 rolled 3, 3, 2
    Well done! You rolled a pair (1p)

Round 4:
  Player 1 rolled 2, 3, 4
    Unlucky, you missed! (0p)
  Player 2 rolled 1, 4, 5
    Unlucky, you missed! (0p)

Player 1 is the winner with 7 points!