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ódulo2.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 sistema2.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 definidos2.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ódulo2.8
Se usa poco, por lo que no acabó como sentencia.
... C2.9
Muy mal, la definición del lenguaje debería exigir el truncamiento hacia
cero.
... sistema2.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.
... definidos2.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.