clock.tick() in the Pygame documentation:

tick()

update the clock

tick(framerate=0) -> milliseconds

This method should be called once per frame. It will compute how many milliseconds have passed since the previous call.

If you pass the optional framerate argument the function will delay to keep the game running slower than the given ticks per second. This can be used to help limit the runtime speed of a game. By calling Clock.tick(40) once per frame, the program will never run at more than 40 frames per second.

Note that this function uses SDL_Delay function which is not accurate on every platform, but does not use much CPU. Use tick_busy_loop if you want an accurate timer, and don't mind chewing CPU.

So the clock.tick() returns the time since the last call to clock.tick(), use that value to multiply all your speeds with it when you move. Example

dt = clock.tick(60)
player.position.x += player.xSpeed * dt
player.position.y += player.ySpeed * dt

This way your player will always move at the same speed regardless of what you put into the clock.tick() function

what is the meaning of the sleep_time variable in this example?

The time required to process a single frame will be calculated for each frame. If it takes less than 1/60th of a second (i.e. sleep_time will be bigger than 0), put the process on hold for the remained of the 1/60th of a second, so that this frame actually takes 1/60th of a second.

time.sleep(sleep_time) suspends the thread for at least the duration of sleep_time (it may be longer).

how does dt help me limit fps

So in this example, the dt will be used to make sure you have a fixed/constant time step of FPS.

Sort of.

This way of limiting the framerate is not very good. I've modified the example in the question a bit with "printouts":

import time

prev_time = time.time()
FPS = 60
STEP_TIME = 1./FPS
running = True

count = 0
accum = 0

while running:
    current_time = time.time()
    dt = current_time - prev_time
    accum += dt
    count += 1
    if accum >= 1.0:
        accum -= 1.0
        print(count)
        count = 0
      
    prev_time = current_time
    sleep_time = STEP_TIME - dt
    if sleep_time > 0:
        time.sleep(sleep_time)

With the results:

% py main.py
64
64
68
62
62
62

We don't get 60hz. For two reasons:

First, as mentioned, time.sleep(sleep_time) will guarantee that the thread sleeps for at least this amount of time. That is how the OS works. So you can't control precisely how long your program will be sleeping.

Second, let's take a closer look at dt.

dt = prev_time - current_time

so the dt is the time spent during the previous frame. That's fine and all, and it would likely work if we didn't want to throttle the framerate. The problem comes when we want to sleep. When we call time.sleep(sleep_time), we're actually calling time.sleep(1./FPS - (prev_time - current_time)). We're actually fixing last frames time. This has a nasty effect of having some frames where we'll sleep, and other frames where we'll not sleep, resulting inconsistent frame times, at least from the user perspective; adding print(dt, sleep_time) at the end of the previous code snippet, we get something like:

% py main.py
0.0 0.016666666666666666
0.03285384178161621 -0.016187175114949545
0.0 0.016666666666666666
0.033695220947265625 -0.01702855428059896
0.0 0.016666666666666666
0.03452634811401367 -0.017859681447347005
0.0 0.016666666666666666
0.03141927719116211 -0.014752610524495443
0.0002942085266113281 0.01637245814005534
0.032390594482421875 -0.01572392781575521
0.0 0.016666666666666666
0.031510353088378906 -0.01484368642171224
0.0 0.016666666666666666
0.019999265670776367 -0.0033325990041097008
0.0005021095275878906 0.016164557139078776
0.03202223777770996 -0.015355571111043295
0.0006344318389892578 0.01603223482767741
0.03662467002868652 -0.019958003362019857
0.0 0.016666666666666666

To control the frame rate, I generally prefer the "busy loop" approach, which offers a more fine grained control w.r.t. using any sleep methods.

import time

prev_time = time.perf_counter()
current_time = prev_time
FPS = 60
STEP_TIME = 1./FPS
running = True

count = 0
accum = 0

while running:
    prev_time = current_time
    current_time = time.perf_counter()
    dt = current_time - prev_time

    accum += dt
    count += 1
    if accum >= 1.0:
        accum -= 1.0
        print(count)
        count = 0
    # print(dt)

    # busy loop, where we just wait this frame's time to pass
    while time.perf_counter() < (current_time + STEP_TIME):
        pass

Please note that instead of time.time(), I use time.perf_counter() which is much more precise for what we need to do.

With this method, I get this for the actual frame rate:

% py main.py
61
60
60
60
60
60
60
60

and this for individual frame time:

% py main.py
2.100015990436077e-06
0.016670000040903687
0.016669799922965467
0.016668600030243397
0.016668600030243397
0.016668800031766295
0.016668399912305176
0.01667120005004108
0.016669100034050643
0.016668599913828075
0.016668800031766295
0.016668800031766295
0.016668600030243397
0.016668399912305176
0.016669300035573542
0.0166680000256747
0.016668400028720498
0.016668399912305176
0.0166680000256747

Although dt is still about last frame's time, we're still controlling how this frame's time is spent.

get_fps() only gives a correct result, when you call tick() once per frame:

clock = pygame.time.Clock()
run = True
while run:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            run = False          

    clock.tick()
    print(clock.get_fps())

    # [...]

See the documentation of get_fps()

get_fps() compute the clock framerate

get_fps() -> float

Compute your game's framerate (in frames per second). It is computed by averaging the last ten calls to Clock.tick().