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__()".

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.
