硒，存在的许多元素之一？
Selenium, Presence of one of many elements located?
根据 How to wait until the page is loaded with Selenium for Python? 的答案，我正在尝试创建一种方法，允许使用预期条件轮询多个元素是否存在。
我收到错误 'bool' object is not callable 在包含以下内容的行上：wait.until(any(expectations))。
思考过程是允许按预期条件传递多个 Xpath，然后使用 any(), in a similar manner to this java based answer, Trying to wait for one of two elements in the page using selenium xpath，检查是否存在任何条件。
在这种情况下使用 any() 的正确方法是什么？或者更好的是，需要做什么才能使此方法起作用？
假设 Selenium .get('url') 已在调用此方法之前立即执行。
def wait_with_xpath_expectation(self, search_elements, timeout=6, max_attempts=3):
"""
Selenium wait for an element(s) designated by Xpath to become available in the DOM. Useful for javascript AJAXy
loading pages where content may be be rendered dynamically on the client side after page load appears complete.
search_elements may be one Xpath as a string or many as a list. This allows for any of multiple elements on a
page or pages to be determined to have loaded based on expectations.
:param search_elements: string or list (strings converted to lists), Xpath(s)
:param timeout: int, seconds
:param max_attempts: int, time to wait before giving up on page loading
:return: Boolean, True if page has loaded, False if all attempts have failed
"""
# Page is not loaded yet
loaded = False
# Initialize attempt count
attempt = 0
# If only one element has been passed, ensure it is encapsulated by a list
if type(search_elements) is str:
search_elements = [search_elements]
# Begin the polling loop
while attempt < max_attempts:
try:
while loaded is False:
# Create a list of expected elements using list comprehension
expectations = [EC.presence_of_element_located((By.XPATH, element)) for element in search_elements]
# Define wait
wait = WebDriverWait(self.browser, timeout)
# Execute
wait.until(any(expectations))
# Acknowledge load
loaded = True
print("Success: Page loaded based on expectations")
# Exit returning True for load
return loaded
except TimeoutException as e:
# Increment attempts
attempt += 1
# Check again if max attempts has not been exceeded
while attempt < max_attempts:
# Increase timeout by 20%
timeout *= .2
# Try again
continue
# Print an error if max attempts is exceeded
print("Error: Max load with expectations attempts exceeded,", e)
# Exit returning False for load
return loaded
一旦我意识到 Xpath 具有联合的能力，下面的方法就起作用了。我会留下这个答案，以防其他人有更好的答案。
def wait_with_xpath_expectation(self, search_elements, timeout=6, max_attempts=3):
"""
Selenium wait for an element designated by Xpath to become available in the DOM. Useful for javascript AJAXy
loading pages where content may be be rendered dynamically on the client side after page load appears complete.
search_elements may be one Xpath as a string or many as a list. This allows for any of multiple elements on a
page or pages to be determined to have loaded based on expectations.
:param search_elements: string or list (strings converted to lists), Xpath(s)
:param timeout: int, seconds
:param max_attempts: int, time to wait before giving up on page loading
:return: Boolean, True if page has loaded, False if all attempts have failed
"""
# Page is not loaded yet
loaded = False
# Initialize attempt count
attempt = 0
# If only one element has been passed, ensure it is encapsulated by a list
if type(search_elements) is str:
search_elements = [search_elements]
# Begin the polling loop
while attempt < max_attempts:
try:
while loaded is False:
# Decompose the list of Xpaths to a union of nodes
node_union = " | ".join(search_elements)
expectation = EC.presence_of_element_located((By.XPATH, node_union))
# Define wait
wait = WebDriverWait(self.browser, timeout)
# Execute
wait.until(expectation)
# Acknowledge load
loaded = True
print("Success: Page loaded based on expectations")
# Exit returning True for load
return loaded
except TimeoutException as e:
# Increment attempts
attempt += 1
# Check again if max attempts has not been exceeded
while attempt < max_attempts:
# Increase timeout by 20%
timeout *= .2
# Try again
continue
# Print an error if max attempts is exceeded
print("Error: Max load with expectations attempts exceeded,", e)
# Exit returning False for load
return loaded
您可以有一个预期条件 class 来等待预期条件的组合。这是一个例子。
class wait_for_all(object):
def __init__(self, methods):
self.methods = methods
def __call__(self, driver):
try:
for method in self.methods:
if not method(driver):
return False
return True
except StaleElementReferenceException:
return False
这将通过构建预期条件数组并在同一等待中检查所有这些条件来使用。 （为清楚起见，拆分了示例行。）
methods = []
methods.append(EC.visibility_of_element_located(BY.ID, "idElem1"))
methods.append(EC.visibility_of_element_located(BY.ID, "idElem2"))
method = wait_for_all(methods)
WebDriverWait(driver, 5).until(method)
这将在检查两个不同元素的可见性时等待五秒钟。
我在博客中进一步记录了这一点 post here。
根据 How to wait until the page is loaded with Selenium for Python? 的答案，我正在尝试创建一种方法，允许使用预期条件轮询多个元素是否存在。
我收到错误 'bool' object is not callable 在包含以下内容的行上：wait.until(any(expectations))。
思考过程是允许按预期条件传递多个 Xpath，然后使用 any(), in a similar manner to this java based answer, Trying to wait for one of two elements in the page using selenium xpath，检查是否存在任何条件。
在这种情况下使用 any() 的正确方法是什么？或者更好的是，需要做什么才能使此方法起作用？
假设 Selenium .get('url') 已在调用此方法之前立即执行。
def wait_with_xpath_expectation(self, search_elements, timeout=6, max_attempts=3):
"""
Selenium wait for an element(s) designated by Xpath to become available in the DOM. Useful for javascript AJAXy
loading pages where content may be be rendered dynamically on the client side after page load appears complete.
search_elements may be one Xpath as a string or many as a list. This allows for any of multiple elements on a
page or pages to be determined to have loaded based on expectations.
:param search_elements: string or list (strings converted to lists), Xpath(s)
:param timeout: int, seconds
:param max_attempts: int, time to wait before giving up on page loading
:return: Boolean, True if page has loaded, False if all attempts have failed
"""
# Page is not loaded yet
loaded = False
# Initialize attempt count
attempt = 0
# If only one element has been passed, ensure it is encapsulated by a list
if type(search_elements) is str:
search_elements = [search_elements]
# Begin the polling loop
while attempt < max_attempts:
try:
while loaded is False:
# Create a list of expected elements using list comprehension
expectations = [EC.presence_of_element_located((By.XPATH, element)) for element in search_elements]
# Define wait
wait = WebDriverWait(self.browser, timeout)
# Execute
wait.until(any(expectations))
# Acknowledge load
loaded = True
print("Success: Page loaded based on expectations")
# Exit returning True for load
return loaded
except TimeoutException as e:
# Increment attempts
attempt += 1
# Check again if max attempts has not been exceeded
while attempt < max_attempts:
# Increase timeout by 20%
timeout *= .2
# Try again
continue
# Print an error if max attempts is exceeded
print("Error: Max load with expectations attempts exceeded,", e)
# Exit returning False for load
return loaded
一旦我意识到 Xpath 具有联合的能力，下面的方法就起作用了。我会留下这个答案，以防其他人有更好的答案。
def wait_with_xpath_expectation(self, search_elements, timeout=6, max_attempts=3):
"""
Selenium wait for an element designated by Xpath to become available in the DOM. Useful for javascript AJAXy
loading pages where content may be be rendered dynamically on the client side after page load appears complete.
search_elements may be one Xpath as a string or many as a list. This allows for any of multiple elements on a
page or pages to be determined to have loaded based on expectations.
:param search_elements: string or list (strings converted to lists), Xpath(s)
:param timeout: int, seconds
:param max_attempts: int, time to wait before giving up on page loading
:return: Boolean, True if page has loaded, False if all attempts have failed
"""
# Page is not loaded yet
loaded = False
# Initialize attempt count
attempt = 0
# If only one element has been passed, ensure it is encapsulated by a list
if type(search_elements) is str:
search_elements = [search_elements]
# Begin the polling loop
while attempt < max_attempts:
try:
while loaded is False:
# Decompose the list of Xpaths to a union of nodes
node_union = " | ".join(search_elements)
expectation = EC.presence_of_element_located((By.XPATH, node_union))
# Define wait
wait = WebDriverWait(self.browser, timeout)
# Execute
wait.until(expectation)
# Acknowledge load
loaded = True
print("Success: Page loaded based on expectations")
# Exit returning True for load
return loaded
except TimeoutException as e:
# Increment attempts
attempt += 1
# Check again if max attempts has not been exceeded
while attempt < max_attempts:
# Increase timeout by 20%
timeout *= .2
# Try again
continue
# Print an error if max attempts is exceeded
print("Error: Max load with expectations attempts exceeded,", e)
# Exit returning False for load
return loaded
您可以有一个预期条件 class 来等待预期条件的组合。这是一个例子。
class wait_for_all(object):
def __init__(self, methods):
self.methods = methods
def __call__(self, driver):
try:
for method in self.methods:
if not method(driver):
return False
return True
except StaleElementReferenceException:
return False
这将通过构建预期条件数组并在同一等待中检查所有这些条件来使用。 （为清楚起见，拆分了示例行。）
methods = []
methods.append(EC.visibility_of_element_located(BY.ID, "idElem1"))
methods.append(EC.visibility_of_element_located(BY.ID, "idElem2"))
method = wait_for_all(methods)
WebDriverWait(driver, 5).until(method)
这将在检查两个不同元素的可见性时等待五秒钟。
我在博客中进一步记录了这一点 post here。