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)

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 integrada callable() se puede llamar.

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

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.

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.
All Rights Reserved.

Copyright (c) 1995-2001 Corporation for National Research Initiatives.
All Rights Reserved.

Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
All Rights Reserved.

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.nombre = nombre
...         self.apellido = apellido
...         self.sexo = sexo
...     def __str__(self):
...         """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']

eval()

Evalúa una cadena como una expresión:

>>> eval('2 + 5')
7

Ademas si se han definido anteriormente variables las acepta como parámetros:

>>> numero = 10
>>> eval('numero * 10 - 5')
95

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 globals es dado, locals es por defecto a la misma.

>>> execfile('./holamundo.py')
Hola Mundo

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

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 https://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>

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

len()

Devuelve el número de elementos de un tipo de secuencia o colección.

>>> len("leonardo caballero")
18

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 https://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:

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

open()

La función open() es definida dentro del modulo integrado io, esta le permite abrir un archivo usando 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.
  U	el archivo se abre con soporte a nueva linea universal, cualquier fin de linea ingresada sera como un \n en 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.

>>> file.__doc__

range()

La función range() devuelve una lista conteniendo una progresión aritmética de enteros.

range(inicio, detener[, paso]) -> lista de enteros

>>> range(3,9)
[3, 4, 5, 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).

>>> range(3,9,2)
[3, 5, 7]

En el ejemplo anterior, la función range(3,9,2) devuelve [3, 5, 7], es decir, el rango inicia en 3 y termina en 9 incrementando cada 2 números.

range(detener) -> lista de enteros

>>> range(4)
[0, 1, 2, 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.

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)

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
...
0
1
2
3
4
>>> for item in xrange(5):
...     print item
...
0
1
2
3
4
>>>

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).

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'>

>>> 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

>>>

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__.

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
2
<type 'int'>
>>> dato = input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: 23.4
23.4
<type 'float'>
>>> dato = input("Por favor, ingresa un dato: "); dato; type(dato)
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:

>>> dato = input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: leonardo
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'leonardo' is not defined
>>> dato = input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: "leonardo"
'leonardo'
<type 'str'>
>>> dato = input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: leonardo caballero
  File "<string>", line 1
    leonardo caballero
                     ^
SyntaxError: unexpected EOF while parsing
>>> dato = input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: "leonardo caballero"
'leonardo caballero'
<type 'str'>

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'>
>>> dato = raw_input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: 2.3
'2.3'
<type 'str'>
>>> dato = raw_input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: 23L
'23L'
<type 'str'>
>>> dato = raw_input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: leonardo
'leonardo'
<type 'str'>
>>> dato = raw_input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: "leonardo"
'"leonardo"'
<type 'str'>
>>> dato = raw_input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: leonardo caballero
'leonardo caballero'
<type 'str'>
>>> dato = raw_input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: "leonardo caballero"
'"leonardo caballero"'
<type 'str'>

abs()

Devuelve el valor absoluto de un número (entero o de coma flotante).

>>> abs(3)
3
>>> abs(-3)
3
>>> abs(-2.5)
2.5

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'

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)
0
>>> cmp(2,1)
1

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")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: complex() arg is a malformed string

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)

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

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'

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)
2

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")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '2.5'
>>>
>>> int("doscientos")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'doscientos'

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")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for long() with base 10: '23.4'
>>>
>>> long("23,4")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for long() with base 10: '23,4'

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'>

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'>

pow()

La función pow() si recibe dos (02) argumentos, eleva el primero argumento a la potencia del segundo argumento.

>>> pow(2, 3)
8
>>> pow(10, 2)
100
>>> pow(10, -2)
0.01

Si recibe un tercer argumento opcional, éste funciona como módulo.

>>> pow(2, 3, 3)
2

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

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

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

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'

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

capitalize()

La función capitalize() devuelve una cadenas de caracteres con MAYÚSCULA la primera palabra.

>>> 'leonardo caballero'.capitalize()
'Leonardo caballero'

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)
'~'

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

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  Python Developer    leonardoc@plone.org'
>>> 'Leonardo Caballero\tPython Developer\tleonardoc@plone.org'.expandtabs(2)
'Leonardo Caballero  Python Developer  leonardoc@plone.org'

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")
0
>>> 'leonardo caballero'.find("ana")
-1

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.

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")
0
>>> 'leonardo caballero'.index("ana")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> 'leonardo caballero'.index(" ca")
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'
>>> cadena0 is cadena1
False

A continuación uno ejemplo de comparación de cadena de caracteres con el operador is:

>>>
>>> cadena0 = intern('plone cms')
>>> cadena1 = 'plone cms'
>>> cadena0 is cadena1
False
>>> cadena1 = intern('plone cms')
>>> cadena0 is cadena1
True

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

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

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

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

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

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

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

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 '

lower()

La función lower() devuelve una cadenas de caracteres con MINÚSCULAS en cada palabra.

>>> 'LEONARDO CABALLERO'.lower()
'leonardo caballero'

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

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 parámetros en la función.

>>> 'leonardo caballero'.replace(" cab", " Cab")
'leonardo Caballero'

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']

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']

startswith()

La función startswith() devuelve un valor booleano True o False si coincide que la cadena inicie con el criterio enviado por parámetros en la función.

>>> 'leonardo caballero'.startswith("ca")
False
>>> 'leonardo caballero'.startswith("leo")
True

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'

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()
'leonardo caballero'

title()

La función title() devuelve una cadenas de caracteres con capitales en cada palabra.

>>> "leonardo caballero".title()
'Leonardo Caballero'

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'~'

upper()

La función upper() devuelve una cadenas de caracteres con MAYÚSCULAS en cada palabra.

>>> "leonardo caballero".upper()
'LEONARDO CABALLERO'

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 booleano igual a True. Un valor vacío tiene un tipo booleano igual a False.

>>> all([' ',' ',' '])
True
>>> all({'*','',''})
False

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

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)

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)
{'zope': 2.13, 'python': 2.7, '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}

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)
>>> print versiones_plone, type(versiones_plone)
frozenset([2.5, 4, 5, 6, 2.1, 3.6]) <type 'frozenset'>

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()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
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.

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]

next()

La función next() devuelve el próximo elemento desde un iterador.

>>> elemento = iter([1,2,3,4,5])
>>> next(elemento)
1
>>> next(elemento)
2
>>> next(elemento)
3
>>> next(elemento)
4
>>> next(elemento)
5
>>> next(elemento)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
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.

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)

set()

La función set() es el constructor del tipo de conjuntos, se usa crear un conjunto mutable mediante 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)
>>> print versiones_plone, type(versiones_plone)
set([2.5, 4, 5, 6, 2.1, 3.6]) <type 'set'>

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']

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)]

delattr()

La función delattr() elimina un atributo con nombre en un objeto; delattr(x, 'y') es equivalente a del x.y.

>>> class Persona:
...     """Clase que representa una Persona"""
...     cedula = "V-13458796"
...     nombre = "Leonardo"
...     apellido = "Caballero"
...     sexo = "M"
...
>>> macagua = Persona()
>>> macagua.sexo
'M'
>>> delattr(Persona,'sexo')
>>> macagua.sexo
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: Persona instance has no attribute 'sexo'

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:
...     """Clase que representa una Persona"""
...     cedula = "V-13458796"
...     nombre = "Leonardo"
...     apellido = "Caballero"
...     sexo = "M"
...
>>> macagua = Persona()
>>> getattr(macagua,'sexo')
'M'
>>> macagua.sexo
'M'

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:
...     """Clase que representa una Persona"""
...     cedula = "V-13458796"
...     nombre = "Leonardo"
...     apellido = "Caballero"
...     sexo = "M"
...
>>> macagua = Persona()
>>> hasattr(macagua, 'nombre')
True
>>> hasattr(macagua, 'apellido')
True
>>> hasattr(macagua, 'cedula')
True
>>> hasattr(macagua, 'sexo')
True
>>> hasattr(macagua, 'email')
False

hash()

La función hash() devuelve un valor hash de tipo entero para el objeto.

>>> class Persona:
...     """Clase que representa una Persona"""
...     cedula = "V-13458796"
...     nombre = "Leonardo"
...     apellido = "Caballero"
...     sexo = "M"
...
>>> macagua = Persona
>>> 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.

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).

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).

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:
...     """Clase que representa una Persona"""
...     cedula = "V-13458796"
...     nombre = "Leonardo"
...     apellido = "Caballero"
...     sexo = "M"
...
>>> setattr(macagua, 'email', 'leonardoc@plone.org')
>>> getattr(macagua,'email')
'leonardoc@plone.org'

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.

Mapeando objetos

Evidentemente, siempre que la función map() la utilice correctamente podrá mapear una serie de objetos sin ningún problema:

>>> 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)
... ]
>>> 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:
...
...     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)
... ]
>>> 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

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.

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:

>>> def resta(a, b):
...     return a - b
...
>>> (b=30, a=10)
-20

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)

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.

Por posición

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])
5
Hola Plone
[1, 2, 3, 4, 5]

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:

>>> 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
l => [1, 2, 3, 4, 5]
n => 5

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
...     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
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í.

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():
...     return "Plone CMS", 20, [1,2,3]
...
>>> 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.

Bucle “for” con Listas

A continuación, se presenta un ejemplo del uso del bucle for con tipos de estructuras de datos listas:

animales = ['gato', 'perro', 'serpiente']
for animal in animales:
    print ("El animal es: {0}, tamaño de palabra es: {1}".format(
        animal, len(animal)))

Bucle “for” con Listas y función “range”

A continuación, se presenta un ejemplo del uso del bucle for con tipos de estructuras de datos listas con la función range() y la función len():

oracion = 'Mary entiende muy bien Python'
frases = oracion.split() # convierte a una lista cada palabra
print ("La oración analizada es:", oracion, ".\n")
for palabra in range(len(frases)):
    print ("Palabra: {0}, en la frase su posición es: {1}".format(
        frases[palabra], palabra))

Si se necesita iterar sobre una secuencia de números. Genera una lista conteniendo progresiones aritméticos, por ejemplo, como se hace en el fragmento de código fuente anterior.

Bucle “for” con Tuplas

A continuación, se presenta un ejemplo del uso del bucle for con tipos de estructuras de datos Tuplas:

conexion_bd = "127.0.0.1","root","123456","nomina"
for parametro in conexion_bd:
    print (parametro)

El ejemplo anterior itera una tupla de parámetros.

Bucle “for” con Diccionarios

A continuación, se presenta un ejemplo del uso del bucle for con tipos de estructuras de datos diccionarios:

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"
}
clave = datos_basicos.keys()
valor = datos_basicos.values()
cantidad_datos = datos_basicos.items()

for clave, valor in cantidad_datos:
    print (clave + ": " + valor)