Última actualización: 01 de enero de 2023

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

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.

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', 'reduce', 'reload',
'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted',
'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'unichr',
'vars', '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/python3.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")
7

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 globals es 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 3.7's 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/3.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, symbols, or topics, type
"modules", "keywords", "symbols", or "topics".  Each module also comes
with a one-line summary of what it does; to list the modules whose name
or summary contain a given string 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 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:

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

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

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

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. 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/python3.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.19. 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()

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.

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

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

5.6.3.4. 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.5. 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.6. 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.7. 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'

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

5.6.3.9. 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.10. 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.11. 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

5.6.3.12. 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.13. 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.14. sum()

La función sum() devuelve una lista ordenada de los elementos de la secuencia que recibe como argumento (lista o cadena de caracteres). La secuencia original no es modificada.

>>> lista = [1, 2, 3, 4]
>>> sum(lista)
10

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

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")
0
>>> "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")
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

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 cadena 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 3.7", "python 3.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

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.

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

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

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

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

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 booleano igual 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=3.7, zope=5.2, plone=6.0)
{'zope': 5.2, 'python': 3.7, 'plone': 6.0}

También puede crear un diccionario indicando a las claves usando comillas simples:

>>> {"python": 3.7, "zope": 5.2, "plone": 6.0}
{'python': 3.7, 'zope': 2, 'plone': 6.0}
>>> dict({"python": 3.7, "zope": 5.2, "plone": 6.0})
{{'python': 3.7, 'zope': 5.2, 'plone': 6.0}

Convertir desde un grupo de dos listas de forma recursiva usando la función zip() a tipo diccionario:

>>> dict(zip(["python", "zope", "plone"], [3.7, 5.2, 6.0]))
{'python': 3.7, 'zope': 5.2, 'plone': 6.0}

Convertir desde un grupo de tuplas respectivamente en una lista a tipo diccionario:

>>> dict([("zope", 5.2), ("python", 3.7), ("plone", 6.0)])
{'plone': 6.0, 'zope': 5.2, 'python': 3.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)
>>> print(versiones_plone, type(versiones_plone))
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
<str_iterator object at 0x7f71666f85b0>
>>> next(elemento)
'P'
>>> next(elemento)
'l'
>>> next(elemento)
'o'
>>> next(elemento)
'n'
>>> next(elemento)
'e'
>>> 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 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)
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.

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

5.6.6.11. sorted()

La función sorted() devuelve una li:ref:lista <python_list>`sta ordenada de los elementos del tipo secuencia que recibe como argumento (:ref:`lista <python_list> 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"], [3.7, 5.2, 6.0])
[('python', 3.7), ('zope', 5.2), ('plone', 6.0)]

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:
...     """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'

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

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

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.

1
 
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:
...     """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'

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:

¿Cómo puedo ayudar?

¡Mi soporte está aquí para ayudar!

Mi horario de oficina es de lunes a sábado, de 9 AM a 5 PM. GMT-4 - Caracas, Venezuela.

La hora aquí es actualmente 7:35 PM GMT-4.

Mi objetivo es responder a todos los mensajes dentro de un día hábil.

Contáctenos en la sección de soporte
Contrata mi increíble soporte profesional