Take Screenshots at Random Intervals with Python

In this article, we will learn how to take screenshots at Random Intervals with Python.

Method 1: Using pyautogui.screenshot()

pyautogui: The pyautogui library provides the screenshot() method, The screenshot() method is used to take a screenshot. We will use the random library and sleep() method to take screenshots at Random Intervals.

Syntax: pyautogui.screenshot()

randint(): The randint() method returns an integer number from the range specified.

Syntax: random.randint(start, stop)

Parameters: 

• An integer specifying starting of range.
• An integer specifying ending of the range.

Returns: Returns an Integer.

Example:

In this example, a random delay was generated between 1 to 5 seconds before taking a screenshot. generate a random number between 1 to 5, and create a time delay using the sleep() method. The screenshots will be saved in the exact location of the program with the file name as the current time. The following steps are:

• Import libraries pyautogui, random, and time.
• Take a screenshot using the screenshot() method and wait for sometime
• Create the random delay using randint() method and sleep().
• save the screenshots with the name as the current time.

# importing pyautogui random and time
# libraries
import pyautogui
import random
import time

# Running the while loop for infinite time
while True:
    # generating a random number between 1 
    # to 5 which will represent the time 
    # delay
    random_time = random.randint(1, 5)

    # create a time delay using the sleep()
    # method
    time.sleep(random_time)

    # Take the screenshot using screenshot()
    # method
    myScreenshot = pyautogui.screenshot()

    # Save the screenshot shot using current
    # time as file name.
    file_name = str(time.time())+".png"
    myScreenshot.save(file_name)

Output: The following images are the randomly taken screenshots by running the above code.

Method 2: Using ImageGrab.grab()

The pillow (PIL) library has an ImageGrab module that can be used to copy the contents of the screen or the clipboard to a PIL image memory.

Installing PIllow

pip install Pillow

grab(): The grab() method is used to take a screenshot of the screen. The pixels inside the bounding box are returned as an “RGBA” on macOS, or an “RGB” image otherwise. If the bounding box is omitted, the entire screen is copied.

So now to take screenshots at random time intervals we will make use of grab() and sleep() and random() methods. the grab() will be used to take snapshots, randint() and sleep() will be used to create delay at random time intervals.

Syntax: PIL.ImageGrab.grab(bbox=None, include_layered_windows=False, all_screens=False, xdisplay=None)

Parameters:

• bbox – What region to copy. Default is the entire screen
• Includes layered windows - boolean value
• all_screens –Capture all monitors. Windows OS only.

Return: an image

Example:

In the above code, a random delay was generated between 1 to 5 seconds before taking a screenshot using grab() method. generate a random number between 1 to 5, and create a time delay using the sleep() method. The screenshots will be saved in the exact location of the program with the file name as current time.

• Import PIL, random, and time libraries.
• Take a screenshot using the grab() method and wait for sometime
• Create the random delay using randint() method and sleep().
• save the screenshots with the name as the current time.

# importing ImageGrab class
from PIL import ImageGrab

# importing random module
import random

# importing time module
import time

# Running the while loop for infinite time
while True:
    # generating a random number between
    # 1 to 5 , which will represent the 
    # time delay
    random_time = random.randint(1, 5)

    # create a time delay using the sleep() 
    # method
    time.sleep(random_time)

    # Take the screenshot using grab()
    # method
    snapshot = ImageGrab.grab()

    # Save the screenshot shot using current time
    # as file name.
    file_name = str(time.time())+".png"
    snapshot.save(file_name)

Output:

Method 3: Using shot()  from MSS module

MSS is an ultra-fast cross-platform multiple screenshots module in pure python using ctypes. This module can be used to capture screenshots.

Installing MSS

pip install mss

The shot() method is used to take a screenshot of the screen or monitor.

Syntax: mss_instance.shot("file_destination")

Parameters:

• file_destination: The place where screenshots need to be saved.

Example:

In the above code, a random delay was generated between 1 to 5 seconds before taking a screenshot. generate a random number between 1 to 5, and create a time delay using the shot() method. The screenshots will be saved in the exact location of the program with the file name as the current time.

• Import PIL, random, and time libraries.
• Create an instance of mss using with keyword, Take a screenshot using the shot() method and wait for sometime
• Create the random delay using randint() method and sleep().
• save the screenshots with the name as the current time.

# importing random module
import random
import mss

# importing time module
import time

# Running the while loop for infinite time
while True:
    # generating a random number between 1 
    # to 5 , which will represent the time
    # delay
    random_time = random.randint(1, 5)

    # create a time delay using the sleep()
    # method
    time.sleep(random_time)

    # Save the screenshot shot using current time 
    # as file name.
    file_name = str(time.time())+".png"

    # Take the screenshot using shot() method
    with mss.mss() as mss_obj:
        mss_obj.shot(output=file_name)

Output: