Списки

Введение

Примеры

  • 19

    Доступ к значениям списка

    Списки Python имеют нулевую индексацию и действуют как массивы в других языках.

     lst = [1, 2, 3, 4]
    lst[0]  # 1
    lst[1]  # 2
    
     

    Попытка получить доступ к индексу за пределы списка возбудит IndexError .

     lst[4]  # IndexError: list index out of range
    
     

    Отрицательные показатели интерпретируются как отсчет от конца списка.

     lst[-1]  # 4
    lst[-2]  # 3
    lst[-5]  # IndexError: list index out of range
    
     

    Это функционально эквивалентно

     lst[len(lst)-1]  # 4
    
     

    Списки позволяют использовать ломтик обозначение , как lst[start:end:step] . Выход среза обозначений представляет собой новый список , содержащий элементы из индекса start до end-1 . Если параметры опущены start значения по умолчанию для начала списка, end в конец списка и step 1:

     lst[1:]      # [2, 3, 4]
    lst[:3]      # [1, 2, 3]
    lst[::2]     # [1, 3]
    lst[::-1]    # [4, 3, 2, 1] 
    lst[-1:0:-1] # [4, 3, 2]
    lst[5:8]     # [] since starting index is greater than length of lst, returns empty list
    lst[1:10]    # [2, 3, 4] same as omitting ending index
    
     

    Имея это в виду, вы можете распечатать обратную версию списка, вызвав

     lst[::-1]    # [4, 3, 2, 1]
    
     

    При использовании длин шагов с отрицательными значениями начальный индекс должен быть больше конечного индекса, в противном случае результатом будет пустой список.

     lst[3:1:-1] # [4, 3]
    
     

    Использование индексов отрицательных шагов эквивалентно следующему коду:

     reversed(lst)[0:2] # 0 = 1 -1
                       # 2 = 3 -1
    
     

    Используемые индексы на 1 меньше, чем используемые при отрицательной индексации, и обращены.

    Продвинутая нарезка

    Когда списки нарезали __getitem__() метод объекта списка называется, с slice объектом. В Python есть встроенный метод среза для генерации объектов среза. Мы можем использовать это , чтобы сохранить кусочек и использовать его позже , как это так,

     data = 'chandan purohit    22 2000'  #assuming data fields of fixed length 
    name_slice = slice(0,19)
    age_slice = slice(19,21)
    salary_slice = slice(22,None)
    
    #now we can have more readable slices
    print(data[name_slice]) #chandan purohit     
    print(data[age_slice]) #'22'
    print(data[salary_slice]) #'2000'
    
     

    Это может быть очень полезным, предоставляя функциональность для нарезки наших объектов путем переопределения __getitem__ в нашем классе.

  • 30

    Список методов и поддерживаемых операторов

    Начиная с данным списком a :

     a = [1, 2, 3, 4, 5]
    
     
    1. append(value) - добавляет новый элемент в конец списка.

       # 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"]
      
       

      Обратите внимание , что append() метод только добавляет один новый элемент в конец списка. Если вы добавляете список в другой список, добавляемый вами список становится единым элементом в конце первого списка.

       # 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) - расширяет список путем добавления элементов из другого перечислим.

       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]
      
       

      Списки также могут быть объединены с + оператора. Обратите внимание, что это не изменяет ни один из исходных списков:

       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]) - получает индекс первого вхождения значения входного сигнала. Если входное значение не в таком перечне ValueError исключения. Если указан второй аргумент, поиск начинается с указанного индекса.

       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) - вставляет value непосредственно перед указанным index . Таким образом , после вставки нового элемента занимает позицию index .

       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]) - Удаляет и возвращает элемент index . Без аргументов удаляет и возвращает последний элемент списка.

       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) - удаляет первое вхождение заданного значения. Если прилагаемое значение не может быть найдено, 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() - изменяет список на месте и не возвращает None .

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

      Есть также другие способы реверсирования списка .

    4. count(value) - подсчитывает количество вхождений некоторого значения в списке.

       a.count(7)
      # Returns: 2 
    5. sort() - сортирует список в числовом и лексикографическом порядке и возвращает None .

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

      Списки также могут быть отменены при сортировке с помощью reverse=True , флага в своем sort() методе.

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

      Если вы хотите сортировать по атрибутам элементов, вы можете использовать key ключевого слова аргумента:

       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]
      
       

      В случае списка диктов концепция одинакова:

       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]
      
       

      Сортировать по sub dict:

       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] 

    Лучший способ разобраться с помощью attrgetter и itemgetter

    Списки также могут быть отсортированы с помощью attrgetter и itemgetter функции из модуля оператора. Это может помочь улучшить читаемость и возможность повторного использования. Вот несколько примеров,

     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 также может быть дан индекс. Это полезно, если вы хотите сортировать на основе индексов кортежа.

     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)]
    
     

    Используйте attrgetter , если вы хотите сортировать по атрибутам объекта,

     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() - удаляет все элементы из списка

       a.clear()
      # a = [] 
    2. Репликация - умножая существующий список на целое число будет производить больший список , состоящий из того, что многие копии оригинала. Это может быть полезно, например, для инициализации списка:

       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]
      
       

      Позаботьтесь делать это , если список содержит ссылки на объекты (например , список списков), см Общие Ловушки - Список умножения и общие ссылки .

    3. Удаление элемента - можно удалить несколько элементов в списке , используя del ключевые слова и ломтик обозначение:

       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. копирование

      Назначение по умолчанию "=" назначает ссылку на исходный список новому имени. Таким образом, исходное имя и новое имя указывают на один и тот же объект списка. Изменения, сделанные с помощью одного из них, будут отражены в другом Это часто не то, что вы хотели.

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

      Если вы хотите создать копию списка, у вас есть варианты ниже.

      Вы можете нарезать это:

       new_list = old_list[:]
      
       

      Вы можете использовать встроенную функцию list ():

       new_list = list(old_list)
      
       

      Вы можете использовать универсальный copy.copy ():

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

      Это немного медленнее, чем list (), потому что он должен сначала выяснить тип данных old_list.

      Если список содержит объекты, и вы также хотите скопировать их, используйте generic copy.deepcopy ():

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

      Очевидно, самый медленный и самый требующий памяти метод, но иногда неизбежный.

    copy() - возвращает неполную копию списка

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

    Длина списка

    Используйте len() , чтобы получить одномерный длину списка.

     len(['one', 'two'])  # returns 2
    
    len(['one', [2, 3], 'four'])  # returns 3, not 4
    
     

    len() также работает на струнах, словарей и других структур данных , подобных списков.

    Обратите внимание , что len() является встроенной функцией, а не метод объекта списка.

    Также обратите внимание , что стоимость len() является O(1) , то есть он будет принимать такое же количество времени , чтобы получить длину списка , независимо от его длины.

  • 6

    Перебор списка

    Python поддерживает используя for петли непосредственно на список:

     my_list = ['foo', 'bar', 'baz']
    for item in my_list:
        print(item)
    
    # Output: foo
    # Output: bar
    # Output: baz
    
     

    Вы также можете получить позицию каждого элемента одновременно:

     for (index, item) in enumerate(my_list):
        print('The item in position {} is: {}'.format(index, item))
    
    # Output: The item in position 0 is: foo
    # Output: The item in position 1 is: bar
    # Output: The item in position 2 is: baz
     

    Другой способ итерации списка на основе значения индекса:

     for i in range(0,len(my_list)):
        print(my_list[i])
    #output:
    >>>
    foo
    bar
    baz
    
     

    Обратите внимание, что изменение элементов в списке во время итерации может привести к неожиданным результатам:

     for item in my_list:
        if item == 'foo':
            del my_list[0]
        print(item)
    
    # Output: foo
    # Output: baz
    
     

    В этом последнем примере, мы удалили первый элемент в первой итерации, но это вызвало bar , который следует пропустить.

  • 6

    Проверка наличия элемента в списке

    Python позволяет очень просто проверить, есть ли элемент в списке. Просто используйте in операторе.

     lst = ['test', 'twest', 'tweast', 'treast']
    
    'test' in lst
    # Out: True
    
    'toast' in lst
    # Out: False
    
     

    Примечание: in оператора на множествах асимптотически быстрее , чем в списках. Если вам нужно использовать его много раз на потенциально большие списках, вы можете превратить ваш list в set , и проверить наличие элементов на set .

     slst = set(lst)
    'test' in slst
    # Out: True 
  • 4

    Сторнирование элементов списка

    Вы можете использовать reversed функцию , которая возвращает итератор обращенного списка:

     In [3]: rev = reversed(numbers)
    
    In [4]: rev
    Out[4]: [9, 8, 7, 6, 5, 4, 3, 2, 1]
    
     

    Обратите внимание, что список «чисел» остается неизменным этой операцией и остается в том же порядке, в котором он был изначально.

    Чтобы изменить на месте, вы можете также использовать в reverse метод .

    Вы также можете изменить список (фактически получая копию, исходный список не затрагивается), используя синтаксис срезов, задав третий аргумент (шаг) как -1:

     In [1]: numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    In [2]: numbers[::-1]
    Out[2]: [9, 8, 7, 6, 5, 4, 3, 2, 1]
    
    
     
  • 7

    Проверка, если список пуст

    Пустота списка связан с булево значение False , так что вы не должны проверить len(lst) == 0 , а только lst или not lst

     lst = []
    if not lst:
        print("list is empty")
    
    # Output: list is empty 
  • 4

    Объединить и объединить списки

    1. Самый простой способ конкатенации list1 и list2 :

       merged = list1 + list2 
    2. zip возвращает список кортежей, где I-й кортеж содержит I-й элемент из каждого из аргументов последовательностей или итерируемыми:

       alist = ['a1', 'a2', 'a3']
      blist = ['b1', 'b2', 'b3']
      
      for a, b in zip(alist, blist):
          print(a, b)
      
      # Output:
      # a1 b1
      # a2 b2
      # a3 b3
      
       

      Если списки имеют разную длину, результат будет включать в себя столько элементов, сколько самый короткий:

       alist = ['a1', 'a2', 'a3']
      blist = ['b1', 'b2', 'b3', 'b4']
      for a, b in zip(alist, blist):
          print(a, b)
      
      # Output:
      # a1 b1
      # a2 b2
      # a3 b3
      
      alist = []
      len(list(zip(alist, blist)))
      
      # Output:
      # 0
      
       

      Для заполнения списков неравной длины к самой длинной один с None S Использовать itertools.zip_longest ( itertools.izip_longest в Python 2)

       alist = ['a1', 'a2', 'a3']
      blist = ['b1']
      clist = ['c1', 'c2', 'c3', 'c4']
      
      for a,b,c in itertools.zip_longest(alist, blist, clist):
          print(a, b, c)
      
      # Output: 
      # a1 b1 c1
      # a2 None c2
      # a3 None c3
      # None None c4 
    1. Вставить в определенный индекс значения:

        alist = [123, 'xyz', 'zara', 'abc']
       alist.insert(3, [2009])
       print("Final List :", alist)
      
       

      Выход:

        Final List : [123, 'xyz', 'zara', 2009, 'abc'] 
  • 5

    Каждый и все

    Вы можете использовать all() , чтобы определить , если все значения итератора вычисляться значение True

     nums = [1, 1, 0, 1]
    all(nums)
    # False
    chars = ['a', 'b', 'c', 'd']
    all(chars)
    # True
    
     

    Аналогично, any() определяет , является ли одно или более значений в качестве итератора оценки Истины

     nums = [1, 1, 0, 1]
    any(nums)
    # True
    vals = [None, None, None, False]
    any(vals)
    # False
    
     

    Хотя в этом примере используется список, важно отметить, что эти встроенные модули работают с любыми итерациями, включая генераторы.

     vals = [1, 2, 3, 4]
    any(val > 12 for val in vals)
    # False
    any((val * 2) > 6 for val in vals)
    # True 
  • 3

    Удалить повторяющиеся значения в списке

    Удаление повторяющихся значений в списке может быть сделано путем преобразования списка в set (то есть неупорядоченный набор различных объектов). Если list необходима структура данных, то множество может быть преобразовано обратно в список с помощью функции list() :

     names = ["aixk", "duke", "edik", "tofp", "duke"]
    list(set(names))
    # Out: ['duke', 'tofp', 'aixk', 'edik']
    
     

    Обратите внимание, что при преобразовании списка в набор исходный порядок теряется.

    Для того, чтобы сохранить порядок списка можно использовать OrderedDict

     import collections
    >>> collections.OrderedDict.fromkeys(names).keys()
    # Out: ['aixk', 'duke', 'edik', 'tofp'] 
  • 0

    Доступ к значениям во вложенном списке

    Начиная с трехмерного списка:

     alist = [[[1,2],[3,4]], [[5,6,7],[8,9,10], [12, 13, 14]]]
    
     

    Доступ к элементам в списке:

     print(alist[0][0][1])
    #2
    #Accesses second element in the first list in the first list
    
    print(alist[1][1][2])
    #10
    #Accesses the third element in the second list in the second list
    
     

    Выполнение вспомогательных операций:

     alist[0][0].append(11)
    print(alist[0][0][2])
    #11
    #Appends 11 to the end of the first list in the first list
    
     

    Использование вложенных циклов for для печати списка:

     for row in alist: #One way to loop through nested lists
        for col in row:
            print(col)
    #[1, 2, 11]
    #[3, 4]
    #[5, 6, 7]
    #[8, 9, 10]
    #[12, 13, 14]
    
     

    Обратите внимание, что эта операция может использоваться для понимания списка или даже в качестве генератора для повышения эффективности, например:

     [col for row in alist for col in row]
    #[[1, 2, 11], [3, 4], [5, 6, 7], [8, 9, 10], [12, 13, 14]]
    
    
     

    Не все элементы во внешних списках должны быть самими списками:

     alist[1].insert(2, 15)
    #Inserts 15 into the third position in the second list
    
     

    Еще один способ использовать вложенные циклы. Другой способ лучше, но мне нужно было использовать это иногда:

     for row in range(len(alist)): #A less Pythonic way to loop through lists
        for col in range(len(alist[row])):
           print(alist[row][col])
    
    #[1, 2, 11]
    #[3, 4]
    #[5, 6, 7]
    #[8, 9, 10]
    #15
    #[12, 13, 14]
    
     

    Использование фрагментов во вложенном списке:

     print(alist[1][1:])
    #[[8, 9, 10], 15, [12, 13, 14]]
    #Slices still work
    
     

    Финальный список:

     print(alist)
    #[[[1, 2, 11], [3, 4]], [[5, 6, 7], [8, 9, 10], 15, [12, 13, 14]]] 
  • 1

    Сравнение списков

    Можно сравнивать списки и другие последовательности лексикографически, используя операторы сравнения. Оба операнда должны быть одного типа.

     [1, 10, 100] < [2, 10, 100]
    # True, because 1 < 2
    [1, 10, 100] < [1, 10, 100]
    # False, because the lists are equal
    [1, 10, 100] <= [1, 10, 100]
    # True, because the lists are equal
    [1, 10, 100] < [1, 10, 101]
    # True, because 100 < 101
    [1, 10, 100] < [0, 10, 100]
    # False, because 0 < 1
    
     

    Если один из списков содержится в начале другого, выигрывает самый короткий список.

     [1, 10] < [1, 10, 100]
    # True 
  • 0

    Инициализация списка с фиксированным числом элементов

    Для неизменяемых элементов (например , None , строковые литералы и т.д.):

     my_list = [None] * 10
    my_list = ['test'] * 10
    
     

    Для изменяемых элементов, та же конструкция , приведет все элементы списка со ссылкой на тот же объект, например, для набора:

     >>> my_list=[{1}] * 10
    >>> print(my_list)
    [{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}]
    >>> my_list[0].add(2)
    >>> print(my_list)
    [{1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}]
    
     

    Вместо того , чтобы инициализировать список с фиксированным числом различных изменяемых объектов, используйте:

     my_list=[{1} for _ in range(10)] 

Синтаксис

Параметры

Примечания