Python используется во всем мире для различных областей, таких как создание веб-сайтов, искусственный интеллект и многое другое. Но чтобы все это стало возможным, данные играют очень важную роль, а это значит, что эти данные должны храниться эффективно, а доступ к ним должен быть своевременным. Так как же этого добиться? Мы используем то, что называется структурами данных. При этом давайте рассмотрим темы, которые мы рассмотрим в разделе Структуры данных в Python.
Статья разбита на следующие части:
- Что такое структура данных?
- Типы структур данных в Python
- Встроенные структуры данных
- Список
- Словарь
- Кортеж
- Наборы
- Пользовательские структуры данных
- Массивы против списка
- Куча
- Очередь
- Деревья
- Связанные списки
- Графики
- HashMaps
Что такое структура данных?
Организация, управление и хранение данных очень важны, поскольку они обеспечивают более легкий доступ и эффективное изменение. Структуры данных позволяют вам организовать ваши данные таким образом, чтобы вы могли хранить наборы данных, связывать их и выполнять с ними соответствующие операции.
Типы структур данных в Python
Python имеет неявную поддержку структур данных, которые позволяют хранить данные и получать к ним доступ. Эти структуры называются List, Dictionary, Tuple и Set.
Python позволяет своим пользователям создавать свои собственные структуры данных, что дает им полный контроль над их функциональностью. Наиболее известными структурами данных являются стек, очередь, дерево, связанный список и т. д., которые также доступны вам на других языках программирования. Итак, теперь, когда вы знаете, какие типы вам доступны, почему бы нам не перейти к структурам данных и не реализовать их с помощью Python.
Встроенные структуры данных
Как следует из названия, эти структуры данных встроены в Python, что упрощает программирование и помогает программистам использовать их для более быстрого получения решений. Давайте подробно обсудим каждый из них.
Списки
Списки используются для последовательного хранения данных разных типов. Каждому элементу списка присвоены адреса, которые называются индексами. Значение индекса начинается с 0 и продолжается до последнего элемента, называемого положительным индексом. Существует также отрицательное индексирование, которое начинается с -1, что позволяет вам обращаться к элементам от последнего к первому. Давайте теперь лучше разберемся со списками с помощью примера программы.
Создание списка
Чтобы создать список, вы используете квадратные скобки и соответственно добавляете в него элементы. Если вы не передадите какие-либо элементы внутри квадратных скобок, вы получите пустой список в качестве вывода.
my_list = [] #create empty list print(my_list) my_list = [1, 2, 3, 'example', 3.132] #creating list with data print(my_list)
Вывод:
[]
[1, 2, 3, "пример", 3,132]
Добавление элементов
Добавление элементов в список может быть выполнено с помощью функций append(), extend() и insert().
- Функция append() добавляет все переданные ей элементы как один элемент.
- Функция extend() добавляет элементы в список один за другим.
- Функция insert() добавляет переданный элемент к значению индекса и также увеличивает размер списка.
my_list = [1, 2, 3] print(my_list) my_list.append([555, 12]) #add as a single element print(my_list) my_list.extend([234, 'more_example']) #add as different elements print(my_list) my_list.insert(1, 'insert_example') #add element i print(my_list)
Вывод:
[1, 2, 3]
[1, 2, 3, [555, 12]]
[1, 2, 3, [555] , 12], 234, 'more_example']
[1, 'insert_example', 2, 3, [555, 12], 234, 'more_example']
Удаление элементов
- Чтобы удалить элементы, используйте ключевое слово del, встроенное в Python, но оно ничего нам не возвращает.
- Если вы хотите вернуть элемент, вы используете функцию pop(), которая принимает значение индекса.
- Чтобы удалить элемент по его значению, вы используете функцию remove().
Пример:
my_list = [1, 2, 3, 'example', 3.132, 10, 30]
del my_list[5] #delete element at index 5
print(my_list)
my_list.remove('example') #remove element with value
print(my_list)
a = my_list.pop(1) #pop element from list
print('Popped Element: ', a, ' List remaining: ', my_list)
my_list.clear() #empty the list
print(my_list)
Вывод:
[1, 2, 3, 'пример', 3.132, 30]
[1, 2, 3, 3.132, 30]
Всплывающий элемент: 2 Список оставшихся: [1, 3, 3.132, 30]
[]
Доступ к элементам
Доступ к элементам аналогичен доступу к строкам в Python. Вы передаете значения индекса и, следовательно, можете получать значения по мере необходимости.
my_list = [1, 2, 3, 'example', 3.132, 10, 30]
for element in my_list: #access elements one by one
print(element)
print(my_list) #access all elements
print(my_list[3]) #access index 3 element
print(my_list[0:2]) #access elements from 0 to 1 and exclude 2
print(my_list[::-1]) #access elements in reverse
Вывод:
1
2
3
пример
3,132
10
30
[1 , 2, 3, 'пример', 3.132, 10, 30]
пример
[1, 2]
[30, 10, 3.132, 'пример', 3, 2, 1]
Другие функции
У вас есть несколько других функций, которые можно использовать при работе со списками.
- Функция len() возвращает нам длину списка.
- Функция index() находит значение индекса переданного значения там, где оно встречается в первый раз.
- Функция count() находит количество переданного ей значения.
- Функции sorted() и sort() делают одно и то же, то есть сортируют значения списка. sorted() имеет возвращаемый тип, тогда как sort() изменяет исходный список.
my_list = [1, 2, 3, 10, 30, 10] print(len(my_list)) #find length of list print(my_list.index(10)) #find index of element that occurs first print(my_list.count(10)) #find count of the element print(sorted(my_list)) #print sorted list but not change original my_list.sort(reverse=True) #sort original list print(my_list)
Вывод:
6 3 2 [1, 2, 3, 10, 10, 30] [30, 10, 10, 3, 2, 1]
Словарь
Словари используются для хранения пар ключ-значение. Чтобы лучше понять, представьте себе телефонный справочник, в который добавлены сотни и тысячи имен и соответствующих им номеров. Теперь постоянными значениями здесь являются Имя и Телефонные номера, которые называются ключами. А различные имена и номера телефонов — это значения, которые были переданы на ключи. Если вы получите доступ к значениям ключей, вы получите все имена и номера телефонов. Вот что такое пара ключ-значение. А в Python эта структура хранится с помощью словарей. Давайте лучше поймем это на примере программы.
Создание словаря
Словари можно создавать с помощью фигурных скобок или с помощью функции dict(). Вам нужно добавлять пары ключ-значение всякий раз, когда вы работаете со словарями.
my_dict = {} #empty dictionary
print(my_dict)
my_dict = {1: 'Python', 2: 'Java'} #dictionary with elements
print(my_dict)
Вывод:
{}
{1: "Python", 2: "Java"}
Изменение и добавление пар ключ, значение
Чтобы изменить значения словаря, вам нужно сделать это с помощью ключей. Итак, вы сначала получаете доступ к ключу, а затем соответствующим образом меняете значение. Чтобы добавить значения, вы просто добавляете еще одну пару ключ-значение, как показано ниже.
my_dict = {'First': 'Python', 'Second': 'Java'}
print(my_dict)
my_dict['Second'] = 'C++' #changing element
print(my_dict)
my_dict['Third'] = 'Ruby' #adding key-value pair
print(my_dict)
Вывод:
{'Первый': 'Python', 'Второй': 'Java'}
{'Первый': 'Python', 'Второй': 'C++' }
{'Первый': 'Python', 'Второй': 'C++', 'Третий': 'Ruby'}
Удаление пар ключ, значение
- Чтобы удалить значения, вы используете функцию pop(), которая возвращает значение, которое было удалено.
- Чтобы получить пару ключ-значение, вы используете функцию popitem(), которая возвращает кортеж из ключа и значения.
- Чтобы очистить весь словарь, вы используете функцию clear().
my_dict = {'First': 'Python', 'Second': 'Java', 'Third': 'Ruby'}
a = my_dict.pop('Third') #pop element
print('Value:', a)
print('Dictionary:', my_dict)
b = my_dict.popitem() #pop the key-value pair
print('Key, value pair:', b)
print('Dictionary', my_dict)
my_dict.clear() #empty dictionary
print('n', my_dict)
Вывод:
Значение: Ruby
Словарь: {‘Первый’: ‘Python’, ‘Второй’: ‘Java’}
Ключ, пара значений: («Второй», «Java»)
Словарь {«Первый»: «Python»}
{}
Доступ к элементам
Вы можете получить доступ к элементам, используя только ключи. Вы можете использовать либо функцию get(), либо просто передать значения ключей, и вы получите значения.
my_dict = {'First': 'Python', 'Second': 'Java'} print(my_dict['First']) #access elements using keys print(my_dict.get('Second'))
Вывод:
Python
Java
Другие функции
У вас есть разные функции, которые возвращают нам ключи или значения пары ключ-значение соответственно функциям keys(), values(), items().
my_dict = {'First': 'Python', 'Second': 'Java', 'Third': 'Ruby'}
print(my_dict.keys()) #get keys
print(my_dict.values()) #get values
print(my_dict.items()) #get key-value pairs
print(my_dict.get('First'))
Вывод:
dict_keys(['Первый', 'Второй', 'Третий'])
dict_values(['Python', 'Java', 'Ruby'])< br /> dict_items([('Первый', 'Python'), ('Второй', 'Java'), ('Третий', 'Ruby')])
Python
Кортеж
Кортежи такие же, как и списки, за исключением того, что данные, однажды введенные в кортеж, не могут быть изменены ни при каких обстоятельствах. Единственное исключение — когда данные внутри кортежа изменяемы, только тогда можно изменить данные кортежа. Пример программы поможет вам лучше понять.
Создание кортежа
Вы создаете кортеж, используя скобки или функцию tuple().
my_tuple = (1, 2, 3) #create tuple print(my_tuple)
Вывод:
(1, 2, 3)
Доступ к элементам
Доступ к элементам аналогичен доступу к значениям в списках.
my_tuple2 = (1, 2, 3, 'edureka') #access elements
for x in my_tuple2:
print(x)
print(my_tuple2)
print(my_tuple2[0])
print(my_tuple2[:])
print(my_tuple2[3][4])
Вывод:
1
2
3
edureka
(1, 2, 3, 'edureka')
1< br /> (1, 2, 3, 'эдурека')
е
Добавление элементов
Чтобы добавить значения, вы используете оператор «+», который присоединяется к другому кортежу.
my_tuple = (1, 2, 3) my_tuple = my_tuple + (4, 5, 6) #add elements print(my_tuple)
Вывод:
(1, 2, 3, 4, 5, 6)
Другие функции
Эти функции такие же, как и для списков.
my_tuple = (1, 2, 3, ['hindi', 'python']) my_tuple[3][0] = 'english' print(my_tuple) print(my_tuple.count(2)) print(my_tuple.index(['english', 'python']))
Наборы
Наборы — это наборы неупорядоченных элементов, которые уникальны. Это означает, что даже если данные повторяются более одного раза, они будут введены в набор только один раз. Это напоминает наборы, которые вы изучали в арифметике. Операции такие же, как и с арифметическими множествами. Пример программы поможет вам лучше понять.
Создание набора
Наборы создаются с помощью фигурных скобок, но вместо добавления пар ключ-значение вы просто передаете им значения.
my_set = {1, 2, 3, 4, 5, 5, 5} #create set
print(my_set)
Вывод:
{1, 2, 3, 4, 5}
Добавление элементов
Чтобы добавить элементы, вы используете функцию add() и передаете ей значение.
my_set = {1, 2, 3}
my_set.add(4) #add element to set
print(my_set)
Операции в множествах
Различные операции начала, такие как объединение, пересечение и т. д., показаны ниже.
my_set = {1, 2, 3, 4}
my_set_2 = {3, 4, 5, 6}
print(my_set.union(my_set_2), '----------', my_set | my_set_2)
print(my_set.intersection(my_set_2), '----------', my_set & my_set_2)
print(my_set.difference(my_set_2), '----------', my_set - my_set_2)
print(my_set.symmetric_difference(my_set_2), '----------', my_set ^ my_set_2)
my_set.clear()
print(my_set)
- Функция union() объединяет данные, присутствующие в обоих наборах.
- Функция пересечения () находит данные, присутствующие только в обоих наборах.
- Функция Differenti() удаляет данные, присутствующие в обоих, и выводит данные, присутствующие только в переданном наборе.
- Функция симметричная_разность() делает то же самое, что и функция разность(), но выводит данные, оставшиеся в обоих наборах.
Вывод:
{1, 2, 3, 4, 5, 6} — — — — {1, 2, 3, 4, 5, 6}
{3, 4} — — — — {3, 4}
{1, 2} — — — — {1, 2}
{1, 2, 5, 6} — — — — {1, 2 , 5, 6}
установить()
Теперь, когда вы поняли встроенные структуры данных, давайте начнем с определяемых пользователем структур данных. Определяемые пользователем структуры данных, само название предполагает, что пользователи определяют, как будет работать структура данных, и определяют в ней функции. Это дает пользователю полный контроль над тем, как данные должны быть сохранены, обработаны и так далее.
Давайте двинемся дальше и изучим наиболее известные структуры данных в большинстве языков программирования.
Пользовательские структуры данных
Массивы против списков
Массивы и списки имеют одну и ту же структуру с одним отличием. Списки позволяют хранить разнородные элементы данных, тогда как массивы позволяют хранить в них только однородные элементы.
Куча
Стеки — это линейные структуры данных, основанные на принципе «последний пришел — первый вышел» (LIFO), где данные, которые вводятся последними, будут доступны первыми. Он построен с использованием структуры массива и имеет операции, а именно: вталкивание (добавление) элементов, извлечение (удаление) элементов и доступ к элементам только из одной точки в стеке, называемой ТОР. Этот TOP является указателем на текущую позицию стека. Стеки широко используются в таких приложениях, как рекурсивное программирование, обращение слов, механизмы отмены в текстовых редакторах и так далее.
Очередь
Очередь также представляет собой линейную структуру данных, основанную на принципе «первым пришел – первым обслужен» (FIFO), где сначала будут доступны данные, введенные первыми. Он построен с использованием структуры массива и имеет операции, которые могут выполняться с обоих концов Очереди, то есть по принципу «голова-хвост» или «вперед-назад». Такие операции, как добавление и удаление элементов, называются En-Queue и De-Queue, и можно выполнять доступ к элементам. Очереди используются в качестве сетевых буферов для управления перегрузкой трафика, используются в операционных системах для планирования заданий и во многих других случаях.
Дерево
Деревья — это нелинейные структуры данных, которые имеют корень и узлы. Корень — это узел, из которого берутся данные, а узлы — это другие доступные нам точки данных. Узел, который предшествует, является родителем, а узел после называется дочерним. Есть уровни дерева, чтобы показать глубину информации. Последние узлы называются листьями. Деревья создают иерархию, которую можно использовать во многих реальных приложениях, таких как HTML-страницы, использующие деревья, чтобы различать, какой тег относится к какому блоку. Это также эффективно в целях поиска и многое другое.
Связанный список
Связанные списки — это линейные структуры данных, которые не хранятся последовательно, а связаны друг с другом с помощью указателей. Узел связанного списка состоит из данных и указателя, называемого next. Эти структуры наиболее широко используются в приложениях для просмотра изображений, музыкальных проигрывателях и т.д.
График
Графики используются для хранения набора данных о точках, называемых вершинами (узлами) и ребрами (ребрами). Графики можно назвать наиболее точным представлением карты реального мира. Они используются для нахождения различной стоимости-расстояния между различными точками данных, называемыми узлами, и, следовательно, для нахождения наименьшего пути. Многие приложения, такие как Google Maps, Uber и многие другие, используют графики, чтобы найти наименьшее расстояние и наилучшим образом увеличить прибыль.
HashMaps
HashMaps такие же, как и словари в Python. Их можно использовать для реализации таких приложений, как телефонные книги, заполнение данными по спискам и многое другое.
На этом заканчиваются все известные структуры данных в Python. Я надеюсь, вы поняли встроенные, а также определяемые пользователем структуры данных, которые есть в Python, и почему они важны.
Если вы хотите прочитать больше статей о самых популярных на рынке технологиях, таких как искусственный интеллект, DevOps, этический взлом, вы можете обратиться к официальному сайту Edureka.
Обратите внимание на другие статьи из этой серии, в которых объясняются другие различные аспекты Python и науки о данных.
4. Библиотеки Python для науки о данных и машинного обучения
15. Питон против С++
17. Питон SciPy
20. Основы Python
23. Декоратор Python
Первоначально опубликовано на https://www.edureka.co.
