UNIVERSIDAD TECNICA DE MACHALA

UNIDAD ACADEMICA DE INGENIERIA CIVIL

CARRERA DE INGENIERIA DE SISTEMAS

ACTIVIDAD N°: 01 FECHA ENVIO: 15/05/2015 FECHA ENTREGA: 22/05/2015

TEMA: Elementos principales de Python.

”INTRODUCCIÓN A LA PROGRAMACIÓN POR
UNIDAD N°1:
PROCEDIMIENTOS”

OBJETIVO: Profundizar la investigación sobre las librerías, funciones predefinidas y palabras

integradas en el lenguaje de programación Python.
PROBLEMA: Desconocimiento de las librerías, funciones predefinidas y palabras integradas en
el lenguaje de programación Python.

INDICADOR DE EVALUACION: CALIFICACIÓN

Investigar temas avanzados y aplicando a problemas de la realidad
relacionados con la carrera.

CRITERIOS DE EVALUACIÓN: Siempre A veces Nunca

(100%) (75%) (10%)

EN IMPRESOS
 Entrega documentación impresa y digital. (Siguiendo las normas y convenciones para la escritura y
sin falta de ortografía). La redacción del documento debe ser clara. Debe incluir todas las fuentes de
donde tomó la información.
 Cumple con el formato, normas y estructura para la elaboración del documento.
APLICACIÓN DE VALORES.
 Puntualidad. Entrega de trabajo a tiempo
 Responsabilidad ética. El trabajo es inédito y respeta la propiedad intelectual
 Responsabilidad profesional. Cumple con las normas técnicas.
USO DE RECURSOS:
 Material electrónico formato Power Point
 Internet
 Computadora
 Microsoft Word
CAPACIDAD DE REFLEXIÓN.
 Incluye ejemplos claros que permiten un mejor entendimiento del tema.
CONOCIMIENTO TÉCNICO.
 Destreza con las herramientas informáticas.
TIPO DE ACTIVIDAD
LUGAR ALCANCE FORMA
□ Intraclase □Individual □Taller □Práctica en laboratorio
□ Extraclase □Grupal □Síntesis, esquemas □Práctica en clase
□Caso de estudio □Resolución de problemas,
□Investigativa ejercicios
□Vinculación con la colectividad □Ensayo, artículo
□Informe de exposición

ROLES Y RESPONSABILIDADES DE LOS PARTICIPANTES EN LA TAREA:

NOMBRE ESTUDIANTE ROL

Jhonathan Rodríguez Álvarez Investigador – Analista

TÉCNICAS EMPLEADAS
Investigación.
 PYTHON

Python es un lenguaje de programación de alto nivel que podemos usar para

realizar todo tipo de tareas en múltiples plataformas. Su filosofía hace énfasis en
que el código que escribamos sea lo más legible posible y su sintaxis
permite expresar nuestra idea en menos líneas de código que otros lenguajes
como Java o C++. Es un lenguaje que está diseñado para ser ejecutado
mediante un intérprete, en contraste con otros lenguajes compilados. Es
multiparadigma, ya que soporta orientación a objetos, programación imperativa
y programación funcional. Es un lenguaje interpretado, usa tipado dinámico y es
multiplataforma.

LIBRERÍAS EN PYTHON

A continuación, se verán algunas de las librerías que se pueden emplear para

trabajar en Python:

 Colorama: Su función es la de mostrar el texto con diferentes fondos y

colores de una forma muy sencilla y sin quebraderos de cabeza. Muy
recomendada si queréis hacer un script que sea visualmente atractivo.
 Kivy: Es una librería multiplataforma, también podremos crear aplicaciones
multitouch en Windows, Mac OS X y Linux.
 PyWeather: Esta librería nos da la posibilidad de recoger los datos de
varias fuentes meteorológicas y mostrarlo a nuestra manera.
 PyQt: Es un binding de la biblioteca gráfica Qt para el lenguaje de
programación Python, nos permite crear interfaces gráficas multiplataforma.
 PyGTK: Esta librería nos permite crear programas de interfaz gráfica
multiplataforma utilizando para ello GTK+.
 Para la programación de videojuegos: en este caso podríamos
mencionar al conocido Pygame o también a Pyglet. Si combinamos estos
con la librería Kivy mencionada anteriormente, se podrán crear juegos para
Android.
FUNCIONES PREDEFINIDAS

El intérprete de Python tiene una serie de funciones incorporadas en ella que

siempre están disponibles. Se enumeran en orden alfabético.

Además, hay otras cuatro funciones integradas que ya no se consideran

esenciales: apply () , buffer () , coerce () , y intern ().

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 delx.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, and0 <= 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 devuelvedefault 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 C2.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 opcionalbufsize 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 questop. 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 lanzaValueError.
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 (puesxrange() 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.

PALABRAS RESERVADAS

Las 30 palabras reservadas (keywords) de Python son:

and, as, assert, break, class, continue, def, del, elif,

else, except, finally, for, from, global, if, import, in, is,
lambda, nonlocal, not, or, pass, raise, return,
try, while, with, yield

No podemos declarar variables, objetos, funciones y clases con estos términos.

and / or

Representaciones lógicas de “y” y “ó”, respectivamente.

 1. >>> True and False
2. False
3. >>> True and True
4. True
5. >>> False and False
6. False
7. >>> True or False
8. True
9. >>> True or True
10. True
11. >>> False or False
12. False

as

Su función es dual. Puede utilizarse al momento de importar un determinado

objeto de un módulo, para asignar un nombre diferente.

from keyword import kwlist as keyword_list

Además, se utiliza la siguiente sintaxis para asignar información de una

excepción a un determinado objeto.

1. >>> try:
2. ... sin_definir
3. ... except NameError as e:
4. ... print(e)
5. ...
6. name 'sin_definir' is not defined

assert

Durante la depuración (si __debug__ es True), assert permite especificar una

expresión que lanzará AssertionError en caso de ser evaluada como falsa.

1. >>> assert 1 == 2
 2. Traceback (most recent call last):
3. File "<stdin>", line 1, in <module>
4. AssertionError
5. >>> assert 1 == 1

Nótese que no es posible asignar un valor a __debug__, éste será False al

llamar a un archivo con las opciones del intérprete -o y -oo.

break

Finaliza la ejecución de un bucle.

1. >>> while True:

2. ... break
3. ...
4. >>> for i in range(10):
5. ... if i == 4:
6. ... break
7. ... else:
8. ... print(i)
9. ...
10. 0
11. 1
12. 2
13. 3

class

Define una clase.

1. >>> class C:
2. ... def __init__(self):
3. ... print("Hello world!")
4. ...
5. >>> c = C()
6. Hello world!
continue

Suspende la ejecución de un bucle para resumirla con el siguiente elemento.

1. >>> for i in range(10):

2. ... if i == 4:
3. ... continue
4. ... else:
5. ... print(i)
6. ...
7. 0
8. 1
9. 2
10. 3
11. 5
12. 6
13. 7
14. 8
15. 9

También aplicable a bucles while.

def

Define una función.

1. >>> def func(a):

2. ... print(a)
3. ...
4. >>> func("Hello world!")
5. Hello world!

del

En caso de utilizarse seguido de un objeto, elimina su referencia.

1. >>> a = 1
 2. >>> a
3. 1
4. >>> del a
5. >>> a
6. Traceback (most recent call last):
7. File "<stdin>", line 1, in <module>
8. NameError: name 'a' is not defined

En diccionarios, remueve el elemento del mismo. En listas, además, reordena el

conjunto de elementos para llenar el espacio vacío.

1. >>> d = {"Yes": 1, "No": 2}

2. >>> d["Yes"]
3. 1
4. >>> del d["Yes"]
5. >>> d["Yes"]
6. Traceback (most recent call last):
7. File "<stdin>", line 1, in <module>
8. KeyError: 'Yes'
9. >>> d
10. {'No': 2}

1. >>> L = ["Yes", "No"]

2. >>> L[0]
3. 'Yes'
4. >>> del L[0]
5. >>> L[0]
6. 'No'
7. >>> L
8. ['No']

exec

Permite ejecutar código Python a partir de una cadena o archivo.

1. >>> exec "a = 1"

 2. >>> a
3. 1

Su utilización no es recomendada. Véase más información en la documentación

oficial.

Únicamente en versiones anteriores a Python 3.x. A partir de esta

última, exec() es una función incorporada por defecto.

for

Permite recorrer los elementos de un objeto iterable (listas, tuplas, diccionarios,

etc.).

1. >>> for i in (1, 2, 3):

2. ... print(i)
3. ...
4. 1
5. 2
6. 3

from

Importa uno o más objetos de un modulo, prescindiendo del nombre de éste

como prefijo al ser utilizado.

1. >>> from keyword import kwlist, iskeyword

2. >>> iskeyword("assert")
3. True

Si se quieren importar todos los objetos, puede utilizarse un asterisco.

from keyword import *

Aunque esta práctica no es recomendable.

global
Permite modificar el valor de un objeto global desde un ámbito con menor
alcance (una función, por ejemplo).

1. >>> a = 1
2. >>> def f():
3. ... global a
4. ... a = 2
5. ...
6. >>> f()
7. >>> a
8. 2

El valor del objeto a no habría sido modficiado sin utilizar global; en su lugar, se
habría creado otro objeto dentro de la función f.

1. >>> a = 1
2. >>> def f():
3. ... a = 2
4. ...
5. >>> f()
6. >>> a
7. 1

if / elif / else

1. if a:
2. # bool(a) es True
3. print("a")
4. elif b:
5. # bool(a) es False
6. # bool(b) es True
7. print("b")
8. elif c:
9. # bool(a) es False
10. # bool(b) es False
 11. # bool(c) es True
12. print("c")
13. else:
14. # Todas las anteriores son falsas.
15. print("Ninguna de las anteriores.")

else incluye un uso adicional (véase más adelante).

import

Importa un módulo, o bien un objeto de éste si es utilizado junto a from.

1. >>> import keyword

2. >>> keyword.iskeyword("assert")
3. True

in

Determina la existencia de un determinado valor dentro de una lista, tupla,

diccionario o cualquier objeto iterable.

1. >>> 2 in (1, 2, 3)
2. True
3. >>> "Hello" in "Hello, world!"
4. True
5. >>> "Si" in {"Yes": 1, "No": 2}
6. False

is

Determina si dos objetos son iguales, a diferencia de los signos de equivalencia

(==), que determinan si ambos tienen el mismo valor.

1. >>> class Number:

2. ... def __init__(self, number):
3. ... self.number = number
4. ... def __eq__(self, other):
 5. ... return self.number == other
6. ...
7. >>> a = Number(1)
8. >>> b = Number(1)
9. >>> a == b
10. True
11. >>> a is b
12. False
13. >>> c = b
14. >>> b is c
15. True

Siempre debe ser utilizado al comprar con None.

1. >>> a = None
2. >>> a is None
3. True

lambda

Véase Funciones lambda.

nonlocal

Permite modificar el valor de un objeto que ha sido creado en un ámbito anterior.

1. >>> def a():

2. ... i = 1
3. ... def b():
4. ... nonlocal i
5. ... i = 2
6. ... b()
7. ... print(i)
8. ...
9. >>> a()
10. 2
Sin el empleo de este vocablo no habría sido posible modificar el valor
de i desde b().

1. >>> def a():

2. ... i = 1
3. ... def b():
4. ... i = 2
5. ... b()
6. ... print(i)
7. ...
8. >>> a()
9. 1

Soportado únicamente en Python 3.

not

Operador lógico “no”.

1. >>> not True

2. False
3. >>> not False
4. True

pass

Esta palabra reservada carece de función alguna. Es utilizada para rellenar

espacios requeridos por Python para evitar errores de sintaxis.

1. >>> def f():

2. ... pass
3. ...
4. >>> f()

print
Imprime en pantalla una determinada cadena. Otros objetos son convertidos
automáticamente.

1. >>> print "Hello, world!"

2. Hello, world!
3. >>> print 1
4. 1

Únicamente en versiones anteriores a Python 3.x. A partir de esta

última, print() es una función incorporada por defecto.

raise

Lanza una excepción.

1. >>> raise NameError

2. Traceback (most recent call last):
3. File "<stdin>", line 1, in <module>
4. NameError

return

Dentro de una función, especifica el valor de retorno.

1. >>> def f():

2. ... return 1
3. ...
4. >>> f()
5. 1

True, False y None

1. >>> True == 1
2. True
3. >>> False == 0
4. True
None es utilizado para indicar la ausencia de un valor en un objeto determinado.