Python Notes
HubHistory of Python - Complete Guide 2026Python Applications - Complete Guide 2026Python Features - Complete Guide 2026What is Python? - Complete Guide 2026Why Learn Python? - Complete Guide 2026Your First Python Program – Hello World & Beyond 2026How to Install Python on Windows, Mac & Linux – Complete Guide 2026Install VS Code for Python – Complete Setup Guide with Extensions 2026Python Environment Setup – Virtual Environments, pip & Project Structure 2026Python IDLE – Complete Guide for Beginners 2026Python CommentsPython Data TypesPython Input and OutputPython OperatorsPython SyntaxPython Strings BasicsPython Type CastingPython VariablesBreak, Continue and Pass in PythonElif Statement in PythonFor Loop in PythonIf-Else Statement in PythonIf Statement in PythonNested If in PythonPattern Programs in PythonWhile Loop in PythonDecorators in PythonFunction Arguments in PythonFunctions Basics in PythonGenerators in PythonLambda Functions in PythonRecursive Functions in PythonReturn Statement in PythonScope of Variables in PythonAbstraction in PythonClasses and Objects in PythonConstructors in PythonEncapsulation in PythonInheritance in PythonMagic Methods (Dunder Methods) in PythonMethod Overriding in PythonPolymorphism in PythonPython Comprehensions – List, Dict, Set & GeneratorPython Dictionaries – Key-Value StorePython Dictionary Methods – Complete ReferencePython List Methods – All Built-in MethodsPython Lists – Complete GuidePython Set Methods – Complete ReferencePython Sets – Unordered Unique CollectionsPython Tuples – Immutable SequencesPython Asynchronous Programming with asyncioPython Context ManagersAdvanced Python DecoratorsAdvanced Python GeneratorsPython Iterators - Advanced GuidePython Memory ManagementPython MultiprocessingPython MultithreadingCRUD Operations in Python DatabasesMySQL with Python (mysql-connector-python)ORM Introduction with SQLAlchemyPostgreSQL with Python (psycopg2)SQLite3 with PythonIntroduction to DjangoDjango Models and ORMDjango REST API with DRFDjango ViewsIntroduction to FlaskFlask RoutingFlask Templates with Jinja2Email Automation with PythonPDF Automation with PythonSelenium Web Automation with PythonTask Scheduler with PythonWeb Scraping with PythonData Analysis with PythonData Cleaning with PythonData Visualization ProjectData Visualization with MatplotlibNumPy IntroductionPandas IntroductionStatistical Visualization with SeabornClassification AlgorithmsClustering AlgorithmsIntroduction to Machine LearningMachine Learning Project: Churn PredictionModel Evaluation and SelectionRegression AlgorithmsSave pipeline (includes preprocessing + model)AI Assistant ProjectCalculator ProjectChatbot ProjectExpense Tracker ProjectFace Detection ProjectPassword Generator ProjectWeather App ProjectPython Coding Interview QuestionsPython OOP Interview Questions and AnswersPython Master CheatsheetPython Interview Questions and AnswersPython Best PracticesCommon Python Errors and SolutionsPython Debugging TechniquesPython Learning Resources
Master Selenium WebDriver with Python for browser automation, form filling, clicking, screenshots, handling dynamic content, waits, and headless browsing with Hindi explanations.
Introduction
Selenium is a library for programmatically controlling browsers. Dynamic content loaded via JavaScript, login forms, button clicks — all of this can be automated with Selenium.
bash example
pip install selenium
pip install webdriver-manager # Auto ChromeDriver download2. Finding Elements
Example
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options
options = Options()
options.add_argument("--headless=new")
driver = webdriver.Chrome(options=options)
driver.get("https://www.google.com")
# By.ID
search_input = driver.find_element(By.ID, "APjFqb") # Google's search box
# By.NAME
# search = driver.find_element(By.NAME, "q")
# By.CLASS_NAME
# element = driver.find_element(By.CLASS_NAME, "some-class")
# By.CSS_SELECTOR — most reliable
# submit_btn = driver.find_element(By.CSS_SELECTOR, "input[type='submit']")
# logo = driver.find_element(By.CSS_SELECTOR, "#hplogo img")
# By.XPATH — most flexible
# link = driver.find_element(By.XPATH, "//a[contains(text(), 'Python')]")
# parent = driver.find_element(By.XPATH, "//input[@id='q']/..")
# Find MULTIPLE elements
links = driver.find_elements(By.TAG_NAME, "a")
print(f"Total links: {len(links)}")
# Element properties
if links:
for link in links[:3]:
print(f" Text: {link.text}, href: {link.get_attribute('href')}")
driver.quit()
# XPATH cheatsheet
"""
Useful XPATH patterns:
//tag[@attr='value'] — attribute match
//tag[contains(@class,'x')] — partial class match
//tag[text()='exact text'] — exact text match
//tag[contains(text(),'x')] — partial text match
//parent/child — direct child
//ancestor//descendant — any descendant
(//tag)[n] — nth occurrence
"""
Output
Total links: 18 Text: More information..., href: https://www.iana.org/domains/example Text: , href: https://www.google.com/intl/en/about.html Text: Store, href: https://store.google.com
3. Interacting with Elements
Example
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.chrome.options import Options
import time
options = Options()
options.add_argument("--headless=new")
driver = webdriver.Chrome(options=options)
# Form interaction demo with httpbin.org
driver.get("https://httpbin.org/forms/post")
# Type in text field
name_field = driver.find_element(By.CSS_SELECTOR, "input[name='custname']")
name_field.clear() # Existing text clear karo
name_field.send_keys("Alice Johnson") # Type text
# Keyboard shortcuts
name_field.send_keys(Keys.TAB) # Tab to next field
name_field.send_keys(Keys.CONTROL, "a") # Select all
name_field.send_keys(Keys.DELETE) # Delete
# Dropdown (select element)
from selenium.webdriver.support.ui import Select
size_dropdown = driver.find_element(By.CSS_SELECTOR, "select[name='size']")
select = Select(size_dropdown)
# Select by visible text
select.select_by_visible_text("Large")
# Select by value
select.select_by_value("medium")
# Select by index
select.select_by_index(0)
# Get all options
options_list = [opt.text for opt in select.options]
print(f"Size options: {options_list}")
# Radio buttons and checkboxes
radio_btn = driver.find_element(By.CSS_SELECTOR, "input[type='radio'][value='bacon']")
if not radio_btn.is_selected():
radio_btn.click()
# Click button
submit_btn = driver.find_element(By.CSS_SELECTOR, "button[type='submit']")
submit_btn.click()
time.sleep(2)
print(f"Current URL: {driver.current_url}")
driver.quit()
Output
Size options: ['Small', 'Medium', 'Large'] Current URL: https://httpbin.org/post
4. Waits — Handling Dynamic Content
Example
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.options import Options
from selenium.common.exceptions import TimeoutException, NoSuchElementException
options = Options()
options.add_argument("--headless=new")
driver = webdriver.Chrome(options=options)
# 1. Implicit Wait — globally apply
driver.implicitly_wait(10) # 10 seconds tak try karo
# 2. Explicit Wait — for a specific element
wait = WebDriverWait(driver, timeout=15)
def wait_for_element(driver, by, selector, timeout=10, condition="clickable"):
"""Wait for element with condition"""
wait = WebDriverWait(driver, timeout)
conditions = {
"visible": EC.visibility_of_element_located,
"clickable": EC.element_to_be_clickable,
"present": EC.presence_of_element_located,
"invisible": EC.invisibility_of_element_located,
}
try:
element = wait.until(conditions[condition]((by, selector)))
return element
except TimeoutException:
print(f"Timeout waiting for {selector}")
return None
# Usage
driver.get("https://httpbin.org/html")
try:
# Wait until element is visible
h1 = wait.until(EC.visibility_of_element_located((By.TAG_NAME, "h1")))
print(f"Found h1: {h1.text}")
# Wait until element is clickable
# btn = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, ".submit-btn")))
# Wait for text to appear
# wait.until(EC.text_to_be_present_in_element((By.ID, "status"), "Done"))
# Wait for URL change
# wait.until(EC.url_contains("success"))
# Wait for element to disappear (loader)
# wait.until(EC.invisibility_of_element_located((By.CSS_SELECTOR, ".loading")))
except TimeoutException as e:
print(f"Timeout: {e}")
finally:
driver.quit()
Output
Found h1: Herman Melville - Moby Dick
📝 Hindi Explanation
Wait is THE MOST important concept in Selenium. Modern websites load content dynamically via JavaScript.implicitly_wait(n)globally waits for all elements, whileWebDriverWait(explicit wait) waits for specific conditions — this is the recommended approach.
5. Screenshots and Page Source
Example
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import os
options = Options()
options.add_argument("--headless=new")
options.add_argument("--window-size=1920,1080")
driver = webdriver.Chrome(options=options)
driver.get("https://example.com")
# Full page screenshot
driver.save_screenshot("screenshot.png")
print("Screenshot saved!")
# Element screenshot
from selenium.webdriver.by import By
from selenium.webdriver import Keys
h1 = driver.find_element(By.TAG_NAME, "h1")
h1.screenshot("element_screenshot.png")
# Page source (HTML)
html_source = driver.page_source
with open("page_source.html", "w", encoding="utf-8") as f:
f.write(html_source)
# Parse with BeautifulSoup
from bs4 import BeautifulSoup
soup = BeautifulSoup(html_source, "lxml")
text = soup.get_text(separator="\n", strip=True)
print(f"Page text: {text[:200]}")
# JavaScript execute karo
scroll_height = driver.execute_script("return document.body.scrollHeight")
print(f"Page height: {scroll_height}px")
# Scroll down
driver.execute_script("window.scrollTo(0, document.body.scrollHeight)")
# Get element position
element = driver.find_element(By.TAG_NAME, "h1")
position = driver.execute_script("return arguments[0].getBoundingClientRect()", element)
print(f"Element position: {position}")
driver.quit()
Output
Screenshot saved!
Page text: Example Domain
This domain is for use in illustrative examples in documents...
Page height: 600px
Element position: {'x': 32, 'y': 100.5, 'width': 600, 'height': 38}6. Handling Alerts, Frames, Windows
python example
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.options import Options
options = Options()
options.add_argument("--headless=new")
driver = webdriver.Chrome(options=options)
wait = WebDriverWait(driver, 10)
# Alert handling
def handle_alert(driver, action="accept"):
try:
alert = wait.until(EC.alert_is_present())
print(f"Alert text: {alert.text}")
if action == "accept":
alert.accept() # OK button
elif action == "dismiss":
alert.dismiss() # Cancel button
elif action == "input":
alert.send_keys("input text") # Prompt mein text
alert.accept()
except Exception as e:
print(f"No alert: {e}")
# Frame/iframe handling
def switch_to_frame_and_back(driver, frame_selector):
# Switch to iFrame
frame = driver.find_element(By.CSS_SELECTOR, frame_selector)
driver.switch_to.frame(frame)
# Work inside the iFrame
content = driver.find_element(By.TAG_NAME, "body").text
# Main document pe wapas
driver.switch_to.default_content()
return content
# Multiple windows/tabs
def open_and_switch_window(driver, url):
# Naya tab kholo
original_window = driver.current_window_handle
driver.execute_script(f"window.open('{url}', '_blank')")
# New window pe switch karo
for window in driver.window_handles:
if window != original_window:
driver.switch_to.window(window)
break
print(f"New window title: {driver.title}")
# Original window pe wapas
driver.switch_to.window(original_window)
driver.quit()7. Actions Chains — Complex Interactions
python example
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.chrome.options import Options
options = Options()
options.add_argument("--headless=new")
driver = webdriver.Chrome(options=options)
driver.get("https://example.com")
actions = ActionChains(driver)
# Hover
element = driver.find_element(By.TAG_NAME, "h1")
actions.move_to_element(element).perform()
# Click at offset
actions.move_to_element_with_offset(element, 50, 10).click().perform()
# Drag and drop (simulated)
source = driver.find_element(By.ID, "source") # If element exists
target = driver.find_element(By.ID, "target")
# actions.drag_and_drop(source, target).perform()
# Complex action chain
# actions.move_to_element(menu)
# .click()
# .move_to_element(submenu)
# .click()
# .perform()
# Keyboard actions
from selenium.webdriver.common.keys import Keys
body = driver.find_element(By.TAG_NAME, "body")
actions.key_down(Keys.CONTROL).send_keys("a").key_up(Keys.CONTROL).perform() # Ctrl+A
driver.quit()8. Headless Browser Automation
Example
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import time
def create_headless_driver():
"""Production-ready headless Chrome"""
options = Options()
options.add_argument("--headless=new")
options.add_argument("--no-sandbox")
options.add_argument("--disable-dev-shm-usage")
options.add_argument("--disable-gpu")
options.add_argument("--window-size=1920,1080")
options.add_argument("--disable-extensions")
options.add_argument("--disable-images") # Faster loading
options.add_experimental_option("excludeSwitches", ["enable-automation"])
options.add_experimental_option("useAutomationExtension", False)
# Disable WebDriver detection
driver = webdriver.Chrome(options=options)
driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
})
return driver
def scrape_dynamic_page(url):
"""JavaScript-rendered page scrape karo"""
driver = create_headless_driver()
try:
driver.get(url)
# Page fully load hone ka wait
WebDriverWait(driver, 10).until(
lambda d: d.execute_script("return document.readyState") == "complete"
)
# Additional wait for JS to render
time.sleep(2)
# Data extract karo
title = driver.find_element(By.TAG_NAME, "h1").text if driver.find_elements(By.TAG_NAME, "h1") else ""
links = [(a.text, a.get_attribute("href")) for a in driver.find_elements(By.TAG_NAME, "a") if a.text]
return {"title": title, "links": links[:5], "url": url}
except Exception as e:
print(f"Error: {e}")
return None
finally:
driver.quit()
result = scrape_dynamic_page("https://example.com")
if result:
print(f"Title: {result['title']}")
print(f"Links found: {len(result['links'])}")
Output
Title: Example Domain Links found: 1
9. Page Object Model (POM)
Example
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
class BasePage:
"""Base class for all pages"""
def __init__(self, driver):
self.driver = driver
self.wait = WebDriverWait(driver, 10)
def find(self, by, selector):
return self.wait.until(EC.presence_of_element_located((by, selector)))
def find_clickable(self, by, selector):
return self.wait.until(EC.element_to_be_clickable((by, selector)))
def click(self, by, selector):
self.find_clickable(by, selector).click()
def type_text(self, by, selector, text):
elem = self.find(by, selector)
elem.clear()
elem.send_keys(text)
def get_text(self, by, selector):
return self.find(by, selector).text
class SearchPage(BasePage):
"""Google/Bing search page"""
SEARCH_BOX = (By.NAME, "q")
SEARCH_RESULTS = (By.CSS_SELECTOR, ".result-title")
def search(self, query):
self.type_text(*self.SEARCH_BOX, query)
from selenium.webdriver.common.keys import Keys
self.driver.find_element(*self.SEARCH_BOX).send_keys(Keys.RETURN)
def get_results(self):
results = self.driver.find_elements(*self.SEARCH_RESULTS)
return [r.text for r in results]
# Usage
# driver = create_headless_driver()
# page = SearchPage(driver)
# driver.get("https://www.google.com")
# page.search("Python Selenium tutorial")
# results = page.get_results()
Summary
| Feature | Method |
|---|---|
| Navigate | driver.get(url) |
| Find element | find_element(By.X, "selector") |
| Find multiple | find_elements(By.X, "selector") |
| Click | element.click() |
| Type text | element.send_keys("text") |
| Get text | element.text |
| Get attribute | element.get_attribute("href") |
| Screenshot | driver.save_screenshot("x.png") |
| Wait | WebDriverWait(driver, 10).until(EC...) |
| Run JS | driver.execute_script("...") |
| Quit | driver.quit() |
When to use Selenium vs requests? - requests + BS4: Static HTML, APIs — faster, simpler - Selenium: JavaScript-rendered content, login forms, clicking buttons, testing UIs
⚠️ Common Mistakes
❌ Mistake 1: time.sleep() ka overuse
python example
# ❌ WRONG — fixed sleep unreliable hai
import time
driver.get("https://example.com")
time.sleep(5) # Page load ho ya na ho, 5 sec wait karega
element = driver.find_element(By.ID, "content")
# ✅ RIGHT — Explicit wait use karo
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located((By.ID, "content"))
)💡 time.sleep() makes tests slow and flaky. WebDriverWait dynamically waits until the condition becomes true.❌ Mistake 2: Not calling driver.quit()
python example
# ❌ WRONG — browser process leak hoga
driver = webdriver.Chrome()
driver.get("https://example.com")
# ... script ends without quit
# ✅ RIGHT — HAMESHA try/finally ya context manager use karo
try:
driver = webdriver.Chrome()
driver.get("https://example.com")
finally:
driver.quit()💡 If you don't call driver.quit(), Chrome processes will accumulate and slow down the system.❌ Mistake 3: Forgetting to switch frames
python example
# ❌ WRONG — element inside iframe won't be found directly
element = driver.find_element(By.ID, "iframe-content") # NoSuchElementException!
# ✅ RIGHT — switch to frame first
driver.switch_to.frame("my-iframe")
element = driver.find_element(By.ID, "iframe-content")
driver.switch_to.default_content() # Wapas main page pe❌ Mistake 4: Not handling Stale Element Reference
python example
# ❌ WRONG — after page refresh, old element reference becomes invalid
element = driver.find_element(By.ID, "btn")
driver.refresh()
element.click() # StaleElementReferenceException!
# ✅ RIGHT — re-find karo element
driver.refresh()
element = driver.find_element(By.ID, "btn")
element.click()❌ Mistake 5: Mixing implicit and explicit waits
python example
# ❌ WRONG — mixing both causes unpredictable behavior
driver.implicitly_wait(10)
wait = WebDriverWait(driver, 5) # Conflict!
# ✅ RIGHT — ek approach choose karo (Explicit recommended)
wait = WebDriverWait(driver, 10)
element = wait.until(EC.element_to_be_clickable((By.ID, "btn")))❌ Mistake 6: Not setting window size in headless mode
python example
# ❌ WRONG — default window size is small in headless mode
options.add_argument("--headless=new")
# Elements visible nahi honge, responsive layout break hoga
# ✅ RIGHT — explicit window size set karo
options.add_argument("--headless=new")
options.add_argument("--window-size=1920,1080")❌ Mistake 7: Hard-coded XPaths use karna
Example
# ❌ WRONG — fragile, DOM change hote hi break
driver.find_element(By.XPATH, "/html/body/div[3]/div[1]/div/a[2]")
# ✅ RIGHT — stable selectors use karo
driver.find_element(By.CSS_SELECTOR, "[data-testid='login-btn']")
driver.find_element(By.XPATH, "//button[contains(text(), 'Login')]")
💡 Never use absolute XPath. Prefer IDs, data attributes, or meaningful CSS selectors.
✅ Key Takeaways
- 🔑 WebDriver = Real Browser Control — Selenium programmatically operates an actual Chrome/Firefox browser, unlike the requests library
- 🔑 Headless Mode is essential for production scraping — the
--headless=newflag runs the browser without a GUI - 🔑 Explicit Waits > Implicit Waits > time.sleep() —
WebDriverWait+ Expected Conditions is the most reliable approach - 🔑 Locator Strategy Priority: ID > CSS Selector > XPath > Class Name > Tag Name — specificity matters
- 🔑 Page Object Model (POM) is a MUST for large test suites — improves maintainability and reusability
- 🔑 ALWAYS call
driver.quit()— to avoid memory leaks and zombie processes - 🔑 Anti-detection measures are necessary for scraping — hide WebDriver property, set realistic user-agent
- 🔑 ActionChains are for complex interactions (hover, drag-drop, right-click) — more powerful than simple
.click() - 🔑 Understanding frame/window switching is essential — nested content isn't accessible without
switch_to.frame()andswitch_to.window() - 🔑 Screenshots are lifesavers during debugging — use
save_screenshot()to capture visual state when tests fail
❓ FAQ
Q1: Selenium vs Playwright vs Puppeteer — kaunsa choose karein?
A: Selenium is the oldest and most widely supported (Java, Python, C#, JS). Playwright is modern, faster, and has better auto-wait. Puppeteer is Chrome-only but very fast for Node.js. Choose based on team skills and requirements.
Q2: How to fix ChromeDriver version mismatch error?
A: Use the webdriver-manager library — it automatically downloads the correct version:
python example
from webdriver_manager.chrome import ChromeDriverManager
service = Service(ChromeDriverManager().install())If managing manually, the Chrome browser version and ChromeDriver version must match.
Q3: Website is detecting Selenium — how to bypass?
A: Multiple techniques combine karo:
navigator.webdriverproperty hide karo via CDP command- Realistic User-Agent set karo
--disable-blink-features=AutomationControlledflag add karo- Random delays add karo between actions
- Note: Scrape ethically — respect the website's ToS!
Q4: How to scrape infinite scroll pages?
A: Execute JavaScript to scroll and wait for new content to load:
python example
last_height = driver.execute_script("return document.body.scrollHeight")
while True:
driver.execute_script("window.scrollTo(0, document.body.scrollHeight)")
time.sleep(2)
new_height = driver.execute_script("return document.body.scrollHeight")
if new_height == last_height:
break
last_height = new_heightQ5: How to upload files in Selenium?
A: input[type='file'] element pe directly send_keys() use karo:
Example
upload = driver.find_element(By.CSS_SELECTOR, "input[type='file']")
upload.send_keys("/path/to/file.pdf")
There's no need to make hidden inputs visible — send_keys directly sends the path.
Q6: How to handle multiple tabs/windows?
A: driver.window_handles gives a list of all open windows. switch_to.window(handle) switches to a specific window. For a new tab, use driver.execute_script('window.open()') and switch to the new handle.
Q7: How to access Shadow DOM elements?
A: Selenium 4+ mein shadow_root property available hai:
python example
shadow_host = driver.find_element(By.CSS_SELECTOR, "#shadow-host")
shadow_root = shadow_host.shadow_root
inner_element = shadow_root.find_element(By.CSS_SELECTOR, "#inner-content")Q8: How to integrate Selenium tests into a CI/CD pipeline?
A: Enable headless mode, use a Docker container (selenium/standalone-chrome), and run with pytest. In GitHub Actions / Jenkins, use xvfb (virtual display) for non-headless execution if needed.
🎯 Interview Questions
Q1: What is Selenium WebDriver and how is it different from Selenium RC?
A: Selenium WebDriver directly calls the browser's native APIs via browser-specific drivers (ChromeDriver, GeckoDriver). Selenium RC (deprecated) injected JavaScript into the browser — slower, less reliable. WebDriver is the modern, W3C standardized approach.
Q2: What is the difference between Implicit Wait, Explicit Wait, and Fluent Wait?
A:
- Implicit Wait: Set globally. Polls for the specified time on every
find_elementcall.driver.implicitly_wait(10)— searches for element up to 10 sec. - Explicit Wait: Waits for a specific condition.
WebDriverWait(driver, 10).until(EC.element_to_be_clickable(...))— gives precise control. - Fluent Wait: Advanced version of Explicit Wait — offers custom polling interval and the ability to ignore specific exceptions. Explicit Wait is recommended for production.
Q3: What is Page Object Model (POM) and what are its advantages?
A: POM is a design pattern where each web page is represented by a class. The page's elements and actions are encapsulated within that class. Advantages:
- Maintainability — when UI changes, only one place needs updating
- Reusability — the same page object is used across multiple tests
- Readability — test code stays clean and business-logic focused
- Separation of Concerns — locators and test logic are kept separate
Q4: What is Stale Element Reference Exception and how to handle it?
A: This exception occurs when the DOM is refreshed/re-rendered and the old element reference becomes invalid. Solution: Re-find the element after DOM changes, or use retry logic with explicit waits.
python example
from selenium.common.exceptions import StaleElementReferenceException
def click_with_retry(driver, locator, retries=3):
for i in range(retries):
try:
driver.find_element(*locator).click()
return
except StaleElementReferenceException:
if i == retries - 1:
raiseQ5: What are the different types of locators in Selenium? What should the priority order be?
A: Locators: By.ID, By.NAME, By.CLASS_NAME, By.TAG_NAME, By.CSS_SELECTOR, By.XPATH, By.LINK_TEXT, By.PARTIAL_LINK_TEXT. Priority: ID > Name > CSS Selector > XPath > Others. ID is fastest because it's unique in the DOM. CSS Selector parses faster than XPath. XPath is most flexible but slowest and most fragile.
Q6: What are the advantages and disadvantages of headless browser testing?
A: Advantages: Faster execution, CI/CD friendly, no GUI dependency, less resource usage. Disadvantages: Visual bugs aren't caught, some sites detect headless mode, debugging is harder (need to take screenshots), and rendering differences may exist compared to headed mode.
Q7: How do you handle dynamic web elements in Selenium?
A: For dynamic elements:
- Explicit Waits — wait for element to appear
- Dynamic XPath/CSS —
contains(),starts-with()use karo - JavaScript Executor — access directly via
execute_script() - Retry logic — retry mechanism for StaleElement
- Fluent Wait — custom polling frequency set karo
Q8: What is Selenium Grid and when do you use it?
A: Selenium Grid is a distributed testing framework that runs parallel tests on multiple machines/browsers. The Hub is the central server that distributes tests. Nodes are machines with actual browsers. Use it when you need cross-browser testing, parallel execution for faster CI/CD, or testing on different OS versions.
Q9: What is the difference between driver.close() and driver.quit()?
A: driver.close() closes only the current window/tab. driver.quit() closes all windows AND ends the WebDriver session (terminates the browser process). Always use quit() in cleanup to prevent resource leaks.
Q10: When and how do you take screenshots in Selenium? How does it help with debugging?
A: Capture screenshots automatically at test failure time:
python example
import pytest
@pytest.fixture(autouse=True)
def screenshot_on_failure(request, driver):
yield
if request.node.rep_call.failed:
driver.save_screenshot(f"screenshots/{request.node.name}.png")In debugging, screenshots are essential for seeing page state inside headless mode. Element-level screenshot (element.screenshot()) helps inspect specific UI components in isolation.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Selenium Web Automation with Python.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Python Master Course topic.
Search Terms
python-master-course, python master course, python, master, course, automation, selenium, selenium web automation with python
Related Python Master Course Topics
Continue learning this concept
AutomationEmail Automation with PythonComplete guide to email automation with Python using smtplib, email library, sending HTML emails, attachments, reading emails with IMAP, and scheduling email automation.AutomationPDF Automation with PythonMaster PDF automation with Python using PyPDF2, reportlab, pdfplumber for reading, writing, merging, splitting PDFs, extracting text/tables, and generating PDF reports.AutomationTask Scheduler with PythonComplete guide to task scheduling in Python using schedule library, APScheduler, cron jobs, threading timers, and building automated workflows with Hindi explanations.AutomationWeb Scraping with PythonComplete guide to web scraping with Python using requests, BeautifulSoup4, lxml, handling pagination, scraping APIs, and best practices with Hindi explanations.Advanced PythonPython Asynchronous Programming with asyncioDeep dive into Python async/await, asyncio event loop, coroutines, tasks, async generators, aiohttp, and real-world asynchronous patterns with Hindi explanations.Advanced PythonPython Context ManagersComprehensive guide to Python context managers using with statement, __enter__ and __exit__ methods, contextlib module, nested context managers and custom resource management.