Как считать список в python

Списки в Python

В Python есть множество комплексных типов данных, называемых последовательностями. Список — один из часто используемых и универсальных типов данных. Это аналог массивов в других языках программирования.

Как создать список

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

В списке допускается любое количество элементов разных типов (целые числа, числа с плавающей точкой, строки и т. д.).

# пустой список my_list = [] # список целых чисел my_list = [1, 2, 3] # список с элементами разных типов my_list = [1, "Привет", 3.4]

Элементом списка может быть и другой список. Такие списки называются вложенными.

# внутри основного списка — вложенный список my_list = ["мышь", [8, 4, 6], ['a']]

Как получить доступ к элементам списка

1. По индексу

Чтобы получить доступ к элементу списка, можно воспользоваться оператором индекса [] .

Примечание. Обратите внимание, что индексирование кортежа начинается с 0. Поэтому у списка из 5 элементов будут индексы с 0 по 4.

Попытка взять элемент по индексу, не входящему в диапазон, приведет к IndexError. Индекс — обязательно целое число. Нельзя использовать числа с плавающей точкой и другие типы, это приведет к TypeError.

Вложенные списки можно получить с помощью вложенной индексации.

# Индексация списков my_list = ['п', 'р', 'о', 'б', 'а'] # Вывод: п print(my_list[0]) # Вывод: о print(my_list[2]) # Вывод: а print(my_list[4]) # Вложенный список — [2, 0, 1, 5] n_list = ["Счастье", [2, 0, 1, 5]] # Вложенная индексация print(n_list[0][1]) print(n_list[1][3]) # Ошибка! Для индексации используются только целочисленные значения print(my_list[4.0])

Вывод:

п
o
а
ч
5

Traceback (most recent call last): 
File "", line 21, in 
TypeError: list indices must be integers or slices, not float

2. По отрицательному индексу

Python поддерживает отрицательные индексы в последовательностях. Индекс -1 указывает на последний элемент, -2 — на предпоследний и т. д.

# Отрицательные индексы в списках my_list = ['п', 'р', 'о', 'б', 'а'] print(my_list[-1]) print(my_list[-5])

Вывод:

Срезы списков

С помощью оператора среза : можно получить диапазон элементов в списке.

my_list = ['c', 'o' , 'd', 'e', 'c', 'h', 'i', 'c', 'k'] # элементы с 3 по 5 print(my_list[2:5]) # элементы с 1 по 4 print(my_list[:-5]) # элементы с 6 по последний print(my_list[5:]) # элементы с первого по последний print(my_list[:])

Вывод:

['d', 'e', 'c']
['c','o,'d','e']
['h','i','c','k']
['c','o,'d','e','c','h','i','c','k']

Как изменять элементы в списке

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

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

Допустим, у нас есть список, который называется odd (нечётные числа). Но в нём почему-то хранятся четные числа. Давайте это исправим.

odd = [2, 4, 6, 8] # изменяем 1-й элемент odd[0] = 1 print(odd) # изменяем элементы со второго по 4 odd[1:4] = [3, 5, 7] print(odd) 

Вывод:

[1, 4, 6, 8]
[1, 3, 5, 7]

Как добавлять элементы в список

Один элемент в список добавляется с помощью метода append() , а несколько — с помощью метода extend() .

odd = [1, 3, 5] odd.append(7) print(odd) odd.extend([9, 11, 13]) print(odd)

Вывод:

[1, 3, 5, 7]

[1, 3, 5, 7, 9, 11, 13]

Для объединения двух списков используется оператор + . Это называется конкатенацией списков.

Оператор * повторяет список заданное количество раз.

odd = [1, 3, 5] print(odd + [9, 7, 5]) print(["re"] * 3)

Вывод:

[1, 3, 5, 9, 7, 5]
['re', 're', 're']

С помощью метода insert() можно вставить один элемент по данному индексу, а присвоив их пустому срезу — несколько.

odd = [1, 9] odd.insert(1,3) print(odd) odd[2:2] = [5, 7] print(odd)

Вывод:

[1, 3, 9]
[1, 3, 5, 7, 9]

Как удалять элементы из списка

Один или несколько элементов списка можно удалить с помощью ключевого слова del . С помощью него можно удалить и весь список.

my_list = ['п', 'р', 'o', 'б', 'л', 'е', 'м', 'а'] # удаление одного элемента del my_list[2] print(my_list) # удаление среза элементов del my_list[1:5] print(my_list) # удаление всего списка del my_list # этот вызов приведет к ошибке # список не определен, т. к. мы удалили его print(my_list)

Вывод:

['п', 'р', 'б', 'л', 'е', 'м', 'а']
['п', 'м', 'а']
Traceback (most recent call last): 
File "", line 18, in 
NameError: name 'my_list' is not defined

Чтобы удалить элемент по значению, можно использовать метод remove() , а для удаления по индексу — метод pop() .

Метод pop() удаляет и возвращает последний элемент из списка, если не указан индекс. Это помогает применять списки как стек (структура данных, которая подчиняется принципу LIFO: «последним пришел — первым вышел»).

Для очистки списка используется метод clear() .

my_list = ['п', 'р', 'o', 'б', 'л', 'е', 'м', 'а'] my_list.remove('п') # Вывод: ['р', 'o', 'б', 'л', 'е', 'м', 'а'] print(my_list) # Вывод: 'o' print(my_list.pop(1)) # Вывод: ['р', 'б', 'л', 'е', 'м', 'а'] print(my_list) # Вывод: 'м' print(my_list.pop()) # Вывод: ['р', 'б', 'л', 'е', 'а'] print(my_list) my_list.clear() # Вывод: [] print(my_list)

Вывод:

['р', 'o', 'б', 'л', 'е', 'м', 'а']
o
['р', 'б', 'л', 'е', 'м', 'а']
м
['р', 'б', 'л', 'е', 'а']
[]

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

>>> my_list = ['п', 'р', 'o', 'б', 'л', 'е', 'м', 'а'] >>> my_list[2:3] = [] >>> my_list ['п', 'р', 'б', 'л', 'е', 'м', 'а'] >>> my_list[2:5] = [] >>> my_list ['п', 'р', 'м', 'а']

Методы списков

Методы списков перечислены в таблице ниже. Их нужно использовать с помощью конструкции список.метод() . Некоторые из них мы уже использовали.

Название метода

Что делает

Добавляет элемент в конец списка

Добавляет все элементы списка в другой список

Вставляет элемент по данному в качестве аргумента индексу

Удаляет элемент из списка

Удаляет элемент из списка и возвращает его

Удаляет все элементы из списка

Возвращает индекс первого совпавшего элемента

Считает количество элементов в списке, совпадающих с переданным аргументом

Сортирует элементы в списке в порядке возрастания

Возвращает неглубокую копию списка

# Методы списков my_list = [3, 8, 1, 6, 0, 8, 4] # Вывод: 1 print(my_list.index(8)) # Вывод: 2 print(my_list.count(8)) my_list.sort() # Вывод: [0, 1, 3, 4, 6, 8, 8] print(my_list) my_list.reverse() # Вывод: [8, 8, 6, 4, 3, 1, 0] print(my_list)

Вывод:

1
2
[0, 1, 3, 4, 6, 8, 8]
[8, 8, 6, 4, 3, 1, 0]

Представления списков

Представление списков — элегантный и лаконичный способ создать новый список из существующего.

Представление списков состоит из выражения, за которым следует оператор for , и эта конструкция заключается в квадратные скобки [] .

Давайте создадим список степеней двойки от 1 до 9. Используем для это представление списка.

pow2 = [2 ** x for x in range(10)] print(pow2)

Вывод:

[1, 2, 4, 8, 16, 32, 64, 128, 256, 512]

То же самое можно сделать и так:

pow2 = [] for x in range(10): pow2.append(2 ** x)

Но так — длинее. Представление списков более элегантный способ.

В представлениях списков может быть больше операторов for и if . Оператор if он позволяет отфильтровать элементы для нового списка. Он необязателен.

>>> pow2 = [2 ** x for x in range(10) if x > 5] >>> pow2 [64, 128, 256, 512] >>> odd = [x for x in range(20) if x % 2 == 1] >>> odd [1, 3, 5, 7, 9, 11, 13, 15, 17, 19] >>> [y+x for x in ['Python ','C '] for y in ['Язык','Программирование на']] ['Язык Python', 'Программирование на Python', 'Язык C', 'Программирование на C']

Другие операции со списками

Проверка на вхождение элемента в список

С помощью ключевого слова in можно узнать, есть элемент в списке или нет.

my_list = ['п', 'р', 'o', 'б', 'л', 'е', 'м', 'а'] # Вывод: True print('п' in my_list) # Вывод: False print('у' in my_list) # Вывод: True print('с' not in my_list)

Вывод:

True
False
True

Итерирование по списку

С помощью цикла for можно пройтись по каждому элементу в списке.

for fruit in ['яблоки','бананы','манго']: print("Я люблю",fruit)

Вывод:

Я люблю яблоки
Я люблю бананы
Я люблю манго

СodeСhick.io — простой и эффективный способ изучения программирования.

2023 © ООО «Алгоритмы и практика»

21. Дополнительно про списки в Python

В предыдущих уроках вы узнали, как получить срез списка и какие есть основные методы.

В этом уроке вы узнаете про обратное индексирование, познакомитесь с методами index , clear , reverse , count и другими. Для примеров работы методов были использованы списки, состоящие из чисел. Но не забывайте, что списки могут содержать любые объекты: числа, строки, другие списки и вообще все что угодно. При этом список может быть неоднородным:

a = [1, 'Hello', [2, 3, 4], 2]

Элементы списка можно вызывать не только с начала, но и с конца: обратное индексирование. В отличие от обычного индексирования, обратное начинается не с 0 , а с -1 . Например:

a = [1, 2, 3, 4, 5]
a[-1] # => 5

Обратное индексирование очень полезно в некоторых ситуациях и повышает эффективность кода. Например, в большом списке с изменяемой длиной вам не придется считать элементы с самого начала, чтобы добраться до последнего. Достаточно воспользоваться предыдущим примером.

Иногда необходимо определить индекс элемента, зная его значение. Для этого существует метод index() , в параметре которого указывается значение элемента, индекс которого необходимо узнать:

a = [1, 2, 3, 4, 5]
a.index(2) # => 1

Если вы передадите несуществующее значение, то будет вызвано исключение ValueError , но об исключениях вы узнаете позднее.

Как удалить конкретный элемент списка вы узнали из этого урока. А как очистить весь список? Для этого есть метод clear() .

a = [1, 2, 3, 4, 5]
a.clear() # => []

Список можно развернуть, то есть изменить порядок следования элементов на обратный при помощи метода reverse() .

a = [1, 2, 3, 4, 5]
a.reverse() # => [5, 4, 3, 2, 1]

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

a = [1, 2, 2, 2, 5]
a.count(2) # => 3

До этого момента мы рассматривали методы списков. Далее взглянем на функции, которые применимы к спискам. Что такое функции и методы и в чем их различия мы еще поговорим далее, а сейчас достаточно знать, что методы вызываются с помощью оператора точка ( . ), например:

words.reverse()

Где words является списком, а reverse() – методом. Функция выглядит следующим образом:

sum(words)

Где words является списком, а sum – функцией.

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

Кстати, в примере выше была использована функция sum() , которая возвращает общую сумму чисел в списке. Если в списке есть что-то, кроме чисел, то функцию sum , как вы понимаете, использовать нельзя.

Так же есть функции min() и max() , которые возвращают минимальное и максимальное значение из списка, соответственно.

Напоследок вспомним про урок, где мы генерировали случайные числа. Предположим, вы необходимо перемешать элементы списка, для чего необходимо подключить модуль random и использовать метод snuffle() из этого модуля.

import random
a = [1, "Hello", [3, 6, 7], 4, 5]
random.shuffle(a) # ~=> [5, 'Hello', 4, 1, [3, 6, 7]]

Обратите внимание, список является неоднородным и элемент с индексом 2 является другим списком. После применения метода snuffle() элементы списка перемешаются в случайном (точнее псевдослучайном) порядке, но элементы списка [3, 6, 7] не будут перемешаны.

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

Массивы и списки в Python

Рассмотрим в уроке массивы и их виды, списки, нумерацию списков и основные методы при работе с ними.

Массивы

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

Перед началом работы с массивами подключаем соответствующий модуль. Для этого введем команду:

from array import *

Создадим массив для данных типа int:

>>> a = array('i', [2, 5, 4, 0, 8]) >>> type(a) >>> a array('i', [2, 5, 4, 0, 8])

Теперь обратимся к каждому из элементов данного массива. Попробуем изменить их и дополнить массив:

>>> a[2] 4 >>> a[6] Traceback (most recent call last): File "", line 1, in a[6] IndexError: array index out of range

Как видите, нельзя обратиться к элементу, которого нет.

Любой массив может содержать данные только одного типа, то есть нельзя использовать int и float в одном массиве. Это является недостатком при работе, для устранения которого были введены списки (list).

Список в Python

Список в Python похож на массив. Различие в том, что в списках можно хранить объекты различных типов данных. Размер списка не статичен и поддается изменениям.

На программном уровне переменная, определяемая как список, содержит ссылку на структуру в памяти, которая хранит ссылки на какие-либо другие объекты или структуры.

Рассмотрим на примере:

>>> a = [] >>> type(a)

Теперь добавим элементы и проверим доступ к ним:

>>> a = [1,0.34,"Hello"] >>> a [1, 0.34, 'Hello'] >>> a[2] 'Hello' >>> a[0] 1 >>> a[1] 0.34

Нумерация списка в Python

Прямая и обратная нумерация

По умолчанию нумерация начинается с 0.

a = [1, 'abc', h, 0,256] 0 1 2 3 

При обратной нумерации элементы считаются с конца и начинаются с -1:

a = [1, 'abc', h, 0,256] -4 -3 -2 -1

С помощью этих индексов можем обратиться к каждому элементу списка:

a[0] >>> 1 a[-2] >>> h

Срез

Срез — это некий диапазон символов, к которому мы обращаемся. При срезе вторым числом мы указываем номер символа, который не входит в диапазон:

a[0:2] #[1, 'abc'] a[-4:-2] #[1, 'abc']

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

a[0:-2] #[1, 'abc']

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

a[:2] #[1, 'abc'] a[2:] #[h, 0,256]

Методы работы со списками

Рассмотрим основные методы работы со списками на примерах.

list.append(x)

Добавляет в конце списка новый элемент x:

>>> a = [0,0.1,"один"] >>> a.append(321) >>> a [0, 0.1, 'один', 321]

list.insert(i,x)

Вставка элемента x на место i (нумерация начинается с нуля):

>>> a = [0,0.1,"один"] >>> a.insert(1,321) >>> a [0, 321, 0.1, 'один']

list.extend(L)

Добавляет в конец списка список L:

>>> a = [0,0.1,"один"] >>> b = ["два",3,4.1] >>> a.extend(b) >>> a [0, 0.1, 'один', 'два', 3, 4.1]

list.remove(x)

Удаляет первый встреченный элемент со значением x:

>>> a = [0,0.1,"один",0] >>> a.remove(0) >>> a [0.1, 'один', 0]

list.pop(i)

Возвращает элемент, размещенный по индексу i, удаляет его из списка:

>>> a = [0,0.1,"один",0] >>> a.pop(3) 0 >>> a [0, 0.1, 'один']

list.count(x)

Возвращает количество элементов, равных x:

>>> a = [0,0.1,"один",0] >>> a.count(0) 2

list.clear()

>>> a = [0,0.1,"один",0] >>> a [0, 0.1, 'один', 0] >>> a.clear() >>> a []

Курсы Робикс, в которых изучается этот материал.

1. Программирование на Python в Minecraft
2. Duckietown робот с системой Автопилота

Получить список, состоящий из цифр числа?

называть переменные именами встроенных методов — очень плохая идея. поменяйте имя int на что-то более правильное.

18 мар 2021 в 8:16

• python
• list

Важное на Мете

Похожие

Подписаться на ленту

Лента вопроса

Для подписки на ленту скопируйте и вставьте эту ссылку в вашу программу для чтения RSS.

Дизайн сайта / логотип © 2023 Stack Exchange Inc; пользовательские материалы лицензированы в соответствии с CC BY-SA . rev 2023.11.15.1019

Нажимая «Принять все файлы cookie» вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.