Puedes usar el método sort() para ordenar los elementos de una lista, por
ejemplo:
1
2
3
4
5
6
lst = [5, 3, 1, 2, 4]
print(lst)
lst.sort()
print(lst) # output: [1, 2, 3, 4, 5]
2.También hay un método de lista llamado reverse(), que puedes usar para
invertir la lista, por ejemplo:
1
2
3
4
5
6
lst = [5, 3, 1, 2, 4]
print(lst)
lst.reverse()
print(lst) # output: [4, 2, 1, 3, 5]
Si tienes una lista list_1, y la siguiente asignación: list_2 = list_1 esto no
hace una copia de la lista list_1, pero hace que las variables list_1 y list_2
apunten a la misma lista en la memoria. Por ejemplo:
1
2
3
4
5
6
7
vehicles_one = ['coche', 'bicicleta', 'motor']
print(vehicles_one) # output: ['coche', 'bicicleta', 'motor']
vehicles_two = vehicles_one
del vehicles_one[0] # elimina 'coche'
print(vehicles_two) # output: ['bicicleta', 'motor']
2. Si deseas copiar una lista o parte de la lista, puedes hacerlo haciendo uso de
rebanadas:
1
2
3
4
5
colors = ['rojo', 'verde', 'naranja']
copy_whole_colors = colors[:] # copia la lista entera
copy_part_colors = colors[0:2] # copia parte de la lista
3. También puede utilizar índices negativos para hacer uso de rebanadas. Por
ejemplo:
1
2
3
4
sample_list = ["A", "B", "C", "D", "E"]
new_list = sample_list[2:-1]
print(new_list) # output: ['C', 'D']
4. Los parámetros start y end son opcionales al partir en rebanadas una lista:
list[start:end], por ejemplo:
1
2
3
4
5
6
7
8
9
my_list = [1, 2, 3, 4, 5]
slice_one = my_list[2: ]
slice_two = my_list[ :2]
slice_three = my_list[-2: ]
print(slice_one) # output: [3, 4, 5]
print(slice_two) # output: [1, 2]
print(slice_three) # output: [4, 5]
5. Puedes eliminar rebanadas utilizando la instrucción del:
1
2
3
4
5
6
7
my_list = [1, 2, 3, 4, 5]
del my_list[0:2]
print(my_list) # output: [3, 4, 5]
del my_list[:]
print(my_list) # elimina el contenido de la lista, genera: []
6. Puedes probar si algunos elementos existen en una lista o no utilizando las
palabras clave in y not in, por ejemplo:
1
2
3
4
5
6
my_list = ["A", "B", 1, 2]
print("A" in my_list) # output: True
print("C" not in my_list) # output: True
print(2 not in my_list) # output: False
1. La comprensión de listas te permite crear nuevas listas a partir de las existentes de una
manera concisa y elegante. La sintaxis de una comprensión de lista es la siguiente:
[expresión para el elemento en la lista si es condicional]
El cual es un equivalente del siguiente código:
for element in list:
if conditional:
expression
Este es un ejemplo de una comprensión de lista - el código siguiente crea una lista de cinco
elementos con los primeros cinco números naturales elevados a la potencia de 3:
1
2
3
cubed = [num ** 3 for num in range(5)]
print(cubed) # output: [0, 1, 8, 27, 64]
2. Puedes usar listas anidadas en Python para crear matrices (es decir, listas
bidimensionales). Por ejemplo:
1
2
3
4
5
6
7
8
9
10
11
# Una tabla de cuatro columnas y cuatro filas: un arreglo
bidimensional (4x4)
table = [[":(", ":)", ":(", ":)"],
[":)", ":(", ":)", ":)"],
[":(", ":)", ":)", ":("],
[":)", ":)", ":)", ":("]]
print(table)
print(table[0][0]) # output: ':('
print(table[0][3]) # output: ':)'
3. Puedes anidar tantas listas en las listas como desee y, por lo tanto, crear listas
n-dimensionales, por ejemplo, arreglos de tres, cuatro o incluso sesenta y cuatro
dimensiones. Por ejemplo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# Cubo - un arreglo tridimensional (3x3x3)
cube = [[[':(', 'x', 'x'],
[':)', 'x', 'x'],
[':(', 'x', 'x']],
[[':)', 'x', 'x'],
[':(', 'x', 'x'],
[':)', 'x', 'x']],
[[':(', 'x', 'x'],
[':)', 'x', 'x'],
[':)', 'x', 'x']]]
print(cube)
print(cube[0][0][0]) # output: ':('
print(cube[2][2][0]) # output: ':)'
