Tipos Integrados¶
Esta sección describe los tipos de datos estándar que vienen incluidos en el intérprete.
Los principales tipos de datos son: numéricos, secuencias, mapas, clases, instancias y excepciones.
Algunas clases de tipo colección son mutables. Los métodos que añaden, retiran u ordenan los contenidos lo hacen internamente, y a no ser que retornen un elemento concreto, nunca retornan la propia instancia contenedora, sino None
.
Algunas operaciones son soportadas por varios tipos de objetos diferentes; por ejemplo, prácticamente todos los objetos pueden ser comparados por igualdad, evaluados para ser considerados como valores booleanos, o representarse en forma de cadena de caracteres (Ya sea con la función repr()
o la ligeramente diferente str()
). Esta última es la usada implícitamente por la función print()
.
Evaluar como valor verdadero/falso¶
Cualquier objeto puede ser evaluado como si fuera un valor verdadero o falso, para ser usado directamente en sentencias if
o while
, o como un operador en una operación booleana como las que veremos más adelante.
Por defecto, un objeto se considera verdadero a no ser que su clase defina o bien un método __bool__()
que retorna False
o un método __len__()
que retorna cero, cuando se invoque desde ese objeto. 1 Aquí están listados la mayoría de los objetos predefinidos que se evalúan como falsos:
constantes definidas para tener valor falso:
None
yFalse
.cero en cualquiera de los diferentes tipos numéricos:
0
,0.0
,0j
,Decimal(0)
,Fraction(0, 1)
cualquier colección o secuencia vacía:
''
,()
,[]
,{}
,set()
,range(0)
Las operaciones y funciones predefinidas que retornan como resultado un booleano siempre retornan 0
o False
para un valor falso, y 1
o True
para un valor verdadero, a no ser que se indique otra cosa (Hay una excepción importante: Los operadores booleanos or
y and
siempre retornan uno de los dos operadores).
Operaciones booleanas — and
, or
, not
¶
Estas son las operaciones booleanas, ordenadas de menor a mayor prioridad:
Operación |
Resultado |
Notas |
---|---|---|
|
si x es falso, entonces y, si no, x |
(1) |
|
si x es falso, entonces x, si no, y |
(2) |
|
si x es falso, entonces |
(3) |
Notas:
Este operador usar lógica cortocircuitada, por lo que solo evalúa el segundo argumentos si el primero es falso.
Este operador usa lógica cortocircuitada, por lo que solo evalúa el segundo argumentos si el primero es verdadero.
El operador
not
tiene menos prioridad que los operadores no booleanos, así quenot a == b
se interpreta comonot (a == b)`, y ``a == not b
es un error sintáctico.
Comparaciones¶
Existen ocho operadores de comparación en Python. Todos comparten el mismo nivel de prioridad (que es mayor que el nivel de las operaciones booleanas). Las comparaciones pueden encadenarse de cualquier manera; por ejemplo, x < y <= z
equivale a x < y and y <= z
, excepto porque y solo se evalúa una vez (No obstante, en ambos casos z no se evalúa si no es verdad que x < y
).
Esta tabla resumen las operaciones de comparación:
Operación |
Significado |
---|---|
|
estrictamente menor que |
|
menor o igual que |
|
estrictamente mayor que |
|
mayor o igual que |
|
igual que |
|
diferente que |
|
igualdad a nivel de identidad (Son el mismo objeto) |
|
desigualdad a nivel de identidad (no son el mismo objeto) |
Nunca se consideran iguales objetos que son de tipos diferentes, con la excepción de los tipos numéricos. El operador ==
siempre está definido, pero en algunos tipos de objetos (Como por ejemplo, las clases) es equivalente al operador is
. Los operadores <
, <=
, >
y >=
solo están definidos cuando tienen sentido; por ejemplo, si uno de los operadores es un número complejo, la comparación elevará una excepción de tipo TypeError
.
Instancias de una clase que no son idénticas normalmente se consideran como diferentes, a no ser que la clase defina un método __eq__()
.
Las instancias de una clase no pueden ordenarse con respecto a otras instancias de la misma clases, ni con otro tipo de objetos, a no ser que la clase defina un subconjunto suficiente de estos métodos: __lt__()
, __le__()
, __gt__()
y __ge__()
(En general, __lt__()
y __eq__()
son suficientes, si solo necesitas los significados convencionales de los operadores de comparación).
El comportamiento de los operadores is
e is not
no se puede personalizar; además, nunca elevan una excepción, no importa que dos objetos se comparen.
Hay otras dos operaciones con la misma prioridad sintáctica: in
y not in
, que son soportadas por aquellos tipos de datos que son de tipo iterable o que implementen el método __contains__()
.
Tipos numéricos — int
, float
, complex
¶
Hay tres tipos numéricos distintos: enteros, números en coma flotante`y :dfn:`números complejos. Además, los booleanos son un subtipo de los enteros. Los enteros tiene precisión ilimitada. Los números en coma flotante se implementan normalmente usando el tipo double
de C; Hay más información sobre la precisión y la representación interna de los números en coma flotante usadas por la máquina sobre la que se ejecuta tu programa en sys.float_info
. Los números complejos tienen una parte real y otra imaginaria, ambas representadas con números en coma flotante. Para extraer estas partes del número complejo z se usan los métodos z.real
y z.imag
. (La librería estándar incluye tipos numéricos adicionales: fractions.Fraction
para números racionales y decimal.Decimal
para números en coma flotante con precisión definida por el usuario).
Los números se crean a partir de una expresión literal, o como resultado de una combinación de funciones predefinidas y operadores. Expresiones literales de números (incluyendo números expresados en hexadecimal, octal o binario) producen enteros. Si la expresión literal contiene un punto decimal o un signo de exponente, se genera un número en coma flotante. Si se añade como sufijo una 'j'
o una 'J'
a un literal numérico, se genera un número imaginario puro (Un número complejo con la parte real a cero), que se puede sumar a un número entero o de coma flotante para obtener un número complejo con parte real e imaginaria.
Python soporta completamente una aritmética mixta: Cuando un operador binario de tipo aritmético se encuentra con que los operadores son de tipos diferentes, el operando con el tipo de dato más «estrecho» o restrictivo se convierte o amplia hasta el nivel del otro operando. Los enteros son más «estrechos» que los de coma flotante, que a su vez son más estrechos que los números complejos. Las comparaciones entre números de diferentes tipos se comportan como si se compararan los valores exactos de estos. 2
Las funciones constructoras int()
, float()
y complex()
se pueden usar para generar números de cada tipo determinado.
Todos los tipos numéricos (menos los complejos) soportan las siguientes operaciones (Para las prioridades de las operaciones, véase Prioridad de operador):
Operación |
Resultado |
Notas |
Documentación completa |
---|---|---|---|
|
suma de x e y |
||
|
resta de x e y |
||
|
multiplicación de x por y |
||
|
división de x por y |
||
|
división entera de x por y |
(1) |
|
|
resto o residuo de x por y |
(2) |
|
|
valor de x, negado |
||
|
valor de x, sin cambiar |
||
|
valor absoluto de la magnitud de x |
||
|
valor de x convertido a entero |
(3)(6) |
|
|
valor de x convertido a número de punto flotante |
(4)(6) |
|
|
un número complejo, con parte real re y parte imaginaria im. El valor de im por defecto vale cero. |
(6) |
|
|
conjugado del número complejo c |
||
|
el par de valores |
(2) |
|
|
x elevado a y |
(5) |
|
|
x elevado a y |
(5) |
Notas:
También conocida como división entera. El resultado es un número entero en el sentido matemático, pero no necesariamente de tipo entero. El resultado se redondea de forma automática hacia menos infinito:
1//2
es0
,(-1)//2
es-1
,1//(-2)
es-1
y(-1)//(-2)
es0
.No es apropiada para números complejos. Es preferible convertir a valores en coma flotante usando la función
abs()
si fuera apropiado.Conversiones desde coma flotante a entero pueden redondearse o truncarse como en C; véanse las funciones
math.floor()
ymath.ceil()
para un mayor control.float también acepta las cadenas de caracteres «nan» e «inf», con un prefijo opcional «+» o «-», para los valores Not a Number (NaN) e infinito positivo o negativo.
Python define
pow(0, 0)
y0 ** 0
para que valgan1
, como es práctica habitual en los lenguajes de programación.Los literales numéricos aceptables incluyen los dígitos desde el
0
hasta el9
, así como cualquier carácter Unicode equivalente (puntos de código con la propiedadNd
).En http://www.unicode.org/Public/12.1.0/ucd/extracted/DerivedNumericType.txt se puede consultar una lista completa de los puntos de código con la propiedad
Nd
.
Todas las clases derivadas de numbers.Real
(int
y float
) también soportan las siguientes operaciones:
Operación |
Resultado |
---|---|
x truncado a |
|
El valor de x redondeado a n dígitos, redondeando la mitad al número par más cercano (Redondeo del banquero). Si no se especifica valor para n, se asume 0. |
|
el mayor número |
|
el menor número |
Para más operaciones numéricas consulta los módulos math
y cmath
.
Operaciones de bits en números enteros¶
Las operaciones a nivel de bit solo tienen sentido con números enteros. El resultado de una de estas operaciones se calcula como si se hubiera realizado en una representación en complemento a dos que tuviera un número infinito de bits de signo.
La prioridad de todas las operaciones de bits son menores que las operaciones numéricas, pero mayores que las comparaciones; la operación unaria ~
tiene la misma prioridad que las otras operaciones unarias numéricas (+
y -
).
Esta tabla lista las operaciones de bits, ordenadas de menor a mayor prioridad:
Operación |
Resultado |
Notas |
---|---|---|
|
la operación or entre x e y |
(4) |
|
la operación exclusive or entre x e y |
(4) |
|
la operación and entre x e y |
(4) |
|
El valor x desplazado a la izquierda n bits |
(1)(2) |
|
valor de x desplazado a la derecha n bits |
(1)(3) |
|
invierte los bits de x |
Notas:
Los desplazamientos negativos son ilegales y elevan una excepción de tipo
ValeError
.A left shift by n bits is equivalent to multiplication by
pow(2, n)
.A right shift by n bits is equivalent to floor division by
pow(2, n)
.Realizar estos cálculos con al menos un bit extra de signo en una representación finita de un número en complemento a dos (Un ancho de bits de trabajo de
1 + max(x.bit_length(), y.bit_length())
o más) es suficiente para obtener el mismo resultado que si se hubiera realizado con un número infinito de bits de signo.
Métodos adicionales de los enteros¶
El tipo int implementa la clase base abstracta numbers.Integral
. Además, proporciona los siguientes métodos:
-
int.
bit_length
()¶ Retorna el número de bits necesarios para representar un número entero, excluyendo el bit de signo y los ceros a la izquierda:
>>> n = -37 >>> bin(n) '-0b100101' >>> n.bit_length() 6
De forma más precisa, si
x
es distinto de cero, entoncesx.bit_length()
es el único número entero positivok
tal que2**(k-1) <= abs(x) < 2**k
. De igual manera, cuandoabs(x)
es lo suficientemente pequeño para tener un logaritmo redondeado correctamente, entoncesk = 1 + int(log(abs*x), 2))
. Six
es cero, entoncesx.bit_length()
retorna0
.Equivale a:
def bit_length(self): s = bin(self) # binary representation: bin(-37) --> '-0b100101' s = s.lstrip('-0b') # remove leading zeros and minus sign return len(s) # len('100101') --> 6
Nuevo en la versión 3.1.
-
int.
to_bytes
(length, byteorder, *, signed=False)¶ Retorna un array de bytes que representan el número entero.
>>> (1024).to_bytes(2, byteorder='big') b'\x04\x00' >>> (1024).to_bytes(10, byteorder='big') b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> (-1024).to_bytes(10, byteorder='big', signed=True) b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little') b'\xe8\x03'
El número entero se representa usando el número de bits indicados con length. Se elevará la excepción
OverflowError
si no se puede representar el valor con ese número de bits.El argumento byteorder determina el orden de representación del número entero. Si byteorder es
"big"
, el byte más significativo ocupa la primera posición en el vector. Si byteorder es"little"
, el byte más significativo estará en la última posición. Para indicar que queremos usar el ordenamiento propio de la plataforma, podemos usarsys.byteorder
como valor del argumento.El parámetro signed determina si se usa el complemento a dos para representar los números enteros. Si signed es
False
, y se usa un valor entero negativo, se elevará la excepciónOverflowError
. El valor por defecto para signed esFalse
.Nuevo en la versión 3.2.
-
classmethod
int.
from_bytes
(bytes, byteorder, *, signed=False)¶ Retorna el número entero representado por el vector de bytes.
>>> int.from_bytes(b'\x00\x10', byteorder='big') 16 >>> int.from_bytes(b'\x00\x10', byteorder='little') 4096 >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True) -1024 >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False) 64512 >>> int.from_bytes([255, 0, 0], byteorder='big') 16711680
El argumento bytes debe ser o bien un objeto tipo binario o un iterable que produzca bytes.
El argumento byteorder determina el orden de representación del número entero. Si byteorder es
"big"
, el byte más significativo ocupa la primera posición en el vector. Si byteorder es"little"
, el byte más significativo estará en la última posición. Para indicar que queremos usar el ordenamiento propio de la plataforma, podemos usarsys.byteorder
como valor del argumento.El argumento signed determina si se representará el número entero usando complemento a dos.
Nuevo en la versión 3.2.
-
int.
as_integer_ratio
()¶ Retorna una pareja de números enteros cuya proporción es igual a la del numero entero original, y con un denominador positivo. En el caso de números enteros, la proporción siempre es el número original y
1
en el denominador.Nuevo en la versión 3.8.
Métodos adicionales de Float¶
El tipo float implementa la clase numbers.Real
clase base abstracta. Los números float tienen además los siguientes métodos.
-
float.
as_integer_ratio
()¶ Retorna una pareja de números enteros cuya proporción es exactamente igual que la del valor en punto flotante original, con un denominador positivo. Si se llama con valores infinitos eleva una excepción de tipo
OverflowError
y si se llama con NaN (Not A Number) eleva una excepción de tipoValueError
.
-
float.
is_integer
()¶ Retorna
True
si el valor en coma flotante se puede representar sin perdida con un número entero, yFalse
si no se puede:>>> (-2.0).is_integer() True >>> (3.2).is_integer() False
Hay dos métodos que convierten desde y hacia cadenas de caracteres en hexadecimal. Como los valores en coma flotante en Python se almacenan internamente en binario, las conversiones desde o hacia cadenas decimales pueden implicar un pequeño error de redondeo. Pero con cadenas de texto en hexadecimal, las cadenas se corresponden y permiten representar de forma exacta los números en coma flotante. Esto puede ser útil, ya sea a la hora de depurar errores, o en procesos numéricos.
-
float.
hex
()¶ Retorna la representación de un valor en coma flotante en forma de cadena de texto en hexadecimal. Para números finitos, la representación siempre empieza con el prefijo
0x
, y con unap
justo antes del exponente.
-
classmethod
float.
fromhex
(s)¶ Método de clase que retorna el valor en coma flotante representado por la cadena de caracteres en hexadecimal en s. La cadena s puede tener espacios en blanco al principio o al final.
Nótese que float.hex()
es un método de instancia, mientras que float.fromhex()
es un método de clase.
Una cadena de caracteres en hexadecimal sigue este formato:
[sign] ['0x'] integer ['.' fraction] ['p' exponent]
donde el componente opcional sign
puede ser o bien +
o -
. Las componentes integer
y fraction
son cadenas de caracteres que solo usan dígitos hexadecimales, y exponent
es un número decimal, precedido con un signo opcional. No se distingue entre mayúsculas y minúsculas, y debe haber al menos un dígito hexadecimal tanto en la parte entera como en la fracción. Esta sintaxis es similar a la sintaxis especificada en la sección 6.4.4.2 del estándar C99, y es también la sintaxis usada en Java desde la versión 1.5. En particular, la salida de float.hex()
se puede usar como una cadena de caracteres en hexadecimal en código C o Java, y las cadenas de caracteres hexadecimal producidas por el carácter de formato %a``en C, o por el método Java, ``Double.toHexString
, son aceptadas por float.fromhex()
.
Nótese que el valor del exponente está expresado en decimal, no en hexadecimal, e indica la potencia de 2 por la que debemos multiplicar el coeficiente. Por ejemplo, la cadena de caracteres hexadecimal 0x3.a7p10
representa el número en coma flotante (3 + 10./16 + 7./16**2) * 2.0**10
, o 3740.0
:
>>> float.fromhex('0x3.a7p10')
3740.0
Si aplicamos la operación inversa a 3740.0
retorna una cadena de caracteres hexadecimal diferente que, aun así, representa el mismo número:
>>> float.hex(3740.0)
'0x1.d380000000000p+11'
Calculo del hash de tipos numéricos¶
Para dos números x
e y
, posiblemente de tipos diferentes, se requiere que hash(x) == hash(y)
sea verdadero siempre que x == y
(Véase la documentación sobre el método __hash__()
para más detalles). Por razones tanto de eficiencia como de facilidad de implementación entre los tipos numéricos diferentes (Incluyendo int
, float
, decimal.Decimal
y fractions.Fraction
), el método de hash de Python se basa en una función matemática sencilla que está definida para cualquier número racional, con lo cual se puede aplicar a todas las instancias de int
y fractions.Fraction
, y a todas las instancias finitas de float
y decimal.Decimal
. En esencia, lo que hace esta función es una reducción modulo P
para un valor fijo del número primo P
. El valor de P
está disponible en Python como atributo de sys.hash_info
con el nombre de modulus
.
CPython implementation detail: Actualmente, el número primo usado es P = 2**31 - 1
para máquinas de 32 bits, y P = 2**61 - 1
en máquinas de 64 bits.
Aquí están las reglas en detalle:
Si
x = m / n
es un número racional no negativo yn
no es divisible porP
, se definehash(x)
comom * invmod(n, P) % P
, dondeinvmod(n, P)
retorna la inversa den
moduloP
.Si
x = m / n
es un número racional no negativo yn
es divisible porP
(Pero no asím
), entoncesn
no tiene módulo inverso deP
y no se puede aplicar la regla anterior; en este caso,hash(x)``retorna el valor constante definido en ``sys.hash_info.inf
.Si
x = m / n
es un número racional negativo se definehash(x)
como-hash(x)
. Si el resultado fuera-1
, lo cambia por-2
.Los valores concretos
sys.hash_info.inf
,-sys.hash_info.inf
ysys.hash_info.nan
se usan como valores hash de infinito positivo, infinito negativo y NaN (Not a Number), respectivamente. (Todos los valores NaN comparten el mismo valor de hash).Para un número complejo
z
(Una instancia de la clasecomplex
), el valor de hash se calcula combinando los valores de hash de la parte real e imaginaria, usando la fórmulahash(z.real) + sys.hash_info.imag * hash(z.imag)
, módulo reducido2**sys.hash_info.width
, de forma que el valor obtenido esté en en rangorange(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1))
. De nuevo, si el resultado fuera-1
, se reemplaza por-2
.
Para clarificar las reglas previas, aquí mostramos un ejemplo de código Python, equivalente al cálculo realizado en la función hash, para calcular el hash de un número racional, de tipo float
, o complex
:
import sys, math
def hash_fraction(m, n):
"""Compute the hash of a rational number m / n.
Assumes m and n are integers, with n positive.
Equivalent to hash(fractions.Fraction(m, n)).
"""
P = sys.hash_info.modulus
# Remove common factors of P. (Unnecessary if m and n already coprime.)
while m % P == n % P == 0:
m, n = m // P, n // P
if n % P == 0:
hash_value = sys.hash_info.inf
else:
# Fermat's Little Theorem: pow(n, P-1, P) is 1, so
# pow(n, P-2, P) gives the inverse of n modulo P.
hash_value = (abs(m) % P) * pow(n, P - 2, P) % P
if m < 0:
hash_value = -hash_value
if hash_value == -1:
hash_value = -2
return hash_value
def hash_float(x):
"""Compute the hash of a float x."""
if math.isnan(x):
return sys.hash_info.nan
elif math.isinf(x):
return sys.hash_info.inf if x > 0 else -sys.hash_info.inf
else:
return hash_fraction(*x.as_integer_ratio())
def hash_complex(z):
"""Compute the hash of a complex number z."""
hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
# do a signed reduction modulo 2**sys.hash_info.width
M = 2**(sys.hash_info.width - 1)
hash_value = (hash_value & (M - 1)) - (hash_value & M)
if hash_value == -1:
hash_value = -2
return hash_value
Tipos de iteradores¶
Python soporta el concepto de iteradores sobre contenedores. Esto se implementa usando dos métodos diferentes: Estos son usados por las clases definidas por el usuario para soportar iteración. Las secuencias, que se describirán con mayor detalle, siempre soportan la iteración.
Para que un objeto contenedor soporte iteración, debe definir un método:
-
container.
__iter__
()¶ Retorna un objeto iterador. Este objeto es requerido para soportar el protocolo de iteración que se describe a continuación. Si un contenedor soporta diferentes tipos de iteración, se pueden implementar métodos adicionales para estos iteradores (por ejemplo, un tipo de contenedor que puede soportar distintas formas de iteración podría ser una estructura de tipo árbol que proporcione a la vez un recorrido en profundidad o en anchura). Este método se corresponde al slot
tp_iter
de la estructura usada para los objetos Python en la API Python/C.
Los objetos iteradores en si necesitan definir los siguientes dos métodos, que forma juntos el protocolo iterador:
-
iterator.
__iter__
()¶ Retorna el propio objeto iterador. Este método es necesario para permitir tanto a los contenedores como a los iteradores usar la palabras clave
for
oin
. Este método se corresponde con el slottp_iter
de la estructura usada para los objetos Python en la API Python/C.
-
iterator.
__next__
()¶ Retorna el siguiente elemento del contenedor. Si no hubiera más elementos, eleva la excepción
StopIteration
. Este método se corresponde con el slottp_iternext
de la estructura usada para los objetos Python en la API Python/C.
Python define varios objetos iteradores que permiten iterar sobre las secuencias, ya sean generales o específicas, diccionarios y otras estructuras de datos especializadas. Los tipos específicos no son tan importantes como la implementación del protocolo iterador.
Una vez que la ejecución del método __next__()
eleva la excepción StopIteration
, debe continuar haciéndolo en subsiguientes llamadas al método. Si una implementación no cumple esto, se considera rota.
Tipos Generador¶
Los generator de Python proporcionan una manera cómoda de implementar el protocolo iterador. Si un objeto de tipo contenedor implementa el método __iter__()
como un generador, de forma automática este retornará un objeto iterador (Técnicamente, un objeto generador) que implementa los métodos __iter__()
y __next__()
. Se puede obtener más información acerca de los generadores en la documentación de la expresión yield.
Tipos secuencia — list
, tuple
, range
¶
Hay tres tipos básicos de secuencia: listas, tuplas y objetos de tipo rango. Existen tipos de secuencia especiales usados para el procesado de datos binarios y cadenas de caracteres que se describirán en secciones específicas.
Operaciones comunes de las secuencias¶
Las operaciones de la siguiente tabla están soportadas por la mayoría de los tipos secuencia, tanto mutables como inmutables. La clase ABC collections.abc.Sequence
se incluye para facilitar la implementación correcta de estas operaciones en nuestros propios tipos de secuencias.
La tabla lista las operaciones ordenadas de menor a mayor prioridad. En la tabla, s y t representan secuencias del mismo tipo, n, i, j y k son números enteros y x es un objeto arbitrario que cumple con cualquier restricción de tipo o valor impuesta por s.
Las operaciones in
y not in
tienen la misma prioridad que los operadores de comparación. Las operaciones +
(Concatenación) y *
(Repetición) tienen la misma prioridad que sus equivalentes numéricos 3
Operación |
Resultado |
Notas |
---|---|---|
|
|
(1) |
|
|
(1) |
|
la concatenación de s y t |
(6)(7) |
|
equivale a concatenar s consigo mismo n veces |
(2)(7) |
|
El elemento i-esimo de s, empezando a contar en 0 |
(3) |
|
la rebanada de s desde i hasta j |
(3)(4) |
|
la rebanada de s desde i hasta j, con paso j |
(3)(5) |
|
longitud de s |
|
|
el elemento más pequeño de s |
|
|
el elemento más grande de s |
|
|
índice de la primera ocurrencia de x en s (en la posición i o superior, y antes de j) |
(8) |
|
número total de ocurrencias de x en s |
También se pueden comparar secuencias del mismo tipo. En particular, las tuplas y las listas se comparan por orden lexicográfico, comparando los elementos en la misma posición. Esto significa que, para que se consideren iguales, todos los elementos correspondientes deben ser iguales entre si, y las dos secuencias deben ser del mismo tipo y de la misma longitud (Para más detalles, véase Comparaciones en la referencia del lenguaje).
Notas:
Aunque las operaciones
in
ynot in
se usan generalmente para comprobar si un elemento está dentro de un contenedor, en algunas secuencias especializadas (Comostr
,bytes
ybytearray
) también se pueden usar para comprobar si está incluida una secuencia:>>> "gg" in "eggs" True
Valores de n menores que
0
se consideran como0
(Que produce una secuencia vacía del mismo tipo que s). Nótese que los elementos de la secuencia s no se copian, sino que se referencian múltiples veces. Esto a menudo confunde a programadores noveles de Python; considérese:>>> lists = [[]] * 3 >>> lists [[], [], []] >>> lists[0].append(3) >>> lists [[3], [3], [3]]
Lo que ha pasado es que
[[]]
es una lista de un elemento, siendo este elemento una lista vacía, así que los tres elementos de[[]] * 3
son referencias a la misma lista vacía. Modificar cualquiera de los elementos delists
modifica la lista inicial. Para crear una lista de listas independientes entre si, se puede hacer:>>> lists = [[] for i in range(3)] >>> lists[0].append(3) >>> lists[1].append(5) >>> lists[2].append(7) >>> lists [[3], [5], [7]]
Se puede consultar una explicación más completa en esta entrada de la lista de preguntas más frecuentes ¿Cómo puedo crear una lista multidimensional?.
Si i o j es negativo, el índice es relativo al final de la secuencia s: Se realiza la sustitución
len(s) + i
olen(s) + j
. Nótese que-0
sigue siendo0
.La rebanada de s desde i a j se define como la secuencia de elementos con índice k, de forma que
i <= k < j
. Si i o j es mayor quelen(s)
se usalen(s)
. Si i se omite o esNone
, se usa0
. Si j se omite o esNone
, se usalen(s)
. Si i es mayor o igual a j, la rebanada estaría vacía.La rebanada de s, desde i hasta j con paso k, se define como la secuencia de elementos con índice
x = i + n*k
tal que0 <= n < (j-i)/k
. En otras palabras, los índices soni
,i+k
,i+2*k
,i+3*k
y así consecutivamente, hasta que se alcance el valor de j (Pero sin incluir nunca j). Cuando k es positivo, i y j se limitan al valor delen(s)
, si fueran mayores. Si k es negativo, i y j se reducen delen(s) - 1
. Si i o j se omiten o su valor esNone
, se convierten es valores «finales» (Donde el sentido de final depende del signo de k). Nótese que k no puede valer0
. Si k valeNone
, se considera como1
.La concatenación de secuencias inmutables siempre produce un nuevo objeto. Esto significa que construir una secuencia usando la concatenación tiene un coste en ejecución cuadrático respecto al tamaño de la secuencia final. Para obtener un rendimiento lineal, se puede optar por una de las alternativas siguientes:
en vez de concatenar objetos de tipo
str
, se puede construir una lista y usar finalmente el métodostr.join()
, o bien utilizar una instancia de la claseio.StringIO
y recuperar el valor final completode forma similar, en vez de concatenar objetos de tipo
bytes
se puede usar el métodobytes.join()
, la claseio.BytesIO
, o se puede realizar una modificación interna usando un objeto de la clasebytearray
. Los objetos de tipobytearray
son mutables y tienen un mecanismo interno de gestión muy eficienteen vez de concatenar tuplas (Instancias de
tuple
), usar una lista (list
) y expandirlapara otros tipos, investiga la documentación relevante de la clase
Algunos tipos de secuencia (como la clase
range
) solo soportan elementos que siguen un patrón específico, y por tanto no soportan la concatenación ni la repetición.El método
index
eleva la excepciónValueError
si x no se encuentra en s. No todas las implementaciones soportan los parámetros opcionales i y j. Estos parámetros permiten una búsqueda eficiente de partes de una secuencia. Usar estos parámetros es más o menos equivalente a usars[i:j].index(x)
, pero sin copiar ningún dato y con el valor de índice retornado como valor relativo al inicio de la secuencia, en vez de al inicio de la rebanada.
Tipos de secuencia inmutables¶
La única operación que las secuencias inmutables implementan generalmente, y que no esta definida también en las secuencias mutables, es el soporte para el cálculo de la función predefinida hash()
.
Este soporte permite usar secuencias inmutables, como por ejemplo las instancias de la clase tuple
, como claves para diccionarios (dict
), así como ser almacenadas en conjuntos (set
) o conjuntos congelados (frozenset
).
Intentar calcular el hash de una secuencia inmutable que contenga objetos mutables producirá una excepción de tipo TypeError
.
Tipos de secuencia mutables¶
Las operaciones de la siguiente tabla están definidas para todas los tipos de secuencia mutables. La clase ABC collections.abc.MutableSequence
se incluye para facilitar la implementación correcta de un tipo de secuencia propio.
En la tabla, s es una instancia de una secuencia de tipo mutable, t es cualquier objeto iterable y x es un objeto arbitrario que cumple las restricciones de tipo y valor que vengan impuestas por s (Como ejemplo, la clase bytearray
solo acepta enteros que cumplan la condición 0 <= x <= 255
).
Operación |
Resultado |
Notas |
---|---|---|
|
el elemento i de s es reemplazado por x |
|
|
la rebanada de valores de s que van de i a j es reemplazada por el contenido del iterador t |
|
|
equivalente a |
|
|
los elementos de |
(1) |
|
borra los elementos de |
|
|
añade x al final de la secuencia (Equivale a |
|
|
elimina todos los elementos de s (Equivale a |
(5) |
|
crea una copia superficial de s (Equivale a |
(5) |
|
extiende s con los contenidos de t (En la mayoría de los casos equivale a |
|
|
actualiza s con su contenido repetido n veces |
(6) |
|
inserta x en s en la posición indicada por el índice i (Equivale a |
|
|
retorna el elemento en la posición indicada por i, y a la vez lo elimina de la secuencia s |
(2) |
|
elimina el primer elemento de s tal que |
(3) |
|
invierte el orden de los elementos de s, a nivel interno |
(4) |
Notas:
La secuencia t debe tener la misma longitud que la rebanada a la que reemplaza.
El parámetro opcional i tiene un valor por defecto de
-1
, así que si no se especifica se retorna el último valor y este se elimina de la secuencia.El método
remove()
eleva la excepciónValueError
cuando no se encuentra x en s.El método
reverse()
modifica la secuencia internamente, por motivos de eficiencia espacial para secuencias muy grandes. Como recordatorio al usuario de que el método produce un efecto secundario, no se retorna la secuencia invertida.Ambos métodos
clear()
ycopy()
se incluyen por consistencia con las interfaces de clases que no soportan operaciones de rebanado (Como las clasesdict
yset
). El métodocopy()
no es parte de la clase ABCcollections.abc.MutableSequence
, pero la mayoría de las clases finales de tipo secuencia mutable lo incluyen.Nuevo en la versión 3.3: Los métodos
clear()
ycopy()
.El valor de n es un entero, o un objeto que implemente el método
__index__()
. Los valores negativos, junto con el cero, producen una lista vacía. Los elementos de la secuencia no son copiados, sino que se referencian múltiples veces, tal y como se explicó paras * n
en Operaciones comunes de las secuencias.
Listas¶
Las listas son secuencia mutables, usadas normalmente para almacenar colecciones de elementos homogéneos (Donde el grado de similitud de los mismo depende de la aplicación).
-
class
list
([iterable])¶ Las listas se pueden construir de diferentes formas:
Usando un par de corchetes para definir una lista vacía:
[]
Usando corchetes, separando los elementos incluidos con comas:
[a]
,[a, b, c]
Usando una lista intensiva o por comprensión:
[x for x in iterable]
Usando el constructor de tipo:
list()
olist(iterable)
La lista se construye con los mismos elementos y en el mismo orden que iterable, donde iterable puede ser una secuencia, un contenedor que soporta iteración, o un objeto iterador. Si iterable es de por si una lista, se construye y retorna una copia, como si se hubiera llamado a
iterable[:]
. Por ejemplo,list('abc')
retorna['a', 'b', 'c']
ylist( (1, 2, 3) )
retorna[1, 2, 3]
. Si no se pasan parámetros, se construye una nueva lista vacía,[]
.Muchas otras operaciones también producen listas, incluyendo la función básica
sorted()
.Las listas implementan todas las operaciones comunes y mutables propias de las secuencias. Además, las listas incorporan los siguientes métodos:
-
sort
(*, key=None, reverse=False)¶ Este método ordena la lista in situ (se modifica internamente), usando unicamente comparaciones de tipo
<
. Las excepciones no son capturadas internamente: si alguna comparación falla, la operación entera de ordenación falla (Y la lista probablemente haya quedado modificada parcialmente).El método
sort()
acepta dos parámetros, que solo pueden pasarse por nombre (keyword-only arguments):El parámetro key especifica una función de un argumento que se usa para obtener, para cada elemento de la lista, un valor concreto o clave (key) a usar en las operaciones de comparación (Por ejemplo,
key=str.lower
). El elemento clave para cada elemento se calcula una única vez y se reutiliza para todo el proceso de ordenamiento. El valor por defecto,None
, hace que la lista se ordene comparando directamente los elementos, sin obtener valores clave.La utilidad
functools.cmp_to_key()
se puede usar para convertir una función cmp del estilo de la versión 2.x a una función key.El valor de reverse es un valor booleano. Si se define como
True
, entonces los elementos de la lista se ordenan como si las operaciones de comparación se hubiesen invertido.Este método modifica la lista in situ, para ahorrar espacio cuando se ordena una secuencia muy grande. Para recordar a los usuarios que funciona de esta manera, no se retorna la secuencia ordenada (Puedes usar
sorted()
para obtener de forma explicita una nueva secuencia ordenada).El método
sort()
es estable. Una algoritmo de ordenación es estable si garantiza que no se cambia el orden relativo que mantienen inicialmente los elementos que se consideran iguales — Esto es útil para realizar ordenaciones en múltiples fases (Por ejemplo, ordenar por departamento y después por salario).Para ver ejemplos de ordenación y un breve tutorial sobre el tema, véase HOW TO - Ordenar.
CPython implementation detail: Mientras una lista está siendo ordenada, los efectos de intentar modificarla, o incluso examinarla, no están definidos. La implementación en C de Python hace que la lista parezca vacía durante la ordenación, y eleva una excepción del tipo
ValueError
si detecta un cambio en la lista durante el proceso de ordenación.
Tuplas¶
Las tuplas son secuencias inmutables, usadas normalmente para almacenar colecciones de datos heterogéneos (Como las duplas o tuplas de dos elementos producidas por la función básica enumerate()
). También son usadas en aquellos casos donde se necesite una secuencia inmutable de datos heterogéneos (Como por ejemplo permitir el almacenamiento en un objeto de tipo set
o dict
).
-
class
tuple
([iterable])¶ Las tuplas se pueden construir de diferentes maneras:
Usando un par de símbolos de paréntesis, para indicar una tupla vacía:
()
Usando una coma al final, para crear una tupla de un único elemento:
a,
o(a,)
Separando los elementos por comas:
a, b, c
o(a, b, c)
Usando la función básica
tuple()
built-in:tuple()
otuple(iterable)
El constructor genera una tupla cuyos elementos son los mismos y están en el mismo orden que los elementos del iterable, donde iterable puede ser una secuencia, un contenedor que soporta iteración, o un objeto de tipo iterator. Si iterable es ya de por si una tupla, se retorna sin cambiar. Por ejemplo,
tuple('abc')
retorna('a', 'b', 'c')
ytuple( [1, 2, 3] )
retorna(1, 2, 3)
. Si no se indica ningún parámetro, el constructor creará una nueva tupla vacía.()
.Nótese que es la coma la que realmente construye la tupla, no los paréntesis. Los paréntesis son opcionales, excepto en el caso de la tupla vacía, o cuando se necesitan para evitar una ambigüedad sintáctica. Por ejemplo,
f(a, b, c)
es una llamada a una función con tres parámetros, perof((a, b, c))
es una llamada a una función con un único parámetro, en este caso una tupla de tres elementos.Las tuplas implementan todas las operaciones de secuencia common.
Para colecciones de datos heterogéneos donde el acceso por nombre resulta más claro que por índice, quizá crear una tupla con nombres (collections.namedtuple()
) pueden ser más apropiado.
Rangos¶
Los objetos de tipo range
representan una secuencia inmutable de números y se usan habitualmente para ejecutar un bucle for
un número determinado de veces.
-
class
range
(stop)¶ -
class
range
(start, stop[, step]) Los parámetros usados por el constructor del rango deben ser números enteros (O bien objetos de tipo
int
o instancias de una clase que implemente el método especial__index__
). Si el parámetro step se omite, se asume el valor1
. Si se omite el parámetrostart
, se toma como0
. Si se intenta usar0
como valor destep
, se eleva una excepción de tipoValueError
.Para un valor positivo de step, el contenido del rango
r
viene determinado por la fórmular[i] = start + step*i
dondei >= 0
yr[i] < stop
.Para un valor negativo de step, el contenido del rango sigue estando determinado por la fórmula
r[i] = start + step*i
, pero las restricciones ahora soni >= 0
yr[i] > stop
.Un objeto de tipo rango se considera vacío si
r[0]
no cumple con las restricciones de valor. Los rangos soportan índices negativos, pero estos son interpretados como índices considerados desde el final de la secuencia determinada por los índices positivos.Los rangos que contengan valores mayores que
sys.maxsize
se permiten, pero algunas capacidades (como la funciónlen()
) pueden elevar una excepción de tipoOverflowError
.Ejemplos de rangos:
>>> list(range(10)) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> list(range(1, 11)) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] >>> list(range(0, 30, 5)) [0, 5, 10, 15, 20, 25] >>> list(range(0, 10, 3)) [0, 3, 6, 9] >>> list(range(0, -10, -1)) [0, -1, -2, -3, -4, -5, -6, -7, -8, -9] >>> list(range(0)) [] >>> list(range(1, 0)) []
Los rangos implementan todas las operaciones comunes de las secuencias, excepto la concatenación y la repetición (Esto es porque los objetos de tipo rango solamente pueden representar secuencias que siguen un patrón estricto, y tanto la repetición como la concatenación pueden romperlo).
-
start
¶ El valor del parámetro
start
(0
si no se utiliza el parámetro)
-
stop
¶ El valor del parámetro
stop
-
step
¶ El valor del parámetro
step
(1
si no se utiliza el parámetro)
-
La ventaja de usar un objeto de tipo range
en vez de uno de tipo list
o tuple
es que con range
siempre se usa una cantidad fija (y pequeña) de memoria, independientemente del rango que represente (Ya que solamente necesita almacenar los valores para start
, stop
y step
, y calcula los valores intermedios a medida que los va necesitando).
Los objetos rango implementan la clase ABC collections.abc.Sequence
, y proporcionan capacidades como comprobación de inclusión, búsqueda de elementos por índice, operaciones de rebanadas y soporte de índices negativos (Véase Tipos secuencia — list, tuple, range):
>>> r = range(0, 20, 2)
>>> r
range(0, 20, 2)
>>> 11 in r
False
>>> 10 in r
True
>>> r.index(10)
5
>>> r[5]
10
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18
La comparación entre rangos usando los operadores ==
y !=
se realiza como con las secuencias. Esto es, dos rangos se consideran iguales si representan exactamente la misma secuencia de elementos. (Fíjate que, según esta definición, dos rangos pueden considerarse iguales aunque tengan diferentes valores para start
, stop
y step
, por ejemplo range(0) == range(2, 1, 3)
y range(0, 3, 2) == range(0, 4, 2)
).
Distinto en la versión 3.2: Implementa la clase abstracta Sequence
. Soportan operaciones de rebanado e índices negativos. Comprobar si un entero de tipo int
está incluido en un rango se realiza en un tiempo constante, no se realiza una iteración a través de todos los elementos.
Distinto en la versión 3.3: Define los operadores “==” y “!=” para comparar rangos en base a la secuencia de valores que definen (En vez de compararse en base a la identidad).
Ver también
En linspace recipe se muestra como implementar una versión lazy o perezosa de una función para
range
que funciona con valores en coma flotante.
Cadenas de caracteres — str
¶
La información textual se representa en Python con objetos de tipo str
, normalmente llamados cadenas de caracteres o simplemente cadenas. Las cadenas de caracteres son secuencias inmutables de puntos de código Unicode. Las cadenas se pueden definir de diferentes maneras:
Comillas simples:
'permite incluir comillas "dobles"'
Comillas dobles:
"permite incluir comillas 'simples'"
.Triples comillas: ya sea con comillas simples
'''Triples comillas simples'''
o dobles"""Triples comillas dobles"""
Las cadenas definidas con comillas tripes pueden incluir varias líneas. Todos los espacios en blancos incluidos se incorporan a la cadena de forma literal.
Cadenas literales que forman parte de una expresión y que solo estén separados por espacios en blanco, se convertirán implícitamente a una única cadena. Esto es, ("spam " "eggs") == "spam eggs"
.
Véase Literales de cadenas y bytes para más información acerca de las diferentes formas de expresar cadenas de forma literal, incluidos los caracteres de escape, y del prefijo r
(»raw») que deshabilita el procesamiento de la mayoría de dichas secuencias de escape.
Las cadenas de caracteres también se pueden crear usando el constructor str
.
Como no hay un tipo separado para los caracteres, indexar una cadena produce una cadena de longitud 1. Esto es, para una cadena de caracteres no vacía s, s[0] == s[0:1]
.
Tampoco hay una versión mutable de las cadenas de caracteres, pero el método str.join()
o la clase io.StringIO
pueden usarse para construir de forma eficiente una cadena de caracteres a partir de fragmentos.
Distinto en la versión 3.3: Para facilitar la compatibilidad hacia atrás con la versión 2, el prefijo u
se permite en las cadenas de caracteres. No tiene ningún efecto en la interpretación del literal y no se puede combinar con el prefijo r
.
-
class
str
(object='')¶ -
class
str
(object=b'', encoding='utf-8', errors='strict') Retorna una representación en forma de cadena de caracteres de object. Si no se proporciona ningún valor, retorna una cadena vacía. Si se proporciona, el comportamiento de
str()
depende de los valores pasados en los parámetros encoding y errors, como veremos.Si no se especifica ni encoding ni errors,
str(object)
retornaobject.__str__()
, que es la representación «informal» o mas cómoda de usar, en forma de cadena de caracteres, del valor de object. Para una cadena de caracteres, es la cadena en sí. Si object no tiene un método__str__()
, entoncesstr()
usará como reemplazo el métodorepr(object)
.Si se indica alguno de los dos parámetros encoding o errors, entonces object debe ser un objeto binario o similar (bytes-like object, es decir, una instancia de
bytes
obytearray
). En este caso, si object es de tipobytes
obytearray
, la llamada astr(bytes, encoding, errors)
es equivalente abytes.decode(encoding, errors)
. Si no, el objeto de tipo bytes que esta subyacente en el objeto buffer se obtiene mediante una llamada abytes.decode()
. Véase Tipos de secuencias binarias — bytes, bytearray y memoryview y Protocolo Búfer para más información sobre los objetos buffer.Si se pasa un objeto de tipo
bytes
a la funciónstr()
sin especificar o bien el parámetro encoding o bien el errors, se vuelve al caso normal donde se retorna la representación informal (Véase también la-b
de las opciones de línea de órdenes de Python). Por ejemplo:>>> str(b'Zoot!') "b'Zoot!'"
Para más información sobre la clase
str
y sus métodos, consulta Cadenas de caracteres — str y la sección Métodos de las cadenas de caracteres a continuación. Para las opciones de formateo de cadenas, lee las secciones Literales de cadena formateados y Sintaxis de formateo de cadena. También puedes consultar la sección Servicios de procesamiento de texto.
Métodos de las cadenas de caracteres¶
Todas las cadenas de caracteres implementan las operaciones comunes de las secuencias, junto con los métodos descritos a continuación.
Las cadenas soportan dos estilos de formateo, uno proporciona un grado muy completo de flexibilidad y personalización (Véase str.format()
, Sintaxis de formateo de cadena y Formato de cadena de caracteres personalizado) mientras que el otro se basa en la función C printf
, que soporta un menor número de tipos y es ligeramente más complicada de usar, pero es a menudo más rápida para los casos que puede manejar (Formateo de cadenas al estilo *printf*).
La sección Servicios de procesamiento de texto de la librería estándar cubre una serie de módulos que proporcionan varias utilidades para trabajar con textos (Incluyendo las expresiones regulares en el módulo re
).
-
str.
capitalize
()¶ Retorna una copia de la cadena con el primer carácter en mayúsculas y el resto en minúsculas.
Distinto en la versión 3.8: El primer carácter se pasa ahora a título, más que a mayúsculas. Esto significa que caracteres como dígrafos solo tendrán la primera letra en mayúsculas, en ves de todo el carácter.
-
str.
casefold
()¶ Retorna el texto de la cadena, normalizado a minúsculas. Los textos así normalizados pueden usarse para realizar búsquedas textuales independientes de mayúsculas y minúsculas.
El texto normalizado a minúsculas es más agresivo que el texto en minúsculas normal, porque se intenta unificar todas las grafías distintas de la letras. Por ejemplo, En Alemán la letra minúscula
'ß'
equivale a"ss"
. Como ya está en minúsculas, el métodolower()
no modifica'ß'
, pero el métodocasefold()
lo convertirá a"ss"
.El algoritmo de normalización a minúsculas se describe en la sección 3.13 del estándar Unicode.
Nuevo en la versión 3.3.
-
str.
center
(width[, fillchar])¶ Retorna el texto de la cadena, centrado en una cadena de longitud width. El relleno a izquierda y derecha se realiza usando el carácter definido por el parámetro fillchar (Por defecto se usa el carácter espacio ASCII). Si la cadena original tiene una longitud
len(s)
igual o superior a width, se retorna el texto sin modificar.
-
str.
count
(sub[, start[, end]])¶ Retorna el número de ocurrencias no solapadas de la cadena sub en el rango [start, end]. Los parámetros opcionales start y end Se interpretan como en una expresión de rebanada.
-
str.
encode
(encoding="utf-8", errors="strict")¶ Retorna una versión codificada en forma de bytes. La codificación por defecto es
'utf-8'
. El parámetro errors permite especificar diferentes esquemas de gestión de errores. El valor por defecto de errors es'strict'
, que significa que cualquier error en la codificación eleva una excepción de tipoUnicodeError
. Otros valores posibles son'ignore'
,'replace'
,'xmlcharrefreplace'
,'backslashreplace'
y cualquier otro nombre que se haya registrado mediante la funcióncodecs.register_error()
, véase la sección Manejadores de errores. Para una lista de los posibles sistemas de codificación, véase la sección Codificaciones estándar.Distinto en la versión 3.1: Añade soporte para el uso de parámetros por nombre.
-
str.
endswith
(suffix[, start[, end]])¶ Retorna
True
si la cadena termina con el sufijo especificado con el parámetro prefix, yFalse
en caso contrario. También podemos usar suffix para pasar una tupla de sufijos a buscar. Si especificamos el parámetro opcional start, la comprobación empieza en esa posición. Con el parámetro opcional stop, la comprobación termina en esa posición.
-
str.
expandtabs
(tabsize=8)¶ Retorna una copia de la cadena, con todos los caracteres de tipo tabulador reemplazados por uno o más espacios, dependiendo de la columna actual y del tamaño definido para el tabulador. Las posiciones de tabulación ocurren cada tabsize caracteres (Siendo el valor por defecto de tabsize 8, lo que produce las posiciones de tabulación 0, 8, 16,…). Para expandir la cadena, la columna actual se pone a cero y se va examinando el texto carácter a carácter. Si se encuentra un tabulador, (
\t
), se insertan uno o más espacios hasta que sea igual a la siguiente posición de tabulación (El carácter tabulador en sí es descartado). Si el carácter en un indicador de salto de línea (\n
) o de retorno (\r
), se copia y el valor de columna actual se vuelve a poner a cero. Cualquier otro carácter es copiado sin cambios y hace que el contador de columna se incremente en 1, sin tener en cuenta como se representa gráficamente el carácter.>>> '01\t012\t0123\t01234'.expandtabs() '01 012 0123 01234' >>> '01\t012\t0123\t01234'.expandtabs(4) '01 012 0123 01234'
-
str.
find
(sub[, start[, end]])¶ Retorna el menor índice de la cadena s donde se puede encontrar la cadena sub, considerando solo el intervalo
s[start:end]
. Los parámetros opcionales start y end se interpretan como si fueran “indices de una rebanada. retorna-1
si no se encuentra la cadena.
-
str.
format
(*args, **kwargs)¶ Realiza una operación de formateo. La cadena de caracteres sobre la que se está ejecutando este método puede contener texto literal y también marcas de reemplazo de texto definidas mediante llaves
{}
. Cada sección a reemplazar contiene o bien un índice numérico que hace referencia a un parámetro por posición, o el nombre de un parámetro por nombre. retorna una copia de la cadena donde se han sustituido las marcas de reemplazo por los valores correspondientes pasados como parámetros.>>> "The sum of 1 + 2 is {0}".format(1+2) 'The sum of 1 + 2 is 3'
Véase Sintaxis de formateo de cadena para una descripción de las distintas opciones de formateo que se pueden usar.
Nota
Cuando se formatea un número (
int
,float
,complex
,decimal.Decimal
y clases derivadas) usando lan
(Por ejemplo,'{:n}'.format(1234)
), las función ajusta temporalmente el valor de la variable de entorno localLC_TYPE
aLC_NUMERIC
para decodificar los campos*decimal_point*
y*thousands_sep*
de la funciónlocaleconv()
, si usan caracteres que no son ASCII o si ocupan más de un byte, y el valor definido enLC_NUMERIC
es diferente del definido enLC_CTYPE
. Estos cambios temporales pueden afectar a otros threads.Distinto en la versión 3.7: Cuando se formatea un número usando la
n
, la función puede asignar de forma temporal la variableLC_CTYPE
.
-
str.
format_map
(mapping)¶ Similar a
str.format(**mapping)`, pero se usa ``*mapping*
de forma directa y no se copia a una diccionario. Esto es útil si*mapping*
es, por ejemplo, una instancia de una subclase dedict
:>>> class Default(dict): ... def __missing__(self, key): ... return key ... >>> '{name} was born in {country}'.format_map(Default(name='Guido')) 'Guido was born in country'
Nuevo en la versión 3.2.
-
str.
index
(sub[, start[, end]])¶ Como
find()
, pero eleva una excepción de tipoValueError
si no se encuentra la cadena a buscar.
-
str.
isalnum
()¶ Retorna
True
si todos los caracteres de la cadena son alfanuméricos y hay, al menos, un carácter. En caso contrario, retornaFalse
. Un carácterc
se considera alfanumérico si alguna de las siguientes funciones retornaTrue
:c.isalpha()
,c.isdecimal()
,c.isdigit()
oc.isnumeric()
.
-
str.
isalpha
()¶ Retorna
True
si todos los caracteres de la cadena son alfabéticos y hay, al menos, un carácter. En caso contrario, retornaFalse
. Los caracteres alfabéticos son aquellos definidos en la base de datos de Unicode como «*Letter*
, es decir, aquellos cuya propiedad categoría general es «Lm», «Lt», «Lu», «Ll» o «Lo». Nótese que esta definición de «Alfabético» es diferente de la que usa el estándar Unicode.
-
str.
isascii
()¶ Retorna
True
si la cadena de caracteres está vacía, o si todos los caracteres de la cadena son ASCII. En caso contrario, retornaFalse
. Los caracteres ASCII son aquellos cuyos puntos de código Unicode están en el rango U+0000-U+007F.Nuevo en la versión 3.7.
-
str.
isdecimal
()¶ Retorna
True
si todos los caracteres de la cadena son caracteres decimales y hay, al menos, un carácter. En caso contrario, retornaFalse
. Los caracteres decimales son aquellos que se pueden usar para formar números en base 10, por ejemplo,U+0660, ARABIC-INDIC DIGIT ZERO
. Formalmente, un carácter decimal es un carácter en la categoría general «Nd» de Unicode.
-
str.
isdigit
()¶ Retorna
True
si todos los caracteres de la cadena son dígitos y hay, al menos, un carácter. En caso contrario, retornaFalse
. Los dígitos incluyen los caracteres decimales y dígitos que requieren un tratamiento especial, como por ejemplo los usados para superíndices. Esto incluye dígitos que no pueden ser usados para formar números en base 10, como los números Kharosthi. Formalmente, un dígito es un carácter que tiene la propiedad*Numeric_Type*
definida como*Digit*
o*Decimal*
.
-
str.
isidentifier
()¶ Retorna
True
si la cadena de caracteres es un identificar válido de acuerdo a la especificación del lenguaje, véase Identificadores y palabras clave.Se puede usar la función
keyword.iskeyword()
para comprobar si la cadenas
es una palabra reservada, comodef
oclass
.Ejemplo:
>>> from keyword import iskeyword >>> 'hello'.isidentifier(), iskeyword('hello') True, False >>> 'def'.isidentifier(), iskeyword('def') True, True
-
str.
islower
()¶ Retorna
True
si todos los caracteres de la cadena que tengan formas en mayúsculas y minúsculas 4 están en minúsculas y hay, al menos, un carácter de ese tipo. En caso contrario, retornaFalse
.
-
str.
isnumeric
()¶ Retorna
True
si todos los caracteres de la cadena son caracteres numéricos y hay, al menos, un carácter. En caso contrario, retornaFalse
. Los caracteres numéricos incluyen los dígitos, y todos los caracteres Unicode que tiene definida la propiedad valor numérico, por ejemplo U+2155, VULGAR FRACTION ONE FIFTH. Formalmente, los caracteres numéricos son aquellos que la propiedadNumeric_Type
definida comoDigit
,Decimal
oNumeric
.
-
str.
isprintable
()¶ Retorna
True
si todos los caracteres de la cadena son imprimibles o si la cadena está vacía. En caso contrario, retornaFalse
. Los caracteres no imprimibles son aquellos definidos en la base de datos de Unicode como «other
» o «Separator
», con la excepción del carácter ASCII «espacio» (0x20
), que se considera imprimible (Nótese que en este contexto, imprimible son aquellos caracteres que no necesitan ser escapados cuando se imprimen con la funciónrepr()
. No tiene relevancia en cadenas escritas asys.stdout
osys.stderr
).
-
str.
isspace
()¶ Retorna
True
si todos los caracteres de la cadena son espacios en blanco y hay, al menos, un carácter. En caso contrario, retornaFalse
.Un carácter se considera espacio en blanco si, en la base de datos de Unicode (Véase
unicodedata
), está clasificado en la categoría generalZs``("Espacio, separador") o la clase bidireccional es ``WS
,B
, orS
.
-
str.
istitle
()¶ Retorna
True
si las palabras en la cadena tiene forma de título y hay, al menos, un carácter, por ejemplo una mayúscula solo puede aparecer al principio o después de un carácter que no tenga formas alternativas mayúsculas-minúsculas, y las minúsculas solo después de carácter que si tiene formas alternativas mayúsculas-minúsculas. En caso contrario, retornaFalse
.
-
str.
isupper
()¶ Retorna
True
si todos los caracteres de la cadena que tengan formas en mayúsculas y minúsculas 4 están en mayúsculas y hay, al menos, un carácter de ese tipo. En caso contrario, retornaFalse
.
-
str.
join
(iterable)¶ Retorna una cadena de caracteres formada por la concatenación de las cadenas en el iterable. Se eleva una excepción de tipo
TypeError
si alguno de los elementos en el iterable no es una cadena, incluyendo objetos de tipobytes
. Se usa como separador entre los elementos la cadena de caracteres pasada como parámetro.
-
str.
ljust
(width[, fillchar])¶ Retorna el texto de la cadena, justificado a la izquierda en una cadena de longitud width. El carácter de relleno a usar viene definido por el parámetro fillchar (Por defecto se usa el carácter espacio ASCII). Si la cadena original tiene una longitud
len(s)
igual o superior a width, se Retorna el texto sin modificar.
-
str.
lower
()¶ Retorna una copia de la cadena de caracteres con todas las letras en minúsculas 4.
El algoritmo usado para la conversión a minúsculas está descrito en la sección 3..13 del estándar Unicode.
-
str.
lstrip
([chars])¶ Retorna una copia de la cadena, eliminado determinados caracteres si se encuentren al principio. El parámetro chars especifica el conjunto de caracteres a eliminar. Si se omite o si se especifica
None
, se eliminan todos los espacios en blanco. No debe entenderse el valor de chars como un prefijo, sino que se elimina cualquier combinación de sus caracteres:>>> ' spacious '.lstrip() 'spacious ' >>> 'www.example.com'.lstrip('cmowz.') 'example.com'
-
static
str.
maketrans
(x[, y[, z]])¶ Este método estático retorna una tabla de traducción apta para ser usada por el método
str.translate()
.Si solo se usa un parámetro, este debe ser un diccionario que mapea valores de punto Unicode (enteros) o caracteres (Cadenas de longitud 1) a valores Unicode, cadenas (De cualquier longitud) o
None
. Las claves se convertirán a ordinales.Si se pasan dos parámetros, deben ser cadenas de la misma longitud, y en la tabla resultante, cada carácter en x se mapea al carácter en la misma posición en y. Si se añade un tercer parámetro, debe ser una cadena de caracteres, todos los cuales se mapearán a
None
en la tabla resultante.
-
str.
partition
(sep)¶ Divide la cadena en la primera ocurrencia de sep, y retorna una tupla de tres elementos, conteniendo la parte anterior al separador, el separador en sí y la parte posterior al separador. Si no se encuentra el separador, Retorna una tupla de tres elementos, el primero la cadena original y los dos siguientes son cadenas vacías.
-
str.
replace
(old, new[, count])¶ Retorna una copia de la cadena con todas las ocurrencias de la cadena old sustituidas por new. Si se utiliza el parámetro count, solo se cambian las primeras count ocurrencias.
-
str.
rfind
(sub[, start[, end]])¶ Retorna el mayor índice dentro de la cadena s donde se puede encontrar la cadena sub, estando sub incluida en
s[start:end]
. Los parámetros opcionales start y end se interpretan igual que en las operaciones de rebanado. retorna-1
si no se encuentra sub.
-
str.
rindex
(sub[, start[, end]])¶ Como el método
rfind()
, pero eleva la excepciónValueError
si no se encuentra la cadena sub.
-
str.
rjust
(width[, fillchar])¶ Retorna el texto de la cadena, justificado a la derecha en una cadena de longitud width. El carácter de relleno a usar viene definido por el parámetro fillchar (Por defecto se usa el carácter espacio ASCII). Si width es menor o igual que
len(s)
, se retorna el texto sin modificar.
-
str.
rpartition
(sep)¶ Divide la cadena en la última ocurrencia de sep, y retorna una tupla de tres elementos, conteniendo la parte anterior al separador, el separador en sí y la parte posterior al separador. Si no se encuentra el separador, Retorna una tupla de tres elementos, los dos primeras posiciones con cadenas vacías y en la tercera la cadena original.
-
str.
rsplit
(sep=None, maxsplit=-1)¶ Retorna una lista con las palabras que componen la cadena de caracteres original, usando como separador el valor de sep. Si se utiliza el parámetro maxsplit, se realizan como máximo maxsplit divisiones, retornando los que están más a la derecha. Si no se especifica sep o se pasa con valor
None
, se usa como separador cualquier carácter de espacio en blanco. Si no contamos la diferencia de empezar las divisiones desde la derecha, el comportamiento de este métodorsplit()
es equivalente al desplit()
, que se describe con detalle más adelante.
-
str.
rstrip
([chars])¶ Retorna una copia de la cadena, eliminado determinados caracteres si se encuentren al final. El parámetro chars especifica el conjunto de caracteres a eliminar. Si se omite o si se especifica
None
, se eliminan todos los espacios en blanco. No debe entenderse el valor de chars como un prefijo, sino que se elimina cualquier combinación de sus caracteres:>>> ' spacious '.rstrip() ' spacious' >>> 'mississippi'.rstrip('ipz') 'mississ'
-
str.
split
(sep=None, maxsplit=-1)¶ Retorna una lista con las palabras que componen la cadena de caracteres original, usando como separador el valor de sep. Si se utiliza el parámetro maxsplit, se realizan como máximo maxsplit divisiones, (Por tanto, la lista resultante tendrá
maxsplit+1
elementos). Si no se especifica maxsplit o se pasa con valor-1
, entonces no hay límite al número de divisiones a realizar (Se harán todas las que se puedan).Si se especifica sep, las repeticiones de caracteres delimitadores no se agrupan juntos, sino que se considera que están delimitando cadenas vacías (Por ejemplo,
'1,,2'.split(',')
retorna['1', '', '2']
). El parámetro sep puede contener más de un carácter (Por ejemplo,'1<>2<>3'.split('<>')
retorna['1', '2', '3']
). Dividir una cadena vacía con un separador determinado retornará['']
.Por ejemplo:
>>> '1,2,3'.split(',') ['1', '2', '3'] >>> '1,2,3'.split(',', maxsplit=1) ['1', '2,3'] >>> '1,2,,3,'.split(',') ['1', '2', '', '3', '']
Si no se especifica sep o es
None
, se usa un algoritmo de división diferente: Secuencias consecutivas de caracteres de espacio en blanco se consideran como un único separador, y el resultado no contendrá cadenas vacías ni al principio ni al final de la lista, aunque la cadena original tuviera espacios en blanco al principio o al final. En consecuencia, dividir una cadena vacía o una cadena que solo contenga espacios en blanco usandoNone
como separador siempre retornará una lista vacía[]
.Por ejemplo:
>>> '1 2 3'.split() ['1', '2', '3'] >>> '1 2 3'.split(maxsplit=1) ['1', '2 3'] >>> ' 1 2 3 '.split() ['1', '2', '3']
-
str.
splitlines
([keepends])¶ Retorna una lista con las líneas en la cadena, dividiendo por los saltos de línea. Los caracteres de salto de línea en sí no se incluyen a no ser que se especifique lo contrario pasando el valor
True
en al parámetro keepends.Este método considera como saltos de línea los siguientes caracteres. En concreto, estos son un superconjunto de los saltos de líneas universales.
Representación
Descripción
\n
Salto de línea
\r
Retorno de carro
\r\n
Retorno de carro + salto de línea
\v
o\x0b
Tabulación de línea
\f
o\x0c
Avance de página
\x1c
Separador de archivo
\x1d
Separador de grupo
\x1e
Separador de registro
\x85
Siguiente línea (Código de control C1)
\u2028
Separador de línea
\u2029
Separador de párrafo
Distinto en la versión 3.2: Se añaden
\v
y\f
a la lista de separadores.Por ejemplo:
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines() ['ab c', '', 'de fg', 'kl'] >>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True) ['ab c\n', '\n', 'de fg\r', 'kl\r\n']
Al contrario que con
split()
, cuando se especifica una cadena con sep, el método retorna una lista vacía para la cadena vacía, y un salto de línea al final del texto no produce una línea extra:>>> "".splitlines() [] >>> "One line\n".splitlines() ['One line']
Por comparación,
split('\n')
entrega:>>> ''.split('\n') [''] >>> 'Two lines\n'.split('\n') ['Two lines', '']
-
str.
startswith
(prefix[, start[, end]])¶ Retorna
True
si la cadena empieza por prefix, en caso contrario RetornaFalse
. El valor de prefix puede ser también una tupla de prefijos por los que buscar. Con el parámetro opcional start, la comprobación empieza en esa posición de la cadena.
-
str.
strip
([chars])¶ Retorna una copia de la cadena con los caracteres indicados eliminados, tanto si están al principio como al final de la cadena. El parámetro opcional chars es una cadena que especifica el conjunto de caracteres a eliminar. Si se omite o se usa
None
, se eliminan los caracteres de espacio en blanco. No debe entenderse el valor de chars como un prefijo, sino que se elimina cualquier combinación de sus caracteres:>>> ' spacious '.strip() 'spacious' >>> 'www.example.com'.strip('cmowz.') 'example'
Los caracteres indicados por chars se eliminan de los extremos al principio y al final de la cadena. Se elimina los caracteres del inicio hasta que se encuentra un carácter que no esté incluido en el conjunto definido por chars. Se procede de manera similar para los caracteres al final. Por ejemplo:
>>> comment_string = '#....... Section 3.2.1 Issue #32 .......' >>> comment_string.strip('.#! ') 'Section 3.2.1 Issue #32'
-
str.
swapcase
()¶ Retorna una copia de la cadena con los caracteres en mayúsculas convertidos a minúsculas, y viceversa. Nótese que no es necesariamente cierto que
s.swapcase().swapcase() == s
.
-
str.
title
()¶ Retorna una versión en forma de título de la cadena, con la primera letra de cada palabra en mayúsculas y el resto en minúsculas.
Por ejemplo:
>>> 'Hello world'.title() 'Hello World'
El algoritmo usa una definición sencilla e independiente del lenguaje, consistente en considerar una palabra como un grupo de letras consecutivas. Esta definición funciona en varios entornos, pero implica que, por ejemplo en inglés, los apóstrofos en las contracciones y en los posesivos constituyen una separación entre palabras, que puede que no sea el efecto deseado:
>>> "they're bill's friends from the UK".title() "They'Re Bill'S Friends From The Uk"
Se puede solucionar parcialmente el problema de los apóstrofos usando expresiones regulares:
>>> import re >>> def titlecase(s): ... return re.sub(r"[A-Za-z]+('[A-Za-z]+)?", ... lambda mo: mo.group(0).capitalize(), ... s) ... >>> titlecase("they're bill's friends.") "They're Bill's Friends."
-
str.
translate
(table)¶ Retorna una copia de la cadena en la que cada carácter ha sido sustituido por su equivalente definido en la tabla de traducción dada. La tabla puede ser cualquier objeto que soporta el acceso mediante índices implementado en método
__getitem__()
, normalmente un objeto de tipo mapa o secuencia. Cuando se accede como índice con un código Unicode (Un entero), el objeto tabla puede hacer una de las siguientes cosas: retornar otro código Unicode o retornar una cadena de caracteres, de forma que se usaran uno u otro como reemplazo en la cadena de salida; retornarNone
para eliminar el carácter en la cadena de salida, o elevar una excepción de tipoLookupError
, que hará que el carácter se copie igual en la cadena de salida.Se puede usar
str.maketrans()
para crear un mapa de traducción carácter a carácter de diferentes formas.Véase también el módulo
codecs
para una aproximación más flexible al mapeo de caracteres.
-
str.
upper
()¶ Retorna una copia de la cadena, con todos los caracteres con formas mayúsculas/minúsculas 4 pasados a minúsculas. Nótese que
s.upper().isupper()
puede retornar falso sis
contiene caracteres que no tengan las dos formas, o si la categoría Unicode del carácter o caracteres resultantes no es «Lu» (Letra, mayúsculas), sino, por ejemplo, «Lt» (Letra, Título).El algoritmo de paso a mayúsculas es el descrito en la sección 3.13 del estándar Unicode.
-
str.
zfill
(width)¶ Retorna una copia de la cadena, rellena por la izquierda con los carácter ASCII
'0'
necesarios para conseguir una cadena de longitud width. El carácter prefijo de signo ('+'
/'-'
) se gestiona insertando el relleno después del carácter de signo en vez de antes. Si width es menor o igual quelen(s)
, se retorna la cadena original.Por ejemplo:
>>> "42".zfill(5) '00042' >>> "-42".zfill(5) '-0042'
Formateo de cadenas al estilo *printf*
¶
Nota
Las operaciones de formateo explicadas aquí tienen una serie de peculiaridades que conducen a ciertos errores comunes (Como fallar al representar tuplas y diccionarios correctamente). Se pueden evitar estos errores usando las nuevas cadenas de caracteres con formato, el método str.format()
, o plantillas de cadenas de caracteres. Cada una de estas alternativas proporcionan sus propios compromisos entre facilidad de uso, flexibilidad y capacidad de extensión.
Las cadenas de caracteres tienen una operación básica: El operador %
(módulo). Esta operación se conoce también como formateo de cadenas y operador de interpolación. Dada la expresión formato % valores
(Donde formato es una cadena), las especificaciones de conversión indicadas en la cadena con el símbolo %
son reemplazadas por cero o más elementos de valores. El efecto es similar a usar la función del lenguaje C sprintf()
.
Si formato tiene un único marcador, valores puede ser un objeto sencillo, no una tupla. 5 En caso contrario, valores debe ser una tupla con exactamente el mismo número de elementos que marcadores usados en la cadena de formato, o un único objeto de tipo mapa (Por ejemplo, un diccionario).
Un especificador de conversión consiste en dos o más caracteres y tiene los siguientes componentes, que deben aparecer en el siguiente orden:
El carácter
'%'
, que identifica el inicio del marcador.Una clave de mapeo (opcional), consistente en una secuencia de caracteres entre paréntesis, como por ejemplo,
(somename)
.Indicador de conversión (opcional), que afecta el resultado de ciertas conversiones de tipos.
Valor de ancho mínimo (opcional). Si se especifica un
'*'
(asterisco), el ancho real se lee del siguiente elemento de la tupla valores, y el objeto a convertir viene después del ancho mínimo, con un indicador de precisión opcional.Precisión (Opcional), en la forma
'.'
(punto) seguido de la precisión. Si se especifica un'*'
(Asterisco), el valor de precisión real se lee del siguiente elemento de la tupla valores, y el valor a convertir viene después de la precisión.Modificador de longitud (Opcional).
Tipo de conversión.
Cuando el operador derecho es un diccionario (o cualquier otro objeto de tipo mapa), los marcadores en la cadena deben incluir un valor de clave entre paréntesis, inmediatamente después del carácter '%'
. El valor de la clave se usa para seleccionar el valor a formatear desde el mapa. Por ejemplo:
>>> print('%(language)s has %(number)03d quote types.' %
... {'language': "Python", "number": 2})
Python has 002 quote types.
En este caso, no se pueden usar el especificador *
en la cadena de formato (Dado que requiere una lista secuencial de parámetros).
Los indicadores de conversión son:
Flag |
Significado |
---|---|
|
El valor a convertir usara la «forma alternativa» (Que se definirá más adelante) |
|
La conversión rellena con ceros por la izquierda para valores numéricos. |
|
El valor convertido se ajusta a la izquierda (Sobreescribe la conversión |
|
(Un espacio) Se deba añadir un espacio en blanco antes de un número positivo (O una cadena vacía) si se usa una conversión con signo. |
|
Un carácter signo ( |
Puede estar presente un modificador de longitud (h
, l
o L
), pero se ignora y no es necesario para Python – por lo que, por ejemplo, la salida de %ld
es idéntica a %d
.
Los tipos de conversión son:
Conversión |
Significado |
Notas |
---|---|---|
|
Entero decimal con signo. |
|
|
Entero decimal con signo. |
|
|
Valor octal con signo. |
(1) |
|
Obsoleto – es idéntico a |
(6) |
|
Hexadecimal con signo (En minúsculas) |
(2) |
|
Hexadecimal con signo (En mayúsculas) |
(2) |
|
Formato en coma flotante exponencial (En minúsculas). |
(3) |
|
Formato en coma flotante exponencial (En mayúsculas). |
(3) |
|
Formato en coma flotante decimal. |
(3) |
|
Formato en coma flotante decimal. |
(3) |
|
Formato en coma flotante. Usa formato exponencial con minúsculas si el exponente es menor que -4 o no es menor que la precisión, en caso contrario usa el formato decimal. |
(4) |
|
Formato en coma flotante. Usa formato exponencial con mayúsculas si el exponente es menor que -4 o no es menor que la precisión, en caso contrario usa el formato decimal. |
(4) |
|
Un único carácter (Acepta números enteros o cadenas de caracteres de longitud 1) |
|
|
Cadena de texto (Representará cualquier objeto usando la función |
(5) |
|
Cadena de texto (Representará cualquier objeto usando la función |
(5) |
|
Cadena de texto (Representará cualquier objeto usando la función |
(5) |
|
No se representa ningún argumento, obteniéndose en el resultado la cadena |
Notas:
La forma alternativa hace que se inserte antes del primer dígito un prefijo indicativo del formato octal (
'0o'
)La forma alternativa hace que se inserte antes del primer dígito uno de los dos prefijos indicativos del formato hexadecimal
'0x'
or'0X'
(Que se use uno u otro depende de que indicador de formato se haya usado,'x'
or'X'
).La forma alternativa hace que se incluya siempre el símbolo del punto o coma decimal, incluso si no hubiera dígitos después.
La precisión determina el número de dígitos que vienen después del punto decimal, y por defecto es 6.
La forma alternativa hace que se incluya siempre el símbolo del punto o coma decimal, y los ceros a su derecha no se eliminan, como seria el caso en la forma normal.
La precisión determina el número de dígitos significativos que vienen antes y después del punto decimal, y por defecto es 6.
Si la precisión es
N
, la salida se trunca aN
caracteres.Véase PEP 237.
Como en Python las cadenas de caracteres tiene una longitud explícita, la conversión de %s
no requiere que la cadena termine con '\0'
.
Distinto en la versión 3.1: Las conversiones %f
para números con valores absolutos mayores que 1e50 ya no son reemplazadas por conversiones %g
.
Tipos de secuencias binarias — bytes
, bytearray
y memoryview
¶
Los tipos básicos para trabajar con datos binarios son las clases bytes
y bytearray
. Ambas pueden ser usadas por la clase memoryview
, que usa el protocolo buffer para acceder a la memoria de otros objetos binarios sin necesidad de hacer una copia.
El módulo array
soporta un almacenamiento eficiente de tipos de datos básicos como enteros de 32 bits o números en formato de doble precisión en coma flotante IEEE754.
Objetos de tipo Bytes¶
Los objetos bytes son secuencias inmutables de bytes. Como muchos de los protocolos binarios más usados se basan en la codificación ASCII para texto, los objetos bytes ofrecen varios métodos que solo son válidos cuando se trabaja con datos compatibles ASCII y son, en varios aspectos, muy cercanos a los cadenas de texto.
-
class
bytes
([source[, encoding[, errors]]])¶ Para empezar, la sintaxis de los valores literales de bytes son prácticamente iguales que para las cadenas de texto, con la diferencia de que se añade el carácter
b
como prefijo:Comillas sencillas:
b'Se siguen aceptando comillas "dobles" embebidas'
Comillas dobles:
b'Se siguen aceptando comillas 'simples' embebidas'
.Comillas triples:
b'''3 comillas simples'''
,b"""3 comillas dobles"""
Solo se admiten caracteres ASCII en representaciones literales de bytes (Con independencia del tipo de codificación declarado). Cualquier valor por encima de 127 debe ser definido usando su secuencia de escape.
Al igual que con las cadenas, los literales de bytes pueden usar el prefijo
r
para deshabilitar el procesado de las secuencias de escape. Véase Literales de cadenas y bytes para más información acerca de los diferentes formas de expresar bytes de forma literal, incluyendo el soporte de secuencias de escape.Aunque las secuencias de bytes y sus representaciones se basen en texto ASCII, los objetos bytes se comportan más como secuencias inmutables de números enteros, donde cada elemento de la secuencia está restringido a los valores de x tal que
0 <= x < 256
(Si se intenta violar esta restricción se elevará una excepción de tipoValueError
). Esto se ha hecho de forma intencionada para enfatizar que, aunque muchos formatos binarios incluyen elementos basados en caracteres ASCII y pueden ser manipulados mediante algunas técnicas de procesado de textos, este no es el caso general para los datos binarios (Aplicar algoritmos pensados para proceso de textos a datos binarios que no se compatibles con ASCII normalmente corromperán dichos datos.Además de con literales, se pueden crear objetos de tipo byte de las siguientes maneras:
Un secuencia de una longitud especificada rellena con ceros:
bytes(10)
A partir de un iterable de números enteros:
bytes(range(20))
Copiando datos binarios ya existentes mediante el protocolo buffer:
bytes(obj)
Véase además la función básica bytes.
Como dos dígitos hexadecimales se corresponden exactamente con un byte, suelen usase números hexadecimales para describir datos binarios. Por ello, los objetos de tipo byte disponen de un método adicional para leer datos en ese formato:
-
classmethod
fromhex
(string)¶ Este método de clase de
bytes
retorna un objeto binario, decodificado a partir de la cadena suministrada como parámetro. La cadena de texto debe consistir en dos dígitos hexadecimales por cada byte, ignorándose los caracteres ASCII de espacio en blanco, si los hubiera.>>> bytes.fromhex('2Ef0 F1f2 ') b'.\xf0\xf1\xf2'
Distinto en la versión 3.7: El método
bytes.fromhex()
ignora ahora todos los caracteres ASCII de espacio en blanco, no solo el carácter espacio.
Existe una función que realiza la operación inversa, es decir, transforma un objeto binario en una representación textual usando hexadecimal.
-
hex
([sep[, bytes_per_sep]])¶ Retorna una cadena de texto que contiene dos dígitos hexadecimales por cada byte de la instancia.
>>> b'\xf0\xf1\xf2'.hex() 'f0f1f2'
Si quieres que la cadena en hexadecimal sea más fácil de leer, se puede especificar un único carácter separador con el parámetro sep para que se añada a la salida. Un segundo parámetro opcional, bytes_per_sep, controla los espacios. Valores positivos calculan la posición del separador desde la derecha, los negativos lo hacen desde la izquierda.
>>> value = b'\xf0\xf1\xf2' >>> value.hex('-') 'f0-f1-f2' >>> value.hex('_', 2) 'f0_f1f2' >>> b'UUDDLRLRAB'.hex(' ', -4) '55554444 4c524c52 4142'
Nuevo en la versión 3.5.
Distinto en la versión 3.8: El método
bytes.hex()
ahora soporta los parámetros opcionales sep y bytes_per_sep, que permiten insertar separadores entre los bytes de la cadena de salida.
Como los objetos de tipo bytes son secuencias de números enteros (Similares a tuplas), para un objeto binario b, b[0]
retorna un entero, mientras que b[0:1]
retorna un objeto de tipo bytes de longitud 1 (Mientras que las cadenas de texto siempre retornan una cadena de longitud 1, ya sea accediendo por índice o mediante una operación de rebanada).
La representación de los objetos tipo bytes usa el formato literal (b'...'
) ya que es, por lo general, más útil que, digamos, bytes([46, 46, 46])
. Siempre se puede convertir un objeto binario en una lista de enteros usando list(b)
.
Nota
Para usuarios de Python 2.x: En la serie Python 2.x, se permitía una variedad de conversiones implícitas entre cadenas de caracteres de 8 bits (El tipo de datos más cercano que se podía usar en estas versiones) y cadenas de caracteres Unicode. Esto se implemento como una forma de compatibilidad hacia atrás para reflejar el hecho de que originalmente Python solo soportaba textos de 8 bits, siendo el texto Unicode un añadido posterior. En Python 3.x, estas conversiones implícitas se han eliminado: Todas las conversiones entre datos binarios y textos Unicode deben ser explícitas, y objetos de tipo bytes y objetos de tipo cadena de caracteres siempre serán considerados diferentes.
Objetos de tipo Bytearray¶
Los objetos de tipo bytearray
son versiones mutables de los objetos de tipo bytes
.
-
class
bytearray
([source[, encoding[, errors]]])¶ No existe una sintaxis específica para crear objetos de tipo bytearray, hay que crearlos siempre llamando a su constructor:
Creando una secuencia vacía:
bytearray()
Creando una instancia de una longitud determinada, rellena con ceros:
bytearray(10)
A partir de un iterable de números enteros:
bytearray(range(20))
Copiando datos binarios ya existentes mediante el protocolo buffer:
bytearray(b'Hi!')
Como los objetos bytearray son mutables, soportan todas las operaciones aplicables a tipos mutables, además de las operaciones propias de los bytearrays descritas en Operaciones de bytes y bytearray.
Véase también la función básica bytearray.
Como dos dígitos hexadecimales se corresponden exactamente con un byte, suelen usase números hexadecimales para describir datos binarios. Por ello, los objetos de tipo bytearray disponen de un método de clase adicional para leer datos en ese formato:
-
classmethod
fromhex
(string)¶ Este método de clase de
bytes
retorna un objeto bytearray, decodificado a partir de la cadena suministrada como parámetro. La cadena de texto debe consistir en dos dígitos hexadecimales por cada byte, ignorándose los caracteres ASCII de espacio en blanco, si los hubiera.>>> bytearray.fromhex('2Ef0 F1f2 ') bytearray(b'.\xf0\xf1\xf2')
Distinto en la versión 3.7: El método
bytearray.fromhex()
ignora ahora todos los caracteres ASCII de espacio en blanco, no solo el carácter espacio.
Existe una función que realiza la operación inversa, es decir, transforma un objeto bytearray en una representación textual usando hexadecimal.
-
hex
([sep[, bytes_per_sep]])¶ Retorna una cadena de texto que contiene dos dígitos hexadecimales por cada byte de la instancia.
>>> bytearray(b'\xf0\xf1\xf2').hex() 'f0f1f2'
Nuevo en la versión 3.5.
Distinto en la versión 3.8: De forma similar a
bytes.hex()
,bytearray.hex()
soporta ahora los parámetros opcionales sep y bytes_per_sep para insertar separadores entre los bytes en la cadena hexadecimal de salida.
Como los objetos de tipo bytearray son secuencias de números enteros (Similares a listas), para un objeto bytearray b, b[0]
retorna un entero, mientras que b[0:1]
retorna un objeto de tipo bytearray de longitud 1 (Mientras que las cadenas de texto siempre retornan una cadena de longitud 1, ya sea accediendo por índice o mediante una operación de rebanada).
La representación de los objetos tipo bytearray usa el formato literal (bytearray(b'...')
) ya que es, por lo general, más útil que, digamos, bytearray([46, 46, 46])
. Siempre se puede convertir un objeto bytearray en una lista de enteros usando list(b)
.
Operaciones de bytes y bytearray¶
Ambos tipos, bytes y bytearray soportan las operaciones comunes de las secuencias. Los operadores no funcionan solo con operandos del mismo tipo, sino con cualquier objeto tipo binario. Gracias a esta flexibilidad, estos tipos pueden combinarse libremente en expresiones sin que se produzcan errores. Sin embargo, el tipo del valor resultante puede depender del orden de los operandos.
Nota
Los métodos de objetos de tipo bytes y bytesarray no aceptan cadenas de caracteres como parámetros, de la misma manera que los métodos de las cadenas tampoco aceptan bytes como parámetros. Por ejemplo, debes escribir:
a = "abc"
b = a.replace("a", "f")
y:
a = b"abc"
b = a.replace(b"a", b"f")
Algunas operaciones de bytes y bytearrays asumen el uso de formatos binarios compatibles ASCII, y por tanto deben ser evitadas cuando trabajamos con datos binarios arbitrarios. Estas restricciones se explican a continuación.
Nota
Usar estas operaciones basadas en ASCII para manipular datos binarios que no se almacenan en un formato basado en ASCII pueden producir corrupción de datos.
Los siguientes métodos de bytes y bytearrays pueden ser usados con datos en formatos binarios arbitrarios.
-
bytes.
count
(sub[, start[, end]])¶ -
bytearray.
count
(sub[, start[, end]])¶ Retorna el número de secuencias no solapadas de la subsecuencia sub en el rango [start, end]. Los parámetros opcionales start y end se interpretan como en las operaciones de rebanado.
La subsecuencia a buscar puede ser cualquier objeto tipo binario o un número entero entre 0 y 255.
Distinto en la versión 3.3: También acepta como subsecuencia un número entero entre 0 y 255.
-
bytes.
decode
(encoding="utf-8", errors="strict")¶ -
bytearray.
decode
(encoding="utf-8", errors="strict")¶ Retorna una cadena de caracteres decodificada a partir de la secuencia de bytes. La codificación por defecto es
'utf-8'
. El parámetro errors puede definir diferentes estrategias de gestión de errores. El valor por defecto de errors es'strict'
, que hace que cualquier error de la decodificación eleva una excepción de tipoUnicodeError
. Otros valores posibles son``”ignore”, ``'replace'
y cualquier otro nombre definido mediante la funcióncodecs.register_error()
, véase la sección Manejadores de errores. Para un listado de todos los valores de codificación posibles, véase Codificaciones estándar.Nota
Pasando el parámetro encoding a la clase
str
permite decodificar cualquier objeto tipo binario directamente, sin necesidad de crear una objeto temporal de tipo bytes o bytearray.Distinto en la versión 3.1: Añadido soporte para poder usar parámetros por nombre.
-
bytes.
endswith
(suffix[, start[, end]])¶ -
bytearray.
endswith
(suffix[, start[, end]])¶ Retorna
True
si los datos binarios acaban con el valor indicado por suffix, en caso contrario retornaFalse
. El valor de suffix puede ser también una tupla de sufijos para buscar. Con el parámetro opcional start, la comparación empieza a partir de esa posición. Si se especifica el parámetro opcional end, la comparación termina en esa posición.El sufijo (o sufijos) a buscar puede ser cualquier objeto tipo binario.
-
bytes.
find
(sub[, start[, end]])¶ -
bytearray.
find
(sub[, start[, end]])¶ Retorna el mínimo índice dentro de los datos donde se ha encontrado la subsecuencia sub, de forma que sub está contenida en la rebanada
s[start:end]
. Los parámetros opcionales start y end se interpretan como en las operaciones de rebanadas. retorna-1
si no se puede encontrar sub.La subsecuencia a buscar puede ser cualquier objeto tipo binario o un número entero entre 0 y 255.
Nota
El método
find()
se debe usar solo si se necesita saber la posición de sub. Si solo se necesita comprobar si sub es una parte de s, es mejor usar el operadorin
:>>> b'Py' in b'Python' True
Distinto en la versión 3.3: También acepta como subsecuencia un número entero entre 0 y 255.
-
bytes.
index
(sub[, start[, end]])¶ -
bytearray.
index
(sub[, start[, end]])¶ Como
find()
, pero eleva una excepción de tipoValueError
si no se encuentra la subsecuencia a buscar.La subsecuencia a buscar puede ser cualquier objeto tipo binario o un número entero entre 0 y 255.
Distinto en la versión 3.3: También acepta como subsecuencia un número entero entre 0 y 255.
-
bytes.
join
(iterable)¶ -
bytearray.
join
(iterable)¶ Retorna un objeto de tipo bytes o bytearray que es la concatenación de las secuencias binarias en iterable. Si alguno de los objetos de la secuencia no es un objeto tipo binario se eleva la excepción
TypeError
, incluso si son cadenas de caracteres (objetosstr
). El separador entre los distintos elementos es el contenido del objeto bytes o bytearray usando para invocar el método.
-
static
bytes.
maketrans
(from, to)¶ -
static
bytearray.
maketrans
(from, to)¶ Este método estático retorna una tabla de traducción apta para ser usada por el método
bytes.translate()
, que mapea cada carácter en from en la misma posición en to; tanto from como to debe ser objetos tipo binario y deben tener la misma longitud.Nuevo en la versión 3.1.
-
bytes.
partition
(sep)¶ -
bytearray.
partition
(sep)¶ Retorna la secuencia en la primera ocurrencia de sep, y retorna una tupla de tres elementos que contiene la parte antes del separador, el separador en sí o una copia de tipo bytearray y la parte después del separador. Si no se encuentra el separador, retorna una tupla de tres elementos, con la primera posición ocupada por la secuencia original, y las dos posiciones siguientes rellenas con objetos bytes o bytearray vacíos.
El separador a buscar puede ser cualquier objeto tipo binario.
-
bytes.
replace
(old, new[, count])¶ -
bytearray.
replace
(old, new[, count])¶ Retorna una copia de la secuencia con todas las ocurrencias de old sustituidas por new. Si se utiliza el parámetro count, solo se cambian las primeras count ocurrencias.
La subsecuencia a buscar y su reemplazo puede ser cualquier objeto tipo binario.
Nota
La versión bytearray de este método no modifica los valores internamente (no opera in place): siempre produce un nuevo objeto, aun si no se hubiera realizado ningún cambio.
-
bytes.
rfind
(sub[, start[, end]])¶ -
bytearray.
rfind
(sub[, start[, end]])¶ Retorna el mayor índice dentro de la secuencia s donde se puede encontrar sub, estando sub incluida en
s[start:end]
. Los parámetros opcionales start y end se interpretan igual que en las operaciones de rebanado. Retorna-1
si no se encuentra sub.La subsecuencia a buscar puede ser cualquier objeto tipo binario o un número entero entre 0 y 255.
Distinto en la versión 3.3: También acepta como subsecuencia un número entero entre 0 y 255.
-
bytes.
rindex
(sub[, start[, end]])¶ -
bytearray.
rindex
(sub[, start[, end]])¶ Como el método
rfind()
, pero eleva la excepciónValueError
si no se encuentra sub.La subsecuencia a buscar puede ser cualquier objeto tipo binario o un número entero entre 0 y 255.
Distinto en la versión 3.3: También acepta como subsecuencia un número entero entre 0 y 255.
-
bytes.
rpartition
(sep)¶ -
bytearray.
rpartition
(sep)¶ Divide la secuencia en la primera ocurrencia de sep, y retorna una tupla de tres elementos que contiene la parte antes del separador, el separador en sí o una copia de tipo bytearray y la parte después del separador. Si no se encuentra el separador, retorna una tupla de tres elementos, con las dos primeras posiciones rellenas con objetos bytes o bytearray vacíos, y la tercera posición ocupada por la secuencia original.
El separador a buscar puede ser cualquier objeto tipo binario.
-
bytes.
startswith
(prefix[, start[, end]])¶ -
bytearray.
startswith
(prefix[, start[, end]])¶ Retorna
True
si los datos binarios empiezan con el valor indicado por prefix, en caso contrario retornaFalse
. El valor de prefix puede ser también una tupla de prefijos para buscar. Con el parámetro opcional start, la comparación empieza a partir de esa posición. Si se especifica el parámetro opcional end, la comparación termina en esa posición.El prefijo (o prefijos) a buscar puede ser cualquier objeto tipo binario.
-
bytes.
translate
(table, /, delete=b'')¶ -
bytearray.
translate
(table, /, delete=b'')¶ Retorna una copia del objeto bytes o bytearray donde todas las ocurrencias de bytes especificados en el parámetro delete han sido borrados, y el resto han sido mapeados a través de la tabla de traducción indicada, que debe ser un objeto de tipo bytes con una longitud de 256 elementos.
Puedes usar el método
bytes.maketrans()
para crear la tabla de traducción.Se puede ajustar el parámetro table a
None
para conseguir una traducción que solo borra caracteres:>>> b'read this short text'.translate(None, b'aeiou') b'rd ths shrt txt'
Distinto en la versión 3.6: El parámetro delete se puede ahora especificar por nombre.
Los siguientes métodos de los objetos bytes y bytearray presentan un comportamiento por defecto que asume el uso de formatos binarios compatibles con ASCII, pero aun así pueden ser usados con datos binarios arbitrarios usando los parámetros apropiados. Nótese que todos los métodos de bytearray en esta sección nunca modifican los datos internamente, sino que siempre retornan objetos nuevos.
-
bytes.
center
(width[, fillbyte])¶ -
bytearray.
center
(width[, fillbyte])¶ Retorna una copia del objeto centrado en una secuencia de longitud width. El relleno se realiza usando el valor definido en el parámetro fillbyte (Por defecto, el carácter espacio en ASCII). Para los objetos de tipo
bytes
, se retorna la secuencia original intacta si width es menor o igual quelen(s)
.Nota
La versión bytearray de este método no modifica los valores internamente (no opera in place): siempre produce un nuevo objeto, aun si no se hubiera realizado ningún cambio.
-
bytes.
ljust
(width[, fillbyte])¶ -
bytearray.
ljust
(width[, fillbyte])¶ Retorna una copia del objeto justificado por la izquierda en una secuencia de longitud width. El relleno se realiza usando el valor definido en el parámetro fillbyte (Por defecto, el carácter espacio en ASCII). Para los objetos de tipo
bytes
, se retorna la secuencia original intacta si width es menor o igual quelen(s)
.Nota
La versión bytearray de este método no modifica los valores internamente (no opera in place): siempre produce un nuevo objeto, aun si no se hubiera realizado ningún cambio.
-
bytes.
lstrip
([chars])¶ -
bytearray.
lstrip
([chars])¶ Retorna una copia de la secuencia con los caracteres iniciales especificados eliminados. El parámetro chars es una secuencia binaria que especifica el conjunto bytes a ser eliminados; el nombre hace referencia a que este método se usa normalmente con secuencias de caracteres ASCII. Si no se indica o si se especifica
None
, el comportamiento por defecto será eliminar los caracteres de espacio ASCII. No debe entenderse el valor de chars como un prefijo, sino que se elimina cualquier combinación de sus caracteres:>>> b' spacious '.lstrip() b'spacious ' >>> b'www.example.com'.lstrip(b'cmowz.') b'example.com'
La secuencia binaria de bytes a eliminar deber ser un objeto tipo binario.
Nota
La versión bytearray de este método no modifica los valores internamente (no opera in place): siempre produce un nuevo objeto, aun si no se hubiera realizado ningún cambio.
-
bytes.
rjust
(width[, fillbyte])¶ -
bytearray.
rjust
(width[, fillbyte])¶ Retorna una copia del objeto justificado por la derecha en una secuencia de longitud width. El relleno se realiza usando el valor definido en el parámetro fillbyte (Por defecto, el carácter espacio en ASCII). Para los objetos de tipo
bytes
, se retorna la secuencia original intacta si width es menor o igual quelen(s)
.Nota
La versión bytearray de este método no modifica los valores internamente (no opera in place): siempre produce un nuevo objeto, aun si no se hubiera realizado ningún cambio.
-
bytes.
rsplit
(sep=None, maxsplit=-1)¶ -
bytearray.
rsplit
(sep=None, maxsplit=-1)¶ Divide una secuencia binaria en subsecuencias del mismo tipo, usando como separador el valor de sep. Si se utiliza el parámetro maxsplit, se realizan como máximo maxsplit divisiones, retornando los que están más a la derecha. Si no se especifica sep o se pasa con valor
None
, se usa como separador el carácter espacio en ASCII. Si no contamos la diferencia de empezar las divisiones desde la derecha, el comportamiento de este métodorsplit()
es equivalente al desplit()
, que se describe con detalle más adelante.
-
bytes.
rstrip
([chars])¶ -
bytearray.
rstrip
([chars])¶ Retorna una copia de la cadena, eliminado determinados bytes si se encuentren al final. El parámetro chars es una secuencia binaria que especifica el conjunto de bytes a eliminar; el nombre hace referencia a que este método se usa normalmente con secuencias de caracteres ASCII. Si se omite o si se especifica
None
, se eliminan los caracteres espacio en ASCII. No debe entenderse el valor de chars como un prefijo, sino que se elimina cualquier combinación de sus caracteres:>>> b' spacious '.rstrip() b' spacious' >>> b'mississippi'.rstrip(b'ipz') b'mississ'
La secuencia binaria de bytes a eliminar deber ser un objeto tipo binario.
Nota
La versión bytearray de este método no modifica los valores internamente (no opera in place): siempre produce un nuevo objeto, aun si no se hubiera realizado ningún cambio.
-
bytes.
split
(sep=None, maxsplit=-1)¶ -
bytearray.
split
(sep=None, maxsplit=-1)¶ Divide una secuencia binaria en subsecuencias del mismo tipo, usando como separador el valor de sep. Si se utiliza el parámetro maxsplit y es un número positivo, se realizan como máximo maxsplit divisiones (Resultando en una secuencia de como mucho
maxsplit+1
elementos). Si no se especifica sep o se pasa'1
, no hay límite al número de divisiones.Si se especifica sep, las repeticiones de caracteres delimitadores no se agrupan juntos, sino que se considera que están delimitando cadenas vacías (Por ejemplo,
b'1,,2'.split(b',')
retorna[b'1', b'', b'2']
). El parámetro sep puede contener más de un carácter (Por ejemplo,b'1<>2<>3'.split(b'<>')
retorna[b'1', b'2', b'3']
). Dividir una cadena vacía con un separador determinado retornará[b'']
o[bytearray(b'')]
dependiendo del tipo de objeto dividido. El parámetro sep puede ser cualquier objeto tipo binario.Por ejemplo:
>>> b'1,2,3'.split(b',') [b'1', b'2', b'3'] >>> b'1,2,3'.split(b',', maxsplit=1) [b'1', b'2,3'] >>> b'1,2,,3,'.split(b',') [b'1', b'2', b'', b'3', b'']
Si no se especifica sep o es
None
, se usa un algoritmo de división diferente: Secuencias consecutivas de caracteres de espacio en ASCII se consideran como un único separador, y el resultado no contendrá cadenas vacías ni al principio ni al final de la lista, aunque la cadena original tuviera espacios en blanco al principio o al final. En consecuencia, dividir una secuencia vacía o que solo contenga espacios en blanco usandoNone
como separador siempre retornará una lista vacía[]
.Por ejemplo:
>>> b'1 2 3'.split() [b'1', b'2', b'3'] >>> b'1 2 3'.split(maxsplit=1) [b'1', b'2 3'] >>> b' 1 2 3 '.split() [b'1', b'2', b'3']
-
bytes.
strip
([chars])¶ -
bytearray.
strip
([chars])¶ Retorna una copia de la secuencia con los bytes indicados eliminados, tanto si están al principio como al final de la cadena. El parámetro opcional chars es una secuencia de bytes que especifica el conjunto de caracteres a eliminar; el nombre hace referencia a que este método se usa normalmente con secuencias de caracteres ASCII. Si se omite o se usa
None
, se eliminan los caracteres de espacio ASCII. No debe entenderse el valor de chars como un prefijo o sufijo, sino que se elimina cualquier combinación de sus valores:>>> b' spacious '.strip() b'spacious' >>> b'www.example.com'.strip(b'cmowz.') b'example'
La secuencia binaria de bytes a eliminar deber ser un objeto tipo binario.
Nota
La versión bytearray de este método no modifica los valores internamente (no opera in place): siempre produce un nuevo objeto, aun si no se hubiera realizado ningún cambio.
Los siguientes métodos de los objetos bytes y bytearray asumen el uso de formatos binarios compatibles con ASCII, y no deben ser usados con datos binarios arbitrarios. Nótese que todos los métodos de bytearray en esta sección nunca modifican los datos internamente, sino que siempre retornan objetos nuevos.
-
bytes.
capitalize
()¶ -
bytearray.
capitalize
()¶ Retorna una copia de la secuencia con cada byte interpretado como un carácter ASCII, y el primer byte en mayúsculas y el resto en minúsculas. Los valores que no sean ASCII no se ven modificados.
Nota
La versión bytearray de este método no modifica los valores internamente (no opera in place): siempre produce un nuevo objeto, aun si no se hubiera realizado ningún cambio.
-
bytes.
expandtabs
(tabsize=8)¶ -
bytearray.
expandtabs
(tabsize=8)¶ Retorna una copia de la secuencia, con todos los caracteres ASCII tab/ reemplazados por uno o más espacios ASCII, dependiendo de la columna actual y del tamaño definido para el tabulador. Las posiciones de tabulación ocurren cada tabsize caracteres (Siendo el valor por defecto de tabsize 8, lo que produce las posiciones de tabulación 0, 8, 16,…). Para expandir la secuencia, la columna actual se pone a cero y se va examinando byte a byte. Si se encuentra un tabulador, (
b'\t'
), se insertan uno o más espacios hasta que sea igual a la siguiente posición de tabulación (El carácter tabulador en sí es descartado). Si el byte en un indicador de salto de línea (b'\n'
) o de retorno (b'\r'
), se copia y el valor de columna actual se vuelve a poner a cero. Cualquier otro carácter es copiado sin cambios y hace que el contador de columna se incremente en 1, sin tener en cuenta como se representa impreso el byte:>>> b'01\t012\t0123\t01234'.expandtabs() b'01 012 0123 01234' >>> b'01\t012\t0123\t01234'.expandtabs(4) b'01 012 0123 01234'
Nota
La versión bytearray de este método no modifica los valores internamente (no opera in place): siempre produce un nuevo objeto, aun si no se hubiera realizado ningún cambio.
-
bytes.
isalnum
()¶ -
bytearray.
isalnum
()¶ Retorna
True
si todos los bytes de la secuencia son caracteres alfabéticos ASCII o caracteres decimales ASCII y la secuencia no está vacía. En cualquier otro caso retornaFalse
. Los caracteres alfabéticos ASCII son los bytes incluidos en la secuenciab'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
. Los caracteres decimales ASCII son los bytes incluidos en la secuenciab'0123456789'
.Por ejemplo:
>>> b'ABCabc1'.isalnum() True >>> b'ABC abc1'.isalnum() False
-
bytes.
isalpha
()¶ -
bytearray.
isalpha
()¶ Retorna
True
si todos los bytes de la secuencia son caracteres alfabéticos ASCII y la secuencia no está vacía. En cualquier otro caso RetornaFalse
. Los caracteres alfabéticos ASCII son los bytes incluidos en la secuenciab'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
.Por ejemplo:
>>> b'ABCabc'.isalpha() True >>> b'ABCabc1'.isalpha() False
-
bytes.
isascii
()¶ -
bytearray.
isascii
()¶ Retorna
True
si la secuencia está vacía o si todos los bytes de la secuencia son caracteres ASCII. En cualquier otro caso retornaFalse
. Los caracteres ASCII son los bytes incluidos en el rango 0-0x7F.Nuevo en la versión 3.7.
-
bytes.
isdigit
()¶ -
bytearray.
isdigit
()¶ Retorna
True
si todos los bytes de la secuencia son caracteres decimales ASCII y la secuencia no está vacía. En cualquier otro caso retornaFalse
. Los caracteres decimales ASCII son los bytes incluidos en la secuenciab'0123456789'
.Por ejemplo:
>>> b'1234'.isdigit() True >>> b'1.23'.isdigit() False
-
bytes.
islower
()¶ -
bytearray.
islower
()¶ Retorna
True
si hay al menos un carácter ASCII en minúsculas, y no hay ningún carácter ASCII en mayúsculas. En cualquier otro caso retornaFalse
.Por ejemplo:
>>> b'hello world'.islower() True >>> b'Hello world'.islower() False
Los caracteres ASCII en minúsculas son los bytes incluidos en la secuencia
b'abcdefghijklmnopqrstuvwxyz'
. los caracteres ASCII en mayúsculas son los bytes en la secuenciab'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
.
-
bytes.
isspace
()¶ -
bytearray.
isspace
()¶ Retorna
True
si todos los bytes de la secuencia son caracteres ASCII de espacio en blanco y la secuencia no está vacía. En cualquier otro caso RetornaFalse
. Los caracteres de espacio en blanco ASCII son los bytes incluidos en la secuenciab' \t\n\r\x0b\f'
(Espacio, tabulador, nueva línea, retorno de carro, tabulador vertical y avance de página).
-
bytes.
istitle
()¶ -
bytearray.
istitle
()¶ Retorna
True
si la secuencia ASCII está en forma de título, y la secuencio no está vacía. En cualquier otro caso retornaFalse
. Véase el métodobytes.title()
para más detalles en la definición de «En forma de título».Por ejemplo:
>>> b'Hello World'.istitle() True >>> b'Hello world'.istitle() False
-
bytes.
isupper
()¶ -
bytearray.
isupper
()¶ Retorna
True
si hay al menos un carácter ASCII en mayúsculas, y no hay ningún carácter ASCII en minúsculas. En cualquier otro caso retornaFalse
.Por ejemplo:
>>> b'HELLO WORLD'.isupper() True >>> b'Hello world'.isupper() False
Los caracteres ASCII en minúsculas son los bytes incluidos en la secuencia
b'abcdefghijklmnopqrstuvwxyz'
. los caracteres ASCII en mayúsculas son los bytes en la secuenciab'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
.
-
bytes.
lower
()¶ -
bytearray.
lower
()¶ Retorna una copia de la secuencia con todos los caracteres ASCII en mayúsculas sustituidos por su versión correspondiente en minúsculas.
Por ejemplo:
>>> b'Hello World'.lower() b'hello world'
Los caracteres ASCII en minúsculas son los bytes incluidos en la secuencia
b'abcdefghijklmnopqrstuvwxyz'
. los caracteres ASCII en mayúsculas son los bytes en la secuenciab'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
.Nota
La versión bytearray de este método no modifica los valores internamente (no opera in place): siempre produce un nuevo objeto, aun si no se hubiera realizado ningún cambio.
-
bytes.
splitlines
(keepends=False)¶ -
bytearray.
splitlines
(keepends=False)¶ Retorna una lista de las líneas en la secuencia binaría, usando como separadores los saltos de líneas universales. Los caracteres usados como separadores no se incluyen en la lista de resultados a no ser que se pase el parámetro keepends a
True
.Por ejemplo:
>>> b'ab c\n\nde fg\rkl\r\n'.splitlines() [b'ab c', b'', b'de fg', b'kl'] >>> b'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True) [b'ab c\n', b'\n', b'de fg\r', b'kl\r\n']
Al contrario que el método
split()
, cuando se especifica una cadena delimitadora con el parámetro sep, este método retorna una lista vacía para la cadena vacía, y un carácter de salto de línea al final de la secuencia no resulta en una línea extra:>>> b"".split(b'\n'), b"Two lines\n".split(b'\n') ([b''], [b'Two lines', b'']) >>> b"".splitlines(), b"One line\n".splitlines() ([], [b'One line'])
-
bytes.
swapcase
()¶ -
bytearray.
swapcase
()¶ Retorna una copia de la secuencia con todos los caracteres ASCII en minúsculas sustituidos por su versión correspondiente en mayúsculas, y viceversa.
Por ejemplo:
>>> b'Hello World'.swapcase() b'hELLO wORLD'
Los caracteres ASCII en minúsculas son los bytes incluidos en la secuencia
b'abcdefghijklmnopqrstuvwxyz'
. los caracteres ASCII en mayúsculas son los bytes en la secuenciab'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
.Al contrario que la función
str.swapcase()
, en este caso siempre se cumple quebin.swapcase().swapcase() == bin
para las versiones binarias. La conversión de mayúsculas a minúsculas son simétricas en ASCII, aunque esto no es el caso general para códigos de punto Unicode.Nota
La versión bytearray de este método no modifica los valores internamente (no opera in place): siempre produce un nuevo objeto, aun si no se hubiera realizado ningún cambio.
-
bytes.
title
()¶ -
bytearray.
title
()¶ Retorna una versión en forma de título de la secuencia binaria, con la primera letra de cada palabra en mayúsculas y el resto en minúsculas.
Por ejemplo:
>>> b'Hello world'.title() b'Hello World'
Los caracteres ASCII en minúsculas son los bytes incluidos en la secuencia
b'abcdefghijklmnopqrstuvwxyz'
. los caracteres ASCII en mayúsculas son los bytes en la secuenciab'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
. El resto de los caracteres no presentan diferencias entre mayúsculas y minúsculas.El algoritmo usa una definición sencilla e independiente del lenguaje, consistente en considerar una palabra como un grupo de letras consecutivas. Esta definición funciona en varios entornos, pero implica que, por ejemplo en inglés, los apóstrofos en las contracciones y en los posesivos constituyen una separación entre palabras, que puede que no sea el efecto deseado:
>>> b"they're bill's friends from the UK".title() b"They'Re Bill'S Friends From The Uk"
Se puede solucionar parcialmente el problema de los apóstrofos usando expresiones regulares:
>>> import re >>> def titlecase(s): ... return re.sub(rb"[A-Za-z]+('[A-Za-z]+)?", ... lambda mo: mo.group(0)[0:1].upper() + ... mo.group(0)[1:].lower(), ... s) ... >>> titlecase(b"they're bill's friends.") b"They're Bill's Friends."
Nota
La versión bytearray de este método no modifica los valores internamente (no opera in place): siempre produce un nuevo objeto, aun si no se hubiera realizado ningún cambio.
-
bytes.
upper
()¶ -
bytearray.
upper
()¶ Retorna una copia de la secuencia con todos los caracteres ASCII en minúsculas sustituidos por su versión correspondiente en mayúsculas.
Por ejemplo:
>>> b'Hello World'.upper() b'HELLO WORLD'
Los caracteres ASCII en minúsculas son los bytes incluidos en la secuencia
b'abcdefghijklmnopqrstuvwxyz'
. los caracteres ASCII en mayúsculas son los bytes en la secuenciab'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
.Nota
La versión bytearray de este método no modifica los valores internamente (no opera in place): siempre produce un nuevo objeto, aun si no se hubiera realizado ningún cambio.
-
bytes.
zfill
(width)¶ -
bytearray.
zfill
(width)¶ Retorna una copia de la secuencia rellenada por la izquierda con los caracteres ASCII
b'0'
necesarios para conseguir una cadena de longitud width. El carácter prefijo de signo (b'+'
/b'-'
) se gestiona insertando el relleno después del carácter de signo en vez de antes.Para objetosbytes
, se retorna la secuencia original si width es menor o igual quelen(s)
.Por ejemplo:
>>> b"42".zfill(5) b'00042' >>> b"-42".zfill(5) b'-0042'
Nota
La versión bytearray de este método no modifica los valores internamente (no opera in place): siempre produce un nuevo objeto, aun si no se hubiera realizado ningún cambio.
Usando el formateo tipo printf
con bytes¶
Nota
Las operaciones de formateo explicadas aquí tienen una serie de peculiaridades que conducen a ciertos errores comunes (Como fallar al representar tuplas y diccionarios correctamente). Si el valor a representar es una tupla o un diccionario, hay que envolverlos en una tupla.
Los objetos binarios (bytes
/bytearray
) tienen una operación básica: El operador %
(módulo). Esta operación se conoce también como operador de formateo o de interpolación. Dada la expresión formato % valores
(Donde formato es un objeto binario), las especificaciones de conversión indicadas en la cadena con el símbolo %
son reemplazadas por cero o más elementos de valores. El efecto es similar a usar la función del lenguaje C sprintf()
.
Si formato tiene un único marcador, valores puede ser un objeto sencillo, no una tupla. 5 En caso contrario, valores debe ser una tupla con exactamente el mismo número de elementos que marcadores usados en el objeto binario, o un único objeto de tipo mapa (Por ejemplo, un diccionario).
Un especificador de conversión consiste en dos o más caracteres y tiene los siguientes componentes, que deben aparecer en el siguiente orden:
El carácter
'%'
, que identifica el inicio del marcador.Una clave de mapeo (opcional), consistente en una secuencia de caracteres entre paréntesis, como por ejemplo,
(somename)
.Indicador de conversión (opcional), que afecta el resultado de ciertas conversiones de tipos.
Valor de ancho mínimo (opcional). Si se especifica un
'*'
(asterisco), el ancho real se lee del siguiente elemento de la tupla valores, y el objeto a convertir viene después del ancho mínimo, con un indicador de precisión opcional.Precisión (Opcional), en la forma
'.'
(punto) seguido de la precisión. Si se especifica un'*'
(Asterisco), el valor de precisión real se lee del siguiente elemento de la tupla valores, y el valor a convertir viene después de la precisión.Modificador de longitud (Opcional).
Tipo de conversión.
Cuando el operador derecho es un diccionario (o cualquier otro objeto de tipo mapa), los marcadores en el objeto binario deben incluir un valor de clave entre paréntesis, inmediatamente después del carácter '%'
. El valor de la clave se usa para seleccionar el valor a formatear desde el mapa. Por ejemplo:
>>> print(b'%(language)s has %(number)03d quote types.' %
... {b'language': b"Python", b"number": 2})
b'Python has 002 quote types.'
En este caso, no se pueden usar el especificador *
en la cadena de formato (Dado que requiere una lista secuencial de parámetros).
Los indicadores de conversión son:
Flag |
Significado |
---|---|
|
El valor a convertir usara la «forma alternativa» (Que se definirá más adelante) |
|
La conversión rellena con ceros por la izquierda para valores numéricos. |
|
El valor convertido se ajusta a la izquierda (Sobreescribe la conversión |
|
(Un espacio) Se deba añadir un espacio en blanco antes de un número positivo (O una cadena vacía) si se usa una conversión con signo. |
|
Un carácter signo ( |
Puede estar presente un modificador de longitud (h
, l
o L
), pero se ignora y no es necesario para Python – por lo que, por ejemplo, la salida de %ld
es idéntica a %d
.
Los tipos de conversión son:
Conversión |
Significado |
Notas |
---|---|---|
|
Entero decimal con signo. |
|
|
Entero decimal con signo. |
|
|
Valor octal con signo. |
(1) |
|
Obsoleto – es idéntico a |
(8) |
|
Hexadecimal con signo (En minúsculas) |
(2) |
|
Hexadecimal con signo (En mayúsculas) |
(2) |
|
Formato en coma flotante exponencial (En minúsculas). |
(3) |
|
Formato en coma flotante exponencial (En mayúsculas). |
(3) |
|
Formato en coma flotante decimal. |
(3) |
|
Formato en coma flotante decimal. |
(3) |
|
Formato en coma flotante. Usa formato exponencial con minúsculas si el exponente es menor que -4 o no es menor que la precisión, en caso contrario usa el formato decimal. |
(4) |
|
Formato en coma flotante. Usa formato exponencial con mayúsculas si el exponente es menor que -4 o no es menor que la precisión, en caso contrario usa el formato decimal. |
(4) |
|
Byte único (Acepta números enteros o binarios de un único byte) |
|
|
Bytes (Cualquier objeto que siga el protocolo de objetos de tipo binario o implemente el método |
(5) |
|
|
(6) |
|
Bytes (Convierte cualquier objeto Python usando |
(5) |
|
|
(7) |
|
No se representa ningún argumento, obteniéndose en el resultado la cadena |
Notas:
La forma alternativa hace que se inserte antes del primer dígito un prefijo indicativo del formato octal (
'0o'
)La forma alternativa hace que se inserte antes del primer dígito uno de los dos prefijos indicativos del formato hexadecimal
'0x'
or'0X'
(Que se use uno u otro depende de que indicador de formato se haya usado,'x'
or'X'
).La forma alternativa hace que se incluya siempre el símbolo del punto o coma decimal, incluso si no hubiera dígitos después.
La precisión determina el número de dígitos que vienen después del punto decimal, y por defecto es 6.
La forma alternativa hace que se incluya siempre el símbolo del punto o coma decimal, y los ceros a su derecha no se eliminan, como seria el caso en la forma normal.
La precisión determina el número de dígitos significativos que vienen antes y después del punto decimal, y por defecto es 6.
Si la precisión es
N
, la salida se trunca aN
caracteres.b'%s'
está obsoleto, pero no se retirará durante la serie 3.x.b'%r'
está obsoleto, pero no se retirará durante la serie 3.x.Véase PEP 237.
Nota
La versión bytearray de este método no modifica los valores internamente (no opera in place): siempre produce un nuevo objeto, aun si no se hubiera realizado ningún cambio.
Ver también
PEP 461 - Añadir formateo usando % con bytes y bytearray
Nuevo en la versión 3.5.
Vistas de memoria¶
Los objetos de tipo memoryview
permiten al código Python acceder a los datos internos de objetos que soporten el protocolo buffer sin necesidad de hacer copias.
-
class
memoryview
(obj)¶ Crea un
memoryview
que referencia obj. La variable obj debe soportar el protocolo buffer. Los tipos de datos básicos que soportan el protocolo buffer incluyen losbytes
ybytearray
.La clase
memoryview
usa el concepto de elemento, que es la unidad de memoria atómica gestionada por el objeto original obj. Para muchos tipos de datos simples comobytes
ybytearray
, un elemento es un único byte, pero otros tipos, como la clasearray.array
pueden tener elementos más grandes.El resultado de
len(view)
es igual a la longitud detolist
. Siview.ndim = 0
, la longitud es 1. Siview.ndim = 1
, la longitud es igual al número de elementos en la vista. Para dimensiones superiores, la longitud es igual a la de la representación como lista anidada de la vista. El atributoitemsize
contiene el número de bytes que ocupa un único elemento.Un objeto de tipo
memoryview
soporta operaciones de rebanado y acceso por índices a sus datos. Un rebanado unidimensional producirá una sub-vista:>>> v = memoryview(b'abcefg') >>> v[1] 98 >>> v[-1] 103 >>> v[1:4] <memory at 0x7f3ddc9f4350> >>> bytes(v[1:4]) b'bce'
Si
format
es uno de los especificadores de formato nativos del módulostruct
, el indexado con un número entero o una tupla de números enteros también es posible, y retorna un único elemento con el tipo adecuado. Objetos memoryview unidimensionales pueden ser indexados con un entero o con una tupla de enteros. Los memoryview con múltiples dimensiones pueden ser indexados con tuplas de exactamente ndim enteros, donde ndim es el número de dimensiones. Vistas memoryviews con cero dimensiones pueden ser indexados con una tupla vacía.Aquí hay un ejemplo con un formato que no es un byte:
>>> import array >>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444]) >>> m = memoryview(a) >>> m[0] -11111111 >>> m[-1] 44444444 >>> m[::2].tolist() [-11111111, -33333333]
Si el objeto usado para crear la vista es modificable, la vista memoryview soporta asignación unidimensional mediante rebanadas. Sin embargo, no se permite el cambio de tamaño:
>>> data = bytearray(b'abcefg') >>> v = memoryview(data) >>> v.readonly False >>> v[0] = ord(b'z') >>> data bytearray(b'zbcefg') >>> v[1:4] = b'123' >>> data bytearray(b'z123fg') >>> v[2:3] = b'spam' Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: memoryview assignment: lvalue and rvalue have different structures >>> v[2:6] = b'spam' >>> data bytearray(b'z1spam')
Los objetos memoryviews de una única dimensión que contienen tipos de datos hashables (De solo lectura) con formatos
'B'
,'b'
o'c'
son también hashables. El hash se define comohash(m) == hash(m.tobytes())
:>>> v = memoryview(b'abcefg') >>> hash(v) == hash(b'abcefg') True >>> hash(v[2:4]) == hash(b'ce') True >>> hash(v[::-2]) == hash(b'abcefg'[::-2]) True
Distinto en la versión 3.3: Los objetos memoryviews de una única dimensión pueden ahora ser usados con operaciones de rebanado. Los objetos memoryviews de una única dimensión con formatos
'B'
,'b'
o'c'
son ahora hashables.Distinto en la versión 3.4: los objetos memoryview son registrados automáticamente con la clase
collections.abc.Sequence
Distinto en la versión 3.5: los objetos memoryviews se pueden ahora acceder usando como índices una tupla de números enteros.
La clase
memoryview
tiene varios métodos:-
__eq__
(exporter)¶ Un objeto memoryview y un exportador PEP 3118 son iguales si sus formas son equivalentes y todos los valores correspondientes son iguales cuando los formatos respectivos de los operandos son interpretados usando la sintaxis de
struct
.Para el subconjunto de formatos de
struct
soportados actualmente portolist()
,v
yw
son iguales siv.tolist() == w.tolist()
:>>> import array >>> a = array.array('I', [1, 2, 3, 4, 5]) >>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0]) >>> c = array.array('b', [5, 3, 1]) >>> x = memoryview(a) >>> y = memoryview(b) >>> x == a == y == b True >>> x.tolist() == a.tolist() == y.tolist() == b.tolist() True >>> z = y[::-2] >>> z == c True >>> z.tolist() == c.tolist() True
Si cualquiera de las cadenas de formato no es soportada por el módulo
struct
, entonces la comparación de los objetos siempre los considerará diferentes (Incluso si las cadenas de formato y el contenido del buffer son idénticos):>>> from ctypes import BigEndianStructure, c_long >>> class BEPoint(BigEndianStructure): ... _fields_ = [("x", c_long), ("y", c_long)] ... >>> point = BEPoint(100, 200) >>> a = memoryview(point) >>> b = memoryview(point) >>> a == point False >>> a == b False
Nótese que, al igual que con los números en coma flotante,
v is w
no implica quev == w
para objetos del tipo memoryview.Distinto en la versión 3.3: Versiones previas comparaban la memoria directamente, sin considerar ni el formato de los elementos ni la estructura lógica de array.
-
tobytes
(order=None)¶ Retorna los datos en el buffer en forma de cadena de bytes. Equivale a llamar al constructor de la clase
bytes
en el objeto memoryview:>>> m = memoryview(b"abc") >>> m.tobytes() b'abc' >>> bytes(m) b'abc'
Para arrays no contiguos el resultado es igual a la representación en forma de lista aplanada, con todos los elementos convertidos a bytes. El método
tobytes()
soporta todos los formatos de texto, incluidos aquellos que no se encuentran en la sintaxis del módulostruct
.Nuevo en la versión 3.8: El valor de order puede ser {“C”, “F”, “A”}. Cuando order es “C” o “F”, los datos en el array original se convierten al orden de C o Fortran. Para vistas contiguas, “A” retorna una copia exacta de la memoria física. En particular, el orden en memoria de Fortran se mantiene inalterado. Para vista no contiguas, los datos se convierten primero a C. Definir order=None es lo mismo que order=”C”.
-
hex
([sep[, bytes_per_sep]])¶ Retorna una cadena de caracteres que contiene dos dígitos hexadecimales por cada byte en el buffer:
>>> m = memoryview(b"abc") >>> m.hex() '616263'
Nuevo en la versión 3.5.
Distinto en la versión 3.8: De forma similar a
bytes.hex()
,memoryview.hex()
soporta ahora los parámetros opcionales sep y bytes_per_sep para insertar separadores entre los bytes en la cadena hexadecimal de salida.
-
tolist
()¶ Retorna los datos en el buffer como una lista de elementos.
>>> memoryview(b'abc').tolist() [97, 98, 99] >>> import array >>> a = array.array('d', [1.1, 2.2, 3.3]) >>> m = memoryview(a) >>> m.tolist() [1.1, 2.2, 3.3]
-
toreadonly
()¶ Retorna una versión de solo lectura del objeto memoryview. El objeto original permanece inalterado:
>>> m = memoryview(bytearray(b'abc')) >>> mm = m.toreadonly() >>> mm.tolist() [89, 98, 99] >>> mm[0] = 42 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: cannot modify read-only memory >>> m[0] = 43 >>> mm.tolist() [43, 98, 99]
Nuevo en la versión 3.8.
-
release
()¶ Libera el buffer subyacente expuesto por el objeto memoryview. Muchos objetos realizan operaciones especiales cuando una vista los está conteniendo (Por ejemplo, un objeto
bytearray
temporalmente prohíbe el cambio de tamaño); la llamada a release() sirve para eliminar estas restricciones (Así como para tratar con los recursos pendientes) lo más pronto posible.Después de que se ha llamado a este método, cualquier operación posterior sobre la vista producirá una excepción de tipo
ValueError
(Excepto por el propio métodorelease()
, que puede ser llamado las veces que se quiera):>>> m = memoryview(b'abc') >>> m.release() >>> m[0] Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: operation forbidden on released memoryview object
El protocolo de gestión de contexto puede ser usado para obtener un efecto similar, usando la sentencia
with
:>>> with memoryview(b'abc') as m: ... m[0] ... 97 >>> m[0] Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: operation forbidden on released memoryview object
Nuevo en la versión 3.2.
-
cast
(format[, shape])¶ Transforma el formato o el tamaño de un objeto memoryview. El parámetro shape por defecto vale
[byte_length//new_itemsize]
, lo que significa que el resultado será unidimensional. El valor de retorno es un nuevo objeto de tipo memoryview, pero el buffer en sí no se copia. Las transformaciones pueden ser 1D -> C-contiguo y C-contiguo -> 1D.El formato de destino está restringido a un único elemento de formato nativo en la sintaxis de
struct
. Uno de los formatos debe ser un formato de byte ('B'
,'b'
o'c'
). La longitud en bytes del resultado debe coincidir con la longitud original.Transforma de
1D/long
a bytes1D/unsigned
:>>> import array >>> a = array.array('l', [1,2,3]) >>> x = memoryview(a) >>> x.format 'l' >>> x.itemsize 8 >>> len(x) 3 >>> x.nbytes 24 >>> y = x.cast('B') >>> y.format 'B' >>> y.itemsize 1 >>> len(y) 24 >>> y.nbytes 24
Transforma de
1D/unsigned
a bytes1D/char
:>>> b = bytearray(b'zyz') >>> x = memoryview(b) >>> x[0] = b'a' Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: memoryview: invalid value for format "B" >>> y = x.cast('c') >>> y[0] = b'a' >>> b bytearray(b'ayz')
Transforma de
1D/bytes
a3D/ints
a caracteres1D/signed
:>>> import struct >>> buf = struct.pack("i"*12, *list(range(12))) >>> x = memoryview(buf) >>> y = x.cast('i', shape=[2,2,3]) >>> y.tolist() [[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]] >>> y.format 'i' >>> y.itemsize 4 >>> len(y) 2 >>> y.nbytes 48 >>> z = y.cast('b') >>> z.format 'b' >>> z.itemsize 1 >>> len(z) 48 >>> z.nbytes 48
Transforma de long
1D/unsigned
a long2D/unsigned
:>>> buf = struct.pack("L"*6, *list(range(6))) >>> x = memoryview(buf) >>> y = x.cast('L', shape=[2,3]) >>> len(y) 2 >>> y.nbytes 48 >>> y.tolist() [[0, 1, 2], [3, 4, 5]]
Nuevo en la versión 3.3.
Distinto en la versión 3.5: El formato de origen ya no está restringido cuando se transforma a una vista de bytes.
Hay disponibles varios atributos de solo lectura:
-
obj
¶ El objeto subyacente del memoryview:
>>> b = bytearray(b'xyz') >>> m = memoryview(b) >>> m.obj is b True
Nuevo en la versión 3.3.
-
nbytes
¶ nbytes == product(shape) * itemsize == len(m.tobytes())
. Este es el espacio, medido en bytes, que usará el array en una representación continua. No tiene que ser necesariamente igual alen(m)
:>>> import array >>> a = array.array('i', [1,2,3,4,5]) >>> m = memoryview(a) >>> len(m) 5 >>> m.nbytes 20 >>> y = m[::2] >>> len(y) 3 >>> y.nbytes 12 >>> len(y.tobytes()) 12
Matrices de múltiples dimensiones:
>>> import struct >>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)]) >>> x = memoryview(buf) >>> y = x.cast('d', shape=[3,4]) >>> y.tolist() [[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]] >>> len(y) 3 >>> y.nbytes 96
Nuevo en la versión 3.3.
-
readonly
¶ Un booleano que indica si la memoria es de solo lectura.
-
format
¶ Una cadena de caracteres que contiene el formato (En el estilo del módulo
struct
) para cada elemento de la vista. Un objeto memoryview se puede crear a partir de un exportador con textos de formato arbitrarios, pero algunos métodos (Como, por ejemplo,tolist()
) están restringidos a usar formatos de elementos nativos sencillos.Distinto en la versión 3.3: el formato
'B'
se gestiona ahora de acuerdo a la sintaxis descrita en el módulostruct
. Esto significa quememoryview(b'abc')[0] == b'abc'[0] == 97
.
-
itemsize
¶ El tamaño en bytes de cada elemento del objeto memoryview:
>>> import array, struct >>> m = memoryview(array.array('H', [32000, 32001, 32002])) >>> m.itemsize 2 >>> m[0] 32000 >>> struct.calcsize('H') == m.itemsize True
-
ndim
¶ Un número entero que indica cuantas dimensiones de una matriz multi-dimensional representa la memoria.
-
shape
¶ Una tupla de números enteros, de longitud
ndim
, que indica la forma de la memoria en una matriz de N dimensiones.Distinto en la versión 3.3: Una tupla vacía, en vez de
None
, cuandondom = 0
.
-
strides
¶ Una tupla de números enteros, de longitud
ndim
, que indica el tamaño en bytes para acceder a cada dimensión de la matriz.Distinto en la versión 3.3: Una tupla vacía, en vez de
None
, cuandondom = 0
.
-
suboffsets
¶ De uso interno para las matrices estilo PIL. El valor es solo informativo.
-
c_contiguous
¶ Un booleano que indica si la memoria es contiguous al estilo C.
Nuevo en la versión 3.3.
-
f_contiguous
¶ Un booleano que indica si la memoria es contiguous al estilo Fortran.
Nuevo en la versión 3.3.
-
contiguous
¶ Un booleano que indica si la memoria es contiguous.
Nuevo en la versión 3.3.
-
Conjuntos — set
, frozenset
¶
Un objeto de tipo conjunto o set es una colección no ordenada de distintos objetos hashable. Los casos de uso habituales incluyen comprobar la pertenencia al conjunto de un elemento, eliminar duplicados de una secuencia y realizar operaciones matemáticas como la intersección, la unión, la diferencia o la diferencia simétrica (Para otros tipos de contenedores véanse las clases básicas dict
, list
, y tuple
, así como el módulo collections
).
Como otras colecciones, los conjuntos soportan x in set
, len(set)
y for x in set
. Como es una colección sin orden, los conjuntos no registran ni la posición ni el orden de inserción de los elementos. Por lo mismo, los conjuntos no soportan indexado, ni operaciones de rebanadas, ni otras capacidades propias de las secuencias.
En la actualidad hay dos tipos básicos de conjuntos: set
y frozenset
. La clase set
es mutable, es decir, el contenido del conjunto puede ser modificado con métodos como add()
y remove()
. Como es mutable, no tiene un valor de hash y no pueden ser usados como claves de diccionarios ni como elementos de otros conjuntos. La clase frozenset
es inmutable y hashable, es decir, que sus contenidos no pueden ser modificados después de creados. Puede ser usado, por tanto, como claves de diccionario o como elemento de otro conjunto.
Se pueden crear conjuntos no vacíos (sets, no frozensets) escribiendo una lista de elementos separados por comas, entre llaves, por ejemplo {'jack', 'sjoerd'}
, además de con el constructor de la clase set
.
El constructor para ambas clases se usa de la misma forma:
-
class
set
([iterable])¶ -
class
frozenset
([iterable])¶ Retorna un nuevo set o frozenset, tomando los elementos a partir de iterable. Los elementos de un conjunto tienen que tener la propiedad de ser hashable. Para representar conjuntos anidados, o conjuntos de conjuntos, los conjuntos interiores tienen que ser instancias de
frozenset
. Si no se especifica el parámetro iterable, se retorna un conjunto vacío.Sets can be created by several means:
Use a comma-separated list of elements within braces:
{'jack', 'sjoerd'}
Use a set comprehension:
{c for c in 'abracadabra' if c not in 'abc'}
Use the type constructor:
set()
,set('foobar')
,set(['a', 'b', 'foo'])
Las instancias de
set
yfrozenset
proporcionan las siguientes operaciones:-
len(s)
Retorna el número de elementos en el conjunto s (Cardinalidad de s)
-
x in s
Comprueba que el elemento x está incluido en s.
-
x not in s
Comprueba que el elemento x no está incluido en s.
-
isdisjoint
(other)¶ Retorna
True
si el conjunto no tienen ningún elemento en común con other. Dos conjuntos son disjuntos si y solo si su intersección es el conjunto vacío.
-
issubset
(other)¶ -
set <= other
Comprueba si cada elemento del conjunto también se encuentra en other.
-
set < other
Comprueba si el conjunto es un subconjunto propio de other, es decir,
set <= other and set != other
.
-
issuperset
(other)¶ -
set >= other
Comprueba que cada elemento de other está incluido en el conjunto.
-
set > other
Comprueba si el conjunto es un superconjunto propio de other, es decir,
set >= other and set != other
.
-
union
(*others)¶ -
set | other | ...
Retorna un conjunto nuevo que contiene todos los elementos del conjunto y de others.
-
intersection
(*others)¶ -
set & other & ...
Retorna un conjunto nuevo que contiene todos los elementos que están a la vez en conjunto y en others.
-
difference
(*others)¶ -
set - other - ...
Retorna un conjunto nuevo que contiene todos los elementos del conjunto y que no están incluidos en others.
-
symmetric_difference
(other)¶ -
set ^ other
Retorna un conjunto nuevo que contiene elementos que están incluidos en el conjunto o en others, pero no en los dos a la vez.
-
copy
()¶ Retorna una copia superficial del conjunto.
Hay que señalar que las versiones de las operaciones que son métodos (no los operadores) como
union()
,intersection()
,difference()
,symmetric_difference()
,issubset()
, yissuperset()
aceptan cualquier iterable como parámetro. Por el contrario, los operadores requieren que los argumentos sean siempre conjuntos. Esto evita ciertas construcciones propensas a errores comoset('abc') & 'cbs'
, favoreciendo el uso formas más legibles comoset('abc').intersection('cbs')
.Ambas clases
set
yfrozenset
soportan comparaciones entre si. Dos conjuntos son iguales si y solo si cada elemento de cada conjunto está incluido en el otro (Cada uno de ellos es subconjunto del otro). Un conjunto es menor que otro si y solo si el primero es un subconjunto propio del segundo (Es un subconjunto, pero no son iguales). Un conjunto es mayor que otro si y solo si el primero en un superconjunto propio del segundo (Es un superconjunto, pero no son iguales).Las instancias de
set
se comparan con las instancias defrozenset
en base a sus elementos. Por ejemploset('abc') == frozenset('abc')
retornaTrue
y lo mismo haceset('abc') in set([frozenset('abc')])
.Las comparaciones de subconjunto e igualdad no son tan generales que permitan una función de ordenación total. Por ejemplo, dos conjuntos cualesquiera que no estén vacíos y que sean disjuntos no son iguales y tampoco son subconjuntos uno del otro, así que todas estas operaciones retornan
False
:a<b
,a==b
, ora>b
.Como los conjuntos solo definen un orden parcial (Relaciones de conjuntos), la salida del método
list.sort()
no está definida para listas de conjuntos.Los elementos de un conjunto, al igual que las claves de un diccionario, deben ser hashable.
Las operaciones binarias que mezclan instancias de
set
yfrozenset
retornan el tipo del primer operando. Por ejemplofrozenset('ab') | set('bc')
retornará una instancia defrozenset
.La siguiente tabla muestra las operaciones disponibles para la clase
set
que no son aplicables a los conjuntos inmutablesfrozenset
:-
update
(*others)¶ -
set |= other | ...
Actualiza el conjunto, añadiendo los elementos que se encuentren en others.
-
intersection_update
(*others)¶ -
set &= other & ...
Actualiza el conjunto, manteniendo solo los elementos que se encuentren en si mismo y en others.
-
difference_update
(*others)¶ -
set -= other | ...
Actualiza el conjunto, eliminado los elementos que se encuentren en others.
-
symmetric_difference_update
(other)¶ -
set ^= other
Actualiza el conjunto, manteniendo solo los elementos que se encuentren en el conjunto o en others, pero no en los dos a la vez.
-
add
(elem)¶ Añade al conjunto el elemento elem.
-
remove
(elem)¶ Elimina del conjunto el elemento elem. Eleva la excepción
KeyError
si elem no estaba incluido en el conjunto.
-
discard
(elem)¶ Elimina del conjunto el elemento elem, si estuviera incluido.
-
pop
()¶ Elimina y retorna un elemento cualquiera del conjunto. Eleva la excepción
KeyError
si el conjunto estaba vacío.
-
clear
()¶ Elimina todos los elementos del conjunto.
Hay que señalar que los métodos (no los operadores)
update()
,intersection_update()
,difference_update()
, ysymmetric_difference_update()
aceptan cualquier iterable como parámetro.Nótese que el parámetro elem de los métodos
__contains__()
,remove()
ydiscard()
puede ser un conjunto. Para soportar la búsqueda por un frozenset equivalente se crea uno temporal a partir de elem.
Tipos Mapa — dict
¶
Un objeto de tipo mapping relaciona valores (que deben ser hashable) con objetos de cualquier tipo. Los mapas son objetos mutables. En este momento solo hay un tipo estándar de mapa, los diccionarios (Para otros tipos contenedores, véanse las clases básicas list
, set
, y tuple
, así como el módulo collections
).
Las claves de un diccionario pueden ser casi de cualquier tipo. Los valores que no son hashable, como por ejemplo valores que contengan listas, diccionarios u otros tipo mutables (que son comparados por valor, no por referencia) no se pueden usar como claves. Los tipos numéricos, cuando se usan como claves siguen las reglas habituales de la comparación numérica: Si dos números se consideran iguales (Como 1
y 1.0
), ambos valores pueden ser usados indistintamente para acceder al mismo valor (Pero hay que tener en cuenta que los ordenadores almacenan algunos números en coma flotante como aproximaciones, por lo que normalmente no es recomendable usarlos como claves).
Los diccionarios se pueden crear colocando una lista separada por comas de pares key: value
entre llaves, por ejemplo: {'jack': 4098, 'sjoerd': 4127}
o {4098: 'jack', 4127: 'sjoerd'}
, o por el constructor dict
.
-
class
dict
(**kwarg)¶ -
class
dict
(mapping, **kwarg) -
class
dict
(iterable, **kwarg) Retorna un diccionario creado a partir de un parámetro opcional por posición, y por una serie de parámetros por nombre, también opcionales.
Dictionaries can be created by several means:
Use a comma-separated list of
key: value
pairs within braces:{'jack': 4098, 'sjoerd': 4127}
or{4098: 'jack', 4127: 'sjoerd'}
Use a dict comprehension:
{}
,{x: x ** 2 for x in range(10)}
Use the type constructor:
dict()
,dict([('foo', 100), ('bar', 200)])
,dict(foo=100, bar=200)
Si no se especifica el parámetro por posición, se crea un diccionario vacío. Si se pasa un parámetro por posición y es un objeto de tipo mapa, se crear el diccionario a partir de las parejas clave-valor definidos en el mapa. Si no fuera un mapa, se espera que el parámetro sea un objeto iterable. Cada elemento del iterable debe ser una dupla (Una tupla de dos elementos); el primer componente de la dupla se usará como clave y el segundo como valor a almacenar en el nuevo diccionario. Si una clave aparece más de una vez, el último valor será el que se almacene en el diccionario resultante.
Si se usan parámetros por nombre, los nombres de los parámetros y los valores asociados se añaden al diccionario creado a partir del parámetro por posición. Si un valor de clave ya estaba presente, el valor pasado con el parámetro por nombre reemplazara el valor del parámetro por posición.
A modo de ejemplo, los siguientes ejemplo retornan todos el mismo diccionario
{"one": 1, "two": 2, "three": 3}
:>>> a = dict(one=1, two=2, three=3) >>> b = {'one': 1, 'two': 2, 'three': 3} >>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3])) >>> d = dict([('two', 2), ('one', 1), ('three', 3)]) >>> e = dict({'three': 3, 'one': 1, 'two': 2}) >>> a == b == c == d == e True
Si queremos definir claves con parámetros por nombre, como en el primer ejemplo, entonces los valores de clave solo puede ser cadenas de texto conteniendo identificadores de Python válidos. En los otros casos, se puede usar cualquier valor como clave.
Estas son las operaciones soportados por los diccionarios (Y que, por tanto, deberían ser soportados por los tipos de mapa personalizados):
-
list(d)
Retorna una lista de todas las claves usadas en el diccionario d.
-
len(d)
Retorna el número de elementos almacenados en el diccionario d.
-
d[key]
Retorna el elemento dentro de d almacenado bajo la clave key. Eleva una excepción de tipo
KeyError
si la clave key no se encuentra en el diccionario d.Si una subclase de un diccionario define el método
__missing__()
y key no está presente, la operaciónd[key]
llama a este método pasando como parámetro el valor de key. La operaciónd[key]
o bien retorna un valor o eleva la excepción que sea retornada por la llamada a__missing__(key)
. Ninguna otra operación o método llama a__missing__()
. Si el método__missing__()
no está definido, se elevaKeyError
. Si se define__missing__()
, debe ser de forma obligatoria un método, no puede ser una variable de instancia:>>> class Counter(dict): ... def __missing__(self, key): ... return 0 >>> c = Counter() >>> c['red'] 0 >>> c['red'] += 1 >>> c['red'] 1
El ejemplo anterior muestra parte de la implementación de la clase
collections.Counter
. Otro ejemplo de uso del método__missing__
se puede encontrar en la clasecollections.defaultdict
.
-
d[key] = value
Asigna el valor value a
d[key]
.
-
del d[key]
Elimina
d[key]
de d. Eleva una excepciónKeyError
si key no está en el mapa.
-
key in d
Retorna
True
si d tiene una entrada en la clave key,False
en caso contrario.
-
key not in d
Equivale a
not key in d
.
-
iter(d)
Retorna un iterador que recorre todas las claves de un diccionario. Es una forma abreviada de
iter(d.keys())
.
-
clear
()¶ Elimina todos los contenidos del diccionario.
-
copy
()¶ Retorna una copia superficial del diccionario.
-
classmethod
fromkeys
(iterable[, value])¶ Crea un nuevo diccionario con las claves obtenidos a partir del iterable y con valor value.
El método
fromkeys()
es un método de clase que retorna un diccionario nuevo. El valor de value por defecto esNone
. Todos los valores harán referencia a una única instancia, por lo que en general no tiene sentido que value sea un objeto mutable, como una lista vacía. Para poder obtener valores diferentes, se puede usar mejor un diccionario por comprensión.
-
get
(key[, default])¶ Retorna el elemento dentro de d almacenado bajo la clave key, si key está en el diccionario; si no, retorna default. El valor de default por defecto es
None
, por lo que esta función nunca eleva la excepciónKeyError
.
-
items
()¶ Retorna una nueva vista de los contenidos del diccionario (Pares
(key, value)
). Vea documentación de los objetos vistas.
-
keys
()¶ Retorna una nueva vista de las claves del diccionario. Véase la documentación de las vistas.
-
pop
(key[, default])¶ Si key está en el diccionario, lo elimina del diccionario y retorna su valor; si no está, retorna default. Si no se especifica valor para default y la clave no se encuentra en el diccionario, se eleva la excepción
KeyError
.
-
popitem
()¶ Elimina y retorna una pareja
(key, value)
del diccionario. Las parejas se retornan en el orden LIFO.El método
popitem()
es útil para recorrer y a la vez vaciar un diccionario, un proceso usado a menudo en algoritmos de conjuntos. Si el diccionario está vacío, llamar apopitem()
eleva la excepciónKeyError
.Distinto en la versión 3.7: El orden LIFO ahora está garantizado. En versiones anteriores, el método
popitem()
retorna una pareja clave/valor arbitraria.
-
reversed(d)
Retorna un iterador que recorre las claves en orden inverso. Es una forma abreviada de
reversed(d.keys())
.Nuevo en la versión 3.8.
-
setdefault
(key[, default])¶ Si key está incluida en el diccionario, retorna el valor almacenado. Si no, inserta con la clave key el valor definido en default y retorna default. El valor por defecto de default es
None
.
-
update
([other])¶ Actualiza el diccionario con las parejas clave/valor obtenidas de other, escribiendo encima de las claves existentes. retorna
None
.El método
update()
acepta tanto un diccionario como un iterable que Retorna parejas de claves, valor (ya sea como tuplas o como otros iterables de longitud 2). Si se especifican parámetros por nombre, el diccionario se actualiza con esas combinaciones de clave y valor:d.update(red=1, blue=2)
.
-
values
()¶ Retorna una nueva vista de los valores del diccionario. Véase la documentación sobre objetos vistas.
Una comparación de igualdad entre una vista
dict.values()
y otra siempre retornaráFalse
. Esto también pasa cuando se comparadict.values()
consigo mismo:>>> d = {'a': 1} >>> d.values() == d.values() False
Los diccionarios se consideran iguales si y solo si tienen el mismo conjunto de parejas
(key, value)
(Independiente de su orden). Los intentos de comparar usando los operadores “<”, “<=”, “>=”, “>” elevan una excepción de tipoTypeError
.Los diccionarios mantiene de forma interna el orden de inserción. Actualizar una entrada no modifica ese orden. Las claves que vuelven a ser insertadas después de haber sido borradas se añaden al final.:
>>> d = {"one": 1, "two": 2, "three": 3, "four": 4} >>> d {'one': 1, 'two': 2, 'three': 3, 'four': 4} >>> list(d) ['one', 'two', 'three', 'four'] >>> list(d.values()) [1, 2, 3, 4] >>> d["one"] = 42 >>> d {'one': 42, 'two': 2, 'three': 3, 'four': 4} >>> del d["two"] >>> d["two"] = None >>> d {'one': 42, 'three': 3, 'four': 4, 'two': None}
Distinto en la versión 3.7: Se garantiza que el orden del diccionario es el de inserción. Este comportamiento era un detalle de implementación en CPython desde la versión 3.6.
Tanto los diccionarios como las vistas basadas en diccionarios son reversibles:
>>> d = {"one": 1, "two": 2, "three": 3, "four": 4} >>> d {'one': 1, 'two': 2, 'three': 3, 'four': 4} >>> list(reversed(d)) ['four', 'three', 'two', 'one'] >>> list(reversed(d.values())) [4, 3, 2, 1] >>> list(reversed(d.items())) [('four', 4), ('three', 3), ('two', 2), ('one', 1)]
Distinto en la versión 3.8: Los diccionarios son ahora reversibles.
Ver también
Se puede usar un objeto de tipo types.MappingProxyType
para crear una vista de solo lectura de un objeto dict
.
Objetos tipos vista de diccionario¶
Los objetos retornados por los métodos dict.keys()
, dict.values()
y dict.items()
son objetos tipo vista o view. Estos objetos proporcionan una vista dinámica del contenido del diccionario, lo que significa que si el diccionario cambia, las vistas reflejan estos cambios.
Las vistas de un diccionario pueden ser iteradas para retornar sus datos respectivos, y soportan operaciones de comprobación de pertenencia:
-
len(dictview)
Retorna el número de entradas en un diccionario.
-
iter(dictview)
Retorna un iterador sobre las claves, valores o elementos (representados en forma de tuplas
(key, value)
) de un diccionario.Las claves y los valores se iteran en orden de inserción. Esto permite la creación de parejas
(value, key)
usando la funciónzip()
:pairs = zip(d.values(), d.keys())
. Otra forma de crear la misma lista espairs = [(v, k) for (k, v) in d.items()]
.Iterar sobre un diccionario a la vez que se borran o añaden entradas puede elevar una excepción de tipo
RuntimeError
, o puede provocar que no se iteren sobre todas las entradas.Distinto en la versión 3.7: Se garantiza que el orden de los diccionarios es el de inserción.
-
x in dictview
Retorna
True
si x está incluido en las claves, los valores o los elementos del diccionario. En el último caso, x debe ser una tupla(key, value)
.
-
reversed(dictview)
Retorna un iterador inverso sobre las claves y valores del diccionario. El orden de la vista sera el inverso del orden de inserción.
Distinto en la versión 3.8: Las vistas de un diccionario no son reversibles.
Las vistas de claves son similares a conjuntos, dado que todas las claves deben ser únicas y hashables. Si todos los valores son también hashables, de forma que las parejas (key, value)
son también únicas y hashables, entonces la vista items es también similar a un conjunto (La vista values no son consideradas similar a un conjunto porque las valores almacenados en el diccionario no tiene que ser únicos). Las vistas similares a conjuntos pueden usar todas las operaciones definidas en la clase abstracta collections.abc.Set
, como por ejemplo ==
, <
, or ^
.
Un ejemplo de uso de una vista de diccionario:
>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()
>>> # iteration
>>> n = 0
>>> for val in values:
... n += val
>>> print(n)
504
>>> # keys and values are iterated over in the same order (insertion order)
>>> list(keys)
['eggs', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]
>>> # view objects are dynamic and reflect dict changes
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['bacon', 'spam']
>>> # set operations
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}
>>> keys ^ {'sausage', 'juice'}
{'juice', 'sausage', 'bacon', 'spam'}
Tipos Gestores de Contexto¶
La expresión with
de Python soporta el concepto de un contexto en tiempo de ejecución definido mediante un gestor de contexto. Para implementar esto, se permite al usuario crear clases para definir estos contextos definiendo dos métodos, uno a ejecutar ante de entrar del bloque de código y otro a ejecutar justo después de salir del mismo:
-
contextmanager.
__enter__
()¶ Entra en el contexto en tiempo de ejecución, y retorna o bien este objeto u otro relacionado con el contexto. El valor retornado por este método se vincula al identificador que viene tras la palabra clave
as
usada en la sentenciawith
que define el contexto.Un ejemplo de gestor de contexto que se retorna a si mismo es un objeto de tipo file object. Los objetos de tipo
File
se retornan a si mismo en la llamada a__enter__()
, lo que permite queopen()
sea usado como gestores de contexto en una sentenciawith
.Un ejemplo de gestor de contexto que retorna otro objeto relacionado en el que define la función
decimal.localcontext()
. Este gestor define el contexto de uso en operaciones decimales a partir de una copia del contexto original, y retorna esa copia. De esta manera se puede cambiar el contexto decimal dentro del cuerpo delwith
sin afectar al código fuera del mismo.
-
contextmanager.
__exit__
(exc_type, exc_val, exc_tb)¶ Sale del contexto y retorna un indicador booleano que indica si se debe ignorar cualquier posible excepción que hubiera ocurrido dentro del mismo. Si se produce una excepción mientras se ejecutan las sentencias definidas en el cuerpo de la sentencia
with
, los parámetros de esta función contienen el tipo y valor de la excepción, así como la información relativa a la traza de ejecución. Si no se produce ninguna excepción, los tres parámetros valenNone
.Si este método retorna un valor
True
, la sentenciawith
ignora la excepción y el flujo del programa continua con la primera sentencia inmediatamente después del cuerpo. En caso contrario la excepción producida continua propagándose después de que este método termine de ejecutarse. Cualquier excepción que pudieran producirse dentro de este método reemplaza a la excepción que se hubiera producido en el cuerpo delwith
.La excepción pasada nunca debe volver a elevarse explícitamente; en vez de eso, el método debería retornar un valor falso para indicar que el método ha terminado de ejecutarse sin problemas y que no se desea suprimir la excepción. Esto permite a los gestores de contexto detectar fácilmente si el método
__exit__()
ha podido terminar o no.
Python define varios gestores de contexto para facilitar la sincronía entre hilos, asegurarse del cierre de ficheros y otros objetos similares y para modificar de forma simple el contexto para las expresiones aritméticas con decimales.Los tipos específicos no se tratan especialmente fuera de su implementación del protocolo de administración de contexto.Ver el módulo contextlib
para algunos ejemplos.
Los generator y el decoradores definidos en la clase contextlib.contextmanager
permiten implementar de forma sencilla estos protocolos. Si una función generadora se decora con la clase contextlib.contextmanager
, retornará un gestor de contexto que incluye los necesarios métodos __enter__()
y __exit__()
, en vez del iterador que se produciría si no se decora la función.
Nótese que no hay una ranura específica para ninguno de estos métodos en la estructura usada para los objetos Python en el nivel de la API C. Objetos que quieran definir estos métodos deben implementarlos como métodos normales de Python. Comparado con la complejidad de definir un contexto en tiempo de ejecución, lo complejidad de una búsqueda simple en un diccionario es mínima.
Otros tipos predefinidos¶
El intérprete soporta otros tipos de objetos variados. La mayoría de ellos solo implementan una o dos operaciones.
Módulos¶
La única operación especial que implementan los módulos es el acceso como atributos: m.name
, donde m es un módulo y name accede a un nombre definido en la tabla de símbolos del módulo m. También se puede asignar valores a los atributos de un módulo (Nótese que la sentencia import
no es, estrictamente hablando, una operación del objeto de tipo módulo. La sentencia import foo
no requiere la existencia de un módulo llamado foo, sino una definición (externa) de un módulo foo en alguna parte).
Un atributo especial de cada módulo es __dict__
. Es un diccionario que contiene la tabla de símbolos del módulo. Cambiar el diccionario cambiará por tanto el contenido de la tabla de símbolos, pero no es posible realizar una asignación directa al atributo __dict__
(Se puede realizar una asignación como m.__dict__['a'] = 1
, que define el valor de m.a
como 1
, pero no se puede hacer m.__dict__ = {}
). No se recomiendo manipular los contenidos del atributo __dict__
directamente.
Los módulos incluidos en el intérprete se escriben así: <module 'sys' (built-in)>
. Si se cargan desde un archivo, se escriben como <module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>
.
Clases e instancias de clase¶
Véase Objetos, valores y tipos y Definiciones de clase para más información.
Funciones¶
Los objetos de tipo función se crean mediante definiciones de función. La única operación posible con un objeto de tipo función en llamarla: func(argument-list)
.
Hay dos tipos de funciones: Las funciones básicas o predefinidas y las funciones definidas por el usuario. Las dos soportan la misma operación (ser llamadas), pero la implementación es diferente, de ahí que se consideren de distintos tipo.
Véase Definiciones de funciones para más información.
Métodos¶
Los métodos son funciones que se llaman usando la notación de atributos. Hay de dos tipos: métodos básicos o predefinidos (Como el método append()
en las listas) y métodos de instancia de clase. Los métodos básicos o predefinidos se describen junto con los tipos que los soportan.
Si se accede a un método (Una función definida dentro de un espacio de nombres de una clase) a través de una instancia,se obtiene un objeto especial, un método ligado (También llamado método de instancia). Cuando se llama, se añade automáticamente el parámetro self
a la lista de parámetros. Los métodos ligados tienen dos atributos especiales de solo lectura: m.__self__
es el objeto sobre el que está operando el método, y m.__func__
es la función que implementa el método.
Al igual que los objetos de tipo función, los métodos ligados o de instancia soportan asignación de atributos arbitrarios. Sin embargo, como los atributos de los métodos se almacenan en la función subyacente (meth.__func__
), definir cualquier atributo en métodos ligados está desaconsejado. Intentar asignar un atributo a un método produce que se eleve una excepción de tipo AttributeError
. Para poder definir un atributo a un método, este debe ser definido explícitamente en la función subyacente:
>>> class C:
... def method(self):
... pass
...
>>> c = C()
>>> c.method.whoami = 'my name is method' # can't set on the method
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'method' object has no attribute 'whoami'
>>> c.method.__func__.whoami = 'my name is method'
>>> c.method.whoami
'my name is method'
Véase Jerarquía de tipos estándar para más información.
Objetos código¶
Los objetos de tipo código son usados por la implementación del lenguaje para representar código ejecutable «pseudo-compilado», como por ejemplo el cuerpo de una función. A diferencia de los objetos de tipo función, no contienen una referencia a un entorno global de ejecución. Los objetos de tipo código se pueden obtener usando la función básica compile()
o se pueden extraer a partir de objetos de tipo función a través de su atributo __code__
. Para más detalle véase el módulo code
.
Accessing __code__
raises an auditing event
object.__getattr__
with arguments obj
and "__code__"
.
Un objeto de tipo código puede ser evaluado o ejecutando pasándolo como parámetros a las funciones básicas exec()
o eval()
(Que también aceptan código Python en forma de cadena de texto).
Véase Jerarquía de tipos estándar para más información.
Objetos Tipo¶
Los objetos de tipo Tipo (Type) representan a los distintos tipos de datos. El tipo de un objeto particular puede ser consultado usando la función básica type()
. Los objetos Tipo no tienen ninguna operación especial. El módulo types
define nombres para todos los tipos básicos definidos en la biblioteca estándar.
Los tipos se escriben de la siguiente forma: <class 'int'>
.
El objeto nulo (Null)¶
Todas las funciones que no definen de forma explícita un valor de retorno retornan este objeto. Los objetos nulos no soportan ninguna operación especial. Solo existe un único objeto nulo, llamado None
(Un nombre predefinido o básico). La expresión type(None)()
produce el mismo objeto None
, esto se conoce como Singleton.
Se escribe None
.
El objeto puntos suspensivos (Ellipsis)¶
Este objeto es usado a menudo en operaciones de rebanadas (Véase Segmentos). No soporta ninguna operación especial. Solo existe un único objeto de puntos suspensivos, llamado Ellipsis
(Un nombre predefinido o básico). La expresión type(Ellipsis)()
produce el mismo objeto Ellipsis
, esto se conoce como Singleton.
Se puede escribir como Ellipsis
o ...
.
El objeto NotImplemented¶
Este objeto se retorna en todas las operaciones binarias y comparaciones cuando se intenta operar con tipos que no están soportados. Véase Comparaciones para más información. Solo existe un objeto de tipo NotImplemented
. La expresión type(NotImplemented)()
produce el mismo objeto, esto se conoce como Singleton.
Se escribe NotImplemented
.
Valores booleanos¶
Los valores booleanos o lógicos son los dos objetos constantes False
y True
. Su usan para representar valores de verdad (Aunque otros valores pueden ser considerados también como verdaderos o falsos). En contextos numéricos (Por ejemplo, cuando se usan como argumentos de una operación aritmética) se comportan como los números enteros 0 y 1 respectivamente. Se puede usar la función incorporada bool()
para convertir valores de cualquiera tipo a Booleanos, si dicho valor puede ser interpretado como valores verdaderos/falsos (Véase la sección Evaluar como valor verdadero/falso anterior).
Se escriben False
y True
respectivamente.
Objetos internos¶
Véase la sección Jerarquía de tipos estándar para saber más de estos objetos. Se describen los objetos marco de pila, los objetos de traza de ejecución (traceback) y los objetos de tipo rebanada (slice).
Atributos especiales¶
La implementación añade unos cuantos atributos de solo lectura a varios tipos de objetos, cuando resulta relevante. Algunos de estos atributos son reportados por la función incorporada dir()
.
-
object.
__dict__
¶ Un diccionario u otro tipo de mapa usado para almacenar los atributos de un objeto (Si son modificables).
-
instance.
__class__
¶ La clase a la que pertenece una instancia.
-
class.
__bases__
¶ La tupla de clases base de las que deriva una clase.
-
definition.
__name__
¶ El nombre de la clase, función, método, descriptor o instancia generadora.
-
definition.
__qualname__
¶ El nombre calificado (qualified name) de la clase, función, método, descriptor o instancia generadora.
Nuevo en la versión 3.3.
-
class.
__mro__
¶ Este atributo es una tupla de las clases que serán consideradas cuando se busque en las clases base para resolver un método.
-
class.
mro
()¶ Este método puede ser reescrito por una metaclase para personalizar el orden de resolución de métodos para sus instancias. Es llamado en la creación de la clase, y el resultado se almacena en el atributo
__mro__
.
-
class.
__subclasses__
()¶ Cada clase mantiene una lista de referencias débiles a sus subclase inmediatamente anteriores. Este método retorna una lista de todas las referencias que todavía estén vivas. Por ejemplo:
>>> int.__subclasses__() [<class 'bool'>]
Integer string conversion length limitation¶
CPython has a global limit for converting between int
and str
to mitigate denial of service attacks. This limit only applies to decimal or
other non-power-of-two number bases. Hexadecimal, octal, and binary conversions
are unlimited. The limit can be configured.
The int
type in CPython is an arbitrary length number stored in binary
form (commonly known as a «bignum»). There exists no algorithm that can convert
a string to a binary integer or a binary integer to a string in linear time,
unless the base is a power of 2. Even the best known algorithms for base 10
have sub-quadratic complexity. Converting a large value such as int('1' *
500_000)
can take over a second on a fast CPU.
Limiting conversion size offers a practical way to avoid CVE-2020-10735.
The limit is applied to the number of digit characters in the input or output string when a non-linear conversion algorithm would be involved. Underscores and the sign are not counted towards the limit.
When an operation would exceed the limit, a ValueError
is raised:
>>> import sys
>>> sys.set_int_max_str_digits(4300) # Illustrative, this is the default.
>>> _ = int('2' * 5432)
Traceback (most recent call last):
...
ValueError: Exceeds the limit (4300) for integer string conversion: value has 5432 digits; use sys.set_int_max_str_digits() to increase the limit.
>>> i = int('2' * 4300)
>>> len(str(i))
4300
>>> i_squared = i*i
>>> len(str(i_squared))
Traceback (most recent call last):
...
ValueError: Exceeds the limit (4300) for integer string conversion: value has 8599 digits; use sys.set_int_max_str_digits() to increase the limit.
>>> len(hex(i_squared))
7144
>>> assert int(hex(i_squared), base=16) == i*i # Hexadecimal is unlimited.
The default limit is 4300 digits as provided in
sys.int_info.default_max_str_digits
.
The lowest limit that can be configured is 640 digits as provided in
sys.int_info.str_digits_check_threshold
.
Verification:
>>> import sys
>>> assert sys.int_info.default_max_str_digits == 4300, sys.int_info
>>> assert sys.int_info.str_digits_check_threshold == 640, sys.int_info
>>> msg = int('578966293710682886880994035146873798396722250538762761564'
... '9252925514383915483333812743580549779436104706260696366600'
... '571186405732').to_bytes(53, 'big')
...
Nuevo en la versión 3.8.14.
Affected APIs¶
The limitation only applies to potentially slow conversions between int
and str
or bytes
:
int(string)
with default base 10.int(string, base)
for all bases that are not a power of 2.str(integer)
.repr(integer)
.any other string conversion to base 10, for example
f"{integer}"
,"{}".format(integer)
, orb"%d" % integer
.
The limitations do not apply to functions with a linear algorithm:
int(string, base)
with base 2, 4, 8, 16, or 32.Especificación de formato Mini-Lenguaje for hex, octal, and binary numbers.
str
todecimal.Decimal
.
Configuring the limit¶
Before Python starts up you can use an environment variable or an interpreter command line flag to configure the limit:
PYTHONINTMAXSTRDIGITS
, e.g.PYTHONINTMAXSTRDIGITS=640 python3
to set the limit to 640 orPYTHONINTMAXSTRDIGITS=0 python3
to disable the limitation.-X int_max_str_digits
, e.g.python3 -X int_max_str_digits=640
sys.flags.int_max_str_digits
contains the value ofPYTHONINTMAXSTRDIGITS
or-X int_max_str_digits
. If both the env var and the-X
option are set, the-X
option takes precedence. A value of -1 indicates that both were unset, thus a value ofsys.int_info.default_max_str_digits
was used during initialization.
From code, you can inspect the current limit and set a new one using these
sys
APIs:
sys.get_int_max_str_digits()
andsys.set_int_max_str_digits()
are a getter and setter for the interpreter-wide limit. Subinterpreters have their own limit.
Information about the default and minimum can be found in sys.int_info
:
sys.int_info.default_max_str_digits
is the compiled-in default limit.sys.int_info.str_digits_check_threshold
is the lowest accepted value for the limit (other than 0 which disables it).
Nuevo en la versión 3.8.14.
Prudencia
Setting a low limit can lead to problems. While rare, code exists that
contains integer constants in decimal in their source that exceed the
minimum threshold. A consequence of setting the limit is that Python source
code containing decimal integer literals longer than the limit will
encounter an error during parsing, usually at startup time or import time or
even at installation time - anytime an up to date .pyc
does not already
exist for the code. A workaround for source that contains such large
constants is to convert them to 0x
hexadecimal form as it has no limit.
Test your application thoroughly if you use a low limit. Ensure your tests
run with the limit set early via the environment or flag so that it applies
during startup and even during any installation step that may invoke Python
to precompile .py
sources to .pyc
files.
Recommended configuration¶
The default sys.int_info.default_max_str_digits
is expected to be
reasonable for most applications. If your application requires a different
limit, set it from your main entry point using Python version agnostic code as
these APIs were added in security patch releases in versions before 3.11.
Example:
>>> import sys
>>> if hasattr(sys, "set_int_max_str_digits"):
... upper_bound = 68000
... lower_bound = 4004
... current_limit = sys.get_int_max_str_digits()
... if current_limit == 0 or current_limit > upper_bound:
... sys.set_int_max_str_digits(upper_bound)
... elif current_limit < lower_bound:
... sys.set_int_max_str_digits(lower_bound)
If you need to disable it entirely, set it to 0
.
Notas al pie
- 1
Se puede consultar información adicional sobre estos métodos especiales en el Manual de Referencia de Python (Basic customization).
- 2
En consecuencia, la lista
[1, 2]
se considera igual que[1.0, 2.0]
, y de forma similar para las tuplas.- 3
Deben haberlo hecho, ya que el analizador no puede decir el tipo de operandos.
- 4(1,2,3,4)
Los caracteres con versiones mayúsculas/minúsculas son aquellos cuya categoría general corresponde con «Lu» (Letra, Mayúscula), «Ll» (Letra, minúscula) o «Lt» (Letra, titlecase).
- 5(1,2)
Para formatear solo una tupla se debe, por tanto, usar una tupla conteniendo un único elemento, que sería la tupla a ser formateada.