En el tutorial anterior , aprendimos sobre la sintaxis básica y varios elementos del lenguaje Python. Python ofrece seis tipos de secuencias: cadenas, bytes, matrices de bytes, rangos, tuplas y listas.
Es importante señalar que las cadenas, bytes, rangos y tuplas son secuencias inmutables que no se pueden modificar una vez definidas. Sólo puedes crear o destruir estas secuencias. Esto deja las listas de bytes y las matrices como las únicas secuencias mutables.
Python también admite colecciones desordenadas, como conjuntos, conjuntos congelados y diccionarios. Los conjuntos congelados son inmutables y los conjuntos y diccionarios son colecciones mutables. Además, las estructuras de datos definidas por el usuario se pueden definir como clases y siempre son mutables.
Las secuencias y colecciones inmutables son útiles cuando es necesario utilizar ciertos valores de datos en todo el código. Las secuencias y colecciones mutables son útiles para mantener valores de datos relacionados que se pueden agrupar por motivos específicos. Dado que los valores de datos en una secuencia/colección mutable se pueden modificar en cualquier parte del código, se utilizan idealmente para la manipulación y el procesamiento de datos. Después de todo, en cualquier programa estamos manipulando y procesando valores de datos.
Normalmente, usaremos secuencias o colecciones (desordenadas) de valores de datos en la mayoría de las aplicaciones. Por lo tanto, es esencial comprender cómo se pueden modificar y manipular los valores de datos en estas secuencias/colecciones mutables. Las listas, matrices de bytes, conjuntos y diccionarios están disponibles como secuencias/colecciones mutables de Python. Repasemos cada uno.
Liza
Las listas son una colección ordenada y mutable de elementos. Los elementos de una lista son arbitrarios y pueden ser de cualquier tipo. Una lista se define mediante un constructor de listas o mediante el uso de un par de corchetes ().
También puede agregar, eliminar y modificar elementos de una lista. Se puede acceder a estos elementos mediante claves enteras o índices. La clave o índice de elementos de una lista comienza desde cero. Por lo tanto, el primer elemento tiene una clave o índice de 0. Esto significa que si "x" es una lista, se puede acceder a sus elementos como x(y) donde y es la clave/índice del elemento al que se accede. Si se utiliza un índice negativo, se accederá al elemento desde el final de la lista en lugar de desde el principio.
Al final de la lista, los índices comienzan en -1.
Por ejemplo:
X = (1, 2, 3, 4)
X(1) # Devuelve 2
X(-1) #Devuelve 4
Se pueden modificar uno o más elementos de una lista, individualmente o mediante un segmento. Para hacer esto individualmente, acceda al elemento de la lista como referencia de destino en una tarea o tarea aumentada de la siguiente manera:
X = (1, 2, 3, 4)
X(1) = 'uno' # x = (1, 'uno', 3, 4)
X(2) += 22 # x = (1, a, 25, 4)
Cuando se utiliza una asignación aumentada para modificar un elemento de la lista, el tipo de datos de la expresión RHS debe ser el mismo que el de los elementos. De lo contrario, el resultado será un error semántico.
También se pueden modificar juntos varios elementos de una lista utilizando el operador de división como referencia de destino en una declaración de asignación como esta:
X = (1, 2, 3, 4)
X(1:3) = (22, 33) # x = (1, 22, 33, 4)
Un segmento x(a:b) modificará todos los elementos con un índice entre a y b-1 en la lista "x", pero no "b". El sector se puede asignar a cualquier iterable. Si el sector se asigna a un iterable con menos elementos que el sector, los elementos no asignados se eliminan de la lista. Si el sector se asigna a un iterable con más elementos que el sector, los elementos adicionales se agregan después del último elemento del sector.
Aquí hay un ejemplo:
X = (1, 2, 3, 4)
X(1:3) = (22) # x = (1, 22, 4)
X = (1, 2, 3, 4)
X(1:3) = (22, 33, 44) # x = (1, 22, 33, 44, 4)
Si un segmento vacío x(a:a) recibe ciertos valores/objetos de datos, esos valores/objetos se agregarán antes del elemento con índice “a: en la lista “x”. De manera similar, un segmento puede cubrir toda la lista y volver a vincularle nuevos valores/objetos utilizando la expresión x(:) como referencia de destino para la lista "x".
Considere este ejemplo:
X = (1, 2, 3, 4)
X(1:1) = (22) # x = (1, 22, 2, 3, 4)
X = (1, 2, 3, 4)
X(:) = (22, 33, 44) # x = (22, 33, 44)
Cualquier elemento o porción de elementos se puede eliminar de una lista utilizando la declaración "del". Aquí, un operador de corte también puede usar el paso para omitir la eliminación de elementos en un intervalo regular.
Aquí hay unos ejemplos:
X = (1, 2, 3, 4, 5, 6, 7, 8, 9)
delX(8)#x = (1, 2, 3, 4, 5, 6, 7, 8)
delX(4:6) # x = (1, 2, 3, 4, 7, 8)
delX(4:) # x = (1, 2, 3, 4)
delX(::2) # x = (2, 4)
Las listas tienen estos métodos:
Estos métodos se pueden aplicar a listas utilizando la sintaxis list_name.method_name. Aquí hay un ejemplo:
x = ('león', 'tigre')=
x.append('elefante') # x = ('león', 'tigre', 'elefante')
x.insert(0, 'leopardo') # x = ('leopardo', 'tigre', 'elefante')
x.extend(('gato', 'serpiente')) # x = ('leopardo', 'tigre', 'elefante', 'gato', 'serpiente')
x.remove('serpiente') # x = ('leopardo', 'tigre', 'elefante', 'gato')
x.pop(0) # x = ('tigre', 'elefante', 'gato')
x.index('gato') # devuelve 2
y = x.copia #y = ('tigre', 'elefante', 'gato')
x.count('gato') # devuelve 1
x.count('león') # devuelve 0
x.sort #x = ('gato', 'elefante', 'tigre')
definición f(e):
longitud de retorno(e)
x.sort(clave = f) # x = ('gato', 'tigre', 'elefante')
x.reverse #x = ('elefante', tigre, 'gato')
por supuesto#x=
Estas funciones integradas aceptan listas como argumentos:
Se puede pasar una lista como argumento a la función len para obtener el tamaño de esa lista. Aquí hay un ejemplo:
x = (1, 2, 3, 4)
len(x) #devuelve 4
Esta tabla resume las operaciones de listas comunes que utilizan operadores, declaraciones, métodos o funciones:
Cadenas, bytes y matrices de bytes
Las cadenas son una secuencia inmutable de caracteres Unicode (Python V3) o ASCII (Python V2). Los bytes son una secuencia inmutable de bytes. Las matrices de bytes son una secuencia mutable de bytes.
Las cadenas se definen como secuencias de caracteres Unicode/ASCII entre comillas simples, dobles o triples. Cualquier elemento de un iterable destinado a ser utilizado como cadena debe ir entre comillas. De lo contrario, Python lo tratará como un identificador y asumirá que es una referencia.
Aquí hay un ejemplo:
x = ('a', 'b', 'c')
un = 12
segundo = 10
c = 11
y = (a, b, c)
imprimir(x) # Imprimir ('a', 'b', 'c')
imprimir(y) # Impresiones (12, 10, 11)
Las cadenas son secuencias inmutables. Esto significa que no puede agregar, eliminar o modificar ningún elemento (carácter Unicode/ASCII) de una cadena accediendo a su índice. Entonces estas son declaraciones inválidas :
x = “Python”
x(0) = “J” #INVÁLIDO
delx(0) #INVÁLIDO
Sin embargo, es posible realizar manipulación de cadenas utilizando métodos construidos, funciones y funciones definidas por el usuario. Los caracteres similares en un objeto de cadena se pueden reemplazar usando la función de reemplazo.
Mira este ejemplo:
x = 'PPython'
x = x.reemplazar(“P”, “J”)
imprimir (x)
Los bytes se definen mediante la función de bytes o anteponiendo "b" antes de una cadena de bytes. Los bytes también son secuencias inmutables. No puede agregar, eliminar o modificar bytes en un objeto de bytes accediendo a ellos desde su índice. A continuación se muestran ejemplos válidos de objetos de bytes:
x = b“Python”
x = byte (“Python”)
Las matrices de bytes son una versión mutable de bytes. Se pueden configurar usando la función bytearray. Estos son ejemplos válidos de bytes y matrices de bytes:
x = bytearray(“Python”, 'utf-8') #cadena definida como matriz de bytes
x = bytearray(b“Python”)
x = matriz de bytes((1, 2, 3, 4, 5,))
x = bytearray # bytearray vacío
Si una cadena se define como una matriz de bytes utilizando la función bytearray, la cadena debe estar entre comillas y la codificación debe pasarse como argumento. A diferencia de los bytes, las matrices de bytes son mutables, lo que significa que puede agregar, eliminar o modificar elementos (bytes) en una matriz de bytes accediendo a ellos a través de su índice.
Sin embargo, solo se puede acceder a los elementos de una matriz de bytes a través de un operador de división. Este es un ejemplo no válido de modificación de la matriz de bytes:
x = bytearray(b”Python”)
imprimir (x)
x(0) = b”J” #INVÁLIDO
imprimir (x)
A continuación se muestra un ejemplo válido de modificación de la matriz de bytes:
x = bytearray(b”Python”)
print(x) #retorna bytearray(b'Python')
x(0:1) = b”J”
print(x) #devuelve bytearray(b'Jython')
El siguiente ejemplo muestra cómo agregar, eliminar, modificar y agregar bytes en una matriz de bytes:
x = bytearray(b”Python”)
imprimir (x)
x(6:) = b” es divertido” #agregar elementos a la matriz de bytes mediante asignación
print(x) #prints bytearray(b'Python es divertido')
x.append(110) #agregar elementos a la matriz de bytes
x.añadir(121)
print(x) #prints bytearray(b'Python es divertido')
x(6 
=b”” #eliminar elementos en la matriz de bytes por asignación
print(x) #prints bytearray(b'Python es divertido')
x(6:) = b”Objetos”
print(x) #imprime bytearray(b'Objetos Python')
del x(6:) #eliminar elementos en la matriz de bytes mediante la instrucción del
print(x) #imprime bytearray(b'Python')
Asegúrate de probar todos estos códigos de ejemplo en tu Raspberry Pi.
En el próximo tutorial discutiremos cómo manipular valores de datos en conjuntos y diccionarios.
