Tuplas (Tuple) en Python

El tuple en Python es similar aLista.La diferencia entre ambos es que, una vez asignado, no se puede cambiar el elemento del tuple, mientras que en una lista, sí se puede cambiar.

Crear un tuple

Crear un tuple poniendo todos los proyectos (elementos) dentro de corchetes () (separados por comas). Los corchetes son opcionales, pero, es una buena práctica usarlos.

Un tuple puede tener cualquier número de elementos y pueden tener diferentes tipos (enteros, números de punto flotante, listas,Cadena等).

También se puede crear un tuple sin usar corchetes. Esto se llama empaque de tupla.

Un poco especial es crear un tuple con un solo elemento.

Crear un tuple con un solo elemento es un poco especial. La coma dentro de los corchetes no es suficiente. Necesitamos una coma al final para indicar que realmente es un tuple.

my_tuple = ("hello")
print(type(my_tuple))          # <class 'str'>
# Crear un tuple con un solo elemento
my_tuple = ("hello",)　　
print(type(my_tuple))          # <class 'tuple'>　
# Los corchetes son opcionales
my_tuple = "hello",
print(type(my_tuple))          # <class 'tuple'>

Acceder a elementos de tupla

Podemos acceder a los elementos del tuple de diversas maneras.

1.índice

Podemos usar el operador de índice [] para acceder a los elementos del tuple que comienzan en 0.

elementos tendrá índices desde 0 hasta6Un tuple de5índice de.6,7 ...) provocará IndexError.

El índice debe ser un entero; por lo tanto, no podemos usar float u otro tipo. Si se hace, causará TypeError.

Del mismo modo, se accede a las tuplas anidadas utilizando un índice anidado, como se muestra en el siguiente ejemplo.

my_tuple = ('p','e','r','m','i','t')
print(my_tuple[0])          # 'p'　
print(my_tuple[5])          # 't'
# IndexError: Índice de lista fuera de rango
# print(my_tuple[6])
# El índice debe ser un entero
# TypeError: El índice de lista debe ser un entero, no un número de punto flotante
# my_tuple[2.0]
# Anidamiento de tuplas
n_tuple = ("mouse", [8,　4,　6], (1,　2,　3))
# Índice anidado
print(n_tuple[0][3])          # 's'
print(n_tuple[1][1])          #　4

2.índice negativo

Python permite que se realice un índice negativo en sus secuencias.

Índice-1Representa el último elemento,-2Representa el segundo último elemento, y así sucesivamente.

my_tuple = ('p','e','r','m','i','t')
# Salida: 't'
print(my_tuple[-1])
# Salida: 'p'
print(my_tuple[-6])

3.cortar

Podemos usar el operador-El carácter de dos puntos “:” para acceder a una serie de proyectos en una tupla.

my_tuple = ('p','r','o','g','r','a','m','i','z')
# El2elementos-4elementos
# Salida:　('r',　'o',　'g')
print(my_tuple[1:4])
# Desde el principio hasta el segundo elemento
# Salida:　('p',　'r')
print(my_tuple[:-7])
# El8elementos hasta el final
# Salida:　('i',　'z')
print(my_tuple[7:])
# Desde el principio hasta el final de los elementos
# Salida:　('p',　'r',　'o',　'g',　'r',　'a',　'm',　'i',　'z')
print(my_tuple[:])

Considerando la ubicación del índice entre los elementos, se puede visualizar mejor el recorte, como se muestra a continuación. Por lo tanto, si se desea acceder a un rango, se deben usar los índices de la parte recortada de la tupla.

Cambiar tupla

Diferente de las listas, las tuplas son inmutables.

Esto significa que una vez que se asignen los elementos de una tupla, no se pueden cambiar. Sin embargo, si los elementos en sí mismos son tipos de datos variables (como listas), se pueden cambiar sus proyectos anidados.

También podemos asignar una tupla a diferentes valores (reasignar).

my_tuple = (4,　2,　3,　[6,　5])
# TypeError: El objeto 'tupla' no admite la asignación de elementos
# my_tuple[1]　=　9
# Sin embargo, los elementos variables pueden cambiar
my_tuple[3][0]　=　9　　　　# Salida:　(4,　2,　3,　[9,　5])
print(my_tuple)
# Las tuplas pueden ser reasignadas
my_tuple = ('p','r','o','g','r','a','m','i','z')
# Salida:　('p',　'r',　'o',　'g',　'r',　'a',　'm',　'i',　'z')
print(my_tuple)

Podemos usar+para combinar dos tuplas. Esto también se llamaoperador de conexión。

También podemos usar el operador*，vamos a repetir los elementos de la tuplarepetirel número de veces dado.

sin importar+y*La operación causará un nuevo registro.

# Conectar
# Salida:　(1,　2,　3,　4,　5,　6)
print(((1,　2,　3)　+　(4,　5,　6))
# Repetir
# Salida:　('Repeat',　'Repeat',　'Repeat')
print(("Repeat",)　*　3)

Eliminar tupla

Como se mencionó anteriormente, no podemos cambiar los elementos de una tupla. Esto también significa que no podemos eliminar ni eliminar proyectos de una tupla.

pero se puede usar la palabra clavedelEliminar completamente una tupla.

my_tuple = ('p','r','o','g','r','a','m','i','z')
# No se puede eliminar elementos
# TypeError: El objeto 'tupla' no admite la eliminación de elementos
# del my_tuple[3]
# Puede eliminar todo el tupla
del my_tuple
# ErrorName: Nombre no definido “my_tuple”
print(my_tuple)

Tuple methods

Tuples do not provide methods to add or delete items. Only the following two methods are available.

Some examples of Python tuple methods:

my_tuple　=　('a','p','p','l','e',)
print(my_tuple.count('p'))　　#　Output:　2
print(my_tuple.index('l'))　　#　Output:　3

Other tuple operations

1.Member qualification test

We can use the keyword 'in' to test whether an item exists in the tuple.

my_tuple　=　('a','p','p','l','e',)
#　In　operation
#　Output:　True
print('a'　in　my_tuple)
#　Output:　False
print('b'　in　my_tuple)
#　Not　in　operation
#　Output:　True
print('g'　not　in　my_tuple)

2.Traverse tuple

Using a for loop, we can traverse each item in the tuple.

#　Output:　
#　Hello　John
#　Hello　Kate
for　name　in　('John','Kate'):
　　　　　print("Hello", name)

Advantages of tuples over lists

Since tuples are very similar to lists, they are also used in similar situations.

However, implementing tuples on lists has certain advantages. The following lists some of the main advantages:

• We usually use tuples for heterogeneous (different) data types and lists for homogeneous (similar) data types.

• Since tuples are immutable, iterating over a tuple is faster than using a list. Therefore, there is a slight performance improvement.

• Tuples containing immutable elements can be used as dictionary keys. This is not possible for lists.

• If you have immutable data, implementing it as a tuple will ensure it remains write-protected.