# Funciones Built-in

El intérprete de Python tiene una serie de funciones y tipos incluidos en él que están siempre disponibles. Están listados aquí en orden alfabético.

|  | Funciones Built-in |  |
--- | --- | --- | --- | ---
`abs()` | `delattr()` | `hash()` | `memoryview()` | `set()`
`all()` | `dict()` | `help()` | `min()` | `setattr()`
`any()` | `dir()` | `hex()` | `next()` | `slice()`
`ascii()` | `divmod()` | `id()` | `object()` | `sorted()`
`bin()` | `enumerate()` | `input()` | `oct()` | `staticmethod()`
`bool()` | `eval()` | `int()` | `open()` | `str()`
`breakpoint()` | `exec()` | `isinstance()` | `ord()` | `sum()`
`bytearray()` | `filter()` | `issubclass()` | `pow()` | `super()`
`bytes()` | `float()` | `iter()` | `print()` | `tuple()`
`callable()` | `format()` | `len()` | `property()` | `type()`
`chr()` | `frozenset()` | `list()` | `range()` | `vars()`
`classmethod()` | `getattr()` | `locals()` | `repr()` | `zip()`
`compile()` | `globals()` | `map()` | `reversed()` | `__import__()`
`complex()` | `hasattr()` | `max()` | `round()` |

`abs`(x)

  Retorna el valor absoluto de un número. El argumento puede ser un número entero o de punto flotante. Si el argumento es un número complejo, retorna su magnitud. Si x define un método `__abs__()`, `abs(x)` retorna `x.__abs__()`.

`all`(iterable)

  Retorna `True` si todos los elementos del iterable son verdaderos (o si el iterable está vacío). Equivalente a:

      def all(iterable):
          for element in iterable:
              if not element:
                  return False
          return True

`any`(iterable)

  Retorna `True` si un elemento cualquiera del iterable es verdadero. Si el iterable está vacío, retorna `False`. Equivalente a:

      def any(iterable):
          for element in iterable:
              if element:
                  return True
          return False

`ascii`(object)

  Como `repr()`, retorna una cadena que contiene una representación imprimible de un objeto, pero que escapa los caracteres no-ASCII que `repr()` retorna usando `\x`, `\u` or `\U`. Esto genera una cadena similar a la retornada por `repr()` en Python 2.

`bin`(x)

  Convierte un número entero a una cadena binaria con prefijo «0b». El resultado es una expresión de Python válida. Si x no es un objeto de clase `int` en Python, tiene que definir un método `__index__()` que retorne un entero. Algunos ejemplos:

      >>> bin(3)
      '0b11'
      >>> bin(-10)
      '-0b1010'

  Según se desee o no el prefijo «0b», se puede usar uno u otro de las siguientes maneras.

      >>> format(14, '#b'), format(14, 'b')
      ('0b1110', '1110')
      >>> f'{14:#b}', f'{14:b}'
      ('0b1110', '1110')

  Véase también `format()` para más información.

class `bool`([x])

  Retorna un booleano, es decir, o bien `True` o `False`. x es convertido usando el estándar truth testing procedure. Si x es falso u omitido, retorna `False`; en caso contrario retorna `True`. La clase `bool` es una subclase de `int` (véase Tipos numéricos — int, float, complex). De ella no pueden derivarse más subclases. Sus únicas instancias son `False` y `True` (véase Valores booleanos).

  Distinto en la versión 3.7: x es ahora un argumento solo de posición.

`breakpoint`(*args, **kws)

  Esta función te lleva al depurador en el sitio donde se produce la llamada. Específicamente, llama a `sys.breakpointhook()`, pasando `args` y `kws` directamente. Por defecto, `sys.breakpointhook()` llama a `pdb.set_trace()` sin esperar argumentos. En este caso, es puramente una función de conveniencia para evitar el importe explícito de `pdb` o tener que escribir tanto código para entrar al depurador. Sin embargo, `sys.breakpointhook()` puede ser configurado a otra función y `breakpoint()` llamará automáticamente a esta, permitiendo entrar al depurador elegido.

  Lanza un evento de auditoría `builtins.breakpoint` con `breakpointhook` como argumento.

  Nuevo en la versión 3.7.

class `bytearray`([source[, encoding[, errors]]])

  Retorna un nuevo array de bytes. La clase `bytearray` es una secuencia mutable de enteros en el rango 0 <= x < 256. Tiene la mayoría de los métodos comunes en las secuencias mutables, descritos en Tipos de secuencia mutables, así como la mayoría de los métodos que la clase `bytes` tiene, véase Operaciones de bytes y bytearray.

  El parámetro opcional source puede ser empleado para inicializar el vector (array) de varias maneras distintas:

  - Si es una string, debes proporcionar también el parámetro encoding (y opcionalmente, errors; entonces `bytearray()` convierte la cadena a bytes empleando `str.encode()`.

  - Si es un integer, el array tendrá ese tamaño y será inicializado con bytes nulos.

  - If it is an object conforming to the buffer interface, a read-only buffer of the object will be used to initialize the bytes array.

  - Si es un iterable, debe ser un iterable de enteros en el rango `0 <= x < 256`, que son usados como los contenidos iniciales del array.

  Sin argumento, se crea un array de tamaño 0.

  Ver también: Tipos de secuencias binarias — bytes, bytearray y memoryview y Objetos de tipo Bytearray.

class `bytes`([source[, encoding[, errors]]])

  Retorna un nuevo objeto bytes, que es una secuencia inmutable de enteros en el rango `0 <= x < 256`. `bytes` es una versión inmutable de `bytearray` — tiene los mismos métodos no-mutables y el mismo comportamiento en términos de indexación y segmentación.

  En consecuencia, los argumentos del constructor son interpretados como los de `bytearray()`.

  Los objetos de bytes también pueden ser creados con literales, ver Literales de cadenas y bytes.

  Ver también Tipos de secuencias binarias — bytes, bytearray y memoryview, Objetos de tipo Bytes, y Operaciones de bytes y bytearray.

`callable`(object)

  Retorna `True` si el argumento object parece invocable, y `False` sino. Si retorna `True`, aun es posible que la invocación falle, pero si es `False`, invocar el object no funcionará nunca. Hay que tener en cuenta que las clases son invocables (ya que llamarlas retorna una instancia nueva); y que las instancias lo serán si su clase tiene un método `__call__()`.

  Nuevo en la versión 3.2: Está función fue eliminada en Python 3.0 pero traída de vuelta en Python 3.2.

`chr`(i)

  Retorna la cadena que representa un carácter cuyo código Unicode es el entero i. Por ejemplo, `chr(97)` retorna la cadena `’a’`, mientras que `chr(8364)` retorna la cadena `’€’`. Esta función es la inversa de `ord()`.

  El rango válido para el argumento i es desde 0 a 1,114,111 (0x10FFFF en base 16). Se lanzará una excepción `ValueError` si i está fuera de ese rango.

`@``classmethod`

  Transforma un método en un método de clase.

  Un método de clase recibe la clase como primer argumento implícito, de la misma forma que un método de instancia recibe la instancia. Para declarar un método de clase, emplea la siguiente expresión:

      class C:
          @classmethod
          def f(cls, arg1, arg2, ...): ...

  La forma `@classmethod` es una función decorator — ver Definiciones de funciones para más detalles.

  Un método de clase puede ser llamado en la clase (como `C.f()`) o en la instancia (como `C().f()`). La instancia es ignorada salvo por su clase. Si un método de clase es llamado desde una clase derivada, entonces el objeto de la clase derivada se pasa como primer argumento implícito.

  Los métodos de clase son diferentes a los métodos estáticos de C++ o Java. Si quieres ese tipo de métodos, revisa `staticmethod()`.

  Para más información sobre métodos de clase, ver Jerarquía de tipos estándar.

`compile`(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

  Compila el source en código o en un objeto AST (Abstract Syntax Tree, árbol de sintaxis abstracta). Los objetos código pueden ser ejecutados por las funciones `exec()` or `eval()`. source puede ser una cadena normal, una cadena de bytes o un objeto AST. Para más información sobre cómo trabajar con objetos AST, revisa la documentación del módulo `ast`.

  El argumento filename debería dar el fichero desde el que el código fue leído; pasará un valor reconocible en caso este no fuera leído de un fichero (`’<string>’` es usado comúnmente para esto).

  El argumento mode especifica que tipo de código debe ser compilado; puede ser `’exec’` si source consiste en una secuencia de declaraciones, `’eval’` si consiste de una expresión sencilla, o `’single’` si consiste en una declaración única interactiva (en este último caso, las declaraciones de expresiones que evalúen a algo distinto de `None` serán impresas).

  Los argumentos opcionales flags y dont_inherit controlan que future statements afectan a la compilación de source. Si ninguno de los dos está presente (o los dos son cero), el código se compila con las declaraciones futuras que están en el código que está llamando a `compile()`. Si el argumento flags está presente, y dont_inherit no (o es cero), entonces se usan las declaraciones futuras especificadas en el argumento flags, además de aquellas que iban a ser utilizadas en cualquier caso. Si dont_inherit es un entero distinto de cero entonces el argumento flags es ignorado y no se consideran las declaraciones futuras en efecto durante la llamada a compile.

  Las declaraciones futuras son especificadas por bits que pueden, bit a bit, ser unidos por OR para especificar múltiples declaraciones. El campo de bit requerido para especificar una característica específica puede ser encontrado como el atributo `compiler_flag` de la instancia de la clase `_Feature` en el módulo `__future__`.

  El argumento opcional flags también controla si el código compilado puede contener `await`, `async for` y `async with` de nivel superior. Cuando se establece el bit `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT` , el objeto código retornado tiene `CO_COROUTINE` establecido en `co_code`, y puede ser ejecutado de forma interactiva a través de `await eval(code_object)`.

  El argumento optimize especifica el nivel de optimización del compilador; el valor por defecto de `-1` selecciona el nivel de optimización del intérprete de la misma forma que las opciones `-O`. Los niveles explícitos son `0` (sin optimización; `__debug__` es true), `1` (se eliminan los asserts, `__debug__` es false) or `2` (las docstrings también son eliminadas).

  Esta función lanza un `SyntaxError` si el código compilado es inválido, y un `ValueError` si contiene bytes nulos.

  Si quieres transformar código Python a su representación AST, revisa `ast.parse()`.

  Lanza un evento de auditoría `compile` con argumentos `source` y `filename`. Este evento también puede ser lanzado por la compilación implícita.

  Nota

  Cuando se compile una cadena multilínea de código en los modos `’single’` o `’eval’`, la entrada debe terminar con un carácter de nueva línea como mínimo. Esto facilita la detección de declaraciones completas e incompletas en el módulo `code`.

  Advertencia

  Con una cadena lo suficientemente larga o compleja, al compilar a un objeto AST es posible que el intérprete de Python pare inesperadamente debido a las limitaciones de la profundidad de la pila en el compilador del AST de Python.

  Distinto en la versión 3.2: Permite el uso de caracteres de nueva línea de Windows y Mac. También, la entrada en el modo `’exec’` no tiene porque terminar en una nueva línea. Se añade el parámetro optimize.

  Distinto en la versión 3.5: Anteriormente, un `TypeError` era lanzado cuando se encontraban bytes nulos en source.

  Nuevo en la versión 3.8: `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT` puede ahora ser pasado en flags para permitir el soporte de `await`, `async for`, y `async with` en niveles superiores.

class `complex`([real[, imag]])

  Retorna el número complejo con el valor real + imag*1j o convierte una cadena o un número a un número complejo. Si el primer parámetro es una cadena, será interpretada como un número complejo y la función debe ser llamada sin un segundo parámetro. El segundo parámetro nunca puede ser una cadena. Cada argumento puede ser de cualquier tipo numérico (incluyendo complex). Si se omite imag, su valor por defecto es cero y el constructor sirve como un conversor numérico como `int` y `float`. Si ambos argumentos son omitidos, retorna `0j`.

  Para un objeto general de Python `x`, `complex(x)` delega a `x.__complex__()`. Si `__complex__()` no está definida, entonces llama a `__float__()`. Si `__float__()` no está definida, entonces llama a `__index__()`.

  Nota

  Cuando se convierte desde una cadena, la cadena no debe contener espacios en blanco alrededor de los operadores centrales `+` or `-`. Por ejemplo, `complex(‘1+2j’)` es correcto, pero `complex(‘1 + 2j’)` lanza `ValueError`.

  El tipo complejo está descrito en Tipos numéricos — int, float, complex.

  Distinto en la versión 3.6: Agrupar dígitos con guiones bajos como en los literales de código está permitido.

  Distinto en la versión 3.8: Recurre a `__index__()` si `__complex__()` y `__float__()` no están definidos.

`delattr`(object, name)

  Esta función está emparentada con `setattr()`. Los argumentos son un objeto y una cadena. La cadena debe ser el mismo nombre que alguno de los atributos del objeto. La función elimina el atributo nombrado, si es que el objeto lo permite. Por ejemplo `delattr(x, ‘foobar’)` es equivalente a `del x.foobar`.

class `dict`(**kwarg)
class `dict`(mapping, **kwarg)
class `dict`(iterable, **kwarg)

  Crea un nuevo diccionario. El objeto `dict` es la clase diccionario. Véase `dict` y Tipos Mapa — dict para más información sobre esta clase.

  Para otros contenedores véase las clases incorporadas (built-in) `list`, `set`, y `tuple`, así como el módulo `collections`.

`dir`([object])

  Sin argumentos, retorna la lista de nombres en el ámbito local. Con un argumento, intenta retornar una lista de atributos válidos para ese objeto.

  Si el objeto tiene un método llamado `__dir__()`, éste será llamado y debe retornar la lista de atributos. Esto permite que los objetos que implementan una función personalizada `__getattr__()` o `__getattribute__()` puedan decidir la manera en la que `dir()` reporta sus atributos.

  Si el objeto no provee de un método `__dir__()`, la función intenta obtener la información del atributo `__dict__` del objeto, si está definido, y de su objeto tipo. La lista resultante no está necesariamente completa, y puede ser inexacta cuando el objeto tiene una función `__getattr__()` implementada.

  El mecanismo por defecto de `dir()` se comporta de forma distinta con diferentes tipos de objeto, ya que intenta producir la información más relevante en vez de la más completa:

  - Si el objeto es un módulo, la lista contiene los nombres de los atributos del módulo.

  - Si el objeto es un tipo o una clase, la lista contiene los nombres de sus atributos, y recursivamente la de los atributos de sus clases base.

  - En cualquier otro caso, la lista contiene los nombres de los atributos del objeto, los nombres de los atributos de su clase, y recursivamente los atributos de sus clases base.

  La lista resultante está ordenada alfabéticamente. Por ejemplo:

      >>> import struct
      >>> dir()   # show the names in the module namespace
      ['__builtins__', '__name__', 'struct']
      >>> dir(struct)   # show the names in the struct module
      ['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
       '__initializing__', '__loader__', '__name__', '__package__',
       '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
       'unpack', 'unpack_from']
      >>> class Shape:
      ...     def __dir__(self):
      ...         return ['area', 'perimeter', 'location']
      >>> s = Shape()
      >>> dir(s)
      ['area', 'location', 'perimeter']

  Nota

  Ya que `dir()` se ofrece como una herramienta para uso en una terminal de forma interactiva, intenta ofrecer un grupo interesante de nombres más que un uno rigurosamente definido, y su comportamiento detallado puede cambiar entre versiones. Por ejemplo, los atributos de metaclase no están en la lista resultante cuando el argumento es una clase.

`divmod`(a, b)

  Toma dos números (no complejos) como argumentos y retorna un par de números consistentes en su cociente y su resto al emplear división de enteros. Con operandos de tipos diferentes, se aplican las reglas de los operadores aritméticos binarios. Para enteros, el resultado es el mismo que `(a // b, a % b)`. Para números de punto flotante el resultado es `(q, a % b)`, donde q normalmente es `math.floor(a / b)` pero puede ser 1 menos que eso. En cualquier caso `q * b + a % b` es muy cercano a a, si `a % b` es distinto de cero y tiene el mismo signo que b, y `0 <= abs(a % b) < abs(b)`.

`enumerate`(iterable, start=0)

  Retorna un objeto enumerador. iterable tiene que ser una secuencia, un iterator, o algún otro objeto que soporte la iteración. El método `__next__()` del iterador retornado por la función `enumerate()` retorna una tupla que contiene un contador (desde start, cuyo valor por defecto es 0) y los valores obtenidos al iterar sobre iterable.

      >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
      >>> list(enumerate(seasons))
      [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
      >>> list(enumerate(seasons, start=1))
      [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

  Equivalente a:

      def enumerate(sequence, start=0):
          n = start
          for elem in sequence:
              yield n, elem
              n += 1

`eval`(expression[, globals[, locals]])

  Los argumentos son una cadena y opcionalmente, globales y locales. Si se introduce, globals tiene que ser un diccionario, y locals puede ser cualquier objeto de mapeo.

  El argumento expression se parsea y evalúa como una expresión de Python (técnicamente, una lista de condiciones), usando los diccionarios globals y locals como espacios de nombres globales y locales. Si el diccionario globals está presente y no contiene un valor para la clave `__builtins__`, se inserta bajo esa clave una referencia al diccionario del módulo incorporado `builtins` antes de que la expression sea parseada. Esto significa que en condiciones normales expression tiene acceso total al módulo estándar `builtins` y los entornos restringidos son propagados. Si el diccionario locals es omitido entonces su valor por defecto es el diccionario globals. Si ambos diccionarios son omitidos, la expresión es ejecutada con las globals y locals del entorno en el que `eval()` es llamada. Tenga en cuenta que eval() no tiene acceso al alcances anidados (no-locales) en el entorno que lo contiene.

  El valor que retorna es el resultado de la expresión evaluada. Los errores de sintaxis son reportados como excepciones. Por ejemplo:

      >>> x = 1
      >>> eval('x+1')
      2

  La función también puede ser utilizada para ejecutar objetos código arbitrario (como los que crea la función `compile()`). En este caso, se pasa un objeto código en vez de una cadena. Si el objeto código ha sido compilado usando `'exec'` como el argumento mode, el valor que retornará `eval()`será `None`.

  Pista: la ejecución dinámica de declaraciones está soportada por la función `exec()`. Las funciones `globals()` y `locals()` retornan los diccionarios global y local en ese momento, lo cual puede ser útil para su uso en `eval()` o `exec()`.

  Véase `ast.literal_eval()`, una función que puede evaluar de forma segura cadenas con expresiones que contienen solo literales.

  Lanza un evento de auditoría `exec` con un argumento `code_object`.

`exec`(object[, globals[, locals]])

  This function supports dynamic execution of Python code. object must be either a string or a code object. If it is a string, the string is parsed as a suite of Python statements which is then executed (unless a syntax error occurs). 1 If it is a code object, it is simply executed. In all cases, the code that’s executed is expected to be valid as file input (see the section «File input» in the Reference Manual). Be aware that the `nonlocal`, `yield`, and `return` statements may not be used outside of function definitions even within the context of code passed to the `exec()` function. The return value is `None`.

  En todos los casos, si las partes opcionales son omitidas, el código es ejecutado en el ámbito actual. Si solo se indica globals, debe ser un diccionario (y no una subclase de diccionario), que será usada tanto para las variables locales como las globales. Si se indican tanto globals como locals, son usadas para las variables globales y locales respectivamente. Si se indican, locals puede ser cualquier objeto de mapeo. Recuerda que a nivel de módulo, globals y locals son el mismo diccionario. Si exec recibe dos objetos separados como globals y locals, el código será ejecutado como si estuviera incorporado en una definición de clase.

  Si el diccionario globals no contiene un valor para la clave `__builtins__`, una referencia al diccionario del módulo built-in `builtins` se inserta bajo esa clave. De esta forma puedes controlar que builtins están disponibles para el código ejecutado insertando tu propio diccionario `__builtins__` en globals antes de pasárselo a `exec()`.

  Lanza un evento de auditoría `exec` con un argumento `code_object`.

  Nota

  Las funciones built-in `globals()` y `locals()` Retornan el diccionario local y global actual, respectivamente, lo que puede ser útil para pasarlo y emplearlo como el segundo y el tercer argumento de `exec()`.

  Nota

  El locals por defecto actúa de la forma descrita para la función `locals()` más abajo: no se deben intentar modificaciones sobre el diccionario locals por defecto. Pasa un diccionario explícito locals si necesitas ver los efectos del código en locals después de que la función `exec()` retorne.

`filter`(function, iterable)

  Construye un iterador a partir de aquellos elementos de iterable para los cuales function retorna true. iterable puede ser una secuencia, un contenedor que soporta iteración, o un iterador. Si function es `None`, se asume la función identidad, es decir, todos los elementos de iterable que son false son eliminados.

  Ten en cuenta que `filter(function, iterable)` es equivalente a la expresión de un generador `(item for item in iterable if function(item))` si function no es `None` y a `(item for item in iterable if item)` si function es `None`.

  Ver `itertools.filterfalse()` para la función complementaria que retorna los elementos de iterable para los cuales function retorna false.

class `float`([x])

  Retorna un número de punto flotante construido a partir de un número o una cadena x.

  Si el argumento es una cadena, debe contener un número decimal, opcionalmente precedido de un signo, y opcionalmente entre espacios en blanco. El signo opcional puede ser `’+’` o `’-‘`; un signo `’+’` no tiene efecto en el valor producido. El argumento puede ser también una cadena representando un NaN (no es un número), o un infinito positivo o negativo. Más concretamente, el argumento debe adecuarse a la siguiente gramática una vez eliminados de la cadena los caracteres en blanco por delante o detrás:

      sign           ::=  "+" | "-"
      infinity       ::=  "Infinity" | "inf"
      nan            ::=  "nan"
      numeric_value  ::=  floatnumber | infinity | nan
      numeric_string ::=  [sign] numeric_value

  Aquí `floatnumber` es el formato de un literal de punto flotante de Python, tal y como está descrito en Literales de punto flotante. No es relevante si los caracteres son mayúsculas o minúsculas, de forma que «inf», «Inf», «INFINITY» e «iNfINity» son todas formas aceptables de escribir el infinito positivo.

  Sino, en caso de que el argumento sea un entero o un decimal de punto flotante, se retorna un número de punto flotante del mismo valor (dentro de la precisión de punto flotante de Python). Si el argumento está fuera del rango de un punto flotante de Python, se generará una excepción `OverflowError`.

  Para el objeto general de Python `x`, `float(x)` delega a `x.__float__()`. Si `__float__()` no está definido entonces recurre a `__index__()`.

  Si no se le da un argumento, retorna `0.0`.

  Ejemplos:

      >>> float('+1.23')
      1.23
      >>> float('   -12345\n')
      -12345.0
      >>> float('1e-003')
      0.001
      >>> float('+1E6')
      1000000.0
      >>> float('-Infinity')
      -inf

  El tipo float está descrito en Tipos numéricos — int, float, complex.

  Distinto en la versión 3.6: Agrupar dígitos con guiones bajos como en los literales de código está permitido.

  Distinto en la versión 3.7: x es ahora un argumento solo de posición.

  Distinto en la versión 3.8: Recurre a `__index__()` si `__float__()` no está definido.

`format`(value[, format_spec])

  Convierte value a su representación «con formato», de forma controlada por format_spec. La interpretación de format_spec dependerá del tipo del argumento value. Sin embargo, hay una sintaxis estándar de formato que emplean la mayoría de los tipos built-in: Especificación de formato Mini-Lenguaje.

  El format_spec por defecto es una cadena vacía que normalmente produce el mismo efecto que llamar a `str(value)`.

  Una llamada a `format(value, format_spec)` se traduce a `type(value).__format__(value, format_spec)` , que sortea el diccionario de la instancia cuando busca por el método `__format__()` del valor. Una excepción `TypeError` será lanzada si la búsqueda del método llega a `object` y format_spec no está vacío, o si format_spec o el valor de retorno no son cadenas.

  Distinto en la versión 3.4: `object().__format__(format_spec)` lanza `TypeError` si format_spec no es una cadena vacía.

class `frozenset`([iterable])

  Retorna un nuevo objeto `frozenset` , opcionalmente con elementos tomados de iterable. `frozenset` es una clase built-in. Ver `frozenset` y Conjuntos — set, frozenset para documentación sobre esta clase.

  Para otro tipo de contenedores, ver las clases built-in `set`, `list`, `tuple`, y `dict`, así como el módulo `collections`.

`getattr`(object, name[, default])

  Retorna el valor del atributo nombrado de object. name debe ser una cadena. Si la cadena es el nombre de uno de los atributos del objeto, el resultado es el valor de ese atributo. Por ejemplo, `getattr(x, ‘foobar’)` es equivalente a `x.foobar`. Si el atributo nombrado no existe, se retorna default si ha sido proporcionado como argumento, y sino se lanza una excepción `AttributeError`.

`globals`()

  Retorna un diccionario que representa la tabla global de símbolos. Es siempre el diccionario del módulo actual (dentro de una función o método, este es el módulo donde está definida, no el módulo desde el que es llamada).

`hasattr`(object, name)

  Los argumentos son un objeto y una cadena. El resultado es `True` si la cadena es el nombre de uno de los atributos del objeto, y `False` en caso contrario. (Está implementado mediante una llamada a `getattr(object, name)` que comprueba si se lanza una excepción `AttributeError` o no).

`hash`(object)

  Retorna el valor hash del objeto (si tiene uno). Los valores hash son enteros. Se usan para comparar de forma rápida claves de diccionarios durante las operaciones de búsqueda. Valores numéricos que son iguales tienen el mismo valor hash (incluso si son de tipos diferentes, como es el caso para 1 y 1.0).

  Nota

  Para objetos que implementan métodos `__hash__()`, ten en cuenta que `hash()` trunca el valor de retorno en base a la tasa de bits de la máquina host. Ver `__hash__()` para más detalles.

`help`([object])

  Invoca el sistema de ayuda integrado (built-in). (Esta función está indicada para su uso interactivo). Si no se le da argumento, el sistema interactivo de ayuda se inicia en la consola del intérprete. Si el argumento es una cadena, entonces es buscada como nombre de un módulo, función, clase, método, palabra clave o tema de documentación, y una página de ayuda es impresa en la consola. Si el argumento es cualquier otro tipo de objeto, una página de ayuda sobre el objeto es generada.

  Ten en cuenta que si una barra(/) aparece en la lista de parámetros de una función, al invocar `help()` significa que los parámetros anteriores a la barra son solo posicionales. Para más información, puedes ver the FAQ entry on positional-only parameters.

  Esta función se añade al espacio de nombres built-in a través del módulo `site`.

  Distinto en la versión 3.4: Cambios a los módulos `pydoc` y `inspect` implican que las signaturas reportadas para objetos invocables son más completas y consistentes.

`hex`(x)

  Convierte un número entero a una cadena hexadecimal de minúsculas con el prefijo «0x». Si x no es un objeto de la clase Python `int`, tiene que definir un método `__index__()` que retorne un entero. Algunos ejemplos:

      >>> hex(255)
      '0xff'
      >>> hex(-42)
      '-0x2a'

  Si quieres convertir un número entero a una cadena hexadecimal de mayúsculas o minúsculas con prefijo o sin el, puedes usar cualquiera de las siguientes formas:

      >>> '%#x' % 255, '%x' % 255, '%X' % 255
      ('0xff', 'ff', 'FF')
      >>> format(255, '#x'), format(255, 'x'), format(255, 'X')
      ('0xff', 'ff', 'FF')
      >>> f'{255:#x}', f'{255:x}', f'{255:X}'
      ('0xff', 'ff', 'FF')

  Véase también `format()` para más información.

  Ver también `int()` para convertir una cadena hexadecimal a un entero usando una base de 16.

  Nota

  Para obtener una cadena hexadecimal que represente un punto flotante, utiliza el método `float.hex()`.

`id`(object)

  Retorna la «identidad» de un objeto. Esto es un entero que está garantizado que es único y constante para este objeto durante toda su existencia. Dos objetos con existencias en el tiempo que no coincidan pueden tener el mismo valor de `id()`.

  CPython implementation detail: This is the address of the object in memory.

  Raises an auditing event `builtins.id` with argument `id`.

`input`([prompt])

  Si el argumento prompt está presente, se escribe a la salida estándar sin una nueva línea a continuación. La función lee entonces una línea de la entrada, la convierte en una cadena (eliminando la nueva línea), y retorna eso. Cuando se lee EOF, se lanza una excepción `EOFError`. Ejemplo:

      >>> s = input('--> ')
      --> Monty Python's Flying Circus
      >>> s
      "Monty Python's Flying Circus"

  Si el módulo `readline` estaba cargado, entonces `input()` lo usará para proporcionar características más elaboradas de edición de líneas e historiales.

  Lanza un evento de auditoría `builtins.input` con el argumento `prompt` antes de leer entrada

  Lanza un evento de auditoría `builtins.input/result` con el resultado justo después de haber leído con éxito la entrada.

class `int`([x])
class `int`(x, base=10)

  Retorna un objeto entero construido desde un número o cadena x, o retorna `0` si no se le proporcionan argumentos. Si x define `__int__()`, `int(x)` retorna `x.__int__()`. Si x define `__index__()`, retorna `x.__index__()`. Si x define `__trunc__()`, retorna `x.__trunc__()`. Para números de punto flotante, los valores serán truncados hacia cero.

  Si x no es un número o si se indica base, entonces x debe ser una cadena, una instancia de `bytes`, o una de `bytearray` que representa un integer literal de base base. Opcionalmente, el literal puede ser precedido de `+` or `-` (sin espacios entre el número y el signo) y rodeados por espacio en blanco. Un literal de base-n consiste en los dígitos de 0 a n-1, con valores entre 10 y 35 para los caracteres de `a` a `z` (o de `A` a `Z`). La base por defecto es 10. Los valores permitidos son 0 y 2–36. Los literales de base-2, -8 y -16 pueden incluir opcionalmente un prefijo `0b`/`0B`, `0o`/`0O`, o `0x`/`0X`, de igual forma que los literales enteros en el código. Base-0 indica que se debe interpretar exactamente como un literal de código, de forma que la base real es 2, 8, 10 o 16, y que `int('010', 0)` no sea legal, mientras que `int('010')` sí lo es, así como `int('010', 8)`.

  El tipo entero se describe en Tipos numéricos — int, float, complex.

  Distinto en la versión 3.4: Si base no es una instancia de `int` y el objeto base tiene un método `base.__index__`, ese método es llamado para obtener un entero para esa base. En versiones anteriores se empleaba `base.__int__` en vez de `base.__index__`.

  Distinto en la versión 3.6: Agrupar dígitos con guiones bajos como en los literales de código está permitido.

  Distinto en la versión 3.7: x es ahora un argumento solo de posición.

  Distinto en la versión 3.8: Recurre a `__index__()` si no está definido `__int__()`.

  Distinto en la versión 3.8.14: `int` string inputs and string representations can be limited to help avoid denial of service attacks. A `ValueError` is raised when the limit is exceeded while converting a string x to an `int` or when converting an `int` into a string would exceed the limit. See the integer string conversion length limitation documentation.

`isinstance`(object, classinfo)

  Retorna `True` si el argumento object es una instancia del argumento classinfo, o de una subclase (directa, indirecta o virtual) del mismo. Si object no es un objeto del tipo indicado, esta función siempre retorna `False`. Si classinfo es una tupla de objetos de tipo (o recursivamente, otras tuplas lo son), retorna `True` si object es una instancia de alguno de los tipos. Si classinfo no es un tipo, una tupla de tipos, ó una tupla de tuplas de tipos, una excepción `TypeError` es lanzada.

`issubclass`(class, classinfo)

  Retorna `True` si class es una subclase (directa, indirecta o virtual) de classinfo. Una clase es considerada una subclase de sí misma. classinfo puede ser una tupla de objetos de clase, en cuyo caso cada elemento en classinfo será comprobado. En cualquier otro caso, se lanzará una excepción `TypeError`.

`iter`(object[, sentinel])

  Retorna un objeto iterator. El primer argumento se interpreta de forma muy diferente en función de la presencia del segundo. Sin un segundo argumento, object debe ser un objeto collection que soporte el protocolo de iteración (el método `__iter__()`), o debe soportar el protocolo de secuencia (el método `__getitem__()` con argumentos enteros comenzando en `0`). Si no soporta ninguno de esos protocolos, se lanza una excepción `TypeError`. Si el segundo argumento, sentinel, es indicado, entonces object debe ser un objeto invocable. El iterador creado en ese caso llamará a object sin argumentos para cada invocación a su método `__next__()` ; si el valor retornado es igual a sentinel, una `StopIteration` será lanzada, de lo contrario el valor será retornado.

  Ver también Tipos de iteradores.

  Una aplicación muy útil de la segunda forma de `iter()` es la construcción de un lector de bloques. Por ejemplo, leer bloques de ancho fijo de una base de datos binaria hasta que el fin del fichero sea alcanzado:

      from functools import partial
      with open('mydata.db', 'rb') as f:
          for block in iter(partial(f.read, 64), b''):
              process_block(block)

`len`(s)

  Retorna el tamaño (el número de elementos) de un objeto. El argumento puede ser una secuencia (como una cadena, un objeto byte, una tupla, lista o rango) o una colección (como un diccionario, un set o un frozen set).

class `list`([iterable])

  Más que una función, `list` es realmente un tipo de secuencia mutable, como está documentado en Listas y Tipos secuencia — list, tuple, range.

`locals`()

  Actualiza y retorna un diccionario representando la tabla de símbolos locales actual. Las variables libres son retornadas por `locals()` cuando ésta es llamada en bloques de funciones, pero no en bloques de clases. Nótese que a nivel de módulo, `locals()` y `globals()` son el mismo diccionario.

  Nota

  Los contenidos de este diccionario no deben ser modificados; sus cambios no afectarán los valores de las variables locales y libres utilizadas por el intérprete.

`map`(function, iterable, ...)

  Retorna un iterador que aplica function a cada elemento de iterable, retornando el resultado. Si se le pasan argumentos adicionales de tipo iterable, function debe tomar la misma cantidad de argumentos y es aplicado a los elementos de todos ellos en paralelo. Con iterables múltiples, el iterador se detiene cuando el iterable más corto se agota. Para casos donde las entradas de la función ya están organizadas como tuplas de argumentos, ver `itertools.starmap()`.

`max`(iterable, *[, key, default])
`max`(arg1, arg2, *args[, key])

  Retorna el elemento mayor en un iterable o el mayor de dos o más argumentos.

  Si un argumento posicional es dado, debe ser un iterable. El elemento mayor en el iterable es retornado. Si dos o más argumentos posicionales son indicados, el mayor de los argumentos posicionales será retornado.

  Hay dos argumentos de solo palabra clave que son opcionales. El argumento key especifica una función de ordenación de un sólo argumento, como la usada para `list.sort()`. El argumento default especifica un objeto a retornar si el iterable proporcionado está vacío. Si el iterable está vacío y default no ha sido indicado, se lanza un `ValueError`.

  Si hay múltiples elementos con el valor máximo, la función retorna el primero que ha encontrado. Esto es consistente con otras herramientas para preservar la estabilidad de la ordenación como `sorted(iterable, key=keyfunc, reverse=True)[0]` y `heapq.nlargest(1, iterable, key=keyfunc)`.

  Nuevo en la versión 3.4: El argumento default sólo por palabra clave.

  Distinto en la versión 3.8: key puede ser `None`.

class `memoryview`(obj)

  Retorna un objeto «memory view» creado a partir del argumento indicado. Para más información ver Vistas de memoria.

`min`(iterable, *[, key, default])
`min`(arg1, arg2, *args[, key])

  Retorna el menor elemento en un iterable o el menor de dos o más argumentos.

  Si se le indica un argumento posicional, debe ser un iterable. El menor elemento del iterable es retornado. Si dos o más argumentos posicionales son indicados, el menor de los argumentos posicionales es retornado.

  Hay dos argumentos de solo palabra clave que son opcionales. El argumento key especifica una función de ordenación de un sólo argumento, como la usada para `list.sort()`. El argumento default especifica un objeto a retornar si el iterable proporcionado está vacío. Si el iterable está vacío y default no ha sido indicado, se lanza un `ValueError`.

  Si hay múltiples elementos con el valor mínimo, la función retorna el primero que encuentra. Esto es consistente con otras herramientas que preservan la estabilidad de la ordenación como `sorted(iterable, key=keyfunc)[0]` y `heapq.nsmallest(1, iterable, key=keyfunc)`.

  Nuevo en la versión 3.4: El argumento default sólo por palabra clave.

  Distinto en la versión 3.8: key puede ser `None`.

`next`(iterator[, default])

  Extrae el siguiente elemento de iterator llamando a su método `__next__()`. Si se le indica default, éste será retornado si se agota el iterador, de lo contrario, se lanza un `StopIteration`.

class `object`

  Retorna un nuevo objeto indiferenciado. `object` es la base de todas las clases. Tiene todos los métodos que son comunes a todas las instancias de clases de Python. Esta función no acepta ningún argumento.

  Nota

  `object` no tiene un `__dict__`, así que no puedes asignar atributos arbitrarios a una instancia de la clase `object`.

`oct`(x)

  Convierte un número entero a una cadena octal con prefijo «0o». El resultado es una expresión válida de Python. Si x no es un objeto de la clase Python `int`, tiene que tener definido un método `__index__()` que retorne un entero. Por ejemplo:

      >>> oct(8)
      '0o10'
      >>> oct(-56)
      '-0o70'

  Si quieres convertir un número entero a una cadena octal, tanto con prefijo «0o» como sin el, puedes usar cualquiera de las siguientes formas.

      >>> '%#o' % 10, '%o' % 10
      ('0o12', '12')
      >>> format(10, '#o'), format(10, 'o')
      ('0o12', '12')
      >>> f'{10:#o}', f'{10:o}'
      ('0o12', '12')

  Véase también `format()` para más información.

`open`(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

  Open file and return a corresponding file object. If the file cannot be opened, an `OSError` is raised. See Leyendo y escribiendo archivos for more examples of how to use this function.

  file es un path-like object que da la ruta (absoluta o relativa al directorio de trabajo actual) del fichero a ser abierto o un descriptor de fichero entero del fichero a ser envuelto. (Si un descriptor de fichero es dado, será cerrado cuando el objeto de entrada-salida sea cerrado, a menos que closefd esté puesto a `False`.)

  mode es una cadena opcional que especifica el modo en el cual el fichero es abierto. Su valor por defecto es `'r'` que significa que está abierto para lectura en modo texto. Otros valores comunes son `’w’` para escritura (truncando el fichero si ya existe), `’x’` para creación en exclusiva y `’a’` para añadir (lo que en algunos sistemas Unix implica que toda la escritura añade al final del fichero independientemente de la posición de búsqueda actual). En modo texto, si no se especifica encoding entonces la codificación empleada es dependiente de plataforma: se invoca a `locale.getpreferredencoding(False)` para obtener la codificación regional actual. (Para lectura y escritura de bytes en crudo usa el modo binario y deja encoding sin especificar). Los modos disponibles son:

  Carácter | Significado
  --- | ---
  `’r’` | abierto para lectura (por defecto)
  `'w'` | abierto para escritura, truncando primero el fichero
  `'x'` | abierto para creación en exclusiva, falla si el fichero ya existe
  `’a’` | abierto para escritura, añadiendo al final del fichero si este existe
  `'b'` | modo binario
  `’t’` | modo texto (por defecto)
  `’+’` | abierto para actualizar (lectura y escritura)

  El modo por defecto es `’r’` (abierto para lectura de texto, sinónimo de `’rt’`. Los modos `’w+’` y `’w+b’` abren y truncan el fichero. Los modos `’r+’` y `’r+b’` abren el fichero sin truncarlo.

  Como se menciona en Resumen, Python distingue entre I/O binario y de texto. Los ficheros abiertos en modo binario (incluyendo `’b’` en el argumento mode) retornan su contenido como objetos de `bytes` sin ninguna descodificación. En modo de texto (por defecto, o cuando se incluye `’t’` en el argumento mode), los contenidos del fichero se retornan como `str`, tras descodificar los bytes usando una codificación dependiente de plataforma o usando el encoding especificado como argumento.

  Hay un carácter adicional permitido para indicar un modo, `’U’`, que ya no tiene ningún efecto y que se considera obsoleto. Permitía anteriormente en modo texto universal newlines, lo que se convirtió en el comportamiento por defecto en Python 3.0. Para más detalles, referirse a la documentación del parámetro newline.

  Nota

  Python no depende de la noción de ficheros de texto del sistema operativo subyacente; todo el procesado lo hace Python, y es por tanto independiente de plataforma.

  buffering es un entero opcional que configura la política de buffering. Indica 0 para desactivar el buffering (sólo permitido en modo binario), 1 para seleccionar buffering por línea (sólo para modo texto), y un entero >1 para indicar el tamaño en bytes de un buffer de tamaño fijo. Cuando no se indica el argumento buffering, la norma por defecto de buffering funciona de la siguiente manera:

  - Los ficheros binarios son transmitidos por búferes con tamaños fijos de bloque; el tamaño del búfer es escogido usando un intento heurístico para determinar el tamaño de bloque del dispositivo y recurriendo sino a `io.DEFAULT_BUFFER_SIZE`. En muchos sistemas, el búfer tendrá normalmente un tamaño de 4096 o 8192 bytes.

  - Los ficheros de texto «interactivos» (ficheros para los cuales `isatty()` retorna `True`) usan buffering por líneas. Otros ficheros de texto emplean la norma descrita anteriormente para ficheros binarios.

  encoding es el nombre de la codificación empleada con el fichero. Esto solo debe ser usado en el modo texto. La codificación por defecto es dependiente de plataforma (aquello que retorna `locale.getpreferredencoding()`), pero puede emplearse cualquier text encoding soportado por Python. Véase el módulo `codecs` para la lista de codificaciones soportadas.

  errors es una cadena opcional que especifica como deben manejarse los errores de codificación y descodificación – esto no puede ser usado en modo binario. Están disponibles varios gestores de error (listados en Manejadores de errores), pero también es válido cualquier nombre de gestión de error registrado con `codecs.register_error()`. Los nombres estándar incluyen:

  - `'strict'` para lanzar una excepción `ValueError` si hay un error de codificación. El valor por defecto, `None`, produce el mismo efecto.

  - `'ignore'` ignora los errores. Nótese que ignorar errores de codificación puede conllevar la pérdida de datos.

  - `'replace'` provoca que se inserte un marcador de reemplazo (como `'?'`) en aquellos sitios donde hay datos malformados.

  - `'surrogateescape'` representa bytes incorrectos como puntos código del Unicode Private Use Area que van desde U+DC80 a U+DCFF. Estos puntos código privados volverán a convertirse en los mismos bytes cuando el gestor de errores `surrogateescape` sea usando al escribir datos. Esto es útil para el procesado de ficheros con una codificación desconocida.

  - `'xmlcharrefreplace'` está soportado solamente cuando se escribe a un fichero. Los caracteres que no estén soportados por la codificación son reemplazados por la referencia al carácter XML apropiado `&#nnn;`.

  - `'backslashreplace'` reemplaza datos malformados con las secuencias de escapes de barra invertida de Python.

  - `'namereplace'` reemplaza caracteres no soportados con secuencias de escape `\N{...}` (y también está sólo soportado en escritura).

  newline controla cómo funciona el modo universal newlines (solo aplica a modo texto). Puede ser `None`, `''`, `'\n'`, `'\r'`, y `'\r\n'`. Funciona de la siguiente manera:

  - Cuando se está leyendo entrada desde el flujo, si newline es `None`, el modo universal newlines es activado. Las líneas en la entrada pueden terminar en `'\n'`, `'\r'`, o `'\r\n'`, y serán traducidas a `'\n'` antes de ser retornadas a la entidad que llama. Si es `''`, el modo universal newlines estará activado pero los finales de línea se retornan sin traducir a la entidad que llama. Si tiene cualquiera de los otros valoras válidos, las líneas de entrada estarán terminadas sólo por la cadena dada, y los finales de línea serán retornados sin traducir a la entidad que llama.

  - Cuando se escribe salida al flujo, si newline es `None`, cualquier carácter `'\n'` escrito es traducido al separador de línea por defecto en el sistema, `os.linesep`. Si newline es `''` o `'\n'`, entonces no se produce ninguna traducción. Si newline toma cualquiera de los otros valores válidos, entonces cualquier carácter `'\n'` escrito es traducido a la cadena indicada.

  Si closefd es `False` y se indica un descriptor de fichero en vez de un nombre de fichero, el descriptor se mantendrá abierto cuando se cierre el fichero. Si se indica un nombre de fichero, closefd debe ser `True` (lo es por defecto), ya que de otra forma se lanzará un error.

  Un abridor personalizado puede emplearse pasando un invocable como opener. El descriptor de fichero del objeto se obtiene llamando a opener con (file, flags). opener debe retornar un descriptor de fichero abierto (pasando `os.open` como opener resulta en una funcionalidad similar a `None`).

  El nuevo fichero creado es no-heredable.

  El siguiente ejemplo emplea el parámetro dir_fd de la función `os.open()` para abrir un fichero relativo a un directorio dado:

      >>> import os
      >>> dir_fd = os.open('somedir', os.O_RDONLY)
      >>> def opener(path, flags):
      ...     return os.open(path, flags, dir_fd=dir_fd)
      ...
      >>> with open('spamspam.txt', 'w', opener=opener) as f:
      ...     print('This will be written to somedir/spamspam.txt', file=f)
      ...
      >>> os.close(dir_fd)  # don't leak a file descriptor

  El tipo de file object retornado por la función `open()` depende del modo. Cuando se emplea `open()` para abrir un fichero en modo texto (`'w'`, `'r'`, `'wt'`, `'rt'`, etc.), retorna una subclase de `io.TextIOBase` (específicamente `io.TextIOWrapper`). Cuando se emplea para abrir un fichero en modo binario con buffering, la clase retornada es una subclase de `io.BufferedIOBase`. La clase exacta varía: en modo binario de lectura, retorna `io.BufferedReader`; en modo de escritura y adición en binario, retorna `io.BufferedWriter`, y en modo de escritura/lectura, retorna `io.BufferedRandom`. Si el buffering está desactivado, el flujo en crudo, una subclase de `io.RawIOBase`, `io.FileIO`, es retornada.

  Véase también los módulos para manejo de ficheros, como `fileinput`, `io` (donde es declarada `open()`), `os`, `os.path`, `tempfile`, y `shutil`.

  Lanza un evento de auditoría `open` con los argumentos `file`, `mode`, `flags`.

  Los argumentos `mode` y `flags` pueden haber sido modificados o inferidos de la llamada original.

  > Distinto en la versión 3.3:

  > - El parámetro opener fue añadido.

  > - El modo `'x'` fue añadido.

  > - `IOError` era la excepción lanzada anteriormente, ahora es un alias de `OSError`.

  > - Se lanza `FileExistsError` si ya existe el fichero abierto en modo de creación exclusiva (`'x'`).

  > Distinto en la versión 3.4:

  > - El fichero ahora es no-heredable.

  Deprecated since version 3.4, will be removed in version 3.9: El modo `'U'`.

  > Distinto en la versión 3.5:

  > - Si la llamada al sistema es interrumpida y el gestor de señales no lanza una excepción, ahora la función reintenta la llamada de sistema en vez de lanzar una excepción `InterruptedError` (véase PEP 475 para la justificación).

  > - El gestor de errores `'namereplace'` fue añadido.

  > Distinto en la versión 3.6:

  > - Añadido el soporte para aceptar objetos que implementan `os.PathLike`.

  > - En Windows, abrir un búfer en la consola puede retornar una subclase de `io.RawIOBase` en vez de `io.FileIO`.

`ord`(c)

  Al proporcionarle una cadena representando un carácter Unicode, retorna un entero que representa el código Unicode de ese carácter. Por ejemplo, `ord('a')` retorna el entero `97` y `ord('€')` (símbolo del Euro) retorna `8364`. Esta es la función inversa de `chr()`.

`pow`(base, exp[, mod])

  Retorna base elevado a exp; si mod está presente, retorna base elevado a exp, módulo mod (calculado de manera más eficiente que `pow(base, exp) % mod`). La forma con dos argumentos `pow(base, exp)` es equivalente a usar el operador potencia: `base**exp`.

  Los argumentos deben ser de tipo numérico. Si hay tipos mixtos de operandos, las reglas de coerción para operadores binarios aritméticos aplican. Para operandos de la clase `int`, el resultado tiene el mismo tipo que los operandos (después de la coerción) a menos que el segundo argumento sea negativo; en tal caso, todos los argumentos son convertidos a punto flotante y un resultado de punto flotante es retornado. Por ejemplo, `10**2` retorna `100`, pero `10**-2` retorna `0.01`.

  Para operandos `int` como base y exp, si mod está presente, mod debe ser también de tipo entero y distinto de cero. Si mod está presente y exp es negativo, base debe ser un número primo relativo a mod. En ese caso, se retorna `pow(inv_base, -exp, mod)`, dónde inv_base es la inversa al módulo mod de base.

  Aquí tienes un ejemplo de cómo calcular la inversa de `38` módulo `97`:

      >>> pow(38, -1, mod=97)
      23
      >>> 23 * 38 % 97 == 1
      True

  Distinto en la versión 3.8: Para operandos `int`, la forma de `pow` con tres argumentos acepta ahora que el segundo argumento sea negativo, lo que permite el cálculo de inversos modulares.

  Distinto en la versión 3.8: Permite argumentos de palabra clave. Anteriormente, solo se soportaba el uso de argumentos posicionales.

`print`(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

  Imprime objects al flujo de texto file, separándolos por sep y seguidos por end. sep, end, file y flush, si están presentes, deben ser dados como argumentos por palabra clave.

  Todos los argumentos que no son por palabra clave se convierten a cadenas tal y como `str()` hace y se escriben al flujo, separados por sep y seguidos por end. Tanto sep como end deben ser cadenas; también pueden ser `None`, lo cual significa que se empleen los valores por defecto. Si no se indica objects, `print()` escribirá end.

  El argumento file debe ser un objeto que implemente un método `write(string)`; si éste no está presente o es `None`, se usará `sys.stdout`. Dado que los argumentos mostrados son convertidos a cadenas de texto, `print()` no puede ser utilizada con objetos fichero en modo binario. Para esos, utiliza en cambio `file.write(…)`.

  Que la salida sea en búfer o no suele estar determinado por file, pero si el argumento por palabra clave flush se emplea, el flujo se descarga forzosamente.

  Distinto en la versión 3.3: Añadido el argumento por palabra clave flush.

class `property`(fget=None, fset=None, fdel=None, doc=None)

  Retorna un atributo propiedad.

  fget es una función para obtener el valor de un atributo. fset es una función para asignar el valor de un atributo. fdel es una función para eliminar el valor de un atributo. Y doc crea un docstring para el atributo.

  Un caso de uso típico es la definición de un atributo gestionado `x`:

      class C:
          def __init__(self):
              self._x = None

          def getx(self):
              return self._x

          def setx(self, value):
              self._x = value

          def delx(self):
              del self._x

          x = property(getx, setx, delx, "I'm the 'x' property.")

  Si c es una instancia de C, `c.x` invocará el obtenedor (getter), `c.x = value` invocará el asignador (setter) y `del c.x` el suprimidor (deleter).

  Si está indicada, doc será la docstring del atributo propiedad. En caso contrario, la propiedad copiará la dosctring de fget si ésta existe. Esto permite crear propiedades de sólo lectura de forma fácil empleando `property()` como decorator:

      class Parrot:
          def __init__(self):
              self._voltage = 100000

          @property
          def voltage(self):
              """Get the current voltage."""
              return self._voltage

  El decorador `@property` convierte el método `voltage()` en un «getter» para un atributo de sólo lectura con el mismo nombre, y asigna «Get the current voltage.» como la docstring de voltage.

  Un objeto propiedad tiene métodos `getter`, `setter`, y `deleter` que pueden usarse como decoradores que crean una copia de la propiedad con su correspondiente función de acceso asignada a la función decorada. Esto se explica mejor con un ejemplo:

      class C:
          def __init__(self):
              self._x = None

          @property
          def x(self):
              """I'm the 'x' property."""
              return self._x

          @x.setter
          def x(self, value):
              self._x = value

          @x.deleter
          def x(self):
              del self._x

  Este código equivale exactamente al primer ejemplo. Asegúrese de otorgarle a las funciones adicionales el mismo nombre que la propiedad original (`x` en este caso.)

  El objeto propiedad retornado tiene también los atributos `fget`, `fset`, y `fdel` correspondientes a los argumentos del constructor.

  Distinto en la versión 3.5: Las docstrings de los objetos propiedad son escribibles.

class `range`(stop)
class `range`(start, stop[, step])

  `range`, más que una función, es en realidad un tipo de secuencia inmutable, tal y como está documentado en Rangos y Tipos secuencia — list, tuple, range.

`repr`(object)

  Retorna una cadena que contiene una representación imprimible de un objeto. Para muchos tipos, esta función intenta retornar la cadena que retornaría el objeto con el mismo valor cuando es pasado a `eval()`, de lo contrario la representación es una cadena entre corchetes angulares («<>») que contiene el nombre del tipo del objeto junto con información adicional que incluye a menudo el nombre y la dirección del objeto. Una clase puede controlar lo que esta función retorna definiendo un método `__repr__()`.

`reversed`(seq)

  Retorna un iterator reverso. seq debe ser un objeto que tenga un método `__reversed__()` o que soporte el protocolo de secuencia (el método `__len__()` y el método `__getitem__()` con argumentos enteros comenzando en `0`).

`round`(number[, ndigits])

  Retorna number redondeado a ndigits de precisión después del punto decimal. Si ndigits es omitido o es `None`, retorna el entero más cercano a su entrada.

  Para los tipos integrados (built-in) que soportan `round()`, los valores son redondeados al múltiplo de 10 más cercano a la potencia menos ndigits; si dos múltiplos están igual de cerca, el redondeo se hace hacia la opción par (así que por ejemplo tanto `round(0.5)` como `round(-0.5)` son `0`, y `round(1.5)` es `2`).

  Para un objeto `number` general de Python, `round` delega a `number.__round__`.

  Nota

  El comportamiento de `round()` para flotantes puede ser sorprendente: por ejemplo, `round(2.675, 2)` da `2.67` en vez de los `2.68` esperados. Esto no es un error: es el resultado del hecho de que la mayoría de fracciones decimales no se puede representar de forma exacta como flotantes. Véase Aritmética de Punto Flotante: Problemas y Limitaciones para más información.

class `set`([iterable])

  Retorna un nuevo objeto `set` , opcionalmente con elementos tomados de iterable. `set` es una clase integrada (built-in). Véase `set` y Conjuntos — set, frozenset para documentación sobre esta clase.

  Para otros contenedores ver las clases integradas (built-in) `frozenset`, `list`, `tuple`, y `dict`, así como el módulo `collections`.

`setattr`(object, name, value)

  Es la función complementaria a `getattr()`. Los argumentos son un objeto, una cadena, y un valor arbitrario. La cadena puede nombrar un atributo existente o uno nuevo. La función asigna el valor al atributo si el objeto lo permite. Por ejemplo, `setattr(x, 'foobar', 123)` es equivalente a `x.foobar = 123`.

class `slice`(stop)
class `slice`(start, stop[, step])

  Retorna un objeto slice que representa el conjunto de índices especificados por `range(start, stop, step)`. Los argumentos start y step son por defecto `None`. Los objetos slice tienen atributos de sólo lectura `start`, `stop` y `step` que simplemente retornan los valores de los argumentos (o sus valores por defecto). Éstos no tienen otra funcionalidad explícita; sin embargo son usados por Numerical Python y otras extensiones de terceros. Estos objetos slices pueden ser generados también empleando la sintaxis extendida de indexación. Por ejemplo: `a[start:stop:step]` o `a[start:stop, i]`. Véase `itertools.islice()` para la versión alternativa que retorna un iterador.

`sorted`(iterable, *, key=None, reverse=False)

  Retorna una nueva lista ordenada a partir de los elementos en iterable.

  Tiene dos argumentos opcionales que deben ser especificados como argumentos de palabra clave.

  key especifica una función de un argumento que es empleada para extraer una clave de comparación de cada elemento en iterable (por ejemplo, `key=str.lower`). El valor por defecto es ``None` (compara los elementos directamente).

  reverse es un valor boleado. Si está puesto a `True`, entonces la lista de elementos se ordena como si cada comparación fuera reversa.

  Puedes usar `functools.cmp_to_key()` para convertir las funciones cmp a la antigua usanza en funciones key.

  La función built-in `sorted()` está garantizada en cuanto a su estabilidad. Un ordenamiento es estable si garantiza que no cambia el orden relativo de elementos que resultan igual en la comparación — esto es de gran ayuda para ordenar en múltiples pases (por ejemplo, ordenar por departamento, después por el escalafón de salario).

  Para ejemplos de ordenamiento y para un breve tutorial sobre ello, ver HOW TO - Ordenar.

`@``staticmethod`

  Transforma un método en un método estático.

  Un método estático no recibe un primer argumento implícito. Para declarar un método estático, utiliza esta expresión:

      class C:
          @staticmethod
          def f(arg1, arg2, ...): ...

  La forma `@staticmethod` es una función decorator — ver Definiciones de funciones para más detalles.

  Un método estático puede ser llamado sobre la clase (como `C.f()`) o sobre una instancia (como C().f()`).

  Los métodos estáticos en Python son similares a los que se encuentran en Java o C++. Ver también `classmethod()` para una variante que es útil para crear constructores de clase alternativos.

  Como todos los decoradores, es también posible llamar a `staticmethod` como una función normal y hacer algo con su resultado. Esto es necesario a veces cuando necesitas una referencia a una función desde el cuerpo de una clase y quieres evitar la transformación automática a un método de la instancia. Para dichos casos, emplea esta expresión:

      class C:
          builtin_open = staticmethod(open)

  Para más información sobre métodos estáticos, ver Jerarquía de tipos estándar.

class `str`(object='')
class `str`(object=b'', encoding='utf-8', errors='strict')

  Retorna una versión `str` del object. Ver `str()` para más detalles.

  `str` es la class cadena built-in . Para información general sobre strings, ver Cadenas de caracteres — str.

`sum`(iterable, /, start=0)

  Suma start y los elementos de un iterable de izquierda a derecha y Retorna el total. Los elementos del iterable son normalmente números, y el valor start no puede ser una cadena.

  Para algunos casos de uso, hay buenas alternativas a `sum()`. La manera preferente y más rápida de concatenar secuencias de cadenas es llamado a `’’.join(sequence)`. Para añadir valores de punto flotante con precisión extendida, ver `math.fsum()`. Para concatenar series de iterabais, considera usar `itertools.chain()`.

  Distinto en la versión 3.8: El parámetro start puede ser especificado como un argumento de palabra clave.

`super`([type[, object-or-type]])

  Retorna un objeto proxy que delega las llamadas de métodos a clases padre o hermanas de type. Esto es útil para acceder métodos heredados que han sido invalidados en una clase.

  object-or-type determina el method resolution order a ser buscado. La búsqueda empieza desde la clase justo después de type.

  Por ejemplo `__mro__` de object-or-type es `D -> B -> C -> A -> object` y el valor de type es `B`, entonces `super()` busca `C -> A -> object`.

  El atributo `__mro__` de object-or-type lista el orden de búsqueda del método de solución empleado por `getattr()` y `super()`. El atributo es dinámico y puede cambiar en cuanto la jerarquía de herencia se actualiza.

  Si se omite el segundo argumento, el objeto super retornado no está vinculado. Si el segundo argumento es un objeto, `isinstance(obj, type)` debe ser verdadero. Si el segundo argumento es un tipo, `issubclass(type2, type)` debe ser verdadero (esto es útil para classmethods).

  Hay dos casos de uso típicos para super. En una jerarquía de clases con herencia única, super puede ser utilizado para referirse a las clases padre sin llamarlas explícitamente, haciendo el código más sencillo de mantener. Este uso es muy similar al de super en otros lenguajes de programación.

  The second use case is to support cooperative multiple inheritance in a dynamic execution environment. This use case is unique to Python and is not found in statically compiled languages or languages that only support single inheritance. This makes it possible to implement «diamond diagrams» where multiple base classes implement the same method. Good design dictates that such implementations have the same calling signature in every case (because the order of calls is determined at runtime, because that order adapts to changes in the class hierarchy, and because that order can include sibling classes that are unknown prior to runtime).

  Para ambos casos, la llamada típica de una superclase se parece a:

      class C(B):
          def method(self, arg):
              super().method(arg)    # This does the same thing as:
                                     # super(C, self).method(arg)

  Además de para los métodos de búsqueda, `super()` también funciona para búsquedas de atributos. Un caso de uso posible para esto es llamar a descriptores en una clase padre o hermana.

  Nótese que `super()` se implementa como parte del proceso vinculante para búsquedas de atributos explícitos punteados tales como `super().__getitem__(name)`. Lo hace implementando su propio método `__getattribute__()` para buscar clases en un orden predecible que soporte herencia múltiple cooperativa. De la misma manera, `super()` no está definida para búsquedas implícitas usando declaraciones o operadores como `super()[name]`.

  Nótese también, que aparte de en su forma sin argumentos, `super()` no está limitada a su uso dentro de métodos. La forma con dos argumentos especifica de forma exacta los argumentos y hace las referencias apropiadas. La forma sin argumentos solo funciona dentro de una definición de clase, ya que el compilador completa los detalles necesarios para obtener correctamente la clase que está siendo definida, así como accediendo a la instancia actual para métodos ordinarios.

  Para sugerencias prácticas sobre como diseñas clases cooperativas usando `super()`, véase guía de uso de super().

class `tuple`([iterable])

  Más que una función, `tuple` es en realidad un tipo de secuencia inmutable, tal y como está documentado en Tuplas y Tipos secuencia — list, tuple, range.

class `type`(object)
class `type`(name, bases, dict, **kwds)

  Con un argumento, retorna el tipo de un object. El valor de retorno es un objeto tipo y generalmente el mismo objeto que el retornado por `object.__class__`.

  La función integrada `isinstance()` es la recomendada para testear el tipo de un objeto, ya que tiene en cuenta las subclases.

  With three arguments, return a new type object. This is essentially a dynamic form of the `class` statement. The name string is the class name and becomes the `__name__` attribute. The bases tuple contains the base classes and becomes the `__bases__` attribute; if empty, `object`, the ultimate base of all classes, is added. The dict dictionary contains attribute and method definitions for the class body; it may be copied or wrapped before becoming the `__dict__` attribute. The following two statements create identical `type` objects:

      >>> class X:
      ...     a = 1
      ...
      >>> X = type('X', (), dict(a=1))

  Ver también Objetos Tipo.

  Keyword arguments provided to the three argument form are passed to the appropriate metaclass machinery (usually `__init_subclass__()`) in the same way that keywords in a class definition (besides metaclass) would.

  See also Customizing class creation.

  Distinto en la versión 3.6: Subclases de `type` que no sobrecarguen `type.__new__` ya no pueden usar la forma con un argumento para obtener el tipo de un objeto.

`vars`([object])

  Retorna el atributo `__dict__` para un módulo, clase, instancia o cualquier otro objeto con un atributo `__dict__`.

  Los objetos como módulos o instancias tienen un atributo actualizable `__dict__`; sin embargo, otros objetos pueden tener restricciones de escritura en sus atributos `__dict__` (por ejemplo, hay clases que usan `types.MappingProxyType` para evitar actualizaciones directas del diccionario).

  Sin un argumento, `vars()` funciona como `locals()`. Ten en cuenta que el diccionario de locals solo es útil para lecturas ya que las actualizaciones del diccionario de locals son ignoradas.

  A `TypeError` exception is raised if an object is specified but it doesn’t have a `__dict__` attribute (for example, if its class defines the `__slots__` attribute).

`zip`(*iterables)

  Produce un iterador que agrega elementos de cada uno de los iterables.

  Retorna un iterador de tuplas, donde el i-ésimo elemento de la tupla contiene el i-ésimo elemento de cada una de las secuencias o iterables en los argumentos. El iterador para cuando se agota el iterable de entrada más corto. Con un sólo argumento iterable, retorna un iterador de 1 tupla. Sin argumentos, retorna un iterador vacío. Es equivalente a:

      def zip(*iterables):
          # zip('ABCD', 'xy') --> Ax By
          sentinel = object()
          iterators = [iter(it) for it in iterables]
          while iterators:
              result = []
              for it in iterators:
                  elem = next(it, sentinel)
                  if elem is sentinel:
                      return
                  result.append(elem)
              yield tuple(result)

  La evaluación de izquierda a derecha de los iterables está garantizada. Esto permite emplear una expresión idiomática para agregar una serie de datos en grupos de tamaño n usando `zip(*[iter(s)]*n)`. Esto repite el mismo iterador `n` veces de forma que cada tupla de salida tiene el resultado de `n` llamadas al iterador. Esto tiene el efecto de dividir la entrada en trozos de longitud n.

  `zip()` solo debería utilizarse con tamaños de entrada diferentes en el caso de que no te importe que haya valores sin agrupar de los iterables más largos. Si en cambio esos valores son importantes, utiliza en cambio `itertools.zip_longest()`.

  `zip()` en conjunción con el operador `*` puede usar para descomprimir (unzip) una lista:

      >>> x = [1, 2, 3]
      >>> y = [4, 5, 6]
      >>> zipped = zip(x, y)
      >>> list(zipped)
      [(1, 4), (2, 5), (3, 6)]
      >>> x2, y2 = zip(*zip(x, y))
      >>> x == list(x2) and y == list(y2)
      True

`__import__`(name, globals=None, locals=None, fromlist=(), level=0)

  Nota

  Ésta es una función avanzada que no se necesita en el uso cotidiano de programación en Python, a diferencia de `importlib.import_module()`.

  Esta función es invocada por la declaración `import`. Puede ser reemplazada para cambiar la semántica de la declaración `import` (mediante la importación del módulo `builtins` y su asignación a `builtins.__import__`), pero esto está fuertemente no recomendado ya que es normalmente mucho más simple usar ganchos (hooks) de importación (ver PEP 302) para obtener los mismos objetivos y sin causar problemas en código que asume que la implementación por defecto de importaciones está siendo utilizada. El uso directo de `__import__()` tampoco está recomendado y se prefiere `importlib.import_module()`.

  La función importa el módulo name, usando potencialmente las globals y locals indicadas para determinar como interpretar el nombre en el contexto de un paquete. fromlist indica los nombres de objetos o submódulos que deberían ser importados del módulo indicado por name. La implementación estándar no utiliza su argumento locals para nada, y usa globals solo para determinar el contexto en un paquete de la declaración `import`.

  level especifica si usar importaciones absolutas o relativas. `0` (por defecto) significa sólo realizar importaciones absolutas. Valores positivos de level indican el número de directorios progenitores relativos al del módulo para buscar llamando a `__import__()` (ver PEP 328 para los detalles).

  Cuando la variable name tiene la forma `package.module`, normalmente el paquete del nivel más alto (el nombre hasta el primer punto) se retorna, no el modulo llamado por name. Sin embargo, cuando un argumento fromlist no vacío es indicado, el módulo llamado por name es retornado.

  Por ejemplo, la declaración `import spam` resulta en un bytecode similar al siguiente código:

      spam = __import__('spam', globals(), locals(), [], 0)

  La declaración `import spam.ham` resulta en esta llamada:

      spam = __import__('spam.ham', globals(), locals(), [], 0)

  Nótese cómo `__import__()` retorna el módulo del nivel superior en este caso porque este es el objeto que está enlazado a un nombre por la declaración `import`.

  Por otra parte, la declaración `from spam.ham import eggs, sausage as saus` resulta en

      _temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
      eggs = _temp.eggs
      saus = _temp.sausage

  Aquí, el módulo `spam.ham` es retornado desde `__import__()`. Desde este objeto, los nombres a importar son obtenidos y asignados a sus nombres respectivos.

  Si simplemente quieres importar un módulo (potencialmente dentro de un paquete) por nombre, usa `importlib.import_module()`.

  Distinto en la versión 3.3: Valores negativos para level ya no están soportados (lo que también cambia el valor por defecto a 0).

Notas al pie

1

  Ten en cuenta que el parser sólo acepta la convención de final de línea de tipo Unix. Si estás leyendo el código de un fichero, asegúrate de usar la el modo de conversión de nueva línea para convertir las líneas de tipo Windows o Mac.