The Ultimate Selenium Cheat Sheet with Python for Test Automation

Opening a link or document

It is important to open the target URL (or test URL) before performing any operations on the web elements present on the page. Next, you will see several ways to open a URL in Selenium with Python:

driver.get (URL)

Method driver.get() goes to the page that is passed to the method as a parameter. Selenium WebDriver will wait until the page is fully loaded, after which it will fire the event “onload“And returns control to the test script. The article Selenium Waits in Python you can find more information on waiting handling in Selenium.


Refreshing the page

There are scenarios in which you need to update the page content. The page refresh method in Selenium WebDriver is used to refresh web pages.

Method driver.refresh() refreshes the current web page. It takes no arguments and returns no values.


Entering text into a web element

Method send_keys() in Python it is used to enter text into a text element. This text is passed to the method as an argument. The same technique can be used to simulate key presses in any field (for example, in form input fields).

Usage example send_keys()where the email is passed to the text element on the LambdaTest registration page:

from selenium import webdriver
# create webdriver object
driver = webdriver.Chrome()
# get lambdatest
# get element 
element = driver.find_element_by_id("useremail")
# send keys 

Remove text in a web item

Method element.clear() in Selenium it is used to remove text from fields like form input fields etc.

An example of using the method to clear the contents of an email input field on the LambdaTest home page:

from selenium import webdriver
# create webdriver object
driver = webdriver.Chrome()
# get lambdatest
# get element 
element = driver.find_element_by_id("useremail")
# send keys 

Clicking on a web element

Method in Selenium it is used to click on an element such as anchor link, button, etc.

Like this using the method click() you can click on the button on the LambdaTest home page:

from selenium import webdriver
# create webdriver object
driver = webdriver.Chrome()
# get lambdatest
# get element 
element = driver.find_element_by_id("useremail")
# send keys 
# get element 
button_element = driver.find_element_by_link_text("Start Free Testing")
# click the element

Dragging and dropping a web element

Drag and drop is one of the widely used scripts in popular applications (or programs) like Canvas, Google Drive, Trello, Asana, etc. Method drag_and_drop(element, target) in Selenium helps automate the functionality of dragging and dropping web elements from the source and bringing them to the target area (or element).

At the class Actions Selenium has two methods with which you can perform drag and drop operations when testing cross browser compatibility. Be sure to check out our detailed guide, which has information on how drag and drop in Selenium.

Here is a simple example of using the method drag_and_drop():

element = driver.find_element_by_name("source")
target = driver.find_element_by_name("target")

from selenium.webdriver import ActionChains
action_chains = ActionChains(driver)
action_chains.drag_and_drop(element, target).perform()

Option selection

Select(element) provides useful methods for interacting with dropdowns, selecting items, and more.

This is how you can select an element by index:

from import Select
select = Select(driver.find_element_by_id('city'))

Here are some variations on how to select the desired item using the method select_by_*():




The method takes an integer value – the index of the option we want to select.


The method takes a string value and selects an option that contains the desired text.


The method takes a string value and selects a parameter with the same attribute value.


The method allows you to deselect all selected options.

Navigation between windows

If you have multiple windows, you may need to switch between them before performing actions on web elements from the DOM.

driver.switch_to_window (“window_name”)

Method switch_to_window() Selenium WebDriver allows you to switch to the desired window. The window handle is passed as an argument to the method switch_to_window()


All subsequent calls to WebDriver are now applied to the focused window (or to a new window after switching).


Property window_handles WebDriver returns handles to windows. Now you can use the method switch_to_window() to go to any window from the list window_handles

for handle in driver.window_handles:


Method current_window_handle() returns a handle to the current window (or window with focus).

handler = driver.current_window_handle 

Switch to iFrame

Selenium WebDriver is unable to access or find web elements inside an iFrame in the context of the home page. Hence, you need to switch to the iFrame before accessing the elements within it.

driver.switch_to_frame (“iframe_name”)

Method switch_to_frame() in Selenium Python allows changing the WebDriver context from the main page context. We can also access subframes by adding a dot between the path and the index.


driver.switch_to_default_content ()

The method allows you to navigate back to the context of the master page.


Handling pop-ups and alerts

There are only three main types of pop-ups and alerts that are commonly used in web applications:

  • Simple Alert

  • Confirmation Alert

  • Prompt Alert

You can switch to the alert, reject it, or accept it. Check out our detailed guidance on handling alerts and pop-ups in Selenium. Even though it uses C #, the basics remain the same!


Property switch_to.alert in WebDriver returns the currently open object alert… You can accept it, reject it, read the content, or enter it on the command line.

alert_obj = driver.switch_to.alert

alert_obj.accept ()

Once you have a window handle alert (For example, alert_obj), method accept() will help you accept the warning popup.

alert_obj = driver.switch_to.alert 

alert_obj.dismiss ()

After you switched to the window alert (For example, alert_obj), you can use the method dismiss()to dismiss the warning popup.

alert_obj = driver.switch_to.alert 

alert_obj.text ()

This method is used to retrieve the message from the alert popup.

alert_obj = driver.switch_to.alert 
msg = alert_obj.text()

Getting the page code

Method page_source() in Selenium WebDriver is used to get the page code.

page_source = driver.page_source

Browsing history navigation

Selenium WebDriver in Python provides several functions for moving back and forth through browser history.

driver.forward ()

This method allows scripts to move one step forward in browser history.


driver.back ()

This method allows scripts to navigate one step back in browser history.


Selenium Cookie Handling

Cookie handling in Selenium WebDriver is one of the common scenarios that you might have to deal with when automating. Various operations can be performed such as add, delete, get the cookie name, and more.

driver.add_cookie ()

This method helps to set up a cookie for a Selenium session. It accepts values ​​as a key-value pair.

# Go to the domain

# Now set the cookie. 
cookie = {'name' : 'user', 'value' : 'vinayak'}

driver.get_cookies ()

This method will dump all available cookies for the current Selenium session.

# Go to the domain


driver.delete_cookie ()

It is possible to delete a specific cookie or all cookies associated with the current Selenium session.

# delete one cookie
# delete all cookies

Setting the window size

# Setting the window size to 1200 * 800
driver.set_window_size(1200, 800)

Setting timeouts in Selenium WebDriver

When a browser loads a page, the web elements inside it may load at different intervals. This can make it difficult to interact with dynamic elements present on the page.

If the element is not present in the DOM of the web page, the method locate will throw an exception. Expectations in Selenium allow you to add delays (in milliseconds or seconds) between actions performed between page loading and finding the desired web element.

Implicit wait and explicit wait are two main ways to add delays to Selenium code in Python to handle dynamic web elements on a page.

Implicit waiting in Selenium Python

An implicit wait informs Selenium WebDriver to check the DOM for a specified period of time when trying to find a web element that is not available immediately after the page is loaded.

By default, implicit wait is zero. However, once we define it, it is set for the lifetime of the WebDriver object. Check out the detailed tutorial that demonstrates the use of implicit wait in Selenium Python.

from selenium import webdriver

driver = webdriver.Chrome()
driver.implicitly_wait(10) # in seconds
element = driver.find_element_by_id("testing_form")

Explicit wait in Selenium Python

Explicit expectation in Selenium with Python it is used when we want to wait for a certain condition to be met before proceeding.

Selenium WebDriver has several convenient methods that allow you to wait until a certain condition is met. For example, an explicit expectation can be obtained using the class webdriverWait in combination with expected conditions in Selenium.

Here are some of the expected conditions that can be used in conjunction with an explicit expectation in Selenium Python:

  • presence_of_all_elements_located

  • text_to_be_present_in_element

  • text_to_be_present_in_element_value

  • frame_to_be_available_and_switch_to_it

  • invisibility_of_element_located

  • title_is

  • title_contains

  • presence_of_element_located

  • visibility_of_element_located

  • visibility_of

  • element_located_selection_state_to_be

  • alert_is_present

  • element_to_be_clickable

  • staleness_of

  • element_to_be_selected

  • element_located_to_be_selected

  • Element_selection_state_to_be

There is an example below that demonstrates the use of an explicit wait, which performs a non-blocking wait of 10 seconds until the required web element is found (using its ID attribute):

from selenium import webdriver
from import By
from import WebDriverWait
from import expected_conditions as EC

driver = webdriver.Chrome()
    element = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.ID, "testing_form"))
    print(“some error happen !!”)

Taking screenshots

During the automation process, you may need to take a screenshot of an entire page or a specific web element.

This way you can check what went wrong while running the test. Take screenshots of web elements using seleniumif you want to check which specific element caused an error while executing a test.

Method save_screenshot() Selenium WebDriver is used to create screenshots of the web page.


This certification is designed for professionals who want to develop advanced practical skills in test automation with Selenium in Python and take their careers to the next level.

LambdaTest Selenium Python 101 Certification Brief:


Python is one of the most popular languages ​​and there is no doubt that you can perform complex operations with Selenium with just a few lines of code. In this Selenium in Python Cheat Sheet, we looked at some of the widely used Selenium commands that are primarily used for testing. cross-browser compatibility

This Selenium Cheat Sheet can be used as a guide (or reference) for a quick introduction to commands that might be of interest to your case. I hope you find it useful and be sure to let me know if you come across any Selenium team that should be part of it.

Happy Python Automated Testing!

Material prepared as part of the course Python QA Engineer.

We invite everyone to a free two-day intensive “About Python for the Automator: The Basics of the Basics.” Content:
1. A few words about Python.
2. Let’s figure out what data types / objects are in Python and why know about it at all.
3. Decorators and their use in autotests: let’s practice writing decorators and look for useful uses for them.

Suitable for those who not so long ago automate in Python, but did not understand the possibilities and limitations of Python, and for those who are still new, but would like to. For those who have been programming in Python for a long time, it will be boring and you are unlikely to learn something new.

Method set_window_size() is used to adjust the desired dimensions of the browser window (width and height).