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.
5.6.1.5. copyright()¶
Imprime el texto de la nota de copyright.
>>> copyright()
Copyright (c) 2001-2016 Python Software Foundation.
All Rights Reserved.
Copyright (c) 2000 BeOpen.com.
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',
'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError',
'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError',
'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError',
'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup',
'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError',
'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning',
'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError',
'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError',
'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError',
'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError',
'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning',
'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration',
'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError',
'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError',
'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning',
'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError',
'__IPYTHON__', '__build_class__', '__debug__', '__doc__', '__import__',
'__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter',
'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray',
'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright',
'credits', 'delattr', 'dict', 'dir', 'display', 'divmod', 'enumerate', 'eval',
'exec', 'filter', 'float', 'format', 'frozenset', 'get_ipython', 'getattr',
'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance',
'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max',
'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print',
'property', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice',
'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', '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:
... """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.11/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__', '__bool__', '__ceil__',
'__class__', '__delattr__', '__dir__', '__divmod__',
'__doc__', '__eq__', '__float__', '__floor__', '__floordiv__',
'__format__', '__ge__', '__getattribute__', '__getnewargs__',
'__getstate__', '__gt__', '__hash__', '__index__', '__init__',
'__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__',
'__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__',
'__or__', '__pos__', '__pow__', '__radd__', '__rand__',
'__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__',
'__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__',
'__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__',
'__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__',
'__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__',
'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate',
'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
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.11'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.11/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
See https://www.python.org/psf/license/
>>> license()
See https://www.python.org/psf/license/
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
rel archivo se abre en modo de solo lectura, no se puede escribir (argumento por defecto).
wmodo de solo escritura (si existe un archivo con el mismo nombre, se borra).
amodo de agregado (
append), los datos escritos se agregan al final del archivo.r+el archivo se abre para lectura y escritura al mismo tiempo.
bel archivo se abre en modo binario, para almacenar cualquier cosa que no sea texto.
Uel archivo se abre con soporte a nueva linea universal, cualquier fin de linea ingresada sera como un
\nen 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:
>>> from importlib import reload
>>> 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
>>> from importlib import reload
>>> 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.11/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'>
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, 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 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 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, 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. 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.9. 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.10. 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.11. 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.12. 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.13. 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.14. 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).7Es 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.dEs 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.0Ese es el carácter, el cual es colocado en lugar de los espacios vacíos.9Es 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)..3Ese es el operador de precisión que define la precisión del número flotante dado a 3 lugares.fEs 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.11", "python 3.11"
>>> 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.11, zope=5.2, plone=6.0)
{'zope': 5.2, 'python': 3.11, 'plone': 6.0}
También puede crear un diccionario indicando a las claves usando comillas simples:
>>> {"python": 3.11, "zope": 5.2, "plone": 6.0}
{'python': 3.11, 'zope': 2, 'plone': 6.0}
>>> dict({"python": 3.11, "zope": 5.2, "plone": 6.0})
{{'python': 3.11, '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.11, 5.2, 6.0]))
{'python': 3.11, '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.11), ("plone", 6.0)])
{'plone': 6.0, 'zope': 5.2, 'python': 3.11}
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.11, 5.2, 6.0])
[('python', 3.11), ('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 |
|
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.
