Locating single elements in Selenium Python

Selenium, a vigorous tool for web automation, offers a Python module that improves on the most common way of automating web tasks. Whether you're trying a web application or automating redundant web communications, Selenium's Python ties provide a strong and easy-to-use Programming interface. In this two-section article series, we'll investigate the fundamental idea of finding single components in Selenium Python.

Locating Single Elements

Selenium Python follows different locator strategies to find elements on a web page. Regardless, you want to import the By class from Selenium's web driver.common.by module.

from selenium.webdriver.common.by import By

There are eight essential locator strategies that Selenium Python uses to find single elements:

By.ID:

This strategy finds the primary element with an ID quality matching the predetermined worth. On the off chance that no matching element is found, a NoSuchElementException is raised.

<html>
 <body>
  <form id = " registrationForm ">
   <input name = "username" type = "text" />
   <input name = "email" type = "email" />
   <input name = "password" type = "password" />
   <button id = "registerButton">Register</button>
  </form>
 </body>
</html>

To find and interface with the registration form utilizing By.ID, you can utilize the accompanying Python code:

Python:

from selenium.webdriver.common.by import By
# Locate the registration form by its ID
registration_form = driver.find_element(By.ID, ' registrationForm ')
# Now, Perform actions on the form elements

By.XPATH:

This strategy utilizes an XPath example to find the primary element. If no matching element is found, a NoSuchElementException is raised.

<html>
 <body>
  <div class = " container ">
   <div class = " content ">
    <p> This is some content </p>
   </div>
  </div>
 </body>
</html>

Python:

from selenium.webdriver.common.by import By
# Locate the content div using XPath
content_div = driver.find_element( By.XPATH, " // div [ @ class = ' container ' ]/ div[ @ class = 'content']" )
# Perform actions on the content

By.NAME:

It finds the main element with a name property matching the provided esteem. Like ID, if no match is found, a NoSuchElementException is raised.

<html>
 <body>
  <form name = " searchForm ">
   <input name = " query " type = "text" />
   <button name = " searchButton " >Search</button>
  </form>
 </body>
</html>

You can find and connect with the hunt form utilizing By.NAME

Python:

from selenium.webdriver.common.by import By
# Locate the search form by its name attribute
search_form = driver.find_element(By.NAME, ' searchForm ')
# Perform actions on the form elements

By.TAG_NAME:

It finds the main element with the predetermined HTML tag name. On the off chance that no matching element is found, a NoSuchElementException is raised.

<html>
 <body>
  <h1> Welcome to Selenium </h1>
  <h2> Introduction </h2>
  <h3> Getting Started </h3>
 </body>
</html>

You can find and associate with the headings utilizing By.TAG_NAME:

Python:

from selenium.webdriver.common.by import By
# Locate the first heading using its tag name
first_heading = driver.find_element( By.TAG_NAME, ' h1 ')

# Get the text of the first heading
heading_text = first_heading.text

By.LINK_TEXT:

It finds the main element with interface text precisely matching the provided esteem. If no matching connection text is found, a NoSuchElementException is raised.

<html>
 <body>
  <p> Visit our < a href = " https://example.com "> Example </a> page  for  more info. </p>
  <p> For more  details, click < a href = " https://sample.com "> here </a>. </p>
 </body>
</html>

By.PARTIAL_LINK_TEXT:

This strategy tracks down the main element with partial connection text matching the provided esteem. On the off chance that no match is found, a NoSuchElementException is raised. You can find and cooperate with these connections utilizing By.LINK_TEXT and By.PARTIAL_LINK_TEXT:

Python:

from selenium.webdriver.common.by import By
# Locate the " Example " link by its full link text
example_link = driver.find_element(By.LINK_TEXT, ' Example ')
# Click the link
example_link.click()
# Locate the " here " link by its partial link text
partial_link = driver.find_element( By.PARTIAL_LINK_TEXT, 'here' )
# Click the link
partial_link.click()

By.CLASS_NAME:

This strategy finds the primary element with a matching class trait name. On the off chance that no match is found, a NoSuchElementException is raised.

<html>
 <body>
  <p class = " important " > This is  an important  message. </p>
  <p> This is a  regular message. </p>
 </body>
</html>

You can find and collaborate with the "significant" message utilizing By.CLASS_NAME:

Python:

from selenium.webdriver.common.by import By
# Locate the important message using its class name
important_message = driver.find_element( By.CLASS_NAME, ' important ')
# Get the text of the important message
message_text = important_message.text

By.CSS_SELECTOR:

It finds the principal element utilizing a matching CSS selector. On the off chance that no matching element is found, a NoSuchElementException is raised.

<html>
 <body>
  <div class = " styled " >
   <p> This paragraph has a special style. </p>
  </div>
 </body>
</html>

You can find and connect with the styled section utilizing By.CSS_SELECTOR:

Python:

from selenium.webdriver.common.by import By
# Locate the styled paragraph using a CSS selector
styled_paragraph = driver.find_element( By.CSS_SELECTOR, ' div.styled  > p')
# Perform actions on the styled paragraph

Practical Examples

Example 1:

Locating Elements by ID

Assume you are automating a login interaction on a website with the accompanying HTML structure:

<html>
 <body>
  <form id = " login Form ">
   <input name = " username " type = " text " />
   <input name = " password " type = " password " />
   <input name = " continue " type = " submit " value = " Login " />
  </form>
 </body>
</html>

To find and cooperate with the username input field utilizing By.ID, you can utilize the accompanying Python code:

Python:

from selenium.webdriver.common.by import By
# Locate the username input field
username_input = driver.find_element( By.ID, ' login Form ')
# Perform an action ( e.g., send_keys )
username_input.send_keys(" your_username ")

Example 2:

Locating Elements by XPATH

Assume you have a webpage with various output elements, and you need to find the main outcome utilizing an XPath articulation. This is the way you can make it happen:

<html>
 <body>
  <ul class = " search-results " >
   <li class = " result "> Result 1 </li>
   <li class = " result "> Result 2 </li>
   <li class = " result "> Result 3 </li>
  </ul>
 </body>
</html>

Utilize the accompanying Python code to find the primary outcome element:

Python:

from selenium.webdriver.common.by import By
# Locate the first result using XPath
first_result = driver.find_element( By.XPATH, " //ul [@class = ' search-results ']/li[ 1] ")
# Perform an action (e.g., get text)
result_text = first_result.text

Example 3:

Locating Links by Partial Connection Text

Assume you need to click a connection with the text "Proceed" on a webpage with the accompanying construction:

<html>
 <body>
  <p>Are you sure you want to do this?</p>
  <a href = " continue.html " > Continue </a>
  <a href = " cancel.html" > Cancel </a>
 </body>
</html>

You can utilize By.PARTIAL_LINK_TEXT to find and tap the connection:

Python:

You can utilize By.PARTIAL_LINK_TEXT to find and tap the connection:
from selenium.webdriver.common.by import By
# Locate the " Continue " link by partial link text
continue_link = driver.find_element(By.PARTIAL_LINK_TEXT, ' Conti ')
# Click the link
continue_link.click()

Best Practices

1. Focus on ID and Name Locators

Whenever the situation allows, use By.ID or By.NAME locators as they are the quickest and most dependable strategies for locating elements. These locators are ideal for identifying special elements on a page.

2. Use CSS Selectors for Adaptability

By.CSS_SELECTOR offers adaptability in choosing elements because of different traits and conditions. It's a strong locator strategy, particularly when you want to track down elements by class, property, or relationship with different elements.

3. Avoid XPath Overuse

While XPath is adaptable, it tends to be increasingly slow and meaningful than other locator strategies. Hold XPath for complex situations where different strategies are lacking.

4. Handle Dynamic Content with Waits

Web pages frequently contain dynamic content that heaps nonconcurrently. Utilize express waits (WebDriverWait) to guarantee that elements are available and prepared for association before performing activities on them.

5. Keep Your Code Viable

Structure your code to make it effectively viable. Store locators in factors or constants to unify changes when the web page structure develops.

6. Debug with Print Statements

While investigating issues with the element area, add print statements to your code to see what's going on at each step. This can be accommodating for debugging.

Conclusion:

Selenium, with its Python, engages us to communicate with web elements, automating tasks and testing web applications effectively. These strategies are fundamental tools in the Selenium Python toolkit, permitting you to pinpoint and control single elements on web pages.

Next TopicSelenium C# Tutorial

← prev next →