Find element by partial link text in Selenium Python - Deep Dive

Overview - Find element by partial link text

What is it?

Finding an element by partial link text means locating a clickable link on a webpage using only part of the link's visible text. Instead of matching the entire link text exactly, you provide a substring that appears anywhere in the link. This helps when the full link text is long or dynamic, making tests more flexible and easier to maintain.

Why it matters

Without the ability to find elements by partial link text, testers would have to rely on exact matches or other less reliable methods, which can break easily if the link text changes slightly. This feature makes automated tests more robust and less fragile, saving time and reducing errors in web testing.

Where it fits

Before learning this, you should understand basic Selenium commands and how to find elements by ID, name, or full link text. After mastering partial link text, you can explore more advanced locators like CSS selectors and XPath for even finer control.

Mental Model

Core Idea

Finding an element by partial link text means searching for a link whose visible text contains a specific substring anywhere inside it.

Think of it like...

It's like looking for a book on a shelf by remembering just a few words from its title instead of the full title.

┌───────────────────────────────┐
│ Webpage with multiple links   │
│ ┌─────────────┐               │
│ │ Link Text 1 │               │
│ │ Link Text 2 │               │
│ │ PartialText │ ← Search here │
│ │ Link Text 3 │               │
│ └─────────────┘               │
└───────────────────────────────┘

Build-Up - 6 Steps

1

Foundation

Understanding Web Links and Text

Concept: Learn what a link is and how its visible text appears on a webpage.

A link (anchor tag) on a webpage has visible text that users click. For example, Click here to learn shows 'Click here to learn' as the link text. Selenium can find this link by matching this text.

Result

You understand that links have visible text that Selenium can use to find them.

Knowing that links have visible text is the base for using text-based locators.

2

Foundation

Basic Selenium Element Finding

Concept: Learn how Selenium finds elements by exact link text.

Using Selenium's find_element method with By.LINK_TEXT, you can find a link by its full visible text. Example: driver.find_element(By.LINK_TEXT, 'Click here to learn') finds the exact link.

Result

You can locate links by their full text exactly.

Understanding exact matching prepares you to see why partial matching is useful.

3

Intermediate

Partial Link Text Locator Introduction

🤔Before reading on: do you think partial link text matching requires the substring to be at the start of the link text or anywhere inside? Commit to your answer.

Concept: Partial link text locator finds links containing the substring anywhere in their visible text.

Selenium's By.PARTIAL_LINK_TEXT locator lets you find links by giving only part of their text. For example, driver.find_element(By.PARTIAL_LINK_TEXT, 'learn') finds any link with 'learn' anywhere in its text, like 'Click here to learn' or 'Learn more now'.

Result

You can find links even if you only know part of their text.

Knowing partial matching makes tests more flexible and less brittle to text changes.

4

Intermediate

Writing Robust Partial Link Text Tests

🤔Before reading on: do you think using very short partial texts (like one letter) is a good idea for finding links? Commit to your answer.

Concept: Choosing meaningful partial texts avoids false matches and makes tests reliable.

When using partial link text, pick substrings that uniquely identify the link. For example, 'learn' is better than 'l' because 'l' might match many links. Also, avoid substrings that appear in multiple links to prevent wrong matches.

Result

Tests find the correct link reliably without confusion.

Understanding how substring choice affects matching prevents flaky tests.

5

Advanced

Combining Partial Link Text with Other Locators

🤔Before reading on: do you think partial link text can be combined with other locators like CSS or XPath in Selenium? Commit to your answer.

Concept: Partial link text is one locator strategy; combining it with others can improve precision.

Selenium allows only one locator at a time, but you can filter elements after finding them by partial link text. Alternatively, use XPath or CSS selectors for complex queries. For example, find all links by partial text, then check attributes in code.

Result

You can handle complex cases where partial link text alone is not enough.

Knowing the limits of partial link text helps you choose the best locator strategy.

6

Expert

Performance and Reliability Considerations

🤔Before reading on: do you think partial link text locators are faster or slower than ID or CSS selectors? Commit to your answer.

Concept: Partial link text locators can be slower and less reliable than other locators, especially on large pages.

Finding elements by partial link text requires Selenium to scan all links and check their text, which can be slower than direct ID or CSS selectors. Also, if multiple links share the substring, Selenium returns the first match, which may cause flaky tests. Use partial link text carefully in large or dynamic pages.

Result

You understand when partial link text is appropriate and when to avoid it.

Knowing performance tradeoffs helps write efficient and stable tests.

Under the Hood

When Selenium uses partial link text, it retrieves all anchor () elements on the page and checks their visible text for the given substring. It returns the first element whose text contains the substring. This process involves DOM traversal and string matching at runtime.

Why designed this way?

Partial link text was designed to offer a flexible way to find links without requiring exact matches, which can be brittle. It trades off some speed for ease of use and robustness against minor text changes. Alternatives like XPath offer more power but are more complex.

┌───────────────────────────────┐
│ Selenium WebDriver            │
│ ┌─────────────────────────┐ │
│ │ Find elements by partial │ │
│ │ link text: 'learn'       │ │
│ └─────────────┬───────────┘ │
│               │             │
│  ┌────────────▼───────────┐ │
│  │ Get all <a> elements    │ │
│  └────────────┬───────────┘ │
│               │             │
│  ┌────────────▼───────────┐ │
│  │ Check each link's text  │ │
│  │ for substring 'learn'   │ │
│  └────────────┬───────────┘ │
│               │             │
│  ┌────────────▼───────────┐ │
│  │ Return first matching   │ │
│  │ element                │ │
│  └─────────────────────────┘ │
└───────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does partial link text matching require the substring to be at the start of the link text? Commit to yes or no.

Common Belief: Partial link text only matches if the substring is at the beginning of the link text.

Reality: Partial link text matches the substring anywhere inside the link text, not just at the start.

Why it matters: Believing this limits test flexibility and causes confusion when expected matches are missed.

Quick: Can partial link text uniquely identify a link if the substring is very short? Commit to yes or no.

Common Belief: Any partial substring, even a single letter, is fine to find a unique link.

Reality: Very short substrings often match multiple links, causing Selenium to return the first match, which may be wrong.

Why it matters: Using too short substrings leads to flaky tests that break unpredictably.

Quick: Does Selenium support combining partial link text with other locators in one call? Commit to yes or no.

Common Belief: You can combine partial link text with CSS selectors or XPath in a single Selenium locator.

Reality: Selenium does not support combining partial link text with other locators directly; you must use one locator at a time.

Why it matters: Expecting combined locators causes confusion and incorrect test code.

Quick: Is finding elements by partial link text always faster than other locators? Commit to yes or no.

Common Belief: Partial link text locators are always fast and efficient.

Reality: Partial link text locators can be slower because they scan all links and check text at runtime.

Why it matters: Ignoring performance can cause slow tests and delays in large web applications.

Expert Zone

1

Partial link text matching is case-sensitive in Selenium, so substring case must match exactly.

2

If multiple links contain the substring, Selenium returns only the first match, so test order and page structure affect results.

3

Dynamic web pages that change link texts after load can cause partial link text locators to fail unless waits or retries are used.

When NOT to use

Avoid partial link text when link texts are very similar or dynamic. Use unique IDs, CSS selectors, or XPath with attributes instead for precise and faster element location.

Production Patterns

In real-world tests, partial link text is often used for navigation menus or buttons with stable but long texts. Testers combine it with explicit waits to handle dynamic content and avoid flaky failures.

Connections

XPath selectors

Alternative locator strategy

Understanding partial link text helps appreciate XPath's power to locate elements by complex text conditions and attributes.

Regular expressions

Text matching technique

Partial link text is a simple substring match; knowing regex shows how more flexible and powerful text searches can be implemented.

Human pattern recognition

Similar cognitive process

Finding links by partial text mimics how humans recognize objects by partial features, showing how automation mimics natural behavior.

Common Pitfalls

#1 Using too short or common substrings causing wrong matches.

Wrong approach: driver.find_element(By.PARTIAL_LINK_TEXT, 'a')

Correct approach: driver.find_element(By.PARTIAL_LINK_TEXT, 'learn')

Root cause: Misunderstanding that very short substrings match many elements, leading to flaky tests.

#2 Assuming partial link text is case-insensitive.

Wrong approach: driver.find_element(By.PARTIAL_LINK_TEXT, 'Learn') # but link text is 'learn more'

Correct approach: driver.find_element(By.PARTIAL_LINK_TEXT, 'learn')

Root cause: Not realizing Selenium's partial link text matching is case-sensitive.

#3 Trying to combine partial link text with CSS selectors in one call.

Wrong approach: driver.find_element(By.CSS_SELECTOR + By.PARTIAL_LINK_TEXT, 'learn')

Correct approach: driver.find_element(By.PARTIAL_LINK_TEXT, 'learn')

Root cause: Misunderstanding Selenium's locator API which accepts only one locator strategy per call.

Key Takeaways

Partial link text locator finds links by matching any substring inside the visible link text, making tests more flexible.

Choosing meaningful and sufficiently long substrings is crucial to avoid false matches and flaky tests.

Partial link text matching is case-sensitive and returns the first matching element, so test reliability depends on page structure.

This locator is slower than ID or CSS selectors because it scans all links and checks text at runtime.

Use partial link text wisely and combine with waits or other locators when needed for robust, maintainable tests.