Список
Список — это непрерывная динамическая коллекция элементов. Каждому элементу списка присваивается порядковый номер — его индекс. Первый индекс равен нулю, второй — единице и так далее. Основные операции для работы со списками — это индексирование, срезы, добавление и удаление элементов, а также проверка на наличие элемента в последовательности.
Создание пустого списка выглядит так:
Создадим список, состоящий из нескольких чисел:
numbers = [ 40 , 20 , 90 , 11 , 5 ]
Настало время строковых переменных:
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
Не будем забывать и о дробях:
fractions = [ 3.14 , 2.72 , 1.41 , 1.73 , 17.9 ]
Мы можем создать список, состоящий из различных типов данных:
values = [ 3.14 , 10 , ‘Hello world!’ , False, ‘Python is the best’ ]
И такое возможно (⊙_⊙)
list_of_lists = [[ 2 , 4 , 0 ], [ 11 , 2 , 10 ], [ 0 , 19 , 27 ]]
Индексирование
Что же такое индексирование? Это загадочное слово обозначает операцию обращения к элементу по его порядковому номеру ( ( ･ω･)ア напоминаю, что нумерация начинается с нуля). Проиллюстрируем это на примере:
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
print (fruits[ 0 ])
print (fruits[ 1 ])
print (fruits[ 4 ])
Списки в Python являются изменяемым типом данных. Мы можем изменять содержимое каждой из ячеек:
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
fruits[ 0 ] = ‘Watermelon’
fruits[ 3 ] = ‘Lemon’
print (fruits)
>>> [ ‘Watermelon’ , ‘Grape’ , ‘Peach’ , ‘Lemon’ , ‘Orange’ ]
Индексирование работает и в обратную сторону. Как такое возможно? Всё просто, мы обращаемся к элементу списка по отрицательному индексу. Индекс с номером -1 дает нам доступ к последнему элементу, -2 к предпоследнему и так далее.
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
print (fruits[ -1 ])
print (fruits[ -2 ])
print (fruits[ -3 ])
print (fruits[ -4 ])
Создание списка с помощью list()
Переходим к способам создания списка. Самый простой из них был приведен выше. Еще раз для закрепления:
А есть еще способы? Да, есть. Один из них — создание списка с помощью функции list() В неё мы можем передать любой итерируемый объект (да-да, тот самый по которому можно запустить цикл (• ᵕ •) )
Рассмотрим несколько примеров:
letters = list ( ‘abcdef’ )
numbers = list ( range ( 10 ))
even_numbers = list ( range ( 0 , 10 , 2 ))
print (letters)
print (numbers)
print (even_numbers)
>>> [ ‘a’ , ‘b’ , ‘c’ , ‘d’ , ‘e’ , ‘f’
>>> [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]
>>> [ 0 , 2 , 4 , 6 , 8 ]
Длина списка
С созданием списка вроде разобрались. Следующий вопрос: как узнать длину списка? Можно, конечно, просто посчитать количество элементов. (⊙_⊙) Но есть способ получше! Функция len() возвращает длину любой итерируемой переменной, переменной, по которой можно запустить цикл. Рассмотрим пример:
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
print ( len (fruits))
numbers = [ 40 , 20 , 90 ]
print ( len (numbers))
«. любой итерируемой», а это значит:
string = ‘Hello world’
print ( len (string))
# 11
print ( len ( range ( 10 ))
Срезы
В начале статьи что-то говорилось о «срезах». Давайте разберем подробнее, что это такое. Срезом называется некоторая подпоследовательность. Принцип действия срезов очень прост: мы «отрезаем» кусок от исходной последовательности элемента, не меняя её при этом. Я сказал «последовательность», а не «список», потому что срезы работают и с другими итерируемыми типами данных, например, со строками.
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
part_of_fruits = fruits[ 0 :3]
print (part_of_fruits)
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ ]
Детально рассмотрим синтаксис срезов:
итерируемая_переменная[начальный_индекс:конечный_индекс — 1 :длина_шага]
Обращаю ваше внимание, что мы делаем срез от начального индекса до конечного индекса — 1. То есть i = начальный_индекс и i = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
print (fruits[ 0 :1])
# Если начальный индекс равен 0, то его можно опустить
print (fruits[: 2 ])
print (fruits[: 3 ])
print (fruits[: 4 ])
print (fruits[: 5 ])
# Если конечный индекс равен длине списка, то его тоже можно опустить
print (fruits[: len (fruits)])
print (fruits[::])
>>> [ ‘Apple’ ]
>>> [ ‘Apple’ , ‘Grape’ ]
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ ]
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ ]
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
Самое время понять, что делает третий параметр среза — длина шага!
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
print (fruits[:: 2 ])
print (fruits[:: 3 ])
# Длина шага тоже может быть отрицательной!
print (fruits[:: -1 ])
print (fruits[ 4 :2: -1 ])
print (fruits[ 3 :1: -1 ])
>>> [ ‘Apple’ , ‘Peach’ , ‘Orange’ ]
>>> [ ‘Apple’ , ‘Banan’ ]
>>> [ ‘Orange’ , ‘Banan’ , ‘Peach’ , ‘Grape’ , ‘Apple’ ]
>>> [ ‘Orange’ , ‘Banan’ ]
>>> [ ‘Banan’ , ‘Peach’ ]
А теперь вспоминаем всё, что мы знаем о циклах. В Python их целых два! Цикл for и цикл while Нас интересует цикл for, с его помощью мы можем перебирать значения и индексы наших последовательностей. Начнем с перебора значений:
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
f or fruit in fruits:
print (fruit, end = ‘ ‘ )
>>> Apple Grape Peach Banan Orange
Выглядит несложно, правда? В переменную fruit объявленную в цикле по очереди записываются значения всех элементов списка fruits
А что там с перебором индексов?
f or index in range ( len (fruits)):
print (fruits[index], end = ‘ ‘ )
Этот пример гораздо интереснее предыдущего! Что же здесь происходит? Для начала разберемся, что делает функция range(len(fruits))
Мы с вами знаем, что функция len() возвращает длину списка, а range() генерирует диапазон целых чисел от 0 до len()-1.
Сложив 2+2, мы получим, что переменная index принимает значения в диапазоне от 0 до len()-1. Идем дальше, fruits[index] — это обращение по индексу к элементу с индексом index списка fruits. А так как переменная index принимает значения всех индексов списка fruits, то в цикле мы переберем значения всех элементов нашего списка!
Операция in
С помощью in мы можем проверить наличие элемента в списке, строке и любой другой итерируемой переменной.
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
if ‘Apple’ in fruits:
print ( ‘В списке есть элемент Apple’ )
>>> В списке есть элемент Apple
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
if ‘Lemon’ in fruits:
print ( ‘В списке есть элемент Lemon’ )
else :’
print ( ‘В списке НЕТ элемента Lemon’ )
>>> В списке НЕТ элемента Lemon
Приведу более сложный пример:
all_fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
my_favorite_fruits = [ ‘Apple’ , ‘Banan’ , ‘Orange’ ]
f or item in all_fruits:
if item in my_favorite_fruits:
print (item + ‘ is my favorite fruit’ )
else :
print ( ‘I do not like ‘ + item)
>>> Apple is my favorite fruit
>>> I do not like Grape
>>> I do not like Peach
>>> Banan is my favorite fruit
>>> Orange is my favorite fruit
Методы для работы со списками
Начнем с метода append(), который добавляет элемент в конец списка:
# Создаем список, состоящий из четных чисел от 0 до 8 включительно
numbers = list ( range ( 0 ,10, 2 ))
# Добавляем число 200 в конец списка
numbers. append ( 200 )
numbers. append ( 1 )
numbers. append ( 2 )
numbers. append ( 3 )
print (numbers)
>>> [ 0 , 2 , 4 , 6 , 8 , 200 , 1 , 2 , 3 ]
Мы можем передавать методу append() абсолютно любые значения:
all_types = [ 10 , 3.14 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]]
all_types. append ( 1024 )
all_types. append ( ‘Hello world!’ )
all_types. append ([ 1 , 2 , 3 ])
print (all_types)
>>> [ 10 , 3.14 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ], 1024 , ‘Hello world!’ , [ 1 , 2 , 3 ]]
Метод append() отлично выполняет свою функцию. Но, что делать, если нам нужно добавить элемент в середину списка? Это умеет метод insert(). Он добавляет элемент в список на произвольную позицию. insert() принимает в качестве первого аргумента позицию, на которую нужно вставить элемент, а вторым — сам элемент.
# Создадим список чисел от 0 до 9
numbers = list ( range ( 10 ))
# Добавление элемента 999 на позицию с индексом 0
numbers. insert ( 0 , 999 )
print (numbers) # первый print
numbers. insert ( 2 , 1024 )
print (numbers) # второй print
numbers. insert ( 5 , ‘Засланная строка-шпион’ )
print (numbers) # третий print
>>> [ 999 , 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # первый print
>>> [ 999 , 0 , 1024 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # второй print
>>> [ 999 , 0 , 1024 , 1 , 2 , ‘Засланная строка-шпион’ , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # третий print
Отлично! Добавлять элементы в список мы научились, осталось понять, как их из него удалять. Метод pop() удаляет элемент из списка по его индексу:
numbers = list ( range ( 10 ))
print (numbers) # 1
# Удаляем первый элемент
numbers. pop ( 0 )
print (numbers) # 2
numbers. pop ( 0 )
print (numbers) # 3
numbers. pop ( 2 )
print (numbers) # 4
# Чтобы удалить последний элемент, вызовем метод pop без аргументов
numbers. pop ()
print (numbers) # 5
numbers. pop ()
print (numbers) # 6
>>> [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # 1
>>> [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # 2
>>> [ 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # 3
>>> [ 2 , 3 , 5 , 6 , 7 , 8 , 9 ] # 4
>>> [ 2 , 3 , 5 , 6 , 7 , 8 ] # 5
>>> [ 2 , 3 , 5 , 6 , 7 ] # 6
Теперь мы знаем, как удалять элемент из списка по его индексу. Но что, если мы не знаем индекса элемента, но знаем его значение? Для такого случая у нас есть метод remove(), который удаляет первый найденный по значению элемент в списке.
all_types = [ 10 , ‘Python’ , 10 , 3.14 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]]
all_types. remove ( 3.14 )
print (all_types) # 1
all_types. remove ( 10 )
print (all_types) # 2
all_types. remove ( ‘Python’ )
print (all_types) # 3
>>> [ 10 , ‘Python’ , 10 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]] # 1
>>> [ ‘Python’ , 10 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]] # 2
>>> [ 10 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]] # 3
А сейчас немного посчитаем, посчитаем элементы списка с помощью метода count()
numbers = [ 100 , 100 , 100 , 200 , 200 , 500 , 500 , 500 , 500 , 500 , 999 ]
print (numbers. count ( 100 )) # 1
print (numbers. count ( 200 )) # 2
print (numbers. count ( 500 )) # 3
print (numbers. count ( 999 )) # 4
В программировании, как и в жизни, проще работать с упорядоченными данными, в них легче ориентироваться и что-либо искать. Метод sort() сортирует список по возрастанию значений его элементов.
numbers = [ 100 , 2 , 11 , 9 , 3 , 1024 , 567 , 78 ]
numbers. sort ()
print (numbers) # 1
fruits = [ ‘Orange’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Apple’ ]
fruits. sort ()
print (fruits) # 2
>>> [ 2 , 3 , 9 , 11 , 78 , 100 , 567 , 1024 ] # 1
>>> [ ‘Apple’ , ‘Banan’ , ‘Grape’ , ‘Orange’ , ‘Peach’ ] # 2
Мы можем изменять порядок сортировки с помощью параметра reverse. По умолчанию этот параметр равен False
fruits = [ ‘Orange’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Apple’ ]
fruits. sort ()
print (fruits) # 1
fruits. sort (reverse = True)
print (fruits) # 2
>>> [ ‘Apple’ , ‘Banan’ , ‘Grape’ , ‘Orange’ , ‘Peach’ ] # 1
>>> [ ‘Peach’ , ‘Orange’ , ‘Grape’ , ‘Banan’ , ‘Apple’ ] # 2
Иногда нам нужно перевернуть список, не спрашивайте меня зачем. Для этого в самом лучшем языке программирования на этой планете JavaScr..Python есть метод reverse():
numbers = [ 100 , 2 , 11 , 9 , 3 , 1024 , 567 , 78 ]
numbers. reverse ()
print (numbers) # 1
fruits = [ ‘Orange’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Apple’ ]
fruits. reverse ()
print (fruits) # 2
>>> [ 78 , 567 , 1024 , 3 , 9 , 11 , 2 , 100 ] # 1
>>> [ ‘Apple’ , ‘Banan’ , ‘Peach’ , ‘Grape’ , ‘Orange’ ] # 2
Допустим, у нас есть два списка и нам нужно их объединить. Программисты на C++ cразу же кинулись писать циклы for, но мы пишем на python, а в python у списков есть полезный метод extend(). Этот метод вызывается для одного списка, а в качестве аргумента ему передается другой список, extend() записывает в конец первого из них начало второго:
fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
vegetables = [ ‘Tomato’ , ‘Cucumber’ , ‘Potato’ , ‘Carrot’ ]
fruits. extend (vegetables)
print (fruits)
>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ , ‘Tomato’ , ‘Cucumber’ , ‘Potato’ , ‘Carrot’ ]
В природе существует специальный метод для очистки списка — clear()
fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
vegetables = [ ‘Tomato’ , ‘Cucumber’ , ‘Potato’ , ‘Carrot’ ]
fruits. clear ()
vegetables. clear ()
print (fruits)
print (vegetables)
Осталось совсем чуть-чуть всего лишь пара методов, так что делаем последний рывок! Метод index() возвращает индекс элемента. Работает это так: вы передаете в качестве аргумента в index() значение элемента, а метод возвращает его индекс:
fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
print (fruits. index ( ‘Apple’ ))
print (fruits. index ( ‘Banana’ ))
print (fruits. index ( ‘Grape’ ))
Финишная прямая! Метод copy(), только не падайте, копирует список и возвращает его брата-близнеца. Вообще, копирование списков — это тема достаточно интересная, давайте рассмотрим её по-подробнее.
Во-первых, если мы просто присвоим уже существующий список новой переменной, то на первый взгляд всё выглядит неплохо:
fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
new_fruits = fruits
print (fruits)
print (new_fruits)
>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
Но есть одно маленькое «НО»:
fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
new_fruits = fruits
fruits. pop ()
print (fruits)
print (new_fruits)
# Внезапно, из списка new_fruits исчез последний элемент
>>> [ ‘Banana’ , ‘Apple’ ]
>>> [ ‘Banana’ , ‘Apple’ ]
При прямом присваивании списков копирования не происходит. Обе переменные начинают ссылаться на один и тот же список! То есть если мы изменим один из них, то изменится и другой. Что же тогда делать? Пользоваться методом copy(), конечно:
fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
new_fruits = fruits. copy ()
fruits. pop ()
print (fruits)
print (new_fruits)
>>> [ ‘Banana’ , ‘Apple’ ]
>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
Отлично! Но что если у нас список в списке? Скопируется ли внутренний список с помощью метода copy() — нет:
fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ , [ ‘Orange’ , ‘Peach’ ]]
new_fruits = fruits. copy ()
fruits[ -1 ]. pop ()
print (fruits) # 1
print (new_fruits) # 2
>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ , [ ‘Orange’ ]] # 1
>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ , [ ‘Orange’ ]] # 2
Решение задач
1. Создайте список из 10 четных чисел и выведите его с помощью цикла for
2. Создайте список из 5 элементов. Сделайте срез от второго индекса до четвертого
3. Создайте пустой список и добавьте в него 10 случайных чисел и выведите их. В данной задаче нужно использовать функцию randint.
from random import randint
n = randint ( 1 , 10 ) # Случайное число от 1 до 10
4. Удалите все элементы из списка, созданного в задании 3
5. Создайте список из введенной пользователем строки и удалите из него символы ‘a’, ‘e’, ‘o’
6. Даны два списка, удалите все элементы первого списка из второго
a = [ 1 , 3 , 4 , 5 ]
b = [ 4 , 5 , 6 , 7 ]
# Вывод
>>> [ 6 , 7 ]
7. Создайте список из случайных чисел и найдите наибольший элемент в нем.
8. Найдите наименьший элемент в списке из задания 7
9. Найдите сумму элементов списка из задания 7
10. Найдите среднее арифметическое элементов списка из задания 7
Сложные задачи
1. Создайте список из случайных чисел. Найдите номер его последнего локального максимума (локальный максимум — это элемент, который больше любого из своих соседей).
2. Создайте список из случайных чисел. Найдите максимальное количество его одинаковых элементов.
3. Создайте список из случайных чисел. Найдите второй максимум.
a = [ 1 , 2 , 3 ] # Первый максимум == 3, второй == 2
4. Создайте список из случайных чисел. Найдите количество различных элементов в нем.
Create a List With a Specific Size in Python
Preallocating storage for lists or arrays is a typical pattern among programmers
when they know the number of elements ahead of time.
Unlike C++ and Java, in Python, you have to initialize all of your pre-allocated storage with some values. Usually, developers use false values for that purpose, such as None , » , False , and 0 .
Please enable JavaScript
Python offers several ways to create a list of a fixed size, each with
different performance characteristics.
To compare performances of different approaches, we will use Python’s standard
module timeit .
It provides a handy way to measure run times of small chunks of Python code.
Preallocate Storage for Lists
The first and fastest way to use the * operator, which repeats a list a specified
number of times.
A million iterations (default value of iterations in timeit ) take approximately
117 ms.
Another approach is to use the range built-in function with a list comprehension.
It’s almost six times slower and takes 612 ms second per million iterations.
The third approach is to use a simple for loop together with the list.append() .
Using loops is the slowest method and takes 842 ms to complete a million iterations.
Preallocate Storage for Other Sequential Data Structures
Since you’re preallocating storage for a sequential data structure, it may make a lot of sense to use the array built-in data structure instead of a list.
As we see below, this approach is second fastest after [None] * 10 .
Let’s compare the above pure Python approaches to the NumPy Python package for scientific computing.
The NumPy way takes 589 ms per million iterations.
However, the NumPy way will be much faster for more massive lists.
The conclusion is that it’s best to stick to [None] * 10 for small lists, but switch
to NumPy’s empty() when dealing with more massive sequential data.
Create an empty list with certain size in Python
How do I create an empty list that can hold 10 elements?
After that, I want to assign values in that list. For example:
However, that gives IndexError: list assignment index out of range . Why?
Editor’s note:
In Python, lists do not have a set capacity, but it is not possible to assign to elements that aren’t already present. Answers here show code that creates a list with 10 "dummy" elements to replace later. However, most beginners encountering this problem really just want to build a list by adding elements to it. That should be done using the .append method, although there will often be problem-specific ways to create the list more directly. Please see Why does this iterative list-growing code give IndexError: list assignment index out of range? How can I repeatedly add elements to a list? for details.
18 Answers 18
You cannot assign to a list like xs[i] = value , unless the list already is initialized with at least i+1 elements (because the first index is 0). Instead, use xs.append(value) to add elements to the end of the list. (Though you could use the assignment notation if you were using a dictionary instead of a list.)
Creating an empty list:
Assigning a value to an existing element of the above list:
Keep in mind that something like xs[15] = 5 would still fail, as our list has only 10 elements.
range(x) creates a list from [0, 1, 2, . x-1]
Using a function to create a list:
List comprehension (Using the squares because for range you don’t need to do all this, you can just return range(0,9) ):
Try this instead:
The above will create a list of size 10, where each position is initialized to None . After that, you can add elements to it:
Admittedly, that’s not the Pythonic way to do things. Better do this:
Or even simpler, in Python 2.x you can do this to initialize a list with values from 0 to 9:
And in Python 3.x:
varunl’s currently accepted answer
Works well for non-reference types like numbers. Unfortunately if you want to create a list-of-lists you will run into referencing errors. Example in Python 2.7.6:
As you can see, each element is pointing to the same list object. To get around this, you can create a method that will initialize each position to a different object reference.
There is likely a default, built-in python way of doing this (instead of writing a function), but I’m not sure what it is. Would be happy to be corrected!
Edit: It’s [ [] for _ in range(10)]
I’m surprised nobody suggest this simple approach to creating a list of empty lists. This is an old thread, but just adding this for completeness. This will create a list of 10 empty lists
There are two «quick» methods:
It appears that [None]*x is faster:
But if you are ok with a range (e.g. [0,1,2,3. x-1] ), then range(x) might be fastest:
You can .append(element) to the list, e.g.:
What you are currently trying to do is access an element ( s1[i] ) that does not exist.
The accepted answer has some gotchas. For example:
So each dictionary refers to the same object. Same holds true if you initialize with arrays or objects.
You could do this instead:
How do I create an empty list that can hold 10 elements?
All lists can hold as many elements as you like, subject only to the limit of available memory. The only "size" of a list that matters is the number of elements currently in it.
However, that gives IndexError: list assignment index out of range . Why?
The first time through the loop, i is equal to 0 . Thus, we attempt xs[0] = 0 . This does not work because there are currently 0 elements in the list, so 0 is not a valid index.
We cannot use indexing to write list elements that don’t already exist — we can only overwrite existing ones. Instead, we should use the .append method:
The next problem you will note is that your list will actually have only 9 elements, because the end point is skipped by the range function. (As side notes: [] works just as well as list() , the semicolon is unnecessary, and only one parameter is needed for range if you’re starting from 0 .) Addressing those issues gives:
However, this is still missing the mark — range is not some magical keyword that’s part of the language the way for (or, say, def ) is.
In 2.x, range is a function, which directly returns the list that we already wanted:
In 3.x, range is a cleverly designed class, and range(10) creates an instance. To get the desired list, we can simply feed it to the list constructor:
Список (list) в Python
Списки в Python используются для одновременного хранения множества данных. Список создается путем размещения элементов внутри квадратных скобок [] , разделенных запятыми. Список может содержать любое количество элементов, и они могут быть разных типов (int, float, string и др.).
Создание списка в Python
Список создается путем размещения элементов внутри [] , разделенных запятыми. Например:
Здесь мы создали список с именем numbers , содержащий 3 целочисленных элемента.
Список может содержать любое количество элементов, и они могут быть разных типов (int, float, string и т.д.). Например:
Доступ к элементам списка в Python
В Python каждый элемент списка ассоциируется с индексом. Мы можем получить доступ к элементам массива, используя номер индекса (0, 1, 2,…). Например:
Здесь мы видим, что каждый элемент списка связан с номером индекса. И мы использовали индекс для доступа к элементам.
Примечание: Отсчет элементов в списке всегда начинается с индекса 0. Отсюда следует, что первый элемент списка находится под индексом 0, а не 1.
Отрицательная индексация в Python
Python позволяет использовать отрицательный индекс для своих последовательностей. Индекс -1 относится к последнему элементу, -2 относится к предпоследнему элементу и так далее. Например:
Примечание: Если указанный индекс не существует в списке, то Python выдаст ошибку IndexError .
Срез списка в Python
В Python с помощью оператора среза : можно получить доступ сразу к группе элементов (а не только к одному). Например:
Примечание: При выполнении среза в списках, первый индекс является включающим, а конечный — исключающим.
Добавление элементов в список в Python
В Python есть сразу несколько методов для добавления элементов в список.
1. Использование метода append()
Метод append() добавляет элемент в конец списка. Например:
Before Append: [21, 34, 54, 12]
After Append: [21, 34, 54, 12, 32]
Мы создали список с именем numbers . Обратите внимание на строку:
Здесь функция append() добавляет 32 в конец массива.
2. Использование метода extend()
Метод extend() используется для добавления всех элементов одного списка в другой. Например:
List1: [2, 3, 5]
List2: [4, 6, 8]
List after append: [2, 3, 5, 4, 6, 8]
У нас есть два списка с именами prime_numbers и even_numbers . Обратите внимание на стейтмент:
Здесь мы добавили все элементы even_numbers к prime_numbers .
Изменения значений элементов списка
Списки в Python являются изменяемыми. Это означает, что мы можем изменять элементы списка, присваивая им новые значения с помощью оператора = . Например:
Удаление элементов из списка
1. Использование оператора del
В Python мы можем использовать оператор del для удаления одного или нескольких элементов из списка. Например:
2. Использование метода remove()
Мы также можем использовать метод remove() для удаления элементов из списка. Например:
Методы для работы со списками в Python
Рассмотрим наиболее часто используемые методы для работы со списками в Python.
| Метод | Описание |
| append() | Добавляет элемент в конец списка. |
| extend() | Добавляет элементы из списка в конец другого списка. |
| insert() | Вставляет элемент по указанному индексу. |
| remove() | Удаляет элемент по указанному индексу. |
| pop() | Возвращает и удаляет элемент, присутствующий по указанному индексу. |
| clear() | Удаляет все элементы из списка. |
| index() | Возвращает индекс указанного элемента. |
| count() | Возвращает количество указанных элементов в списке. |
| sort() | Сортирует список в порядке возрастания/убывания. |
| reverse() | Возвращает список в обратном порядке («разворачивает» последовательность). |
| copy() | Возвращает *поверхностную копию списка. |
*Примечание: Поверхностная копия создает новый составной объект, и затем (по мере возможности) вставляет в него ссылки на объекты, находящиеся в оригинале. Глубокая копия создает новый составной объект, и затем рекурсивно вставляет в него копии объектов, находящихся в оригинале.
Итерация по списку в Python
Мы можем использовать цикл for для перебора элементов списка. Например: