Hoja de referencia de Python3
Métodos integrados
| abs(num) | Obtener el valor absoluto |
| all(iterable) | Devuelve True si todos los elementos del iterable son True |
| any(iterable) | Devuelve True si algún elemento del iterable es True |
| ascii(object) | Convierte caracteres no ASCII en un objeto a caracteres ASCII |
| bin(num) | Convierte un número en una cadena binaria |
| bool([value]) | Convierte el valor en un booleano |
| bytearray(source) | Convierte source en tipo bytearray |
| bytes(source) | Convierte source en tipo bytes |
| callable(object) | Comprueba si un objeto es invocable |
| chr(i) | Convierte el código ASCII en carácter |
| classmethod(function) | Convierte un método en un método de clase |
| compile(source, filename, mode) | Compila la fuente en un objeto de código ejecutable |
| complex([real[, imag]]) | Crea un número complejo a partir de partes reales e imaginarias |
| delattr(object, name) | Elimina el atributo nombrado del objeto; genera una excepción si no existe |
| dict() | Crea un diccionario |
| dir([object]) | Devuelve la lista de atributos del objeto |
| divmod(x, y) | Divide x por y; devuelve el cociente y el resto |
| enumerate(iterable, start=0) | Combina un iterable en una secuencia de índices con índices y datos |
| eval(expression) | Ejecuta una expresión de cadena única y devuelve el resultado |
| exec(object, globals, locals) | Ejecuta código complejo (cadena o tipo de código); sin retorno |
| filter(function, iterable) | Filtra el iterable, conservando objetos donde la función devuelve True |
| float([x]) | Convierte número o cadena a tipo de punto flotante |
| format(value[, format_spec]) | Formatea el objeto como una cadena |
| frozenset([iterable]) | Convierte iterable en tipo conjunto inmutable |
| getattr(object, name[, default]) | Obtiene el atributo especificado del objeto; devuelve el valor predeterminado si no existe |
| globals() | Devuelve todas las variables globales en forma de diccionario |
| hasattr(object, name) | Comprueba si el objeto tiene el atributo especificado |
| hash(object) | Obtiene el valor hash de un objeto |
| help(object) | Obtiene la documentación de ayuda de un objeto |
| hex(x) | Convierte un entero en una cadena hexadecimal |
| id(object) | Devuelve el identificador único de un objeto |
| input([prompt]) | Lee una línea de entrada del usuario y la devuelve |
| int(x=0, base=10) | Convierte número o cadena en un entero |
| isinstance(object, classinfo) | Comprueba si un objeto es una instancia de una clase o su subclase |
| issubclass(object, classinfo) | Comprueba si una clase es una subclase de otra clase |
| iter(object[, sentinel]) | Genera un iterador a partir de un objeto |
| len(s) | Obtiene la longitud de un objeto (s debe ser una secuencia o colección) |
| list([iterable]) | Convierte un iterable en una lista |
| locals() | Devuelve todas las variables locales en forma de diccionario |
| map(function, iterable, …) | Aplica la función a cada elemento del iterable; devuelve la lista de resultados |
| max(arg1, arg2, *args[, key]) | Obtiene el valor máximo de un iterable o argumentos |
| memoryview(obj) | Envuelve un objeto en un objeto de vista de memoria |
| min(arg1, arg2, *args[, key]) | Obtiene el valor mínimo de un iterable o argumentos |
| next(iterator, default) | Obtiene el siguiente elemento del iterador; devuelve default si no hay más elementos |
| object() | Devuelve un nuevo objeto |
| oct(x) | Convierte un entero en una cadena octal |
| open(file) | Abre un archivo y devuelve un objeto de archivo |
| ord(c) | Convierte un carácter Unicode en su valor entero ASCII o Unicode |
| pow(x, y[, z]) | Calcula x a la potencia de y, módulo z |
| print(*objects) | Envía objetos a la salida estándar o al flujo de archivos |
| property() | Genera un atributo a partir de getter, setter, deleter |
| range(start, stop[, step]) | Devuelve una secuencia inmutable de números |
| repr(obj) | Devuelve la forma imprimible de un objeto (adecuada para el intérprete) |
| reversed(seq) | Invierte una secuencia y devuelve un iterador |
| round(number[, ndigits]) | Redondea un número de punto flotante a los decimales especificados |
| set([iterable]) | Convierte un iterable en un tipo de conjunto |
| setattr(object, name, value) | Establece el atributo del objeto por nombre |
| slice(start, stop, step) | Devuelve un objeto de rebanada (slice) |
| sorted(iterable[, key][, reverse]) | Ordena un iterable y devuelve una nueva lista |
| staticmethod(function) | Convierte un método en un método estático |
| str(object=’') | Convierte un objeto a tipo cadena (legible por humanos) |
| sum(iterable, start) | Suma todos los elementos de un iterable |
| super(type[, object-or-type]) | Obtiene la clase principal |
| tuple(iterable) | Convierte un iterable en una tupla |
| type(object) | Devuelve el tipo de un objeto |
| type(name, bases, dict) | Crea un nuevo objeto de tipo |
| vars(object) | Devuelve los atributos y valores del objeto en forma de diccionario |
| zip(*iterables) | Empaqueta elementos de múltiples iterables en tuplas; devuelve una lista |
| import(name) | Importa dinámicamente un módulo |
Métodos de lista
| append(item) | Agrega un elemento al final de la lista |
| extend(lst) | Agrega todos los elementos de lst a la lista |
| insert(index, element) | Inserta un elemento en la posición especificada en la lista |
| remove(element) | Busca y elimina la primera aparición del elemento desde la izquierda |
| index(element) | Busca y devuelve el índice de la primera aparición del elemento desde la izquierda |
| count(element) | Devuelve el número de apariciones del elemento especificado |
| pop(index) | Elimina y devuelve el elemento en la posición especificada |
| reverse() | Invierte la lista |
| sort(key=…, reverse=…) | Ordena la lista |
| copy() | Copia superficial de la lista |
| clear() | Elimina todos los elementos de la lista |
Métodos de diccionario
| clear() | Elimina todos los elementos |
| copy() | Copia superficial |
| fromkeys(sequence[, value]) | Crea un nuevo diccionario con sequence como claves y value como valor |
| get(key[, value]) | Devuelve el valor de la clave; devuelve el valor si no existe |
| items() | Devuelve todos los pares clave-valor del diccionario (como tuplas) |
| keys() | Devuelve todas las claves del diccionario |
| popitem() | Elimina y devuelve un elemento arbitrario (no aleatorio) |
| setdefault(key[, default_value]) | Inserta la clave con default_value si no existe; devuelve el valor de la clave |
| pop(key[, default]) | Elimina y devuelve el valor de la clave; devuelve default si no existe |
| values() | Devuelve todos los valores del diccionario |
| update([other]) | Actualiza el diccionario con other (diccionario o iterable de pares) |
Métodos de conjunto (Set)
| remove(element) | Elimina el elemento especificado; genera una excepción si no existe |
| add(elem) | Agrega el elemento; no hace nada si ya existe |
| copy() | Copia superficial del conjunto |
| clear() | Elimina todos los elementos del conjunto |
| a.difference(b) | Devuelve un conjunto de elementos en a pero no en b |
| a.difference_update(b) | Elimina los elementos de b de a |
| discard(x) | Elimina el elemento especificado si existe |
| a.intersection(*other_sets) | Devuelve la intersección de a y otros conjuntos |
| a.intersection_update(*other_sets) | Mantiene solo los elementos encontrados en a y todos los demás conjuntos |
| a.isdisjoint(b) | Comprueba si dos conjuntos no tienen elementos comunes |
| a.issubset(b) | Comprueba si a es un subconjunto de b |
| pop() | Elimina y devuelve un elemento arbitrario (no aleatorio) del conjunto |
| a.symmetric_difference(b) | Devuelve un conjunto de elementos en a o b pero no en ambos |
| a.symmetric_difference_update(b) | Actualiza a con la diferencia simétrica de a y b |
| a.union(*other_sets) | Devuelve la unión de a y otros conjuntos |
| a.update(b) | Actualiza a con elementos de b |
Métodos de tupla
| index(element) | Busca y devuelve la posición del elemento; genera una excepción si no existe |
| count(element) | Cuenta las apariciones del elemento especificado |
Indexación y rebanado (Slicing)
| a[x] | Obtiene el elemento (x + 1)-ésimo |
| a[-x] | Obtiene el x-ésimo elemento desde el final |
| a[x:] | Obtiene desde el elemento (x + 1)-ésimo hasta el final |
| a[:x] | Obtiene desde el primer elemento hasta el elemento (x + 1)-ésimo |
| a[:-x] | Obtiene desde el primer elemento hasta el x-ésimo elemento desde el final |
| a[x:y] | Obtiene desde el elemento (x + 1)-ésimo hasta el (y + 1)-ésimo |
| a[:] | Copia superficial de a |
Métodos de cadena
| capitalize() | Capitaliza el primer carácter |
| center(width[, fillchar]) | Centra la cadena y rellena con fillchar hasta el ancho especificado |
| casefold() | Convierte la cadena a minúsculas (más agresivo que lower()) |
| count(substring[, start[, end]]) | Cuenta las apariciones de la subcadena |
| endswith(suffix[, start[, end]]) | Comprueba si la cadena termina con el sufijo especificado |
| expandtabs(tabsize) | Convierte los \t en la cadena al número especificado de espacios |
| encode(encoding=‘UTF-8’, errors=‘strict’) | Codifica la cadena a cualquier codificación compatible |
| find(sub[, start[, end]]) | Busca la posición de la subcadena desde la izquierda (-1 si no existe) |
| format(p0, p1, …, k0=v0, k1=v1, …) | Formatea la cadena |
| index(sub[, start[, end]]) | Busca la posición de la subcadena desde la izquierda (excepción si no existe) |
| isalnum() | Comprueba si la cadena es alfanumérica |
| isalpha() | Comprueba si la cadena es alfabética |
| isdecimal() | Comprueba si la cadena consiste solo en caracteres decimales |
| isdigit() | Comprueba si la cadena consiste solo en dígitos |
| isidentifier() | Comprueba si la cadena es un identificador válido |
| islower() | Comprueba si la cadena consiste en letras minúsculas |
| isnumeric() | Comprueba si la cadena consiste solo en caracteres numéricos (soporte Unicode) |
| isprintable() | Comprueba si la cadena es imprimible |
| isspace() | Comprueba si la cadena consiste solo en espacios en blanco |
| istitle() | Comprueba si la cadena tiene formato de título |
| isupper() | Comprueba si la cadena consiste solo en letras mayúsculas |
| join(iterable) | Une un iterable de cadenas con el delimitador especificado |
| ljust(width[, fillchar]) | Justifica a la izquierda y rellena la cadena |
| rjust(width[, fillchar]) | Justifica a la derecha y rellena la cadena |
| lower() | Convierte todos los caracteres a minúsculas |
| upper() | Convierte todos los caracteres a mayúsculas |
| swapcase() | Intercambia mayúsculas por minúsculas y viceversa |
| lstrip([chars]) | Elimina los caracteres especificados de la izquierda |
| rstrip([chars]) | Elimina los caracteres especificados de la derecha |
| strip([chars]) | Elimina los caracteres especificados de ambos lados |
| partition(separator) | Divide la cadena en el primer separador; devuelve (antes, sep, después) |
| maketrans(x[, y[, z]]) | Crea una tabla de mapeo de traducción |
| rpartition(separator) | Divide la cadena en el último separador; devuelve (antes, sep, después) |
| translate(table) | Reemplaza caracteres usando la tabla de traducción |
| replace(old, new [, count]) | Reemplaza la subcadena old por new, hasta count veces |
| rfind(sub[, start[, end]]) | Busca la posición de la subcadena desde la derecha (-1 si no existe) |
| rindex(sub[, start[, end]]) | Busca la posición de la subcadena desde la derecha (excepción si no existe) |
| split([separator [, maxsplit]]) | Divide desde la izquierda usando un separador |
| rsplit([separator [, maxsplit]]) | Divide desde la derecha usando un separador |
| splitlines([keepends]) | Divide la cadena por líneas |
| title() | Convierte la cadena a formato de título (cada palabra empieza con mayúscula) |
| zfill(width) | Rellena la cadena a la izquierda con ceros hasta el ancho especificado |
| format_map(mapping) | Formatea la cadena usando un mapeo de diccionario |