Funciones incorporadas de Python (1)

El intérprete de Python tiene muchas funciones y tipos incorporados que puede utilizar en su programación en cualquier momento y en cualquier lugar. De hecho, hemos estado expuestos a muchas funciones integradas en el estudio anterior.

Aquí los resumimos en las siguientes tablas para que podamos aprender a usarlos:

Descripción:
La tabla anterior contiene "funciones incorporadas" y "tipos incorporados", en las que los tipos incorporados se pueden usar como funciones para convertir otros tipos de objetos en objetos de ese tipo. Por ejemplo, int es un tipo incorporado e int('123') convierte una cadena en un entero. No hay diferencia entre los dos en uso. La documentación oficial también introduce el tipo incorporado como una función incorporada.

Con ipython, podemos ver si la función o el tipo están en la tabla. Por ejemplo:

In [14]: abs?
Signature: abs(x, /)
Docstring: Return the absolute value of the argument.
Type:      builtin_function_or_method

In [15]: int?
Init signature: int(self, /, *args, **kwargs)
Docstring:     
int(x=0) -> integer
int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments
are given.  If x is a number, return x.__int__().  For floating point
numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string,
bytes, or bytearray instance representing an integer literal in the
given base.  The literal can be preceded by '+' or '-' and be surrounded
by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
Base 0 means to interpret the base from the string as an integer literal.
>>> int('0b100', base=0)
4
Type:           type
Subclasses:     bool, IntEnum, IntFlag, _NamedIntConstant

En ipython, verifique la descripción correspondiente por el signo de interrogación ? Typees su tipo. Puede ver que abs es una función builtin_function_or_method , e int es un tipo de type .

Introducimos estas funciones incorporadas (tipos) en varias categorías.

Operación numerica

abs(x)
Encuentra el valor absoluto de x. x puede ser un número entero o flotante, y si es un número complejo, devuelve su módulo.

bin(x)
Convierte un entero en una cadena binaria con el prefijo 0b . El resultado es una expresión legal de Python. Si x no es un objeto int de Python, entonces necesita definir el método index () para devolver un entero. Por ejemplo:

In [26]: bin(5)
Out[26]: '0b101'

In [27]: bin(-5)
Out[27]: '-0b101'

x no puede ser un número de punto flotante, de lo contrario se informará un error.
También se puede convertir por la función format() :

In [30]: format(5, '#b')
Out[30]: '0b101'

In [31]: format(5, 'b')
Out[31]: '101'

También se puede convertir con formato de f-string :

In [32]: f'{5:#b}'
Out[32]: '0b101'

In [33]: f'{5:b}'
Out[33]: '101'

chr(i)
Devuelve el formato de cadena de un carácter cuyo punto de código Unicode es un entero i. Por ejemplo, chr (97) devuelve la cadena 'a' y chr (20013) devuelve la cadena 'in'. Este es el inverso de ord ().

El rango legal del argumento es de 0 a 1, 114, 111 (la representación hexadecimal es 0x10FFFF). Si i excede este rango, se activa una excepción ValueError.

divmod(a, b)
Toma dos números (no complejos) como argumentos y devuelve un par de cocientes y restos al realizar la división de enteros. Para los tipos de operandos mixtos, se aplican las reglas para los operadores de aritmética binocular. Para enteros, el resultado es consistente con (a // b, a% b). Para los números de punto flotante, el resultado es (q, a% b), q suele ser math.floor (a / b) pero puede ser menor que 1. En cualquier caso, q * b + a% b y a son esencialmente iguales; si a% b no es cero, su signo es el mismo que b, y 0 <= abs (a% b) <abs (b).

format(value[, format_spec])
Convierte el valor en una representación "formateada" del control format_spec.

hex(x)
Convierte un entero en una cadena hexadecimal en minúsculas con el prefijo "0x". Si x no es un objeto int de Python, debe definir un método de índice () que devuelva un entero.

oct(x)
Convierta un entero en una cadena octal con el prefijo "0o". El resultado es una expresión legal de Python. Si x no es un objeto int de Python, entonces necesita definir el método index () para devolver un entero.

ord(c)
Para una cadena que representa un solo carácter Unicode, devuelva un entero que represente su punto de código Unicode. Por ejemplo, ord ('a') devuelve un entero de 97, ord ('€') (euro match) devuelve 8364. Este es el inverso de chr ().

pow(x, y[, z])
Devuelve la potencia de y a la potencia de x; si z existe, se necesita un resto de z (más eficiente que el cálculo directo de potencia (x, y)% z). Dos formas de parámetros de pow (x, y) son equivalentes al operador de energía: x**y .

round(number[, ndigits])
Devuelve el número de ndigits de precisión después del punto decimal. Si se omite ndigits o es None, se devuelve el entero más cercano a su entrada.

Para los tipos incorporados que admiten round (), el valor se redondea al extremo más cercano (redondeado hacia arriba); si la distancia es igual (5), permanece hacia el lado par. (Por ejemplo, round (0.5) y round (-0.5) son ambos 0, y round (1.5) es 2). Cualquier valor entero es válido para ndigits (positivo, cero o negativo). Si se omiten ndigits o None, el valor de retorno es un entero. De lo contrario, el valor de retorno es el mismo que el tipo de número.

Para un número de objeto Python genérico, el agente se redondea al number.__round__ .

Nota: el comportamiento de round () en números de punto flotante puede ser sorprendente, por ejemplo, round(2.675, 2) produce 2.67 lugar del esperado 2.68 . Esto no es un error, porque la mayoría de las fracciones decimales no se representan con precisión como números binarios de punto flotante.

sum(iterable[, start])

Los elementos iterables se acumulan de izquierda a derecha comenzando desde el start y se devuelve el total. El valor predeterminado de inicio es 0. El elemento iterable suele ser un número, y el valor inicial no puede ser una cadena.

Para algunos casos de uso, sum () tiene una buena alternativa. La forma rápida preferida de conectar una secuencia de cadenas es llamar ''.join(sequence) . Para acumular valores de punto flotante con precisión extendida, use math.fsum() . Para coser una serie de objetos iterables, considere usar itertools.chain() .

Operación iterable

all(iterable), any(iterable)
Estas dos funciones, que hemos aprendido muchas veces antes de aprender estructuras de datos como list y dict.
Todos (): devuelve True si todos los elementos de iterable son verdaderos (o iterable está vacío), equivalente a:

def all(iterable):
    for item in iterable:
        if not item:
            return False
    return True

Any (): Devuelve True si cualquier elemento de la iterable es True . Devuelve la devolución si iterable está vacío. Equivalente a:

def any(iterable):
    for item in iterable:
        if item:
        return True
    return False

enumerate(iterable, start=0)
Devuelve un objeto de enumeración. Iterable debe ser una secuencia, un iterador u otro objeto que admita la iteración. El método next () del iterador devuelto por enumerate () devuelve una tupla que contiene un valor de recuento (que comienza en el inicio, el valor predeterminado es 0) y el valor obtenido por iteración iterable.

In [4]: ll = ['a', 'b', 'c', 'd']

In [5]: list(enumerate(ll))
Out[5]: [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]

In [6]: list(enumerate(ll, start=1))
Out[6]: [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

Equivalente a:

def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

filter(function, iterable)
Construya un nuevo iterador devolviendo los elementos reales con la función de función en iterable. Iterable puede ser una secuencia, un contenedor que admite iteración o un iterador. Si la función es Ninguna, se supone que es una función de identidad, es decir, se eliminarán todos los elementos que devuelvan falso en iterable.

Tenga en cuenta que el filtro (función, iterable) es equivalente a una expresión generadora, cuando la función no es Ninguna (elemento para elemento en iterable si función (elemento)), cuando función es Ninguno (elemento para elemento en iterable si Artículo).
La función de complemento del elemento en iterable se selecciona solo si la función devuelve falso.

map(function, iterable, …)
Produce un iterador que aplica una función a todos los elementos en el iterador y devuelve el resultado. Si se pasa un argumento iterable adicional, la función debe aceptar el mismo número de argumentos y usar los elementos recuperados en paralelo en todos los iteradores. Cuando hay varios iteradores, el iterador más corto se agota y la iteración completa termina. Si la entrada a la función ya es un argumento de tupla, consulte itertools.starmap ().

zip(*iterables)
Cree un iterador que agregue de cada elemento iterable.

Devuelve un iterador de tuplas, donde la i-th tupla contiene el elemento i de cada secuencia de parámetros o iteración. El iterador se detiene cuando la entrada más corta se puede iterar. Usando un solo parámetro iterable, devuelve un iterador de 1 tupla. Sin argumentos, devuelve un iterador vacío. Equivalente a:

def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)

El orden de evaluación de la iteración de izquierda a derecha está garantizado. Esto hace posible utilizar zip(*[iter(s)]*n) para agrupar series de datos en grupos de n longitud.Esto repetirá el mismo iterador n veces, de modo que cada tupla de salida tenga n veces el resultado de llamar al iterador. Esto tiene el efecto de dividir la entrada en bloques de n longitud.

Cuando no te importa el final, los valores no coincidentes para las iteraciones más largas, zip () solo se debe usar con entradas de longitud desigual. Si estos valores son importantes, use itertools.zip_longest() lugar.

Zip () se usa con el operador * para descomprimir la lista:

In [80]: a = [1, 2, 3]

In [81]: b = ['a', 'b', 'c']

In [82]: zipped = zip(a, b)

In [83]: list(zipped)
Out[83]: [(1, 'a'), (2, 'b'), (3, 'c')]

In [84]: a2, b2 = zip(*zip(a, b))

In [85]: a == list(a2) and b == list(b2)
Out[86]: True

max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])
Devuelve el elemento más grande en el objeto iterable, o devuelve el mayor de los dos o más argumentos.

Si solo se proporciona un argumento posicional, debe ser iterable no nulo, devolviendo el elemento más grande en el objeto iterable; si se suministran dos o más argumentos posicionales, se devuelve el argumento posicional más grande.

Hay dos argumentos opcionales que solo pueden usarse con palabras clave. El argumento clave especifica los argumentos utilizados por la función de ordenación, como pasados a list.sort (). El argumento predeterminado es el valor que se devuelve cuando el objeto iterable está vacío. Si el objeto iterable está vacío y no se da ningún valor predeterminado, se dispara un ValueError.

Si hay varios elementos más grandes, esta función devolverá el primero que se encuentre. Esto es consistente con otras herramientas de clasificación estables tales como ordenado (iterable, key = keyfunc, reverse = True) [0] y heapq.nlargest (1, iterable, key = keyfunc).

min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])
Devuelve el elemento más pequeño en el objeto iterable, o el más pequeño de los dos o más argumentos.

Si solo se proporciona un parámetro posicional, debe ser iterable, devolviendo el elemento más pequeño en el objeto iterable; si se proporcionan dos o más parámetros posicionales, se devuelve el parámetro posicional más pequeño.

Si hay varios elementos mínimos, esta función devolverá el primero encontrado. Esto es consistente con otras herramientas de clasificación estables, como ordenado (iterable, key = keyfunc) [0] y heapq.nsmallest (1, iterable, key = keyfunc).

reversed(seq)
Devuelve un iterador inverso. Seq debe ser un objeto con un método reversed(), o admitir un protocolo de secuencia (método len () y método getitem () con argumentos enteros que comienzan en 0).

sorted(iterable, *, key=None, reverse=False)

Devuelve una nueva lista ordenada de los elementos en el iterable.

Hay dos parámetros opcionales que deben especificarse como argumentos de palabras clave.

La clave especifica una función de un parámetro que se utiliza para extraer una clave de comparación de cada elemento en el iterable (por ejemplo, clave = str.lower). El valor predeterminado es Ninguno (elemento de comparación directa).

Reverse es un valor booleano. Si se establece en Verdadero, los elementos de la lista se ordenarán de la manera opuesta.

Convierta la antigua función cmp en una función clave usando functools.cmp_to_key ().

La función clasificada () incorporada garantiza la estabilidad. Si la ordenación garantiza que el orden relativo de los elementos que son iguales no se modifica, la ordenación es estable; esto ayuda a pasar la ordenación varias veces (por ejemplo, ordenada por departamento y luego por nivel de pago).

iter(object[, sentinel])
Devuelve un objeto iterador. La interpretación del primer argumento es muy diferente dependiendo de si hay un segundo argumento. Si no hay un segundo argumento, el objeto debe ser un objeto de colección que admita un protocolo iterativo (con el método iter ()), o debe admitir un protocolo de secuencia (con el método getitem (), y el argumento numérico comienza en 0). Si no es compatible con estos protocolos, se activará un TypeError. Si hay un segundo argumento, centinela, entonces el objeto debe ser un objeto llamable. El iterador generado en este caso llamará a un objeto sin argumentos cuando llame a su método next () en cada iteración; si devuelve un centinela, activará StopIteration; de lo contrario, devolverá el resultado de la llamada.

next(iterator[, default])
Obtenga el siguiente elemento llamando al método next () del iterador. Si el iterador está agotado, se devuelve el valor predeterminado dado, y si no hay un valor predeterminado, se desencadena StopIteration.

Tipo incorporado

class bool([x])
Descripción: En la documentación, los parámetros de la función están entre corchetes []para indicar que el parámetro es opcional (en la lista de parámetros).
Tipo incorporado, devuelve un valor booleano: True o False . x utiliza el procedimiento de prueba de verdad etiquetado para convertir, y el conocimiento sobre la prueba de verdad se puede revisar más adelante en nuestro capítulo sobre valores booleanos.
bool clase bool es una subclase de int . Esta clase bool es muy especial, no se puede heredar y solo hay dos instancias de True y False .

class bytearray([source[, encoding[, errors]]])
Devuelve una nueva matriz de bytes. La clase bytearray es una secuencia variable que contiene enteros en el rango 0 <= x <256. Tiene los métodos más comunes de secuencias variables y la mayoría de los métodos del tipo de bytes.
La fuente de parámetros opcional puede inicializar la matriz de diferentes maneras:

Si es una cadena, debe proporcionar el parámetro de codificación (el parámetro de errores sigue siendo opcional); bytearray () utilizará el método str.encode () para convertir la cadena en bytes.

Si es un entero, una matriz de tamaño se inicializa y se rellena con bytes nulos.
Si es un objeto que se ajusta a la interfaz del búfer, el búfer de solo lectura del objeto se utilizará para inicializar la matriz de bytes.
Si es un objeto iterable iterable, su rango de elementos debe ser un número entero de 0 <= x <256, que se utilizará como contenido inicial de la matriz.

Si no hay ningún argumento, cree una matriz de tamaño 0.

class bytes([source[, encoding[, errors]]])
Devuelve un nuevo objeto "bytes", que es una secuencia inmutable que contiene un número entero en el rango 0 <= x <256. Bytes es una versión inmutable de bytearray: tiene métodos en los que la secuencia no se modifica y las mismas operaciones de indexación y segmentación.

Por lo tanto, el argumento del constructor es el mismo que bytearray ().

class complex([real[, imag]])
El valor de retorno es un número complejo de real + imag*1j , o una cadena o número se convierte en un número complejo. Si el primer parámetro formal es una cadena, se interpreta como un número complejo y la función debe llamarse sin un segundo parámetro formal. El segundo parámetro no puede ser una cadena. Cada argumento puede ser de cualquier tipo numérico (incluido el plural). Si se omite imag, el valor predeterminado es cero y el constructor realiza una conversión numérica como int y float.Si se omiten ambos argumentos, se devuelve 0j.

Observaciones Al convertir desde una cadena, la cadena no debe tener espacios alrededor de + o -. Por ejemplo, el complejo ('1 + 2j') es legal, pero el complejo ('1 + 2j') activará una excepción ValueError.
Cambiado en la versión 3.6: Puede usar guiones bajos para agrupar los números en el texto del código.

class float([x])
Devuelve un número de punto flotante generado a partir de un número o cadena x.

Si el argumento es una cadena, debe ser una cadena que contenga un número decimal, que puede estar precedido por un símbolo, o precedido por un espacio. Los símbolos opcionales son '+' y '-'; '+' no tiene efecto en el valor creado. Los argumentos también pueden ser cadenas NaN (no numéricas), infinitas positivas y negativas.

class int([x])
class int(x, base=10)
Devuelve un objeto entero generado con un número o cadena x, o 0 si no hay ningún argumento. Si x define int (), int (x) devuelve x. Int (). Si x define trunc (), devuelve x. Trunc (). Para los números de punto flotante, se redondea a cero.

Si x no es un número o tiene un parámetro base, x debe ser una cadena, bytes o una instancia de bytearray que representa un literal entero en la base. El texto puede ir precedido por + o - (sin espacios intermedios), con espacios antes y después. Un número en la forma de n contiene números del 0 al n-1, donde a a z (o A a Z) representan 10 a 35. La base predeterminada es 10, y el radix permitido es 0, 2-36. Los números en 2, 8 y hexadecimal se pueden representar en el código con el prefijo 0b / 0B, 0o / 0O, 0x / 0X. El número hexadecimal es 0. El valor literal del código de seguridad se interpreta exactamente. El resultado final será uno de 2, 8, 10 y hexadecimal. Así que int ('010', 0) es ilegal, pero int ('010') e int ('010', 8) son legales.

class str(object=”)
class str(object=b”, encoding=’utf-8′, errors=’strict’)

Devuelve un objeto de tipo str. str es una clase de cadena incorporada

class list([iterable])
Además de ser una función, la lista también es un tipo de secuencia variable. Consulte la lista y los Tipos de secuencia: lista, tupla, rango para detalles.

Tupla ([iterable])
Una tupla es un tipo incorporado de secuencia inmutable. Tuple tuple() genera un objeto de tupla y los elementos del parámetro opcional iterable se agregan a la tupla nueva.

Clase dict(**kwarg)
Clase dict(mapping, **kwarg)
Clase dict(iterable, **kwarg)
Crear un nuevo diccionario. El objeto dict es una clase de diccionario para otros tipos de contenedores, vea las clases integradas de lista, conjunto y tupla, así como el módulo de colecciones.

class set([iterable])
Devuelve un objeto establecido. El parámetro opcional iterable se agregará al nuevo objeto establecido.

class frozenset([iterable])
Devuelve un nuevo objeto frozenset que contiene los elementos en el parámetro opcional iterable. Frozenset es una clase incorporada.

class object
Devuelve un nuevo objeto sin características. El objeto es la clase base para todas las clases. Tiene una forma genérica de todas las instancias de clase Python. Esta función no acepta ningún argumento.

Nota Debido a que el objeto no tiene un dict , no es posible asignar ningún atributo a una instancia de objeto.

class range(stop)
class range(start, stop[, step])
range es en realidad un tipo de secuencia numérica inmutable en lugar de una función, generalmente se usa para hacer un bucle un número específico de veces en un bucle for.
El argumento pasado al rango debe ser un entero (ya sea un tipo incorporado int o un objeto que implementa el método especial de índice ). Si se omite el parámetro de step , el valor predeterminado es 1. Si start omite el start , el valor predeterminado es 0. Si el step es 0, se informa de un error: ValueError .

Si step es un entero, el contenido del rango se determina mediante la fórmula: r[i] = start + step*i , donde i >= 0, r[i] < stop .

Si el step es negativo, el contenido del rango aún está determinado por la fórmula: r[i] = start + step*i , donde i >= 0, r[i] > stop .

Si r [0] no satisface la restricción de valor, el objeto de rango estará vacío. El rango admite índices negativos, pero estos índices se interpretan como índices que comienzan al final de la secuencia determinada por el índice positivo.

Se permite que el sys.maxsize contenga valores sys.maxsize valor absoluto sea mayor que sys.maxsize , pero algunas características (como len ()) pueden reportar un error: OverflowError .
Vea el ejemplo de rango a continuación:

In [32]: list(range(9))
Out[32]: [0, 1, 2, 3, 4, 5, 6, 7, 8]

In [33]: list(range(3,9))
Out[33]: [3, 4, 5, 6, 7, 8]

In [34]: list(range(0, 20, 3))
Out[34]: [0, 3, 6, 9, 12, 15, 18]

In [35]: list(range(0, -10, -1))
Out[35]: [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

In [36]: list(range(0))
Out[36]: []

In [37]: list(range(10, 0))
Out[37]: []

La ventaja del tipo de rango sobre una lista normal o tupla es que el rango siempre ocupa la misma cantidad (pequeña) de memoria debajo de la línea, sin importar qué tan grande sea. Debido a que solo almacena los valores de start , stop y step , evalúa elementos individuales o subrangos cuando sea necesario.

El objeto de rango implementa funciones como listas o secuencias de tuplas, como pruebas, búsquedas de índices de elementos, cortes y compatibilidad con índices negativos. Vea el ejemplo a continuación:

In [43]: r = range(0, 10, 2)

In [44]: r
Out[44]: range(0, 10, 2)

In [45]: 5 in r
Out[45]: False

In [46]: 6 in r
Out[46]: True

In [47]: r.index(8)
Out[47]: 4

In [48]: r[3]
Out[48]: 6

In [49]: r[:3]
Out[49]: range(0, 6, 2)

In [50]: r[-1]
Out[50]: 8

Probar la igualdad de dos objetos de rango con == y != Es una comparación de ellos como una secuencia. Es decir, si dos objetos de rango representan secuencias del mismo valor, se consideran iguales en tiempo real.

Nota: Dos objetos de rango son iguales pero pueden tener diferentes atributos de start , stop y step , como el range(0) == range(2, 1, 1) o range(0, 3, 2) == range(0, 4, 2) .

class slice(stop)
class slice(start, stop[, step])

Devuelve un objeto de sector que representa el conjunto de índices especificado por rango (inicio, parada, paso). Los parámetros de inicio y paso están predeterminados en Ninguno. El objeto Slice tiene propiedades de datos de solo lectura de inicio, detención y paso que devuelven solo los valores de los parámetros (o sus valores predeterminados).No tienen otras características explícitas, pero son utilizadas por Numerical Python y otras extensiones de terceros. También se genera un objeto de división cuando se utiliza la sintaxis de índice extendido. Por ejemplo: a [start: stop: step] o a [start: stop, i].

class type(object)
class type(name, bases, dict)

Pasar un objeto de parámetro devuelve el tipo del objeto. El valor de retorno es un objeto de tipo, generalmente el mismo que devuelve el object.__class__ .
Se recomienda usar la función incorporada isinstance () para probar el tipo de objeto, ya que debe considerar subclases.
Devuelve un nuevo tipo de objeto con tres parámetros. Esto es en realidad una forma dinámica de una declaración de clase. La cadena de nombre es el nombre de la clase y se convierte en el atributo de nombre , la tupla primitiva enumera la clase base y se convierte en el atributo de base , y el diccionario dict es el espacio de nombres que contiene la definición del cuerpo de la clase y se copia al diccionario estándar para convertirse en el atributo dict . Por ejemplo, las siguientes dos declaraciones crean el mismo objeto de tipo:

In [77]: class A: 
    ...:     a = 1 
    ...:

In [78]: A = type('A', (object,), dict(a=1))

Códigopara

搜尋此網誌