Что нужно знать о Python List()

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

Как мы знаем, list() — довольно широко используемый тип данных в python, который помогает нам хранить набор данных с похожим типом данных (гомогенный) или с различным типом данных (гетерогенный), и они могут быть примитивными данными, такими как int, float и логические или не примитивные данные, такие как список, словарь, кортежи и т. д.

Список () строится по значению с индексом, поэтому, если мы хотим получить доступ к значению, нам просто нужно указать индекс этого значения, список () можно изменить, хранить данные в списке — это как писать «список дел» карандашом поэтому, если мы хотим изменить «план», мы можем стереть его и написать другой «план».

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

Присвоить значение

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

mylist = [1,'a',0.5,[2,'b',0.9],(3,'c',1.1),{'d':4,'e':'f','g':2.3}]
print(mylist)
print(type(mylist))
Output:
[1, 'a', 0.5, [2, 'b', 0.9], (3, 'c', 1.1), {'d': 4, 'e': 'f', 'g': 2.3}]
<class 'list'>

Или вы можете назначить новый список со значением из другого назначенного списка с помощью оператора «=»

print('\norigin list')
mylist = ['item 1','item 2','item 3','item 4','item 5','item 6']
print(mylist)
Output:
new_list = mylist
print('\ncopy list')
print(new_list)
Output:
copy list
['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6']

Но проблема при копировании таким образом заключается в том, что если вы измените один из списков, исходный список или список копирования, они оба изменятся. Давайте посмотрим на пример, в этом случае мы добавляем новый элемент «элемент 7» в new_list методом добавления.

new_list.append('item 7')
print('\norigin list')
print(mylist)
print('\ncopy list')
print(new_list)
Output:
origin list
['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6', 'item 7']

copy list
['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6', 'item 7']

Как мы видим, мы меняем только элемент new_list, добавляя ‘item 7’, но это влияет не только на список new_new, но и на mylist. Чтобы предотвратить эту проблему, вы можете использовать метод copy() или использовать нарезку для копирования значения из исходного списка.

метод копирования()

new_list = mylist.copy()
print(new_list)

Нарезка

new_list = mylist[:] # Copy all value from mylist
print(new_list)
new_list = mylist[1:5] # Copy mylist value from index 1 until 4
print(new_list)

И когда вы меняете значение new_list или mylist, это изменит только измененный список, а не оба.

print(mylist)
new_list = mylist[:]
print(new_list)
new_list[0] = 'modified item'
print(mylist)
print(new_list)
Output:
['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6', 'item 7']
['modified item', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6', 'item 7']

Значение доступа

Доступ к значению или чтение значения списка можно выполнить с помощью двухстороннего индексирования и нарезки, где индексация может использоваться для извлечения 1 значения, а нарезка может извлекать 1 или более значений из списка.

Индексирование

На практике мы используем оператор индекса«[ ‹index›]» или квадратную скобку после имени списка для выполнения индексации.

mylist = [1,'a',0.5,[2,'b',0.9],(3,'c',1.1),{'d':4,'e':'f','g':2.3}]
item = mylist[0]
print(item)
Output:
1

Нарезка

Как упоминалось выше, ключевое различие между индексированием и нарезкой заключается в том, что при индексировании извлекается только 1 значение, а при нарезке может извлекаться 1 или более значений (подмножество списка). Таким образом, он по-прежнему использует оператор индекса (квадратную скобку), но мы помещаем в него диапазон индекса. Мы можем определить диапазон индекса, используя 3 параметра: начало, конец и шаг, разделенные двоеточием «:».

<list variable name> [<start index>:<end index>:<step>]

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

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

Если параметр шага не заполнен, значение по умолчанию заполняется 1.

mylist = ['item 1','item 2','item 3','item 4','item 5','item 6']
items = mylist[::]
print(items)
Output:
['item 1','item 2','item 3','item 4','item 5','item 6']

Это показывает нам, что если мы не определим все параметры, он использует параметр по умолчанию и получает доступ ко всем данным из списка. вот пример, когда мы пытаемся получить доступ к данным с номером индекса от 2 до 4 (эксклюзивно) с последовательностью 1 шага.

Вот пример, когда мы пытаемся получить доступ к данным с порядковым номером от 2 до 4 (исключительно) с последовательностью из 1 шага.

items = mylist[2:4:1]
print(items)
Output:
['item 3','item 4']

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

items = mylist[-1:-4:-2]
print(items)
Output:
['item 6','item 4']

метод count()

С помощью метода count() мы можем получить количество раз, когда элемент появляется в списке. Он принимает значение списка в качестве параметра.

mylist = ['item 1','item 2','item 3','item 4','item 5','item 3']
print(mylist)
print(f"count of item 3 is {mylist.count('item 3')}")
Output:
['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 3']
count of item 3 is 2

метод index()

Метод index() может помочь нам получить первый индекс элемента, который ищется по его значению. В качестве параметра принимает 3 аргумента:

• значение элемента, значение для поиска
• start, индекс начала поиска (необязательно)
• стоп, остановить поиск по индексу (необязательно)

print('\nindex')
mylist = ['item 1','item 2','item 3','item 1','item 4','item 5']
print(mylist)
print(f"index of item 3 is {mylist.index('item 3')}")
Output:
index of item 3 is 2

Изменить список

Есть способ изменить или изменить значение в списке. Давайте посмотрим их один за другим.

методы append() и extend()

Append — это метод, который работает так же просто, как добавление данных в список. Добавляемые данные помещаются в последний индекс.

mylist = ['item 1','item 2','item 3','item 4','item 5','item 6']
print(mylist)
Output:
['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6']
mylist.append('item 7')
print(mylist)
Output:
['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6', 'item 7']

Append может добавить только одно значение, где значение может быть базовым типом данных или типом данных последовательности.

mylist.append(['item 7','item 8','item 9'])
print(mylist)
Output:
['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6', 'item 7',['item 7','item 8','item 9']]

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

mylist = ['item 1','item 2','item 3','item 4','item 5','item 6']
added_items = ['item 7','item 8']
for item in added_items:
    mylist.append(item)
print(mylist)
Output:
['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6', 'item 7','item 8']
mylist = ['item 1','item 2','item 3','item 4','item 5','item 6']
mylist.extend(added_items)
print(mylist)
Output:
['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6', 'item 7','item 8']

метод вставки()

Когда метод append() добавляет значение в список с последним индексом, с помощью метода insert() вы можете добавлять значение с любым индексом по своему усмотрению. Он принимает желаемый индекс и значение в качестве параметров.

mylist = ['item 1','item 2','item 3','item 4','item 5','item 6']
print(mylist)
Output:
['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6']

mylist.insert(2,'item 7')
print(mylist)
Output:
['item 1', 'item 2', 'item 7','item 3', 'item 4', 'item 5', 'item 6']

метод реверса()

Метод reverse() используется, если вы хотите изменить индекс списка в обратном порядке. Ему не нужны никакие входные параметры.

mylist = ['item 1','item 2','item 3','item 4','item 5','item 6']
print(mylist)
Output:
['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6']

mylist.reverse()
print(mylist)
Output:
['item 6', 'item 5', 'item 4','item 3', 'item 2', 'item 1']

метод sort()

Метод sort() упорядочивает элемент списка в зависимости от его значения либо в порядке возрастания, либо в порядке убывания. По умолчанию sort() не требует никаких параметров. Но у него есть два необязательных параметра:

• "reverse = True", если вы хотите отсортировать список в обратном порядке (или отсортировать по убыванию)
• ключфункция, которая служит ключом для сравнения сортировки.

mylist = ['item 1','item 2','item 3','item 4','item 5','item 6']
print(mylist)
Output:
['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6']

mylist.sort(reverse=True)
print(mylist)
Output:
['item 6', 'item 5', 'item 4','item 3', 'item 2', 'item 1']

mylist.sort()
print(mylist)
Output:
['item 1', 'item 2', 'item 3','item 4', 'item 5', 'item 6']

Удалить значение

В то время как добавление или расширение могут добавить значение в список, мы можем удалить значение с помощью методов очистки, извлечения, удаления и удаления. В чем разница между ними? и какой метод мы должны выбрать в каком-то другом случае?. Это будет объяснено в этом разделе.

метод очистки()

Он удалит все элементы в списке.

print(mylist)
Output:
['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6']
mylist.clear()
print(mylist)
Output:
[]

метод pop()

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

mylist = ['item 1','item 2','item 3','item 4','item 5','item 6']
print(mylist)
Output:
 ['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6']
poped_item = mylist.pop(3)
print(mylist)
print(poped_item)
Output:
['item 1', 'item 2', 'item 3', 'item 5', 'item 6']
item 4

метод удаления()

Он удалит элемент в списке по его значению.

mylist = ['item 1','item 2','item 3','item 4','item 5','item 6']
print(mylist)
Output:
['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6']
mylist.remove('item 2')
print(mylist)
Output:
['item 1', 'item 3', 'item 4', 'item 5', 'item 6']

метод удаления

Он удалит элемент или группу элементов в списке по его индексу или нарезке.

mylist = ['item 1','item 2','item 3','item 4','item 5','item 6']
print(mylist)
Output:
['item 1', 'item 2', 'item 3', 'item 4', 'item 5', 'item 6']
del mylist[2]
print(mylist)
Output:
['item 1', 'item 3', 'item 4', 'item 5', 'item 6']
mylist = ['item 1','item 2','item 3','item 4','item 5','item 6']
del mylist[1:3]
print(mylist)
Output:
['item 1', 'item 4', 'item 5', 'item 6']

Заключение

Список — это последовательный изменяемый тип данных, который может хранить множество типов данных. с этими характеристиками мы можем делать много вещей со списком. И для этого нам нужен метод, который может помочь нам в обработке этих типов данных. Мы изучили много основных методов для типа данных списка, надеюсь, это поможет решить проблемы программирования, с которыми мы столкнемся в будущем.

если вы хотите больше статей о питоне, вы можете перейти на www.pythontamer.com