2.3 Funciones internas

El intérprete de Python cuenta con funciones internas que siempre se hallan disponibles. Se muestran a continuación, en orden alfabético.

__import__ (name[, globals[, locals[, fromlist]]])

Esta función es llamada por la sentencia import. Existe con el propósito principal de reemplazarla con otra función compatible en interfaz, para hacer posible cambiar la semántica de la sentencia import. Consultar los módulos de biblioteca estándar ihooks y rexec si se desea ver por qué y cómo hacer esto. Consultar también el módulo interno imp, que define ciertas operaciones útiles para construir una función __import__() propia.

Por ejemplo, la sentencia `import spam' causa la siguiente llamada: __import__('spam', globals(), locals(), []); la sentencia from spam.jamon import huevos resulta en __import__('spam.jamon', globals(), locals(), ['huevos']). Hay que ver que, a pesar de que se pasan locals() y ['huevos'] como argumentos, la función __import__() no da valor a la variable local huevos; esto se realiza con el código adicional generado por la sentencia import (de hecho, la implementación estándar no utiliza el argumento locals en absoluto y usa globals sólo para determinar el contexto del paquete de la sentencia import).

Cuando la variable name tiene la forma package.module, normalmente, se devuelve el paquete de nivel más elevado (el nombre hasta el primer punto, no el módulo denotado por name. Sin embargo,. cuando se proporciona un argumento fromlist no vacío, se devuelve el módulo denominado name. Esto se hace de esta manera por compatibilidad con el bytecode generado para las diferentes clases de sentencias import. Cuando se utiliza "import spam.jamon.huevos", el paquete de nivel superior spam debe colocarse en el espacio nominal que ha llamado a import, pero cuando se usa "from spam.jamon import huevos", se ha de utilizar el subpaquete spam.jamon para encontrar la variable huevos. Como remedio a este comportamiento, se puede utilizar getattr() para extraer los componentes deseados. Por ejemplo, se podría definir la siguiente función de ayuda:

import string

def my_import(name):
    mod = __import__(name)
    components = string.split(name, '.')
    for comp in components[1:]:
        mod = getattr(mod, comp)
    return mod

abs (x): Devuelve el valor absoluto de un número. El argumento puede ser un entero normal o largo o un número de coma flotante. Si el argumento es un número complejo, se devuelve su módulo.

apply (function, args[, keywords]): El argumento function debe ser un objeto invocable (una función o método definido por el usuario o interna) y args una secuencia (si no es una tupla, primero se convierte la secuencia a tupla). Se llama a la función function con args como lista de argumentos. El número de argumentos es la longitud de la tupla (se diferencia de llamar sin más a func(args), pues en este caso siempre hay exactamente un argumento). Si se proporciona el argumento opcional keywords, debe ser un diccionario cuyas claves sean cadenas. Especifica argumentos clave a añadir al final de la lista de argumentosd.

buffer (object[, offset[, size]]): EL argumento object debe ser un objeto con interfaz compatible con buffer (cadenas, matrices y buffers). Se creará un nuevo objeto buffer referente a object. El objeto buffer será un corte desde el principio de object (o desde el desplazamiento inicial offset especificado). El corte se extenderá hasta el final de object (o tendrá una longitud especificada por el argumento size).

callable (object): Devuelve verdadero si el argumento object parece tener una interfaz de llamadas (como las funciones y métodos) y falso en caso contrario. SI devuelve verdadero, aún es posible que falle la llamada, pero si es falso, las llamadas a object siempre serán infructuosas. Es importante ver que las clases siempre tienen la interfaz de llamadas (y al llamarlas se obtiene una nueva instancia). Las instancias de clases son llamables si cuentan con un método __call__().

chr (i): Devuelve una cadena de un carácter cuyo código ASCII es el entero i, es decir, chr(97) devuelve la cadena 'a'. Es la inversa de la función ord(). El argumento debe estar en el rango de 0 a 255, ambos incluidos. Se lanza ValueError si i está fuera de dicho rango.

cmp (x, y): Compara los objetos x y y y devuelve un entero acorde con la comparación. El valor devuelto es negativo si x < y, cero si x == y y estrictamente positivo si x > y.

coerce (x, y): Devuelve una tupla de dos argumentos numéricos convertidos a un tipo común, usando las mismas reglas que usan las operaciones aritméticas.

compile (string, filename, kind): Compila la cadena string a un objeto código. Los objetos código pueden ejecutarse con la sentencia exec evaluarse en una llamada a eval(). El argumento filename debe proporcionar el fichero del que se leyó el código. Pasar, por ejemplo, '<string>' si no se ha recuperado el código de ningún fichero. El argumento kind especifica qué tipo de código se ha de compilar. Puede ser 'exec' si string es una secuencia de sentencias, 'eval' si es una sola expresión o 'single' si es una sola sentencia interactiva (en cuyo caso, las sentencias-expresión que den como resultado algo diferente de None mostrarán este resultado en pantalla).

complex (real[, imag]): Crea un número complejo con el valor real + imag*j o convierte una cadena o número a complejo. Cada argumento puede ser de cualquier tipo numérico (incluso complejo). imag toma un valor cero por omisión, y la función sirve de función de conversión como int(), long() y float(); en tal caso también acepta un argumento cadena, que debe representar un número complejo válido.

delattr (object, name): Esta función es pariente de setattr(). Los argumentos son un objeto y una cadena. La cadena debe ser el nombre de uno de los atributos del objeto. La función elimina dicho atributo, siempre que el objeto lo permita. Por ejemplo, delattr(x, 'foobar') equivale a del x.foobar.

dir ([object])

Sin argumentos, devuelve la lista de nombres de la tabla de símbolos local actual. Con argumento, intenta recuperar una lista de atributos válidos para el objeto indicado. Esta información se infiere a partir de los atributos __dict__, __methods__ y __members__ del objeto, de existir. Esta lista no es necesariamente completa, pues para las clases, no se incluyen los atributos de clases base, y en el caso de instancias de una clase, no se incluyen los métodos. La lista resultante está en orden alfabético. Por ejemplo:

>>> import sys
>>> dir()
['sys']
>>> dir(sys)
['argv', 'exit', 'modules', 'path', 'stderr', 'stdin', 'stdout']

divmod (a, b): Toma como argumentos dos números y devuelve una pareja de números: el primero es el cociente de los argumentos y el segundo su resto. Si los operandos son de tipo mixto, se aplican las reglas de operadores binarios aritméticos. En el caso de los enteros largos, el resultado equivale a (a / b, a % b). En el caso de los números en coma flotante, el resultado es (q, a % b), donde q suele ser math.floor(a / b), pero puede ser uno menos. En cualquier caso, q * b + a % b se acerca mucho a a, si a % b no es cero y tiene el mismo signo que b, and 0 <= abs(a % b) < abs(b).

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

Los argumentos son una cadena y dos diccionarios opcionales. El argumento expression se analiza y evalúa como expresión de Python (hablando técnicamente, una lista de condiciones) usando los diccionarios globals y locals como espacio nominal global y local, respectivamente. Si se omite el diccionario locals, toma por valor el diccionario globals. Si se omiten los dos diccionarios, la expresión se evalúa en el entorno en que se llama a eval. El valor devuelto es el resultado de la expresión evaluada. Los errores de sintaxis se comunican como excepciones. Por ejemplo:

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

También se puede utilizar esta función para ejecutar objetos código arbitrarios (es decir, los creados con compile()). Para ello, se debe pasar un objeto código en lugar de una cadena. El objeto código debe compilarse con el argumento kind a 'eval'.

Pistas: La ejecución dinámica de sentencias se logra con la sentencia exec. La ejecución de sentencias de un fichero se logra con la función execfile(). Las funciones globals() y locals() devuelven el diccionario actual global y local, respectivamente, lo que puede resultar útil para pasárselo a eval() o execfile().

execfile (file[, globals[, locals]]): Esta función es similar a la sentencia exec, pero analiza un fichero en lugar de una cadena. Es diferente de la sentencia import porque no utiliza la administración de módulos, sino que lee el fichero incondicionalmente y no crea un nuevo módulo^2.8.
Los argumentos son un nombre de fichero y dos diccionarios opcionales. El fichero se analiza y evalúa como una secuencia de sentencias de Python (de modo similar a un módulo) usando los diccionarios globals y locals como espacio nominal global y local, respectivamente. Si se omite el diccionario locals, toma por valor el diccionario globals. Si se omiten los dos diccionarios, la expresión se evalúa en el entorno en que se llama a execfile(). El valor devuelto es None.

filter (function, list): Construye una lista a partir de los elementos de list para los cuales la función function devuelve un valor verdadero. Si list es una cadena o una tupla, el resultado tiene ese tipo también; en caso contrario es una lista. Si function es None, se presupone la función identidad, por lo que se eliminan todos los elementos falsos (cero, nulo o vacío) de list.

float (x): Convierte una cadena o número a coma flotante. Si el argumento es una cadena, debe contener una representación válida de un número en coma flotante, con espacio en blanco alrededor opcionalmente. En este caso, se comporta igual que string.atof(x). En caso contrario, el argumento puede ser un entero normal o largo, y se devuelve un número de coma flotante del mismo valor (dentro de la precisión de coma flotante de Python).
Nota: Cuando se pasa una cadena, pueden devolverse los valores de NaN e Infinity, dependiendo de la biblioteca de C subyacente. El conjunto de cadenas específico aceptado para devolver estos valores depende por completo de la biblioteca de C y varía de un sistema a otro.

getattr (object, name[, default]): Devuelve el valor del atributo denominado name de object. name debe ser una cadena de uno de los atributos del objeto, siendo el resultado el valor de dicho atributo. Por ejemplo, getattr(x, 'foobar') equivale a x.foobar. Si el atributo especificado no existe, se devuelve default si se ha proporcionado o se lanza AttributeError si no.

globals (): Devuelve un diccionario que representa la tabla global de símbolos actual. Éste es siempre el diccionario del módulo actual (dentro de una función o método, éste es el módulo en que está definido, no el módulo desde el que se llama).

hasattr (object, name): Los argumentos son un objeto y una cadena. El resultado es 1 si la cadena es el nombre de uno de los atributos del objeto o 0 en caso contrario (se implementa llamando a getattr(object, name), mirando si hace saltar una excepción o no).

hash (object): Devuelve el valor hash del objeto (si lo tuviere). Los valores hash son enteros que se utilizan para comparar claves de diccionario de manera rápida en las búsquedas. Los valores numéricos que resultan iguales en una comparación tienen el mismo valor hash (aun si son de tipos diferentes, como 1 y 1.0).

hex (x): Convierte un número entero (de cualquier tamaño) a una cadena hexadecimal. El resultado es una expresión Python válida. Esta función siempre devuelve un literal sin signo, por ejemplo, en una máquina de 32 bit, hex(-1) devuelve '0xffffffff'. Si se evalúa en una máquina con el mismo tamaño de palabra, este literal siempre se evalúa como -1, pero en una máquina de palabra de diferente tamaño, puede acabar como un entero positivo muy grande o lanzar una excepción OverflowError.

id (object): Devuelve la `identidad' de un objeto. Es un entero (o entero largo) que cumple ser único y constante durante toda la vida del objeto. Dos objetos cuya vida no coincida en el tiempo pueden compartir el mismo valor de id(). Nota de implementación: Es la dirección en memoria del objeto.

input ([prompt])

Equivale a eval(raw_input(prompt)). Advertencia: ¡Esta función no está a salvo de errores de usuario! Espera una expresión Python válida como entrada. Si la entrada no es sintácticamente válida, se lanzará SyntaxError. Se pueden lanzar otras excepciones si hay cualquier error durante la evaluación (por otra parte, a veces es justo lo que necesitas cuando hay que escribir un guion rápidamente para uso por expertos).

Si está cargado el módulo readline, input() lo utilizará para proporcionar edición compleja de línea e histórico de órdenes.

Se debe considerar el uso de la función raw_input() para la entrada de usuarios en general.

int (x[, radix]): Convierte una cadena o número a entero simple. Si el argumento es una cadena, debe contener un número decimal con signo opcional representable como entero de Python, con espacio alrededor opcional. Se comporta de manera idéntica a string.atoi(x[, radix]) en este caso. El parámetro radix proporciona la base para la conversión y puede ser cualquier entero en el rango [2, 36]. Si se especifica radix y x no es una cadena, se lanza TypeError. En otros casos, el argumento puede ser un entero normal o largo, o un número en coma flotante. La conversión de los números de coma flotante a enteros está definida por la biblioteca C^2.9.

intern (string): Introduce string en la tabla de cadenas ``internas'' y devuelve la cadena interna, que es la propia string o una cadena. Internar cadenas es útil para ganar algo de rendimiento en el caso de búsquedas en diccionarios; si las claves de un diccionario son internas y la clave buscada es interna también, las búsquedas por clave (tras hallar el valor hash) se realizan por comparación de punteros en lugar de comparación de cadenas. Normalmente, los nombres utilizados en programas de Python se internan automáticamente, así como las claves utilizadas para contener atributos de módulo, clase o instancia. Las cadenas internas son inmortales (es decir, nunca son recolectadas como basura).

isinstance (object, class): Devuelve verdadero si el argumento object es una instancia del argumento class o de una de sus subclases. También devuelve verdadero si class es un objeto tipo y object es un objeto de este tipo. Si object no es una instancia de clase u objeto del tipo indicados, devuelve falso. Si class no es ni un objeto de una clase ni de un tipo, se lanza una excepción TypeError.

issubclass (class1, class2): Devuelve verdadero si class1 es una subclase (directa o indirecta) de class2. Una clase se considera subclase de sí misma. Si alguno de los dos argumentos no es un objeto clase, se lanza una excepción TypeError.

len (s): Devuelve la longitud (el número de elementos) de un objeto. El argumento puede ser una secuencia (cadena, tupla o lista) o una correspondencia (diccionario).

list (sequence): Devuelve una lista cuyos elementos son los mismos que los de sequence en el mismo orden. Si sequence ya es una lista, se devuelve una copia, de modo parecido a sequence[:]. Por ejemplo, list('abc') devuelve ['a', 'b', 'c'] y list( (1, 2, 3) ) devuelve [1, 2, 3].

locals (): Devuelve un diccionario que representa la tabla de símbolos local actual. Advertencia: No debe modificarse el contenido de este diccionario. Los cambios pueden no afectar a las variables locales del intérprete.

long (x): Convierte una cadena o número a un entero largo. Si el argumento es una cadena, debe contener un número decimal de cualquier tamaño de signo opcional, con espacio alrededor opcional también. Se comporta de manera idéntica a string.atol(x) en este modo. El argumento puede ser también un entero normal o largo, o un número en coma flotante, para el que se devuelve un entero largo del mismo valor. La conversión de los números de coma flotante a enteros viene determinada por la librería de C, como se veía en la descripción de int().

map (function, list, ...): Aplica function a cada elemento de list y devuelve una lista con los resultados. Si se pasan argumentos adicionales list, function debe tomar tantos argumentos como listas haya y se aplica la función en paralelo sobre todos los elementos de la misma posición de todas las listas argumento. Si alguna de las listas es más corta que el resto, se tomará el valor de None para los elementos que falten. Si function es None, se supone la función identidad; si hay múltiples argumentos lista, map() devuelve una lista de las tuplas de los elementos correspondientes de cada lista (lo que supone una especie de transposición matricial). Los argumentos list pueden ser cualquier tipo de secuencia; el resultado siempre es una lista.

max (s[, args...]): Con un solo argumento s, devuelve el mayor elemento de una secuencia no vacía. Si hay más de una argumento, devuelve el mayor de los argumentos.

min (s[, args...]): Con un solo argumento s, devuelve el menor elemento de una secuencia no vacía. Si hay más de una argumento, devuelve el menor de los argumentos.

oct (x): Convierte un número entero (de cualquier tamaño) a una cadena octal. El resultado es una expresión de Python válida. Nota: Siempre devuelve un entero sin signo, por ejemplo, en una máquina de 32 bit, oct(-1) devuelve '037777777777'. Si se evalúa en una máquina de la misma longitud de palabra, este literal se evaluará como -1, si el tamaño de palabra es diferente podría resultar un entero positivo grande o lanzar una excepción OverflowError.

open (filename[, mode[, bufsize]])

Devuelve un nuevo objeto fichero (descrito anteriormento bajo Tipos internos). Los primeros dos argumentos son los mismos que los de la función C fopen() de la cabecera stdio: filename es el nombre del fichero a abrir, mode indica cómo se ha de abrir el fichero: 'r' en sólo lectura, 'w' para escritura (truncando el fichero si existe) y 'a' para agregar (lo que en algunos sistemas Unix supone que todas las escrituras se agregan al final del archivo, sin importar la posición actual del cursor de escritura.

Los modos 'r+', 'w+' y 'a+' abren el fichero para actualización (hay que observar que 'w+' trunca el fichero). Se ha de añadir 'b' al modo para abrir el fichero en modo binario, para los sistemas que diferencian los ficheros binarios y de texto (si no, se hace caso omiso). Si no es posible abrir el fichero, se lanza IOError.

Si se omite mode, toma un valor de 'r'. Al abrir un fichero binario, se debe añador 'b' al valor de mode para mejorar la compatibilidad (es útil hasta en sistemas que no hacen distinciones entre ficheros de texto y binarios, pues sirve de documentación). El argumento opcional bufsize especifica el tamaño de tampón deseado: 0 significa sin tampón, 1 indica tampón de líneas y cualquier otro valor positivo especifica el tamaño del tampón a usar (aproximado). Un bufsize negativo indica que se ha de usar el valor predeterminado por el sistema, que suele ser tampón de líneas para los dispositivos tty y tampón completo para otros ficheros. Si se omite, se usa el valor predeterminado del sistema^2.10.

ord (c): Devuelve el valor ASCII de una cadena de un carácter o un carácter Unicode. Por ejemplo, ord('a') devuelve el entero 97, ord(u' u2020') devuelve 8224. Es la inversa de chr() para cadenas y la de unichr() para caracteres Unicode.

pow (x, y[, z]): Devuelve x elevado a y; si se proporciona z, devuelve x elevado a y, módulo z (calculado de manera más eficaz que pow(x, y) % z). Los argumentos deben ser de tipo numérico. Si los tipos son mixtos, se aplican las reglas de operadores binarios aritméticos habituales. El tipo de operando efectivo coincide con el del resultado. Si el resultado no es expresable en este tipo, se lanzará una excepción, por lo que, por ejemplo, no está permitido pow(2, -1) ni pow(2, 35000).

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

Ésta es una versátil función para crear listas que contengan progresiones aritméticas. Su uso más popular es en los bucles for. Los argumentos deben ser enteros normales. Si se omite el argumento step toma un valor de 1. Si se omite el argumento start toma un valor de 0. La forma completa devuelve una lista de enteros normales

[start, start + step,
  start + 2 * step, ...]

. Si step es positivo, el último elemento es el mayor valor

start + i *
  step

menor que stop; si step es negativo, el último elemento es el mayor valor start + i * step mayor que stop. step no debe ser cero (o se lanza ValueError). Por ejemplo:

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(0, -10, -1)
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]

raw_input ([prompt])

Si se proporciona el argumento prompt, se escribe en la salida estándar sin salto de línea al final. La función lee una línea de la entrada, la convierte a una cadena (eliminando el salto de línea final) y devuelve el resultado. Si se lee EOF (el carácter de fin de fichero, Control-Z en Windows, Control-D en Unix), se lanza EOFError. Ejemplos:

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

Si se ha cargado el módulo readline, raw_input() lo utilizará para proporcionar edición compleja de línea e histórico de órdenes.

reduce (function, sequence[, initializer]): Aplicar function (una función de dos argumentos), reiteradamente a los argumentos de sequence, desde el inicio (izquierda) hasta reducir la secuencia a un solo valor. Por ejemplo, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calcula ((((1+2)+3)+4)+5). Si se proporciona el parámetro opcional initializer, se coloca a la izquierda de los elementos de la secuencia antes de iniciar los cálculos y sirve como valor por defecto si la secuencia está vacía.

reload (module)

Re-analizar y re-inicializar un módulo module ya importado. El argumento debe ser un objeto módulo, por lo que ya se debe haber importado con éxito anteriormente. Es útil si se ha editado el módulo con un editor externo y se desea probar la nueva versión sin abandonar y volver al intérprete de Python. El valor de retorno es el objeto módulo (es decir, el mismo argumento de entrada).

Hay que observar ciertos detalles:

Si un módulo es correcto sintácticamente pero falla su inicialización, el primer import que se haga no enlaza su nombre localmente, sino que guarda un módulo (parcialmente inicializado) en sys.modules. Para recargar el módulo, hay que volver a importarlo (lo que enlazará el nombre localmente al módulo parcialemente inicializado) antes de poder recargarlo con reload().

Al recargar un módulo, su diccionario (que contiene las variables globales del módulo) se mantiene. Las redefiniciones de los nombres sobreescribirán las antiguas definiciones, por lo que esto nu suele suponer un problema. Si al nueva versión de un módulo no define un nombre que definía la versión anterior, la definición antigua permanece en memoria. Esta característica se puede utilizar si el módulo mantiene una tabla global o caché de objetos, pues una sentencia try puede comprobar la presencia de la tabla y saltarse la inicialización si se desea.

Es legal, aunque no suele ser muy útil, recargar módulos internos o de carga dinámica, salvo sys, __main__ y __builtin__. En muchos casos los módulos de extensión no están diseñados para ser inicializados más de una vez y pueden fallar de manera arbitraria si se recargan.

Si un módulo importa objetos de otro módulo con from ... import ..., llamar a reload() del otro módulo no redefine los objetos importados de éste. Una manera de saltarse esto es re-ejecutar la sentencia from, otra es usar import y nombres cualificados (module.name).

Si un módulo genera instancias de una clase, recargar el módulo que define la clase no afecta a las definiciones de métodos de las instancias, que seguirán utilizando la definición antigua. Lo mismo ocurre en el caso de clases derivadas.

repr (object): Devuelve una cadena que contiene un representación imprimible del objeto. Es el mismo valor que devuelven las conversiones (comillas invertidas). A veces es útil acceder a esta operación en forma de función normal. En muchos tipos, esta función hace lo posible para devolver una cadena que devolvería un objeto del mismo valor que el original al evaluarla con eval().

round (x[, n]): Devuelve el valor de coma flotantex redondeado a n dígitos tras la coma decimal. Si se omite n toma el valor de cero. El resultado es un número de coma flotante. Los valores se redondean al valor más cercano a 10 elevado a menos n. Si hay dos múltiplos igual de cercanos, se redondea alejándose de 0 (así que round(0.5) es 1.0 y round(-0.5) es -1.0).

setattr (object, name, value): Es la función contraria a getattr(). Los argumentos son un objeto, una cadena y un valor arbitrario. La cadena puede nombrar un atributo existente o nuevo. La función asigna el valor al atributo, siempre que el objeto lo permita. Por ejemplo, setattr(x, 'foobar', 123) equivale a x.foobar = 123.

slice ([start,] stop[, step]): Devuelve un corte que representa el conjunto de índices especificado por range(start, stop, step). Los argumentos start y step toman el valor por omisión de None. Los objetos corte tienen atributos de sólo lectura start, stop y step que se limitan a devolver los valores de los argumentos (o su valor por defecto). No tienen ninguna otra funcionalidad explícita, pero son utilizados por Numerical Python (la extensión de cálculo matricial) y otras extensiones de terceros. Los objetos corte resultan también como producto de la sintaxis de corte extendida: "a[start:stop:step]" o "a[start:stop, i]".

str (object): Devuelve una cadena que contiene una representación imprimible de un objeto. En el caso de cadenas, devuelve la propia cadena. La diferencia con repr(object) es que str(object) no intenta devolver una cadena que acepte eval(), su objetivo es devolver una cadena imprimible.

tuple (sequence): Devuelve una tupla cuyos elementos son los mismos que los de sequence en el mismo orden. Si sequence ya es una tupla, se devuelve sin cambios. Por ejemplo, tuple('abc') devuelve ('a', 'b', 'c') y tuple([1, 2, 3]) devuelve (1, 2, 3).

type (object)

Devuelve el tipo de object. El resultado es un objeto tipo. El módulo estándar types define nombres para todos los tipos internos. Por ejemplo:

>>> import types
>>> if type(x) == types.StringType: print "Es una cadena"

unichr (i): Devuelve la cadena Unicode de una carácter cuyo código Unicode es el entero i, es decir, unichr(97) devuelve la cadena u'a'. Es la función inversa de ord() para cadenas Unicode. El argumento debe estar en el rango [0..65535], ambos incluidos. En caso contrario, se lanza ValueError. Nuevo en la versión 2.0.

unicode (string[, encoding[, errors]]): Descodifica string usando el codec de encoding. La gestión de errores se lleva a cabo según errors. El comportamiento predeterminado es descodificar UTF-8 en modo estricto, lo que significa que los errores de codificación lanzan ValueError. Hay más información en el módulo codecs. Nuevo en la versión 2.0.

vars ([object]): Sin argumentos, devuelve un diccionario correspondiente a la tabla de símbolos local actual. Con un módulo, clase o instancia de clase como argumento (o cualquier cosa que tenga un atributo __dict__ attribute), devuelve un diccionario correspondiente a la tabla de símbolos del objeto. El diccionario devuelto no debería modificarse, pues los efectos sobre la tabla de símbolos no están definidos^2.11.

xrange ([start,] stop[, step]): Esta función es muy similar a range(), pero devuelve un ``objeto xrange'' en lugar de una lista. Es un tipo secuencia opaco que devuelve los mismos valores que la correspondiente lista, sin almacenarlos simultáneamente. La ventaja de xrange() sobre range() es mínima (pues xrange() todavía tiene que crear los valores al pedísrselos) excepto en máquinas impedidas en cuestión de memoria (por ejemplo, MS-DOS) o cuando nunca se utilizan todos los elementos del rango (por ejemplo, porque se suele interrumpir la ejecución del bucle con break).

zip (seq1, ...): Esta función devuelve una lista de tuplas, donde cada tupla contiene el i-ésimo elemento de cada una de las secuencias de argumento. Se requiere al menos una secuencia, o se lanzará TypeError. La lista devuelta se trunca a la longitud de la secuencia de argumento más corta. Cuando hay múltiples secuencias de argumento de la misma longitud, zip() es similar a map() con un argumento inicial de None. Con una sola secuencia como argumento, devuelve una lista de tuplas de un solo elemento. Nuevo en la versión 2.0.

Footnotes

... módulo ^2.8: Se usa poco, por lo que no acabó como sentencia.
... C ^2.9: Muy mal, la definición del lenguaje debería exigir el truncamiento hacia cero.
... sistema ^2.10: Especificar un tamaño de tampón no tiene en la actualidad ningún efecto en los sistemas que carecen de una función setvbuf(). La interfaz para especificar el tamaño del tampón no se realiza mediante una llamada a setvbuf(), porque podría causar una interrupción incontrolada del programa si se llama tras realizar cualquier E/S y no hay un método fiable de determinar si éste es el caso.
... definidos ^2.11: En la implementación actual, no es posible afectar a las variables locales de este modo, aunque es posible alterar variables recuperadas de otros ámbitos (por ejemplol, módulos). Esto puede cambiar.

Ver Sobre este documento... para obtener información sobre sugerencias.