Imagine being a programmer who has to repeat some boring and tedious tasks every day— logging into websites, submitting forms, scraping data, checking webpage content, or taking screenshots and recording screens.
Isn’t it annoying? Now, what if we told you that Python can make browsers obey through automation tools and help you complete these heavy tasks? You would surely be very happy.
Today, as your programming guide blogger, we will dive deep into Playwright, this powerful browser automation tool, and see how it can free your hands and improve your work efficiency!
Playwright is a modern browser automation framework developed by Microsoft. Compared to Selenium, Playwright is lighter, more efficient, and supports cross-browser operations (Chrome, Firefox, Webkit).
Most importantly, Playwright provides stronger control over webpage content, including network interception, screenshots, and page interactions. Moreover, Playwright is based on Node.js, but it can also be perfectly integrated with Python through the playwright-python package.
Why choose Playwright?
Cross-browser support: Playwright supports Google Chrome, Firefox, and Webkit (the engine for Safari). One framework, all browser support.
Fast and stable: Compared to Selenium, Playwright is faster in page loading and element rendering, and it is more stable.
Automation control: It not only supports simulating user clicks, inputs, and scrolling but also controls page network requests, responses, and even simulates device environments.
Suitable for modern web applications: Playwright can support some dynamic web pages, especially the automation of single-page applications (SPAs), solving the issues that Selenium often encounters with such pages.
Next, let’s explore how to achieve browser automation using Playwright with Python! You will learn how to install Playwright, how to automate tasks with it, and how to perform some advanced operations.
1. Installing Playwright
First, we need to install the Python version of Playwright. You can install Playwright and its dependencies using the pip command:
pip install playwrightOnce the installation is complete, we need to use the tools provided by Playwright to download the required browsers.
python -m playwright installThis command will download all the browsers required by Playwright: Chromium, Firefox, and WebKit. These browsers are internally supported by Playwright, so you don’t need to worry about their installation and configuration.
2. Starting the browser and performing page operations
After installation, we can start playing around. First, let’s implement a simple browser automation task: opening a webpage and taking a screenshot.
Example code: Open a webpage and take a screenshot
from playwright.sync_api import sync_playwright
def run():
with sync_playwright() as p:
# Start the browser
browser = p.chromium.launch(headless=False) # headless=False means open the browser window
page = browser.new_page() # Create a new tab
page.goto('https://www.python.org') # Visit the Python official website
# Take a screenshot and save it to the current directory
page.screenshot(path='python_org.png')
print("Screenshot saved!")
# Close the browser
browser.close()
if __name__ == "__main__":
run()Code explanation:
sync_playwright(): The synchronous version of Playwright, which we use to start the browser and operate on the page.
browser = p.chromium.launch(headless=False): Launches the Chromium browser, where headless=False means to open the browser window. If you want the browser to run in the background (headless mode), you can set headless to True.
page.goto(‘https://www.python.org’): The browser visits the Python official website.
page.screenshot(path=’python_org.png’): Takes a screenshot and saves it.
Output:
After running this code, the browser will automatically open the Python official website and save a screenshot named python_org.png in the current directory.
3. Page interaction: Simulating clicks and inputs
In web automation, simulating user behavior is one of the most common tasks. Playwright makes these operations very simple. We can simulate clicking buttons, entering text, and even handling pop-up windows.
Example code: Fill out a form and submit
Suppose we need to automate a login process. We will simulate filling in the username and password and clicking the login button.
from playwright.sync_api import sync_playwright
def run():
with sync_playwright() as p:
browser = p.chromium.launch(headless=False)
page = browser.new_page()
# Open the login page
page.goto('https://example.com/login')
# Fill in the username and password
page.fill('input[name="username"]', 'myusername') # Fill in the username
page.fill('input[name="password"]', 'mypassword') # Fill in the password
# Simulate clicking the login button
page.click('button[type="submit"]') # Wait a moment to ensure the page loads
page.wait_for_selector('div#welcome-message') # Wait for the welcome message to display
print("Login successful!")
browser.close()
if __name__ == "__main__":
run()Code explanation:
page.fill(): Fills in a text box, passing the selector and the value to fill in.
page.click(): Clicks a button or link, passing the button’s CSS selector.
page.wait_for_selector(): Waits for the specified element to load completely. This is a very useful operation to ensure that the page elements are fully rendered.
Advanced tips:
Form validation: You can capture the response of network requests through Playwright to validate the results after form submission, rather than just relying on changes in page content.
Dynamic waiting: wait_for_selector() allows your script to wait for an element to load, avoiding errors caused by incomplete page rendering.
4. Network interception and control
Playwright also provides powerful network control features, allowing you to intercept requests, simulate responses, and even modify the content of HTTP requests.
Example code: Intercept requests and modify responses
from playwright.sync_api import sync_playwright
def run():
with sync_playwright() as p:
browser = p.chromium.launch(headless=False)
page = browser.new_page()
# Intercept requests and modify response content
page.on('route', lambda route, request: route.continue_(url="https://example.com/data", method="GET", headers=request.headers))
# Visit the page that needs to intercept requests
page.goto('https://example.com')
# Perform some operations to ensure requests occur
browser.close()
if __name__ == "__main__":
run()Code explanation:
page.on(‘route’, lambda route, request: route.continue_()): Intercepts all HTTP requests and modifies the request behavior. You can continue the request, modify request headers, simulate custom responses, etc.
Advanced tips:
Simulating network environments: You can control request delays, simulate different network conditions, etc., for complex performance testing.
Custom responses: You can directly return custom response content, simulating different results returned by the server.
5. Automated screenshots and page recording
Playwright not only supports screenshots but also allows for page recording, which can be used to generate test cases or create demonstrations of dynamic content.
Example code: Record page operations
from playwright.sync_api import sync_playwright
def run():
with sync_playwright() as p:
browser = p.chromium.launch(headless=False)
page = browser.new_page()
# Start recording
page.start_video(path="test_video.mp4")
# Open the webpage and perform operations
page.goto("https://www.example.com")
page.click('text=More Information')
# Stop recording
page.stop_video()
print("Video recording completed!")
browser.close()
if __name__ == "__main__":
run()Code explanation:
page.start_video(): Starts recording page operations, generating a video.
page.stop_video(): Stops recording and saves the video file.
6. Summary and Expansion
Through this article, you have mastered the basic operations of Playwright, including browser control, page interaction, network interception, screenshots, and recording. Next, you can apply this knowledge to real projects:
Web scraping and automated testing: By automating the browser, you can regularly scrape webpage content or write automated test cases to ensure website functionality remains stable.
Simulating different devices and environments: By simulating different browsers and devices, you can check how the website performs on different platforms.
Complex business process automation: If you have highly repetitive tasks in your work, Playwright can help you automate all of this and improve efficiency.
From basic browser automation to complex network request control, Playwright can handle it efficiently.
I hope this article helps you gain a deeper understanding of the powerful features of Playwright, allowing you to advance further on your programming journey!