Управление окнами браузера: как программно закрыть лишнюю вкладку на Python

Всем привет! Если вы занимаетесь парсингом или автоматизацией веб-тестов, то наверняка сталкивались с ситуацией, когда ваш скрипт начинает плодить вкладки как кроликов. Кликнули по ссылке — новая вкладка, нажали на рекламный баннер — еще одна. Если вовремя не навести порядок, браузер быстро «съест» всю оперативную память, и ваш мощный сервер превратится в тыкву. Сегодня мы разберем, как элегантно закрыть вкладку python, чтобы ваш код работал стабильно часами и сутками. Я поделюсь своим опытом работы с библиотеками Selenium и Playwright, объясню, почему иногда вкладки отказываются закрываться, и покажу, как управлять «фокусом» браузера, чтобы не закрыть то, что вам еще нужно.

Selenium: Close против Quit — в чем реальная разница?

Начинающие разработчики часто путают две базовые команды Selenium. Кажется, что и та, и другая должны «выключить» браузер, но на деле их работа сильно отличается. Если ваша задача — именно закрыть вкладку python, сохранив при этом работу остального браузера, вам нужно четко понимать логику WebDriver. Метод driver.close() закрывает только то окно или вкладку, на которой в данный момент сфокусирован драйвер. Если у вас открыто пять вкладок и вы вызовете close(), закроется одна, а остальные останутся висеть в памяти.

С другой стороны, driver.quit() — это «ядерная кнопка». Она полностью завершает процесс браузера, закрывает все окна и освобождает все ресурсы, связанные с сессией WebDriver. В профессиональной разработке хорошим тоном считается использовать close() для очистки мусорных вкладок в процессе работы, а quit() — строго в конце работы скрипта (в блоке finally). Это гарантирует, что даже если скрипт упадет с ошибкой, процесс браузера не останется «зомби» в вашей системе, потребляя ресурсы впустую.

📚 Документация:Selenium WebDriver.close() «Метод close() закрывает текущее окно, на которое сфокусирован WebDriver. Если это было последнее открытое окно, браузер закроется полностью.»

Практика: Как закрыть вкладку в Selenium и не потерять управление

Чтобы успешно закрыть конкретную вкладку, нужно сначала на нее переключиться. Selenium видит вкладки как список уникальных идентификаторов (хендлов). Чтобы эффективно закрыть вкладку python, мы должны получить список всех открытых окон, выбрать нужное и отправить команду закрытия. Но будьте осторожны: после закрытия текущей вкладки драйвер остается «в пустоте». Вам обязательно нужно переключить его на любое другое живое окно, иначе следующая команда (например, поиск элемента) вызовет ошибку NoSuchWindowException.

Ранее мы уже подробно разбирали переход между вкладками Python Selenium, и эти знания нам сейчас пригодятся. Логика проста: запоминаем основную вкладку, открываем новую, делаем там дела, закрываем её и возвращаемся назад. Это стандартный паттерн для любого парсера, который заходит в карточки товаров и возвращается в общий список.

from selenium import webdriver
import time

driver = webdriver.Chrome()
driver.get("https://ya.ru/")

# Сохраняем ID главной вкладки
main_window = driver.current_window_handle

# Допустим, мы открыли новую вкладку (имитируем это через JS)
driver.execute_script("window.open('https://google.com', '_blank');")
time.sleep(2) # Даем время на загрузку

# Получаем список всех вкладок
all_windows = driver.window_handles

# Переключаемся на новую вкладку (она будет последней в списке)
driver.switch_to.window(all_windows[1])
print(f"Сейчас мы на вкладке: {driver.title}")

# Задача: закрыть вкладку python (текущую новую)
driver.close()

# ВАЖНО: Переключаемся обратно на главную, иначе драйвер потеряется
driver.switch_to.window(main_window)
print(f"Вернулись на: {driver.title}")

driver.quit()

В этом примере мы использовали window_handles — это список строк. Индексация начинается с нуля, где 0 — это самая первая вкладка. Если вы открываете много окон, всегда следите за тем, на каком индексе вы находитесь. Не забывайте про Selenium на Python: полное руководство, где я описывал работу с ожиданиями, так как вкладка может не успеть появиться в списке мгновенно.

Playwright: Современный подход к закрытию вкладок

Playwright — это более современный инструмент, который работает быстрее и стабильнее Selenium. Здесь концепция вкладок реализована через «страницы» (Pages) внутри «контекста» (BrowserContext). Это гораздо удобнее: вам не нужно постоянно жонглировать хендлами, как в Selenium. Чтобы закрыть вкладку python в Playwright, вам достаточно вызвать метод .close() непосредственно у объекта страницы. При этом фокус на других страницах не теряется автоматически, что делает код чище.

Playwright позволяет изолировать сессии. Вы можете открыть один браузер, создать в нем три контекста, и в каждом будет свой набор вкладок и куки. Это киллер-фича для многопоточного парсинга. Если вы закроете контекст, закроются все вкладки внутри него, но сам браузер останется запущенным для других задач.

📚 Документация:Playwright Page.close() «Метод page.close() завершает работу конкретной страницы. После этого события ‘close’ отправляются всем слушателям. Это лучший способ освободить ресурсы отдельной вкладки без остановки всего браузера.»

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=False)
    context = browser.new_context()
    
    # Открываем первую страницу
    page1 = context.new_page()
    page1.goto("https://ya.ru/")
    
    # Открываем вторую страницу (вкладку)
    page2 = context.new_page()
    page2.goto("https://google.com")
    
    print(f"Открыто вкладок: {len(context.pages)}")
    
    # Чтобы закрыть вкладку python в Playwright, просто вызываем метод у объекта
    page2.close()
    
    print(f"Осталось вкладок: {len(context.pages)}")
    
    browser.close()

Как видите, в Playwright всё гораздо интуитивнее. Вам не нужно помнить, какая страница «активна» для драйвера — вы просто обращаетесь к переменной page2 и закрываете её. Это отличный пример того, как писать чистый и читаемый код на Python, избегая лишних переключений состояний.

Продвинутые сценарии: Закрытие вкладок по условию

Иногда нам нужно не просто закрыть текущую вкладку, а почистить все, кроме главной. Например, после долгого парсинга у вас остались висеть рекламные окна или пустые страницы. В Selenium это делается простым циклом. Мы перебираем все хендлы и закрываем те, чей идентификатор не совпадает с нашим «главным».

Такой подход часто используется, когда скрипт сталкивается с динамическими всплывающими окнами (pop-ups). Если вы не знаете как найти элемент в JavaScript через Python, который закрывает крестик на баннере, проще всего найти хендл этого окна и принудительно его закрыть через driver.close().

# Пример для Selenium: закрыть все вкладки, кроме основной
for handle in driver.window_handles:
    if handle != main_window:
        driver.switch_to.window(handle)
        driver.close()

# Не забываем вернуться на главную в конце цикла
driver.switch_to.window(main_window)

В Playwright это делается еще изящнее через список context.pages. Вам не нужно менять фокус драйвера — вы просто фильтруете объекты страниц и вызываете метод закрытия у тех, которые вам не нравятся.

from playwright.sync_api import sync_playwright

def close_tabs_by_condition():
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        context = browser.new_context()
        
        # Открываем несколько разных страниц
        main_page = context.new_page()
        main_page.goto("https://ya.ru/")
        
        # Имитируем открытие рекламных и сервисных вкладок
        context.new_page().goto("https://google.com/ads")
        context.new_page().goto("https://bing.com")
        
        print(f"Всего открыто вкладок: {len(context.pages)}")

        # Продвинутое закрытие: оставляем только наш сайт
        for page in context.pages:
            # Проверяем URL или заголовок страницы
            if "pythonauto.org" not in page.url:
                print(f"Закрываем лишнюю вкладку: {page.url}")
                page.close()
        
        print(f"После чистки осталось вкладок: {len(context.pages)}")
        
        # Продолжаем работу на главной странице
        print(f"Текущая активная страница: {main_page.title()}")
        browser.close()

if __name__ == "__main__":
    close_tabs_by_condition()

Разбор логики примера:

• context.pages: Мы получаем актуальный список объектов всех открытых вкладок. Это живой список, который можно обходить обычным циклом for.
• Условие фильтрации: В примере мы проверяем, содержит ли URL адрес нашего сайта. Вы можете проверять что угодно: page.title(), наличие определенного текста на странице или даже время жизни вкладки.
• Отсутствие switch_to: Это самое важное. Мы просто говорим конкретному объекту page.close(). Нам не нужно перемещать «курсор» внимания браузера туда-обратно, что делает код в разы быстрее и надежнее, чем в Selenium.

Полный код проекта: Универсальный менеджер вкладок

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
import time

def tab_manager_demo():
    # Настройка драйвера
    options = webdriver.ChromeOptions()
    driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options)
    
    try:
        driver.get("https://ya.ru/")
        main_tab = driver.current_window_handle
        
        links = ["https://google.com", "https://bing.com"]
        
        for link in links:
            # Открываем ссылку в новой вкладке
            driver.execute_script(f"window.open('{link}', '_blank');")
            time.sleep(2)
            
            # Переключаемся на самую последнюю открытую вкладку
            new_tab = driver.window_handles[-1]
            driver.switch_to.window(new_tab)
            
            print(f"Работаем на странице: {driver.title}")
            
            # Здесь могла быть логика парсинга...
            
            # Задача: закрыть вкладку python после выполнения работы
            print(f"Закрываем {link}...")
            driver.close()
            
            # Возвращаемся на базу
            driver.switch_to.window(main_tab)
            
        print("Все дополнительные вкладки обработаны и закрыты!")
        
    except Exception as e:
        print(f"Ошибка в процессе: {e}")
    finally:
        # Всегда используем quit, чтобы не плодить процессы в системе
        driver.quit()

if __name__ == "__main__":
    tab_manager_demo()

Разбор кода:

• driver.window_handles[-1]: Мы используем индекс -1, чтобы всегда попадать на последнюю открытую вкладку. Это надежнее, чем гадать с индексами 1, 2 или 3.
• try…finally: Это критически важно. Если на этапе driver.close() произойдет сбой, блок finally всё равно выполнит driver.quit(), и ваш компьютер не зависнет от открытых в фоне браузеров.
• window.open: Использование JavaScript для открытия вкладок — это самый стабильный способ, который работает одинаково во всех браузерах.

Заключение

Умение вовремя закрыть вкладку python — это признак качественного кода. Неважно, используете вы Selenium или Playwright, чистота вашей сессии напрямую влияет на скорость парсинга и стабильность работы всей системы. Помните о разнице между close() и quit(), всегда возвращайте фокус на главную страницу в Selenium и не забывайте про обработку исключений. Теперь ваш браузер будет работать как часы, а оперативная память скажет вам «спасибо».