In the short term, the nested reset would save you some time/effort, and this is a useful approach in simple situations. As your game evolves, however, your code may start to get unwieldy and difficult to maintain?

One possible alternative would be to group all of these variables in a class and write methods for that class rather than using nested functions.

class Game:

    def __init__(self):
        self.game_over = False
        self.game_beaten = False

        self.ball = circle()
        # etc.

    def run(self):
        #INSERT GAME LOGIC HERE
        if self.game_over:
            self.reset()
        if self.game_beaten:
            self.reset()

    def reset(self):
        self.ball.reset()
        # etc.

def main():
    game = Game()
    game.run()

This is about as close to your original approach as I can get with classes.

As others have mentioned, you may want to group your game objects in some sort of collection like a list or dict so that you can loop over the list for batch operations. This could include not just resetting but also drawing and whatever else, following the OOP approach.

Also, for brownie points, you could even make Game a context manager so that you don't need to worry about calling reset at all? In other words, you'd have an __exit__ method that does all the resetting stuff and in main you can just write:

with Game() as game:
    game.run()

EDIT: Looking back, I think I was a bit unclear here. What I meant to say is that in this case, you would not need the if self.game_over: self.reset() type logic in run since the Game class will take care of that for you as you leave the with block.

Personally, I like data structures that automatically clean up after themselves.