import turtle
import random
import array
dotsX = []
dotsY = []
a = 0
b = 0
turtle.reset()
turtle.up()
def randomdot():
    turtle.up()
    a = random.uniform(-200, 200)
    b = random.uniform(-200, 250)
    dotsX.append(a)
    dotsY.append(b)
    turtle.goto(a,b)
    turtle.down()
    turtle.dot(5, "red")
    turtle.up()
       
def click(x,y):
    for schet in range(20):
        if dotsX[schet] == x and dotsY[schet] == y:
            turtle.dot(20, "red") 
            break  
def out():
    for num in range(len(dotsX)):
                     print(num, "x=", dotsX[num], end="  ***  ")
                     print(num, "y=",dotsY[num])
def nebo():
    j = 0;
    turtle.down()
    turtle.begin_fill()
    for i in range(2):
        turtle.forward(400)
        turtle.left(90)
        turtle.forward(450)
        turtle.left(90)
    turtle.end_fill()
    turtle.up()
    while j<20:
        randomdot()
        j = j + 1
    
def main():
    turtle.speed(0)
    turtle.width(10)
    turtle.color("black")
    turtle.goto(-200,-200)
    turtle.hideturtle()
    nebo()
    out()
    turtle.onscreenclick(click)
    
    
if __name__ == '__main__':
    main()
    turtle.mainloop()

 import pygame
import sys
import random
import time
from abc import ABCMeta, abstractmethod
class Color:
    Black = "#000000"
    Red = "#E70000"
    @staticmethod
    def get_color(color: str) -> pygame.Color:
        return pygame.Color(color)
class RectTools:
    @staticmethod
    def point_inside_rect(rect, point):
        result = point[0] > rect.left and point[0] < rect.left + rect.width and \
                 point[1] > rect.top and point[1] < rect.top + rect.height
        return result
class Timer:
    def __init__(self, delay, callback):
        self._delay = delay
        self.timeStamp = Timer.ms()
        self.callback = callback
    @staticmethod
    def ms():
        return int(round(time.time() * 1000))
    def tick(self):
        if Timer.ms() - self.timeStamp >= self._delay:
            self.timeStamp = Timer.ms()
            self.callback()
class DrawableObject(metaclass=ABCMeta):
    @abstractmethod
    def draw(self, screen):
        pass
class AnimationProperty(metaclass=ABCMeta):
    @abstractmethod
    def set_property(self, params):
        pass
class DotAnimationProperty(AnimationProperty):
    def __init__(self, rect):
        self.rect = rect
    def set_property(self, params):
        self.rect.width = params[0]
        self.rect.height = params[1]
class Animation:
    def __init__(self, prop: AnimationProperty, keyframes):
        self.prop = prop
        self.keyframes = keyframes
        self.frame = 0
        self._playing = True
    def tick(self):
        if self._playing:
            self.frame = 0 if self.frame == len(self.keyframes) - 1 else self.frame + 1
            self.prop.set_property(self.keyframes[self.frame])
    def play(self, play):
        self._playing = play
class Dot(DrawableObject):
    def __init__(self, position, keyframes):  # list[int]
        self._rect = pygame.Rect(position[0], position[1], 11, 11)
        self.position = position
        prop = DotAnimationProperty(self._rect)
        self.animation = Animation(prop, keyframes)
    def draw(self, screen):
        self.rect.left = self.position[0] - int(self._rect.width * 0.5)
        self.rect.top = self.position[1] - int(self._rect.width * 0.5)
        pygame.draw.rect(screen, Color.get_color(Color.Red), self._rect, 0)
    def set_size(self, size):
        self._rect.width = size[0]
        self._rect.height = size[1]
    @property
    def rect(self):
        return self._rect
class DotHunter:
    def __init__(self, mode=(400, 400)):
        self.MODE = mode
        self._objects = []
        pygame.init()
        self._tasks = []
        self.screen = pygame.display.set_mode(mode)
        self.bg = pygame.Surface(mode)
        self.bg.fill(Color.get_color(Color.Black))
        self.create_scene()
        self.add_task(Timer(100, self._draw).tick)
        self.__run()
    def create_scene(self):
        keyframes = []
        for x in range(10, 4, -1):
            keyframes.append([x, x])
        for x in range(6, 11):
            keyframes.append([x, x])
        dot_count = 0
        prev_pos = [0, 0]
        while dot_count < 10:
            pos = [random.randint(0, self.MODE[0]), random.randint(0, self.MODE[1])]
            prev_pos = pos
            self._objects.append(Dot(pos, keyframes))
            dot_count += 1
    def _draw(self):
        self.screen.blit(self.bg, (0, 0))
        for obj in self._objects:
            obj.animation.tick()
            obj.draw(self.screen)
    def mouse_click(self):
        pos = pygame.mouse.get_pos()
        for obj in self._objects:
            if RectTools.point_inside_rect(obj.rect, pos):
                self.dot_click(obj)
    def dot_click(self, obj):
        obj.animation.play(False)
        obj.set_size([15, 15])
        t = Timer(1000, lambda: self.remove_task(t.tick) != obj.animation.play(True))
        self.add_task(t.tick)
    def add_task(self, task):
        self._tasks.append(task)
    def remove_task(self, task):
        self._tasks.remove(task)
    def __run(self):
        while 1:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    sys.exit()
                if event.type == pygame.MOUSEBUTTONDOWN:
                    if event.button == 1:
                        self.mouse_click()
            for task in self._tasks:
                task()
            pygame.display.update()
DotHunter()