Alternativas a XPath en Selenium: Cómo localizar elementos de manera eficiente

En Selenium, puedes localizar elementos usando diferentes estrategias además de By.XPATH. Aquí te dejo las alternativas y cómo obtenerlas en cada caso.

---

🔹 Alternativas a By.XPATH y cómo obtenerlas

Método	Descripción	Ejemplo
By.ID	Busca por el atributo id del elemento.	By.ID, "miElemento"
By.NAME	Busca por el atributo name del elemento.	By.NAME, "usuario"
By.CLASS_NAME	Busca por el atributo class del elemento.	By.CLASS_NAME, "boton-login"
By.TAG_NAME	Busca por el tipo de etiqueta HTML.	By.TAG_NAME, "button"
By.LINK_TEXT	Busca enlaces (<a>) por su texto exacto.	By.LINK_TEXT, "Iniciar sesión"
By.PARTIAL_LINK_TEXT	Busca enlaces por una parte del texto.	By.PARTIAL_LINK_TEXT, "Iniciar"
By.CSS_SELECTOR	Busca usando selectores CSS.	By.CSS_SELECTOR, ".clase .subclase"

---

✅ Ejemplo con cada alternativa:

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Espera hasta que el elemento esté presente usando diferentes métodos
elemento_id = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "miElemento")))
elemento_name = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "usuario")))
elemento_class = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, "boton-login")))
elemento_tag = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.TAG_NAME, "button")))
elemento_link = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.LINK_TEXT, "Iniciar sesión")))
elemento_partial_link = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.PARTIAL_LINK_TEXT, "Iniciar")))
elemento_css = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, ".clase .subclase")))

---

🔹 ¿Cómo obtener estos valores en la web?

Puedes inspeccionar los elementos en el navegador (F12 → "Inspeccionar elemento") y obtenerlos de la siguiente manera:

1. ID → Busca id="miElemento" en el HTML.
2. NAME → Busca name="usuario".
3. CLASS_NAME → Usa .clase si tiene class="boton-login".
4. TAG_NAME → Usa button, input, div, etc.
5. LINK_TEXT → Usa el texto visible de un enlace (<a>).
6. PARTIAL_LINK_TEXT → Usa parte del texto del enlace.
7. CSS_SELECTOR → Usa selectores CSS como .clase, #id, [atributo="valor"], etc.

---

🔥 ¿Cuándo usar cada uno?

• ID → La mejor opción si el elemento tiene un id único.
• NAME → Útil si hay varios elementos con el mismo nombre (ejemplo: formularios).
• CLASS_NAME → Bueno si la clase es específica y única.
• TAG_NAME → Si buscas todos los elementos de un tipo (button, input).
• LINK_TEXT → Si es un enlace (<a>) con texto fijo.
• PARTIAL_LINK_TEXT → Si el enlace tiene texto variable.
• CSS_SELECTOR → Más rápido que XPath en muchos casos, útil para estructuras complejas.
• XPATH → Más flexible para navegar por estructuras complejas.

Si el id o name están disponibles, úsalos en lugar de XPATH para un mejor rendimiento. 🚀

find_element en Selenium no funciona: causas y soluciones

Si el botón existe pero el código no funciona, aquí hay varias razones posibles y soluciones:

1. El botón aún no está disponible en el DOM

Aunque el botón exista, puede que Selenium intente encontrarlo antes de que esté completamente cargado. Prueba usar WebDriverWait:

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

elemento = WebDriverWait(self.driver, 10).until(
    EC.presence_of_element_located((By.XPATH, xpath_boton_login))
)

🔹 Esto espera hasta 10 segundos a que el botón aparezca en el DOM antes de continuar.

---

2. El botón no es interactuable

Puede que el botón esté en el DOM, pero todavía no sea clickeable. Usa element_to_be_clickable:

elemento = WebDriverWait(self.driver, 10).until(
    EC.element_to_be_clickable((By.XPATH, xpath_boton_login))
)

🔹 Esto espera a que el botón sea interactuable antes de seleccionarlo.

---

3. Hay un iframe que lo bloquea

Si el botón está dentro de un iframe, necesitas cambiar el foco:

self.driver.switch_to.frame("id_del_iframe")
elemento = self.driver.find_element(By.XPATH, xpath_boton_login)
self.driver.switch_to.default_content()  # Volver al contexto principal si es necesario

---

4. El botón está oculto por otro elemento

Si el botón está en el DOM pero no visible, prueba hacer scroll hasta él:

from selenium.webdriver.common.action_chains import ActionChains

elemento = self.driver.find_element(By.XPATH, xpath_boton_login)
self.driver.execute_script("arguments[0].scrollIntoView();", elemento)

🔹 Esto lo lleva a la vista antes de intentar interactuar con él.

---

5. Hay múltiples elementos con el mismo XPath

Si xpath_boton_login selecciona varios elementos, find_element podría estar encontrando el incorrecto. Prueba find_elements:

elementos = self.driver.find_elements(By.XPATH, xpath_boton_login)
if elementos:
    elemento = elementos[0]  # Seleccionar el primero

---

presence_of_element_located

Para hacer que el programa espere hasta que el elemento esté presente en el DOM antes de continuar, usa WebDriverWait con presence_of_element_located.

✅ Código para esperar hasta que el elemento esté presente:

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Esperar hasta que el elemento esté presente en el DOM (máximo 10 segundos)
elemento = WebDriverWait(self.driver, 10).until(
    EC.presence_of_element_located((By.XPATH, xpath_boton_login))
)

---

🔹 Explicación:

1. WebDriverWait(self.driver, 10): Espera hasta 10 segundos antes de lanzar una excepción.
2. until(EC.presence_of_element_located((By.XPATH, xpath_boton_login))):
   • Verifica que el elemento esté en el DOM, pero no necesariamente visible o interactuable.

Si también necesitas que el botón sea clickeable antes de continuar, usa element_to_be_clickable en lugar de presence_of_element_located.

---

✅ Código para esperar hasta que sea clickeable:

elemento = WebDriverWait(self.driver, 10).until(
    EC.element_to_be_clickable((By.XPATH, xpath_boton_login))
)

Este código espera que el botón esté en el DOM y listo para ser presionado.

Si el tiempo de espera se agota sin encontrar el elemento, lanzará un TimeoutException.

Selenium - espera explícita

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
if __name__ == '__main__':

    driver = webdriver.Chrome()
    driver.get("https://www.google.com.ar/maps")

    try:
        # $x("//*[@id='searchboxinput']")
        element = WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "searchboxinput")))
        elem=driver.find_element(By.ID, "searchboxinput")
        elem.send_keys("ddddd")

        # elemento = driver.find_element(By.ID, "searchboxinput")
        elemento = driver.find_element(By.XPATH, "//input[@id='searchboxinput']")
        time.sleep(4)




    except Exception:
        print("nada")
    finally:
        print("fin")
        driver.quit()from selenium.webdriver.support.wait import WebDriverWait

Las siguientes son las condiciones esperadas que se pueden utilizar en la espera explícita.

1. alertIsPresent()
2. elementSelectionStateToBe()
3. elementToBeClickable()
4. elementToBeSelected()
5. frameToBeAvaliableAndSwitchToIt()
6. invisibilityOfTheElementLocated()
7. invisibilityOfElementWithText()
8. presenceOfAllElementsLocatedBy()
9. presenceOfElementLocated()
10. textToBePresentInElement()
11. textToBePresentInElementLocated()
12. textToBePresentInElementValue()
13. titleIs()
14. titleContains()
15. visibilityOf()
16. visibilityOfAllElements()
17. visibilityOfAllElementsLocatedBy()
18. visibilityOfElementLocated()

QT Designer - aplicacion comentada PyQt5

Link al repositorio acá 

import sys
from PyQt5 import uic, QtGui
from PyQt5.QtWidgets import QMainWindow, QApplication


class MainWindow(QMainWindow): #nota7: cuando llama a la clase, viene por aca

    def __init__(self): #nota8: el __init__ de initialized, es el codigo que SIEMPRE se ejecuta, el def ventanaNueva no se ejecuta porque esta fuera de aca, aca se conectan botones, los eventos que vayan a pasar, las restricciones, etc...
        super().__init__() #superposiciona el init, siempre va.
        uic.loadUi('gui_1.ui', self) #aca se carga la gui
        self.pushButton.clicked.connect(self.ventanaNueva) #aca conecta el boton de nombre pushButton que nos da el designer y lo  conectamos a la funcion ventanaNueva

    def ventanaNueva(self):
        gui2.show() #y aca muestra la ventana y nada mas
        #gui2.showMaximized() #esto esta para que prueven cambiando y viendo como cambia
        #gui2.showMinimized() #esto esta para que prueven cambiando y viendo como cambia

class Window2(QMainWindow):
    def __init__(self):
        super().__init__()
        uic.loadUi('gui_2.ui', self)

if __name__ == '__main__':  #nota1: esto siempre va, es para que el programa siempre ejecute esta parte
    app = QApplication(sys.argv) #Nota2: aca crea un objeto para hacer las aplicaciones
    gui = MainWindow() #Nota3: todas las ventanas tendran su armado mediante esto, un objeto del tipo variable=Clase_del_objeto()
    gui2= Window2() #Nota4: para la gui2
    gui.show() #Nota5: aca muestra la gui principal la main, como ya la tiene armada(en Nota3) ahora la muestra mediante el metodo .show(), hay varias maneras, showMaximiced() la muestra maximixada por ej
    sys.exit(app.exec_()) #Nota6: esto es para que quede abierto, sino se cierra el programa, queda ejecutandose

Haciendo el ejecutable

asta acá puedes hacer tu programa y ejecutarlo a medida que vas modificando y agregando interfaces pero a la hora de hacer el ejecutable es necesario hacer cambios...

al momento de usar auto-py-to-exe, muy práctico a la hora de exportar me encontré con algunos problemas, pero recurrí a usar pyuic5 para transformar los .ui a .py y así usar todos los .py en el programa de auto-py-to-exe (donde encontrarlo) 

hay que instalar las librerías necesarias

pip install pyqt5-sip
pip install pyqt5 

con la terminal abierta en la ubicación donde estan los .ui se ingresa el siguiente codigo, usando pycharm puedes usar ALT+F12 y se abre abajo.

pyuic5 -x gui_1.ui -o gui_1_ui.py

la forma es: pyuic5 -x <archivo .ui> -o <nuevo_archivo .py>

el nombre de archivo.ui pasa a archivo_ui.py

para nuestro programa usamos...

>pyuic5 -x gui_1.ui -o gui_1_ui.py

>pyuic5 -x gui_2.ui -o gui_2_ui.py

Esto amerita unos cambios en el codigo...

import sys
from PyQt5 import uic, QtGui
from PyQt5.QtWidgets import QMainWindow, QApplication
from PyQt5 import QtWidgets

#####
from gui_1_ui import *  # NUEVO
from gui_2_ui import *  # NUEVO


#####

# class MainWindow(QMainWindow): #nota7: cuando llama a la clase, viene por aca
class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):  # NUEVO

    def __init__(
            self):  # nota8: el __init__ de initialized, es el codigo que SIEMPRE se ejecuta, el def ventanaNueva no se ejecuta porque esta fuera de aca, aca se conectan botones, los eventos que vayan a pasar, las restricciones, etc...
        # super().__init__()  # superposiciona el init, siempre va.
        # uic.loadUi('gui_1.ui', self)  # aca se carga la gui
        QtWidgets.QMainWindow.__init__(self)  # NUEVO
        self.setupUi(self)  # NUEVO
        self.pushButton.clicked.connect(
            self.ventanaNueva)  # aca conecta el boton de nombre pushButton que nos da el designer y lo  conectamos a la funcion ventanaNueva

    def ventanaNueva(self):
        gui2.show()  # y aca muestra la ventana y nada mas
        # gui2.showMaximized() #esto esta para que prueven cambiando y viendo como cambia
        # gui2.showMinimized() #esto esta para que prueven cambiando y viendo como cambia


# class Window2(QMainWindow):
class Window2(QtWidgets.QWidget, Ui_Form):  # NUEVO
    def __init__(self):
        QtWidgets.QMainWindow.__init__(self)  # NUEVO
        self.setupUi(self)  # NUEVO
        # super().__init__()
        # uic.loadUi('gui_2.ui', self)


# if __name__ == '__main__':  # nota1: esto siempre va, es para que el programa siempre ejecute esta parte
#    app = QApplication(sys.argv)  # Nota2: aca crea un objeto para hacer las aplicaciones
#   gui = MainWindow()  # Nota3: todas las ventanas tendran su armado mediante esto, un objeto del tipo variable=Clase_del_objeto()
#    gui2 = Window2()  # Nota4: para la gui2
#    gui.show()  # Nota5: aca muestra la gui principal la main, como ya la tiene armada(en Nota3) ahora la muestra mediante el metodo .show(), hay varias maneras, showMaximiced() la muestra maximixada por ej
#    sys.exit(app.exec_())  # Nota6: esto es para que quede abierto, sino se cierra el programa, queda ejecutandose

app = QApplication([])  # NUEVO
gui = MainWindow()  # NUEVO
gui2 = Window2()  # NUEVO
gui.show()  # NUEVO
app.exec_()  # NUEVO

luego en una terminal de anaconda, ejecutamos Auto-py-to-exe

en Additional Files, agregamos los .py nuevos

pyinstaller --noconfirm --onefile --console --name "ejemplo4" --add-data "C:/Users/Gaston/PycharmProjects/ejemplo/gui_1_ui.py;." --add-data "C:/Users/Gaston/PycharmProjects/ejemplo/gui_2_ui.py;."  "C:/Users/Gaston/PycharmProjects/ejemplo/main.py"

el programa funciona pero se habre una terminal, con cambiarlo en  Console Window es suficiente

pyinstaller --noconfirm --onefile --windowed --name "ejemplo5" --add-data "C:/Users/Gaston/PycharmProjects/ejemplo/gui_1_ui.py;." --add-data "C:/Users/Gaston/PycharmProjects/ejemplo/gui_2_ui.py;."  "C:/Users/Gaston/PycharmProjects/ejemplo/main.py"

el codigo limpio queda asi...

import sys
from PyQt5 import uic, QtGui
from PyQt5.QtWidgets import QMainWindow, QApplication
from PyQt5 import QtWidgets
from gui_1_ui import *
from gui_2_ui import *


class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):

    def __init__(
            self):
        QtWidgets.QMainWindow.__init__(self)
        self.setupUi(self)
        self.pushButton.clicked.connect(
            self.ventanaNueva)

    def ventanaNueva(self):
        gui2.show()


class Window2(QtWidgets.QWidget, Ui_Form):
    def __init__(self):
        QtWidgets.QMainWindow.__init__(self)
        self.setupUi(self)


app = QApplication([])
gui = MainWindow()
gui2 = Window2()
gui.show()
app.exec_()

01100110 01101001 01101110 00100000 01100100 01100101 00100000 01100011 01101111 01100100 01101001 01100111 01101111

RETURN

sobre Web Scraping

---------------------------------------------------------------------------------------------------------------

pip install requests ; para hacer requerimientos a un servidor

pip install beautifulsoup4 : para parcer los HTML

pip install lxml : para parcer los HTML

pip install selenium : para hacer extracciones dinámicas

pip install Pillow : para hacer extracciones de imágenes

pip install pymongo : para hacer guardado de información en base de datos

si hay problemas usar --user al final, da permisos de administrador, sudo para linux

pip install scrapy

---------------------------------------------------------------------------------------------------------------

tipos de web-scraping

nivel 1: tipo estático, donde toda la información permanece en una página web y no hay cargas del tipo dinámico.

librerías a usar:

1. requests: para hacer requerimientos (pip install requests)
2. xml y BeautifulSoup para parcear los requerimientos y extraer informacion
3. scrapy para realizar requerimientos, parcearlos y extraer información

nivel 2: tipo estático con varias paginas con el mismo dominio, puede ser horizontal(llamado crollin horizontal) que es cuando tiene varias páginas en la parte inferior y se dirige a una página del mismo dominio y crollin vertical que es cuando de va accediendo al detalle de los elementos de la misma página.

librerías a usar:

1. scrapy para realizar requerimientos, parcearlos y extraer información

nivel 3:tipo dinámico, donde se automatiza las acciones de un navegador (mediante python por ej) 

librerías a usar:

1. Selenium python

nivel 4: usos de apis

nivel 5: donde se expande este mundo con

• Autenticación
• captchas
• iFrames 

pasos a seguir para hacer web scraping 

1. Se define una URL semilla, la pagina principal de donde se extraen los datos
2. Realizar los requerimientos (requests)
3. Obtener respuesta del servidor (en formato HTML)
4. Se extrae la información deseada del HTML
5. Se repite el paso 2 con otras URL del mismo dominio (dentro del crollin vertical/horizontal)

para el paso 4, como se extrae la información del HTML mediante XPATH

    XPATH: es un lenguaje que nos permite construir expresiones que recorren y procesan un documento XML. un HTML es un documento del tipo XML

página para practicar XPATH

trucos con XPATH

al momento de armar un xpath se tienen en cuenta

• los ejes (axis) da pie donde se realizará la búsqueda (ej: mediante // se busca en TODO el documento, con  / solo en la raíz y con ./ es una búsqueda relativa al lugar en el que se está)
• el nodo de búsqueda (step) que es el nombre del tag del elemento en el que hacemos foco.
• se definen los predicador, para pulir mas la búsqueda, por medio del usos de los atributos del tag, los atributos tienen un nombre y un valor  

ejemplo

para seleccionar page con el titulo matemáticas , puede hacerse mediante

//page[@title='Clase']/page[@title='2005']/page[@title='Matemáticas']

apretando shift y posando el mouse sobre la palabra sugiere...

//page[2]/page[2]/page[2]/@title 

el eje(axis) es el //, el nodo(step) el page y los predicados van dentro de [ ]  habiendo claro, muchas formas de construirlos. Se pueden indexar las búsquedas.

si van a la pagina de práctica y usan el siguiente código...

-------------------------------------- inicio codigo --------------------------------------

<app>

    <welcome-message>Hi! This is xpather beta...</welcome-message>

    <abstract>

        This web app enables you to query XML/HTML documents with your

browser in real time. It can generate queries for you too! 

    </abstract>

    <description>

        <subject>

You can enter your xpath query in the top-left panel 

and it will be instantly executed against this document.

Once some results are displayed on the right, you can 

scroll to them by clicking on them. 

</subject>

<subject>

To generate an xpath query for a specific element,

please hold CTRL and hover over it.

An xpath is generated heuristically with the aim

to be unambiguous and the shortest possible.

</subject>

    </description>

<extra-notes>

<note>

None of entered documents leave your computer because all

the processing is done by your powerful browser!

(of course as long as you do not save your input)

</note>

        <note>

This application is in an early beta version so please

be forgiving. XPath 2.0 is supported but namespaces are

still being added and they may not fully work yet. 

Please send your comments to: xpather.com@gmail.com

</note>

<note>

By default XML mode is used but if a document cannot

be parsed as XML then HTML mode kicks in.

</note>

<note>

Pasting documents bigger than 500kb may cause your

browser become sluggish or unresponsive.

</note>

</extra-notes>

</app>

-------------------------------------- fin codigo --------------------------------------

y quieren extraer el texto del último note pueden hacerlo mediante //note[last()]/text() acá se observa el uso de función como last() y text()

hay otros como...

position()=<numero>

contains(<tag(ej. @id)>,<cadena string(ej. "Matem")>) #si dentro de un tag contiene un tipo de cadena de string.

not # para negar un predicado

text() # extrae el texto

mas info en https://developer.mozilla.org/es/docs/Web/XPath/Functions (algunas entradas fallan)

webs de interés sobre xml y xpath

http://www.w3bai.com/es/xml/xml_syntax.html

https://diego.com.es/xml-principios-basicos

https://www.guru99.com/xpath-selenium.html#6

Probar expresiones en caliente

al apretar F12 podemos inspeccionar la pagina en la que estemos, en console podemos usar... 

$x("<expresion XPATH>")

mecanismos

teniendo...

import requests
from lxml import html

encabezados = {
    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36"
}

url = "https://www.wikipedia.org/"

respuesta = requests.get(url, headers=encabezados)

requests = respuesta.text #solo lo convierte a texto plano

parser = html.fromstring(requests) #convierte el requests en un parceador, para extraer datos.

dato = parser.get_element_by_id("Matemática") # obtener elemento con id = "Matemática", entrega objeto de tipo elemento porque es una clase

dato_texto = dato.text_content() #para extrar el dato "Matemática" y poder imprimirlo, por ej.

# extraccion de datos usando beautifulSoup
import requests
from bs4 import BeautifulSoup

encabezados = {
    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36"
}
# primer paso, definimos URL semilla
url = 'https://stackoverflow.com/questions'
respuesta = requests.get(url, headers=encabezados)
soup = BeautifulSoup(respuesta.text)
contenedor_de_preguntas = soup.find(id='questions')
lista_de_preguntas = contenedor_de_preguntas.find_all('div', class_='question-summary')
for pregunta in lista_de_preguntas:
    titulo_pregunta = pregunta.find('h3').text
    descripcion_pregunta = pregunta.find(class_='excerpt').text
    descripcion_pregunta = descripcion_pregunta.replace('\n', '').replace('\r', '').strip()

soup.find() #busca según determinado parámetro

contenedor_de_preguntas.find_all() #busca todos los elementos que cumplan la función, entrega una lista.

se usa class_ porque class es una palabra reservada de python.

descripcion_pregunta.replace('\n', '').replace('\r', '').strip() #mediante estos códigos se limpia el resultado

RETURN

La Biblioteca Estándar de Python

 La Biblioteca Estándar de Python
 Mientras que The Python Language Reference describe la sintaxis y la semántica exactas del lenguaje Python, este manual de referencia de la biblioteca describe la biblioteca estándar que se distribuye con Python. También describe algunos de los componentes opcionales que se incluyen comúnmente en las distribuciones de Python.
La biblioteca estándar de Python es muy extensa, ofreciendo un amplio rango de facilidades como se indica en la larga tabla de contenidos que aparece a continuación. La librería contiene módulos incorporados (escritos en C) que proporcionan acceso a la funcionalidad del sistema, como ficheros de E/S que de otra forma serían inaccesibles para los programadores de Python, así como módulos escritos en Python que proporcionan soluciones estandarizadas para muchos problemas que ocurren en la programación diaria. Algunos de estos módulos están explícitamente diseñados para fomentar y mejorar la portabilidad de los programas en Python, abstrayendo los específicos de la plataforma en APIs de plataforma neutral.
Los instaladores de Python para la plataforma Windows suelen incluir toda la biblioteca estándar y a menudo también incluyen muchos componentes adicionales. Para los sistemas operativos tipo Unix, Python se proporciona normalmente como una colección de paquetes, por lo que puede ser necesario utilizar las herramientas de empaquetado proporcionadas con el sistema operativo para obtener algunos o todos los componentes opcionales.
Además de la biblioteca estándar, hay una creciente colección de varios miles de componentes (desde programas y módulos individuales hasta paquetes y marcos de desarrollo de aplicaciones completos), disponibles en el Índice de Paquetes Python.

• Introduction (Introducción)
  
  • Notes on availability (Notas sobre la disponibilidad)
• Built-in Functions (Funciones incorporadas)
• Built-in Constants (Constantes incorporadas)
  
  • Constants added by the site module (Constantes añadidas por el módulo del sitio)
• Built-in Types (Tipos incorporados)
  
  • Truth Value Testing (Prueba de valor de la verdad)
  • Boolean Operations — and, or, not (Operaciones booleanas - y, o, no)
  • Comparisons (Comparaciones)
  • Numeric Types — int, float, complex (Tipos numéricos - int, float, complex)
  • Iterator Types (Tipo de iteradores)
  • Sequence Types — list, tuple, range (Tipos de secuencia - lista, tupla, rango)
  • Text Sequence Type — str (Tipo de secuencia de texto - str)
  • Binary Sequence Types — bytes, bytearray, memoryview (Tipos de secuencia binaria - bytes, matriz de bytes, vista de memoria)
  • Set Types — set, frozenset (Tipos de set - set, set congelado)
  • Mapping Types — dict (Tipos de mapas - dict)
  • Context Manager Types (Tipos de Gestor de Contexto)
  • Other Built-in Types (Otros tipos incorporados)
  • Special Attributes (Atributos especiales)
• Built-in Exceptions (Excepciones incorporadas)
  
  • Base classes (Clases de base)
  • Concrete exceptions (Excepciones concretas)
  • Warnings (Advertencias)
  • Exception hierarchy (Jerarquía de excepciones)
• Text Processing Services (Servicios de procesamiento de textos)
  
  • string — Common string operations (Operaciones comunes de string)
  • re — Regular expression operations (Operaciones de expresión regular)
  • difflib — Helpers for computing deltas (Ayudas para el cálculo de los deltas)
  • textwrap — Text wrapping and filling (Envoltura y relleno de texto)
  • unicodedata — Unicode Database (Base de datos Unicode)
  • stringprep — Internet String Preparation (Preparación de cadenas de Internet)
  • readline — GNU readline interface (Interfaz de línea de lectura de GNU)
  • rlcompleter — Completion function for GNU readline (Función de finalización para la línea de lectura de GNU)
• Binary Data Services (Servicios de datos binarios)
  
  • struct — Interpret bytes as packed binary data
  • codecs — Codec registry and base classes
• Data Types (Tipos de datos)
  
  • datetime — Basic date and time types (Tipos básicos de fecha y hora)
  • calendar — General calendar-related functions (Funciones generales relacionadas con el calendario)
  • collections — Container datatypes (Tipos de datos de contenedor)
  • collections.abc — Abstract Base Classes for Containers (Clases base abstractas para contenedores)
  • heapq — Heap queue algorithm (Algoritmo de cola de espera)
  • bisect — Array bisection algorithm (Algoritmo de bisección de matrices)
  • array — Efficient arrays of numeric values (Matrices eficientes de valores numéricos)
  • weakref — Weak references (Referencias débiles)
  • types — Dynamic type creation and names for built-in types
  • copy — Shallow and deep copy operations
  • pprint — Data pretty printer (Impresora bonita de datos)
  • reprlib — Alternate repr() implementation (Implementación alternativa de repr ())
  • enum — Support for enumerations (Soporte para enumeraciones)
• Numeric and Mathematical Modules (Módulos numéricos y matemáticos)
  
  • numbers — Numeric abstract base classes (Clases base abstractas numéricas)
  • math — Mathematical functions (Funciones matematicas)
  • cmath — Mathematical functions for complex numbers (Funciones matemáticas para números complejos.)
  • decimal — Decimal fixed point and floating point arithmetic (Punto fijo decimal y aritmética de coma flotante)
  • fractions — Rational numbers (Numeros racionales)
  • random — Generate pseudo-random numbers (Generar números pseudoaleatorios)
  • statistics — Mathematical statistics functions (Funciones de estadística matemática)
• Functional Programming Modules (Módulos de programación funcional)
  
  • itertools — Functions creating iterators for efficient looping (Funciones que crean iteradores para un bucle eficiente)
  • functools — Higher-order functions and operations on callable objects (Funciones y operaciones de orden superior en objetos invocables)
  • operator — Standard operators as functions (Operadores estándar como funciones)
• File and Directory Access (Acceso a Archivos y Directorios)
  
  • pathlib — Object-oriented filesystem paths (Rutas de sistema de archivos orientadas a objetos)
  • os.path — Common pathname manipulations (Manipulaciones comunes de nombres de ruta)
  • fileinput — Iterate over lines from multiple input streams (Iterar sobre líneas de múltiples flujos de entrada)
  • stat — Interpreting stat() results (Interpretación de los resultados de stat ())
  • filecmp — File and Directory Comparisons (Comparaciones de archivos y directorios)
  • tempfile — Generate temporary files and directories (Generar archivos y directorios temporales)
  • glob — Unix style pathname pattern expansion (Expansión de patrón de nombre de ruta de estilo Unix)
  • fnmatch — Unix filename pattern matching (Unix coincidencia de patrones de nombre de archivo)
  • linecache — Random access to text lines (Acceso aleatorio a líneas de texto)
  • shutil — High-level file operations
  • macpath — Mac OS 9 path manipulation functions
• Data Persistence (Persistencia de los datos)
  
  • pickle — Python object serialization
  • copyreg — Register pickle support functions
  • shelve — Python object persistence
  • marshal — Internal Python object serialization
  • dbm — Interfaces to Unix “databases”
  • sqlite3 — DB-API 2.0 interface for SQLite databases
• Data Compression and Archiving (Compresión y archivo de datos)
  
  • zlib — Compression compatible with gzip (Compresión compatible con gzip)
  • gzip — Support for gzip files (Soporte para archivos gzip)
  • bz2 — Support for bzip2 compression (Soporte para compresión bzip2)
  • lzma — Compression using the LZMA algorithm (Compresión usando el algoritmo LZMA)
  • zipfile — Work with ZIP archives (Trabajar con archivos ZIP)
  • tarfile — Read and write tar archive files (Leer y escribir archivos tar)
• File Formats (Formatos de archivo)
  
  • csv — CSV File Reading and Writing (Lectura y escritura de archivos CSV)
  • configparser — (Analizador de archivos de configuración)
  • netrc — netrc file processing (procesamiento de archivos netrc)
  • xdrlib — Encode and decode XDR data (Codificar y decodificar datos XDR)
  • plistlib — Generate and parse Mac OS X .plist files
• Cryptographic Services
  • hashlib — Secure hashes and message digests (Asegure hashes y resúmenes de mensajes)
  • hmac — Keyed-Hashing for Message Authentication
  • secrets — Generate secure random numbers for managing secrets (Genere números aleatorios seguros para administrar secretos)
• Generic Operating System Services (Servicios de sistema operativo genérico)
  
  • os — Miscellaneous operating system interfaces (Interfaces diversas del sistema operativo)
  • io — Core tools for working with streams (Herramientas básicas para trabajar con flujos)
  • time — Time access and conversions (Tiempo de acceso y conversiones)
  • argparse — Parser for command-line options, arguments and sub-commands
  • getopt — C-style parser for command line options (Analizador de estilo C para opciones de línea de comando)
  • logging — Logging facility for Python (Instalación de registro para Python)
  • logging.config — Logging configuration (Configuración de registro)
  • logging.handlers — Logging handlers (Controladores de registro)
  • getpass — Portable password input (Entrada de contraseña portátil)
  • curses — Terminal handling for character-cell displays (Manejo de terminales para pantallas de celdas de caracteres)
  • curses.textpad — Text input widget for curses programs (Widget de entrada de texto para programas de maldiciones)
  • curses.ascii — Utilities for ASCII characters (Utilidades para caracteres ASCII)
  • curses.panel — A panel stack extension for curses (Una extensión de pila de paneles para maldiciones)
  • platform — Access to underlying platform’s identifying data (Acceso a los datos de identificación de la plataforma subyacente.)
  • errno — Standard errno system symbols (Símbolos del sistema errno estándar)
  • ctypes — A foreign function library for Python (Una biblioteca de funciones foráneas para Python)
• Concurrent Execution (Ejecución concurrente)
  
  • threading — Thread-based parallelism (Paralelismo basado en hilos)
  • multiprocessing — Process-based parallelism (Paralelismo basado en procesos)
  • The concurrent package (El paquete concurrente)
  • concurrent.futures — Launching parallel tasks (Lanzar tareas paralelas)
  • subprocess — Subprocess management (Gestión de subprocesos)
  • sched — Event scheduler (Planificador de eventos)
  • queue — A synchronized queue class (Una clase de cola sincronizada)
  • _thread — Low-level threading API
  • _dummy_thread — Drop-in replacement for the _thread module
  • dummy_threading — Drop-in replacement for the threading module
• contextvars — Context Variables (Variables de contexto)
  
  • Context Variables (Variables de contexto)
  • Manual Context Management (Gestión manual de contexto)
  • asyncio support (apoyo asincrónico)
• Networking and Interprocess Communication (Redes y comunicación entre procesos)
  
  • asyncio — Asynchronous I/O
  • socket — Low-level networking interface
  • ssl — TLS/SSL wrapper for socket objects
  • select — Waiting for I/O completion
  • selectors — High-level I/O multiplexing
  • asyncore — Asynchronous socket handler
  • asynchat — Asynchronous socket command/response handler
  • signal — Set handlers for asynchronous events
  • mmap — Memory-mapped file support
• Internet Data Handling
  • email — An email and MIME handling package
  • json — JSON encoder and decoder
  • mailcap — Mailcap file handling
  • mailbox — Manipulate mailboxes in various formats
  • mimetypes — Map filenames to MIME types
  • base64 — Base16, Base32, Base64, Base85 Data Encodings
  • binhex — Encode and decode binhex4 files
  • binascii — Convert between binary and ASCII
  • quopri — Encode and decode MIME quoted-printable data
  • uu — Encode and decode uuencode files
• Structured Markup Processing Tools
  • html — HyperText Markup Language support
  • html.parser — Simple HTML and XHTML parser
  • html.entities — Definitions of HTML general entities
  • XML Processing Modules
  • xml.etree.ElementTree — The ElementTree XML API
  • xml.dom — The Document Object Model API
  • xml.dom.minidom — Minimal DOM implementation
  • xml.dom.pulldom — Support for building partial DOM trees
  • xml.sax — Support for SAX2 parsers
  • xml.sax.handler — Base classes for SAX handlers
  • xml.sax.saxutils — SAX Utilities
  • xml.sax.xmlreader — Interface for XML parsers
  • xml.parsers.expat — Fast XML parsing using Expat
• Internet Protocols and Support
  • webbrowser — Convenient Web-browser controller
  • cgi — Common Gateway Interface support
  • cgitb — Traceback manager for CGI scripts
  • wsgiref — WSGI Utilities and Reference Implementation
  • urllib — URL handling modules
  • urllib.request — Extensible library for opening URLs
  • urllib.response — Response classes used by urllib
  • urllib.parse — Parse URLs into components
  • urllib.error — Exception classes raised by urllib.request
  • urllib.robotparser — Parser for robots.txt
  • http — HTTP modules
  • http.client — HTTP protocol client
  • ftplib — FTP protocol client
  • poplib — POP3 protocol client
  • imaplib — IMAP4 protocol client
  • nntplib — NNTP protocol client
  • smtplib — SMTP protocol client
  • smtpd — SMTP Server
  • telnetlib — Telnet client
  • uuid — UUID objects according to RFC 4122
  • socketserver — A framework for network servers
  • http.server — HTTP servers
  • http.cookies — HTTP state management
  • http.cookiejar — Cookie handling for HTTP clients (Manejo de cookies para clientes HTTP)
  • xmlrpc — XMLRPC server and client modules (Servidor XMLRPC y módulos de cliente)
  • xmlrpc.client — XML-RPC client access (Acceso de cliente XML-RPC)
  • xmlrpc.server — Basic XML-RPC servers (Servidores básicos de XML-RPC)
  • ipaddress — IPv4/IPv6 manipulation library (Biblioteca de manipulación de IPv4 / IPv6)
• Multimedia Services (Servicios multimedia)
  
  • audioop — Manipulate raw audio data (Manipular datos de audio sin procesar)
  • aifc — Read and write AIFF and AIFC files (Leer y escribir archivos AIFF y AIFC)
  • sunau — Read and write Sun AU files (Leer y escribir archivos Sun AU)
  • wave — Read and write WAV files (Leer y escribir archivos WAV)
  • chunk — Read IFF chunked data (Leer datos fragmentados de IFF)
  • colorsys — Conversions between color systems (Conversiones entre sistemas de color)
  • imghdr — Determine the type of an image (Determinar el tipo de imagen)
  • sndhdr — Determine type of sound file (Determinar el tipo de archivo de sonido)
  • ossaudiodev — Access to OSS-compatible audio devices (Acceso a dispositivos de audio compatibles con OSS)
• Internationalization (Internacionalizacion)
  
  • gettext — Multilingual internationalization services (Servicios de internacionalización multilingües)
  • locale — Internationalization services (Servicios de internacionalización)
• Program Frameworks (Marcos de programa)
  
  • turtle — Turtle graphics (Gráficos de tortuga)
  • cmd — Support for line-oriented command interpreters
  • shlex — Simple lexical analysis
• Graphical User Interfaces with Tk
  • tkinter — Python interface to Tcl/Tk
  • tkinter.ttk — Tk themed widgets
  • tkinter.tix — Extension widgets for Tk
  • tkinter.scrolledtext — Scrolled Text Widget
  • IDLE
  • Other Graphical User Interface Packages (Otros paquetes de interfaz gráfica de usuario)
• Development Tools (Herramientas de desarrollo)
  
  • typing — Support for type hints (Soporte para sugerencias de tipo)
  • pydoc — Documentation generator and online help system (Generador de documentación y sistema de ayuda en línea)
  • doctest — Test interactive Python examples (Prueba ejemplos interactivos de Python)
  • unittest — Unit testing framework (Marco de pruebas unitarias)
  • unittest.mock — mock object library (biblioteca de objetos simulados)
  • unittest.mock — getting started
  • 2to3 - Automated Python 2 to 3 code translation
  • test — Regression tests package for Python
  • test.support — Utilities for the Python test suite
  • test.support.script_helper — Utilities for the Python execution tests
• Debugging and Profiling
  • bdb — Debugger framework
  • faulthandler — Dump the Python traceback
  • pdb — The Python Debugger
  • The Python Profilers
  • timeit — Measure execution time of small code snippets
  • trace — Trace or track Python statement execution
  • tracemalloc — Trace memory allocations
• Software Packaging and Distribution
  • distutils — Building and installing Python modules
  • ensurepip — Bootstrapping the pip installer
  • venv — Creation of virtual environments
  • zipapp — Manage executable Python zip archives
• Python Runtime Services
  • sys — System-specific parameters and functions
  • sysconfig — Provide access to Python’s configuration information
  • builtins — Built-in objects
  • __main__ — Top-level script environment
  • warnings — Warning control
  • dataclasses — Data Classes
  • contextlib — Utilities for with-statement contexts
  • abc — Abstract Base Classes
  • atexit — Exit handlers
  • traceback — Print or retrieve a stack traceback
  • __future__ — Future statement definitions
  • gc — Garbage Collector interface
  • inspect — Inspect live objects
  • site — Site-specific configuration hook
• Custom Python Interpreters
  • code — Interpreter base classes
  • codeop — Compile Python code
• Importing Modules
  • zipimport — Import modules from Zip archives
  • pkgutil — Package extension utility
  • modulefinder — Find modules used by a script
  • runpy — Locating and executing Python modules
  • importlib — The implementation of import
• Python Language Services
  • parser — Access Python parse trees
  • ast — Abstract Syntax Trees
  • symtable — Access to the compiler’s symbol tables
  • symbol — Constants used with Python parse trees
  • token — Constants used with Python parse trees
  • keyword — Testing for Python keywords
  • tokenize — Tokenizer for Python source
  • tabnanny — Detection of ambiguous indentation
  • pyclbr — Python class browser support
  • py_compile — Compile Python source files
  • compileall — Byte-compile Python libraries
  • dis — Disassembler for Python bytecode
  • pickletools — Tools for pickle developers
• Miscellaneous Services
  • formatter — Generic output formatting
• MS Windows Specific Services
  • msilib — Read and write Microsoft Installer files
  • msvcrt — Useful routines from the MS VC++ runtime
  • winreg — Windows registry access
  • winsound — Sound-playing interface for Windows
• Unix Specific Services
  • posix — The most common POSIX system calls
  • pwd — The password database
  • spwd — The shadow password database
  • grp — The group database
  • crypt — Function to check Unix passwords
  • termios — POSIX style tty control
  • tty — Terminal control functions
  • pty — Pseudo-terminal utilities
  • fcntl — The fcntl and ioctl system calls
  • pipes — Interface to shell pipelines
  • resource — Resource usage information
  • nis — Interface to Sun’s NIS (Yellow Pages)
  • syslog — Unix syslog library routines
• Superseded Modules
  • optparse — Parser for command line options
  • imp — Access the import internals
• Undocumented Modules
  • Platform specific modules

RETURN