Legal, também pensei em fazer algo assim. Ir mostrando os pontos conforme as rodadas iam avançando.

Porém, percebi que ficaria fácil de encontrar o número secreto, pois bastaria verificar a diferença entre 1000 e o número de pontos atual e verificar se o chute foi maior ou menor. Pronto, assim seria possível saber qual era o número secreto logo após a primeira tentativa. Então, desisti da ideia de ir atualizando a pontuação

Mas ainda pensando em dificuldade, pensei fazer com que a dificuldade afetasse a pontuação final. Fiz com que na dificuldade "fácil", o jogador tivesse apenas 50% da pontuação total. Na dificuldade "média", o jogador tivesse 75% e na "difícil", ele tivesse 100% dela.

Meu código final acabou ficando assim:

import random

print("********************************")
print("Bem vindo ao jogo de advinhação!")
print("********************************")

numero_secreto = round(random.randrange(1,101)) #não-inclusive
numero_de_tentativas = 3
rodada = 1
pontos = 1000

print("Qual é o nível de dificuldade?")
print("(1) Fácil (2) Médio (3) Difícil")
dificuldade = int(input("Digite o nível de dificuldade desejado:"))

if (dificuldade == 1):
    numero_de_tentativas = 20

elif (dificuldade == 2):
    numero_de_tentativas = 10

else:
    numero_de_tentativas = 5

while (rodada <= numero_de_tentativas):
    print("Tentativa {} de {}".format(rodada, numero_de_tentativas))
    chute = int(input("Digite um número entre 1 e 100: "))
    print("Você digitou", chute)

    if (chute < 1 or chute > 100):
        print("Você digitou um número fora do intervalo!")
        rodada = rodada + 1
        continue

    chute_certo = chute == numero_secreto
    chute_maior = chute > numero_secreto
    chute_menor = chute < numero_secreto
    pontos_perdidos = abs(numero_secreto-chute)


    if (chute_certo):
        print("Você acertou!")
        break

    else:
        if(chute_maior):
            print("Você errou! O seu chute foi maior do que o número secreto.")

        elif(chute_menor):
            print("Você errou! O seu chute foi menor do que o número secreto.")

    pontos = pontos - pontos_perdidos
    rodada = rodada + 1

if (rodada > numero_de_tentativas and chute_certo == False):
    pontos = 0
    print("O número correto era {}".format(numero_secreto))

if (dificuldade == 1):
        pontos = round(pontos * .5)

elif (dificuldade == 2):
    pontos = round(pontos * .75)

print("Fim do jogo")
print("Sua pontuação final foi de {} pontos".format(pontos))

Legal! Interessante a sua ideia.

Tive uma outra ideia par dificultar do jogador descobrir qual o numero secreto. Criei uma variável chamadadiminui_pontos = random.randrange(1, 101) que gera um número aleatório de 1 a 100 a cada vez que vamos jogar. Esse número gerado, é o número que diminui menos o número secreto gerado também aleatório. Assim fica mais dificíl de saber qual é número secreto. Observe o código abaixo!

Código completo

import random

print("*********************************")
print("Bem vindo ao jogo de Adivinhação!")
print("*********************************")

numero_secreto = random.randrange(1, 101)
diminui_pontos = random.randrange(1, 101) # Variável que substituirá a variável chute para dificultar a possibilidade do jogador descobrir qual o número secreto
total_de_tentativas = 0
pontos = 1000

print("Qual o nível de dificuldade?")
print("(1) Fácil (2) Médio (3) Difícil")

nivel = int(input("Define o nível: "))

if(nivel == 1):
    total_de_tentativas = 20
elif(nivel == 2):
    total_de_tentativas = 10
else:
    total_de_tentativas = 5

print(numero_secreto)


#  variável/em/série/n°inicial, /n°Final, /step, => intervalo entre os elementos
for rodada in range(1, total_de_tentativas + 1):
    print("Tentativa {} de {}".format(rodada, total_de_tentativas))
    #print(f"Tentativa {rodada} de {total_de_tentativas}") # f-strings ou formatted string literals => novo recurso a partir do python 3.6
    chute_str = input("Digite o seu número: ")
    print("Você digitou " , chute_str)
    chute = int(chute_str)

    if (chute < 1 or chute > 100):
        print("Você deve digitar um número entre 1 e 100!")
        continue

    acertou = chute == numero_secreto
    maior = chute > numero_secreto
    menor = chute < numero_secreto

    # desconta e atualiza os pontos atual
    # Para dar sinal positivo sempre. Ex: se der menos, transforma em mais
    desconta_pontos = pontos_perdidos = abs(numero_secreto - diminui_pontos)
    atualiza_pontos = pontos = pontos - pontos_perdidos


    if(acertou):
        print("Parabéns! Você acertou e fez {} pontos!".format(pontos))
        break
    else:
        if(maior):
            print("Você errou! O seu chute foi maior do que o número secreto! Seu placar agora é de {} pontos!".format(pontos))
            if(rodada == total_de_tentativas):
                print("O número secreto era {}. Você fez {}".format(numero_secreto, pontos))
            desconta_pontos
            atualiza_pontos
        elif(menor):
            print("Você errou! O seu chute foi menor do que o número secreto! Seu placar agora é de {} pontos!".format(pontos))
            if(rodada == total_de_tentativas):
                print("O número secreto era {}. Você fez {}".format(numero_secreto, pontos))
            desconta_pontos
            atualiza_pontos

    # rodada = rodada + 1

print("Fim do jogo")

# Abaixo:

# random() => função que gera números aleatórios (precisa ser importado --> import random) Obs: random é uma função que está em um módulo separado, por importar
# round() => função que arredonda o número. Exemplo: 18.895629671768187 para 19 (arredonda pelo mais aproximado)
# random.random() => gera números aleatórios de 0.0 a 1.0
# random.randrange(10) => de 0 a 10
# random.randrange(0, 101) => 0 a 100 inclusivo
# seed => é as entradas dadas a cada chamada da função random e cada seed é utilizado como entrada por padrão os milisegundos(hora). Ou seja, cada milisegundos representa uma entrada e por isso acaba gerando números aleatórios. Lembrando que se repetir a entrada, repete o mesmo número a cada chamada da função random ou a cada sorteio
# pseudo-random => o python recebe esse nome pelo motivo de saber gerar número aleatórios de verdade
# Importante! "funções built-in" => As funções built-in podem ser chamadas a qualquer momento, em todos os lugares. Exemplo de funções são type(..), abs(), input(..) ou int.

##############################################

# Abaixo: funções random e round para fins didáticos

#import random

#numero_random = random.random() * 100
#print(numero_random)

#numero_round = round(numero_random)
#print(numero_round)

##############################################