Funciones Python de LU3

https://entrenamiento-python-basico.readthedocs.io/es/latest/index.
html
5.2. Funciones
Una función es un bloque de código con un nombre asociado, que recibe cero o más argumentos como entrada, sigue una secuencia de
sentencias, la cuales ejecuta una operación deseada y devuelve un valor y/o realiza una tarea, este bloque puede ser llamados cuando se
necesite.
El uso de funciones es un componente muy importante del paradigma de la programación llamada estructurada, y tiene varias ventajas:
 modularización: permite segmentar un programa complejo en una serie de partes o módulos más simples, facilitando así la
programación y el depurado.
 reutilización: permite reutilizar una misma función en distintos programas.
Python dispone de una serie de funciones integradas al lenguaje, y también permite crear funciones definidas por el usuario para ser usadas en
su propios programas.
5.2.1. Sentencia def
La sentencia def es una definición de función usada para crear objetos funciones definidas por el usuario.
Una definición de función es una sentencia ejecutable. Su ejecución enlaza el nombre de la función en el namespace local actual a un objecto
función (un envoltorio alrededor del código ejecutable para la función). Este objeto función contiene una referencia al namespace local global
como el namespace global para ser usado cuando la función es llamada.
La definición de función no ejecuta el cuerpo de la función; esto es ejecutado solamente cuando la función es llamada.
La sintaxis para una definición de función en Python es:
def NOMBRE(LISTA_DE_PARAMETROS):
"""DOCSTRING_DE_FUNCION"""
SENTENCIAS
RETURN [EXPRESION]
A continuación se detallan el significado de pseudo código fuente anterior:
 NOMBRE, es el nombre de la función.

 LISTA_DE_PARAMETROS, es la lista de parámetros que puede recibir una función.
 DOCSTRING_DE_FUNCION, es la cadena de caracteres usada para documentar la función.
 SENTENCIAS, es el bloque de sentencias en código fuente Python que realizar cierta operación dada.
 RETURN, es la sentencia return en código Python.
 EXPRESION, es la expresión o variable que devuelve la sentencia return.
Un ejemplo simple de función esta seguidamente:
>>> def hola(arg):
... """El docstring de la función"""
... print "Hola", arg, "!"
...
>>> hola("Plone")
Hola Plone !
Advertencia
Los bloques de function deben estar indentado como otros bloques estructuras de control.
La palabra reservada def se usa para definir funciones. Debe seguirle el nombre de la función en el ejemplo anterior hola() y la lista de
parámetros formales entre paréntesis. Las sentencias que forman el cuerpo de la función empiezan en la línea siguiente, y deben estar
indentado.
La primer sentencia del cuerpo de la función puede ser opcionalmente una cadenas de caracteres literal; esta es la cadenas de caracteres de
documentación de la función, o docstrings. (Puedes encontrar más acerca de docstrings en la sección Cadenas de texto de documentación).
Hay herramientas que usan las docstrings para producir automáticamente documentación en línea o imprimible, o para permitirle al usuario que
navegue el código en forma interactiva; es una buena práctica incluir docstrings en el código que uno escribe, por lo que se debe hacer un
hábito de esto.
La ejecución de la función hola() muestra la impresión de un mensaje Hola Plone ! que se imprime por consola. Devolver el objeto por los
valores de retorno opcionales.
La ejecución de una función introduce una nueva tabla de símbolos usada para las variables locales de la función. Más precisamente, todas las
asignaciones de variables en la función almacenan el valor en la tabla de símbolos local; así mismo la referencia a variables primero mira la
tabla de símbolos local, luego en la tabla de símbolos local de las funciones externas, luego la tabla de símbolos global, y finalmente la tabla de
nombres predefinidos. Así, no se les puede asignar directamente un valor a las variables globales dentro de una función (a menos se las
nombre en la sentencia global), aunque si pueden ser referenciadas.
Los parámetros reales (argumentos) de una función se introducen en la tabla de símbolos local de la función llamada cuando esta es
ejecutada; así, los argumentos son pasados por valor (dónde el valor es siempre una referencia a un objeto, no el valor del objeto). Cuando
una función llama a otra función, una nueva tabla de símbolos local es creada para esa llamada.
La definición de una función introduce el nombre de la función en la tabla de símbolos actual. El valor del nombre de la función tiene un tipo
que es reconocido por el interprete como una función definida por el usuario. Este valor puede ser asignado a otro nombre que luego puede ser
usado como una función. Esto sirve como un mecanismo general para renombrar.
5.2.2. Argumentos y parámetros
Al definir una función los valores los cuales se reciben se denominan parámetros, pero durante la llamada los valores que se envían se
denominan argumentos.
5.2.2.1. Por posición
Cuando enviá argumentos a una función, estos se reciben por orden en los parámetros definidos. Se dice por tanto que son argumentos por
posición:
>>> def resta(a, b):
... return a - b
...
>>> resta(30, 10)
20
En el ejemplo anterior el argumento 30 es la posición 0 por consiguiente es el parámetro de la función a, seguidamente el argumento 10 es la
posición 1 por consiguiente es el parámetro de la función b.
5.2.2.2. Por nombre
Sin embargo es posible evadir el orden de los parámetros si indica durante la llamada que valor tiene cada parámetro a partir de su nombre:
... return a - b
...
>>> (b=30, a=10)
-20
5.2.2.3. Llamada sin argumentos
Al momento de llamar una función la cual tiene definidos unos parámetros, si no pasa los argumentos correctamente provocará una
excepción TypeError:
>>> resta()
Traceback (most recent call last):

File "<stdin>", line 1, in <module>
TypeError: resta() takes exactly 2 arguments (0 given)
5.2.2.4. Parámetros por defecto
Para solucionar la excepción TypeError ejecutada al momento de la llamada a una función sin argumentos, entonces usted puede asignar unos
valores por defecto nulos a los parámetros, de esa forma puede hacer una comprobación antes de ejecutar el código de la función:
>>> def resta(a=None, b=None):
... if a == None or b == None:
... print "Error, debes enviar dos números a la función"
... return
... return a - b
...
>>> resta(30, 10)
20
>>> resta()
Error, debes enviar dos números a la función
Como puede ver el el código anterior, se indica el final de la función luego de la sentencia print, usando la sentencia return aunque no devuelva
nada.
5.2.3. Argumentos indeterminados
En alguna ocasión usted no sabe previamente cuantos elementos necesita enviar a una función. En estos casos puede utilizar los parámetros
indeterminados por posición y por nombre.
Usted debe crear una lista dinámica de argumentos, es decir, un tipo tupla, definiendo el parámetro con un asterisco, para recibir los
parámetros indeterminados por posición:
>>> def indeterminados_posicion(*args):
... for arg in args:
... print arg
...
>>> indeterminados_posicion(5,"Hola Plone",[1,2,3,4,5])
Hola Plone
[1, 2, 3, 4, 5]
5.2.3.2. Por nombre
Para recibir un número indeterminado de parámetros por nombre (clave-valor o en inglés keyword args), usted debe crear un diccionario
dinámico de argumentos definiendo el parámetro con dos asteriscos:
>>> def indeterminados_nombre(**kwargs):
... print kwargs
...
>>> indeterminados_nombre(n=5, c="Hola Plone", l=[1,2,3,4,5])

{'c': 'Hola Plone', 'l': [1, 2, 3, 4, 5], 'n': 5}
Al recibirse como un diccionario, puede iterarlo y mostrar la clave y valor de cada argumento:
... for kwarg in kwargs:
... print kwarg, "=>", kwargs[kwarg]
...
c => Hola Plone
l => [1, 2, 3, 4, 5]
n => 5
5.2.3.3. Por posición y nombre
Si requiere aceptar ambos tipos de parámetros simultáneamente en una función, entonces debe crear ambas colecciones dinámicas. Primero
los argumentos indeterminados por valor y luego los cuales son por clave y valor:
>>> def super_funcion(*args,**kwargs):
... total = 0
... total += arg
... print "sumatorio => ", total
...
>>> super_funcion(50, -1, 1.56, 10, 20, 300, cms="Plone", edad=38)
sumatorio => 380.56
edad => 38
cms => Plone
Los nombres args y kwargs no son obligatorios, pero se suelen utilizar por convención.
Muchos frameworks y librerías los utilizan por lo que es una buena practica llamarlos así.
5.2.4. Sentencia pass
Es una operación nula — cuando es ejecutada, nada sucede. Eso es útil como un contenedor cuando una sentencia es requerida
sintácticamente, pero no necesita código que ser ejecutado, por ejemplo:
>>> # una función que no hace nada (aun)
... def consultar_nombre_genero(letra_genero): pass
...
>>> type(consultar_nombre_genero)
<type 'function'>
>>> consultar_nombre_genero("M")
>>>
>>> # una clase sin ningún método (aun)
... class Persona: pass
...
>>> macagua = Persona
>>> type(macagua)
<type 'classobj'>
5.2.5. Sentencia return
Las funciones pueden comunicarse con el exterior de las mismas, al proceso principal del programa usando la sentencia return. El proceso de
comunicación con el exterior se hace devolviendo valores. A continuación, un ejemplo de función usando return:
def suma(numero1,numero2):
'''función la cual suma dos números'''
print numero1 + numero2
print "\n"
Esta función se llama de la siguiente forma:
>>> suma(23,74)
97
Nota
Por defecto, las funciones retorna el valor None.
5.2.5.1. Retorno múltiple
Una característica interesante, es la posibilidad de devolver valores múltiples separados por comas:
>>> def prueba():
... return "Plone CMS", 20, [1,2,3]
...
>>> prueba()
('Plone CMS', 20, [1, 2, 3])
En el código anterior los valores múltiples se tratan en conjunto como una tupla inmutable y se pueden reasignar a distintas variables:
>>> def prueba():
...
>>> prueba()
('Plone CMS', 20, [1, 2, 3])
>>> cadena, numero, lista = prueba()
>>> print cadena, type(cadena)
Plone CMS <type 'str'>
>>> print numero, type(numero)
20 <type 'int'>
>>> print lista, type(lista)
[1, 2, 3] <type 'list'>
En el código anterior puede observa como se asignar a distintas variables en base a los valores de la tupla inmutable.
5.2.6. Ejemplos de funciones
A continuación, se presentan algunos ejemplos de su uso:
Definición de funciones
A continuación, se presenta un ejemplo del uso de definir funciones:
def iva():
'''función básica para el calculo del IVA'''
iva = 12
costo = input('¿Cual es el monto a calcular?: ')
calculo = costo * iva / 100
print "El calculo de IVA es: " + str(calculo) + "\n"
Invocar funciones
A continuación, se presenta un ejemplo del uso de llamar funciones:
>>> iva()
¿Cual es el monto a calcular?: 300
36
Funciones con argumentos múltiple
A continuación, se presenta un ejemplo del uso de funciones con argumentos múltiple:
print "\n"
Y se llama de la siguiente forma:
>>> suma(23,74)
97
Importante
Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco
Para ejecutar el código funciones.py, abra una consola de comando, acceda al directorio donde se encuentra el mismo, y ejecute el siguiente
comando:
python funciones.py
Ver también
Consulte la sección de lecturas suplementarias del entrenamiento para ampliar su conocimiento en esta temática.
5.2. Funciones
Una función es un bloque de código con un nombre asociado, que recibe cero o más argumentos como entrada, sigue una secuencia de
sentencias, la cuales ejecuta una operación deseada y devuelve un valor y/o realiza una tarea, este bloque puede ser llamados cuando se
necesite.
El uso de funciones es un componente muy importante del paradigma de la programación llamada estructurada, y tiene varias ventajas:
 modularización: permite segmentar un programa complejo en una serie de partes o módulos más simples, facilitando así la
programación y el depurado.
 reutilización: permite reutilizar una misma función en distintos programas.
Python dispone de una serie de funciones integradas al lenguaje, y también permite crear funciones definidas por el usuario para ser usadas en
su propios programas.
5.2.1. Sentencia def
La sentencia def es una definición de función usada para crear objetos funciones definidas por el usuario.
Una definición de función es una sentencia ejecutable. Su ejecución enlaza el nombre de la función en el namespace local actual a un objecto
función (un envoltorio alrededor del código ejecutable para la función). Este objeto función contiene una referencia al namespace local global
como el namespace global para ser usado cuando la función es llamada.
La definición de función no ejecuta el cuerpo de la función; esto es ejecutado solamente cuando la función es llamada.
La sintaxis para una definición de función en Python es:
def NOMBRE(LISTA_DE_PARAMETROS):
"""DOCSTRING_DE_FUNCION"""
SENTENCIAS
RETURN [EXPRESION]
A continuación se detallan el significado de pseudo código fuente anterior:
 NOMBRE, es el nombre de la función.

 LISTA_DE_PARAMETROS, es la lista de parámetros que puede recibir una función.
 DOCSTRING_DE_FUNCION, es la cadena de caracteres usada para documentar la función.
 SENTENCIAS, es el bloque de sentencias en código fuente Python que realizar cierta operación dada.
 RETURN, es la sentencia return en código Python.
 EXPRESION, es la expresión o variable que devuelve la sentencia return.
Un ejemplo simple de función esta seguidamente:
>>> def hola(arg):
... """El docstring de la función"""
... print "Hola", arg, "!"
...
>>> hola("Plone")
Hola Plone !
Advertencia
Los bloques de function deben estar indentado como otros bloques estructuras de control.
La palabra reservada def se usa para definir funciones. Debe seguirle el nombre de la función en el ejemplo anterior hola() y la lista de
parámetros formales entre paréntesis. Las sentencias que forman el cuerpo de la función empiezan en la línea siguiente, y deben estar
indentado.
La primer sentencia del cuerpo de la función puede ser opcionalmente una cadenas de caracteres literal; esta es la cadenas de caracteres de
documentación de la función, o docstrings. (Puedes encontrar más acerca de docstrings en la sección Cadenas de texto de documentación).
Hay herramientas que usan las docstrings para producir automáticamente documentación en línea o imprimible, o para permitirle al usuario que
navegue el código en forma interactiva; es una buena práctica incluir docstrings en el código que uno escribe, por lo que se debe hacer un
hábito de esto.
La ejecución de la función hola() muestra la impresión de un mensaje Hola Plone ! que se imprime por consola. Devolver el objeto por los
valores de retorno opcionales.
La ejecución de una función introduce una nueva tabla de símbolos usada para las variables locales de la función. Más precisamente, todas las
asignaciones de variables en la función almacenan el valor en la tabla de símbolos local; así mismo la referencia a variables primero mira la
tabla de símbolos local, luego en la tabla de símbolos local de las funciones externas, luego la tabla de símbolos global, y finalmente la tabla de
nombres predefinidos. Así, no se les puede asignar directamente un valor a las variables globales dentro de una función (a menos se las
nombre en la sentencia global), aunque si pueden ser referenciadas.
Los parámetros reales (argumentos) de una función se introducen en la tabla de símbolos local de la función llamada cuando esta es
ejecutada; así, los argumentos son pasados por valor (dónde el valor es siempre una referencia a un objeto, no el valor del objeto). Cuando
una función llama a otra función, una nueva tabla de símbolos local es creada para esa llamada.
La definición de una función introduce el nombre de la función en la tabla de símbolos actual. El valor del nombre de la función tiene un tipo
que es reconocido por el interprete como una función definida por el usuario. Este valor puede ser asignado a otro nombre que luego puede ser
usado como una función. Esto sirve como un mecanismo general para renombrar.
5.2.2. Argumentos y parámetros
Al definir una función los valores los cuales se reciben se denominan parámetros, pero durante la llamada los valores que se envían se
denominan argumentos.
Cuando enviá argumentos a una función, estos se reciben por orden en los parámetros definidos. Se dice por tanto que son argumentos por
posición:
... return a - b
...
>>> resta(30, 10)
20
En el ejemplo anterior el argumento 30 es la posición 0 por consiguiente es el parámetro de la función a, seguidamente el argumento 10 es la
posición 1 por consiguiente es el parámetro de la función b.
5.2.2.2. Por nombre
Sin embargo es posible evadir el orden de los parámetros si indica durante la llamada que valor tiene cada parámetro a partir de su nombre:
... return a - b
...
>>> (b=30, a=10)
-20
5.2.2.3. Llamada sin argumentos
Al momento de llamar una función la cual tiene definidos unos parámetros, si no pasa los argumentos correctamente provocará una
excepción TypeError:
>>> resta()
TypeError: resta() takes exactly 2 arguments (0 given)
5.2.2.4. Parámetros por defecto

Para solucionar la excepción TypeError ejecutada al momento de la llamada a una función sin argumentos, entonces usted puede asignar unos
valores por defecto nulos a los parámetros, de esa forma puede hacer una comprobación antes de ejecutar el código de la función:
>>> def resta(a=None, b=None):
... if a == None or b == None:
... print "Error, debes enviar dos números a la función"
... return
... return a - b
...
>>> resta(30, 10)
20
>>> resta()
Error, debes enviar dos números a la función
Como puede ver el el código anterior, se indica el final de la función luego de la sentencia print, usando la sentencia return aunque no devuelva
nada.
5.2.3. Argumentos indeterminados
En alguna ocasión usted no sabe previamente cuantos elementos necesita enviar a una función. En estos casos puede utilizar los parámetros
indeterminados por posición y por nombre.
Usted debe crear una lista dinámica de argumentos, es decir, un tipo tupla, definiendo el parámetro con un asterisco, para recibir los
parámetros indeterminados por posición:
>>> def indeterminados_posicion(*args):
... print arg
...
>>> indeterminados_posicion(5,"Hola Plone",[1,2,3,4,5])
Hola Plone
[1, 2, 3, 4, 5]
5.2.3.2. Por nombre
Para recibir un número indeterminado de parámetros por nombre (clave-valor o en inglés keyword args), usted debe crear un diccionario
dinámico de argumentos definiendo el parámetro con dos asteriscos:
... print kwargs
...
{'c': 'Hola Plone', 'l': [1, 2, 3, 4, 5], 'n': 5}
Al recibirse como un diccionario, puede iterarlo y mostrar la clave y valor de cada argumento:

...
c => Hola Plone
l => [1, 2, 3, 4, 5]
n => 5
5.2.3.3. Por posición y nombre
Si requiere aceptar ambos tipos de parámetros simultáneamente en una función, entonces debe crear ambas colecciones dinámicas. Primero
los argumentos indeterminados por valor y luego los cuales son por clave y valor:
>>> def super_funcion(*args,**kwargs):
... total = 0
... total += arg
... print "sumatorio => ", total
...
>>> super_funcion(50, -1, 1.56, 10, 20, 300, cms="Plone", edad=38)
sumatorio => 380.56
edad => 38
cms => Plone
Los nombres args y kwargs no son obligatorios, pero se suelen utilizar por convención.
Muchos frameworks y librerías los utilizan por lo que es una buena practica llamarlos así.
5.2.4. Sentencia pass
Es una operación nula — cuando es ejecutada, nada sucede. Eso es útil como un contenedor cuando una sentencia es requerida
sintácticamente, pero no necesita código que ser ejecutado, por ejemplo:
>>> # una función que no hace nada (aun)
... def consultar_nombre_genero(letra_genero): pass
...
>>> type(consultar_nombre_genero)
<type 'function'>
>>> consultar_nombre_genero("M")
>>>
>>> # una clase sin ningún método (aun)
... class Persona: pass
...
>>> type(macagua)
<type 'classobj'>
5.2.5. Sentencia return
Las funciones pueden comunicarse con el exterior de las mismas, al proceso principal del programa usando la sentencia return. El proceso de
comunicación con el exterior se hace devolviendo valores. A continuación, un ejemplo de función usando return:
print "\n"
Esta función se llama de la siguiente forma:
>>> suma(23,74)
97
Nota
Por defecto, las funciones retorna el valor None.
5.2.5.1. Retorno múltiple
Una característica interesante, es la posibilidad de devolver valores múltiples separados por comas:
>>> def prueba():
...
>>> prueba()
('Plone CMS', 20, [1, 2, 3])
En el código anterior los valores múltiples se tratan en conjunto como una tupla inmutable y se pueden reasignar a distintas variables:
>>> def prueba():
...
>>> prueba()
('Plone CMS', 20, [1, 2, 3])
>>> cadena, numero, lista = prueba()
>>> print cadena, type(cadena)
Plone CMS <type 'str'>
>>> print numero, type(numero)
20 <type 'int'>
>>> print lista, type(lista)
[1, 2, 3] <type 'list'>
En el código anterior puede observa como se asignar a distintas variables en base a los valores de la tupla inmutable.
5.2.6. Ejemplos de funciones
Definición de funciones
A continuación, se presenta un ejemplo del uso de definir funciones:
def iva():
'''función básica para el calculo del IVA'''
iva = 12
costo = input('¿Cual es el monto a calcular?: ')
calculo = costo * iva / 100
print "El calculo de IVA es: " + str(calculo) + "\n"
Invocar funciones
A continuación, se presenta un ejemplo del uso de llamar funciones:
>>> iva()
¿Cual es el monto a calcular?: 300
36
Funciones con argumentos múltiple
A continuación, se presenta un ejemplo del uso de funciones con argumentos múltiple:
print "\n"
Y se llama de la siguiente forma:
>>> suma(23,74)
97
Importante
Truco
Para ejecutar el código funciones.py, abra una consola de comando, acceda al directorio donde se encuentra el mismo, y ejecute el siguiente
comando:
python funciones.py
Ver también
3.11. Tipo diccionarios
El diccionario, define una relación uno a uno entre claves y valores.
Clase Tipo Notas Ejemplo
dict Mapeos Mutable, sin orden. {'cms':"Plone",'version':5}

Un objeto mapping mapea valores hashable a objetos arbitrariamente. Los objetos Mapeos son objetos mutable.
El diccionario es el único tipo de mapeo estándar actual. Para otro contenedores ver los integrados en las clases “lista”,
“conjuntos”, y “tupla”, y el modulo “collections”.
Los diccionarios pueden ser creados colocando una lista separada por coma de pares “key:value” entre {}, por ejemplo:
“{'python': 27, 'plone': 51}” o “{27:'python',51:'plone'}”, o por el constructor “dict()”.
>>> diccionario = {
... "clave1":234,
... "clave2":True,
... "clave3":"Valor 1",
... "clave4":[1,2,3,4]
... }
>>> print diccionario, type(diccionario)
{'clave4': [1, 2, 3, 4], 'clave1': 234,
'clave3': 'Valor 1', 'clave2': True} <type 'dict'>
Usted puede acceder a los valores del diccionario usando cada su clave, se presenta unos ejemplos a continuación:
>>> diccionario['clave1']
234
True
'Valor 1'
[1, 2, 3, 4]
Un diccionario puede almacenar los diversos tipos de datos integrados en Python usando la función type(), usted puede pasar el
diccionario con la clave que usted desea determinar el tipo de dato, se presenta unos ejemplos a continuación:
>>> type(diccionario['clave1'])
<type 'int'>
<type 'bool'>
<type 'str'>
<type 'list'>
3.11.1. Operaciones
Los objetos de tipo diccionario permite una serie de operaciones usando operadores integrados en el interprete Python para su
tratamiento, a continuación algunos de estos:
3.11.1.1. Acceder a valor de clave
Esta operación le permite acceder a un valor especifico del diccionario mediante su clave.
>>> versiones = dict(python=2.7, zope=2.13, plone=5.1, django=2.1)
>>> versiones['zope']
2.13
3.11.1.2. Asignar valor a clave
Esta operación le permite asignar el valor especifico del diccionario mediante su clave.
>>> versiones = {'python': 2.7, 'zope': 2.13, 'plone': None}
>>> versiones['plone']
>>> versiones['plone'] = 5.1
>>> versiones
{'python': 2.7, 'zope': 2.13, 'plone': 5.1}
>>> versiones['plone']
5.1
3.11.1.3. Iteración in
Este operador es el mismo operador integrado in en el interprete Python pero aplicada al uso de la secuencia de
tipo diccionario.
>>> print versiones
{'zope': 2.13, 'python': 2.7, 'plone': 5.1, 'django': 2.1}
>>> 'plone' in versiones
True
>>> 'flask' in versiones
False
En el ejemplo anterior este operador devuelve True si la clave esta en el diccionario versiones, de lo contrario devuelve False.
3.11.2. Métodos
Los objetos de tipo diccionario integra una serie de métodos integrados a continuación:
3.11.2.1. clear()
Este método remueve todos los elementos desde el diccionario.
>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> print versiones
{'zope': 2.13, 'python': 2.7, 'plone': 5.1}
>>> versiones.clear()
>>> print versiones
{}
3.11.2.2. copy()
Este método devuelve una copia superficial del tipo diccionario:
>>> otro_versiones = versiones.copy()
>>> versiones == otro_versiones
True
3.11.2.3. fromkeys()
Este método crea un nuevo diccionario con claves a partir de un tipo de dato secuencia. El valor de value por defecto es el
tipo None.
>>> secuencia = ('python', 'zope', 'plone')
>>> versiones = dict.fromkeys(secuencia)
>>> print "Nuevo Diccionario : %s" % str(versiones)
Nuevo Diccionario : {'python': None, 'zope': None, 'plone': None}
En el ejemplo anterior inicializa los valores de cada clave a None, mas puede inicializar un valorcomún por defecto para
cada clave:
>>> versiones = dict.fromkeys(secuencia, 0.1)
>>> print "Nuevo Diccionario : %s" % str(versiones)
Nuevo Diccionario : {'python': 0.1, 'zope': 0.1, 'plone': 0.1}

3.11.2.4. get()
Este método devuelve el valor en base a una coincidencia de búsqueda en un diccionario mediante una clave, de lo contrario
devuelve el objeto None.
>>> versiones.get('plone')
5.1
>>> versiones.get('php')
>>>
3.11.2.5. has_key()
Este método devuelve el valor True si el diccionario tiene presente la clave enviada como argumento.
>>> versiones.has_key('plone')
True
>>> versiones.has_key('django')
False
3.11.2.6. items()
Este método devuelve una lista de pares de diccionarios (clave, valor), como 2 tuplas.
>>> versiones.items()
[('zope', 2.13), ('python', 2.7), ('plone', 5.1)]
3.11.2.7. iteritems()
Este método devuelve un iterador sobre los elementos (clave, valor) del diccionario. Lanza una excepción StopIteration si llega al
final de la posición del diccionario.
>>> print versiones
>>> versiones.iteritems()
<dictionary-itemiterator object at 0x7fab9dd4bc58>
>>> for clave,valor in versiones.iteritems():
... print clave,valor

...
zope 2.13
python 2.7
plone 5.1
>>> versionesIterador = versiones.iteritems()
>>> print versionesIterador.next()
('zope', 2.13)
('python', 2.7)
('plone', 5.1)
StopIteration
3.11.2.8. iterkeys()
Este método devuelve un iterador sobre las claves del diccionario. Lanza una excepción StopIterationsi llega al final de la
posición del diccionario.
>>> print versiones
>>> versiones.iterkeys()
<dictionary-keyiterator object at 0x7fab9dd4bcb0>
>>> for clave in versiones.iterkeys():
... print clave
...
zope
python
plone
>>> versionesIterador = versiones.iterkeys()

zope
python
plone
StopIteration
3.11.2.9. itervalues()
Este método devuelve un iterador sobre los valores del diccionario. Lanza una excepción StopIteration si llega al final de la
posición del diccionario.
>>> print versiones
>>> versiones.itervalues()
<dictionary-valueiterator object at 0x7fab9dd4bc58>
>>> for valor in versiones.itervalues():
... print valor
...
2.13
2.7
5.1
>>> versionesIterador = versiones.itervalues()
2.13
2.7

5.1
StopIteration
3.11.2.10. keys()
Este método devuelve una lista de las claves del diccionario:
>>> versiones.keys()
['zope', 'python', 'plone']
3.11.2.11. pop()
Este método remueve específicamente una clave de diccionario y devuelve valor correspondiente. Lanza una
excepción KeyError si la clave no es encontrada.
>>> versiones
>>> versiones.pop('zope')
2.13
>>> versiones
{'python': 2.7, 'plone': 5.1}
>>> versiones.pop('django')
KeyError: 'django'
3.11.2.12. popitem()
Este método remueve y devuelve algún par (clave, valor) del diccionario como una 2 tuplas. Lanza una excepción KeyError si
el diccionario esta vació.
>>> versiones

>>> versiones.popitem()
('zope', 2.13)
>>> versiones
{'python': 2.7, 'plone': 5.1}
('python', 2.7)
>>> versiones
{'plone': 5.1}
('plone', 5.1)
>>> versiones
{}
KeyError: 'popitem(): dictionary is empty'
3.11.2.13. setdefault()
Este método es similar a get(key, default_value), pero además asigna la clave key al valor por default_value para la clave si esta
no se encuentra en el diccionario.
D.setdefault(key[,default_value])
A continuación un ejemplo de como trabaja el método setdefault() cuando la clave esta en el diccionario:
>>> zope = versiones.setdefault('zope')
>>> print 'Versiones instaladas:', versiones
Versiones instaladas: {'zope': 2.13, 'python': 2.7, 'plone': 5.1}
>>> print 'Versión de Zope:', zope
Versión de Zope: 2.13
A continuación un ejemplo de como trabaja el método setdefault() la clave no esta en el diccionario:
>>> paquetes = {'python': 2.7, 'zope': 2.13}
>>> print paquetes

{'python': 2.7, 'zope': 2.13}
>>> plone = paquetes.setdefault('plone')
>>> print 'paquetes: ', paquetes
paquetes: {'python': 2.7, 'zope': 2.13, 'plone': None}
>>> print 'plone: ', plone
plone: None
Si el valor no es proveído, el valor default_value será el tipo objeto integrado None.
A continuación un ejemplo de como trabaja el método setdefault() la clave no esta en el diccionario pero esta vez
el default_value es proveído:
>>> pkgs = {'python': 2.7, 'zope': 2.13, 'plone': None}
>>> print pkgs
{'python': 2.7, 'zope': 2.13, 'plone': None}
>>> django = paquetes.setdefault('django', 2.1)
>>> print 'paquetes =', pkgs
paquetes = {'python': 2.7, 'zope': 2.13, 'plone': None}
>>> print 'django =', django
django = 2.1
A continuación otro ejemplo en donde puedes agrupar N tuplas por el valor el cual se repite más y construir un diccionario que
cuyas claves son los valores mas repetidos y cuyos valores este agrupados en tipo listas:
>>> PKGS = (('zope', 'Zope2'),
... ('zope', 'pytz'),
... ('plone', 'Plone'),
... ('plone', 'diazo'),
... ('plone', 'z3c.form'),)
>>>
>>> paquetes = {}
>>> for clave, valor in PKGS:
... if paquetes.has_key(clave):
... paquetes[clave].append(valor)
... else:
... paquetes[clave] = [valor]

...
>>> print paquetes
{'zope': ['Zope2', 'pytz'], 'plone': ['Plone', 'diazo', 'z3c.form']}
En el tipo tupla PKGS los elementos mas repetidos son 'zope' y 'plone' estos se convierten en clave del diccionario paquetes y
los otros elementos se agrepan en listas como sus respectivos valores.
A continuación un mejor aprovechamiento implementando el método setdefault():
>>> PKGS = (('zope', 'Zope2'),
... ('zope', 'pytz'),
... ('plone', 'Plone'),
... ('plone', 'diazo'),
... ('plone', 'z3c.form'),)
>>> paquetes = {}
>>> for clave, valor in PKGS:
... paquetes.setdefault(clave, []).append(valor)
...
>>> print paquetes
{'zope': ['Zope2', 'pytz'], 'plone': ['Plone', 'diazo', 'z3c.form']}
En el ejemplo anterior puede ver que el aprovechamiento del método setdefault() a comparación de no usar el respectivo
método.
3.11.2.14. update()
Este método actualiza un diccionario agregando los pares clave-valores en un segundo diccionario. Este método no devuelve
nada.
El método update() toma un diccionario o un objeto iterable de pares clave/valor (generalmente tuplas). Si se llama a update() sin
pasar parámetros, el diccionario permanece sin cambios.
>>> print versiones
>>> versiones_adicional = dict(django=2.1)
>>> print versiones_adicional
{'django': 2.1}
>>> versiones.update(versiones_adicional)
Como puede apreciar este método no devuelve nada, más si muestra de nuevo el diccionarioversiones puede ver que este fue
actualizado con el otro diccionario versiones_adicional.
>>> print versiones
3.11.2.15. values()
Este método devuelve una lista de los valores del diccionario:
>>> versiones.values()
[2.13, 2.7, 5.1]
3.11.2.16. viewitems()
Este método devuelve un objeto como un conjunto mutable proveyendo una vista en los elementos del diccionario:
>>> versiones.viewkeys()
dict_keys(['zope', 'python', 'plone'])
>>> for clave,valor in versiones.iteritems():
... print clave,valor
...
zope 2.13
python 2.7
plone 5.1
3.11.2.17. viewkeys()
Este método devuelve un objeto proveyendo una vista de las claves del diccionario.
>>> versiones.viewkeys()
dict_keys(['zope', 'python', 'plone'])
>>> for clave in versiones.viewkeys():
... print clave
...
zope
python
plone
3.11.2.18. viewvalues()
Este método devuelve un objeto proveyendo una vista de los valores del diccionario.
>>> versiones.viewvalues()
dict_values([2.13, 2.7, 5.1])
>>> for valor in versiones.viewvalues():
... print valor
...
2.13
2.7
5.1
3.11.3. Funciones
Los objetos de tipo diccionario tienen disponibles una serie de funciones integradas en el interprete Python para su tratamiento,
a continuación algunas de estas:
3.11.3.1. cmp()
Esta función es la misma función integrada cmp() en el interprete Python pero aplicada al uso de la secuencia de
tipo diccionario.
>>> versiones_proyecto1 = dict(python=2.7, zope=2.13, plone=5.1)
>>> versiones_proyecto2 = dict(django=2.1, django-filter=1.1.0)
>>> print cmp(versiones_proyecto1, versiones_proyecto2)
La función cmp() es usado en Python para comparar valores y claves de dos diccionarios. Si la función devuelve el valor 0 si
ambos diccionarios son igual, devuelve el valor 1 si el primer diccionario es mayor que el segundo diccionario y devuelve el
valor -1 si el primer diccionario es menor que el segundo diccionario.
3.11.3.2. len()
Esta función es la misma función integrada len() en el interprete Python pero aplicada al uso de la secuencia de tipo diccionario.
>>> len(versiones)
3
3.11.4. Sentencias
Los objetos de tipo diccionario tienen disponibles una serie de sentencias integradas en el interprete Python para su
tratamiento, a continuación algunas de estas:
3.11.4.1. del
Esta sentencia es la misma sentencia integrada del en el interprete Python pero aplicada al uso de la secuencia de
tipo diccionario.
>>> print versiones
>>> del versiones['django']
>>> print versiones
En el código fuente anterior se usa la sentencia del para eliminar un elemento del diccionario mediante su respectiva clave.
3.11.5. Convertir a diccionarios
Para convertir a tipos diccionarios debe usar la función dict() la cual esta integrada en el interprete Python.
Truco
Para más información consulte las funciones integradas para operaciones de secuencias.
3.11.6. Ejemplos
A continuación, se presentan un ejemplo de su uso:
Ejemplo de definición de un diccionario
datos_basicos = {
"nombres":"Leonardo Jose",
"apellidos":"Caballero Garcia",
"cedula":"26938401",
"fecha_nacimiento":"03/12/1980",
"lugar_nacimiento":"Maracaibo, Zulia, Venezuela",
"nacionalidad":"Venezolana",
"estado_civil":"Soltero"
}
Ejemplo de operaciones con tipo diccionario con funciones propias
print "\nClaves de diccionario:", datos_basicos.keys()
print "\nValores de diccionario:", datos_basicos.values()
print "\nElementos de diccionario:", datos_basicos.items()
Ejemplo de iteración avanzada sobre diccionarios con función iteritems
for key, value in datos_basicos.iteritems():
print('Clave: %s, tiene el valor: %s' % (key, value))
Ejemplo real de usar tipo diccionario
print "\n\nInscripción de Curso"
print "===================="
print "\nDatos de participante"
print "---------------------"
print "Cédula de identidad: ", datos_basicos['cedula']
print "Nombre completo: " + datos_basicos['nombres'] + " " + \
datos_basicos['apellidos']
import datetime, locale, os
locale.setlocale(locale.LC_ALL, os.environ['LANG'])
print "Fecha y lugar de nacimiento:", datetime.datetime.strftime(
datetime.datetime.strptime(
datos_basicos['fecha_nacimiento'], '%d/%m/%Y'
), "%d de %B de %Y"
) + " en " + datos_basicos['lugar_nacimiento'] + "."
print "Nacionalidad:", datos_basicos['nacionalidad']
print "Estado civil:", datos_basicos['estado_civil']
3.11.7. Ayuda integrada
Usted puede consultar toda la documentación disponible sobre los diccionarios desde la consola interactiva de la siguiente
forma:
>>> help(dict)
Importante
Truco
Para ejecutar el código tipo_diccionarios.py, abra una consola de comando, acceda al directorio donde se encuentra el mismo, y
ejecute el siguiente comando:
python tipo_diccionarios.py
Ver también
3.12. Tipo conjuntos
Un conjunto, es una colección no ordenada y sin elementos repetidos. Los usos básicos de éstos incluyen verificación de
pertenencia y eliminación de entradas duplicadas.
Clase Tipo Notas Ejemplo

set Conjuntos Mutable, sin orden, no contiene duplicados. set([4.0, 'Carro', True])
frozenset Conjuntos Inmutable, sin orden, no contiene duplicados. frozenset([4.0, 'Carro',True])
3.12.1. Métodos
Los objetos de tipo conjunto mutable y conjunto inmutable integra una serie de métodos integrados a continuación:
3.12.1.1. add()
Este método agrega un elemento a un conjunto mutable. Esto no tiene efecto si el elemento ya esta presente.
>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])
>>> print set_mutable1
set([1, 2, 3, 4, 5, 7, 11])
>>> set_mutable1.add(22)
set([1, 2, 3, 4, 5, 7, 11, 22])
3.12.1.2. clear()
Este método remueve todos los elementos desde este conjunto mutable.
>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])
set([1, 2, 3, 4, 5, 7, 11])
>>> set_mutable1.clear()

set([])
3.12.1.3. copy()
Este método devuelve una copia superficial del tipo conjunto mutable o conjunto inmutable:
>>> set_mutable = set([4.0, 'Carro', True])
>>> otro_set_mutable = set_mutable.copy()
>>> set_mutable == otro_set_mutable
True
3.12.1.4. difference()
Este método devuelve la diferencia entre dos conjunto mutable o conjunto inmutable: todos los elementos que están en el
primero, pero no en el argumento.
>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])
>>> set_mutable2 = set([11, 5, 9, 2, 4, 8])
set([1, 2, 3, 4, 5, 7, 11])
set([2, 4, 5, 8, 9, 11])
>>> print set_mutable1.difference(set_mutable2)
set([1, 3, 7])
>>> print set_mutable2.difference(set_mutable1)
set([8, 9])
3.12.1.5. difference_update()
Este método actualiza un tipo conjunto mutable llamando al método difference_update()con la diferencia de los conjuntos.
>>> proyecto1 = {'python', 'Zope2', 'ZODB3', 'pytz'}
>>> proyecto1
set(['python', 'pytz', 'Zope2', 'ZODB3'])
>>> proyecto2 = {'python', 'Plone', 'diazo'}
>>> proyecto2
set(['python', 'diazo', 'Plone'])
>>> proyecto1.difference_update(proyecto2)
>>> proyecto1
set(['pytz', 'Zope2', 'ZODB3'])
Si proyecto1 y proyecto2 son dos conjuntos. La diferencia del conjunto proyecto1 y conjunto proyecto2 es un conjunto de
elementos que existen solamente en el conjunto proyecto1 pero no en el conjunto proyecto2.
3.12.1.6. discard()
Este método remueve un elemento desde un conjunto mutable si esta presente.
>>> paquetes = {'python', 'zope', 'plone', 'django'}
>>> paquetes
set(['python', 'zope', 'plone', 'django'])
>>> paquetes.discard('django')
>>> paquetes
set(['python', 'zope', 'plone'])
El conjunto mutable permanece sin cambio si el elemento pasado como argumento al método discard() no existe.
>>> paquetes.discard('php')
>>> paquetes
3.12.1.7. intersection()
Este método devuelve la intersección entre los conjuntos mutables o conjuntos inmutables: todos los elementos que están en
ambos.
>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])
>>> set_mutable2 = set([11, 5, 9, 2, 4, 8])
set([1, 2, 3, 4, 5, 7, 11])
set([2, 4, 5, 8, 9, 11])
>>> print set_mutable1.intersection(set_mutable2)
set([2, 11, 4, 5])
>>> print set_mutable2.intersection(set_mutable1)
set([2, 11, 4, 5])
3.12.1.8. intersection_update()
Este método actualiza un conjunto mutable con la intersección de ese mismo y otro conjunto mutable.
El método intersection_update() le permite arbitrariamente varios numero de argumentos (conjuntos).
>>> proyecto1 = {'python', 'Zope2', 'pytz'}
>>> proyecto1
set(['python', 'pytz', 'Zope2'])
>>> proyecto2 = {'python', 'Plone', 'diazo', 'z3c.form'}
>>> proyecto2
set(['python', 'z3c.form', 'diazo', 'Plone'])
>>> proyecto3 = {'python', 'django', 'django-filter'}

>>> proyecto3
set(['python', 'django-filter', 'django'])
>>> proyecto3.intersection_update(proyecto1, proyecto2)
>>> proyecto3
set(['python'])
La intersección de dos o mas conjuntos es el conjunto de elemento el cual es común a todos los conjuntos.
3.12.1.9. isdisjoint()
Este método devuelve el valor True si no hay elementos comunes entre los conjuntos mutables o conjuntos inmutables.
>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])
>>> set_mutable2 = set([11, 5, 9, 2, 4, 8])
set([1, 2, 3, 4, 5, 7, 11])
set([2, 4, 5, 8, 9, 11])
>>> print set_mutable1.isdisjoint(set_mutable2)
3.12.1.10. issubset()
Este método devuelve el valor True si el conjunto mutable es un subconjunto del conjunto mutable o del conjunto
inmutable argumento.
>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])
>>> set_mutable2 = set([11, 5, 9, 2, 4, 8])
>>> set_mutable3 = set([11, 5, 2, 4])
set([1, 2, 3, 4, 5, 7, 11])
set([2, 4, 5, 8, 9, 11])
set([2, 11, 4, 5])
>>> print set_mutable2.issubset(set_mutable1)
False
>>> print set_mutable3.issubset(set_mutable1)
True
3.12.1.11. issuperset()
Este método devuelve el valor True si el conjunto mutable o el conjunto inmutable es un supersetdel conjunto
mutable argumento.
>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])

>>> set_mutable2 = set([11, 5, 9, 2, 4, 8])
>>> set_mutable3 = set([11, 5, 2, 4])
set([1, 2, 3, 4, 5, 7, 11])
set([2, 4, 5, 8, 9, 11])
set([2, 11, 4, 5])
>>> print set_mutable1.issuperset(set_mutable2)
False
>>> print set_mutable1.issuperset(set_mutable3)
True
3.12.1.12. pop()
Este método remueve arbitrariamente y devuelve un elemento de conjunto mutable. El método pop() no toma ningún
argumento. Si el conjunto mutable esta vacío se lanza una excepción KeyError.
>>> paquetes
>>> print "Valor aleatorio devuelto es:", paquetes.pop()
Valor aleatorio devuelto es: python
>>> paquetes
set(['zope', 'plone', 'django'])
Valor aleatorio devuelto es: zope
>>> paquetes
set(['plone', 'django'])
Valor aleatorio devuelto es: plone
>>> paquetes
set(['django'])
Valor aleatorio devuelto es: django
Valor aleatorio devuelto es:

KeyError: 'pop from an empty set'
Tenga en cuenta que usted podría obtener diferente salida devueltas usando el método pop() por que remueve aleatoriamente
un elemento.
3.12.1.13. remove()
Este método busca y remueve un elemento de un conjunto mutable, si debe ser un miembro.
>>> paquetes
>>> paquetes.remove('django')
>>> paquetes
Si el elemento no es existe en el conjunto mutable, lanza una excepción KeyError. Usted puede usar el método discard() si
usted no quiere este error. El conjunto mutable permanece sin cambio si el elemento pasado al método discard() no existe.
Un conjunto es una colección desordenada de elementos. Si usted quiere remover arbitrariamente elemento un conjunto, usted
puede usar el método pop().
3.12.1.14. symmetric_difference()
Este método devuelve todos los elementos que están en un conjunto mutable e conjunto inmutable u otro, pero no en ambos.
>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])
>>> set_mutable2 = set([11, 5, 9, 2, 4, 8])
set([1, 2, 3, 4, 5, 7, 11])
set([2, 4, 5, 8, 9, 11])
>>> print set_mutable1.symmetric_difference(set_mutable2)
set([1, 3, 7, 8, 9])
3.12.1.15. symmetric_difference_update()
Este método actualiza un conjunto mutable llamando al métodosymmetric_difference_update() con los conjuntos de diferencia
simétrica.
La diferencia simétrica de dos conjuntos es el conjunto de elementos que están en cualquiera de los conjuntos pero no en
ambos.
>>> proyecto1 = {'python', 'plone', 'django'}
>>> proyecto1
set(['python', 'plone', 'django'])
>>> proyecto2 = {'django', 'zope', 'pyramid'}
>>> proyecto2
set(['zope', 'pyramid', 'django'])

>>> proyecto1.symmetric_difference_update(proyecto2)
>>> proyecto1
set(['python', 'zope', 'pyramid', 'plone'])
El método symmetric_difference_update() toma un argumento simple de un tipoconjunto mutable.
3.12.1.16. union()
Este método devuelve un conjunto mutable y conjunto inmutable con todos los elementos que están en alguno de
los conjuntos mutables y conjuntos inmutables.
>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])
>>> set_mutable2 = set([11, 5, 9, 2, 4, 8])
set([1, 2, 3, 4, 5, 7, 11])
set([2, 4, 5, 8, 9, 11])
>>> print set_mutable1.union(set_mutable2)
set([1, 2, 3, 4, 5, 7, 8, 9, 11])
3.12.1.17. update()
Este método agrega elementos desde un conjunto mutable (pasando como un argumento) un tipo tupla, un tipo lista, un
tipo diccionario o un tipo conjunto mutable llamado con el métodoupdate().
A continuación un ejemplo de agregar nuevos elementos un tipo conjunto mutable usando otro tipo conjunto mutable:
>>> version_plone_dev = set([5.1, 6])
>>> version_plone_dev
set([5.1, 6])
>>> versiones_plone = set([2.1, 2.5, 3.6, 4])
>>> versiones_plone
set([2.5, 3.6, 2.1, 4])
>>> versiones_plone.update(version_plone_dev)
>>> versiones_plone
set([2.5, 3.6, 4, 6, 5.1, 2.1])
A continuación un ejemplo de agregar nuevos elementos un tipo conjunto mutable usando otro tipo cadena de caracteres:
>>> cadena = 'abc'
>>> cadena
'abc'
>>> conjunto = {1, 2}
>>> conjunto.update(cadena)
>>> conjunto
set(['a', 1, 2, 'b', 'c'])
A continuación un ejemplo de agregar nuevos elementos un tipo conjunto mutable usando otro tipo diccionario:
>>> diccionario = {'key': 1, 2:'lock'}
>>> diccionario.viewitems()
dict_items([(2, 'lock'), ('key', 1)])
>>> conjunto = {'a', 'b'}
>>> conjunto.update(diccionario)
>>> conjunto
set(['a', 2, 'b', 'key'])
3.12.2. Convertir a conjuntos
Para convertir a tipos conjuntos debe usar las funciones set() y frozenset(), las cuales están integradas en el interprete Python.
Truco
Para más información consulte las funciones integradas para operaciones de secuencias.
3.12.3. Ejemplos
3.12.3.1. Conjuntos set
A continuación, se presentan un ejemplo de conjuntos set:
# crea un conjunto sin valores repetidos y lo asigna la variable
para_comer = set([
'pastel', 'tequeno', 'papa', 'empanada', 'mandoca'])
print para_comer, type(para_comer)
para_tomar = set(['refresco', 'malta', 'jugo', 'cafe'])
print para_tomar, type(para_tomar)
# usa operaciones condicionales con operador in
hay_tequeno = 'tequeno' in para_comer
hay_fresco = 'refresco' in para_tomar
print "\nTostadas A que Pipo!"
print "===================="
# valida si un elemento esta en el conjunto
print "Tenéis tequeno?:", 'tequeno' in para_comer
# valida si un elemento esta en el conjunto

print "Tenéis pa' tomar fresco?:", 'refresco' in para_tomar
if (hay_tequeno and hay_fresco):
print "Desayuno vergatario!!!"
else:
print "Desayuno ligero"
3.12.3.2. Conjuntos frozenset
A continuación, se presentan un ejemplo de conjuntos frozenset:
>>> versiones_plone = frozenset([6, 2.1, 2.5, 3.6, 4, 5, 4, 2.5])
>>> print versiones_plone, type(versiones_plone)
frozenset([2.5, 4, 5, 6, 2.1, 3.6]) <type 'frozenset'>
Los elementos de un set son únicos (sin repeticiones dentro del set), y deben ser objetos inmutables: números, cadenas de
caracteres, tuplas y sets inmutables, pero no listas ni sets mutables.
3.12.4. Ayuda integrada
Usted puede consultar toda la documentación disponible sobre los conjuntos set desde la consola interactiva de la siguiente
forma:
>>> help(set)
Usted puede consultar toda la documentación disponible sobre los conjuntos frozenset desde la consola interactiva de la
siguiente forma:
>>> help(frozenset)
Para salir de esa ayuda presione la tecla q.
Importante
Truco
Para ejecutar el código tipo_conjuntos.py, abra una consola de comando, acceda al directorio donde se encuentra el mismo, y
ejecute el siguiente comando:
python tipo_conjuntos.py
Ver también
5.3. Funciones avanzadas
En Python hay varias funciones avanzadas que se describen a continuación:
5.3.1. Funciones de predicado
Las funciones de predicado no es más que una función la cual dice si algo es True o False, es decir, es una función que
devuelve un tipo de datos booleano.
Por hacer
TODO terminar de escribir la sección Funciones de predicado.
5.3.2. Objetos de función

Por hacer
TODO escribir la sección Objetos de función.
5.3.3. Funciones anónimas
Una función anónima, como su nombre indica es una función sin nombre. Es decir, es posible ejecutar una función sin
referenciar un nombre, en Python puede ejecutar una función sin definirla con def.
De hecho son similares pero con una diferencia fundamental, el contenido de una función anónima debe ser una única
expresión en lugar de un bloque de acciones.
Las funciones anónimas se implementan en Python con las funciones o expresiones lambda, esta es unas de las funcionalidades
más potentes de Python, pero a la vez es la más confusas para los principiantes.
Más allá del sentido de función que usted tiene hasta el momento, con su nombre y sus acciones internas, una función en su
sentido más trivial significa realizar algo sobre algo. Por tanto se podría decir que, mientras las funciones
anónimas lambda sirven para realizar funciones simples, las funciones definidas con def sirven para manejar tareas más
extensas.
5.3.4. Expresión lambda
Si deconstruye una función sencilla, puede llegar a una función lambda. Por ejemplo la siguiente función es para doblar un valor
de un número:
>>> def doblar(numero):
... resultado = numero*2
... return resultado
>>> doblar(2)
>>> type(doblar)
<type 'function'>
Si el código fuente anterior se simplifica se verá, de la siguiente forma:
... return numero*2
>>> doblar(2)
>>> type(doblar)
<type 'function'>
Usted puede todavía simplificar más, escribirlo todo en una sola línea, de la siguiente forma:
>>> def doblar(numero): return numero*2

>>> lambda numero: numero*2
<function <lambda> at 0x7f1023944e60>
>>> doblar(2)
>>> type(doblar)
<type 'function'>
Esta notación simple es la que una función lambda intenta replicar, observe, a continuación se va a convertir la función en una
función anónima:
>>> lambda numero: numero*2
<function <lambda> at 0x7f1023944e60>
En este ejemplo tiene una función anónima con una entrada que recibe numero, y una salida que devuelve numero * 2.
Lo único que necesita hacer para utilizarla es guardarla en una variable y utilizarla tal como haría con una función normal:
>>> doblar = lambda numero: numero*2
>>> doblar(2)
>>> type(doblar)
<type 'function'>
Con la flexibilidad de Python usted puede implementar infinitas funciones simples. Usted puede encontrar más ejemplos de
funciones anónimas usando lambda en la sección ejemplos de funciones avanzadas.
Usted puede explotar al máximo la función lambda utilizándola en conjunto con otras funciones como filter() y map().
5.3.5. Ejemplos de funciones avanzadas
Función lambda - operaciones aritméticas
A continuación, se presenta un ejemplo para comprobar si un número es impar:
>>> impar = lambda numero: numero%2 != 0
>>> impar(5)
True
Función lambda - operaciones de cadena
A continuación, se presenta un ejemplo para darle la vuelta a una cadena rebanándola en sentido inverso:
>>> revertir = lambda cadena: cadena[::-1]
>>> revertir("Plone")
'enolP'
>>> revertir("enolP")
'Plone'
Función lambda - varios parámetros

A continuación, se presenta un ejemplo para varios parámetros, por ejemplo para sumar dos números:
>>> sumar = lambda x,y: x+y
>>> sumar(5,2)
Ver también
5.4. Funciones recursivas
Las funciones recursivas son funciones que se llaman a sí mismas durante su propia ejecución. Ellas funcionan de forma similar
a las iteraciones, pero debe encargarse de planificar el momento en que dejan de llamarse a sí mismas o tendrá una función
recursiva infinita.
Estas funciones se estilan utilizar para dividir una tarea en sub-tareas más simples de forma que sea más fácil abordar el
problema y solucionarlo.
5.4.1. Función recursiva sin retorno
Un ejemplo de una función recursiva sin retorno, es el ejemplo de cuenta regresiva hasta cero a partir de un número:
>>> def cuenta_regresiva(numero):
... numero -= 1
... if numero > 0:
... print numero
... cuenta_regresiva(numero)
... else:
... print "Boooooooom!"
... print "Fin de la función", numero
...
>>> cuenta_regresiva(5)
Boooooooom!
Fin de la función 0
5.4.2. Función recursiva con retorno

Un ejemplo de una función recursiva con retorno, es el ejemplo del calculo del factorial de un número corresponde al producto de
todos los números desde 1 hasta el propio número. Es el ejemplo con retorno más utilizado para mostrar la utilidad de este tipo
de funciones:
>>> def factorial(numero):
... print "Valor inicial ->",numero
... if numero > 1:
... numero = numero * factorial(numero -1)
... print "valor final ->",numero
... return numero
...
>>> print factorial(5)
Valor inicial -> 5
Valor inicial -> 4
Valor inicial -> 3
Valor inicial -> 2
Valor inicial -> 1
valor final -> 1
valor final -> 2
valor final -> 6
valor final -> 24
valor final -> 120
120
Por hacer
TODO terminar de escribir la sección Funciones recursivas.
Ver también
5.5. Funciones de orden superior
Las funciones de Python pueden tomar funciones como parámetros y devolver funciones como resultado. Una función que hace
ambas cosas o alguna de ellas se llama función de orden superior.
5.5.1. filter()
La función filter() es una función la cual toma un predicado y una lista y devuelve una lista con los elementos que satisfacen el
predicado. Tal como su nombre indica filter() significa filtrar, ya que a partir de una lista o iterador y una función condicional, es
capaz de devolver una nueva colección con los elementos filtrados que cumplan la condición.
Todo esto podría haberse logrado también usando listas por comprensión que usaran predicados. No hay ninguna regla que diga
cuando usar la función map() o la función filter() en lugar de laslistas por comprensión, simplemente debe decidir que es más
legible dependiendo del contexto.
Por ejemplo, suponga que tiene una lista varios números y requiere filtrarla, quedando únicamente con los números múltiples de
5, eso seria así:
>>> # Primero declaramos una función condicional
def multiple(numero):
# Comprobamos si un numero es múltiple de cinco
if numero % 5 == 0:
# Sólo devolvemos True si lo es
return True
>>> numeros = [2, 5, 10, 23, 50, 33]
>>> filter(multiple, numeros)
[5, 10, 50]
Si ejecuta el filtro obtiene una lista los números múltiples de 5. Por tanto cuando utiliza la función filter() tiene que enviar una
función condicional, para esto, puede utilizar una función anónima lambda, como se muestra a continuación:
>>> numeros = [2, 5, 10, 23, 50, 33]
>>> filter(lambda numero: numero%5 == 0, numeros)
[5, 10, 50]
Así, en una sola línea ha definido y ejecutado el filtro utilizando una función condicional anónima y devolviendo una lista de
números.
5.5.1.1. Filtrando objetos
Sin embargo, más allá de filtrar listas con valores simples, el verdadero potencial de la función filter() sale a relucir cuando usted
necesita filtrar varios objetos de una lista.
Por ejemplo, dada una lista con varias personas, a usted le gustaría filtrar únicamente las cuales son menores de edad:
>>> class Persona:
...
... def __init__(self, nombre, edad):
... self.nombre = nombre
... self.edad = edad
...
... def __str__(self):
... return "{} de {} años".format(self.nombre, self.edad)
...
>>> personas = [
... Persona("Leonardo", 38),
... Persona("Ana", 33),
... Persona("Sabrina", 12),
... Persona("Enrique", 3)
... ]
>>> menores = filter(lambda persona: persona.edad < 18, personas)
>>> for menor in menores:
print menor
Sabrina de 12 años
Enrique de 3 años
Este es un ejemplo sencillo, con el cual usted puede realizar filtrados con objetos, de forma amigable.
5.5.2. map()
La función map() toma una función y una lista y aplica esa función a cada elemento de esa lista, produciendo una nueva lista. Va
a ver su definición de tipo y como se define.
Esta función trabaja de una forma muy similar a filter(), con la diferencia que en lugar de aplicar una condición a un elemento de
una lista o secuencia, aplica una función sobre todos los elementos y como resultado se devuelve un lista de números doblado
su valor:
return numero*2
>>> numeros = [2, 5, 10, 23, 50, 33]
>>> map(doblar, numeros)
[4, 10, 20, 46, 100, 66]
Usted puede simplificar el código anterior usando una función lambda para substituir la llamada de una función definida, como se
muestra a continuación:
>>> map(lambda x: x*2, numeros)
[4, 10, 20, 46, 100, 66]
La función map() se utiliza mucho junto a expresiones lambda ya que permite evitar escribir bucles for.
Además se puede utilizar sobre más de un objeto iterable con la condición que tengan la misma longitud. Por ejemplo, si
requiere multiplicar los números de dos listas:
>>> a = [1, 2, 3, 4, 5]
>>> b = [6, 7, 8, 9, 10]
>>> map(lambda x,y : x*y, a,b)
[6, 14, 24, 36, 50]
E incluso usted puede extender la funcionalidad a tres listas o más:
>>> a = [1, 2, 3, 4, 5]
>>> b = [6, 7, 8, 9, 10]
>>> c = [11, 12, 13, 14, 15]
>>> map(lambda x,y,z : x*y*z, a,b,c)
[66, 168, 312, 504, 750]
5.5.2.1. Mapeando objetos

Evidentemente, siempre que la función map() la utilice correctamente podrá mapear una serie de objetos sin ningún problema:
>>> class Persona:
...
...
...
>>> personas = [
... ]
>>> def incrementar(p):
... p.edad += 1
... return p
...
>>> personas = map(incrementar, personas)
>>> for persona in personas:
... print persona
...
Leonardo de 39 años
Ana de 34 años
Sabrina de 13 años
Enrique de 4 años
Claro que en este caso tiene que utilizar una función definida porque no necesitamos actuar sobre la instancia, a no ser que
usted se tome la molestia de rehacer todo el objeto:
>>> class Persona:
...
...
...
>>> personas = [
... ]
>>> def incrementar(p):
... p.edad += 1
... return p
...
>>> personas = map(lambda p: Persona(p.nombre, p.edad+1), personas)
>>> for persona in personas:
... print persona
...
Leonardo de 39 años
Ana de 34 años
Sabrina de 13 años
Enrique de 4 años
5.5.3. lambda
La expresión lambda, es una función anónima que suelen ser usadas cuando necesita una función una sola vez. Normalmente
usted crea funciones lambda con el único propósito de pasarlas a funciones de orden superior.
En muchos lenguajes, el uso de lambdas sobre funciones definidas causa problemas de rendimiento. No es el caso en Python.
>>> import os
>>> archivos = os.listdir(os.__file__.replace("/os.pyc", "/"))
>>> print filter(lambda x: x.startswith('os.'), archivos)
['os.pyc', 'os.py']
En el ejemplo anterior se usa el método os.__file__ para obtener la ruta donde esta instalada el módulo os en su sistema,
ejecutando la siguiente sentencia:
>>> os.__file__
'/usr/lib/python2.7/os.pyc'
Si con el método os.__file__ obtiene la ruta del módulo os con el métodoreplace("/os.pyc", "/") busca la cadena de carácter
“/os.pyc” y la remplaza por la cadena de carácter “/”
>>> os.__file__.replace("/os.pyc", "/")

'/usr/lib/python2.7/'
Luego se define la variable archivos generando una lista de archivos usando la función os.listdir(), pasando el parámetro
obtenido de la ruta donde se instalo el módulo osejecutando en el comando previo, con la siguiente sentencia:
>>> archivos = os.listdir("/usr/lib/python2.7/")
De esta forma se define en la variable archivos un tipo lista con un tamaño de 433, como se puede comprobar a continuación:
>>> type(archivos)
<type 'list'>
>>> len(archivos)
443
Opcionalmente puede comprobar si la cadena de caracteres os.pyc se encuentras una de las posiciones de la lista archivos,
ejecutando la siguiente sentencia:
>>> "os.pyc" in archivos
True
Ya al comprobar que existe la cadena de caracteres “os.pyc” se usa una función lambda como parámetro de la
función filter() para filtrar todos los archivos del directorio “/usr/lib/python2.7/” por medio del función os.listdir() que inicien con la
cadena de caracteres “os.” usando la función startswith().
>>> print filter(lambda x: x.startswith('os.'), os.listdir('/usr/lib/python2.7/'))
['os.pyc', 'os.py']
Así de esta forma se comprueba que existe el archivo compilado “os.pyc” de Python junto con el mismo módulo Python “os.py”.
Truco
Más detalle consulte la referencia de las expresiones lambda.
Ver también
5.6. Funciones integradas
El interprete Python tiene un número de funciones integradas (built-in) dentro del módulo __builtins__, las cuales están siempre
disponibles. Estas funciones están listadas en orden alfabéticos a continuación:
5.6.1. Funciones generales
Las funciones de uso general se describen a continuación:
5.6.1.1. apply()
La función apply() devuelve el resultado de una función o objeto clase llamado con argumentos soportados.
>>> def demo(valor1, valor2, valor3=None):
... return valor1, valor2, valor3
...
>>> apply(demo, (1, 2), {'valor3': 3})
(1, 2, 3)
5.6.1.2. callable()
La función callable() le indica si un objecto puede ser llamado.
>>> callable([1,2,3])
False
>>> callable(callable)
True
>>> callable(False)
False
>>> callable(list)
True
Una función se puede llamar, una lista no se puede llamar. Incluso la función integradacallable() se puede llamar.
5.6.1.3. compile()
La función compile() devuelve un código objeto Python. Usted usa la función integrada Python para convertir de la cadena de
caracteres de código al código objeto.
>>>
>>> exec(compile('a=5\nb=7\nprint a+b','','exec'))
12
Aquí, exec es el modo. El parámetro anterior que eso es el nombre del archivo para la forma del archivo el cual el código es
leído. Finalmente, es ejecutado usando la función exec().
5.6.1.4. credits()
Imprime el texto de la lista de contribuidores.
>>> credits()
Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
for supporting Python development. See www.python.org for more information.
5.6.1.5. copyright()
Imprime el texto de la nota de copyright.
>>> copyright()
Copyright (c) 2001-2016 Python Software Foundation.
All Rights Reserved.
Copyright (c) 2000 BeOpen.com.
Copyright (c) 1995-2001 Corporation for National Research Initiatives.

Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
5.6.1.6. dir()
Si es llamado sin argumentos, devuelve los nombres en el ámbito actual.
>>> dir()
['__builtins__', '__doc__', '__name__', '__package__']
De lo contrario, devuelve una lista alfabética de nombres que comprende (alguno(s) de) los atributos de un objeto dato, y de los
atributos legibles desde este.
>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError',
'BaseException', 'BufferError', 'BytesWarning',
'DeprecationWarning', 'EOFError', 'Ellipsis',
'EnvironmentError', 'Exception', 'False', 'FloatingPointError',
'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError',
'ImportWarning', 'IndentationError', 'IndexError', 'KeyError',
'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError',
'None', 'NotImplemented', 'NotImplementedError', 'OSError',
'OverflowError', 'PendingDeprecationWarning', 'ReferenceError',
'RuntimeError', 'RuntimeWarning', 'StandardError',
'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError',
'SystemExit', 'TabError', 'True', 'TypeError',
'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError',
'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning',
'UserWarning', 'ValueError', 'Warning', 'ZeroDivisionError',
'_', '__debug__', '__doc__', '__import__', '__name__',
'__package__', 'abs', 'all', 'any', 'apply', 'basestring',
'bin', 'bool', 'buffer', 'bytearray', 'bytes', 'callable',
'chr', 'classmethod', 'cmp', 'coerce', 'compile', 'complex',
'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod',
'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter',
'float', 'format', 'frozenset', 'getattr', 'globals',
'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int',
'intern', 'isinstance', 'issubclass', 'iter', 'len',
'license', 'list', 'locals', 'long', 'map', 'max', 'memoryview',

'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print',
'property', 'quit', 'range', 'raw_input', 'reduce', 'reload',
'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted',
'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'unichr',
'unicode', 'vars', 'xrange', 'zip']
Si el objeto soporta un método llamado __dir__, ese será usado; de lo contrario se usa la lógica dir() predeterminada y devuelve:
 para un objeto módulo: los atributos del módulo.
>>> import os
>>> type(os)
<type 'module'>
>>> dir(os)
['EX_CANTCREAT', 'EX_CONFIG', 'EX_DATAERR', 'EX_IOERR',
'EX_NOHOST', 'EX_NOINPUT', 'EX_NOPERM', 'EX_NOUSER',
'EX_OK', 'EX_OSERR', 'EX_OSFILE', 'EX_PROTOCOL',
'EX_SOFTWARE', 'EX_TEMPFAIL', 'EX_UNAVAILABLE', 'EX_USAGE',
'F_OK', 'NGROUPS_MAX', 'O_APPEND', 'O_ASYNC', 'O_CREAT',
'O_DIRECT', 'O_DIRECTORY', 'O_DSYNC', 'O_EXCL', 'O_LARGEFILE',
'O_NDELAY', 'O_NOATIME', 'O_NOCTTY', 'O_NOFOLLOW', 'O_NONBLOCK',
'O_RDONLY', 'O_RDWR', 'O_RSYNC', 'O_SYNC', 'O_TRUNC', 'O_WRONLY',
'P_NOWAIT', 'P_NOWAITO', 'P_WAIT', 'R_OK', 'SEEK_CUR', 'SEEK_END',
'SEEK_SET', 'ST_APPEND', 'ST_MANDLOCK', 'ST_NOATIME', 'ST_NODEV',
'ST_NODIRATIME', 'ST_NOEXEC', 'ST_NOSUID', 'ST_RDONLY',
'ST_RELATIME', 'ST_SYNCHRONOUS', 'ST_WRITE', 'TMP_MAX', 'UserDict',
'WCONTINUED', 'WCOREDUMP', 'WEXITSTATUS', 'WIFCONTINUED', 'WIFEXITED',
'WIFSIGNALED', 'WIFSTOPPED', 'WNOHANG', 'WSTOPSIG', 'WTERMSIG',
'WUNTRACED', 'W_OK', 'X_OK', '_Environ', '__all__', '__builtins__',
'__doc__', '__file__', '__name__',
...
...
... ]
>>> print os.__doc__
OS routines for NT or Posix depending on what system we're on.
This exports:
- all functions from posix, nt, os2, or ce, e.g. unlink, stat, etc.
- os.path is one of the modules posixpath, or ntpath

- os.name is 'posix', 'nt', 'os2', 'ce' or 'riscos'
- os.curdir is a string representing the current directory ('.' or ':')
- os.pardir is a string representing the parent directory ('..' or '::')
- os.sep is the (or a most common) pathname separator ('/' or ':' or '\\')
...
...
...
 para un objeto clase: sus atributos, y recursivamente los atributos de sus clases bases.
>>> class Persona(object):
... """Clase que representa una Persona"""
... def __init__(self, cedula, nombre, apellido, sexo):
... """ Constructor de clase Persona """
... self.cedula = cedula
... self.apellido = apellido
... self.sexo = sexo
... """Devuelve una cadena representativa al Persona"""
... return "%s: %s %s, %s." % (
... str(self.cedula), self.nombre,
... self.apellido, self.sexo
... )
... def hablar(self, mensaje):
... """Mostrar mensaje de saludo de Persona"""
... print mensaje
...
>>> type(Persona)
<type 'type'>
>>> vars()
{'Persona': <class '__main__.Persona'>,
'__builtins__': <module '__builtin__' (built-in)>,
'__package__': None, '__name__': '__main__',
'os': <module 'os' from '/usr/lib/python2.7/os.pyc'>,
'__doc__': None}
>>> dir(Persona)
['__class__', '__delattr__', '__dict__', '__doc__',

'__format__', '__getattribute__', '__hash__',
'__init__', '__module__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__setattr__',
'__sizeof__', '__str__', '__subclasshook__',
'__weakref__', 'hablar']
>>> Persona.__dict__
dict_proxy({'__module__': '__main__',
'__str__': <function __str__ at 0x7fab8aaad758>,
'__dict__': <attribute '__dict__' of 'Persona' objects>,
'hablar': <function hablar at 0x7fab8aaad7d0>,
'__weakref__': <attribute '__weakref__' of 'Persona' objects>,
'__doc__': ' Clase que representa una persona. ',
'__init__': <function __init__ at 0x7fab8aaad6e0>})
>>> Persona.__doc__
' Clase que representa una persona. '
>>> Persona.__init__.__doc__
' Constructor de clase Persona '
>>> Persona.hablar.__doc__
' Mostrar mensaje de saludo de Persona '
 para cualquier otro objecto: sus atributos, sus atributos de clases, y recursivamente los atributos de esas clases bases de
las clases.
>>> type(int)
<type 'type'>
>>> dir(int)
['__abs__', '__add__', '__and__', '__class__', '__cmp__',
'__coerce__', '__delattr__', '__div__', '__divmod__',
'__doc__', '__float__', '__floordiv__', '__format__',
'__getattribute__', '__getnewargs__', '__hash__', '__hex__',
'__index__', '__init__', '__int__', '__invert__', '__long__',
'__lshift__', '__mod__', '__mul__', '__neg__', '__new__',
'__nonzero__', '__oct__', '__or__', '__pos__', '__pow__',
'__radd__', '__rand__', '__rdiv__', '__rdivmod__', '__reduce__',
'__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__',
'__rmod__', '__rmul__', '__ror__', '__rpow__', '__rrshift__',
'__rshift__', '__rsub__', '__rtruediv__', '__rxor__',
'__setattr__', '__sizeof__', '__str__', '__sub__',

'__subclasshook__', '__truediv__', '__trunc__', '__xor__',
'bit_length', 'conjugate', 'denominator', 'imag', 'numerator',
'real']
5.6.1.7. eval()
Evalúa una cadena como una expresión:
>>> eval('2 + 5')
Ademas si se han definido anteriormente variables las acepta como parámetros:
>>> numero = 10
>>> eval('numero * 10 - 5')
95
5.6.1.8. execfile()
La función execfile() lee y ejecuta un script Python desde un archivo. Los globals y locals son diccionarios, por defecto a los
actuales globals y locals. Si solamente globalses dado, locals es por defecto a la misma.
>>> execfile('./holamundo.py')
Hola Mundo
5.6.1.9. globals()
La función globals() devuelve un diccionario conteniendo ámbito actual global de las variables.
>>> globals()
{'__builtins__': <module '__builtin__' (built-in)>,
'__package__': None, '__name__': '__main__', '__doc__': None}
La función globals() puede ser usada para devolver los nombres en el namespaces global dependiendo en la locación desde
donde ella es llamada.
Si la función globals() es llamada desde una función, eso devolverá todos los nombres que pueden ser accesibles globalmente
desde esa función.
El tipo de dato devuelto por función es un tipo diccionario. Por lo tanto, los nombres pueden ser extraídos usando la función
integrada keys().
5.6.1.10. help()
Invoca el menú de ayuda del intérprete de Python:
>>> help()
Welcome to Python 2.7! This is the online help utility.
If this is your first time using Python, you should definitely check out
the tutorial on the Internet at http://docs.python.org/2.7/tutorial/.
Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules. To quit this help utility and
return to the interpreter, just type "quit".
To get a list of available modules, keywords, or topics, type "modules",
"keywords", or "topics". Each module also comes with a one-line summary
of what it does; to list the modules whose summaries contain a given word
such as "spam", type "modules spam".
help>
5.6.1.11. id()
La función id() devuelve la identidad de un objecto. Esto garantiza ser el único entre objetos simultáneamente existentes.
(Sugerencia: es la dirección de memoria del objeto).
>>> lista = range(5)
>>> lista
[0, 1, 2, 3, 4]
>>> id(lista)
139703096777904
5.6.1.12. len()
Devuelve el número de elementos de un tipo de secuencia o colección.
>>> len("leonardo caballero")
18
5.6.1.13. license()
Imprime el texto de la licencia.
>>> license
Type license() to see the full license text
>>> license()
A. HISTORY OF THE SOFTWARE
==========================
Python was created in the early 1990s by Guido van Rossum at Stichting
Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands

as a successor of a language called ABC. Guido remains Python's
principal author, although it includes many contributions from others.
In 1995, Guido continued his work on Python at the Corporation for
National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
in Reston, Virginia where he released several versions of the
software.
In May 2000, Guido and the Python core development team moved to
BeOpen.com to form the BeOpen PythonLabs team. In October of the same
year, the PythonLabs team moved to Digital Creations (now Zope
Corporation, see http://www.zope.com). In 2001, the Python Software
Foundation (PSF, see http://www.python.org/psf/) was formed, a
non-profit organization created specifically to own Python-related
Intellectual Property. Zope Corporation is a sponsoring member of
the PSF.
All Python releases are Open Source (see http://www.opensource.org for
Hit Return for more, or q (and Return) to quit:
5.6.1.14. locals()
La función locals() devuelve un diccionario conteniendo ámbito actual local de las variables.
>>> locals()
{'__builtins__': <module '__builtin__' (built-in)>,
'__package__': None, '__name__': '__main__', '__doc__': None}
La función locals() puede ser usadas para devolver los nombres en el namespaces local dependiendo en la locación desde
donde ella es llamada.
Si la función locals() es llamada desde una función, eso devolverá todos los nombres que pueden ser accesibles localmente
desde esa función.
El tipo de dato devuelto por la función es un tipo diccionario. Por lo tanto, los nombres pueden ser extraídos usando la función
integrada keys().
5.6.1.15. open()
La función open() es definida dentro del modulo integrado io, esta le permite abrir un archivousando el tipo objeto file, devuelve
un objeto del tipo file (ej. archivo), y se llama habitualmente con de dos a tres argumentos:
file(nombre[, modo[, buffering]]) -> objeto archivo
Los argumentos son:
 nombre, es una cadena de caracteres que indica el nombre de archivo (incluso ruta relativa o absoluta).
 modo, es una cadena de unos pocos caracteres describiendo la forma en la que se usará el archivo, como se indica a
continuación:
Modo Notas
r el archivo se abre en modo de solo lectura, no se puede escribir (argumento por defecto).
w modo de solo escritura (si existe un archivo con el mismo nombre, se borra).
a modo de agregado (append), los datos escritos se agregan al final del archivo.
r+ el archivo se abre para lectura y escritura al mismo tiempo.
b el archivo se abre en modo binario, para almacenar cualquier cosa que no sea texto.
el archivo se abre con soporte a nueva linea universal, cualquier fin de linea ingresada sera como un \n en
U
Python.
 buffering, si este argumento es dado, 0 significa sin búfer, 1 significa búfer de línea y los números más grandes especifican
el tamaño del búfer.
Para crear y abrir un archivo, seria así:
>>> archivo = open('datos.txt', 'w')
>>> type(archivo)
<type 'file'>
El archivo será creado si no existe cuando es abierto para escribir o agregar data. Es archivo sera truncado cuando es abierto
para escritura.
Agregue una ‘U’ a modo para abrir el archivo para la entrada con soporte de nueva línea universal. Cualquier línea que termine
en el archivo de entrada se verá como ‘n’ en Python. Además, un archivo así abierto gana el atributo newlines; el valor para este
atributo es uno de Ninguno (aún no se ha leído una nueva línea), \r, \n, \r\n o una tupla que contiene todos los tipos de nueva
línea que se han visto.
Truco
Ver para futura información desde el modo interactivo Python, lo siguiente:
>>> file.__doc__
5.6.1.16. range()
La función range() devuelve una lista conteniendo una progresión aritmética de enteros.
range(inicio, detener[, paso]) -> lista de enteros
nge(3,9)
, 6, 7, 8]
range(i, j) devuelve [i, i+1, i+2, ..., j-1]; inicia (!) por defecto en 0.
Cuando el paso es definido como un tercer argumento, ese especifica el incremento (o decremento).
nge(3,9,2)
En el ejemplo anterior, la función range(3,9,2) devuelve [3, 5, 7], es decir, el rango inicia en 3y termina en 9 incrementando
cada 2 números.
range(detener) -> lista de enteros
nge(4)
, 3]
En el ejemplo anterior, la función range(4) devuelve [0, 1, 2, 3]. ¡El punto final es omitido! Hay exactamente los indices validos
para una lista de 4 elementos.
5.6.1.17. reload()
Cuando el modulo es importado dentro de un script, el código en la porción del nivel superior de un modulo es ejecutado
solamente una vez.
Por lo tanto, si usted quiere volver a ejecutar la porción del nivel superior el código de un modulo, usted puede usar la
función reload(). Esta función importa otra vez un modulo previamente importado. La sintaxis de la función reload() es la
siguiente:
>>> reload(module_name)
Aquí, module_name es el nombre del modulo que usted quiere volver a cargar y no la cadena de caracteres contendiente el
nombre del modulo. Por ejemplo, para recargar el modulo clases.py, debe hacer lo siguiente:
>>> import clases
>>> reload(clases)
5.6.1.18. xrange()
El tipo xrange es un tipo secuencia inmutable utilizada normalmente en bucles. La ventaja de la función xrange() sobre la
función range(), es que devuelve un objeto xrange el cual ocupa siempre la misma cantidad de memoria, independientemente
del rango el cual represente.
>>> for item in range(5):
... print item
...
>>> for item in xrange(5):
... print item
...
>>>
Como la función xrange(), devuelve un objeto el cual genera los números en el rango a demanda. Para bucles, esto es un poco
mas rápido que la función range() y más eficiente en la memoria.
>>> print xrange(5)
xrange(5)
>>> type(xrange(5))
<type 'xrange'>
>>> dir(xrange(5))
['__class__', '__delattr__', '__doc__', '__format__',
'__getattribute__', '__getitem__', '__hash__', '__init__',
'__iter__', '__len__', '__new__', '__reduce__', '__reduce_ex__',
'__repr__', '__reversed__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__']
La ventaja de la función xrange() es excepto en hardware impedido 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 la
sentencia break).
5.6.1.19. type()
La función type() devuelve el tipo del objeto que recibe como argumento.
>>> type(2)
<type 'int'>
>>> type(2.5)
<type 'float'>
>>> type(True)
<type 'bool'>
>>> type("Hola Mundo")
<type 'str'>
>>> type(int)
<type 'type'>
>>> type(str)
<type 'type'>
>>> type(None)
<type 'NoneType'>
>>> type(object)
<type 'type'>
>>> import os
>>> type(os)
<type 'module'>
>>> type(format)
<type 'builtin_function_or_method'>
Truco
La función type() devuelve el tipo del objeto, en base al modulo integrado types, el cual define los nombres para todos los
símbolos tipo conocidos en el interprete estándar.
>>> import types
>>> help(types)
Help on module types:
NAME
types - Define names for all type symbols known in the standard interpreter.
FILE
/usr/lib/python2.7/types.py
MODULE DOCS
https://docs.python.org/library/types
DESCRIPTION
Types that are part of optional modules (e.g. array) are not listed.
CLASSES
__builtin__.basestring(__builtin__.object)
__builtin__.str
__builtin__.unicode
>>>
5.6.1.20. vars()
La función vars() devuelve un diccionario conteniendo ámbito actual de las variables.
>>> vars()
{'__builtins__': <module '__builtin__' (built-in)>, '__package__':
None, '__name__': '__main__', '__doc__': None}
La función vars() sin argumentos, equivale a la función locals(). Si se llama con un argumento equivale a la
sentencia object.__dict__.
5.6.2. Funciones de entrada y salida
Las funciones de tipos numéricos se describen a continuación:
5.6.2.1. input()
Equivalente a la función eval(raw_input(prompt))
Lee una cadena de caracteres desde la entrada estándar.
>>> dato = input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: 2
<type 'int'>
Por favor, ingresa un dato: 23.4
23.4
<type 'float'>
Por favor, ingresa un dato: 23L
23L
<type 'long'>
En el caso que quiera ingresar una cadena de caracteres desde la entrada estándar usando la función input(), debe colocar la
cadena de caracteres entre comillas simples o dobles, como el siguiente ejemplo:
Por favor, ingresa un dato: leonardo
File "<string>", line 1, in <module>
NameError: name 'leonardo' is not defined
Por favor, ingresa un dato: "leonardo"
'leonardo'
<type 'str'>
Por favor, ingresa un dato: leonardo caballero
File "<string>", line 1
leonardo caballero
SyntaxError: unexpected EOF while parsing

Por favor, ingresa un dato: "leonardo caballero"
'leonardo caballero'
<type 'str'>
5.6.2.2. raw_input()
Lee una cadena de caracteres desde la entrada estándar. La nueva línea final es despojada. Si el usuario indica un EOF
(Unix: Ctl-D, Windows: Ctl-Z+Return), lanza una excepción EOFError. En sistemas Unix, la librería GNU readline es usada si es
habilitada. El prompt de la cadena de caracteres, si es dado, es impreso sin una nueva línea final antes de leer.
>>> dato = raw_input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: 2
'2'
<type 'str'>
Por favor, ingresa un dato: 2.3
'2.3'
<type 'str'>
Por favor, ingresa un dato: 23L
'23L'
<type 'str'>
Por favor, ingresa un dato: leonardo
'leonardo'
<type 'str'>
Por favor, ingresa un dato: "leonardo"
'"leonardo"'
<type 'str'>
Por favor, ingresa un dato: leonardo caballero
<type 'str'>
Por favor, ingresa un dato: "leonardo caballero"
'"leonardo caballero"'
<type 'str'>
5.6.3. Funciones numéricas
Las funciones de tipos numéricos se describen a continuación:
5.6.3.1. abs()
Devuelve el valor absoluto de un número (entero o de coma flotante).
>>> abs(3)
>>> abs(-3)
>>> abs(-2.5)
2.5
5.6.3.2. bin()
Devuelve una representación binaria de un número entero o entero long, es decir, lo convierte de entero a binario.
>>> bin(10)
'0b1010'
5.6.3.3. cmp()
La función cmp() devuelve un valor negativo si x<y, un valor cero si x==y, un valor positivo si x>y:
>>> cmp(1,2)
-1
>>> cmp(2,2)
>>> cmp(2,1)
5.6.3.4. complex()
La función complex() devuelve un número complejo complex. Es un constructor, que crea un entero complex a partir de
un entero, entero long, entero float (cadenas de caracteres formadas por números y hasta un punto), o una cadena de
caracteres que sean coherentes con un número entero.
>>> complex(23)
(23+0j)
>>> complex(23L)
(23+0j)
>>> complex(23.4)
(23.4+0j)
>>> complex("23")
(23+0j)
>>> complex("23.6")
(23.6+0j)
La función complex() sólo procesa correctamente cadenas que contengan exclusivamente números.Si la cadena contiene
cualquier otro carácter, la función devuelve una excepción ValueError.
>>> complex("qwerty")
ValueError: complex() arg is a malformed string
5.6.3.5. divmod()
Debe recibir dos argumentos numéricos, y devuelve dos valores: resultado de la división entera, y el resto.
>>> divmod(22, 4)
(5, 2)
5.6.3.6. float()
La función float() devuelve un número coma flotante float. Es un constructor, que crea un coma flotante a partir de
un entero, entero long, entero float (cadenas de caracteres formadas por números y hasta un punto) o una cadena de
caracteres que sean coherentes con un número entero.
>>> float(2)
2.0
>>> float(23L)
23.0
>>> float(2.5)
2.5
>>> float("2")
2.0
>>> float("2.5")
2.5
5.6.3.7. hex()
Devuelve una representación hexadecimal de un número entero o entero long, es decir, lo convierte de entero a hexadecimal.
>>> hex(10)
'0xa'
5.6.3.8. int()
La función int() devuelve un número entero. Es un constructor, que crea un entero a partir de un entero float, entero complex o
una cadena de caracteres que sean coherentes con un número entero.
>>> int(2.5)
También puede convertir una cadena de caracteres a un número entero.
>>> int("23")
23
La función int() sólo procesa correctamente cadenas que contengan exclusivamente números. Si la cadena contiene cualquier
otro carácter, la función devuelve una excepción ValueError.
>>> int("2.5")
ValueError: invalid literal for int() with base 10: '2.5'
>>>
>>> int("doscientos")
ValueError: invalid literal for int() with base 10: 'doscientos'
5.6.3.9. long()
La función long() devuelve un número entero long. Es un constructor, que crea un entero long a partir de un entero, entero float o
una cadena de caracteres que sean coherentes con un número entero.
>>> long(23)
23L
>>> long(23.4)
23L
También puede convertir una cadena de caracteres a un número entero.
>>> long("23")
23
La función long() sólo procesa correctamente cadenas que contengan exclusivamente números. Si la cadena contiene cualquier
otro carácter, la función devuelve una excepción ValueError.
>>> long("23.4")
ValueError: invalid literal for long() with base 10: '23.4'
>>>
>>> long("23,4")

ValueError: invalid literal for long() with base 10: '23,4'
5.6.3.10. max()
Si recibe más de un argumento, devuelve el mayor de ellos.
>>> max(23, 12, 145, 88)
145
>>> type(max(23, 12, 145, 88))
<type 'int'>
>>> max("a", "Z")
'a'
>>> type(max("a", "Z"))
<type 'str'>
Si recibe un solo argumento, devuelve el mayor de sus elementos. Debe ser un objeto iterable; puede ser una cadena de
caracteres, o alguno de los otros tipos de secuencia o colección.
>>> max("Hola, Plone")
'o'
>>> type(max("Hola, Plone"))
<type 'str'>
5.6.3.11. min()
Tiene un comportamiento similar a max(), pero devuelve el mínimo.
>>> min(23, 12, 145, 88)
12
>>> type(min(23, 12, 145, 88))
<type 'int'>
>>> min("Hola, Plone")
''
>>> type(min("Hola, Plone"))
<type 'str'>
5.6.3.12. pow()
La función pow() si recibe dos (02) argumentos, eleva el primero argumento a la potencia del segundo argumento.
>>> pow(2, 3)
>>> pow(10, 2)
100
>>> pow(10, -2)

0.01
Si recibe un tercer argumento opcional, éste funciona como módulo.
>>> pow(2, 3, 3)
5.6.3.13. reduce()
La función reduce() aplica una función de dos argumentos de forma acumulativa a los elementos de un tipo de secuencia, de
izquierda a derecha, para reducir la secuencia a un solo valor. La sintaxis seria la siguiente:
>>> reduce(funcion, secuencia[, inicial]) -> valor
A continuación un ejemplo:
>>> reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
15
>>> ((((1+2)+3)+4)+5)
15
En el ejemplo anterior, calcula el siguiente calculo ((((1+2)+3)+4)+5).
Si el argumento inicial está presente, se coloca antes de los elementos de la secuencia en el cálculo y sirve como valor
predeterminado cuando la secuencia está vacía.
>>> reduce(lambda x, y: x + y, [1, 2, 3, 4, 5], 5 * 5)
40
En el ejemplo anterior, la función, usada es lambda x, y: x + y, la secuencia es la lista [1,2, 3, 4, 5] y el argumento inicial es 5 * 5
>>> reduce(lambda x, y: x + y, [0, 0, 0, 0, 0], 5 * 5)
25
En el ejemplo anterior, la función, usada es lambda x, y: x + y, la secuencia es la lista [0,0, 0, 0, 0] y el argumento inicial es 5 * 5
5.6.3.14. round()
La función round() redondea un número flotante a una precisión dada en dígitos decimal (por defecto 0 dígitos). Esto siempre
devuelve un número flotante. La precisión tal vez sea negativa.
En el siguiente ejemplo redondeo de un número flotante a entero, mayor o igual a .5 al alza:
>>> round(5.5)
6.0
En este otro ejemplo redondeo de un número flotante a entero, menor de .5 a la baja:
>>> round(5.4)
5.0
5.6.3.15. sum()
La función sum() devuelve una lista ordenada de los elementos de la secuencia que recibe como argumento (lista o cadena). La
secuencia original no es modificada.
>>> lista = [1, 2, 3, 4]
>>> sum(lista)
10
5.6.3.16. oct()
La función oct() convierte un número entero en una cadena en base octal, antecedida del prefijo ‘0’.
>>> oct(8)
'010'
>>> oct(123)
'0173'
5.6.4. Funciones de booleanos
Las funciones de tipos booleanos se describen a continuación:
5.6.4.1. bool()
La función bool(), es un constructor, el cual crea un tipo de datos booleanos, devuelve un tipo booleano True cuando el
argumento dado es True, de lo contrario False.
>>> bool()
False
>>> bool(True)
True
Convertir desde un tipo entero a tipo booleano:
>>> bool(0)
False
>>> bool(1)
True
Convertir desde un tipo entero float de forma recursiva usando la función int() a tipo booleano:
>>> bool(int(0.1))
False
>>> bool(int(1.0))
True
Convertir desde un tipo cadena de caracteres de forma recursiva usando la función str() y la función int() a tipo booleano:
>>> bool(int(str('0')))
False
>>> bool(int(str('1')))
True
5.6.5. Funciones de cadenas de caracteres
Las funciones de tipos cadena de caracteres se describen a continuación:
5.6.5.1. capitalize()
La función capitalize() devuelve una cadenas de caracteres con MAYÚSCULA la primera palabra.
>>> 'leonardo caballero'.capitalize()
'Leonardo caballero'
5.6.5.2. chr()
La función chr() recibe como argumento un entero, y devuelve una cadena con el carácter cuyo código Unicode corresponde a
ese valor. El rango válido para el argumento es de 0 a 256.
>>> chr(64)
'@'
>>> chr(36)
'$'
>>> chr(94)
'^'
>>> chr(126)
'~'
5.6.5.3. endswith()
La función endswith() devuelve un valor booleano True o False si coincide que la cadena termine con el criterio enviado por
parámetros en la función.
>>> 'leonardo caballero'.endswith("do")
False
>>> 'leonardo caballero'.endswith("ro")
True
5.6.5.4. expandtabs()
La función expandtabs() devuelve una copia de la cadena de caracteres donde todos los caracteres tab (tabulación) son
remplazados por uno o más espacios, depende en la actual columna y el tamaño del tab dado.
>>> 'Leonardo Caballero\tPython Developer\tleonardoc@plone.org'.expandtabs()
'Leonardo Caballero Python Developer leonardoc@plone.org'
Usted puede indicar el tamaño de la tecla tab vía parámetro de la función:
>>> 'Leonardo Caballero\tPython Developer\tleonardoc@plone.org'.expandtabs(4)
>>> 'Leonardo Caballero\tPython Developer\tleonardoc@plone.org'.expandtabs(2)

5.6.5.5. find()
La función find() devuelve un valor numérico 0 si encuentra el criterio de búsqueda o -1 si no coincide el criterio de búsqueda
enviado por parámetros en la función.
>>> 'leonardo caballero'.find("leo")
>>> 'leonardo caballero'.find("ana")
-1
5.6.5.6. format()
La función integrada format() devuelve una representación formateada de un valor dato controlado por el especificador de
formato.
La función integrada format() es similar al método format() disponible en el tipo de cadena de caracteres. Internamente, ambos
llaman al método __format__() de un objecto.
Mientras, la función integrada format() es una implementación de bajo nivel para formatear un objeto
usando __format__() internamente, el método format() del tipo de cadena de caracteres es una implementación de alto nivel
disponible para ejecutar operaciones de formateo complejas en múltiples objeto de cadena de caracteres.
La sintaxis de la función integrada format() es:
format(value[, format_spec])
La a función integrada format() toma dos parámetros:
 value - valor que necesita formatear.

 format_spec - La especificación en como el valor debe ser formateado.
A continuación, un ejemplo de un valor número entero, seria de la siguiente forma:
>>> print format(123,"d")
123
A continuación, un ejemplo de un valor número float, seria de la siguiente forma:
>>> print format(123.456789,"f")
123.456789
A continuación, un ejemplo de un valor binario, seria de la siguiente forma:
>>> print format(10,"b")
1010
A continuación, un ejemplo de un valor número entero con formato especifico, seria de la siguiente forma:
>>> print format(1234,"*>+7,d")
*+1,234
En el ejemplo anterior cuando se formatea el número entero 1234, usted especifico el especificador de formato *<+7,d.
Seguidamente, se describe cada opción a continuación:
 * Es la opción del carácter de relleno, el cual rellena los espacio vacío después del formato.
 > Es la opción de alineación a la derecha, el cual alinea la cadena de caracteres de salida a la derecha.
 + Es la opción de signo, el cual obliga al número a ser firmado (con un signo a su izquierda).
 7 Es la opción ancho, el cual obliga el número que tome un mínimo de ancho de 7, otros espacios serán rellenado por el
carácter de relleno.
 , Ese es el operador miles, el cual coloca un carácter coma entre todos los números miles.
 d Es la opción tipo que especifica que el número es un número entero.
A continuación, un ejemplo de un valor número float con formato especifico, seria de la siguiente forma:
>>> print format(123.4567, "^-09.3f")
0123.4570
En el ejemplo anterior cuando se formatea el número float 123.4567, usted especifico el especificador de formato ^-09.3f.
Seguidamente, se describe cada opción a continuación:
 ^ Es la opción de alineación centrar, el cual alinea la cadena de caracteres de salida al centro del espacio restante.
 - Es la opción de signo el cual obliga solo a los números negativos a mostrar el signo.
 0 Ese es el carácter, el cual es colocado en lugar de los espacios vacíos.
 9 Es la opción de ancho, el cual establece el ancho mínimo del número en 9 (incluido el punto decimal, la coma y el signo
de miles).
 .3 Ese es el operador de precisión que define la precisión del número flotante dado a 3 lugares.
 f Es la opción tipo que especifica que el número es un número float.
A continuación, un ejemplo de usar la función format() sobre escribiendo el método especial __format__() de una clase, seria de
la siguiente forma:
>>> class Persona:
... def __format__(self, formato):
... if(formato == 'edad'):
... return '23'
... return 'Formato nulo'
...
>>> print format(Persona(), "edad")
23
En el ejemplo anterior cuando se sobre escribe el método especial __format__() de la clase Persona. Ese ahora acepta el
argumento del método llamado edad el cual devuelve 23.
El método format() internamente ejecuta Persona().__format__("edad"), el cual devuelve el mensaje 23. Si no hay formato
especificado, el mensaje devuelto es Formato nulo.
5.6.5.7. index()
La función index() es como la función find() pero arroja una excepción ValueError cuando la sub-cadena no es encontrada.
>>> 'leonardo caballero'.index("leo")
>>> 'leonardo caballero'.index("ana")
ValueError: substring not found
>>> 'leonardo caballero'.index(" ca")
8
5.6.5.8. intern()
La función intern() introduce la cadena en la tabla de cadenas internadas (si no está ya allí). Esto ingresa la cadena en la tabla
(global) de cadenas internas cuyo propósito es acelerar las búsquedas en el tipo diccionario.
Al utilizar la función intern(), se asegura de que nunca cree dos objetos de cadena de caracteres que tengan el mismo valor:
cuando solicita la creación de un segundo objeto de cadena de caracteres con el mismo valor que un objeto de cadena existente,
recibe una referencia al objeto de cadena preexistente. De esta manera, estás ahorrando memoria. Además, la comparación de
objetos de cadena de caracteres ahora es muy eficiente porque se lleva a cabo comparando las direcciones de memoria de los
dos objetos de cadena de caracteres en lugar de su contenido.
Esencialmente, la función intern() busca (o almacena si no está presente) la cadena de caracteres en una colección de cadenas
de caracteres internadas, por lo que todas las instancias internadas compartirán la misma identidad. Cambia el costo único de
buscar esta cadena de caracteres para realizar comparaciones más rápidas (la comparación puede devolver True después de
solo verificar la identidad, en lugar de tener que comparar cada carácter), y reducir el uso de la memoria.
Sin embargo, Python internará automáticamente cadenas de caracteres que sean pequeñas o que parezcan identificadores, por
lo que es posible que no obtengas ninguna mejora porque tus cadenas de caracteres ya están internadas entre bastidores.
A continuación uno ejemplo de comparación de cadena de caracteres con operadores de relacionales:
>>> cadena0, cadena1 = 'python', 'python'
>>> cadena0 == cadena1
True
>>> cadena0 is cadena1
True
>>> cadena0, cadena1 = 'python 2.7', 'python 2.7'
False
A continuación uno ejemplo de comparación de cadena de caracteres con el operador is:
>>>
>>> cadena0 = intern('plone cms')
>>> cadena1 = 'plone cms'
False
>>> cadena1 = intern('plone cms')
True
5.6.5.9. isalnum()
La función isalnum() devuelve un valor booleano True o False si coincide que la cadena contenga caracteres alfanuméricos.
>>> '23456987'.isalnum()
True
>>> 'V-23456987'.isalnum()
False
5.6.5.10. isalpha()
La función isalpha() devuelve un valor booleano True o False si coincide que la cadena contenga caracteres alfabéticos.
>>> 'leonardo'.isalpha()
True
>>> 'leonardo caballero'.isalpha()
False
5.6.5.11. isdigit()
La función isdigit() devuelve un valor booleano True o False si coincide que la cadena contenga caracteres dígitos.
>>> 'leonardo caballero'.isdigit()
False
>>> '23456987'.isdigit()
True
5.6.5.12. islower()
La función islower() devuelve un valor booleano True o False si coincide que la cadena contenga caracteres en MINÚSCULAS.
>>> 'leonardo caballero'.islower()
True
>>> 'leonardo CABALLERO'.islower()
False
5.6.5.13. istitle()
La función istitle() devuelve un valor booleano True o False si coincide que la cadena de caracteres sean capitales en cada
palabra.
>>> "leonardo caballero".title()
'Leonardo Caballero'
>>> "leonardo Caballero".istitle()
False
5.6.5.14. isspace()
La función isspace() devuelve un valor booleano True o False si no es vacía, y todos sus caracteres son espacios en blanco.
>>> " ".isspace()
True
>>> " ".isspace()
True
>>> "a ".isspace()
False
>>> " A ".isspace()
False
5.6.5.15. isupper()
La función isupper() devuelve un valor booleano True o False si coincide que la cadena de caracteres estén en MAYÚSCULAS
en cada palabra.
>>> 'LEONARDO CABALLERO'.isupper()
True
>>> 'LEONARDO caballero'.isupper()
False
5.6.5.16. lstrip()
La función lstrip() devuelve una copia de la cadena de caracteres con el espacio en blanco inicial eliminado. Si se dan la cadena
de caracteres y no es None, elimina los caracteres en la cadena de caracteres en su lugar. Si la cadena de caracteres
son unicode, serán convertidas a unicode antes de eliminar.
>>> " leonardo caballero ".lstrip()
'leonardo caballero '
5.6.5.17. lower()
La función lower() devuelve una cadenas de caracteres con MINÚSCULAS en cada palabra.
>>> 'LEONARDO CABALLERO'.lower()
5.6.5.18. ord()
La función ord() es el inverso de chr() dada una cadena representando un carácter Unicode, devuelve el entero del código
correspondiente.
>>> ord('@')
64
>>> ord('$')
36
>>> ord('^')
94
>>> ord('~')
126
5.6.5.19. replace()
La función replace() si encuentra el criterio de la búsqueda de la sub-cadena o la remplaza con la nueva sub-cadena enviado por
>>> 'leonardo caballero'.replace(" cab", " Cab")
'leonardo Caballero'
5.6.5.20. split()
La función split() devuelve una lista con la cadena de caracteres separada por cada indice de la lista.
>>> 'leonardo caballero'.split()
['leonardo', 'caballero']
5.6.5.21. splitlines()
La función splitlines() devuelve una lista con la cadena de caracteres separada por cada salto de linea en cada indice de la lista.
>>> 'leonardo jose\ncaballero garcia'.splitlines()
['leonardo jose', 'caballero garcia']
5.6.5.22. startswith()
La función startswith() devuelve un valor booleano True o False si coincide que la cadena inicie con el criterio enviado por
>>> 'leonardo caballero'.startswith("ca")
False
>>> 'leonardo caballero'.startswith("leo")
True
5.6.5.23. str()
La función str() es el constructor del tipo de cadenas de caracteres, se usa crear una carácter o cadenas de caracteres mediante
la misma función str().
Puede convertir un número entero a una cadena de caracteres, de la siguiente forma:
>>> str(2)
'2'
Puede convertir un número float a una cadena de caracteres, de la siguiente forma:
>>> str(2.5)
'2.5'
>>> str(-2.5)
'-2.5'
Puede convertir un número complex a una cadena de caracteres, de la siguiente forma:
>>> str(2.3+0j)
'(2.3+0j)'
Puede convertir un tipo booleano a una cadena de caracteres, de la siguiente forma:
>>> str(True)
'True'
>>> str(False)
'False'
5.6.5.24. swapcase()
La función swapcase() devuelve una cadenas de caracteres convertida al opuesto sea MAYÚSCULAS o MINÚSCULAS.
>>> 'leonardo caballero'.swapcase()
'LEONARDO CABALLERO'
>>> 'LEONARDO CABALLERO'.swapcase()
5.6.5.25. title()
La función title() devuelve una cadenas de caracteres con capitales en cada palabra.
>>> "leonardo caballero".title()
'Leonardo Caballero'
5.6.5.26. unichr()
La función unichr() devuelve una cadena de caracteres Unicode de un carácter con un numero entero.
>>> unichr(64)
u'@'
>>> unichr(36)
u'$'
>>> unichr(94)
u'^'
>>> unichr(126)
u'~'
5.6.5.27. upper()
La función upper() devuelve una cadenas de caracteres con MAYÚSCULAS en cada palabra.
>>> "leonardo caballero".upper()
'LEONARDO CABALLERO'
5.6.6. Funciones de secuencias
Las funciones de secuencias se describen a continuación:
5.6.6.1. all()
La función all() toma un contenedor como un argumento. Esta devuelve las funciones integradas True si todo los valores en el
objeto iterable python tienen un valor de tipo booleanoigual a True. Un valor vacío tiene un tipo booleano igual a False.
>>> all([' ',' ',' '])
True
>>> all({'*','',''})
False
5.6.6.2. any()
La función any() ese toma un argumento y devuelve True incluso si, un valor en el objeto iterable tiene un valor de
tipo booleano igual a True.
>>> any((1,0,0))
True
>>> any((0,0,0))
False
>>> any(range(5))
True
>>> any(range(0))
False
5.6.6.3. coerce()
La función coerce() devuelve una tupla que consta de los dos argumentos numéricos convertidos en un tipo común, utilizando las
mismas reglas que las operaciones aritméticas. Si la coerción no es posible, levante una excepción TypeError.
>>> coerce(3, 4)
(3, 4)
>>> coerce(3, 4.2)
(3.0, 4.2)
5.6.6.4. dict()
La función dict() es el constructor del tipo de diccionario, esta función se usa crear un diccionario:
>>> dict(python=2.7, zope=2.13, plone=5.1)
También puede crear un diccionario indicando a las claves usando comillas simples:
>>> {'python': 2.7, 'zope': 2.13, 'plone': 5.1}
{'python': 2.7, 'zope': 2, 'plone': 5.1}
>>> dict({'python': 2.7, 'zope': 2.13, 'plone': 5.1})
{{'python': 2.7, 'zope': 2.13, 'plone': 5.1}
Convertir desde un grupo de dos listas de forma recursiva usando la función zip() a tipo diccionario:
>>> dict(zip(['python', 'zope', 'plone'], [2.7, 2.13, 5.1]))
{'python': 2.7, 'zope': 2.13, 'plone': 5.1}
Convertir desde un grupo de tuplas respectivamente en una lista a tipo diccionario:
>>> dict([('zope', 2.13), ('python', 2.7), ('plone', 5.1)])
{'plone': 5.1, 'zope': 2.13, 'python': 2.7}

5.6.6.5. frozenset()
La función frozenset() es el constructor del tipo de conjuntos, se usa crear un conjunto inmutable mediante la misma
función frozenset() de un objeto iterable lista:
>>> versiones = [6, 2.1, 2.5, 3.6, 4, 5, 6, 4, 2.5]
>>> print versiones, type(versiones)
[6, 2.1, 2.5, 3.6, 4, 5, 6, 4, 2.5] <type 'list'>
>>> versiones_plone = frozenset(versiones)
frozenset([2.5, 4, 5, 6, 2.1, 3.6]) <type 'frozenset'>
5.6.6.6. iter()
La función iter() obtiene un iterador de un objeto. En la primera forma, el argumento debe proporcionar su propio iterador, o ser
una secuencia.
>>> elemento = iter("Plone")
>>> elemento
<iterator object at 0x7eff6ce10250>
>>> elemento.next()
'P'
>>> elemento.next()
'l'
>>> elemento.next()
'o'
>>> elemento.next()
'n'
>>> elemento.next()
'e'
>>> elemento.next()
StopIteration
En el ejemplo anterior, cuando se itera en la secuencia de tipo cadena de caracteres, al llegar al final mediante el iterador
llamado elemento se llama a la excepción StopIteration y se causa el detener la iteración.
5.6.6.7. list()
La función list() es el constructor del tipo de lista, se usa crear una lista mediante la misma función list() de un iterable. Por
ejemplo, una lista podría crearse mediante la función range(10):
>>> lista = list(range(10))
>>> print lista

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
5.6.6.8. next()
La función next() devuelve el próximo elemento desde un iterador.
>>> elemento = iter([1,2,3,4,5])
>>> next(elemento)
>>> next(elemento)
>>> next(elemento)
>>> next(elemento)
>>> next(elemento)
>>> next(elemento)
StopIteration
En el ejemplo anterior, cuando se itera en la secuencia de tipo lista, al llegar al final mediante el iterador llamado elemento se
llama a la excepción StopIteration y se causa el detener la iteración.
5.6.6.9. tuple()
La función tuple() es el constructor del tipo de tuplas, se usa crear una tupla mediante la misma función tuple() de un iterable. Por
ejemplo, una tupla podría crearse mediante la función range(10):
>>> tupla = tuple(range(4, 9))
>>> print tupla
(4, 5, 6, 7, 8)
5.6.6.10. set()
La función set() es el constructor del tipo de conjuntos, se usa crear un conjunto mutablemediante la misma función set() de un
objeto iterable lista:
>>> versiones = [2.1, 2.5, 3.6, 4, 5, 6, 4]
>>> print versiones, type(versiones)
[2.1, 2.5, 3.6, 4, 5, 6, 4] <type 'list'>
>>> versiones_plone = set(versiones)
set([2.5, 4, 5, 6, 2.1, 3.6]) <type 'set'>

5.6.6.11. sorted()
La función sorted() devuelve una lista ordenada de los elementos del tipo secuencia que recibe como argumento (lista o cadena
de caracteres). La secuencia original no es modificada.
>>> lista = [23, 13, 7, 37]
>>> sorted(lista)
[7, 13, 23, 37]
La función sorted() siempre devuelve una lista, aunque reciba como argumento una cadena de caracteres.
>>> cadena = "asdlk"
>>> sorted(cadena)
['a', 'd', 'k', 'l', 's']
5.6.6.12. zip()
La función zip() devuelve una lista de tuplas, donde cada tupla contiene el elemento i-th desde cada una de los tipos de
secuencias de argumento. La lista devuelta es truncada en longitud a la longitud de la secuencia de argumentos más corta.
>>> zip(['python', 'zope', 'plone'], [2.7, 2.13, 5.1])
[('python', 2.7), ('zope', 2.13), ('plone', 5.1)]
5.6.7. Funciones de objetos
Las funciones de objetos se describen a continuación:
5.6.7.1. delattr()
La función delattr() elimina un atributo con nombre en un objeto; delattr(x, 'y') es equivalente a del x.y.
>>> class Persona:
... cedula = "V-13458796"
... nombre = "Leonardo"
... apellido = "Caballero"
... sexo = "M"
...
>>> macagua = Persona()
>>> macagua.sexo
'M'
>>> delattr(Persona,'sexo')
>>> macagua.sexo

AttributeError: Persona instance has no attribute 'sexo'
5.6.7.2. getattr()
La función getattr() obtiene un atributo nombrado desde un objeto; de la siguiente forma getattr(instancia, 'atributo') el cual es
equivalente a instancia.atributo. Cuando un argumento predeterminado es dato, es es devuelto cuando el atributo no existe; sin
eso, una excepción es lanzada en ese caso.
>>> class Persona:
... cedula = "V-13458796"
... sexo = "M"
...
>>> getattr(macagua,'sexo')
'M'
>>> macagua.sexo
'M'
5.6.7.3. hasattr()
La función hasattr() devuelve un tipo booleano cuando el objeto tiene un atributo con el nombre dado. (Esta hecho llamando a la
función getattr(instancia, atributo) y capturar excepciones.)
>>> class Persona:
... cedula = "V-13458796"
... sexo = "M"
...
>>> hasattr(macagua, 'nombre')
True
>>> hasattr(macagua, 'apellido')
True
>>> hasattr(macagua, 'cedula')
True
>>> hasattr(macagua, 'sexo')
True
>>> hasattr(macagua, 'email')
False
5.6.7.4. hash()
La función hash() devuelve un valor hash de tipo entero para el objeto.
>>> class Persona:
... cedula = "V-13458796"
... sexo = "M"
...
>>> type(macagua)
<type 'classobj'>
Dos objetos con el mismo valor tienen el mismo valor hash.
>>> type(Persona)
<type 'classobj'>
>>> type(macagua)
<type 'classobj'>
>>> hash(macagua)
8742669316448
>>> hash(Persona)
8742669316448
Lo contrario no es necesariamente cierto, pero es probable.
5.6.7.5. isinstance()
La función isinstance() le permite corroborar si un objeto es una instancia de una clase.
isinstance(objeto, tipo)
Esta función devuelve True si el objeto especificado es del tipo especificado, de lo contrario False.
Los parámetros son:
 objeto, es requerido. Un objeto.

 tipo, un tipo o una clase, o una tupla de tipos y/o clases
Un ejemplo de uso con la clase Persona seria como lo siguiente:
>>> persona1 = Persona("V-13458796", "Leonardo", "Caballero", "M")
>>> isinstance(persona1, Persona)

True
Si el tipo de parámetro es una tupla, esta función devuelve True si le objeto es uno de los tipos en la tupla.
>>> persona1 = Persona("V-13458796", "Leonardo", "Caballero", "M")
>>> isinstance(persona1, (Persona, int))
True
Aquí puede decir que persona1 es una instancia de la clase Persona.
Las clases dan la posibilidad de crear estructuras de datos más complejas. En el ejemplo, una clase Persona que realizará un
seguimiento del cedula, nombre, apellido y sexo (que pasará como atributos).
5.6.7.6. issubclass()
La función issubclass() le permite corroborar si un objeto es instancia de una clase.
issubclass(subclase, clase)
Esta función devuelve True si la clase especificada es una subclase de la clase base, de lo contrario False.
Un ejemplo de uso con la subclase Supervisor que deriva de la clase Persona seria como lo siguiente:
>>> sV1 = Supervisor("V-16987456", "Jen", "Paz", "D", "Chivo")
>>> issubclass(sV1, Persona)
True
Si el tipo de parámetro es una tupla, esta función devuelve True si le objeto es uno de los tipos en la tupla.
>>> sV1 = Supervisor("V-16987456", "Jen", "Paz", "D", "Chivo")
>>> issubclass(sV1, (Persona, Empleado, Supervisor, Destreza))
True
Aquí puede decir que sV1 es una subclase derivada de la clase Persona.
Las clases dan la posibilidad de crear estructuras de datos más complejas. En el ejemplo, una clase Persona que realizará un
seguimiento del cedula, nombre, apellido y sexo (que pasará como atributos).
5.6.7.7. setattr()
La función setattr() establecer un atributo con nombre en un objeto; setattr(x, 'y',v) es equivalente a x.y = v.
>>> class Persona:
... cedula = "V-13458796"
... sexo = "M"
...
>>> setattr(macagua, 'email', 'leonardoc@plone.org')
>>> getattr(macagua,'email')
'leonardoc@plone.org'
Importante
La lista de todas las funciones disponibles en el lenguaje Python con la descripción correspondiente se puede encontrar en la
siguiente dirección URL:
 https://docs.python.org/2/library/functions.html

Funciones Python de LU3

Cargado por

Copyright:

Formatos disponibles

Funciones Python de LU3

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Funciones Python de LU3

Cargado por

Copyright:

Formatos disponibles

https://entrenamiento-python-basico.readthedocs.io/es/latest/index.

5.2.1. Sentencia def

La sintaxis para una definición de función en Python es:

A continuación se detallan el significado de pseudo código fuente anterior:

 NOMBRE, es el nombre de la función.

Un ejemplo simple de función esta seguidamente:

>>> def hola(arg):

... """El docstring de la función"""

... print "Hola", arg, "!"

5.2.2. Argumentos y parámetros

5.2.2.1. Por posición

>>> def resta(a, b):

>>> resta(30, 10)

5.2.2.2. Por nombre

>>> def resta(a, b):

>>> (b=30, a=10)

5.2.2.3. Llamada sin argumentos

Traceback (most recent call last):

TypeError: resta() takes exactly 2 arguments (0 given)

5.2.2.4. Parámetros por defecto

>>> def resta(a=None, b=None):

... if a == None or b == None:

... print "Error, debes enviar dos números a la función"

>>> resta(30, 10)

Error, debes enviar dos números a la función

5.2.3. Argumentos indeterminados

5.2.3.1. Por posición

>>> def indeterminados_posicion(*args):

... for arg in args:

... print arg

>>> indeterminados_posicion(5,"Hola Plone",[1,2,3,4,5])

5.2.3.2. Por nombre

>>> def indeterminados_nombre(**kwargs):

... print kwargs

>>> indeterminados_nombre(n=5, c="Hola Plone", l=[1,2,3,4,5])

>>> def indeterminados_nombre(**kwargs):

... for kwarg in kwargs:

... print kwarg, "=>", kwargs[kwarg]

>>> indeterminados_nombre(n=5, c="Hola Plone", l=[1,2,3,4,5])

c => Hola Plone

5.2.3.3. Por posición y nombre

>>> def super_funcion(*args,**kwargs):

... for arg in args:

... total += arg

... print "sumatorio => ", total

... for kwarg in kwargs:

... print kwarg, "=>", kwargs[kwarg]

>>> super_funcion(50, -1, 1.56, 10, 20, 300, cms="Plone", edad=38)

sumatorio => 380.56

cms => Plone

5.2.4. Sentencia pass

>>> # una función que no hace nada (aun)

... def consultar_nombre_genero(letra_genero): pass

... class Persona: pass

>>> macagua = Persona

5.2.5. Sentencia return

'''función la cual suma dos números'''

print numero1 + numero2

Esta función se llama de la siguiente forma: