{"id":379,"date":"2024-11-27T19:13:02","date_gmt":"2024-11-27T19:13:02","guid":{"rendered":"https:\/\/equipomedios.com\/blog\/?p=379"},"modified":"2024-10-18T19:24:52","modified_gmt":"2024-10-18T19:24:52","slug":"funciones-integradas-python","status":"publish","type":"post","link":"https:\/\/equipomedios.com\/blog\/funciones-integradas-python\/","title":{"rendered":"Funciones integradas | Python"},"content":{"rendered":"

Funciones integradas<\/h1>\n

El interprete Python tiene un n\u00famero de funciones integradas (built-in) dentro del m\u00f3dulo\u00a0__builtins__<\/span><\/code>, las cuales est\u00e1n siempre disponibles. Estas funciones est\u00e1n listadas en orden alfab\u00e9ticos a continuaci\u00f3n:<\/p>\n

<\/span><\/p>\n

Funciones generales<\/h2>\n

Las funciones de uso general se describen a continuaci\u00f3n:<\/p>\n

<\/span><\/p>\n

apply()<\/h3>\n

La funci\u00f3n\u00a0apply()<\/span><\/code>\u00a0devuelve el resultado de una funci\u00f3n o objeto clase llamado con argumentos soportados.<\/p>\n

\n
\n
>>> <\/span>def<\/span> demo<\/span>(<\/span>valor1<\/span>,<\/span> valor2<\/span>,<\/span> valor3<\/span>=<\/span>None<\/span>):<\/span>\r\n... <\/span>    return<\/span> valor1<\/span>,<\/span> valor2<\/span>,<\/span> valor3<\/span>\r\n...<\/span>\r\n>>> <\/span>apply<\/span>(<\/span>demo<\/span>,<\/span> (<\/span>1<\/span>,<\/span> 2<\/span>),<\/span> {<\/span>'valor3'<\/span>:<\/span> 3<\/span>})<\/span>\r\n(1, 2, 3)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
callable()<\/h3>\n
La funci\u00f3n\u00a0callable()<\/span><\/code>\u00a0le indica si un objecto puede ser llamado.<\/p>\n
\n
\n
>>> <\/span>callable<\/span>([<\/span>1<\/span>,<\/span>2<\/span>,<\/span>3<\/span>])<\/span>\r\nFalse<\/span>\r\n>>> <\/span>callable<\/span>(<\/span>callable<\/span>)<\/span>\r\nTrue<\/span>\r\n>>> <\/span>callable<\/span>(<\/span>False<\/span>)<\/span>\r\nFalse<\/span>\r\n>>> <\/span>callable<\/span>(<\/span>list<\/span>)<\/span>\r\nTrue<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Una funci\u00f3n se puede llamar, una lista no se puede llamar. Incluso la funci\u00f3n integrada\u00a0callable()<\/span><\/code>\u00a0se puede llamar.<\/p>\n<\/div>\n
<\/span><\/p>\n
compile()<\/h3>\n
La funci\u00f3n\u00a0compile()<\/span><\/code>\u00a0devuelve un c\u00f3digo objeto Python. Usted usa la funci\u00f3n integrada Python para convertir de la cadena de caracteres de c\u00f3digo al c\u00f3digo objeto.<\/p>\n
\n
\n
>>><\/span>\r\n>>> <\/span>exec<\/span>(<\/span>compile<\/span>(<\/span>'a=5<\/span>\\n<\/span>b=7<\/span>\\n<\/span>print a+b'<\/span>,<\/span>''<\/span>,<\/span>'exec'<\/span>))<\/span>\r\n12<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Aqu\u00ed,\u00a0exec<\/span><\/code>\u00a0es el modo. El par\u00e1metro anterior que eso es el nombre del archivo para la forma del archivo el cual el c\u00f3digo es le\u00eddo. Finalmente, es ejecutado usando la funci\u00f3n\u00a0exec()<\/span><\/code>.<\/p>\n<\/div>\n
<\/span><\/p>\n
credits()<\/h3>\n
Imprime el texto de la lista de contribuidores.<\/p>\n
\n
\n
>>> <\/span>credits<\/span>()<\/span>\r\n    Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands<\/span>\r\n    for supporting Python development.  See www.python.org for more information.<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
copyright()<\/h3>\n
Imprime el texto de la nota de copyright.<\/p>\n
\n
\n
>>> <\/span>copyright<\/span>()<\/span>\r\nCopyright (c) 2001-2016 Python Software Foundation.<\/span>\r\nAll Rights Reserved.<\/span>\r\n\r\nCopyright (c) 2000 BeOpen.com.<\/span>\r\nAll Rights Reserved.<\/span>\r\n\r\nCopyright (c) 1995-2001 Corporation for National Research Initiatives.<\/span>\r\nAll Rights Reserved.<\/span>\r\n\r\nCopyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.<\/span>\r\nAll Rights Reserved.<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
dir()<\/h3>\n
Si es llamado sin argumentos, devuelve los nombres en el \u00e1mbito actual.<\/p>\n
\n
\n
>>> <\/span>dir<\/span>()<\/span>\r\n['__builtins__', '__doc__', '__name__', '__package__']<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
De lo contrario, devuelve una lista alfab\u00e9tica de nombres que comprende (alguno(s) de) los atributos de un objeto dato, y de los atributos legibles desde este.<\/p>\n
\n
\n
>>> <\/span>dir<\/span>(<\/span>__builtins__<\/span>)<\/span>\r\n['ArithmeticError', 'AssertionError', 'AttributeError',<\/span>\r\n'BaseException', 'BufferError', 'BytesWarning',<\/span>\r\n'DeprecationWarning', 'EOFError', 'Ellipsis',<\/span>\r\n'EnvironmentError', 'Exception', 'False', 'FloatingPointError',<\/span>\r\n'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError',<\/span>\r\n'ImportWarning', 'IndentationError', 'IndexError', 'KeyError',<\/span>\r\n'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError',<\/span>\r\n'None', 'NotImplemented', 'NotImplementedError', 'OSError',<\/span>\r\n'OverflowError', 'PendingDeprecationWarning', 'ReferenceError',<\/span>\r\n'RuntimeError', 'RuntimeWarning', 'StandardError',<\/span>\r\n'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError',<\/span>\r\n'SystemExit', 'TabError', 'True', 'TypeError',<\/span>\r\n'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError',<\/span>\r\n'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning',<\/span>\r\n'UserWarning', 'ValueError', 'Warning', 'ZeroDivisionError',<\/span>\r\n'_', '__debug__', '__doc__', '__import__', '__name__',<\/span>\r\n'__package__', 'abs', 'all', 'any', 'apply', 'basestring',<\/span>\r\n'bin', 'bool', 'buffer', 'bytearray', 'bytes', 'callable',<\/span>\r\n'chr', 'classmethod', 'cmp', 'coerce', 'compile', 'complex',<\/span>\r\n'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod',<\/span>\r\n'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter',<\/span>\r\n'float', 'format', 'frozenset', 'getattr', 'globals',<\/span>\r\n'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int',<\/span>\r\n'intern', 'isinstance', 'issubclass', 'iter', 'len',<\/span>\r\n'license', 'list', 'locals', 'long', 'map', 'max', 'memoryview',<\/span>\r\n'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print',<\/span>\r\n'property', 'quit', 'range', 'raw_input', 'reduce', 'reload',<\/span>\r\n'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted',<\/span>\r\n'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'unichr',<\/span>\r\n'unicode', 'vars', 'xrange', 'zip']<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Si el objeto soporta un m\u00e9todo llamado\u00a0__dir__<\/span><\/code>, ese ser\u00e1 usado; de lo contrario se usa la l\u00f3gica\u00a0dir()<\/span><\/code>\u00a0predeterminada y devuelve:<\/p>\n
    \n
  • para un objeto m\u00f3dulo: los atributos del m\u00f3dulo.<\/li>\n<\/ul>\n
    \n
    \n
    >>> <\/span>import<\/span> os<\/span>\r\n>>> <\/span>type<\/span>(<\/span>os<\/span>)<\/span>\r\n<type 'module'><\/span>\r\n>>> <\/span>dir<\/span>(<\/span>os<\/span>)<\/span>\r\n['EX_CANTCREAT', 'EX_CONFIG', 'EX_DATAERR', 'EX_IOERR',<\/span>\r\n'EX_NOHOST', 'EX_NOINPUT', 'EX_NOPERM', 'EX_NOUSER',<\/span>\r\n'EX_OK', 'EX_OSERR', 'EX_OSFILE', 'EX_PROTOCOL',<\/span>\r\n'EX_SOFTWARE', 'EX_TEMPFAIL', 'EX_UNAVAILABLE', 'EX_USAGE',<\/span>\r\n'F_OK', 'NGROUPS_MAX', 'O_APPEND', 'O_ASYNC', 'O_CREAT',<\/span>\r\n'O_DIRECT', 'O_DIRECTORY', 'O_DSYNC', 'O_EXCL', 'O_LARGEFILE',<\/span>\r\n'O_NDELAY', 'O_NOATIME', 'O_NOCTTY', 'O_NOFOLLOW', 'O_NONBLOCK',<\/span>\r\n'O_RDONLY', 'O_RDWR', 'O_RSYNC', 'O_SYNC', 'O_TRUNC', 'O_WRONLY',<\/span>\r\n'P_NOWAIT', 'P_NOWAITO', 'P_WAIT', 'R_OK', 'SEEK_CUR', 'SEEK_END',<\/span>\r\n'SEEK_SET', 'ST_APPEND', 'ST_MANDLOCK', 'ST_NOATIME', 'ST_NODEV',<\/span>\r\n'ST_NODIRATIME', 'ST_NOEXEC', 'ST_NOSUID', 'ST_RDONLY',<\/span>\r\n'ST_RELATIME', 'ST_SYNCHRONOUS', 'ST_WRITE', 'TMP_MAX', 'UserDict',<\/span>\r\n'WCONTINUED', 'WCOREDUMP', 'WEXITSTATUS', 'WIFCONTINUED', 'WIFEXITED',<\/span>\r\n'WIFSIGNALED', 'WIFSTOPPED', 'WNOHANG', 'WSTOPSIG', 'WTERMSIG',<\/span>\r\n'WUNTRACED', 'W_OK', 'X_OK', '_Environ', '__all__', '__builtins__',<\/span>\r\n'__doc__', '__file__', '__name__',<\/span>\r\n...<\/span>\r\n...<\/span>\r\n... <\/span>]<\/span>\r\n>>> <\/span>print<\/span> os<\/span>.<\/span>__doc__<\/span>\r\nOS routines for NT or Posix depending on what system we're on.<\/span>\r\n\r\nThis exports:<\/span>\r\n  - all functions from posix, nt, os2, or ce, e.g. unlink, stat, etc.<\/span>\r\n  - os.path is one of the modules posixpath, or ntpath<\/span>\r\n  - os.name is 'posix', 'nt', 'os2', 'ce' or 'riscos'<\/span>\r\n  - os.curdir is a string representing the current directory ('.' or ':')<\/span>\r\n  - os.pardir is a string representing the parent directory ('..' or '::')<\/span>\r\n  - os.sep is the (or a most common) pathname separator ('\/' or ':' or '\\\\')<\/span>\r\n...<\/span>\r\n...<\/span>\r\n...<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
      \n
    • para un objeto clase: sus atributos, y recursivamente los atributos de sus clases bases.<\/li>\n<\/ul>\n
      \n
      \n
      >>> <\/span>class<\/span> Persona<\/span>(<\/span>object<\/span>):<\/span>\r\n... <\/span>    \"\"\"Clase que representa una Persona\"\"\"<\/span>\r\n... <\/span>    def<\/span> __init__<\/span>(<\/span>self<\/span>,<\/span> cedula<\/span>,<\/span> nombre<\/span>,<\/span> apellido<\/span>,<\/span> sexo<\/span>):<\/span>\r\n... <\/span>        \"\"\" Constructor de clase Persona \"\"\"<\/span>\r\n... <\/span>        self<\/span>.<\/span>cedula<\/span> =<\/span> cedula<\/span>\r\n... <\/span>        self<\/span>.<\/span>nombre<\/span> =<\/span> nombre<\/span>\r\n... <\/span>        self<\/span>.<\/span>apellido<\/span> =<\/span> apellido<\/span>\r\n... <\/span>        self<\/span>.<\/span>sexo<\/span> =<\/span> sexo<\/span>\r\n... <\/span>    def<\/span> __str__<\/span>(<\/span>self<\/span>):<\/span>\r\n... <\/span>        \"\"\"Devuelve una cadena representativa al Persona\"\"\"<\/span>\r\n... <\/span>        return<\/span> \"<\/span>%s<\/span>: <\/span>%s<\/span> %s<\/span>, <\/span>%s<\/span>.\"<\/span> %<\/span> (<\/span>\r\n... <\/span>            str<\/span>(<\/span>self<\/span>.<\/span>cedula<\/span>),<\/span> self<\/span>.<\/span>nombre<\/span>,<\/span>\r\n... <\/span>            self<\/span>.<\/span>apellido<\/span>,<\/span> self<\/span>.<\/span>sexo<\/span>\r\n... <\/span>        )<\/span>\r\n... <\/span>    def<\/span> hablar<\/span>(<\/span>self<\/span>,<\/span> mensaje<\/span>):<\/span>\r\n... <\/span>        \"\"\"Mostrar mensaje de saludo de Persona\"\"\"<\/span>\r\n... <\/span>        print<\/span> mensaje<\/span>\r\n...<\/span>\r\n>>> <\/span>type<\/span>(<\/span>Persona<\/span>)<\/span>\r\n<type 'type'><\/span>\r\n>>> <\/span>vars<\/span>()<\/span>\r\n{'Persona': <class '__main__.Persona'>,<\/span>\r\n'__builtins__': <module '__builtin__' (built-in)>,<\/span>\r\n'__package__': None, '__name__': '__main__',<\/span>\r\n'os': <module 'os' from '\/usr\/lib\/python2.7\/os.pyc'>,<\/span>\r\n'__doc__': None}<\/span>\r\n>>> <\/span>dir<\/span>(<\/span>Persona<\/span>)<\/span>\r\n['__class__', '__delattr__', '__dict__', '__doc__',<\/span>\r\n'__format__', '__getattribute__', '__hash__',<\/span>\r\n'__init__', '__module__', '__new__', '__reduce__',<\/span>\r\n'__reduce_ex__', '__repr__', '__setattr__',<\/span>\r\n'__sizeof__', '__str__', '__subclasshook__',<\/span>\r\n'__weakref__', 'hablar']<\/span>\r\n>>> <\/span>Persona<\/span>.<\/span>__dict__<\/span>\r\ndict_proxy({'__module__': '__main__',<\/span>\r\n'__str__': <function __str__ at 0x7fab8aaad758>,<\/span>\r\n'__dict__': <attribute '__dict__' of 'Persona' objects>,<\/span>\r\n'hablar': <function hablar at 0x7fab8aaad7d0>,<\/span>\r\n'__weakref__': <attribute '__weakref__' of 'Persona' objects>,<\/span>\r\n'__doc__': ' Clase que representa una persona. ',<\/span>\r\n'__init__': <function __init__ at 0x7fab8aaad6e0>})<\/span>\r\n>>> <\/span>Persona<\/span>.<\/span>__doc__<\/span>\r\n' Clase que representa una persona. '<\/span>\r\n>>> <\/span>Persona<\/span>.<\/span>__init__<\/span>.<\/span>__doc__<\/span>\r\n' Constructor de clase Persona '<\/span>\r\n>>> <\/span>Persona<\/span>.<\/span>hablar<\/span>.<\/span>__doc__<\/span>\r\n' Mostrar mensaje de saludo de Persona '<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
        \n
      • para cualquier otro objecto: sus atributos, sus atributos de clases, y recursivamente los atributos de esas clases bases de las clases.<\/li>\n<\/ul>\n
        \n
        \n
        >>> <\/span>type<\/span>(<\/span>int<\/span>)<\/span>\r\n<type 'type'><\/span>\r\n>>> <\/span>dir<\/span>(<\/span>int<\/span>)<\/span>\r\n['__abs__', '__add__', '__and__', '__class__', '__cmp__',<\/span>\r\n'__coerce__', '__delattr__', '__div__', '__divmod__',<\/span>\r\n'__doc__', '__float__', '__floordiv__', '__format__',<\/span>\r\n'__getattribute__', '__getnewargs__', '__hash__', '__hex__',<\/span>\r\n'__index__', '__init__', '__int__', '__invert__', '__long__',<\/span>\r\n'__lshift__', '__mod__', '__mul__', '__neg__', '__new__',<\/span>\r\n'__nonzero__', '__oct__', '__or__', '__pos__', '__pow__',<\/span>\r\n'__radd__', '__rand__', '__rdiv__', '__rdivmod__', '__reduce__',<\/span>\r\n'__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__',<\/span>\r\n'__rmod__', '__rmul__', '__ror__', '__rpow__', '__rrshift__',<\/span>\r\n'__rshift__', '__rsub__', '__rtruediv__', '__rxor__',<\/span>\r\n'__setattr__', '__sizeof__', '__str__', '__sub__',<\/span>\r\n'__subclasshook__', '__truediv__', '__trunc__', '__xor__',<\/span>\r\n'bit_length', 'conjugate', 'denominator', 'imag', 'numerator',<\/span>\r\n'real']<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
        <\/span><\/p>\n
        eval()<\/h3>\n
        Eval\u00faa una cadena como una expresi\u00f3n:<\/p>\n
        \n
        \n
        >>> <\/span>eval<\/span>(<\/span>'2 + 5'<\/span>)<\/span>\r\n7<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
        Ademas si se han definido anteriormente variables las acepta como par\u00e1metros:<\/p>\n
        \n
        \n
        >>> <\/span>numero<\/span> =<\/span> 10<\/span>\r\n>>> <\/span>eval<\/span>(<\/span>'numero * 10 - 5'<\/span>)<\/span>\r\n95<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
        <\/span><\/p>\n
        execfile()<\/h3>\n
        La funci\u00f3n\u00a0execfile()<\/span><\/code>\u00a0lee y ejecuta un script Python desde un archivo. Los\u00a0globals<\/span><\/code>\u00a0y\u00a0locals<\/span><\/code>\u00a0son diccionarios, por defecto a los actuales\u00a0globals<\/span><\/code>\u00a0y\u00a0locals<\/span><\/code>. Si solamente\u00a0globals<\/span><\/code>\u00a0es dado,\u00a0locals<\/span><\/code>\u00a0es por defecto a la misma.<\/p>\n
        \n
        \n
        >>> <\/span>execfile<\/span>(<\/span>'.\/holamundo.py'<\/span>)<\/span>\r\nHola Mundo<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
        <\/span><\/p>\n
        globals()<\/h3>\n
        La funci\u00f3n\u00a0globals()<\/span><\/code>\u00a0devuelve un diccionario conteniendo \u00e1mbito actual global de las variables.<\/p>\n
        \n
        \n
        >>> <\/span>globals<\/span>()<\/span>\r\n{'__builtins__': <module '__builtin__' (built-in)>,<\/span>\r\n'__package__': None, '__name__': '__main__', '__doc__': None}<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
        La funci\u00f3n\u00a0globals()<\/span><\/code>\u00a0puede ser usada para devolver los nombres en el\u00a0namespaces<\/span><\/code>\u00a0global dependiendo en la locaci\u00f3n desde donde ella es llamada.<\/p>\n
        Si la funci\u00f3n\u00a0globals()<\/span><\/code>\u00a0es llamada desde una funci\u00f3n, eso devolver\u00e1 todos los nombres que pueden ser accesibles globalmente desde esa funci\u00f3n.<\/p>\n
        El tipo de dato devuelto por funci\u00f3n es un tipo diccionario. Por lo tanto, los nombres pueden ser extra\u00eddos usando la funci\u00f3n integrada\u00a0keys()<\/span><\/code>.<\/p>\n<\/div>\n
        <\/span><\/p>\n
        help()<\/h3>\n
        Invoca el men\u00fa de ayuda del int\u00e9rprete de Python:<\/p>\n
        \n
        \n
        >>> <\/span>help<\/span>()<\/span>\r\n\r\nWelcome to Python 2.7!  This is the online help utility.<\/span>\r\n\r\nIf this is your first time using Python, you should definitely check out<\/span>\r\nthe tutorial on the Internet at https:\/\/docs.python.org\/2.7\/tutorial\/.<\/span>\r\n\r\nEnter the name of any module, keyword, or topic to get help on writing<\/span>\r\nPython programs and using Python modules.  To quit this help utility and<\/span>\r\nreturn to the interpreter, just type \"quit\".<\/span>\r\n\r\nTo get a list of available modules, keywords, or topics, type \"modules\",<\/span>\r\n\"keywords\", or \"topics\".  Each module also comes with a one-line summary<\/span>\r\nof what it does; to list the modules whose summaries contain a given word<\/span>\r\nsuch as \"spam\", type \"modules spam\".<\/span>\r\n\r\nhelp><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
        <\/span><\/p>\n
        id()<\/h3>\n
        La funci\u00f3n\u00a0id()<\/span><\/code>\u00a0devuelve la identidad de un objecto. Esto garantiza ser el \u00fanico entre objetos simult\u00e1neamente existentes. (Sugerencia: es la direcci\u00f3n de memoria del objeto).<\/p>\n
        \n
        \n
        >>> <\/span>lista<\/span> =<\/span> range<\/span>(<\/span>5<\/span>)<\/span>\r\n>>> <\/span>lista<\/span>\r\n[0, 1, 2, 3, 4]<\/span>\r\n>>> <\/span>id<\/span>(<\/span>lista<\/span>)<\/span>\r\n139703096777904<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
        <\/span><\/p>\n
        len()<\/h3>\n
        Devuelve el n\u00famero de elementos de un tipo de secuencia o colecci\u00f3n.<\/p>\n
        \n
        \n
        >>> <\/span>len<\/span>(<\/span>\"leonardo caballero\"<\/span>)<\/span>\r\n18<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
        <\/span><\/p>\n
        license()<\/h3>\n
        Imprime el texto de la licencia.<\/p>\n
        \n
        \n
        >>> <\/span>license<\/span>\r\nType license() to see the full license text<\/span>\r\n>>> <\/span>license<\/span>()<\/span>\r\nA. HISTORY OF THE SOFTWARE<\/span>\r\n==========================<\/span>\r\n\r\nPython was created in the early 1990s by Guido van Rossum at Stichting<\/span>\r\nMathematisch Centrum (CWI, see http:\/\/www.cwi.nl) in the Netherlands<\/span>\r\nas a successor of a language called ABC.  Guido remains Python's<\/span>\r\nprincipal author, although it includes many contributions from others.<\/span>\r\n\r\nIn 1995, Guido continued his work on Python at the Corporation for<\/span>\r\nNational Research Initiatives (CNRI, see http:\/\/www.cnri.reston.va.us)<\/span>\r\nin Reston, Virginia where he released several versions of the<\/span>\r\nsoftware.<\/span>\r\n\r\nIn May 2000, Guido and the Python core development team moved to<\/span>\r\nBeOpen.com to form the BeOpen PythonLabs team.  In October of the same<\/span>\r\nyear, the PythonLabs team moved to Digital Creations (now Zope<\/span>\r\nCorporation, see http:\/\/www.zope.com).  In 2001, the Python Software<\/span>\r\nFoundation (PSF, see https:\/\/www.python.org\/psf\/) was formed, a<\/span>\r\nnon-profit organization created specifically to own Python-related<\/span>\r\nIntellectual Property.  Zope Corporation is a sponsoring member of<\/span>\r\nthe PSF.<\/span>\r\n\r\nAll Python releases are Open Source (see http:\/\/www.opensource.org for<\/span>\r\nHit Return for more, or q (and Return) to quit:<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
        <\/span><\/p>\n
        locals()<\/h3>\n
        La funci\u00f3n\u00a0locals()<\/span><\/code>\u00a0devuelve un diccionario conteniendo \u00e1mbito actual local de las variables.<\/p>\n
        \n
        \n
        >>> <\/span>locals<\/span>()<\/span>\r\n{'__builtins__': <module '__builtin__' (built-in)>,<\/span>\r\n'__package__': None, '__name__': '__main__', '__doc__': None}<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
        La funci\u00f3n\u00a0locals()<\/span><\/code>\u00a0puede ser usadas para devolver los nombres en el\u00a0namespaces<\/span><\/code>\u00a0local dependiendo en la locaci\u00f3n desde donde ella es llamada.<\/p>\n
        Si la funci\u00f3n\u00a0locals()<\/span><\/code>\u00a0es llamada desde una funci\u00f3n, eso devolver\u00e1 todos los nombres que pueden ser accesibles localmente desde esa funci\u00f3n.<\/p>\n
        El tipo de dato devuelto por la funci\u00f3n es un tipo diccionario. Por lo tanto, los nombres pueden ser extra\u00eddos usando la funci\u00f3n integrada\u00a0keys()<\/span><\/code>.<\/p>\n<\/div>\n
        <\/span><\/p>\n
        open()<\/h3>\n
        La funci\u00f3n\u00a0open()<\/span><\/code>\u00a0es definida dentro del modulo integrado\u00a0io<\/span><\/code>, esta le permite\u00a0abrir un archivo<\/span>\u00a0usando el tipo objeto\u00a0file<\/span><\/code>, devuelve un objeto del tipo\u00a0file<\/span>\u00a0(ej.\u00a0archivo<\/em>), y se llama habitualmente con de dos a tres argumentos:<\/p>\n
        \n
        \n
        file<\/span>(<\/span>nombre<\/span>[,<\/span> modo<\/span>[,<\/span> buffering<\/span>]])<\/span> -><\/span> objeto<\/span> archivo<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
        Los argumentos son:<\/p>\n
          \n
        • \n
          nombre<\/span><\/code>, es una\u00a0cadena de caracteres<\/span>\u00a0que indica el\u00a0nombre de archivo<\/em>\u00a0(incluso ruta relativa o absoluta).<\/p>\n<\/li>\n
        • \n
          modo<\/span><\/code>, es una cadena de unos pocos caracteres describiendo la forma en la que se usar\u00e1 el archivo, como se indica a continuaci\u00f3n:<\/p>\n\n\n\n<\/colgroup>\n\n\n\n\n\n\n\n\n
          Modo<\/strong><\/td>\nNotas<\/strong><\/td>\n<\/tr>\n
          r<\/span><\/code><\/td>\nel archivo se abre en modo de solo lectura, no se puede escribir (argumento por defecto).<\/td>\n<\/tr>\n
          w<\/span><\/code><\/td>\nmodo de solo escritura (si existe un archivo con el mismo nombre, se borra).<\/td>\n<\/tr>\n
          a<\/span><\/code><\/td>\nmodo de agregado (append<\/span><\/code>), los datos escritos se agregan al final del archivo.<\/td>\n<\/tr>\n
          r+<\/span><\/code><\/td>\nel archivo se abre para lectura y escritura al mismo tiempo.<\/td>\n<\/tr>\n
          b<\/span><\/code><\/td>\nel archivo se abre en modo binario, para almacenar cualquier cosa que no sea texto.<\/td>\n<\/tr>\n
          U<\/span><\/code><\/td>\nel archivo se abre con soporte a nueva linea universal, cualquier fin de linea ingresada sera como un\u00a0\\n<\/span><\/code>\u00a0en Python.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/li>\n
        • \n
          buffering<\/span><\/code>, si este argumento es dado, 0 significa sin b\u00fafer, 1 significa b\u00fafer de l\u00ednea y los n\u00fameros m\u00e1s grandes especifican el tama\u00f1o del b\u00fafer.<\/p>\n<\/li>\n<\/ul>\n
          Para crear y abrir un archivo, seria as\u00ed:<\/p>\n
          \n
          \n
          >>> <\/span>archivo<\/span> =<\/span> open<\/span>(<\/span>'datos.txt'<\/span>,<\/span> 'w'<\/span>)<\/span>\r\n>>> <\/span>type<\/span>(<\/span>archivo<\/span>)<\/span>\r\n<type 'file'><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          El archivo ser\u00e1 creado si no existe cuando es abierto para escribir o agregar data. Es archivo sera truncado cuando es abierto para escritura.<\/p>\n
          Agregue una \u201cU\u201d a modo para abrir el archivo para la entrada con soporte de nueva l\u00ednea universal. Cualquier l\u00ednea que termine en el archivo de entrada se ver\u00e1 como \u201cn\u201d en Python. Adem\u00e1s, un archivo as\u00ed abierto gana el atributo\u00a0newlines<\/span><\/code>; el valor para este atributo es uno de Ninguno (a\u00fan no se ha le\u00eddo una nueva l\u00ednea),\u00a0\\r<\/span><\/code>,\u00a0\\n<\/span><\/code>,\u00a0\\r\\n<\/span><\/code>\u00a0o una tupla que contiene todos los tipos de nueva l\u00ednea que se han visto.<\/p>\n
          \n
          Truco<\/p>\n
          Ver para futura informaci\u00f3n desde el\u00a0modo interactivo<\/span>\u00a0Python, lo siguiente:<\/p>\n
          \n
          \n
          >>> <\/span>file<\/span>.<\/span>__doc__<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          range()<\/h3>\n
          La funci\u00f3n\u00a0range()<\/span><\/code>\u00a0devuelve una lista conteniendo una progresi\u00f3n aritm\u00e9tica de enteros.<\/p>\n
          range(inicio, detener[, paso]) -> lista de enteros<\/p>\n
          \n
          \n
          \n
          \n
          >>> <\/span>range<\/span>(<\/span>3<\/span>,<\/span>9<\/span>)<\/span>\r\n[3, 4, 5, 6, 7, 8]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/blockquote>\n
          range(i,<\/span>\u00a0j)<\/span><\/code>\u00a0devuelve\u00a0[i,<\/span>\u00a0i+1,<\/span>\u00a0i+2,<\/span>\u00a0...,<\/span>\u00a0j-1]<\/span><\/code>; inicia (!) por defecto en\u00a00<\/strong>.<\/p>\n
          Cuando el\u00a0paso<\/span><\/code>\u00a0es definido como un tercer argumento, ese especifica el incremento (o decremento).<\/p>\n
          \n
          \n
          \n
          \n
          >>> <\/span>range<\/span>(<\/span>3<\/span>,<\/span>9<\/span>,<\/span>2<\/span>)<\/span>\r\n[3, 5, 7]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/blockquote>\n
          En el ejemplo anterior, la funci\u00f3n\u00a0range(3,9,2)<\/span><\/code>\u00a0devuelve\u00a0[3, 5, 7]<\/strong>, es decir, el rango inicia en\u00a03<\/strong>\u00a0y termina en\u00a09<\/strong>\u00a0incrementando cada\u00a02<\/strong>\u00a0n\u00fameros.<\/p>\n
          range(detener) -> lista de enteros<\/p>\n
          \n
          \n
          \n
          \n
          >>> <\/span>range<\/span>(<\/span>4<\/span>)<\/span>\r\n[0, 1, 2, 3]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/blockquote>\n
          En el ejemplo anterior, la funci\u00f3n\u00a0range(4)<\/span><\/code>\u00a0devuelve\u00a0[0, 1, 2, 3]<\/strong>. \u00a1El punto final es omitido! Hay exactamente los indices validos para una lista de\u00a04<\/strong>\u00a0elementos.<\/p>\n<\/div>\n
          <\/span><\/p>\n
          reload()<\/h3>\n
          Cuando el modulo es importado dentro de un script, el c\u00f3digo en la porci\u00f3n del nivel superior de un modulo es ejecutado solamente una vez.<\/p>\n
          Por lo tanto, si usted quiere volver a ejecutar la porci\u00f3n del nivel superior el c\u00f3digo de un modulo, usted puede usar la funci\u00f3n\u00a0reload()<\/span><\/code>. Esta funci\u00f3n importa otra vez un modulo previamente importado. La sintaxis de la funci\u00f3n\u00a0reload()<\/span><\/code>\u00a0es la siguiente:<\/p>\n
          \n
          \n
          >>> <\/span>reload<\/span>(<\/span>module_name<\/span>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          Aqu\u00ed,\u00a0module_name<\/span><\/code>\u00a0es el nombre del modulo que usted quiere volver a cargar y no la\u00a0cadena de caracteres<\/span>\u00a0contendiente el nombre del modulo. Por ejemplo, para recargar el modulo\u00a0clases.py<\/span><\/code>, debe hacer lo siguiente:<\/p>\n
          \n
          \n
          >>> <\/span>import<\/span> clases<\/span>\r\n>>> <\/span>reload<\/span>(<\/span>clases<\/span>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          xrange()<\/h3>\n
          El tipo\u00a0xrange<\/span><\/code>\u00a0es un tipo secuencia inmutable utilizada normalmente en bucles. La ventaja de la funci\u00f3n\u00a0xrange()<\/span><\/code>\u00a0sobre la funci\u00f3n\u00a0range()<\/span><\/code>, es que devuelve un objeto\u00a0xrange<\/span><\/code>\u00a0el cual ocupa siempre la misma cantidad de memoria, independientemente del rango el cual represente.<\/p>\n
          \n
          \n
          >>> <\/span>for<\/span> item<\/span> in<\/span> range<\/span>(<\/span>5<\/span>):<\/span>\r\n... <\/span>    print<\/span> item<\/span>\r\n...<\/span>\r\n0<\/span>\r\n1<\/span>\r\n2<\/span>\r\n3<\/span>\r\n4<\/span>\r\n>>> <\/span>for<\/span> item<\/span> in<\/span> xrange<\/span>(<\/span>5<\/span>):<\/span>\r\n... <\/span>    print<\/span> item<\/span>\r\n...<\/span>\r\n0<\/span>\r\n1<\/span>\r\n2<\/span>\r\n3<\/span>\r\n4<\/span>\r\n>>><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          Como la funci\u00f3n\u00a0xrange()<\/span><\/code>, devuelve un objeto el cual genera los n\u00fameros en el rango a demanda. Para bucles, esto es un poco mas r\u00e1pido que la funci\u00f3n\u00a0range()<\/span><\/code>\u00a0y m\u00e1s eficiente en la memoria.<\/p>\n
          \n
          \n
          >>> <\/span>print<\/span> xrange<\/span>(<\/span>5<\/span>)<\/span>\r\nxrange(5)<\/span>\r\n>>> <\/span>type<\/span>(<\/span>xrange<\/span>(<\/span>5<\/span>))<\/span>\r\n<type 'xrange'><\/span>\r\n>>> <\/span>dir<\/span>(<\/span>xrange<\/span>(<\/span>5<\/span>))<\/span>\r\n['__class__', '__delattr__', '__doc__', '__format__',<\/span>\r\n'__getattribute__', '__getitem__', '__hash__', '__init__',<\/span>\r\n'__iter__', '__len__', '__new__', '__reduce__', '__reduce_ex__',<\/span>\r\n'__repr__', '__reversed__', '__setattr__', '__sizeof__',<\/span>\r\n'__str__', '__subclasshook__']<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          La ventaja de la funci\u00f3n\u00a0xrange()<\/span><\/code>\u00a0es\u00a0excepto<\/em>\u00a0en hardware impedido en cuesti\u00f3n de memoria (por ejemplo, MS-DOS) o cuando nunca se utilizan todos los elementos del rango (por ejemplo, porque se suele interrumpir la ejecuci\u00f3n del bucle con la sentencia\u00a0break<\/span>).<\/p>\n<\/div>\n
          <\/span><\/p>\n
          type()<\/h3>\n
          La funci\u00f3n\u00a0type()<\/span><\/code>\u00a0devuelve el tipo del objeto que recibe como argumento.<\/p>\n
          \n
          \n
          >>> <\/span>type<\/span>(<\/span>2<\/span>)<\/span>\r\n<type 'int'><\/span>\r\n>>> <\/span>type<\/span>(<\/span>2.5<\/span>)<\/span>\r\n<type 'float'><\/span>\r\n>>> <\/span>type<\/span>(<\/span>True<\/span>)<\/span>\r\n<type 'bool'><\/span>\r\n>>> <\/span>type<\/span>(<\/span>\"Hola Mundo\"<\/span>)<\/span>\r\n<type 'str'><\/span>\r\n>>> <\/span>type<\/span>(<\/span>int<\/span>)<\/span>\r\n<type 'type'><\/span>\r\n>>> <\/span>type<\/span>(<\/span>str<\/span>)<\/span>\r\n<type 'type'><\/span>\r\n>>> <\/span>type<\/span>(<\/span>None<\/span>)<\/span>\r\n<type 'NoneType'><\/span>\r\n>>> <\/span>type<\/span>(<\/span>object<\/span>)<\/span>\r\n<type 'type'><\/span>\r\n>>> <\/span>import<\/span> os<\/span>\r\n>>> <\/span>type<\/span>(<\/span>os<\/span>)<\/span>\r\n<type 'module'><\/span>\r\n>>> <\/span>type<\/span>(<\/span>format<\/span>)<\/span>\r\n<type 'builtin_function_or_method'><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          \n
          Truco<\/p>\n
          La funci\u00f3n\u00a0type()<\/span><\/code>\u00a0devuelve el tipo del objeto, en base al modulo integrado\u00a0types<\/span><\/code>, el cual define los nombres para todos los s\u00edmbolos tipo conocidos en el interprete est\u00e1ndar.<\/p>\n
          \n
          \n
          >>> <\/span>import<\/span> types<\/span>\r\n>>> <\/span>help<\/span>(<\/span>types<\/span>)<\/span>\r\n\r\nHelp on module types:<\/span>\r\n\r\nNAME<\/span>\r\n    types - Define names for all type symbols known in the standard interpreter.<\/span>\r\n\r\nFILE<\/span>\r\n    \/usr\/lib\/python2.7\/types.py<\/span>\r\n\r\nMODULE DOCS<\/span>\r\n    https:\/\/docs.python.org\/library\/types<\/span>\r\n\r\nDESCRIPTION<\/span>\r\n    Types that are part of optional modules (e.g. array) are not listed.<\/span>\r\n\r\nCLASSES<\/span>\r\n    __builtin__.basestring(__builtin__.object)<\/span>\r\n        __builtin__.str<\/span>\r\n        __builtin__.unicode<\/span>\r\n\r\n>>><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          vars()<\/h3>\n
          La funci\u00f3n\u00a0vars()<\/span><\/code>\u00a0devuelve un diccionario conteniendo \u00e1mbito actual de las variables.<\/p>\n
          \n
          \n
          >>> <\/span>vars<\/span>()<\/span>\r\n{'__builtins__': <module '__builtin__' (built-in)>, '__package__':<\/span>\r\nNone, '__name__': '__main__', '__doc__': None}<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          La funci\u00f3n\u00a0vars()<\/span><\/code>\u00a0sin argumentos, equivale a la funci\u00f3n\u00a0locals()<\/span>. Si se llama con un argumento equivale a la sentencia\u00a0object.__dict__<\/span><\/code>.<\/p>\n
          \n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          Funciones de entrada y salida<\/h2>\n
          Las funciones de tipos num\u00e9ricos se describen a continuaci\u00f3n:<\/p>\n
          <\/span><\/p>\n
          input()<\/h3>\n
          Equivalente a la funci\u00f3n\u00a0eval(raw_input(prompt))<\/span><\/code><\/p>\n
          Lee una\u00a0cadena de caracteres<\/span>\u00a0desde la entrada est\u00e1ndar.<\/p>\n
          \n
          \n
          >>> <\/span>dato<\/span> =<\/span> input<\/span>(<\/span>\"Por favor, ingresa un dato: \"<\/span>);<\/span> dato<\/span>;<\/span> type<\/span>(<\/span>dato<\/span>)<\/span>\r\nPor favor, ingresa un dato: 2<\/span>\r\n2<\/span>\r\n<type 'int'><\/span>\r\n>>> <\/span>dato<\/span> =<\/span> input<\/span>(<\/span>\"Por favor, ingresa un dato: \"<\/span>);<\/span> dato<\/span>;<\/span> type<\/span>(<\/span>dato<\/span>)<\/span>\r\nPor favor, ingresa un dato: 23.4<\/span>\r\n23.4<\/span>\r\n<type 'float'><\/span>\r\n>>> <\/span>dato<\/span> =<\/span> input<\/span>(<\/span>\"Por favor, ingresa un dato: \"<\/span>);<\/span> dato<\/span>;<\/span> type<\/span>(<\/span>dato<\/span>)<\/span>\r\nPor favor, ingresa un dato: 23L<\/span>\r\n23L<\/span>\r\n<type 'long'><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          En el caso que quiera ingresar una\u00a0cadena de caracteres<\/span>\u00a0desde la entrada est\u00e1ndar usando la funci\u00f3n\u00a0input()<\/span><\/code>, debe colocar la cadena de caracteres entre comillas simples o dobles, como el siguiente ejemplo:<\/p>\n
          \n
          \n
          >>> <\/span>dato<\/span> =<\/span> input<\/span>(<\/span>\"Por favor, ingresa un dato: \"<\/span>);<\/span> dato<\/span>;<\/span> type<\/span>(<\/span>dato<\/span>)<\/span>\r\nPor favor, ingresa un dato: leonardo<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\n  File \"<string>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nNameError<\/span>: name 'leonardo' is not defined<\/span>\r\n>>> <\/span>dato<\/span> =<\/span> input<\/span>(<\/span>\"Por favor, ingresa un dato: \"<\/span>);<\/span> dato<\/span>;<\/span> type<\/span>(<\/span>dato<\/span>)<\/span>\r\nPor favor, ingresa un dato: \"leonardo\"<\/span>\r\n'leonardo'<\/span>\r\n<type 'str'><\/span>\r\n>>> <\/span>dato<\/span> =<\/span> input<\/span>(<\/span>\"Por favor, ingresa un dato: \"<\/span>);<\/span> dato<\/span>;<\/span> type<\/span>(<\/span>dato<\/span>)<\/span>\r\nPor favor, ingresa un dato: leonardo caballero<\/span>\r\n  File \"<string>\"<\/span>, line 1<\/span>\r\n    leonardo<\/span> caballero<\/span>\r\n                     ^<\/span>\r\nSyntaxError<\/span>: unexpected EOF while parsing<\/span>\r\n>>> <\/span>dato<\/span> =<\/span> input<\/span>(<\/span>\"Por favor, ingresa un dato: \"<\/span>);<\/span> dato<\/span>;<\/span> type<\/span>(<\/span>dato<\/span>)<\/span>\r\nPor favor, ingresa un dato: \"leonardo caballero\"<\/span>\r\n'leonardo caballero'<\/span>\r\n<type 'str'><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          raw_input()<\/h3>\n
          Lee una\u00a0cadena de caracteres<\/span>\u00a0desde la entrada est\u00e1ndar. La nueva l\u00ednea final es despojada. Si el usuario indica un EOF (Unix<\/em>:\u00a0Ctl-D<\/span><\/code>,\u00a0Windows<\/em>:\u00a0Ctl-Z+Return<\/span><\/code>), lanza una excepci\u00f3n\u00a0EOFError<\/span>. En sistemas Unix, la librer\u00eda\u00a0GNU readline<\/strong>\u00a0es usada si es habilitada. El\u00a0prompt<\/span><\/code>\u00a0de la cadena de caracteres, si es dado, es impreso sin una nueva l\u00ednea final antes de leer.<\/p>\n
          \n
          \n
          >>> <\/span>dato<\/span> =<\/span> raw_input<\/span>(<\/span>\"Por favor, ingresa un dato: \"<\/span>);<\/span> dato<\/span>;<\/span> type<\/span>(<\/span>dato<\/span>)<\/span>\r\nPor favor, ingresa un dato: 2<\/span>\r\n'2'<\/span>\r\n<type 'str'><\/span>\r\n>>> <\/span>dato<\/span> =<\/span> raw_input<\/span>(<\/span>\"Por favor, ingresa un dato: \"<\/span>);<\/span> dato<\/span>;<\/span> type<\/span>(<\/span>dato<\/span>)<\/span>\r\nPor favor, ingresa un dato: 2.3<\/span>\r\n'2.3'<\/span>\r\n<type 'str'><\/span>\r\n>>> <\/span>dato<\/span> =<\/span> raw_input<\/span>(<\/span>\"Por favor, ingresa un dato: \"<\/span>);<\/span> dato<\/span>;<\/span> type<\/span>(<\/span>dato<\/span>)<\/span>\r\nPor favor, ingresa un dato: 23L<\/span>\r\n'23L'<\/span>\r\n<type 'str'><\/span>\r\n>>> <\/span>dato<\/span> =<\/span> raw_input<\/span>(<\/span>\"Por favor, ingresa un dato: \"<\/span>);<\/span> dato<\/span>;<\/span> type<\/span>(<\/span>dato<\/span>)<\/span>\r\nPor favor, ingresa un dato: leonardo<\/span>\r\n'leonardo'<\/span>\r\n<type 'str'><\/span>\r\n>>> <\/span>dato<\/span> =<\/span> raw_input<\/span>(<\/span>\"Por favor, ingresa un dato: \"<\/span>);<\/span> dato<\/span>;<\/span> type<\/span>(<\/span>dato<\/span>)<\/span>\r\nPor favor, ingresa un dato: \"leonardo\"<\/span>\r\n'\"leonardo\"'<\/span>\r\n<type 'str'><\/span>\r\n>>> <\/span>dato<\/span> =<\/span> raw_input<\/span>(<\/span>\"Por favor, ingresa un dato: \"<\/span>);<\/span> dato<\/span>;<\/span> type<\/span>(<\/span>dato<\/span>)<\/span>\r\nPor favor, ingresa un dato: leonardo caballero<\/span>\r\n'leonardo caballero'<\/span>\r\n<type 'str'><\/span>\r\n>>> <\/span>dato<\/span> =<\/span> raw_input<\/span>(<\/span>\"Por favor, ingresa un dato: \"<\/span>);<\/span> dato<\/span>;<\/span> type<\/span>(<\/span>dato<\/span>)<\/span>\r\nPor favor, ingresa un dato: \"leonardo caballero\"<\/span>\r\n'\"leonardo caballero\"'<\/span>\r\n<type 'str'><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          \n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          Funciones num\u00e9ricas<\/h2>\n
          Las funciones de tipos num\u00e9ricos se describen a continuaci\u00f3n:<\/p>\n
          <\/span><\/p>\n
          abs()<\/h3>\n
          Devuelve el valor absoluto de un n\u00famero (entero o de coma flotante).<\/p>\n
          \n
          \n
          >>> <\/span>abs<\/span>(<\/span>3<\/span>)<\/span>\r\n3<\/span>\r\n>>> <\/span>abs<\/span>(<\/span>-<\/span>3<\/span>)<\/span>\r\n3<\/span>\r\n>>> <\/span>abs<\/span>(<\/span>-<\/span>2.5<\/span>)<\/span>\r\n2.5<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          bin()<\/h3>\n
          Devuelve una representaci\u00f3n binaria de un\u00a0n\u00famero entero<\/span>\u00a0o\u00a0entero long<\/span>, es decir, lo convierte de entero a binario.<\/p>\n
          \n
          \n
          >>> <\/span>bin<\/span>(<\/span>10<\/span>)<\/span>\r\n'0b1010'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          cmp()<\/h3>\n
          La funci\u00f3n\u00a0cmp()<\/span><\/code>\u00a0devuelve un valor negativo si\u00a0x<y<\/span><\/code>, un valor cero si\u00a0x==y<\/span><\/code>, un valor positivo si\u00a0x>y<\/span><\/code>:<\/p>\n
          \n
          \n
          >>> <\/span>cmp<\/span>(<\/span>1<\/span>,<\/span>2<\/span>)<\/span>\r\n-1<\/span>\r\n>>> <\/span>cmp<\/span>(<\/span>2<\/span>,<\/span>2<\/span>)<\/span>\r\n0<\/span>\r\n>>> <\/span>cmp<\/span>(<\/span>2<\/span>,<\/span>1<\/span>)<\/span>\r\n1<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          complex()<\/h3>\n
          La funci\u00f3n\u00a0complex()<\/span><\/code>\u00a0devuelve un n\u00famero complejo\u00a0complex<\/span><\/code>. Es un constructor, que crea un\u00a0entero complex<\/span>\u00a0a partir de un\u00a0entero<\/span>,\u00a0entero long<\/span>,\u00a0entero float<\/span>\u00a0(cadenas de caracteres formadas por n\u00fameros y hasta un punto), o una\u00a0cadena de caracteres<\/span>\u00a0que sean coherentes con un n\u00famero entero.<\/p>\n
          \n
          \n
          >>> <\/span>complex<\/span>(<\/span>23<\/span>)<\/span>\r\n(23+0j)<\/span>\r\n>>> <\/span>complex<\/span>(<\/span>23<\/span>L<\/span>)<\/span>\r\n(23+0j)<\/span>\r\n>>> <\/span>complex<\/span>(<\/span>23.4<\/span>)<\/span>\r\n(23.4+0j)<\/span>\r\n>>> <\/span>complex<\/span>(<\/span>\"23\"<\/span>)<\/span>\r\n(23+0j)<\/span>\r\n>>> <\/span>complex<\/span>(<\/span>\"23.6\"<\/span>)<\/span>\r\n(23.6+0j)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          La funci\u00f3n\u00a0complex()<\/span><\/code>\u00a0s\u00f3lo procesa correctamente cadenas que contengan exclusivamente n\u00fameros.Si la cadena contiene cualquier otro car\u00e1cter, la funci\u00f3n devuelve una excepci\u00f3n\u00a0ValueError<\/span>.<\/p>\n
          \n
          \n
          >>> <\/span>complex<\/span>(<\/span>\"qwerty\"<\/span>)<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nValueError<\/span>: complex() arg is a malformed string<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          divmod()<\/h3>\n
          Debe recibir dos argumentos num\u00e9ricos, y devuelve dos valores: resultado de la divisi\u00f3n entera, y el resto.<\/p>\n
          \n
          \n
          >>> <\/span>divmod<\/span>(<\/span>22<\/span>,<\/span> 4<\/span>)<\/span>\r\n(5, 2)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          float()<\/h3>\n
          La funci\u00f3n\u00a0float()<\/span><\/code>\u00a0devuelve un n\u00famero coma flotante\u00a0float<\/span><\/code>. Es un constructor, que crea un\u00a0coma flotante<\/span>\u00a0a partir de un\u00a0entero<\/span>,\u00a0entero long<\/span>,\u00a0entero float<\/span>\u00a0(cadenas de caracteres formadas por n\u00fameros y hasta un punto) o una\u00a0cadena de caracteres<\/span>\u00a0que sean coherentes con un n\u00famero entero.<\/p>\n
          \n
          \n
          >>> <\/span>float<\/span>(<\/span>2<\/span>)<\/span>\r\n2.0<\/span>\r\n>>> <\/span>float<\/span>(<\/span>23<\/span>L<\/span>)<\/span>\r\n23.0<\/span>\r\n>>> <\/span>float<\/span>(<\/span>2.5<\/span>)<\/span>\r\n2.5<\/span>\r\n>>> <\/span>float<\/span>(<\/span>\"2\"<\/span>)<\/span>\r\n2.0<\/span>\r\n>>> <\/span>float<\/span>(<\/span>\"2.5\"<\/span>)<\/span>\r\n2.5<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          hex()<\/h3>\n
          Devuelve una representaci\u00f3n hexadecimal de un\u00a0n\u00famero entero<\/span>\u00a0o\u00a0entero long<\/span>, es decir, lo convierte de entero a hexadecimal.<\/p>\n
          \n
          \n
          >>> <\/span>hex<\/span>(<\/span>10<\/span>)<\/span>\r\n'0xa'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          int()<\/h3>\n
          La funci\u00f3n\u00a0int()<\/span><\/code>\u00a0devuelve un n\u00famero entero. Es un constructor, que crea un\u00a0entero<\/span>\u00a0a partir de un\u00a0entero float<\/span>,\u00a0entero complex<\/span>\u00a0o una\u00a0cadena de caracteres<\/span>\u00a0que sean coherentes con un n\u00famero entero.<\/p>\n
          \n
          \n
          >>> <\/span>int<\/span>(<\/span>2.5<\/span>)<\/span>\r\n2<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          Tambi\u00e9n puede convertir una cadena de caracteres a un n\u00famero entero.<\/p>\n
          \n
          \n
          >>> <\/span>int<\/span>(<\/span>\"23\"<\/span>)<\/span>\r\n23<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          La funci\u00f3n\u00a0int()<\/span><\/code>\u00a0s\u00f3lo procesa correctamente cadenas que contengan exclusivamente n\u00fameros. Si la cadena contiene cualquier otro car\u00e1cter, la funci\u00f3n devuelve una excepci\u00f3n\u00a0ValueError<\/span>.<\/p>\n
          \n
          \n
          >>> <\/span>int<\/span>(<\/span>\"2.5\"<\/span>)<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nValueError<\/span>: invalid literal for int() with base 10: '2.5'<\/span>\r\n>>><\/span>\r\n>>> <\/span>int<\/span>(<\/span>\"doscientos\"<\/span>)<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nValueError<\/span>: invalid literal for int() with base 10: 'doscientos'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          long()<\/h3>\n
          La funci\u00f3n\u00a0long()<\/span><\/code>\u00a0devuelve un n\u00famero entero\u00a0long<\/span><\/code>. Es un constructor, que crea un\u00a0entero long<\/span>\u00a0a partir de un\u00a0entero<\/span>,\u00a0entero float<\/span>\u00a0o una\u00a0cadena de caracteres<\/span>\u00a0que sean coherentes con un n\u00famero entero.<\/p>\n
          \n
          \n
          >>> <\/span>long<\/span>(<\/span>23<\/span>)<\/span>\r\n23L<\/span>\r\n>>> <\/span>long<\/span>(<\/span>23.4<\/span>)<\/span>\r\n23L<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          Tambi\u00e9n puede convertir una cadena de caracteres a un n\u00famero entero.<\/p>\n
          \n
          \n
          >>> <\/span>long<\/span>(<\/span>\"23\"<\/span>)<\/span>\r\n23<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          La funci\u00f3n\u00a0long()<\/span><\/code>\u00a0s\u00f3lo procesa correctamente cadenas que contengan exclusivamente n\u00fameros. Si la cadena contiene cualquier otro car\u00e1cter, la funci\u00f3n devuelve una excepci\u00f3n\u00a0ValueError<\/span>.<\/p>\n
          \n
          \n
          >>> <\/span>long<\/span>(<\/span>\"23.4\"<\/span>)<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nValueError<\/span>: invalid literal for long() with base 10: '23.4'<\/span>\r\n>>><\/span>\r\n>>> <\/span>long<\/span>(<\/span>\"23,4\"<\/span>)<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nValueError<\/span>: invalid literal for long() with base 10: '23,4'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          max()<\/h3>\n
          Si recibe m\u00e1s de un argumento, devuelve el mayor de ellos.<\/p>\n
          \n
          \n
          >>> <\/span>max<\/span>(<\/span>23<\/span>,<\/span> 12<\/span>,<\/span> 145<\/span>,<\/span> 88<\/span>)<\/span>\r\n145<\/span>\r\n>>> <\/span>type<\/span>(<\/span>max<\/span>(<\/span>23<\/span>,<\/span> 12<\/span>,<\/span> 145<\/span>,<\/span> 88<\/span>))<\/span>\r\n<type 'int'><\/span>\r\n>>> <\/span>max<\/span>(<\/span>\"a\"<\/span>,<\/span> \"Z\"<\/span>)<\/span>\r\n'a'<\/span>\r\n>>> <\/span>type<\/span>(<\/span>max<\/span>(<\/span>\"a\"<\/span>,<\/span> \"Z\"<\/span>))<\/span>\r\n<type 'str'><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          Si recibe un solo argumento, devuelve el mayor de sus elementos. Debe ser un objeto iterable; puede ser una\u00a0cadena de caracteres<\/span>, o alguno de los otros tipos de secuencia o colecci\u00f3n.<\/p>\n
          \n
          \n
          >>> <\/span>max<\/span>(<\/span>\"Hola, Plone\"<\/span>)<\/span>\r\n'o'<\/span>\r\n>>> <\/span>type<\/span>(<\/span>max<\/span>(<\/span>\"Hola, Plone\"<\/span>))<\/span>\r\n<type 'str'><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          min()<\/h3>\n
          Tiene un comportamiento similar a\u00a0max()<\/span><\/code>, pero devuelve el m\u00ednimo.<\/p>\n
          \n
          \n
          >>> <\/span>min<\/span>(<\/span>23<\/span>,<\/span> 12<\/span>,<\/span> 145<\/span>,<\/span> 88<\/span>)<\/span>\r\n12<\/span>\r\n>>> <\/span>type<\/span>(<\/span>min<\/span>(<\/span>23<\/span>,<\/span> 12<\/span>,<\/span> 145<\/span>,<\/span> 88<\/span>))<\/span>\r\n<type 'int'><\/span>\r\n>>> <\/span>min<\/span>(<\/span>\"Hola, Plone\"<\/span>)<\/span>\r\n' '<\/span>\r\n>>> <\/span>type<\/span>(<\/span>min<\/span>(<\/span>\"Hola, Plone\"<\/span>))<\/span>\r\n<type 'str'><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          pow()<\/h3>\n
          La funci\u00f3n\u00a0pow()<\/span><\/code>\u00a0si recibe dos (02) argumentos, eleva el primero argumento a la potencia del segundo argumento.<\/p>\n
          \n
          \n
          >>> <\/span>pow<\/span>(<\/span>2<\/span>,<\/span> 3<\/span>)<\/span>\r\n8<\/span>\r\n>>> <\/span>pow<\/span>(<\/span>10<\/span>,<\/span> 2<\/span>)<\/span>\r\n100<\/span>\r\n>>> <\/span>pow<\/span>(<\/span>10<\/span>,<\/span> -<\/span>2<\/span>)<\/span>\r\n0.01<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          Si recibe un tercer argumento opcional, \u00e9ste funciona como m\u00f3dulo.<\/p>\n
          \n
          \n
          >>> <\/span>pow<\/span>(<\/span>2<\/span>,<\/span> 3<\/span>,<\/span> 3<\/span>)<\/span>\r\n2<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          reduce()<\/h3>\n
          La funci\u00f3n\u00a0reduce()<\/span><\/code>\u00a0aplica una funci\u00f3n 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:<\/p>\n
          \n
          \n
          >>> <\/span>reduce<\/span>(<\/span>funcion<\/span>,<\/span> secuencia<\/span>[,<\/span> inicial<\/span>])<\/span> -><\/span> valor<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          A continuaci\u00f3n un ejemplo:<\/p>\n
          \n
          \n
          >>> <\/span>reduce<\/span>(<\/span>lambda<\/span> x<\/span>,<\/span> y<\/span>:<\/span> x<\/span> +<\/span> y<\/span>,<\/span> [<\/span>1<\/span>,<\/span> 2<\/span>,<\/span> 3<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>])<\/span>\r\n15<\/span>\r\n>>> <\/span>((((<\/span>1<\/span>+<\/span>2<\/span>)<\/span>+<\/span>3<\/span>)<\/span>+<\/span>4<\/span>)<\/span>+<\/span>5<\/span>)<\/span>\r\n15<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          En el ejemplo anterior, calcula el siguiente calculo\u00a0((((1+2)+3)+4)+5)<\/span><\/code>.<\/p>\n
          Si el argumento\u00a0inicial<\/span><\/code>\u00a0est\u00e1 presente, se coloca antes de los elementos de la secuencia en el c\u00e1lculo y sirve como valor predeterminado cuando la secuencia est\u00e1 vac\u00eda.<\/p>\n
          \n
          \n
          >>> <\/span>reduce<\/span>(<\/span>lambda<\/span> x<\/span>,<\/span> y<\/span>:<\/span> x<\/span> +<\/span> y<\/span>,<\/span> [<\/span>1<\/span>,<\/span> 2<\/span>,<\/span> 3<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>],<\/span> 5<\/span> *<\/span> 5<\/span>)<\/span>\r\n40<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          En el ejemplo anterior, la funci\u00f3n, usada es\u00a0lambda<\/span>\u00a0x,<\/span>\u00a0y:<\/span>\u00a0x<\/span>\u00a0+<\/span>\u00a0y<\/span><\/code>, la secuencia es la lista\u00a0[1,<\/span>\u00a02,<\/span>\u00a03,<\/span>\u00a04,<\/span>\u00a05]<\/span><\/code>\u00a0y el argumento\u00a0inicial<\/span><\/code>\u00a0es\u00a05<\/span>\u00a0*<\/span>\u00a05<\/span><\/code><\/p>\n
          \n
          \n
          >>> <\/span>reduce<\/span>(<\/span>lambda<\/span> x<\/span>,<\/span> y<\/span>:<\/span> x<\/span> +<\/span> y<\/span>,<\/span> [<\/span>0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>],<\/span> 5<\/span> *<\/span> 5<\/span>)<\/span>\r\n25<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          En el ejemplo anterior, la funci\u00f3n, usada es\u00a0lambda<\/span>\u00a0x,<\/span>\u00a0y:<\/span>\u00a0x<\/span>\u00a0+<\/span>\u00a0y<\/span><\/code>, la secuencia es la lista\u00a0[0,<\/span>\u00a00,<\/span>\u00a00,<\/span>\u00a00,<\/span>\u00a00]<\/span><\/code>\u00a0y el argumento\u00a0inicial<\/span><\/code>\u00a0es\u00a05<\/span>\u00a0*<\/span>\u00a05<\/span><\/code><\/p>\n<\/div>\n
          <\/span><\/p>\n
          round()<\/h3>\n
          La funci\u00f3n\u00a0round()<\/span><\/code>\u00a0redondea un n\u00famero flotante a una precisi\u00f3n dada en d\u00edgitos decimal (por defecto 0 d\u00edgitos). Esto siempre devuelve un n\u00famero flotante. La precisi\u00f3n tal vez sea negativa.<\/p>\n
          En el siguiente ejemplo redondeo de un n\u00famero flotante a entero, mayor o igual a\u00a0.5<\/em>\u00a0al alza:<\/p>\n
          \n
          \n
          >>> <\/span>round<\/span>(<\/span>5.5<\/span>)<\/span>\r\n6.0<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          En este otro ejemplo redondeo de un n\u00famero flotante a entero, menor de\u00a0.5<\/em>\u00a0a la baja:<\/p>\n
          \n
          \n
          >>> <\/span>round<\/span>(<\/span>5.4<\/span>)<\/span>\r\n5.0<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          sum()<\/h3>\n
          La funci\u00f3n\u00a0sum()<\/span><\/code>\u00a0devuelve una lista ordenada de los elementos de la secuencia que recibe como argumento (lista o cadena). La secuencia original no es modificada.<\/p>\n
          \n
          \n
          >>> <\/span>lista<\/span> =<\/span> [<\/span>1<\/span>,<\/span> 2<\/span>,<\/span> 3<\/span>,<\/span> 4<\/span>]<\/span>\r\n>>> <\/span>sum<\/span>(<\/span>lista<\/span>)<\/span>\r\n10<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          oct()<\/h3>\n
          La funci\u00f3n\u00a0oct()<\/span><\/code>\u00a0convierte un n\u00famero entero en una cadena en base octal, antecedida del prefijo\u00a0\u201c0\u201d<\/em>.<\/p>\n
          \n
          \n
          >>> <\/span>oct<\/span>(<\/span>8<\/span>)<\/span>\r\n'010'<\/span>\r\n>>> <\/span>oct<\/span>(<\/span>123<\/span>)<\/span>\r\n'0173'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          \n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          Funciones de booleanos<\/h2>\n
          Las funciones de tipos\u00a0booleanos<\/span>\u00a0se describen a continuaci\u00f3n:<\/p>\n
          <\/span><\/p>\n
          bool()<\/h3>\n
          La funci\u00f3n\u00a0bool()<\/span><\/code>, es un constructor, el cual crea un tipo de datos\u00a0booleanos<\/span>, devuelve un tipo booleano\u00a0True<\/span><\/code>\u00a0cuando el argumento dado es\u00a0True<\/span><\/code>, de lo contrario\u00a0False<\/span><\/code>.<\/p>\n
          \n
          \n
          >>> <\/span>bool<\/span>()<\/span>\r\nFalse<\/span>\r\n>>> <\/span>bool<\/span>(<\/span>True<\/span>)<\/span>\r\nTrue<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          Convertir desde un tipo\u00a0entero<\/span>\u00a0a tipo\u00a0booleano<\/em>:<\/p>\n
          \n
          \n
          >>> <\/span>bool<\/span>(<\/span>0<\/span>)<\/span>\r\nFalse<\/span>\r\n>>> <\/span>bool<\/span>(<\/span>1<\/span>)<\/span>\r\nTrue<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          Convertir desde un tipo\u00a0entero float<\/span>\u00a0de forma recursiva usando la funci\u00f3n\u00a0int()<\/span>\u00a0a tipo\u00a0booleano<\/em>:<\/p>\n
          \n
          \n
          >>> <\/span>bool<\/span>(<\/span>int<\/span>(<\/span>0.1<\/span>))<\/span>\r\nFalse<\/span>\r\n>>> <\/span>bool<\/span>(<\/span>int<\/span>(<\/span>1.0<\/span>))<\/span>\r\nTrue<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          Convertir desde un tipo\u00a0cadena de caracteres<\/span>\u00a0de forma recursiva usando la funci\u00f3n\u00a0str()<\/span>\u00a0y la funci\u00f3n\u00a0int()<\/span>\u00a0a tipo\u00a0booleano<\/em>:<\/p>\n
          \n
          \n
          >>> <\/span>bool<\/span>(<\/span>int<\/span>(<\/span>str<\/span>(<\/span>'0'<\/span>)))<\/span>\r\nFalse<\/span>\r\n>>> <\/span>bool<\/span>(<\/span>int<\/span>(<\/span>str<\/span>(<\/span>'1'<\/span>)))<\/span>\r\nTrue<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          \n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          Funciones de cadenas de caracteres<\/h2>\n
          Las funciones de tipos\u00a0cadena de caracteres<\/span>\u00a0se describen a continuaci\u00f3n:<\/p>\n
          <\/span><\/p>\n
          capitalize()<\/h3>\n
          La funci\u00f3n\u00a0capitalize()<\/span><\/code>\u00a0devuelve una\u00a0cadenas de caracteres<\/span>\u00a0con MAY\u00daSCULA la primera palabra.<\/p>\n
          \n
          \n
          >>> <\/span>'leonardo caballero'<\/span>.<\/span>capitalize<\/span>()<\/span>\r\n'Leonardo caballero'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          chr()<\/h3>\n
          La funci\u00f3n\u00a0chr()<\/span><\/code>\u00a0recibe como argumento un entero, y devuelve una cadena con el car\u00e1cter cuyo c\u00f3digo\u00a0Unicode<\/em>\u00a0corresponde a ese valor. El rango v\u00e1lido para el argumento es de 0 a 256.<\/p>\n
          \n
          \n
          >>> <\/span>chr<\/span>(<\/span>64<\/span>)<\/span>\r\n'@'<\/span>\r\n>>> <\/span>chr<\/span>(<\/span>36<\/span>)<\/span>\r\n'$'<\/span>\r\n>>> <\/span>chr<\/span>(<\/span>94<\/span>)<\/span>\r\n'^'<\/span>\r\n>>> <\/span>chr<\/span>(<\/span>126<\/span>)<\/span>\r\n'~'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          endswith()<\/h3>\n
          La funci\u00f3n\u00a0endswith()<\/span><\/code>\u00a0devuelve un valor booleano\u00a0True<\/span><\/code>\u00a0o\u00a0False<\/span><\/code>\u00a0si coincide que la cadena termine con el criterio enviado por par\u00e1metros en la funci\u00f3n.<\/p>\n
          \n
          \n
          >>> <\/span>'leonardo caballero'<\/span>.<\/span>endswith<\/span>(<\/span>\"do\"<\/span>)<\/span>\r\nFalse<\/span>\r\n>>> <\/span>'leonardo caballero'<\/span>.<\/span>endswith<\/span>(<\/span>\"ro\"<\/span>)<\/span>\r\nTrue<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          expandtabs()<\/h3>\n
          La funci\u00f3n\u00a0expandtabs()<\/span><\/code>\u00a0devuelve una copia de la\u00a0cadena de caracteres<\/span>\u00a0donde todos los caracteres\u00a0tab<\/span><\/code>\u00a0(tabulaci\u00f3n) son remplazados por uno o m\u00e1s espacios, depende en la actual columna y el tama\u00f1o del tab dado.<\/p>\n
          \n
          \n
          >>> <\/span>'Leonardo Caballero<\/span>\\t<\/span>Python Developer<\/span>\\t<\/span>leonardoc@plone.org'<\/span>.<\/span>expandtabs<\/span>()<\/span>\r\n'Leonardo Caballero      Python Developer        leonardoc@plone.org'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          Usted puede indicar el tama\u00f1o de la tecla\u00a0tab<\/span><\/code>\u00a0v\u00eda par\u00e1metro de la funci\u00f3n:<\/p>\n
          \n
          \n
          >>> <\/span>'Leonardo Caballero<\/span>\\t<\/span>Python Developer<\/span>\\t<\/span>leonardoc@plone.org'<\/span>.<\/span>expandtabs<\/span>(<\/span>4<\/span>)<\/span>\r\n'Leonardo Caballero  Python Developer    leonardoc@plone.org'<\/span>\r\n>>> <\/span>'Leonardo Caballero<\/span>\\t<\/span>Python Developer<\/span>\\t<\/span>leonardoc@plone.org'<\/span>.<\/span>expandtabs<\/span>(<\/span>2<\/span>)<\/span>\r\n'Leonardo Caballero  Python Developer  leonardoc@plone.org'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          find()<\/h3>\n
          La funci\u00f3n\u00a0find()<\/span><\/code>\u00a0devuelve un valor num\u00e9rico\u00a00<\/span><\/code>\u00a0si encuentra el criterio de b\u00fasqueda o\u00a0-1<\/span><\/code>\u00a0si no coincide el criterio de b\u00fasqueda enviado por par\u00e1metros en la funci\u00f3n.<\/p>\n
          \n
          \n
          >>> <\/span>'leonardo caballero'<\/span>.<\/span>find<\/span>(<\/span>\"leo\"<\/span>)<\/span>\r\n0<\/span>\r\n>>> <\/span>'leonardo caballero'<\/span>.<\/span>find<\/span>(<\/span>\"ana\"<\/span>)<\/span>\r\n-1<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
          <\/span><\/p>\n
          format()<\/h3>\n
          La funci\u00f3n integrada\u00a0format()<\/span><\/code>\u00a0devuelve una representaci\u00f3n formateada de un valor dato controlado por el especificador de formato.<\/p>\n
          La funci\u00f3n integrada\u00a0format()<\/span><\/code>\u00a0es similar al\u00a0m\u00e9todo format()<\/span>\u00a0disponible en el tipo de\u00a0cadena de caracteres<\/span>. Internamente, ambos llaman al m\u00e9todo\u00a0__format__()<\/span><\/code>\u00a0de un objecto.<\/p>\n
          Mientras, la funci\u00f3n integrada\u00a0format()<\/span><\/code>\u00a0es una implementaci\u00f3n de bajo nivel para formatear un objeto usando\u00a0__format__()<\/span><\/code>\u00a0internamente, el\u00a0m\u00e9todo format()<\/span>\u00a0del tipo de cadena de caracteres es una implementaci\u00f3n de alto nivel disponible para ejecutar operaciones de formateo complejas en m\u00faltiples objeto de\u00a0cadena de caracteres<\/span>.<\/p>\n
          La sintaxis de la funci\u00f3n integrada\u00a0format()<\/span><\/code>\u00a0es:<\/p>\n
          \n
          \n
          format<\/span>(<\/span>value<\/span>[,<\/span> format_spec<\/span>])<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
          La a funci\u00f3n integrada\u00a0format()<\/span><\/code>\u00a0toma dos par\u00e1metros:<\/p>\n
            \n
          • value – valor que necesita formatear.<\/li>\n
          • format_spec – La especificaci\u00f3n en como el valor debe ser formateado.<\/li>\n<\/ul>\n
            A continuaci\u00f3n, un ejemplo de un valor\u00a0n\u00famero entero<\/span>, seria de la siguiente forma:<\/p>\n
            \n
            \n
            >>> <\/span>print<\/span> format<\/span>(<\/span>123<\/span>,<\/span>\"d\"<\/span>)<\/span>\r\n123<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
            A continuaci\u00f3n, un ejemplo de un valor\u00a0n\u00famero float<\/span>, seria de la siguiente forma:<\/p>\n
            \n
            \n
            >>> <\/span>print<\/span> format<\/span>(<\/span>123.456789<\/span>,<\/span>\"f\"<\/span>)<\/span>\r\n123.456789<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
            A continuaci\u00f3n, un ejemplo de un valor binario, seria de la siguiente forma:<\/p>\n
            \n
            \n
            >>> <\/span>print<\/span> format<\/span>(<\/span>10<\/span>,<\/span>\"b\"<\/span>)<\/span>\r\n1010<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
            A continuaci\u00f3n, un ejemplo de un valor\u00a0n\u00famero entero<\/span>\u00a0con formato especifico, seria de la siguiente forma:<\/p>\n
            \n
            \n
            >>> <\/span>print<\/span> format<\/span>(<\/span>1234<\/span>,<\/span>\"*>+7,d\"<\/span>)<\/span>\r\n*+1,234<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
            En el ejemplo anterior cuando se formatea el\u00a0n\u00famero entero<\/span>\u00a01234<\/em>, usted especifico el especificador de formato\u00a0*<+7,d<\/span><\/code>. Seguidamente, se describe cada opci\u00f3n a continuaci\u00f3n:<\/p>\n
              \n
            • *<\/span><\/code>\u00a0Es la opci\u00f3n del car\u00e1cter de relleno, el cual rellena los espacio vac\u00edo despu\u00e9s del formato.<\/li>\n
            • ><\/span><\/code>\u00a0Es la opci\u00f3n de alineaci\u00f3n a la derecha, el cual alinea la cadena de caracteres de salida a la derecha.<\/li>\n
            • +<\/span><\/code>\u00a0Es la opci\u00f3n de signo, el cual obliga al n\u00famero a ser firmado (con un signo a su izquierda).<\/li>\n
            • 7<\/span><\/code>\u00a0Es la opci\u00f3n ancho, el cual obliga el n\u00famero que tome un m\u00ednimo de ancho de 7, otros espacios ser\u00e1n rellenado por el car\u00e1cter de relleno.<\/li>\n
            • ,<\/span><\/code>\u00a0Ese es el operador miles, el cual coloca un car\u00e1cter coma entre todos los n\u00fameros miles.<\/li>\n
            • d<\/span><\/code>\u00a0Es la opci\u00f3n tipo que especifica que el n\u00famero es un\u00a0n\u00famero entero<\/span>.<\/li>\n<\/ul>\n
              A continuaci\u00f3n, un ejemplo de un valor\u00a0n\u00famero float<\/span>\u00a0con formato especifico, seria de la siguiente forma:<\/p>\n
              \n
              \n
              >>> <\/span>print<\/span> format<\/span>(<\/span>123.4567<\/span>,<\/span> \"^-09.3f\"<\/span>)<\/span>\r\n0123.4570<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
              En el ejemplo anterior cuando se formatea el\u00a0n\u00famero float<\/span>\u00a0123.4567<\/em>, usted especifico el especificador de formato\u00a0^-09.3f<\/span><\/code>. Seguidamente, se describe cada opci\u00f3n a continuaci\u00f3n:<\/p>\n
                \n
              • ^<\/span><\/code>\u00a0Es la opci\u00f3n de alineaci\u00f3n centrar, el cual alinea la cadena de caracteres de salida al centro del espacio restante.<\/li>\n
              • -<\/span><\/code>\u00a0Es la opci\u00f3n de signo el cual obliga solo a los n\u00fameros negativos a mostrar el signo.<\/li>\n
              • 0<\/span><\/code>\u00a0Ese es el car\u00e1cter, el cual es colocado en lugar de los espacios vac\u00edos.<\/li>\n
              • 9<\/span><\/code>\u00a0Es la opci\u00f3n de ancho, el cual establece el ancho m\u00ednimo del n\u00famero en 9 (incluido el punto decimal, la coma y el signo de miles).<\/li>\n
              • .3<\/span><\/code>\u00a0Ese es el operador de precisi\u00f3n que define la precisi\u00f3n del n\u00famero flotante dado a 3 lugares.<\/li>\n
              • f<\/span><\/code>\u00a0Es la opci\u00f3n tipo que especifica que el n\u00famero es un\u00a0n\u00famero float<\/span>.<\/li>\n<\/ul>\n
                A continuaci\u00f3n, un ejemplo de usar la funci\u00f3n\u00a0format()<\/span><\/code>\u00a0sobre escribiendo el m\u00e9todo especial\u00a0__format__()<\/span><\/code>\u00a0de una\u00a0clase<\/span>, seria de la siguiente forma:<\/p>\n
                \n
                \n
                >>> <\/span>class<\/span> Persona<\/span>:<\/span>\r\n... <\/span>    def<\/span> __format__<\/span>(<\/span>self<\/span>,<\/span> formato<\/span>):<\/span>\r\n... <\/span>        if<\/span>(<\/span>formato<\/span> ==<\/span> 'edad'<\/span>):<\/span>\r\n... <\/span>            return<\/span> '23'<\/span>\r\n... <\/span>        return<\/span> 'Formato nulo'<\/span>\r\n...<\/span>\r\n>>> <\/span>print<\/span> format<\/span>(<\/span>Persona<\/span>(),<\/span> \"edad\"<\/span>)<\/span>\r\n23<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                En el ejemplo anterior cuando se sobre escribe el m\u00e9todo especial\u00a0__format__()<\/span><\/code>\u00a0de la clase\u00a0Persona<\/span><\/code>. Ese ahora acepta el argumento del m\u00e9todo llamado\u00a0edad<\/span><\/code>\u00a0el cual devuelve\u00a023<\/em>.<\/p>\n
                El m\u00e9todo\u00a0format()<\/span><\/code>\u00a0internamente ejecuta\u00a0Persona().__format__(\"edad\")<\/span><\/code>, el cual devuelve el mensaje\u00a023<\/em>. Si no hay formato especificado, el mensaje devuelto es\u00a0Formato nulo<\/em>.<\/p>\n<\/div>\n
                <\/span><\/p>\n
                index()<\/h3>\n
                La funci\u00f3n\u00a0index()<\/span><\/code>\u00a0es como la funci\u00f3n\u00a0find()<\/span><\/code>\u00a0pero arroja una excepci\u00f3n\u00a0ValueError<\/span>\u00a0cuando la sub-cadena no es encontrada.<\/p>\n
                \n
                \n
                >>> <\/span>'leonardo caballero'<\/span>.<\/span>index<\/span>(<\/span>\"leo\"<\/span>)<\/span>\r\n0<\/span>\r\n>>> <\/span>'leonardo caballero'<\/span>.<\/span>index<\/span>(<\/span>\"ana\"<\/span>)<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nValueError<\/span>: substring not found<\/span>\r\n>>> <\/span>'leonardo caballero'<\/span>.<\/span>index<\/span>(<\/span>\" ca\"<\/span>)<\/span>\r\n8<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                intern()<\/h3>\n
                La funci\u00f3n\u00a0intern()<\/span><\/code>\u00a0introduce la cadena en la tabla de cadenas internadas (si no est\u00e1 ya all\u00ed). Esto ingresa la cadena en la tabla (global) de cadenas internas cuyo prop\u00f3sito es acelerar las b\u00fasquedas en el tipo diccionario.<\/p>\n
                Al utilizar la funci\u00f3n\u00a0intern()<\/span><\/code>, se asegura de que nunca cree dos objetos de cadena de caracteres que tengan el mismo valor: cuando solicita la creaci\u00f3n 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\u00e1s ahorrando memoria. Adem\u00e1s, la comparaci\u00f3n 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.<\/p>\n
                Esencialmente, la funci\u00f3n\u00a0intern()<\/span><\/code>\u00a0busca (o almacena si no est\u00e1 presente) la cadena de caracteres en una colecci\u00f3n de cadenas de caracteres internadas, por lo que todas las instancias internadas compartir\u00e1n la misma identidad. Cambia el costo \u00fanico de buscar esta cadena de caracteres para realizar comparaciones m\u00e1s r\u00e1pidas (la comparaci\u00f3n puede devolver\u00a0True<\/span><\/code>\u00a0despu\u00e9s de solo verificar la identidad, en lugar de tener que comparar cada car\u00e1cter), y reducir el uso de la memoria.<\/p>\n
                Sin embargo, Python internar\u00e1 autom\u00e1ticamente cadenas de caracteres que sean peque\u00f1as o que parezcan identificadores, por lo que es posible que no obtengas ninguna mejora porque tus cadenas de caracteres ya est\u00e1n internadas entre bastidores.<\/p>\n
                A continuaci\u00f3n uno ejemplo de comparaci\u00f3n de cadena de caracteres con operadores de relacionales:<\/p>\n
                \n
                \n
                >>> <\/span>cadena0<\/span>,<\/span> cadena1<\/span> =<\/span> 'python'<\/span>,<\/span> 'python'<\/span>\r\n>>> <\/span>cadena0<\/span> ==<\/span> cadena1<\/span>\r\nTrue<\/span>\r\n>>> <\/span>cadena0<\/span> is<\/span> cadena1<\/span>\r\nTrue<\/span>\r\n>>> <\/span>cadena0<\/span>,<\/span> cadena1<\/span> =<\/span> 'python 2.7'<\/span>,<\/span> 'python 2.7'<\/span>\r\n>>> <\/span>cadena0<\/span> is<\/span> cadena1<\/span>\r\nFalse<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                A continuaci\u00f3n uno ejemplo de comparaci\u00f3n de cadena de caracteres con el operador\u00a0is<\/span>:<\/p>\n
                \n
                \n
                >>><\/span>\r\n>>> <\/span>cadena0<\/span> =<\/span> intern<\/span>(<\/span>'plone cms'<\/span>)<\/span>\r\n>>> <\/span>cadena1<\/span> =<\/span> 'plone cms'<\/span>\r\n>>> <\/span>cadena0<\/span> is<\/span> cadena1<\/span>\r\nFalse<\/span>\r\n>>> <\/span>cadena1<\/span> =<\/span> intern<\/span>(<\/span>'plone cms'<\/span>)<\/span>\r\n>>> <\/span>cadena0<\/span> is<\/span> cadena1<\/span>\r\nTrue<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                isalnum()<\/h3>\n
                La funci\u00f3n\u00a0isalnum()<\/span><\/code>\u00a0devuelve un valor booleano\u00a0True<\/span><\/code>\u00a0o\u00a0False<\/span><\/code>\u00a0si coincide que la cadena contenga caracteres alfanum\u00e9ricos.<\/p>\n
                \n
                \n
                >>> <\/span>'23456987'<\/span>.<\/span>isalnum<\/span>()<\/span>\r\nTrue<\/span>\r\n>>> <\/span>'V-23456987'<\/span>.<\/span>isalnum<\/span>()<\/span>\r\nFalse<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                isalpha()<\/h3>\n
                La funci\u00f3n\u00a0isalpha()<\/span><\/code>\u00a0devuelve un valor booleano\u00a0True<\/span><\/code>\u00a0o\u00a0False<\/span><\/code>\u00a0si coincide que la cadena contenga caracteres alfab\u00e9ticos.<\/p>\n
                \n
                \n
                >>> <\/span>'leonardo'<\/span>.<\/span>isalpha<\/span>()<\/span>\r\nTrue<\/span>\r\n>>> <\/span>'leonardo caballero'<\/span>.<\/span>isalpha<\/span>()<\/span>\r\nFalse<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                isdigit()<\/h3>\n
                La funci\u00f3n\u00a0isdigit()<\/span><\/code>\u00a0devuelve un valor booleano\u00a0True<\/span><\/code>\u00a0o\u00a0False<\/span><\/code>\u00a0si coincide que la cadena contenga caracteres d\u00edgitos.<\/p>\n
                \n
                \n
                >>> <\/span>'leonardo caballero'<\/span>.<\/span>isdigit<\/span>()<\/span>\r\nFalse<\/span>\r\n>>> <\/span>'23456987'<\/span>.<\/span>isdigit<\/span>()<\/span>\r\nTrue<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                islower()<\/h3>\n
                La funci\u00f3n\u00a0islower()<\/span><\/code>\u00a0devuelve un valor booleano\u00a0True<\/span><\/code>\u00a0o\u00a0False<\/span><\/code>\u00a0si coincide que la cadena contenga caracteres en MIN\u00daSCULAS.<\/p>\n
                \n
                \n
                >>> <\/span>'leonardo caballero'<\/span>.<\/span>islower<\/span>()<\/span>\r\nTrue<\/span>\r\n>>> <\/span>'leonardo CABALLERO'<\/span>.<\/span>islower<\/span>()<\/span>\r\nFalse<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                istitle()<\/h3>\n
                La funci\u00f3n\u00a0istitle()<\/span><\/code>\u00a0devuelve un valor booleano\u00a0True<\/span><\/code>\u00a0o\u00a0False<\/span><\/code>\u00a0si coincide que la\u00a0cadena de caracteres<\/span>\u00a0sean capitales en cada palabra.<\/p>\n
                \n
                \n
                >>> <\/span>\"leonardo caballero\"<\/span>.<\/span>title<\/span>()<\/span>\r\n'Leonardo Caballero'<\/span>\r\n>>> <\/span>\"leonardo Caballero\"<\/span>.<\/span>istitle<\/span>()<\/span>\r\nFalse<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                isspace()<\/h3>\n
                La funci\u00f3n\u00a0isspace()<\/span><\/code>\u00a0devuelve un valor booleano\u00a0True<\/span><\/code>\u00a0o\u00a0False<\/span><\/code>\u00a0si no es vac\u00eda, y todos sus caracteres son espacios en blanco.<\/p>\n
                \n
                \n
                >>> <\/span>\" \"<\/span>.<\/span>isspace<\/span>()<\/span>\r\nTrue<\/span>\r\n>>> <\/span>\"  \"<\/span>.<\/span>isspace<\/span>()<\/span>\r\nTrue<\/span>\r\n>>> <\/span>\"a \"<\/span>.<\/span>isspace<\/span>()<\/span>\r\nFalse<\/span>\r\n>>> <\/span>\" A \"<\/span>.<\/span>isspace<\/span>()<\/span>\r\nFalse<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                isupper()<\/h3>\n
                La funci\u00f3n\u00a0isupper()<\/span><\/code>\u00a0devuelve un valor booleano\u00a0True<\/span><\/code>\u00a0o\u00a0False<\/span><\/code>\u00a0si coincide que la\u00a0cadena de caracteres<\/span>\u00a0est\u00e9n en MAY\u00daSCULAS en cada palabra.<\/p>\n
                \n
                \n
                >>> <\/span>'LEONARDO CABALLERO'<\/span>.<\/span>isupper<\/span>()<\/span>\r\nTrue<\/span>\r\n>>> <\/span>'LEONARDO caballero'<\/span>.<\/span>isupper<\/span>()<\/span>\r\nFalse<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                lstrip()<\/h3>\n
                La funci\u00f3n\u00a0lstrip()<\/span><\/code>\u00a0devuelve una copia de la\u00a0cadena de caracteres<\/span>\u00a0con el espacio en blanco inicial eliminado. Si se dan la cadena de caracteres y no es\u00a0None<\/span>, elimina los caracteres en la cadena de caracteres en su lugar. Si la cadena de caracteres son\u00a0unicode<\/span><\/code>, ser\u00e1n convertidas a\u00a0unicode<\/span><\/code>\u00a0antes de eliminar.<\/p>\n
                \n
                \n
                >>> <\/span>\" leonardo caballero \"<\/span>.<\/span>lstrip<\/span>()<\/span>\r\n'leonardo caballero '<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                lower()<\/h3>\n
                La funci\u00f3n\u00a0lower()<\/span><\/code>\u00a0devuelve una\u00a0cadenas de caracteres<\/span>\u00a0con MIN\u00daSCULAS en cada palabra.<\/p>\n
                \n
                \n
                >>> <\/span>'LEONARDO CABALLERO'<\/span>.<\/span>lower<\/span>()<\/span>\r\n'leonardo caballero'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                ord()<\/h3>\n
                La funci\u00f3n\u00a0ord()<\/span><\/code>\u00a0es el inverso de\u00a0chr()<\/span>\u00a0dada una cadena representando un car\u00e1cter Unicode, devuelve el entero del c\u00f3digo correspondiente.<\/p>\n
                \n
                \n
                >>> <\/span>ord<\/span>(<\/span>'@'<\/span>)<\/span>\r\n64<\/span>\r\n>>> <\/span>ord<\/span>(<\/span>'$'<\/span>)<\/span>\r\n36<\/span>\r\n>>> <\/span>ord<\/span>(<\/span>'^'<\/span>)<\/span>\r\n94<\/span>\r\n>>> <\/span>ord<\/span>(<\/span>'~'<\/span>)<\/span>\r\n126<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                replace()<\/h3>\n
                La funci\u00f3n\u00a0replace()<\/span><\/code>\u00a0si encuentra el criterio de la b\u00fasqueda de la sub-cadena o la remplaza con la nueva sub-cadena enviado por par\u00e1metros en la funci\u00f3n.<\/p>\n
                \n
                \n
                >>> <\/span>'leonardo caballero'<\/span>.<\/span>replace<\/span>(<\/span>\" cab\"<\/span>,<\/span> \" Cab\"<\/span>)<\/span>\r\n'leonardo Caballero'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                split()<\/h3>\n
                La funci\u00f3n\u00a0split()<\/span><\/code>\u00a0devuelve una lista con la\u00a0cadena de caracteres<\/span>\u00a0separada por cada indice de la lista.<\/p>\n
                \n
                \n
                >>> <\/span>'leonardo caballero'<\/span>.<\/span>split<\/span>()<\/span>\r\n['leonardo', 'caballero']<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                splitlines()<\/h3>\n
                La funci\u00f3n\u00a0splitlines()<\/span><\/code>\u00a0devuelve una lista con la\u00a0cadena de caracteres<\/span>\u00a0separada por cada salto de linea en cada indice de la lista.<\/p>\n
                \n
                \n
                >>> <\/span>'leonardo jose<\/span>\\n<\/span>caballero garcia'<\/span>.<\/span>splitlines<\/span>()<\/span>\r\n['leonardo jose', 'caballero garcia']<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                startswith()<\/h3>\n
                La funci\u00f3n\u00a0startswith()<\/span><\/code>\u00a0devuelve un valor booleano\u00a0True<\/span><\/code>\u00a0o\u00a0False<\/span><\/code>\u00a0si coincide que la cadena inicie con el criterio enviado por par\u00e1metros en la funci\u00f3n.<\/p>\n
                \n
                \n
                >>> <\/span>'leonardo caballero'<\/span>.<\/span>startswith<\/span>(<\/span>\"ca\"<\/span>)<\/span>\r\nFalse<\/span>\r\n>>> <\/span>'leonardo caballero'<\/span>.<\/span>startswith<\/span>(<\/span>\"leo\"<\/span>)<\/span>\r\nTrue<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                str()<\/h3>\n
                La funci\u00f3n\u00a0str()<\/span><\/code>\u00a0es el constructor del tipo de\u00a0cadenas de caracteres<\/span>, se usa crear una\u00a0car\u00e1cter<\/em>\u00a0o\u00a0cadenas de caracteres<\/em>\u00a0mediante la misma funci\u00f3n\u00a0str()<\/span><\/code>.<\/p>\n
                Puede convertir un\u00a0n\u00famero entero<\/span>\u00a0a una\u00a0cadena de caracteres<\/em>, de la siguiente forma:<\/p>\n
                \n
                \n
                >>> <\/span>str<\/span>(<\/span>2<\/span>)<\/span>\r\n'2'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                Puede convertir un\u00a0n\u00famero float<\/span>\u00a0a una\u00a0cadena de caracteres<\/em>, de la siguiente forma:<\/p>\n
                \n
                \n
                >>> <\/span>str<\/span>(<\/span>2.5<\/span>)<\/span>\r\n'2.5'<\/span>\r\n>>> <\/span>str<\/span>(<\/span>-<\/span>2.5<\/span>)<\/span>\r\n'-2.5'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                Puede convertir un\u00a0n\u00famero complex<\/span>\u00a0a una\u00a0cadena de caracteres<\/em>, de la siguiente forma:<\/p>\n
                \n
                \n
                >>> <\/span>str<\/span>(<\/span>2.3<\/span>+<\/span>0<\/span>j<\/span>)<\/span>\r\n'(2.3+0j)'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                Puede convertir un tipo\u00a0booleano<\/span>\u00a0a una\u00a0cadena de caracteres<\/em>, de la siguiente forma:<\/p>\n
                \n
                \n
                >>> <\/span>str<\/span>(<\/span>True<\/span>)<\/span>\r\n'True'<\/span>\r\n>>> <\/span>str<\/span>(<\/span>False<\/span>)<\/span>\r\n'False'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                swapcase()<\/h3>\n
                La funci\u00f3n\u00a0swapcase()<\/span><\/code>\u00a0devuelve una\u00a0cadenas de caracteres<\/span>\u00a0convertida al opuesto sea MAY\u00daSCULAS o MIN\u00daSCULAS.<\/p>\n
                \n
                \n
                >>> <\/span>'leonardo caballero'<\/span>.<\/span>swapcase<\/span>()<\/span>\r\n'LEONARDO CABALLERO'<\/span>\r\n>>> <\/span>'LEONARDO CABALLERO'<\/span>.<\/span>swapcase<\/span>()<\/span>\r\n'leonardo caballero'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                title()<\/h3>\n
                La funci\u00f3n\u00a0title()<\/span><\/code>\u00a0devuelve una\u00a0cadenas de caracteres<\/span>\u00a0con capitales en cada palabra.<\/p>\n
                \n
                \n
                >>> <\/span>\"leonardo caballero\"<\/span>.<\/span>title<\/span>()<\/span>\r\n'Leonardo Caballero'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                unichr()<\/h3>\n
                La funci\u00f3n\u00a0unichr()<\/span><\/code>\u00a0devuelve una\u00a0cadena de caracteres<\/em>\u00a0Unicode<\/em>\u00a0de un car\u00e1cter con un numero entero.<\/p>\n
                \n
                \n
                >>> <\/span>unichr<\/span>(<\/span>64<\/span>)<\/span>\r\nu'@'<\/span>\r\n>>> <\/span>unichr<\/span>(<\/span>36<\/span>)<\/span>\r\nu'$'<\/span>\r\n>>> <\/span>unichr<\/span>(<\/span>94<\/span>)<\/span>\r\nu'^'<\/span>\r\n>>> <\/span>unichr<\/span>(<\/span>126<\/span>)<\/span>\r\nu'~'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                upper()<\/h3>\n
                La funci\u00f3n\u00a0upper()<\/span><\/code>\u00a0devuelve una\u00a0cadenas de caracteres<\/span>\u00a0con MAY\u00daSCULAS en cada palabra.<\/p>\n
                \n
                \n
                >>> <\/span>\"leonardo caballero\"<\/span>.<\/span>upper<\/span>()<\/span>\r\n'LEONARDO CABALLERO'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                \n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                Funciones de secuencias<\/h2>\n
                Las funciones de secuencias se describen a continuaci\u00f3n:<\/p>\n
                <\/span><\/p>\n
                all()<\/h3>\n
                La funci\u00f3n\u00a0all()<\/span><\/code>\u00a0toma un contenedor como un argumento. Esta devuelve las funciones integradas\u00a0True<\/span><\/code>\u00a0si todo los valores en el objeto iterable python tienen un valor de tipo\u00a0booleano<\/span>\u00a0igual a\u00a0True<\/span><\/code>. Un valor vac\u00edo tiene un tipo\u00a0booleano<\/span>\u00a0igual a\u00a0False<\/span><\/code>.<\/p>\n
                \n
                \n
                >>> <\/span>all<\/span>([<\/span>' '<\/span>,<\/span>' '<\/span>,<\/span>' '<\/span>])<\/span>\r\nTrue<\/span>\r\n>>> <\/span>all<\/span>({<\/span>'*'<\/span>,<\/span>''<\/span>,<\/span>''<\/span>})<\/span>\r\nFalse<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                any()<\/h3>\n
                La funci\u00f3n\u00a0any()<\/span><\/code>\u00a0ese toma un argumento y devuelve\u00a0True<\/span><\/code>\u00a0incluso si, un valor en el objeto iterable tiene un valor de tipo\u00a0booleano<\/span>\u00a0igual a\u00a0True<\/span><\/code>.<\/p>\n
                \n
                \n
                >>> <\/span>any<\/span>((<\/span>1<\/span>,<\/span>0<\/span>,<\/span>0<\/span>))<\/span>\r\nTrue<\/span>\r\n>>> <\/span>any<\/span>((<\/span>0<\/span>,<\/span>0<\/span>,<\/span>0<\/span>))<\/span>\r\nFalse<\/span>\r\n>>> <\/span>any<\/span>(<\/span>range<\/span>(<\/span>5<\/span>))<\/span>\r\nTrue<\/span>\r\n>>> <\/span>any<\/span>(<\/span>range<\/span>(<\/span>0<\/span>))<\/span>\r\nFalse<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                coerce()<\/h3>\n
                La funci\u00f3n\u00a0coerce()<\/span><\/code>\u00a0devuelve una tupla que consta de los dos argumentos num\u00e9ricos convertidos en un tipo com\u00fan, utilizando las mismas reglas que las operaciones aritm\u00e9ticas. Si la coerci\u00f3n no es posible, levante una excepci\u00f3n\u00a0TypeError<\/span>.<\/p>\n
                \n
                \n
                >>> <\/span>coerce<\/span>(<\/span>3<\/span>,<\/span> 4<\/span>)<\/span>\r\n(3, 4)<\/span>\r\n>>> <\/span>coerce<\/span>(<\/span>3<\/span>,<\/span> 4.2<\/span>)<\/span>\r\n(3.0, 4.2)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                dict()<\/h3>\n
                La funci\u00f3n\u00a0dict()<\/span><\/code>\u00a0es el constructor del tipo de\u00a0diccionario<\/span>, esta funci\u00f3n se usa crear un diccionario:<\/p>\n
                \n
                \n
                >>> <\/span>dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n{'zope': 2.13, 'python': 2.7, 'plone': 5.1}<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                Tambi\u00e9n puede crear un diccionario indicando a las claves usando comillas simples:<\/p>\n
                \n
                \n
                >>> <\/span>{<\/span>'python'<\/span>:<\/span> 2.7<\/span>,<\/span> 'zope'<\/span>:<\/span> 2.13<\/span>,<\/span> 'plone'<\/span>:<\/span> 5.1<\/span>}<\/span>\r\n{'python': 2.7, 'zope': 2, 'plone': 5.1}<\/span>\r\n>>> <\/span>dict<\/span>({<\/span>'python'<\/span>:<\/span> 2.7<\/span>,<\/span> 'zope'<\/span>:<\/span> 2.13<\/span>,<\/span> 'plone'<\/span>:<\/span> 5.1<\/span>})<\/span>\r\n{{'python': 2.7, 'zope': 2.13, 'plone': 5.1}<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                Convertir desde un grupo de dos\u00a0listas<\/span>\u00a0de forma recursiva usando la funci\u00f3n\u00a0zip()<\/span>\u00a0a tipo\u00a0diccionario<\/em>:<\/p>\n
                \n
                \n
                >>> <\/span>dict<\/span>(<\/span>zip<\/span>([<\/span>'python'<\/span>,<\/span> 'zope'<\/span>,<\/span> 'plone'<\/span>],<\/span> [<\/span>2.7<\/span>,<\/span> 2.13<\/span>,<\/span> 5.1<\/span>]))<\/span>\r\n{'python': 2.7, 'zope': 2.13, 'plone': 5.1}<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                Convertir desde un grupo de\u00a0tuplas<\/span>\u00a0respectivamente en una\u00a0lista<\/span>\u00a0a tipo\u00a0diccionario<\/em>:<\/p>\n
                \n
                \n
                >>> <\/span>dict<\/span>([(<\/span>'zope'<\/span>,<\/span> 2.13<\/span>),<\/span> (<\/span>'python'<\/span>,<\/span> 2.7<\/span>),<\/span> (<\/span>'plone'<\/span>,<\/span> 5.1<\/span>)])<\/span>\r\n{'plone': 5.1, 'zope': 2.13, 'python': 2.7}<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                frozenset()<\/h3>\n
                La funci\u00f3n\u00a0frozenset()<\/span><\/code>\u00a0es el constructor del tipo de\u00a0conjuntos<\/span>, se usa crear un conjunto\u00a0inmutable<\/em>\u00a0mediante la misma funci\u00f3n\u00a0frozenset()<\/span><\/code>\u00a0de un objeto iterable\u00a0li<\/span>s<\/span>ta<\/span>:<\/p>\n
                \n
                \n
                >>> <\/span>versiones<\/span> =<\/span> [<\/span>6<\/span>,<\/span> 2.1<\/span>,<\/span> 2.5<\/span>,<\/span> 3.6<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>,<\/span> 4<\/span>,<\/span> 2.5<\/span>]<\/span>\r\n>>> <\/span>print<\/span> versiones<\/span>,<\/span> type<\/span>(<\/span>versiones<\/span>)<\/span>\r\n[6, 2.1, 2.5, 3.6, 4, 5, 6, 4, 2.5] <type 'list'><\/span>\r\n>>> <\/span>versiones_plone<\/span> =<\/span> frozenset<\/span>(<\/span>versiones<\/span>)<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>,<\/span> type<\/span>(<\/span>versiones_plone<\/span>)<\/span>\r\nfrozenset([2.5, 4, 5, 6, 2.1, 3.6]) <type 'frozenset'><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                iter()<\/h3>\n
                La funci\u00f3n\u00a0iter()<\/span><\/code>\u00a0obtiene un\u00a0iterador<\/span>\u00a0de un objeto. En la primera forma, el argumento debe proporcionar su propio\u00a0iterador<\/em>, o ser una secuencia.<\/p>\n
                \n
                \n
                >>> <\/span>elemento<\/span> =<\/span> iter<\/span>(<\/span>\"Plone\"<\/span>)<\/span>\r\n>>> <\/span>elemento<\/span>\r\n<iterator object at 0x7eff6ce10250><\/span>\r\n>>> <\/span>elemento<\/span>.<\/span>next<\/span>()<\/span>\r\n'P'<\/span>\r\n>>> <\/span>elemento<\/span>.<\/span>next<\/span>()<\/span>\r\n'l'<\/span>\r\n>>> <\/span>elemento<\/span>.<\/span>next<\/span>()<\/span>\r\n'o'<\/span>\r\n>>> <\/span>elemento<\/span>.<\/span>next<\/span>()<\/span>\r\n'n'<\/span>\r\n>>> <\/span>elemento<\/span>.<\/span>next<\/span>()<\/span>\r\n'e'<\/span>\r\n>>> <\/span>elemento<\/span>.<\/span>next<\/span>()<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nStopIteration<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                En el ejemplo anterior, cuando se itera en la secuencia de tipo\u00a0cadena de caracteres<\/span>, al llegar al final mediante el iterador llamado\u00a0elemento<\/span><\/code>\u00a0se llama a la excepci\u00f3n\u00a0StopIteration<\/span>\u00a0y se causa el detener la iteraci\u00f3n.<\/p>\n<\/div>\n
                <\/span><\/p>\n
                list()<\/h3>\n
                La funci\u00f3n\u00a0list()<\/span><\/code>\u00a0es el constructor del tipo de\u00a0lista<\/span>, se usa crear una lista mediante la misma funci\u00f3n\u00a0list()<\/span><\/code>\u00a0de un iterable. Por ejemplo, una lista podr\u00eda crearse mediante la funci\u00f3n\u00a0range(10)<\/span>:<\/p>\n
                \n
                \n
                >>> <\/span>lista<\/span> =<\/span> list<\/span>(<\/span>range<\/span>(<\/span>10<\/span>))<\/span>\r\n>>> <\/span>print<\/span> lista<\/span>\r\n[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                next()<\/h3>\n
                La funci\u00f3n\u00a0next()<\/span><\/code>\u00a0devuelve el pr\u00f3ximo elemento desde un\u00a0iterador<\/span>.<\/p>\n
                \n
                \n
                >>> <\/span>elemento<\/span> =<\/span> iter<\/span>([<\/span>1<\/span>,<\/span>2<\/span>,<\/span>3<\/span>,<\/span>4<\/span>,<\/span>5<\/span>])<\/span>\r\n>>> <\/span>next<\/span>(<\/span>elemento<\/span>)<\/span>\r\n1<\/span>\r\n>>> <\/span>next<\/span>(<\/span>elemento<\/span>)<\/span>\r\n2<\/span>\r\n>>> <\/span>next<\/span>(<\/span>elemento<\/span>)<\/span>\r\n3<\/span>\r\n>>> <\/span>next<\/span>(<\/span>elemento<\/span>)<\/span>\r\n4<\/span>\r\n>>> <\/span>next<\/span>(<\/span>elemento<\/span>)<\/span>\r\n5<\/span>\r\n>>> <\/span>next<\/span>(<\/span>elemento<\/span>)<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nStopIteration<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                En el ejemplo anterior, cuando se itera en la secuencia de tipo\u00a0lista<\/span>, al llegar al final mediante el iterador llamado\u00a0elemento<\/span><\/code>\u00a0se llama a la excepci\u00f3n\u00a0StopIteration<\/span>\u00a0y se causa el detener la iteraci\u00f3n.<\/p>\n<\/div>\n
                <\/span><\/p>\n
                tuple()<\/h3>\n
                La funci\u00f3n\u00a0tuple()<\/span><\/code>\u00a0es el constructor del tipo de\u00a0tuplas<\/span>, se usa crear una tupla mediante la misma funci\u00f3n\u00a0tuple()<\/span><\/code>\u00a0de un iterable. Por ejemplo, una tupla podr\u00eda crearse mediante la funci\u00f3n\u00a0range(10)<\/span>:<\/p>\n
                \n
                \n
                >>> <\/span>tupla<\/span> =<\/span> tuple<\/span>(<\/span>range<\/span>(<\/span>4<\/span>,<\/span> 9<\/span>))<\/span>\r\n>>> <\/span>print<\/span> tupla<\/span>\r\n(4, 5, 6, 7, 8)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                set()<\/h3>\n
                La funci\u00f3n\u00a0set()<\/span><\/code>\u00a0es el constructor del tipo de\u00a0conjuntos<\/span>, se usa crear un conjunto\u00a0mutable<\/em>\u00a0mediante la misma funci\u00f3n\u00a0set()<\/span><\/code>\u00a0de un objeto iterable\u00a0lista<\/span>:<\/p>\n
                \n
                \n
                >>> <\/span>versiones<\/span> =<\/span> [<\/span>2.1<\/span>,<\/span> 2.5<\/span>,<\/span> 3.6<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>,<\/span> 4<\/span>]<\/span>\r\n>>> <\/span>print<\/span> versiones<\/span>,<\/span> type<\/span>(<\/span>versiones<\/span>)<\/span>\r\n[2.1, 2.5, 3.6, 4, 5, 6, 4] <type 'list'><\/span>\r\n>>> <\/span>versiones_plone<\/span> =<\/span> set<\/span>(<\/span>versiones<\/span>)<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>,<\/span> type<\/span>(<\/span>versiones_plone<\/span>)<\/span>\r\nset([2.5, 4, 5, 6, 2.1, 3.6]) <type 'set'><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                sorted()<\/h3>\n
                La funci\u00f3n\u00a0sorted()<\/span><\/code>\u00a0devuelve una lista ordenada de los elementos del tipo secuencia que recibe como argumento (lista o cadena de caracteres). La secuencia original no es modificada.<\/p>\n
                \n
                \n
                >>> <\/span>lista<\/span> =<\/span> [<\/span>23<\/span>,<\/span> 13<\/span>,<\/span> 7<\/span>,<\/span> 37<\/span>]<\/span>\r\n>>> <\/span>sorted<\/span>(<\/span>lista<\/span>)<\/span>\r\n[7, 13, 23, 37]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                La funci\u00f3n\u00a0sorted()<\/span><\/code>\u00a0siempre devuelve una lista, aunque reciba como argumento una\u00a0cadena de caracteres<\/span>.<\/p>\n
                \n
                \n
                >>> <\/span>cadena<\/span> =<\/span> \"asdlk\"<\/span>\r\n>>> <\/span>sorted<\/span>(<\/span>cadena<\/span>)<\/span>\r\n['a', 'd', 'k', 'l', 's']<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                zip()<\/h3>\n
                La funci\u00f3n\u00a0zip()<\/span><\/code>\u00a0devuelve una lista de\u00a0tuplas<\/span>, 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\u00e1s corta.<\/p>\n
                \n
                \n
                >>> <\/span>zip<\/span>([<\/span>'python'<\/span>,<\/span> 'zope'<\/span>,<\/span> 'plone'<\/span>],<\/span> [<\/span>2.7<\/span>,<\/span> 2.13<\/span>,<\/span> 5.1<\/span>])<\/span>\r\n[('python', 2.7), ('zope', 2.13), ('plone', 5.1)]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                \n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                Funciones de objetos<\/h2>\n
                Las funciones de objetos se describen a continuaci\u00f3n:<\/p>\n
                <\/span><\/p>\n
                delattr()<\/h3>\n
                La funci\u00f3n\u00a0delattr()<\/span><\/code>\u00a0elimina un atributo con nombre en un objeto;\u00a0delattr(x,<\/span>\u00a0'y')<\/span><\/code>\u00a0es equivalente a\u00a0del<\/span>\u00a0x.y<\/span><\/code>.<\/p>\n
                \n
                \n
                >>> <\/span>class<\/span> Persona<\/span>:<\/span>\r\n... <\/span>    \"\"\"Clase que representa una Persona\"\"\"<\/span>\r\n... <\/span>    cedula<\/span> =<\/span> \"V-13458796\"<\/span>\r\n... <\/span>    nombre<\/span> =<\/span> \"Leonardo\"<\/span>\r\n... <\/span>    apellido<\/span> =<\/span> \"Caballero\"<\/span>\r\n... <\/span>    sexo<\/span> =<\/span> \"M\"<\/span>\r\n...<\/span>\r\n>>> <\/span>macagua<\/span> =<\/span> Persona<\/span>()<\/span>\r\n>>> <\/span>macagua<\/span>.<\/span>sexo<\/span>\r\n'M'<\/span>\r\n>>> <\/span>delattr<\/span>(<\/span>Persona<\/span>,<\/span>'sexo'<\/span>)<\/span>\r\n>>> <\/span>macagua<\/span>.<\/span>sexo<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nAttributeError<\/span>: Persona instance has no attribute 'sexo'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                getattr()<\/h3>\n
                La funci\u00f3n\u00a0getattr()<\/span><\/code>\u00a0obtiene un atributo nombrado desde un objeto; de la siguiente forma\u00a0getattr(instancia,<\/span>\u00a0'atributo')<\/span><\/code>\u00a0el cual es equivalente a\u00a0instancia.atributo<\/span><\/code>. Cuando un argumento predeterminado es dato, es es devuelto cuando el atributo no existe; sin eso, una excepci\u00f3n es lanzada en ese caso.<\/p>\n
                \n
                \n
                >>> <\/span>class<\/span> Persona<\/span>:<\/span>\r\n... <\/span>    \"\"\"Clase que representa una Persona\"\"\"<\/span>\r\n... <\/span>    cedula<\/span> =<\/span> \"V-13458796\"<\/span>\r\n... <\/span>    nombre<\/span> =<\/span> \"Leonardo\"<\/span>\r\n... <\/span>    apellido<\/span> =<\/span> \"Caballero\"<\/span>\r\n... <\/span>    sexo<\/span> =<\/span> \"M\"<\/span>\r\n...<\/span>\r\n>>> <\/span>macagua<\/span> =<\/span> Persona<\/span>()<\/span>\r\n>>> <\/span>getattr<\/span>(<\/span>macagua<\/span>,<\/span>'sexo'<\/span>)<\/span>\r\n'M'<\/span>\r\n>>> <\/span>macagua<\/span>.<\/span>sexo<\/span>\r\n'M'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                hasattr()<\/h3>\n
                La funci\u00f3n\u00a0hasattr()<\/span><\/code>\u00a0devuelve un tipo booleano cuando el objeto tiene un atributo con el nombre dado. (Esta hecho llamando a la funci\u00f3n\u00a0getattr(instancia,<\/span>\u00a0atributo)<\/span><\/code>\u00a0y capturar excepciones.)<\/p>\n
                \n
                \n
                >>> <\/span>class<\/span> Persona<\/span>:<\/span>\r\n... <\/span>    \"\"\"Clase que representa una Persona\"\"\"<\/span>\r\n... <\/span>    cedula<\/span> =<\/span> \"V-13458796\"<\/span>\r\n... <\/span>    nombre<\/span> =<\/span> \"Leonardo\"<\/span>\r\n... <\/span>    apellido<\/span> =<\/span> \"Caballero\"<\/span>\r\n... <\/span>    sexo<\/span> =<\/span> \"M\"<\/span>\r\n...<\/span>\r\n>>> <\/span>macagua<\/span> =<\/span> Persona<\/span>()<\/span>\r\n>>> <\/span>hasattr<\/span>(<\/span>macagua<\/span>,<\/span> 'nombre'<\/span>)<\/span>\r\nTrue<\/span>\r\n>>> <\/span>hasattr<\/span>(<\/span>macagua<\/span>,<\/span> 'apellido'<\/span>)<\/span>\r\nTrue<\/span>\r\n>>> <\/span>hasattr<\/span>(<\/span>macagua<\/span>,<\/span> 'cedula'<\/span>)<\/span>\r\nTrue<\/span>\r\n>>> <\/span>hasattr<\/span>(<\/span>macagua<\/span>,<\/span> 'sexo'<\/span>)<\/span>\r\nTrue<\/span>\r\n>>> <\/span>hasattr<\/span>(<\/span>macagua<\/span>,<\/span> 'email'<\/span>)<\/span>\r\nFalse<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                <\/span><\/p>\n
                hash()<\/h3>\n
                La funci\u00f3n\u00a0hash()<\/span><\/code>\u00a0devuelve un valor hash de tipo entero para el objeto.<\/p>\n
                \n
                \n
                >>> <\/span>class<\/span> Persona<\/span>:<\/span>\r\n... <\/span>    \"\"\"Clase que representa una Persona\"\"\"<\/span>\r\n... <\/span>    cedula<\/span> =<\/span> \"V-13458796\"<\/span>\r\n... <\/span>    nombre<\/span> =<\/span> \"Leonardo\"<\/span>\r\n... <\/span>    apellido<\/span> =<\/span> \"Caballero\"<\/span>\r\n... <\/span>    sexo<\/span> =<\/span> \"M\"<\/span>\r\n...<\/span>\r\n>>> <\/span>macagua<\/span> =<\/span> Persona<\/span>\r\n>>> <\/span>type<\/span>(<\/span>macagua<\/span>)<\/span>\r\n<type 'classobj'><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                Dos objetos con el mismo valor tienen el mismo valor hash.<\/p>\n
                \n
                \n
                >>> <\/span>type<\/span>(<\/span>Persona<\/span>)<\/span>\r\n<type 'classobj'><\/span>\r\n>>> <\/span>type<\/span>(<\/span>macagua<\/span>)<\/span>\r\n<type 'classobj'><\/span>\r\n>>> <\/span>hash<\/span>(<\/span>macagua<\/span>)<\/span>\r\n8742669316448<\/span>\r\n>>> <\/span>hash<\/span>(<\/span>Persona<\/span>)<\/span>\r\n8742669316448<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                Lo contrario no es necesariamente cierto, pero es probable.<\/p>\n<\/div>\n
                <\/span><\/p>\n
                isinstance()<\/h3>\n
                La funci\u00f3n\u00a0isinstance()<\/span><\/code>\u00a0le permite corroborar si un objeto es una\u00a0instancia<\/span>\u00a0de una clase.<\/p>\n
                \n
                \n
                isinstance<\/span>(<\/span>objeto<\/span>,<\/span> tipo<\/span>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                Esta funci\u00f3n devuelve\u00a0True<\/span><\/code>\u00a0si el objeto especificado es del tipo especificado, de lo contrario\u00a0False<\/span><\/code>.<\/p>\n
                Los par\u00e1metros son:<\/p>\n
                  \n
                • objeto<\/em>, es requerido. Un objeto.<\/li>\n
                • tipo<\/em>, un tipo o una clase, o una tupla de tipos y\/o clases<\/li>\n<\/ul>\n
                  Un ejemplo de uso con la clase\u00a0Persona<\/span><\/code>\u00a0seria como lo siguiente:<\/p>\n
                  \n
                  \n
                  >>> <\/span>persona1<\/span> =<\/span> Persona<\/span>(<\/span>\"V-13458796\"<\/span>,<\/span> \"Leonardo\"<\/span>,<\/span> \"Caballero\"<\/span>,<\/span> \"M\"<\/span>)<\/span>\r\n>>> <\/span>isinstance<\/span>(<\/span>persona1<\/span>,<\/span> Persona<\/span>)<\/span>\r\nTrue<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                  Si el tipo de par\u00e1metro es una tupla, esta funci\u00f3n devuelve\u00a0True<\/span><\/code>\u00a0si le objeto es uno de los tipos en la tupla.<\/p>\n
                  \n
                  \n
                  >>> <\/span>persona1<\/span> =<\/span> Persona<\/span>(<\/span>\"V-13458796\"<\/span>,<\/span> \"Leonardo\"<\/span>,<\/span> \"Caballero\"<\/span>,<\/span> \"M\"<\/span>)<\/span>\r\n>>> <\/span>isinstance<\/span>(<\/span>persona1<\/span>,<\/span> (<\/span>Persona<\/span>,<\/span> int<\/span>))<\/span>\r\nTrue<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                  Aqu\u00ed puede decir que\u00a0persona1<\/span><\/code>\u00a0es una instancia de la clase\u00a0Persona<\/span><\/code>.<\/p>\n
                  Las clases dan la posibilidad de crear estructuras de datos m\u00e1s complejas. En el ejemplo, una clase\u00a0Persona<\/span><\/code>\u00a0que realizar\u00e1 un seguimiento del\u00a0cedula<\/span><\/code>,\u00a0nombre<\/span><\/code>,\u00a0apellido<\/span><\/code>\u00a0y\u00a0sexo<\/span><\/code>\u00a0(que pasar\u00e1 como atributos).<\/p>\n<\/div>\n
                  <\/span><\/p>\n
                  issubclass()<\/h3>\n
                  La funci\u00f3n\u00a0issubclass()<\/span><\/code>\u00a0le permite corroborar si un objeto es instancia de una clase.<\/p>\n
                  \n
                  \n
                  issubclass<\/span>(<\/span>subclase<\/span>,<\/span> clase<\/span>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                  Esta funci\u00f3n devuelve\u00a0True<\/span><\/code>\u00a0si la clase especificada es una subclase de la clase base, de lo contrario\u00a0False<\/span><\/code>.<\/p>\n
                  Un ejemplo de uso con la subclase\u00a0Supervisor<\/span><\/code>\u00a0que deriva de la clase\u00a0Persona<\/span><\/code>\u00a0seria como lo siguiente:<\/p>\n
                  \n
                  \n
                  >>> <\/span>sV1<\/span> =<\/span> Supervisor<\/span>(<\/span>\"V-16987456\"<\/span>,<\/span> \"Jen\"<\/span>,<\/span> \"Paz\"<\/span>,<\/span> \"D\"<\/span>,<\/span> \"Chivo\"<\/span>)<\/span>\r\n>>> <\/span>issubclass<\/span>(<\/span>sV1<\/span>,<\/span> Persona<\/span>)<\/span>\r\nTrue<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                  Si el tipo de par\u00e1metro es una tupla, esta funci\u00f3n devuelve\u00a0True<\/span><\/code>\u00a0si le objeto es uno de los tipos en la tupla.<\/p>\n
                  \n
                  \n
                  >>> <\/span>sV1<\/span> =<\/span> Supervisor<\/span>(<\/span>\"V-16987456\"<\/span>,<\/span> \"Jen\"<\/span>,<\/span> \"Paz\"<\/span>,<\/span> \"D\"<\/span>,<\/span> \"Chivo\"<\/span>)<\/span>\r\n>>> <\/span>issubclass<\/span>(<\/span>sV1<\/span>,<\/span> (<\/span>Persona<\/span>,<\/span> Empleado<\/span>,<\/span> Supervisor<\/span>,<\/span> Destreza<\/span>))<\/span>\r\nTrue<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
                  Aqu\u00ed puede decir que\u00a0sV1<\/span><\/code>\u00a0es una subclase derivada de la clase\u00a0Persona<\/span><\/code>.<\/p>\n
                  Las clases dan la posibilidad de crear estructuras de datos m\u00e1s complejas. En el ejemplo, una clase\u00a0Persona<\/span><\/code>\u00a0que realizar\u00e1 un seguimiento del\u00a0cedula<\/span><\/code>,\u00a0nombre<\/span><\/code>,\u00a0apellido<\/span><\/code>\u00a0y\u00a0sexo<\/span><\/code>\u00a0(que pasar\u00e1 como atributos).<\/p>\n<\/div>\n
                  <\/span><\/p>\n
                  setattr()<\/h3>\n
                  La funci\u00f3n\u00a0setattr()<\/span><\/code>\u00a0establecer un atributo con nombre en un objeto;\u00a0setattr(x,<\/span>\u00a0'y',<\/span>\u00a0v)<\/span><\/code>\u00a0es equivalente a\u00a0x.y<\/span>\u00a0=<\/span>\u00a0v<\/span><\/code>.<\/p>\n
                  \n
                  \n
                  >>> <\/span>class<\/span> Persona<\/span>:<\/span>\r\n... <\/span>    \"\"\"Clase que representa una Persona\"\"\"<\/span>\r\n... <\/span>    cedula<\/span> =<\/span> \"V-13458796\"<\/span>\r\n... <\/span>    nombre<\/span> =<\/span> \"Leonardo\"<\/span>\r\n... <\/span>    apellido<\/span> =<\/span> \"Caballero\"<\/span>\r\n... <\/span>    sexo<\/span> =<\/span> \"M\"<\/span>\r\n...<\/span>\r\n>>> <\/span>setattr<\/span>(<\/span>macagua<\/span>,<\/span> 'email'<\/span>,<\/span> 'leonardoc@plone.org'<\/span>)<\/span>\r\n>>> <\/span>getattr<\/span>(<\/span>macagua<\/span>,<\/span>'email'<\/span>)<\/span>\r\n'leonardoc@plone.org'<\/span><\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
                  Funciones integradas El interprete Python tiene un n\u00famero de funciones integradas (built-in) dentro del m\u00f3dulo\u00a0__builtins__, las cuales est\u00e1n siempre disponibles. Estas funciones est\u00e1n listadas en orden alfab\u00e9ticos a continuaci\u00f3n: Funciones generales Las funciones de uso general se describen a continuaci\u00f3n: apply() La funci\u00f3n\u00a0apply()\u00a0devuelve el resultado de una funci\u00f3n o objeto clase llamado con argumentos soportados. […]<\/p>\n","protected":false},"author":1,"featured_media":331,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","enabled":false},"version":2}},"categories":[39,40],"tags":[],"class_list":["post-379","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-programacion","category-python"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"https:\/\/i0.wp.com\/equipomedios.com\/blog\/wp-content\/uploads\/2024\/08\/python-logo-master-v3-TM.png?fit=601%2C203&ssl=1","jetpack_sharing_enabled":true,"jetpack-related-posts":[],"jetpack_likes_enabled":true,"_links":{"self":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/379","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/comments?post=379"}],"version-history":[{"count":1,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/379\/revisions"}],"predecessor-version":[{"id":380,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/379\/revisions\/380"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/media\/331"}],"wp:attachment":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/media?parent=379"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/categories?post=379"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/tags?post=379"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}