Python Language Lista de métodos y operadores soportados.


Ejemplo

Comenzando con una lista dada a :

a = [1, 2, 3, 4, 5]
  1. append(value) : agrega un nuevo elemento al final de la lista.

    # Append values 6, 7, and 7 to the list
    a.append(6)
    a.append(7)
    a.append(7)
    # a: [1, 2, 3, 4, 5, 6, 7, 7]
    
    # Append another list
    b = [8, 9]
    a.append(b)
    # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]
    
    # Append an element of a different type, as list elements do not need to have the same type
    my_string = "hello world"
    a.append(my_string)
    # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9], "hello world"]
    

    Tenga en cuenta que el método append() solo agrega un elemento nuevo al final de la lista. Si agrega una lista a otra, la lista que agregue se convertirá en un elemento único al final de la primera lista.

    # Appending a list to another list
    a = [1, 2, 3, 4, 5, 6, 7, 7]
    b = [8, 9]
    a.append(b)
    # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]
    a[8]
    # Returns: [8,9]
    
  2. extend(enumerable) : extiende la lista agregando elementos de otro enumerable.

    a = [1, 2, 3, 4, 5, 6, 7, 7]
    b = [8, 9, 10]
    
    # Extend list by appending all elements from b
    a.extend(b)
    # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
    
    # Extend list with elements from a non-list enumerable:
    a.extend(range(3))
    # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10, 0, 1, 2]
    

    Las listas también se pueden concatenar con el operador + . Tenga en cuenta que esto no modifica ninguna de las listas originales:

    a = [1, 2, 3, 4, 5, 6] + [7, 7] + b
    # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
    
  3. index(value, [startIndex]) índice de inicio index(value, [startIndex]) : obtiene el índice de la primera aparición del valor de entrada. Si el valor de entrada no está en la lista, se ValueError una excepción ValueError . Si se proporciona un segundo argumento, la búsqueda se inicia en ese índice especificado.

    a.index(7)
    # Returns: 6
    
    a.index(49) # ValueError, because 49 is not in a.
    
    a.index(7, 7)
    # Returns: 7
    
    a.index(7, 8) # ValueError, because there is no 7 starting at index 8
    
  1. insert(index, value) : inserta un value justo antes del index especificado. Así después de la inserción el nuevo elemento ocupa el index posición.

    a.insert(0, 0)  # insert 0 at position 0
    a.insert(2, 5)  # insert 5 at position 2
    # a: [0, 1, 5, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
    
  1. pop([index]) : elimina y devuelve el elemento en el index . Sin ningún argumento, elimina y devuelve el último elemento de la lista.

    a.pop(2)
    # Returns: 5
    # a: [0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
    a.pop(8)
    # Returns: 7
    # a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    
    # With no argument:
    a.pop()
    # Returns: 10
    # a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
  2. remove(value) : elimina la primera aparición del valor especificado. Si no se puede encontrar el valor proporcionado, se ValueError un ValueError .

    a.remove(0)
    a.remove(9)
    # a: [1, 2, 3, 4, 5, 6, 7, 8]
    a.remove(10)
    # ValueError, because 10 is not in a
    
  3. reverse() : invierte la lista en el lugar y devuelve None .

    a.reverse()
    # a: [8, 7, 6, 5, 4, 3, 2, 1]
    

    También hay otras formas de revertir una lista .

  4. count(value) : cuenta el número de apariciones de algún valor en la lista.

    a.count(7)
    # Returns: 2
    
  5. sort() : ordena la lista en orden numérico y lexicográfico y devuelve None .

    a.sort()
    # a = [1, 2, 3, 4, 5, 6, 7, 8]
    # Sorts the list in numerical order
    

    Las listas también se pueden revertir cuando se ordenan usando la reverse=True en el método sort() .

    a.sort(reverse=True)
    # a = [8, 7, 6, 5, 4, 3, 2, 1]
    

    Si desea ordenar por atributos de elementos, puede usar el argumento de palabra key clave:

    import datetime
    
    class Person(object):
        def __init__(self, name, birthday, height):
            self.name = name
            self.birthday = birthday
            self.height = height
    
        def __repr__(self):
            return self.name
    
    l = [Person("John Cena", datetime.date(1992, 9, 12), 175),
         Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
         Person("Jon Skeet", datetime.date(1991, 7, 6), 185)]
    
    l.sort(key=lambda item: item.name)
    # l: [Chuck Norris, John Cena, Jon Skeet]
    
    l.sort(key=lambda item: item.birthday)
    # l: [Chuck Norris, Jon Skeet, John Cena]
    
    l.sort(key=lambda item: item.height)
    # l: [John Cena, Chuck Norris, Jon Skeet]
    

    En caso de lista de dictados el concepto es el mismo:

    import datetime
    
    l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'height': 175},
     {'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'height': 180},
     {'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'height': 185}]
    
    l.sort(key=lambda item: item['name'])
    # l: [Chuck Norris, John Cena, Jon Skeet]
    
    l.sort(key=lambda item: item['birthday'])
    # l: [Chuck Norris, Jon Skeet, John Cena]
    
    l.sort(key=lambda item: item['height'])
    # l: [John Cena, Chuck Norris, Jon Skeet]
    

    Ordenar por subdivisión:

    import datetime
    
    l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'size': {'height': 175, 'weight': 100}},
     {'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'size' : {'height': 180, 'weight': 90}},
     {'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'size': {'height': 185, 'weight': 110}}]
    
    l.sort(key=lambda item: item['size']['height'])
    # l: [John Cena, Chuck Norris, Jon Skeet]
    

Mejor manera de ordenar usando attrgetter y itemgetter

Las listas también se pueden clasificar utilizando las funciones attrgetter y itemgetter del módulo del operador. Estos pueden ayudar a mejorar la legibilidad y la reutilización. Aquí hay unos ejemplos,

from operator import itemgetter,attrgetter

people = [{'name':'chandan','age':20,'salary':2000},
          {'name':'chetan','age':18,'salary':5000},
          {'name':'guru','age':30,'salary':3000}]
by_age = itemgetter('age')
by_salary = itemgetter('salary')

people.sort(key=by_age) #in-place sorting by age
people.sort(key=by_salary) #in-place sorting by salary

itemgetter también se puede dar un índice. Esto es útil si desea ordenar según los índices de una tupla.

list_of_tuples = [(1,2), (3,4), (5,0)]
list_of_tuples.sort(key=itemgetter(1))
print(list_of_tuples) #[(5, 0), (1, 2), (3, 4)]

Utilice el attrgetter si desea ordenar por atributos de un objeto,

persons = [Person("John Cena", datetime.date(1992, 9, 12), 175),
           Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
           Person("Jon Skeet", datetime.date(1991, 7, 6), 185)] #reusing Person class from above example

person.sort(key=attrgetter('name')) #sort by name
by_birthday = attrgetter('birthday')
person.sort(key=by_birthday) #sort by birthday
  1. clear() : elimina todos los elementos de la lista

    a.clear()
    # a = []
    
  2. Replicación : multiplicar una lista existente por un número entero producirá una lista más grande que consiste en tantas copias del original. Esto puede ser útil, por ejemplo, para la inicialización de listas:

    b = ["blah"] * 3
    # b = ["blah", "blah", "blah"]
    b = [1, 3, 5] * 5
    # [1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5]
    

    Tenga cuidado al hacer esto si su lista contiene referencias a objetos (por ejemplo, una lista de listas), vea Errores comunes: multiplicación de listas y referencias comunes .

  3. Eliminación de elementos : es posible eliminar varios elementos de la lista utilizando la palabra clave del y la notación de segmento:

    a = list(range(10))
    del a[::2]
    # a = [1, 3, 5, 7, 9]
    del a[-1]
    # a = [1, 3, 5, 7]
    del a[:]
    # a = []
    
  4. Proceso de copiar

    La asignación predeterminada "=" asigna una referencia de la lista original al nuevo nombre. Es decir, el nombre original y el nuevo nombre apuntan al mismo objeto de lista. Los cambios realizados a través de cualquiera de ellos se reflejarán en otro. Esto a menudo no es lo que pretendías.

    b = a
    a.append(6)
    # b: [1, 2, 3, 4, 5, 6]
    

    Si desea crear una copia de la lista, tiene las siguientes opciones.

    Puedes cortarlo:

    new_list = old_list[:]
    

    Puedes usar la función integrada en la lista ():

    new_list = list(old_list)
    

    Puedes usar copy.copy genérico ():

    import copy
    new_list = copy.copy(old_list) #inserts references to the objects found in the original.
    

    Esto es un poco más lento que list () porque primero tiene que averiguar el tipo de datos de old_list.

    Si la lista contiene objetos y también desea copiarlos, use copy.deepcopy genérico ():

    import copy
    new_list = copy.deepcopy(old_list) #inserts copies of the objects found in the original.
    

    Obviamente, el método más lento y que más memoria necesita, pero a veces inevitable.

Python 3.x 3.0

copy() - Devuelve una copia superficial de la lista

    aa = a.copy()
    # aa = [1, 2, 3, 4, 5]