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: ':)'