Изучая программирование на Python, вы практически в самом начале знакомитесь со списками и различными операциями, которые можете выполнять над ними. В этой статье мы бы хотели рассказать об одной из таких операций над списками.
Представьте, что у вас есть список, состоящий из каких-то элементов, и вам нужно определить индекс элемента со значением x. Сегодня мы рассмотрим, как узнать индекс определенного элемента списка в Python.
Но сначала давайте убедимся, что все понимают, что представляет из себя список.
Список в Python — это встроенный тип данных, который позволяет нам хранить множество различных значений, таких как числа, строки, объекты datetime и так далее.
Важно отметить, что списки упорядочены. Это означает, что последовательность, в которой мы храним значения, важна.
Индексирование списка начинаются с нуля и заканчивается на длине списка минус один. Для получения более подробной информации о списках вы можете обратиться к статье «Списки в Python: полное руководство для начинающих».
Итак, давайте посмотрим на пример списка:
fruits = ["apple", "orange","grapes","guava"] print(type(fruits)) print(fruits[0]) print(fruits[1]) print(fruits[2]) # Результат: # <class 'list'> # apple # orange # grapes
Мы создали список из 4 элементов. Первый элемент в списке имеет нулевой индекс, второй элемент — индекс 1, третий элемент — индекс 2, а последний — 3.
Для списка получившихся фруктов fruits допустимыми индексами являются 0, 1, 2 и 3. При этом длина списка равна 4 (в списке 4 элемента). Индекс последнего элемента равен длине списка (4) минус один, то есть как раз 3.
[python_ad_block]
Как определить индекс элемента списка в Python
Итак, как же определить индекс элемента в Python? Давайте представим, что у нас есть элемент списка и нам нужно узнать индекс или позицию этого элемента. Сделать это можно следующим образом:
print(fruits.index('orange'))
# 1
print(fruits.index('guava'))
# 3
print(fruits.index('banana'))
# А здесь выскочит ValueError, потому что в списке нет значения banana Списки Python предоставляют нам метод index(), с помощью которого можно получить индекс первого вхождения элемента в список, как это показано выше.
Познакомиться с другими методами списков можно в статье «Методы списков Python».
Мы также можем заметить, что метод index() вызовет ошибку VauleError, если мы попытаемся определить индекс элемента, которого нет в исходном списке.
Для получения более подробной информации о методе index() загляните в официальную документацию.
Базовый синтаксис метода index() выглядит так:
list_var.index(item),
где list_var — это исходный список, item — искомый элемент.
Мы также можем указать подсписок для поиска, и синтаксис для этого будет выглядеть следующим образом:
list_var.index(item, start_index_of_sublist, end_index_of_sublist)
Здесь добавляются два аргумента: start_index_of_sublist и end_index_of_sublist. Тут всё просто. start_index_of_sublist обозначает, с какого элемента списка мы хотим начать поиск, а end_index_of_sublist, соответственно, на каком элементе (не включительно) мы хотим закончить.
Чтобы проиллюстрировать это для лучшего понимания, давайте рассмотрим следующий пример.
Предположим, у нас есть список book_shelf_genres, где индекс означает номер полки (индексация начинается с нуля). У нас много полок, среди них есть и полки с учебниками по математике.
Мы хотим узнать, где стоят учебники по математике, но не вообще, а после четвертой полки. Для этого напишем следующую программу:
book_shelf_genres = ["Fiction", "Math", "Non-fiction", "History", "Math", "Coding", "Cooking", "Math"]
print(book_shelf_genres.index("Math"))
# Результат:
# 1 Здесь мы видим проблему. Использование просто метода index() без дополнительных аргументов выдаст первое вхождение элемента в список, но мы хотим знать индекс значения «Math» после полки 4.
Для этого мы используем метод index() и указываем подсписок для поиска. Подсписок начинается с индекса 5 до конца списка book_shelf_genres, как это показано во фрагменте кода ниже:
print(book_shelf_genres.index("Math", 5))
# Результат:
# 7 Обратите внимание, что указывать конечный индекс подсписка необязательно.
Чтобы вывести индекс элемента «Math» после полки номер 1 и перед полкой номер 5, мы просто напишем следующее:
print(book_shelf_genres.index("Math", 2, 5))
# Результат:
# 4 Как найти индексы всех вхождений элемента в списке
А что, если искомое значение встречается в списке несколько раз и мы хотим узнать индексы всех этих элементов? Метод index() выдаст нам индекс только первого вхождения.
В этом случае мы можем использовать генератор списков:
book_shelf_genres = ["Fiction", "Math", "Non-fiction", "History", "Math", "Coding",
"Cooking", "Math"]
indices = [i for i in range(0, len(book_shelf_genres)) if book_shelf_genres[i]=="Math"]
print(indices)
# Результат:
# [1, 4, 7] В этом фрагменте кода мы перебираем индексы списка в цикле for и при помощи range(). Далее мы проверяем значение элемента под каждым индексом на равенство «Math«. Если значение элемента — «Math«, мы сохраняем значение индекса в списке.
Все это делается при помощи генератора списка, который позволяет нам перебирать список и выполнять некоторые операции с его элементами. В нашем случае мы принимаем решения на основе значения элемента списка, а в итоге создаем новый список.
Подробнее про генераторы списков можно почитать в статье «Генераторы списков в Python для начинающих».
Благодаря генератору мы получили все номера полок, на которых стоят книги по математике.
Как найти индекс элемента в списке списков
Теперь представьте ситуацию, что у вас есть вложенный список, то есть список, состоящий из других списков. И ваша задача — определить индекс искомого элемента для каждого из подсписков. Сделать это можно следующим образом:
programming_languages = [["C","C++","Java"],
["Python","Rust","R"],
["JavaScript","Prolog","Python"]]
indices = [(i, x.index("Python")) for i, x in enumerate(programming_languages) if "Python" in x]
print(indices)
# Результат:
# [(1, 0), (2, 2)] Здесь мы используем генератор списков и метод index(), чтобы найти индексы элементов со значением «Python» в каждом из имеющихся подсписков. Что же делает этот код?
Мы передаем список programming_languages методу enumerate(), который просматривает каждый элемент в списке и возвращает кортеж, содержащий индекс и значение элемента списка.
Каждый элемент в списке programming_languages также является списком. Оператор in проверяет, присутствует ли элемент «Python» в этом списке. Если да — мы сохраняем индекс подсписка и индекс элемента «Python» внутри подсписка в виде кортежа.
Результатом программы, как вы можете видеть, является список кортежей. Первый элемент кортежа — индекс подсписка, а второй — индекс искомого элемента в этом подсписке.
Таким образом, (1,0) означает, что подсписок с индексом 1 списка programming_languages имеет элемент «Python», который расположен по индексу 0. То есть, говоря простыми словами, второй подсписок содержит искомый элемент и этот элемент стоит на первом месте. Не забываем, что в Python индексация идет с нуля.
Как искать индекс элемента, которого, возможно, нет в списке
Бывает, нужно получить индекс элемента, но мы не уверены, есть ли он в списке.
Если попытаться получить индекс элемента, которого нет в списке, метод index() вызовет ошибку ValueError. При отсутствии обработки исключений ValueError вызовет аварийное завершение программы. Такой исход явно не является хорошим и с ним нужно что-то сделать.
Вот два способа, с помощью которых мы можем избежать такой ситуации:
books = ["Cracking the Coding Interview", "Clean Code", "The Pragmatic Programmer"]
ind = books.index("The Pragmatic Programmer") if "The Pragmatic Programmer" in books else -1
print(ind)
# Результат:
# 2 Один из способов — проверить с помощью оператора in, есть ли элемент в списке. Оператор in имеет следующий синтаксис:
var in iterable
Итерируемый объект — iterable — может быть списком, кортежем, множеством, строкой или словарем. Если var существует как элемент в iterable, оператор in возвращает значение True. В противном случае он возвращает False.
Это идеально подходит для решения нашей проблемы. Мы просто проверим, есть ли элемент в списке, и вызовем метод index() только если элемент существует. Это гарантирует, что метод index() не вызовет нам ошибку ValueError.
Но если мы не хотим тратить время на проверку наличия элемента в списке (это особенно актуально для больших списков), мы можем обработать ValueError следующим образом:
books = ["Cracking the Coding Interview", "Clean Code", "The Pragmatic Programmer"]
try:
ind = books.index("Design Patterns")
except ValueError:
ind = -1
print(ind)
# Результат:
# -1 Здесь мы применили конструкцию try-except для обработки ошибок. Программа попытается выполнить блок, стоящий после слова try. Если это приведет к ошибке ValueError, то она выполнит блок после ключевого слова except. Подробнее про обработку исключений с помощью try-except можно почитать в статье «Обрабатываем исключения в Python: try и except».
Заключение
Итак, мы разобрали как определить индекс элемента списка в Python. Теперь вы знаете, как это сделать с помощью метода index() и генератора списков.
Мы также разобрали, как использовать метод index() для вложенных списков и как найти каждое вхождение элемента в списке. Кроме того, мы рассмотрели ситуацию, когда нужно найти индекс элемента, которого, возможно, нет в списке.
Мы надеемся, что данная статья была для вас полезной. Успехов в написании кода!
Перевод статьи «Python Index – How to Find the Index of an Element in a List».
Finding the index of an item given a list containing it in Python
For a list
["foo", "bar", "baz"]and an item in the list"bar", what’s the cleanest way to get its index (1) in Python?
Well, sure, there’s the index method, which returns the index of the first occurrence:
>>> l = ["foo", "bar", "baz"]
>>> l.index('bar')
1
There are a couple of issues with this method:
- if the value isn’t in the list, you’ll get a
ValueError - if more than one of the value is in the list, you only get the index for the first one
No values
If the value could be missing, you need to catch the ValueError.
You can do so with a reusable definition like this:
def index(a_list, value):
try:
return a_list.index(value)
except ValueError:
return None
And use it like this:
>>> print(index(l, 'quux'))
None
>>> print(index(l, 'bar'))
1
And the downside of this is that you will probably have a check for if the returned value is or is not None:
result = index(a_list, value)
if result is not None:
do_something(result)
More than one value in the list
If you could have more occurrences, you’ll not get complete information with list.index:
>>> l.append('bar')
>>> l
['foo', 'bar', 'baz', 'bar']
>>> l.index('bar') # nothing at index 3?
1
You might enumerate into a list comprehension the indexes:
>>> [index for index, v in enumerate(l) if v == 'bar']
[1, 3]
>>> [index for index, v in enumerate(l) if v == 'boink']
[]
If you have no occurrences, you can check for that with boolean check of the result, or just do nothing if you loop over the results:
indexes = [index for index, v in enumerate(l) if v == 'boink']
for index in indexes:
do_something(index)
Better data munging with pandas
If you have pandas, you can easily get this information with a Series object:
>>> import pandas as pd
>>> series = pd.Series(l)
>>> series
0 foo
1 bar
2 baz
3 bar
dtype: object
A comparison check will return a series of booleans:
>>> series == 'bar'
0 False
1 True
2 False
3 True
dtype: bool
Pass that series of booleans to the series via subscript notation, and you get just the matching members:
>>> series[series == 'bar']
1 bar
3 bar
dtype: object
If you want just the indexes, the index attribute returns a series of integers:
>>> series[series == 'bar'].index
Int64Index([1, 3], dtype='int64')
And if you want them in a list or tuple, just pass them to the constructor:
>>> list(series[series == 'bar'].index)
[1, 3]
Yes, you could use a list comprehension with enumerate too, but that’s just not as elegant, in my opinion — you’re doing tests for equality in Python, instead of letting builtin code written in C handle it:
>>> [i for i, value in enumerate(l) if value == 'bar']
[1, 3]
Is this an XY problem?
The XY problem is asking about your attempted solution rather than your actual problem.
Why do you think you need the index given an element in a list?
If you already know the value, why do you care where it is in a list?
If the value isn’t there, catching the ValueError is rather verbose — and I prefer to avoid that.
I’m usually iterating over the list anyways, so I’ll usually keep a pointer to any interesting information, getting the index with enumerate.
If you’re munging data, you should probably be using pandas — which has far more elegant tools than the pure Python workarounds I’ve shown.
I do not recall needing list.index, myself. However, I have looked through the Python standard library, and I see some excellent uses for it.
There are many, many uses for it in idlelib, for GUI and text parsing.
The keyword module uses it to find comment markers in the module to automatically regenerate the list of keywords in it via metaprogramming.
In Lib/mailbox.py it seems to be using it like an ordered mapping:
key_list[key_list.index(old)] = new
and
del key_list[key_list.index(key)]
In Lib/http/cookiejar.py, seems to be used to get the next month:
mon = MONTHS_LOWER.index(mon.lower())+1
In Lib/tarfile.py similar to distutils to get a slice up to an item:
members = members[:members.index(tarinfo)]
In Lib/pickletools.py:
numtopop = before.index(markobject)
What these usages seem to have in common is that they seem to operate on lists of constrained sizes (important because of O(n) lookup time for list.index), and they’re mostly used in parsing (and UI in the case of Idle).
While there are use-cases for it, they are fairly uncommon. If you find yourself looking for this answer, ask yourself if what you’re doing is the most direct usage of the tools provided by the language for your use-case.
In this article you will learn how to find the index of an element contained in a list in the Python programming language.
There are a few ways to achieve this, and in this article you will learn three of the different techniques used to find the index of a list element in Python.
The three techniques used are:
- finding the index using the
index()list method, - using a
for-loop, - and finally, using list comprehension and the
enumerate()function.
Specifically, here is what we will cover in depth:
- An overview of lists in Python
- How indexing works
- Use the
index()method to find the index of an item
1.Use optional parameters with theindex()method - Get the indices of all occurrences of an item in a list
- Use a
for-loopto get indices of all occurrences of an item in a list - Use list comprehension and the
enumerate()function to get indices of all occurrences of an item in a list
- Use a
What are Lists in Python?
Lists are a built-in data type in Python, and one of the most powerful data structures.
They act as containers and store multiple, typically related, items under the same variable name.
Items are placed and enclosed inside square brackets, []. Each item inside the square brackets is separated by a comma, ,.
# a list called 'my_information' that contains strings and numbers
my_information = ["John Doe", 34, "London", 1.76]
From the example above, you can see that lists can contain items that are of any data type, meaning list elements can be heterogeneous.
Unlike arrays that only store items that are of the same type, lists allow for more flexibility.
Lists are also mutable, which means they are changeable and dynamic. List items can be updated, new items can be added to the list, and any item can be removed at any time throughout the life of the program.
An Overview of Indexing in Python
As mentioned, lists are a collection of items. Specifically, they are an ordered collection of items and they preserve that set and defined order for the most part.
Each element inside a list will have a unique position that identifies it.
That position is called the element’s index.
Indices in Python, and in all programming languages, start at 0 and not 1.
Let’s take a look at the list that was used in the previous section:
my_information = ["John Doe", 34, "London", 1.76]
The list is zero-indexed and counting starts at 0.
The first list element, "John Doe", has an index of 0.
The second list element, 34, has an index of 1.
The third list element, "London", has an index of 2.
The forth list element, 1.76, has an index of 3.
Indices come in useful for accessing specific list items whose position (index) you know.
So, you can grab any list element you want by using its index.
To access an item, first include the name of the list and then in square brackets include the integer that corresponds to the index for the item you want to access.
Here is how you would access each item using its index:
my_information = ["John Doe", 34, "London", 1.76]
print(my_information[0])
print(my_information[1])
print(my_information[2])
print(my_information[3])
#output
#John Doe
#34
#London
#1.76
But what about finding the index of a list item in Python?
In the sections that follow you will see some of the ways you can find the index of list elements.
So far you’ve seen how to access a value by referencing its index number.
What happens though when you don’t know the index number and you’re working with a large list?
You can give a value and find its index and in that way check the position it has within the list.
For that, Python’s built-in index() method is used as a search tool.
The syntax of the index() method looks like this:
my_list.index(item, start, end)
Let’s break it down:
my_listis the name of the list you are searching through..index()is the search method which takes three parameters. One parameter is required and the other two are optional.itemis the required parameter. It’s the element whose index you are searching for.startis the first optional parameter. It’s the index where you will start your search from.endthe second optional parameter. It’s the index where you will end your search.
Let’s see an example using only the required parameter:
programming_languages = ["JavaScript","Python","Java","C++"]
print(programming_languages.index("Python"))
#output
#1
In the example above, the index() method only takes one argument which is the element whose index you are looking for.
Keep in mind that the argument you pass is case-sensitive. This means that if you had passed «python», and not «Python», you would have received an error as «python» with a lowercase «p» is not part of the list.
The return value is an integer, which is the index number of the list item that was passed as an argument to the method.
Let’s look at another example:
programming_languages = ["JavaScript","Python","Java","C++"]
print(programming_languages.index("React"))
#output
#line 3, in <module>
# print(programming_languages.index("React"))
#ValueError: 'React' is not in list
If you try and search for an item but there is no match in the list you’re searching through, Python will throw an error as the return value — specifically it will return a ValueError.
This means that the item you’re searching for doesn’t exist in the list.
A way to prevent this from happening, is to wrap the call to the index() method in a try/except block.
If the value does not exist, there will be a message to the console saying it is not stored in the list and therefore doesn’t exist.
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
try:
print(programming_languages.index("React"))
except ValueError:
print("That item does not exist")
#output
#That item does not exist
Another way would be to check to see if the item is inside the list in the first place, before looking for its index number. The output will be a Boolean value — it will be either True or False.
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
print("React" in programming_languages)
#output
#False
How to Use the Optional Parameters with the index() Method
Let’s take a look at the following example:
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
print(programming_languages.index("Python"))
#output
#1
In the list programming_languages there are three instances of the «Python» string that is being searched.
As a way to test, you could work backwards as in this case the list is small.
You could count and figure out their index numbers and then reference them like you’ve seen in previous sections:
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
print(programming_languages[1])
print(programming_languages[3])
print(programming_languages[5])
#output
#Python
#Python
#Python
There is one at position 1, another one at position 3 and the last one is at position 5.
Why aren’t they showing in the output when the index() method is used?
When the index() method is used, the return value is only the first occurence of the item in the list. The rest of the occurrences are not returned.
The index() method returns only the index of the position where the item appears the first time.
You could try passing the optional start and end parameters to the index() method.
You already know that the first occurence starts at index 1, so that could be the value of the start parameter.
For the end parameter you could first find the length of the list.
To find the length, use the len() function:
print(len(programming_languages))
#output is 6
The value for end parameter would then be the length of the list minus 1. The index of the last item in a list is always one less than the length of the list.
So, putting all that together, here is how you could try to get all three instances of the item:
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
print(programming_languages.index("Python",1,5))
#output
#1
The output still returns only the first instance!
Although the start and end parameters provide a range of positions for your search, the return value when using the index() method is still only the first occurence of the item in the list.
How to Get the Indices of All Occurrences of an Item in A List
Use a for-loop to Get the Indices of All Occurrences of an Item in A List
Let’s take the same example that we’ve used so far.
That list has three occurrences of the string «Python».
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
First, create a new, empty list.
This will be the list where all indices of «Python» will be stored.
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
python_indices = []
Next, use a for-loop. This is a way to iterate (or loop) through the list, and get each item in the original list. Specifically, we loop over each item’s index number.
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
python_indices = []
for programming_language in range(len(programming_languages)):
You first use the for keyword.
Then create a variable, in this case programming_language, which will act as a placeholder for the position of each item in the original list, during the iterating process.
Next, you need to specify the set amount of iterations the for-loop should perform.
In this case, the loop will iterate through the full length of the list, from start to finish. The syntax range(len(programming_languages)) is a way to access all items in the list programming_languages.
The range() function takes a sequence of numbers that specify the number it should start counting from and the number it should end the counting with.
The len() function calculates the length of the list, so in this case counting would start at 0 and end at — but not include — 6, which is the end of the list.
Lastly, you need to set a logical condition.
Essentially, you want to say: «If during the iteration, the value at the given position is equal to ‘Python’, add that position to the new list I created earlier».
You use the append() method for adding an element to a list.
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
python_indices = []
for programming_language in range(len(programming_languages)):
if programming_languages[programming_language] == "Python":
python_indices.append(programming_language)
print(python_indices)
#output
#[1, 3, 5]
Use List Comprehension and the enumerate() Function to Get the Indices of All Occurrences of an Item in A List
Another way to find the indices of all the occurrences of a particular item is to use list comprehension.
List comprehension is a way to create a new list based on an existing list.
Here is how you would get all indices of each occurrence of the string «Python», using list comprehension:
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
python_indices = [index for (index, item) in enumerate(programming_languages) if item == "Python"]
print(python_indices)
#[1, 3, 5]
With the enumerate() function you can store the indices of the items that meet the condition you set.
It first provides a pair (index, item) for each element in the list (programming_languages) that is passed as the argument to the function.
index is for the index number of the list item and item is for the list item itself.
Then, it acts as a counter which starts counting from 0 and increments each time the condition you set is met, selecting and moving the indices of the items that meet your criteria.
Paired with the list comprehension, a new list is created with all indices of the string «Python».
Conclusion
And there you have it! You now know some of the ways to find the index of an item, and ways to find the indices of multiple occurrences of an item, in a list in Python.
I hope you found this article useful.
To learn more about the Python programming language, check out freeCodeCamp’s Scientific Computing with Python Certification.
You’ll start from the basics and learn in an interacitve and beginner-friendly way. You’ll also build five projects at the end to put into practice and help reinforce what you’ve learned.
Thanks for reading and happy coding!
Learn to code for free. freeCodeCamp’s open source curriculum has helped more than 40,000 people get jobs as developers. Get started
In this article you will learn how to find the index of an element contained in a list in the Python programming language.
There are a few ways to achieve this, and in this article you will learn three of the different techniques used to find the index of a list element in Python.
The three techniques used are:
- finding the index using the
index()list method, - using a
for-loop, - and finally, using list comprehension and the
enumerate()function.
Specifically, here is what we will cover in depth:
- An overview of lists in Python
- How indexing works
- Use the
index()method to find the index of an item
1.Use optional parameters with theindex()method - Get the indices of all occurrences of an item in a list
- Use a
for-loopto get indices of all occurrences of an item in a list - Use list comprehension and the
enumerate()function to get indices of all occurrences of an item in a list
- Use a
What are Lists in Python?
Lists are a built-in data type in Python, and one of the most powerful data structures.
They act as containers and store multiple, typically related, items under the same variable name.
Items are placed and enclosed inside square brackets, []. Each item inside the square brackets is separated by a comma, ,.
# a list called 'my_information' that contains strings and numbers
my_information = ["John Doe", 34, "London", 1.76]
From the example above, you can see that lists can contain items that are of any data type, meaning list elements can be heterogeneous.
Unlike arrays that only store items that are of the same type, lists allow for more flexibility.
Lists are also mutable, which means they are changeable and dynamic. List items can be updated, new items can be added to the list, and any item can be removed at any time throughout the life of the program.
An Overview of Indexing in Python
As mentioned, lists are a collection of items. Specifically, they are an ordered collection of items and they preserve that set and defined order for the most part.
Each element inside a list will have a unique position that identifies it.
That position is called the element’s index.
Indices in Python, and in all programming languages, start at 0 and not 1.
Let’s take a look at the list that was used in the previous section:
my_information = ["John Doe", 34, "London", 1.76]
The list is zero-indexed and counting starts at 0.
The first list element, "John Doe", has an index of 0.
The second list element, 34, has an index of 1.
The third list element, "London", has an index of 2.
The forth list element, 1.76, has an index of 3.
Indices come in useful for accessing specific list items whose position (index) you know.
So, you can grab any list element you want by using its index.
To access an item, first include the name of the list and then in square brackets include the integer that corresponds to the index for the item you want to access.
Here is how you would access each item using its index:
my_information = ["John Doe", 34, "London", 1.76]
print(my_information[0])
print(my_information[1])
print(my_information[2])
print(my_information[3])
#output
#John Doe
#34
#London
#1.76
But what about finding the index of a list item in Python?
In the sections that follow you will see some of the ways you can find the index of list elements.
So far you’ve seen how to access a value by referencing its index number.
What happens though when you don’t know the index number and you’re working with a large list?
You can give a value and find its index and in that way check the position it has within the list.
For that, Python’s built-in index() method is used as a search tool.
The syntax of the index() method looks like this:
my_list.index(item, start, end)
Let’s break it down:
my_listis the name of the list you are searching through..index()is the search method which takes three parameters. One parameter is required and the other two are optional.itemis the required parameter. It’s the element whose index you are searching for.startis the first optional parameter. It’s the index where you will start your search from.endthe second optional parameter. It’s the index where you will end your search.
Let’s see an example using only the required parameter:
programming_languages = ["JavaScript","Python","Java","C++"]
print(programming_languages.index("Python"))
#output
#1
In the example above, the index() method only takes one argument which is the element whose index you are looking for.
Keep in mind that the argument you pass is case-sensitive. This means that if you had passed «python», and not «Python», you would have received an error as «python» with a lowercase «p» is not part of the list.
The return value is an integer, which is the index number of the list item that was passed as an argument to the method.
Let’s look at another example:
programming_languages = ["JavaScript","Python","Java","C++"]
print(programming_languages.index("React"))
#output
#line 3, in <module>
# print(programming_languages.index("React"))
#ValueError: 'React' is not in list
If you try and search for an item but there is no match in the list you’re searching through, Python will throw an error as the return value — specifically it will return a ValueError.
This means that the item you’re searching for doesn’t exist in the list.
A way to prevent this from happening, is to wrap the call to the index() method in a try/except block.
If the value does not exist, there will be a message to the console saying it is not stored in the list and therefore doesn’t exist.
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
try:
print(programming_languages.index("React"))
except ValueError:
print("That item does not exist")
#output
#That item does not exist
Another way would be to check to see if the item is inside the list in the first place, before looking for its index number. The output will be a Boolean value — it will be either True or False.
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
print("React" in programming_languages)
#output
#False
How to Use the Optional Parameters with the index() Method
Let’s take a look at the following example:
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
print(programming_languages.index("Python"))
#output
#1
In the list programming_languages there are three instances of the «Python» string that is being searched.
As a way to test, you could work backwards as in this case the list is small.
You could count and figure out their index numbers and then reference them like you’ve seen in previous sections:
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
print(programming_languages[1])
print(programming_languages[3])
print(programming_languages[5])
#output
#Python
#Python
#Python
There is one at position 1, another one at position 3 and the last one is at position 5.
Why aren’t they showing in the output when the index() method is used?
When the index() method is used, the return value is only the first occurence of the item in the list. The rest of the occurrences are not returned.
The index() method returns only the index of the position where the item appears the first time.
You could try passing the optional start and end parameters to the index() method.
You already know that the first occurence starts at index 1, so that could be the value of the start parameter.
For the end parameter you could first find the length of the list.
To find the length, use the len() function:
print(len(programming_languages))
#output is 6
The value for end parameter would then be the length of the list minus 1. The index of the last item in a list is always one less than the length of the list.
So, putting all that together, here is how you could try to get all three instances of the item:
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
print(programming_languages.index("Python",1,5))
#output
#1
The output still returns only the first instance!
Although the start and end parameters provide a range of positions for your search, the return value when using the index() method is still only the first occurence of the item in the list.
How to Get the Indices of All Occurrences of an Item in A List
Use a for-loop to Get the Indices of All Occurrences of an Item in A List
Let’s take the same example that we’ve used so far.
That list has three occurrences of the string «Python».
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
First, create a new, empty list.
This will be the list where all indices of «Python» will be stored.
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
python_indices = []
Next, use a for-loop. This is a way to iterate (or loop) through the list, and get each item in the original list. Specifically, we loop over each item’s index number.
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
python_indices = []
for programming_language in range(len(programming_languages)):
You first use the for keyword.
Then create a variable, in this case programming_language, which will act as a placeholder for the position of each item in the original list, during the iterating process.
Next, you need to specify the set amount of iterations the for-loop should perform.
In this case, the loop will iterate through the full length of the list, from start to finish. The syntax range(len(programming_languages)) is a way to access all items in the list programming_languages.
The range() function takes a sequence of numbers that specify the number it should start counting from and the number it should end the counting with.
The len() function calculates the length of the list, so in this case counting would start at 0 and end at — but not include — 6, which is the end of the list.
Lastly, you need to set a logical condition.
Essentially, you want to say: «If during the iteration, the value at the given position is equal to ‘Python’, add that position to the new list I created earlier».
You use the append() method for adding an element to a list.
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
python_indices = []
for programming_language in range(len(programming_languages)):
if programming_languages[programming_language] == "Python":
python_indices.append(programming_language)
print(python_indices)
#output
#[1, 3, 5]
Use List Comprehension and the enumerate() Function to Get the Indices of All Occurrences of an Item in A List
Another way to find the indices of all the occurrences of a particular item is to use list comprehension.
List comprehension is a way to create a new list based on an existing list.
Here is how you would get all indices of each occurrence of the string «Python», using list comprehension:
programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]
python_indices = [index for (index, item) in enumerate(programming_languages) if item == "Python"]
print(python_indices)
#[1, 3, 5]
With the enumerate() function you can store the indices of the items that meet the condition you set.
It first provides a pair (index, item) for each element in the list (programming_languages) that is passed as the argument to the function.
index is for the index number of the list item and item is for the list item itself.
Then, it acts as a counter which starts counting from 0 and increments each time the condition you set is met, selecting and moving the indices of the items that meet your criteria.
Paired with the list comprehension, a new list is created with all indices of the string «Python».
Conclusion
And there you have it! You now know some of the ways to find the index of an item, and ways to find the indices of multiple occurrences of an item, in a list in Python.
I hope you found this article useful.
To learn more about the Python programming language, check out freeCodeCamp’s Scientific Computing with Python Certification.
You’ll start from the basics and learn in an interacitve and beginner-friendly way. You’ll also build five projects at the end to put into practice and help reinforce what you’ve learned.
Thanks for reading and happy coding!
Learn to code for free. freeCodeCamp’s open source curriculum has helped more than 40,000 people get jobs as developers. Get started
Содержание:развернуть
- Что такое список
-
Как списки хранятся в памяти?
- Базовая работа со списками
-
Объявление списка
-
Обращение к элементу списка в Python
-
Добавление в список
-
Добавление в список на указанную позицию
-
Изменение элементов списка
-
Удаление элемента из списка
-
Как проверить наличие элемента в списке
-
Объединение списков
-
Копирование списка Python
-
Цикл по списку
- Методы списков
- Вложенные списки
- Срезы
- Генераторы списков
- Best Practices
-
Как получить список в обратном порядке
-
Как перевести список в другой формат?
-
Как узнать индекс элемента в списке?
-
Как посчитать количество уникальных элементов в списке?
-
Как проверить список на пустоту?
-
Как создать список числовых элементов с шагом
Создание списка в Python может понадобиться для хранения в них коллекции объектов. Списки могут хранить объекты всех типов в одном, в отличие от массива в другом языке программирования. Также размер списка доступен к изменению.
Ниже разберёмся, как устроены списки, как с ними работать и приведём 6 примеров из практики.
Что такое список
Список (list) — тип данных, предназначенный для хранения набора или последовательности разных элементов.
[1, 33, 6, 9] # литерал списка в Python
Его можно сравнить со списком покупок для магазина: точно так же вносятся элементы, их тоже можно добавлять и корректировать.
Как списки хранятся в памяти?
Базовая C-структура списков в Python (CPython) выглядит следующим образом:
typedef struct {
PyObject_VAR_HEAD
PyObject **ob_item;
Py_ssize_t allocated;
} PyListObject;
Когда мы создаём список, в памяти под него резервируется объект, состоящий из 3-х частей:
PyObject_VAR_HEAD— заголовок;ob_item— массив указателей на элементы списка;allocated— количество выделенной памяти под элементы списка.
Объект списка хранит указатели на объекты, а не на сами объекты
Python размещает элементы списка в памяти, затем размещает указатели на эти элементы. Таким образом, список в Python — это массив указателей.
Базовая работа со списками
Объявление списка
Объявление списка — самый первый и главный этап его создания. Для объявления списка в Python существует несколько способов.
Вариант №1: Через литерал (выражение, создающее объект):
>>> elements = [1, 3, 5, 6]
>>> type(elements)
<class 'list'>
>>> print(elements)
[1, 3, 5, 6]
В данном примере мы создали список с заранее известными данными. Если нужен пустой список, в квадратных скобках ничего не указывается — elements = [].
Вариант №2: Через функцию list():
>>> elements = list()
>>> type(elements)
<class 'list'>
>>> print(elements)
[]
В этом примере создается пустой список.
Обращение к элементу списка в Python
Чтобы обратиться к элементу списка, достаточно указать его индекс:
>>> elements = [1, 2, 3, 'word']
>>> elements[3]
'word'
Индекс — это порядковый номер элемента в списке. В примере выше индексы (позиции в списке) соответственно будут: 0, 1, 2, 3.
Нумерация элементов списка в Python начинается с нуля
Существует также отрицательный индекс, рассмотрим на примере:
>>> elements = [1, 2, 3, 'word']
>>> elements[-4]
1
>>> elements[-1]
'word'
Отрицательные индексы работают справа налево (то есть индекс значения ‘1’ — -4, а отрицательный индекс ‘word’ — -1.
💡 Отрицательным индексом удобно пользоваться, когда необходимо обратиться к последнему элементу в списке, не высчитывая его номер. Любой конечный элемент будет с индексом, равным -1.
Добавление в список
В списках доступно добавление, изменение, удаление элементов. Рассмотрим каждый способ изменения элементов на примерах.
Для того чтобы добавить новый элемент в список, используется list.append(x), где list — список, x — нужное значение.
>>> elements = [1, 2, 3, 'word']
>>> elements.append('meow')
>>> print(elements)
[1, 2, 3, 'word', 'meow']
Для простого примера, рассмотрим создание списка с нуля с помощью метода append() :
>>> elements = []
>>> elements.append(1)
>>> elements.append('word')
>>> elements.append('meow')
>>> print(elements)
[1, 'word', 'meow']
Добавление в список на указанную позицию
Немаловажно обратить внимание на метод list.insert(i, x), где list — список, i — позиция, x — нужное значение.
>>> elements = [1, 2, 4]
>>> print(elements)
[1, 2, 4]
>>> elements.insert(2, 3)
>>> print(elements)
[1, 2, 3, 4]
Изменение элементов списка
Изменение элементов списка происходит следующим образом: нужно выбрать элемент по индексу (порядковому номеру элемента) и присвоить новое значение.
>>> elements = [2, 4, 6]
>>> elements[2] = 8
>>> print(elements)
[2, 4, 8]
В примере выше мы заменили 6 на 8.
Не забывайте, что счёт начинается с нуля, и в данном списке цифра 6 это 2-й элемент
Удаление элемента из списка
Для удаление из списка используют инструкцию del list[i], где list — список, i — индекс (позиция) элемента в списке:
>>> elements = [1, "test", 5, 7]
>>> del elements[1]
>>> print(elements)
[1, 5, 7]
Удалять можно как из текущего списка, так и из вложенных списков:
>>> my_list = ["hello", "world", "!"]
>>> elements = [1, my_list, "ok"]
>>> del elements[1][2]
>>> print(elements)
[1, ['hello', 'world'], 'ok']
Можно удалять целыми диапазонами:
>>> elements = [2, 4, 6, 8, 12]
>>> del elements[2:] # удаляем все элементы после 2-го элемента (включительно)
>>> print(elements)
[2, 4]
>>> elements = [2, 4, 6, 8, 12]
>>> del elements[:3] # удаляем все элементы до 3-го элемента
>>> print(elements)
[8, 12]
>>> elements = [2, 4, 6, 8, 12]
>>> del elements[1:3] # удаляем от 1-го элемента включительно до 3-го элемента
>>> print(elements)
[2, 8, 12]
Еще один способ удаления из списка — list.remove(x), где list — список, x — значение, которое нужно удалить:
>>> elements = [2, "test", 4]
>>> elements.remove("test")
>>> print(elements)
[2, 4]
Как проверить наличие элемента в списке
Для того чтобы проверить существование какого-либо элемента в списке, нужно воспользоваться оператором in. Рассмотрим на примере:
>>> elements = ['слон', 'кот', 'лошадь', 'змея', 'рыба']
>>> if 'кот' in elements:
print('meow')
meow
Объединение списков
Списки в Python можно объединять с помощью оператора + или метода extend . Выглядит это так:
>>> a = [1, 3, 5]
>>> b = [1, 2, 4, 6]
>>> print(a + b)
[1, 3, 5, 1, 2, 4, 6]
>>> hello = ["h", "e", "l", "l", "o"]
>>> world = ["w", "o", "r", "l", "d"]
>>> hello.extend(world) # extends не возвращает новый список, а дополняет текущий
>>> print(hello)
['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']
Копирование списка Python
Если вы захотите скопировать список оператором =, вы скопируете не сам список, а только его ссылку.
>>> a = [1, 2, 3]
>>> b = a # переменной b присваивается не значение списка a, а его адрес
>>> print(id(a), id(b))
56466376 56466376 # a и b ссылаются на один и тот же список
>>> b.append(4)
>>> print(a, b)
[1, 2, 3, 4] [1, 2, 3, 4]
Для копирования списков можно использовать несколько вариантов:
elements.copy()— встроенный метод copy (доступен с Python 3.3);list(elements)— через встроенную функциюlist();copy.copy(elements)— функцияcopy()из пакета copy;elements[:]— через создание среза (устаревший синтаксис).
Рассмотрим на примере каждый из этих способов:
>>> a = ["кот", "слон", "змея"]
>>> b = a.copy()
>>> print(id(a), id(b), a, b)
56467336 56467016 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']
>>> d = list(a)
>>> print(id(a), id(d), a, d)
56467336 60493768 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']
>>> import copy
>>> e = copy.copy(a) #
>>> print(id(a), id(e), a, e)
56467336 60491304 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']
>>> f = copy.deepcopy(a)
>>> print(id(a), id(f), a, f)
56467336 56467400 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']
>>> c = a[:] # устаревший синтаксис
>>> print(id(a), id(c), a, c)
56467336 60458408 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']
Важно: copy.copy(a) делает поверхностное копирование. Объекты внутри списка будут скопированы как ссылки на них (как в случае с оператором =). Если необходимо рекурсивно копировать всех элементов в списке, используйте copy.deepcopy(a)
Скопировать часть списка можно с помощью срезов. Есть несколько вариантов использования:
>>> a = ["кот", "слон", "змея"]
>>> b = a[2:] # с 2-го элемента (включительно) до конца списка
>>> print(b)
['змея']
>>> c = a[:2] # с начала списка по 2-й элемент
>>> print(c)
['кот', 'слон']
>>> d = a[1:2] # с 1-го элемента (включительно) по 2-й элемент
>>> print(d)
['слон']
>>> a = [1, 2, 3, 4, 5, 6, 7, 8]
>>> e = a[0:8:2] # c 0-го элемента по 8-й элемент с шагом 2
>>> print(e)
[1, 3, 5, 7]
Цикл по списку
Для перебора списков в Python есть два цикла: for и while.
elements = [1, 2, 3, "meow"]
for el in elements:
print(el)
Результат выполнения:
1
2
3
meow
Попробуем построить цикл while. Он выполняется, когда есть какое-либо определённое условие:
elements = [1, 2, 3, "meow"]
elements_len = len(elements)
i = 0
while i < elements_len:
print(elements[i])
i += 1
Результат выполнения:
1
2
3
meow
Из примеров выше можем сделать вывод, что конструкция for выглядит заметно компактнее, чем while.
Методы списков
list.append(x)— позволяет добавлять элемент в конец списка;list1.extend(list2)— предназначен для сложения списков;list.insert(i, x)— служит для добавления элемента на указанную позицию(i— позиция,x— элемент);list.remove(x)— удаляет элемент из списка (только первое вхождение);list.clear()— предназначен для удаления всех элементов (после этой операции список становится пустым []);list.copy()— служит для копирования списков.list.count(x)— посчитает количество элементовxв списке;list.index(x)— вернет позицию первого найденного элементаxв списке;list.pop(i)— удалит элемент из позицииi;list.reverse()— меняет порядок элементов в списке на противоположный;list.sort()— сортирует список.
Пример использования методов:
# append
>>> a = [1, 2, 3]
>>> a.append(4)
print(a)
[1, 2, 3, 4]
# extend
>>> elements = [1, 2, 3, "meow"]
>>> elements.extend([4, 5, "gaf"])
>>> print(elements)
[1, 2, 3, 'meow', 4, 5, 'gaf']
# insert
>>> a = [1, 3, 4]
>>> a.insert(1, 2) # insert добавит на позицию 1 цифру 2
>>> print(a)
[1, 2, 3, 4]
# remove
>>> elements = [1, "meow", 3, "meow"]
>>> elements.remove("meow") # remove удалит только первое вхождение
>>> print(elements)
[1, 3, 'meow']
# clear
>>> a = [1, 2, 3]
>>> a.clear()
>>> print(a)
[]
# copy
>>> a = [1, 2, 3]
>>> b = a.copy()
>>> print(id(a), id(b), a, b)
60458408 60491880 [1, 2, 3] [1, 2, 3]
# count
>>> elements = ["one", "two", "three", "one", "two", "one"]
>>> print(elements.count("one"))
3
# index
>>> elements = ["one", "two", "three", "one", "two", "three"]
>>> print(elements.index("three")) # index вернет первый найденный индекс
2
# pop (положительный индекс)
>>> elements = [1, "meow", 3, "wow"]
>>> elements.pop(1) # удаляет элемент с индексом 1
'meow' # pop возвращает удаленный элемент списка
>>> print(elements)
[1, 3, 'wow']
# pop (отрицательный индекс) [удаление с конца списка, начиная с -1]
elements = ["hello", "world", "!"]
elements.pop(-2)
'world'
>>> print(elements)
['hello', '!']
# pop (без индекса) [удалит из списка последний элемент]
>>> elements = [1, 2, 3]
>>> elements.pop() # по умолчанию, в методе pop индекс равен -1
3
>>> print(elements)
[1, 2]
# reverse
>>> a = [1, 2, 3]
>>> a.reverse()
>>> print(a)
[3, 2, 1]
# sort (по возрастанию)
>>> elements = [3, 19, 0, 3, 102, 3, 1]
>>> elements.sort()
>>> print(elements)
[0, 1, 3, 3, 3, 19, 102]
# sort (по убыванию)
>>> elements = [3, 19, 0, 3, 102, 3, 1]
>>> elements.sort(reverse = True)
>>> print(elements)
[102, 19, 3, 3, 3, 1, 0]
Вложенные списки
Список может содержать объекты разных типов: числовые, буквенные, а также списки. Список списков выглядит следующим образом:
>>> elements = [1, 2, [0.1, 0.2, 0.3]]
Для обращения к элементу вложенного списка нужно использовать два индекса: первый указывает на индекс главного списка, второй — индекс элемента во вложенном списке. Вот пример:
>>> elements = [["яблоки", 50], ["апельсины", 190], ["груши", 100]]
>>> print(elements[0])
['яблоки', 50]
>>> print(elements[1][0])
апельсины
Срезы
Срезы (slices) — это подмножества элементов списка. Срезу нужны, когда необходимо извлечь часть списка из полного списка.
У них есть свой собственный синтаксис. Записывается срез так же, как обращение к элементу, используя индекс. Пример:
elements[START:STOP:STEP]
В этом случае берётся срез от номера start (включительно) до stop (не включая его), а step — это шаг. По умолчанию start и stop равны 0, step равен 1.
>>> elements = [0.1, 0.2, 1, 2, 3, 4, 0.3, 0.4]
>>> int_elements = elements[2:6] # с 2-го элемента включительно по 6-й элемент
>>> print(id(elements), id(int_elements)) # elements и int_elements - 2 разных списка
53219112 53183848
>>> print(elements)
[0.1, 0.2, 1, 2, 3, 4, 0.3, 0.4] # срез не модифицирует исходный список
>>> print(int_elements)
[1, 2, 3, 4]
Генераторы списков
Генератором списка называется способ построения списка с применением выражения к каждому элементу, входящему в последовательность. Есть схожесть генератора списка и цикла for. На этом примере мы рассмотрим простейший генератор списков:
>>> c = [c * 3 for c in 'list']
>>> print(c)
['lll', 'iii', 'sss', 'ttt']
Таким образом мы получили отдельно взятые утроенные буквы слова, введённого в кавычки. Есть множество вариантов применения генератора списков.
Пример генератора списка:
>>> nums = [i for i in range(1, 15)]
>>> print(nums)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
Пример посложнее:
>>> c = [c + d for c in 'list' if c != 'i' for d in 'spam' if d != 'a']
>>> print(c)
['ls', 'lp', 'lm', 'ss', 'sp', 'sm', 'ts', 'tp', 'tm']
Это усложнённая конструкция генератора списков, в которой мы сделали все возможные наборы сочетаний букв из введённых слов. Буквы-исключения видны по циклу, где стоит знак != для одной переменной и другой.
Best Practices
Последние абзацы статьи будут посвящены лучшим решениям практических задач, с которыми так или иначе сталкивается Python-разработчик.
Как получить список в обратном порядке
Изменить порядок размещения элементов в списке помогает функция list.reverse():
>>> elements = [1, 2, 3, 4, 5, 6]
>>> elements.reverse()
>>> print(elements)
[6, 5, 4, 3, 2, 1]
Как перевести список в другой формат?
Иногда требуется перевести список в строку, в словарь или в JSON. Для этого нужно будет вывести список без скобок.
Перевод списка в строку осуществляется с помощью функции join(). На примере это выглядит так:
>>> fruits = ["яблоко", "груша", "ананас"]
>>> print(', '.join(fruits))
яблоко, груша, ананас
В данном случае в качестве разделителя используется запятая.
Словарь в Python — это такая же встроенная структура данных, наряду со списком. Преобразование списка в словарь — задача тоже несложная. Для этого потребуется воспользоваться функцией dict(). Вот пример преобразования:
>>> elements = [['1', 'a'],['2', 'b'],['3', 'c']]
>>> my_dict = dict(elements)
>>> print(my_dict)
{'1': 'a', '2': 'b', '3': 'c'}
JSON — это JavaScript Object Notation. В Python находится встроенный модуль json для кодирования и декодирования данных JSON. С применением метода json.dumps(x) можно запросто преобразовать список в строку JSON.
>>> import json
>>> json.dumps(['word', 'eye', 'ear'])
'["word", "eye", "ear"]'
Как узнать индекс элемента в списке?
Узнать позицию элемента в последовательности списка бывает необходимым, когда элементов много, вручную их не сосчитать, и нужно обращение по индексу. Для того чтобы узнать индекс элемента, используют функцию list.index(x).
>>> elements = [1, 3, 6, 9, 55]
>>> print(elements.index(9))
3
В качестве аргумента передаем значение, а на выходе получаем его индекс.
Как посчитать количество уникальных элементов в списке?
Самый простой способ — приведение списка к set (множеству). После этого останутся только уникальные элементы, которые мы посчитаем функцией len():
>>> words = ["one", "two", "one", "three", "one"]
>>> len(set(words))
3
Как проверить список на пустоту?
>>> a = []
>>> if not a:
print("список пуст!")
список пуст!
Как создать список числовых элементов с шагом
Создание списка числовых элементов с шагом может понадобиться не так и часто, но мы рассмотрим пример построения такого списка.
Шагом называется переход от одного элемента к другому. Если шаг отрицательный, произойдёт реверс массива, то есть отсчёт пойдёт справа налево. Вот так выглядит список с шагом.
>>> elements = [1, 2, 3, 4, 5, 8, 9, 10, 11, 14, 20]
>>> print(elements[0:11:2])
[1, 3, 5, 9, 11, 20]
Еще один вариант — воспользоваться генератором списков:
>>> elements = [c for c in range(0, 10, 2)] # от 0 (включительно) до 10 с шагом 2
>>> print(elements)
[0, 2, 4, 6, 8]
При разработке на языке Python, списки встречаются довольно часто. Знание основ работы со списками поможет быстро и качественно писать программный код 😉.
Как создать список?
Списки объявляются в квадратных скобках [ ].
z = [3, 7, 4, 2] # Создание спискаВ python списки хранят упорядоченный набор элементов, которые могут быть разных типов. В примере, указанном выше элементы имеют один и тот же тип int. Не обязательно все элементы должны быть одного типа.
# Создание списка с разными типам данных
heterogenousElements = [3, True, 'Витя', 2.0]
Этот список содержит int, bool, string и float.
Доступ к элементам списка
Каждый элемент имеет присвоенный ему индекс. Важно отметить, в python индекс первого элемента в списке — 0.
z = [3, 7, 4, 2] # создаем список
# обращение к первому элементу списка с индексом 0
print(z[0])
# элемент с индексом 0 -> 3
Также поддерживается отрицательная индексация. Отрицательная индексация начинается с конца. Иногда её удобнее использовать для получения последнего элемента в списке, потому что не нужно знать длину списка, чтобы получить доступ к последнему элементу.
# выведите последний элемент списка
>>> print(z[-1])
2
Вы также можете получить доступ к одному и тому же элементу с использованием положительных индексов (как показано ниже). Альтернативный способ доступа к последнему элементу в списке z.
Срезы(slice) списка
Срезы хороши для получения подмножества значений с вашего списка. На примере кода, приведенного ниже, он вернет список с элементами из индекса 0 и не включая индекс 2.
# Создайте список
z = [3, 7, 4, 2]
# Вывод элементов с индексом от 0 до 2 (не включая 2)
print(z[0:2])
# вывод: [3, 7]
# Все, кроме индекса 3
>>> print(z[:3])
[3, 7, 4]
Код, указанный ниже возвращает список с элементами начиная с индекса 1 до конца.
# начиная с индекса 1 до конца списка
>>> print(z[1:])
[7, 4, 2]
Изменение элементов в списке
Списки в Python изменяемы. Это означает, что после создания списка можно обновить его отдельные элементы.
z = [3, 7, 4, 2] # Создание списка
# Изменяем элемент с индексом 1 на строку 'fish'
z[1] = 'fish'
print(z)
[3, 'fish', 4, 2]У списков Python есть разные методы, которые помогают в программировании. В этом разделе рассматриваются все методы списков.
Метод Index
Метод index возвращает положение первого индекса, со значением х. В указанном ниже коде, он возвращает назад 0.
# Создайте список
>>> z = [4, 1, 5, 4, 10, 4]
>>> print(z.index(4))
0
Вы также можете указать, откуда начинаете поиск.
>>> print(z.index(4, 3))
3
Метод Count
Метод count работает так, как звучит. Он считает количество раз, когда значение появляется в списке.
>>> random_list = [4, 1, 5, 4, 10, 4]
>>> print(random_list.count(4))
3
Метод Sort
Метод sort сортирует и меняет исходный список.
z = [3, 7, 4, 2]
z.sort()
print(z)
[2, 3, 4, 7]
Вышеуказанный код сортирует список чисел от наименьшего к наибольшему. Код, указанный ниже, показывает, как вы можете сортировать список от наибольшего к наименьшему.
# Сортировка и изменение исходного списка от наивысшего к наименьшему
z.sort(reverse = True)
print(z)
[7, 4, 3, 2]Следует отметить, что вы также можете отсортировать список строк от А до Я (или A-Z) и наоборот.
# Сортировка списка строками
names = ["Стив", "Рейчел", "Майкл", "Адам", "Джессика", "Лестер"]
names.sort()
print(names)
['Адам', 'Джессика', 'Лестер', 'Майкл', 'Рейчел', 'Стив']Метод Append
Метод append добавляет элемент в конец списка. Это происходит на месте.
z = [7, 4, 3, 2]
z.append(3)
print(z)
[7, 4, 3, 2, 3]Метод Remove
z = [7, 4, 3, 2, 3]
z.remove(2)
print(z)
Код удаляет первое вхождение значения 2 из списка z.
[7, 4, 3, 3]Метод Pop
Метод pop удаляет элемент в указанном индексе. Этот метод также вернет элемент, который был удален из списка. В случае, если вы не указали индекс, он по умолчанию удалит элемент по последнему индексу.
z = [7, 4, 3, 3]
print(z.pop(1))
print(z)
4
[7, 3, 3]Метод Extend
Метод extend расширяет список, добавляя элементы. Преимущество над append в том, что вы можете добавлять списки.
Добавим [4, 5] в конец z:
z = [7, 3, 3]
z.extend([4,5])
print(z)
[7, 3, 3, 4, 5]То же самое можно было бы сделать, используя +.
>>> print([1,2] + [3,4])
[7, 3, 3, 4, 5]
Метод Insert
Метод insert вставляет элемент перед указанным индексом.
z = [7, 3, 3, 4, 5]
z.insert(4, [1, 2])
print(z)
[7, 3, 3, 4, [1, 2], 5]Простые операции над списками
| Метод | Описаниее |
|---|---|
x in s | True если элемент x находится в списке s |
x not in s | True если элемент x не находится в списке s |
s1 + s2 | Объединение списков s1 и s2 |
s * n , n * s | Копирует список s n раз |
len(s) | Длина списка s, т.e. количество элементов в s |
min(s) | Наименьший элемент списка s |
max(s) | Наибольший элемент списка s |
sum(s) | Сумма чисел списка s |
for i in list() | Перебирает элементы слева направо в цикле for |
Примеры использование функций со списками:
>>> list1 = [2, 3, 4, 1, 32]
>>> 2 in list1 # 2 в list1?
True
>>> 33 not in list1 # 33 не в list1?
True
>>> len(list1) # количество элементов списка
5
>>> max(list1) # самый большой элемент списка
32
>>> min(list1) # наименьший элемент списка
1
>>> sum(list1) # сумма чисел в списке
42
# генератор списков python (list comprehension)
>>> x = [i for i in range(10)]
>>> print(x)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print(list1.reverse()) # разворачивает список
[32, 1, 4, 3, 2]
Операторы + и * для списков
+ объединяет два списка.
list1 = [11, 33]
list2 = [1, 9]
list3 = list1 + list2
print(list3)
[11, 33, 1, 9]* копирует элементы в списке.
list4 = [1, 2, 3, 4]
list5 = list4 * 3
print(list5)
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]Оператор in и not in
Оператор in проверяет находится ли элемент в списке. При успешном результате он возвращает True, в случае неудачи, возвращает False .
>>> list1 = [11, 22, 44, 16, 77, 98]
>>> 22 in list1
True
Аналогично not in возвращает противоположный от оператора in результат.
>>> 22 not in list1
False
Итерация по списку с использованием цикла for
Список — последовательность. Ниже способ, которые вы можете использовать для цикла, чтобы перебрать все элементы списка.
list1 = [1,2,3,4,5]
for i in list1:
print(i, end=" ")
1 2 3 4 5Преобразование списка в строку
Как преобразовать список в строку?
Для преобразования списка в строку используйте метод join(). В Python это выглядит так: ",".join(["a", "b", "c"]) -> "a,b,c".
Разделитель пишут в кавычках перед join, в список должен состоять из строк.
Вот несколько полезных советов для преобразования списка в строку (или любого другого итерабельного, такого как tuple).
Во-первых, если это список строк, вы можете просто использовать join() следующим образом.
mylist = ['spam', 'ham', 'eggs']
print(', '.join(mylist))
spam, ham, eggsИспользуя тот же метод, вы можете также сделать следующее:
>>> print('n'.join(mylist))
spam
ham
eggs
Однако этот простой метод не работает, если список содержит не строчные объекты, такие как целые числа. Если вы просто хотите получить строку с разделителями-запятыми, вы можете использовать этот шаблон:
list_of_ints = [80, 443, 8080, 8081]
print(str(list_of_ints).strip('[]'))
80, 443, 8080, 8081Или же этот, если ваши объекты содержат квадратные скобки:
>>> print(str(list_of_ints)[1:-1])
80, 443, 8080, 8081
В конце концов, вы можете использовать map() чтобы преобразовать каждый элемент в список строки и затем присоединиться к ним:
>>> print(', '.join(map(str, list_of_ints)))
80, 443, 8080, 8081
>>> print('n'.join(map(str, list_of_ints)))
80
443
8080
8081
Тест на знание списков в Python
Что выведет этот код:
a = [ 1, 342, 223, 'Африка', 'Очки']
print(a[-3])
Что выведет этот код:
sample = [10, 20, 30]
sample.append(60)
sample.insert(3, 40)
print(sample)
Что выведет этот код:
lake = ["Python", 51, False, "22"]
lake.reverse()
lake.reverse()
print(lake[-2])
Что из перечисленного правда?
Мы можем вставить элемент на любую позицию в списке
Все элементы списка должны быть одного типа
Элементы списка не могут повторятся
Список не может содержать вложенных списков
Как получить ['bar', 'baz'] из списка
a = ['foo', 'bar', 'baz', 'qux', 'quux']
?
Как получить 'bar' из списка
x = [10, [3.141, 20, [30, 'baz', 2.718]], 'foo']
?
Как избавиться от «3» в списке a = [1, 3, 5] и получить [1, 5]?
С помощью какого метода можно добавить сразу два элемента в список?
Что вернет этот код [1, 2] * 3?
When you’re learning to code, you eventually learn about lists and the different operations you can perform on them.
In this article, we’ll go through how you can find the index of a particular element which is stored in a list in Python.
What is a List in Python?
A list in Python is an in-built data type which allows us to store a bunch of different values, like numbers, strings, datetime objects and so on.
Lists are ordered, which means the sequence in which we store the values is important.
List indices start from zero and end at the length of the list minus one. For more detailed information on list data type, check out this comprehensive guide.
Let’s see an example of lists:
fruits = ["apple", "orange","grapes","guava"]
type(fruits)
print(fruits[0])
print(fruits[1])
print(fruits[2])
Here we created a list of 4 items, where we see that the first item in the list is at index zero, the second item is at index 1, the third item is at index 2, and so on.
For the fruits list, the valid list indices are 0, 1, 2 and 3.
Let’s do the reverse. That is, given a list item, let’s find out the index or position of that item in the list.
index = fruits.index('orange')
#The value of index is 1
index = fruits.index('guava')
#The value of index is 3
index = fruits.index('banana')
#This raises a ValueError as banana is not present in list
Python lists provide us with the index method which allows us to get the index of the first occurrence of a list item, as shown above.
We can also see that the index method will raise a VauleError if we try to find the index of an item which does not exist in the list.
For greater detail on the index method, check out the official docs here.
The basic syntax of the index method is this:
list_var.index(item)We can also specify a sublist in which to search, and the syntax for that is:
list_var.index(item, start_index_of_sublist, end_index_of_sublist)To illustrate this further, let’s look at an example.
Suppose we have a book_shelf_genres list where the index signifies the shelf number. We have many shelves containing math books. Shelf numbers also start from zero. We want to know which shelf after shelf 4 has any math books.
book_shelf_genres = ["Fiction", "Math", "Non-fiction", "History", "Math", "Coding", "Cooking", "Math"]
index = book_shelf_genres.index("Math")
#The value of index is 1We can see the problem here: using just index() will give the first occurrence of the item in the list – but we want to know the index of «Math» after shelf 4.
To do that, we use the index method and specify the sublist to search in. The sublist starts at index 5 until the end of the book_shelf_genres list, as shown in the code snippet below
index = book_shelf_genres.index("Math", 5)
#The value of index is 7Note that giving the end index of the sublist is optional. To find index of «Math» after shelf number 1 and before shelf number 5, we will simply do this:
index = book_shelf_genres.index("Math", 2, 5)
#The value of index is 4How to Find the Index of a List Item with Multiple Occurrences in Python
What if we need to know the index of a list item which occurs multiple times in a list? The index method won’t give us every occurrence.
In this case, we can find the multiple occurrences using list comprehension as follows:
book_shelf_genres = ["Fiction", "Math", "Non-fiction", "History", "Math", "Coding",
"Cooking", "Math"]
[i for i in range(0, len(book_shelf_genres)) if book_shelf_genres[i]=="Math"]
As shown in this code snippet, we loop over the indices of the list. At each index we check if the item at that index is Math or not. If it is Math then we store that index value in a list.
We do this entire process using list comprehension, which is just syntactic sugar that allows us to iterate over a list and perform some operation. In our case we are doing decision making based on the value of list item. Then we create a new list.
With this process, we now know all the shelf numbers which have math books on them.
How to Find the Index of List Items in a List of Lists in Python
programming_languages = [["C","C++","Java"],["Python","Rust","R"],
["JavaScript","Prolog","Python"]]
[ (i, x.index("Python")) for i, x in enumerate(programming_languages) if "Python" in x ]
Here we use list comprehension and the index method to find the index of «Python» in each of the sublists.
We pass the programming_languages list to the enumerate method which goes over each item in list and returns a tuple containing the index and item of the list at that index.
Each item in programming_languages list is also a list. The in operator then checks whether «Python» is present in this list or not. If present, we store the sublist index and index of «Python» inside the sublist as a tuple.
The output is a list of tuples. The first item in the tuple specifies the sublist index, and the second number specifies the index within the sublist.
So (1,0) means that the sublist at index 1 of the programming_languages list has the «Python» item at index 0.
How to Find the Index of a List Item that May Not Exist in a List in Python
In many cases, we will end up trying to get the index of an item but we are not sure if the item exists in the list or not.
If we have a piece of code which tries to get index of an item which isn’t present in the list, the index() method will raise a ValueError. In the absence of exception handling, this ValueError will cause abnormal program termination.
Here’s two ways in which we can avoid or handle this situation:
books = ["Cracking the Coding Interview", "Clean Code", "The Pragmatic Programmer"]
ind = books.index("The Pragmatic Programmer") if "The Pragmatic Programmer" in books else -1
One way is to check using the «in» operator if the item exists in list or not. The in operator has the basic syntax of
var in iterablewhere iterable could be a list, tuple, set, string or dictionary. If var exists as an item in the iterable, the in operator returns True. Else it returns False.
This is ideal for our case. We will simply check if an item exists in the list or not and only when it exists we will call index() method. This makes sure that the index() method doesn’t raise a ValueError.
If we don’t want to spend time checking if an item exists in the list or not, especially for large lists, we can handle the ValueError like this:
books = ["Cracking the Coding Interview", "Clean Code", "The Pragmatic Programmer"]
try:
ind = books.index("Design Patterns")
except ValueError:
ind = -1
ind
Wrapping up
Today we learnt how to find the index of an item in a list using the index() method.
We also saw how to use the index method over sublists, how to find the index of items in a list of lists, how to find every occurrence of an item in a list, and how to check for items in lists which may not be present.
I hope you found this article useful and an enjoyable read. Happy coding!
Learn to code for free. freeCodeCamp’s open source curriculum has helped more than 40,000 people get jobs as developers. Get started