Find element by tag name in Selenium Python - Deep Dive

Overview - Find element by tag name

What is it?

Finding an element by tag name means locating a part of a webpage using the HTML tag it uses, like 'button' or 'input'. This method helps testers and developers interact with web elements during automated testing. It is a simple way to find elements when you know their tag type. This approach is often used when other unique identifiers like IDs or classes are not available.

Why it matters

Without the ability to find elements by tag name, automated tests would struggle to interact with many web page parts, especially when unique identifiers are missing. This would make testing slower and less reliable, causing more bugs to slip into live websites. Finding elements by tag name helps ensure tests can reach and check important page parts, improving software quality and user experience.

Where it fits

Before learning this, you should understand basic HTML structure and how web pages are built with tags. You should also know how Selenium works to automate browsers. After mastering this, you can learn more precise ways to find elements, like by ID, class name, CSS selectors, or XPath, which offer more control and accuracy.

Mental Model

Core Idea

Finding an element by tag name means telling the browser to look for all parts of the page that use a specific HTML tag and pick the one you want.

Think of it like...

It's like looking for all the chairs in a room by their shape, then choosing the one you want to sit on.

Webpage
  │
  ├─ <div> ... </div>
  ├─ <button>Click me</button>  <-- Find by tag 'button'
  ├─ <input> ... </input>
  └─ <button>Submit</button>  <-- Find by tag 'button'

Find element by tag name 'button' → returns first <button> element found

Build-Up - 7 Steps

1

Foundation

Understanding HTML tags basics

Concept: Learn what HTML tags are and how they define parts of a webpage.

HTML tags are like labels that tell the browser what each part of a webpage is. For example,

2

Foundation

Basics of Selenium element locating

Concept: Learn how Selenium finds elements on a webpage using different methods.

Selenium can find elements by ID, class, name, tag name, CSS selector, or XPath. Each method tells Selenium how to look for elements. Finding by tag name means Selenium looks for elements with a specific HTML tag.

Result

You know that Selenium can locate elements in multiple ways, including by tag name.

Knowing Selenium's locating methods helps you choose the best way to find elements for your tests.

3

Intermediate

Using find_element_by_tag_name in Python

🤔Before reading on: do you think find_element_by_tag_name returns one element or multiple elements? Commit to your answer.

Concept: Learn how to use Selenium's method to find the first element with a given tag name.

In Selenium with Python, you use driver.find_element(By.TAG_NAME, 'tagname') to find the first element with that tag. For example, driver.find_element(By.TAG_NAME, 'button') finds the first button element on the page. You must import 'By' from selenium.webdriver.common.by.

Result

The method returns the first matching element or throws an error if none found.

Understanding that find_element_by_tag_name returns only the first match helps avoid confusion when multiple elements share the same tag.

4

Intermediate

Finding multiple elements by tag name

🤔Before reading on: do you think find_elements_by_tag_name returns a list or a single element? Commit to your answer.

Concept: Learn how to find all elements with a specific tag name using Selenium.

Use driver.find_elements(By.TAG_NAME, 'tagname') to get a list of all elements with that tag. For example, driver.find_elements(By.TAG_NAME, 'button') returns a list of all buttons on the page. You can then loop through this list to interact with each element.

Result

You get a list of matching elements, which can be empty if none found.

Knowing how to get all elements by tag name allows you to handle multiple similar elements, like buttons or inputs, in your tests.

5

Intermediate

Best practices for tag name locating

Concept: Learn when and how to use tag name locating effectively and safely.

Finding elements by tag name is simple but can be risky if many elements share the same tag. Use it when the tag is unique or combined with other checks. Avoid relying only on tag name for complex pages. Always handle exceptions if elements are not found.

Result

You write more reliable tests that avoid false matches or crashes.

Understanding the limits of tag name locating helps you write tests that are both simple and robust.

6

Advanced

Handling dynamic pages with tag name

🤔Before reading on: do you think tag name locating works well on pages that change content dynamically? Commit to your answer.

Concept: Learn how to use tag name locating on pages where elements appear or change after loading.

Dynamic pages may load elements after the initial page load. Use waits like WebDriverWait with expected_conditions to wait for elements by tag name. For example, wait until a button tag appears before interacting. This prevents errors from trying to find elements too early.

Result

Your tests wait properly and interact with elements only when ready.

Knowing how to combine tag name locating with waits prevents flaky tests on modern dynamic websites.

7

Expert

Performance and locator strategy tradeoffs

🤔Before reading on: do you think finding elements by tag name is faster or slower than by CSS selector? Commit to your answer.

Concept: Understand the internal performance and reliability tradeoffs of using tag name locators versus other methods.

Finding elements by tag name is generally fast because browsers index tags efficiently. However, it can return many elements, causing overhead if you only want one specific element. CSS selectors or XPath can be slower but more precise. Experts balance speed and accuracy by choosing the right locator for the test scenario.

Result

You can optimize test speed and reliability by selecting appropriate locators.

Understanding locator tradeoffs helps you write tests that run faster and fail less, improving overall test suite quality.

Under the Hood

When you ask Selenium to find an element by tag name, it sends a command to the browser's driver. The browser then searches its internal document object model (DOM) tree for elements matching the tag. It returns the first match or all matches depending on the method. This search uses the browser's optimized native functions, making it efficient.

Why designed this way?

Tag name locating was designed as a simple, universal way to find elements without needing unique identifiers. It leverages the natural structure of HTML, where tags define element types. This method is fast and straightforward, making it useful for quick tests or when other locators are unavailable. Alternatives like CSS selectors offer more precision but are more complex.

Selenium Test Script
      │
      ▼
  Selenium WebDriver
      │
      ▼
  Browser Driver (e.g., ChromeDriver)
      │
      ▼
  Browser DOM Search by Tag Name
      │
      ├─ Finds first matching element
      └─ Returns element reference to WebDriver
      │
      ▼
  Test script interacts with element

Myth Busters - 4 Common Misconceptions

Quick: Does find_element_by_tag_name return all matching elements or just one? Commit to your answer.

Common Belief: find_element_by_tag_name returns all elements with that tag.

Reality: It returns only the first matching element. To get all, you must use find_elements_by_tag_name.

Why it matters: Assuming it returns all can cause tests to miss interacting with other important elements or cause errors when trying to loop over a single element.

Quick: Is it safe to rely only on tag name to find elements on complex pages? Commit to your answer.

Common Belief: Using tag name alone is always reliable for finding elements.

Reality: Tag name alone can be unreliable on pages with many similar tags, leading to wrong elements being found.

Why it matters: Tests may interact with the wrong elements, causing false test failures or missed bugs.

Quick: Does find_elements_by_tag_name return an error if no elements are found? Commit to your answer.

Common Belief: It throws an error if no elements match the tag name.

Reality: It returns an empty list if no elements are found, not an error.

Why it matters: Knowing this helps avoid unnecessary try-except blocks and write cleaner code.

Quick: Is finding elements by tag name always faster than CSS selectors? Commit to your answer.

Common Belief: Finding by tag name is always faster than CSS selectors.

Reality: While often faster, performance depends on page complexity and browser optimizations; sometimes CSS selectors can be equally fast or faster.

Why it matters: Assuming speed without testing can lead to suboptimal locator choices and slower test suites.

Expert Zone

1

Some browsers optimize tag name searches internally, but performance can degrade if the page has thousands of elements with the same tag.

2

Combining tag name with other filters (like checking attributes after locating) can improve accuracy without losing simplicity.

3

Dynamic content loading can cause stale element references if you find by tag name too early; handling this requires careful wait strategies.

When NOT to use

Avoid using tag name locating when elements share the same tag but differ by attributes like ID or class; use CSS selectors or XPath instead for precision. Also, avoid it on very large pages where many elements share the tag, as it can slow tests.

Production Patterns

In real-world tests, tag name locating is often used for quick checks or when interacting with standard elements like all buttons or inputs. It is combined with waits and error handling to manage dynamic pages. Experts often use it as a fallback locator or in combination with other locators for robustness.

Connections

CSS Selectors

Builds-on

Understanding tag name locating helps grasp CSS selectors, which can specify tags plus classes or IDs for more precise element finding.

Document Object Model (DOM)

Builds-on

Knowing how the DOM represents webpage structure clarifies why finding elements by tag name works and how browsers search elements.

Database Querying

Similar pattern

Finding elements by tag name is like querying a database table for all rows with a certain column value; both involve searching structured data efficiently.

Common Pitfalls

#1 Trying to find multiple elements but using the single element method.

Wrong approach:

button = driver.find_element(By.TAG_NAME, 'button')
for b in button:
print(b.text)

Correct approach:

buttons = driver.find_elements(By.TAG_NAME, 'button')
for b in buttons:
print(b.text)

Root cause:

Confusing find_element (returns one element) with find_elements (returns list) causes errors when iterating.

#2 Assuming tag name locator is always unique and reliable.

Wrong approach:

submit_button = driver.find_element(By.TAG_NAME, 'button')
submit_button.click() # Assumes this is the submit button

Correct approach:

submit_button = driver.find_element(By.CSS_SELECTOR, 'button[type="submit"]')
submit_button.click()

Root cause:

Not considering that multiple buttons exist leads to interacting with the wrong element.

#3 Not waiting for elements to load before finding by tag name on dynamic pages.

Wrong approach:

button = driver.find_element(By.TAG_NAME, 'button')
button.click() # Fails if button not yet loaded

Correct approach:

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
wait = WebDriverWait(driver, 10)
button = wait.until(EC.presence_of_element_located((By.TAG_NAME, 'button')))
button.click()

Root cause:

Ignoring page load timing causes NoSuchElementException or stale element errors.

Key Takeaways

Finding elements by tag name is a simple way to locate webpage parts using their HTML tag.

This method returns the first matching element or a list of all matches, depending on the function used.

It works best when tags are unique or combined with other checks to avoid wrong matches.

On dynamic pages, waiting for elements to appear before interacting is crucial to avoid errors.

Experts balance speed and accuracy by choosing tag name locating when appropriate and combining it with other strategies.