Списки (List) vs Кортежи (Typle)
Списки и кортежи используются для последовательного хранения одного или нескольких объектов или типов данных Python. И те и другие могут хранить любые данные, такие как целые числа, плавающие числа, строки и словари. Списки и кортежи похожи по большинству параметров, но здесь мы опишем основные различия между ними.
Различия в представлении
Представление списков и кортежей отличается незначительно. Списки обычно заключаются в квадратную скобку ё [] , а элементы — через запятую. Кортежи заключаются в круглую скобку () , а элементы разделяются запятой. Скобки использовать необязательно, и такие типы кортежей называются упаковкой кортежей.
Рассмотрим следующий пример.
list1 = ['JavaTpoint', 1, 2, 54.30, ] print(type(list)) tuple1 = ('JavaTpoint',5,8,31.9,[1,2,3]) print(type(tuple1)) В приведенной выше программе мы определили переменную list1 , которая содержит список данных разного типа с индексом от 0 до 4 . Мы определили еще одну переменную tuple1 , которая содержит кортеж данных разного типа. Она заключена в рамку () .
Изменяемые списки и неизменяемые кортежи в Python
Это самое важное различие между списком и кортежем, в то время как списки являются изменяемыми, а кортежи — неизменяемыми. Списки являются изменяемыми, что означает, что объект Python может быть изменен после создания, в то время как кортежи не могут быть изменены после создания. Рассмотрим приведенный пример.
a = ["Peter","Joseph","Mathew","Ricky"] print(a) ['Peter', 'Joseph', 'Mathew', 'Ricky'] Теперь мы меняем 0-й элемент индекса «Peter» на «Samson».
a[0] = "Samson" print(a) ['Samson', 'Joseph', 'Mathew', 'Ricky'] Теперь мы создаем кортеж и делаем то же самое.
a = (10,20,"JavaTpoint",30,40) print(a) (10, 20, 'JavaTpoint', 30, 40) a[0] = 50 TypeError Traceback (most recent call last) in ----> 1 a[0] = 50 TypeError: 'tuple' object does not support item assignment Мы получаем ошибку при изменении 1-го элемента кортежа из-за неизменяемости. Он не поддерживает присвоение элементов.
Отладка кортежей и списков в Python
Кортежи легко отлаживать в большом проекте из-за их неизменяемости. Если у нас небольшой проект или меньшее количество данных, то списки играют эффективную роль. Рассмотрим следующий пример:
a = [6,9,4,3,7,0,1] # Copying address of a in b b = a a[3] = "JavaToint" print(a) [6, 9, 4, 'JavaToint', 7, 0, 1] В приведенном выше коде мы сделали b = a ; здесь мы не копируем объект списка из b в a . b ссылается на адрес списка a . Это означает, что если мы сделаем изменение в b , то это отразится так же, как и в списке a , и это облегчает отладку. Но это сложно для серьезного проекта, где объекты Python могут иметь множество ссылок.
Будет сложно отслеживать эти изменения в списках, но неизменяемый объект кортежа не может измениться после создания. Поэтому кортежи легче отлаживать.
Поддержка функций у кортежей и списков в Python
Кортежи поддерживают меньше операций, чем списки. Встроенный dir(object) используется для получения всех поддерживаемых функций для списка и кортежа.
Функциии списков (List)
dir(list) ['__add__','__class__','__contains__','__delattr__','__delitem__','__dir_, '__doc__','__eq__','__format__', '__get__','__getattribute__','__getitem_' '__gt__','__hash__','__iadd__','__imul__','__init__','__init_subclass__''__iter__','__le__','__len__','__lt__','__mul__', '__ne__','__new__', '__reduce__', '__reduce_ex__','__repr__','__reversed__','__rmul__','__setattr__','__setitem__','__sizeof__','__str__','__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] Функциии кортежей (Tuple)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index'] Расходование памяти у списков (List) и у кортежей (Tuple) в Python
Кортежи более эффективны с точки зрения использования памяти, чем списки, поскольку кортеж имеет меньше встроенных операций. Списки подходят для работы с небольшим количеством элементов, в то время как кортежи немного быстрее, чем списки, для работы с огромным количеством данных.
Tuple = (1,2,3,4,5,6,7,8,9,0,5485,87525,955,3343,53234,6423,623456,234535) List = [1,2,3,4,5,6,7,8,9,0,78,34,43,32,43,55,54,212,642,533,43434,54532 ] print('Tuple size =', Tuple.__sizeof__()) # Tuple size = 52 print('List size =', List.__sizeof__()) Tuple size = 168 List size = 216 В некоторых случаях списки могут показаться более полезными, чем кортежи. Но кортежи являются важными структурами данных в Python. Кортежи обычно используются для неизменяемых данных, или можно сказать, что данные в кортежах «защищены от записи». Кортежи передают интерпретатору Python указание на то, что данные не должны меняться в будущем. Мы можем использовать кортеж так же, как и словарь, не используя ключи для хранения данных, например:
list1 = [(101, "Mike", 24),(102, 'Hussey', 26),(103, 'David', 27),(104, 'Warner', 29)] Кортежи могут использовать ключи словаря, поскольку они хэшируемы и неизменяемы, в то время как списки не могут использовать ключи словаря.
dict = #valid dictionary dict = #Invalid dictionary Списки и кортежи в Python для начинающих
Предположим, что вы составляете список гостей на свадьбу. Этот список постоянно меняется: добавились друзья семьи Дима и Света, не смогут прийти троюродные сестры со стороны жены Лида с Наташей.
Для представления таких данных из реального мира в Python отлично подходят списки. Списки — это еще один встроенный тип данных Python.
Создать, или другими словами, объявить список в Python можно двумя способами, так:
my_list = list()my_list = []Вернемся, однако, к гостям на свадьбе. Для создания списка гостей, сразу же при создании помещаем внутрь скобок строки с именами через запятую.
guests = ['Родители', 'Одноклассники', 'Лида и Наташа']print(guests)Операции с элементами списка ¶
В нашем списке три элемента: «Родители», «Одноклассники», «Лида и Наташа», — которые хранятся внутри списка именно в таком порядке. Если только вы не измените порядок списка, «Родители» всегда будет первым элементом, «Одноклассники» — вторым и «Лида и Наташа» — третьим. Родители представляет собой начало списка, а Лида и Наташа — конец. Мы помним, что Лида и Наташа не смогут прийти, и их нужно удалить из списка.
С помощью метода remove можно удалить последний элемент в списке.
guests = ['Родители', 'Одноклассники', 'Лида и Наташа']print(guests) # ['Родители', 'Одноклассники', 'Лида и Наташа']guests.remove("Лида и Наташа")print(guests) # ['Родители', 'Одноклассники', 'Лида и Наташа']Но не забываем, нужно еще добавить в список двух гостей. Добавление новых элементов в конец списка происходит при помощи метода append .
guests = ['Родители', 'Одноклассники', 'Лида и Наташа']print(guests) # ['Родители', 'Одноклассники', 'Лида и Наташа']guests.remove("Лида и Наташа")print(guests) # ['Родители', 'Одноклассники']guests.append('Дима')guests.append('Света')print(guests) # ['Родители', 'Одноклассники', 'Дима', 'Света']В список можно не только добавить элемент, но и изменить одно из его значений на другое, согласно индексу элемента.
guests = ['Родители', 'Одноклассники', 'Дима', 'Света']print(guests) # ['Родители', 'Одноклассники', 'Лида и Наташа']guests[2] = 'Коллеги'print(guests) # ['Родители', 'Одноклассники', 'Коллеги', 'Света']И так, список — это контейнер, хранящий объекты в определенном порядке. Обратите внимание, что в отличие от строк, методы списка меняют исходный список. Есть однако у списков кое‑что общее со строками. Это доступ к элементу по индексу и срезы. Все это работает в списках точно так же, как и в строках.
guests = ['Родители', 'Одноклассники', 'Дима', 'Света']print(guests[0]) # Родителиprint(guests[-1]) # Светаprint(guests[:2]) # ['Родители', 'Одноклассники']Кортежи ¶
Кортежи — это контейнеры, хранящие объекты в определенном порядке. В отличие от списков, кортежи неизменяемы.
Как только вы создали кортеж, значение какого-либо его элемента уже нельзя изменить, как нельзя добавлять и удалять элементы. Кортежи объявляются с помощью круглых скобок. Элементы в кортеже должны быть разделены запятыми.
Для создания кортежей также используют один из двух вариантов синтаксиса. Первый:
my_tuple = tuple()my_tuple = ()Чтобы добавить в кортеж новые объекты, создайте его вторым способом, указав через запятую каждый желаемый элемент.
data = ('И. Иванов', 1958, True)print(data) # ('И. Иванов', 1958, True)Даже если кортеж содержит только один элемент, после этого элемента все равно нужно поставить запятую. Таким образом Python отличает кортеж от числа в скобках, определяющих порядок выполнения операций.
Получить элементы кортежа можно так же, как и элементы списка, указывая индекс элемента.
books = ("1984", "О дивный новый мир", "451 градус по Фаренгейту")print(books[2]) # 451 градус по ФаренгейтуКлючевое слово in / not in ¶
Проверить, содержится ли элемент в кортеже, можно с помощью ключевого слова in .
books = ("1984", "О дивный новый мир", "451 градус по Фаренгейту")print("1984" in books) # Trueprint("Незнайка на луне" in books) # FalseПоместите перед in ключевое слово not для проверки отсутствия элемента в кортеже.
books = ("1984", "О дивный новый мир", "451 градус по Фаренгейту")print("Незнайка на луне" not in books) # TrueТе же операции с ключевыми словами in и not in сработают и со списками.
Сложение кортежей и списков ¶
При помощи оператора сложения можно соединять друг с другом две одинаковые структуры данных. Пример ниже со списками также будет работать и с кортежами:
colors1 = ["синий", "зеленый", "желтый"]colors2 = ["оранжевый", "розовый", "черный"]print(colors1 + colors2) # ['синий', 'зеленый', 'желтый', 'оранжевый', 'розовый', 'черный']На данном этапе вам может стать интересно, зачем использовать структуры данных, которые кажутся менее гибкими, чем списки? На самом же деле, кортежи удобны, когда вы имеете дело со значениями, которые никогда не изменятся. Примером таких данных для кортежа могут быть географические координаты. Долготу и широту города следует сохранить в кортеже, поскольку эти значения никогда не изменятся, а сохранение в кортеже будет гарантировать, что другие части программы случайно их не изменят.
Итерирование ¶
Строки, списки и кортежи поддерживают итерирование (программа может их перебирать, значение за значением), то есть к каждому их элементу можно получить доступ через цикл — такие объекты называются итерируемыми. Каждый элемент в итерируемом объекте, как мы уже знаем, имеет свой порядковый индекс.
В следующем примере элемент Москва записан в списке с индексом 0, Хельсинки с индексом 1, а ‘Анкара’ с индексом 2.
cities = ['Москва', 'Хельсинки' ,'Анкара']for city in cities: print(city) # Москва# Хельсинки# АнкараВот мы и познакомились с оператором for — циклом, перебирающим итерируемый объект. Цикл for можно использовать, чтобы определять инструкции, которые будут выполняться один раз для каждого элемента в итерируемом объекте, и с помощью таких инструкций вы можете получать доступ ко всем этим элементам и осуществлять операции с ними.
Например, с помощью цикла for , выполняющего перебор списка строк, и метода upper можно сделать символы каждой строки прописными:
cities = ['Москва', 'Хельсинки' ,'Анкара']for city in cities: print(city.upper()) # МОСКВА# ХЕЛЬСИНКИ# АНКАРАКак показано в примерах выше, цикл for определяется синтаксисом: for имя_переменной in имя_итерируемого_объекта: где имя_переменной — выбранное вами имя переменной, в которую каждую итерацию цикла будет записываться очередное значение из итерируемого объекта.
Python с нуля. Освойте с Виртуальным ИИ-помощником!
Оптимизации, используемые в Python: список и кортеж
В Python, есть два похожих типа — список (list) и кортеж (tuple). Самая известная разница между ними состоит в том, что кортежи неизменяемы.
Вы не можете изменить объекты в tuple:
>>> a = (1,2,3) >>> a[0] = 10 Traceback (most recent call last): File "", line 1, in TypeError: 'tuple' object does not support item assignment Но вы можете модифицировать изменяемые объекты внутри кортежа:
>>> b = (1,[1,2,3],3) >>> b[1] [1, 2, 3] >>> b[1].append(4) >>> b (1, [1, 2, 3, 4], 3) Внутри CPython (стандартного интерпретатора), список и кортеж реализованы как лист из указателей (ссылок) на Python объекты, т.е. физически они не хранят объекты рядом с друг другом. Когда вы удаляете объект из списка происходит удаление ссылки на этот объект. Если на объект ещё кто-то ссылается, то он продолжит находиться в памяти.
Кортежи
Несмотря на тот факт, что кортежи намного реже встречаются в коде и не так популярны, это очень фундаментальный тип, который Python постоянно использует для внутренних целей.
Вы можете не замечать, но вы используете кортежи когда:
- работаете с аргументами или параметрами (они хранятся как кортежи)
- возвращаете две или более переменных из функции
- итерируете ключи-значения в словаре
- используете форматирование строк
>>> import gc >>> def type_stats(type_obj): . count = 0 . for obj in gc.get_objects(): . if type(obj) == type_obj: . count += 1 . return count . >>> type_stats(tuple) 3136 >>> type_stats(list) 659 >>> import pandas >>> type_stats(tuple) 6953 >>> type_stats(list) 2455 Пустые списки vs пустые кортежи
Пустой кортеж работает как синглтон, т.е. в памяти запущенного Python скрипта всегда находится только один пустой кортеж. Все пустые кортежи просто ссылаются на один и тот же объект, это возможно благодаря тому, что кортежи неизменяемы. Такой подход сохраняет много памяти и ускоряет процесс работы с пустыми кортежами.
>>> a = () >>> b = () >>> a is b True >>> id(a) 4409020488 >>> id(b) 4409020488 >>> # В CPython, функция id возвращает адрес в памяти. Но это не работает со списками, ведь они могут быть изменены:
>>> a = [] >>> b = [] >>> a is b False >>> id(a) 4465566920 >>> id(b) 4465370632 Оптимизация выделения памяти для кортежей
Для того, чтобы снизить фрагментацию памяти и ускорить создание кортежей, Python переиспользует старые кортежи, которые были удалены. Если кортеж состоит из менее чем 20 элементов и больше не используется, то вместо удаления Python помещает его в специальный список, в котором хранятся свободные для повторного использования кортежи.
Этот список разделен на 20 групп, где каждая группа представляет из себя список кортежей размера n, где n от 0 до 20. Каждая группа может хранить до 2 000 свободных кортежей. Первая группа хранит только один элемент и представляет из себя список из одного пустого кортежа.
>>> a = (1,2,3) >>> id(a) 4427578104 >>> del a >>> b = (1,2,4) >>> id(b) 4427578104 В примере выше, мы можем видеть, что a и b имеют одинаковый адрес в памяти. Это происходит из-за того, что мы мгновенно заняли свободный кортеж такого же размера.
Оптимизация выделения памяти для списков
Так как списки могут изменяться, такую же оптимизацию как в случае с кортежами провернуть уже не получится. Несмотря на это, для списков используется похожая оптимизация нацеленная на пустые списки. Если пустой список удаляется, то он так же может быть переиспользован в дальнейшем.
>>> a = [] >>> id(a) 4465566792 >>> del a >>> b = [] >>> id(b) 4465566792 Изменение размера списка
Чтобы избежать накладные расходы на постоянное изменение размера списков, Python не изменяет его размер каждый раз, как только это требуется. Вместо этого, в каждом списке есть набор дополнительных ячеек, которые скрыты для пользователя, но в дальнейшем могут быть использованы для новых элементов. Как только скрытые ячейки заканчиваются, Python добавляет дополнительное место под новые элементы. Причём делает это с хорошим запасом, количество скрытых ячеек выбирается на основе текущего размера списка — чем он больше, тем больше дополнительных скрытых слотов под новые элементы.
Эта оптимизация особенно выручает, когда вы пытайтесь добавлять множество элементов в цикле.
Паттерн роста размера списка выглядит примерно так: 0, 4, 8, 16, 25, 35, 46, 58, 72, 88,…
Для примера, если вы хотите добавить новый элемент в список с 8 элементами, то свободных ячеек в нём уже не будет и Python сразу расширит его размер до 16 ячеек, где 9 из них будут заняты и видны пользователю.
Формула выбора размера написанная на Python:
>>> def get_new_size(n_items): . new_size = n_items + (n_items // 2 ** 3) . if n_items < 9: . new_size += 3 . else: . new_size += 6 . . return new_size . >>> get_new_size(9) 16 Скорость
Если сравнивать эти два типа по скорости, то в среднем по больнице, кортежи слегка быстрее списков. У Raymond Hettinger есть отличное объяснение разницы в скорости на stackoverflow.
P.S.: Я являюсь автором этой статьи, можете задавать любые вопросы.
Чем отличается кортеж от списка в Python
Кортежи и списки – это два из четырех доступных в Python встроенных типов данных. Оба типа полезны и на первый взгляд могут показаться похожими. Но у них есть существенные различия. Каждый из этих типов данных имеет собственные use cases. О том, чем отличается кортеж от списка в Python, мы бы и хотели сегодня поговорить.
В этой статье мы рассмотрим, как работают кортежи и списки, обсудим их индивидуальные характеристики и уникальные варианты использования. И, разумеется, разберем их сходства и различия.
Советуем вам тестировать все примеры кода, приведенные в статье, на собственной машине. Это поможет лучше разобраться в предмете и надежнее все запомнить.
Итак, давайте начнем!
Что из себя представляют кортежи и списки?
Кортежи и списки – это встроенные структуры данных. Это контейнеры, в которых можно хранить упорядоченную коллекцию из одного или нескольких элементов.
Кортеж имеет класс «кортеж» (англ. tuple): . А список имеет класс «список» (list): .
Чтобы проверить, к какому классу относится объект, вы всегда можете использовать встроенную функцию type() . Просто передайте в нее нужный вам объект в качестве аргумента. Таким образом можно проверить, является ли этот объект кортежем или списком.
Допустим, вы создали кортеж с именем my_tuple . Проверить его тип можно так:
type(my_tuple) # output #
Это особенно полезно для отладки.
Теперь давайте посмотрим, что у кортежей и списков общего.
Сходства между кортежами и списками в Python
Как мы упоминали ранее, кортежи и списки действительно похожи. У них есть общие функции, о которых мы сейчас поговорим.
Кортежи и списки могут хранить несколько элементов в одной переменной
Кортежи и списки могут быть пустыми или содержать один или даже несколько элементов в одной переменной.
Единственное различие заключается в синтаксисе. Создавая кортеж, вы берете элементы в круглые скобки () , тогда как для создания списков используются квадратные [] .
Чтобы создать пустой кортеж, вы либо используете круглые скобки сами по себе, либо применяете метод-конструктор tuple() .
type(()) # my_tuple = () type(my_tuple) # # или. my_tuple = tuple() type(my_tuple) #
Для создания пустого списка вы также можете использовать пустые скобки (только квадратные), или вызвать метод-конструктор list() .
type([]) # # my_list = [] # или. my_list = list()
При создании кортежа из одного элемента не забудьте добавить запятую в конце.
age = (28,)
Также, если вы используете метод tuple() при создании кортежа, не забывайте, что для этого нужны двойные круглые скобки.
age = tuple((28,)) type(age) #
Если вы не добавите запятую в конце, Python не распознает это как кортеж.
age = (28) type(age) #
А вот при создании списка из одного элемента не нужно беспокоиться о добавлении запятой.
age = [28] type(age) #
Хранящиеся в списках и кортежах элементы обычно похожи по своей природе и каким-то образом связаны друг с другом.
Вы можете создать кортеж или список, содержащий только последовательность строк, только последовательность целых чисел или только последовательность логических значений. При этом каждый элемент последовательности должен быть разделен запятой.
Однако вы также можете создать кортеж или список, содержащий смесь разных типов данных.
my_information = ["Dionysia",27,True,"Lemonaki",7,"Python",False] # или. my_information = list(("Dionysia",27,True,"Lemonaki",7,"Python",False)) print(my_information) # ['Dionysia', 27, True, 'Lemonaki', 7, 'Python', False]
Списки и кортежи могут содержать повторяющиеся элементы, а значения могут дублироваться, появляясь несколько раз.
information = ("Jimmy",50,True,"Kate",50) print(information) # ('Jimmy', 50, True, 'Kate', 50) # или. my_information = ["Dionysia",27,True,"Lemonaki",7,"Python",False,27,"Python",27]
Если вы забудете запятые, вы получите следующее сообщение об ошибке:
information = ("Jimmy" 50,True,"Kate",50) # File "", line 1 # information = ("Jimmy" 50,True,"Kate",50) # ^ # SyntaxError: invalid syntax my_information = ["Dionysia" 28,True,"Lemonaki",7,"Python",False] # File "", line 1 # my_information = ["Dionysia" 28,True,"Lemonaki",7,"Python",False] # ^ # SyntaxError: invalid syntax
Чтобы проверить длину списка или кортежа и узнать, сколько элементов в нем находится, можно использовать метод len() .
my_information = ["Dionysia",27,True,"Lemonaki",7,"Python",False,27,"Python",27] len(my_information) # 7
[python_ad_block]
В Python и кортежи, и списки поддерживают распаковку
По сути, при создании кортежа или списка значения «упаковываются» в одну переменную, как мы упоминали ранее.
front_end = («html», «css», «javascript»)
Эти значения можно «распаковать» и присвоить отдельным переменным.
front_end = ("html","css","javascript") content,styling,interactivity = front_end content # 'html' styling # 'css' interactivity # 'javascript'
Убедитесь, что создаваемых вами переменных столько же, сколько значений внутри кортежа/списка, иначе Python выдаст вам ошибку:
front_end = ("html","css","javascript") content,styling = front_end # Traceback (most recent call last): # File "", line 1, in # ValueError: too many values to unpack (expected 2) # или. front_end = ("html","css","javascript") content,styling,interactivity,data = front_end # Traceback (most recent call last): # File "", line 1, in # ValueError: not enough values to unpack (expected 4, got 3)
Элементы и списков,и кортежей доступны по индексу
Как упоминалось ранее, кортежи и списки представляют собой упорядоченные наборы элементов.
Порядок элементов устанавливается при создании списка или кортежа. Он неизменен и сохраняется на протяжении всего срока жизни программы. (Порядок и количество элементов в списке можно изменить, и это мы обсудим чуть ниже. Но сам собой порядок не изменится).
Каждое значение в кортеже и списке имеет уникальный идентификатор, также известный как индекс.
Таким образом, к любому элементу в кортеже или списке можно получить доступ, сославшись на его индекс.
Напомним, что индексация в Python (как и в большинстве языков программирования) начинается с 0. То есть первый элемент имеет индекс 0, второй элемент имеет индекс 1 и так далее.
Чтобы обратиться к конкретному элементу, вы пишете имя кортежа или списка, а затем индекс нужного элемента в квадратных скобках.
names = ("Jimmy","Timmy","John","Kate") names[2] # 'John'
programming_languages = ["Python","JavaScript","Java","C"] programming_languages[0] # 'Python' programming_languages[1] # 'JavaScript'
Теперь, когда мы увидели, насколько кортежи и списки похожи, давайте посмотрим, чем они отличаются.
Чем кортеж отличается от списка?
Кортежи, в отличие от списков, неизменяемы
В Python кортежи неизменяемы. Это означает, что после создания кортежа элементы внутри него не могут измениться.
Если вы попытаетесь изменить значение одного из элементов, вы получите сообщение об ошибке:
names = ("Jimmy","Timmy","John","Kate") names[2] = "Kelly" # Traceback (most recent call last): # File "", line 1, in # TypeError: 'tuple' object does not support item assignment
Поскольку кортежи неизменяемы, нельзя добавлять, заменять, переназначать или удалять содержащиеся в них элементы.
Это также означает, что кортежи имеют фиксированную длину. Она не меняется на протяжении всего жизненного цикла программы.
Когда использовать кортежи
Кортежи удобно использовать, если вы хотите, чтобы данные в вашей коллекции были доступны только для чтения и всегда оставались неизменными и постоянными.
Благодаря гарантии неизменности кортежи могут использоваться в словарях и множествах, для которых требуется, чтобы содержащиеся в них элементы имели неизменяемый тип.
Когда использовать списки
С другой стороны, списки можно легко редактировать и модифицировать, потому что они изменяемы.
Вы можете добавлять элементы в список, удалять элементы из списка, перемещать элементы и заменять их.
Это означает, что длина и размер списков увеличивается и уменьшается на протяжении жизненного цикла программы.
Списки полезны, когда вы хотите, чтобы ваши данные были гибкими или чтобы при необходимости их можно было изменить.
В Python есть множество встроенных методов для выполнения разнообразных операций со списками. Использовать эти методы с кортежами не выйдет.
Давайте рассмотрим несколько простых способов изменения списков.
Как изменять списки в Python
Поскольку списки изменяемы, вам необходимо знать несколько основных способов обновления данных в них.
Как обновить элемент в списке в Python
Чтобы обновить конкретный элемент в списке, нужно указать его индекс в квадратных скобках. Затем ему можно присвоить новое значение.
#general syntax list_name[index] = new_value programming_languages = ["Python","JavaScript","Java","C"] print(programming_languages) # ['Python', 'JavaScript', 'Java', 'C'] programming_languages[2] = "C++" print(programming_languages) # ['Python', 'JavaScript', 'C++', 'C']
Как добавить элементы в список в Python
Метод .append() добавляет один новый элемент в конец списка.
#general syntax list_name.append(item) programming_languages = ["Python","JavaScript","Java","C"] print(programming_languages) # ['Python', 'JavaScript', 'Java', 'C'] programming_languages.append("C++") print(programming_languages) # ['Python', 'JavaScript', 'Java', 'C', 'C++']
Чтобы добавить один элемент на определенную позицию, используется метод .insert() .
Он вставляет элемент в список на конкретное место. Остальные элементы в списке, идущие после, сдвигаются на одну позицию вправо.
#general syntax list_name.insert(index,item) names = ["Cody","Dillan","James","Nick"] print(names) # ['Cody', 'Dillan', 'James', 'Nick'] names.insert(0,"Stephanie") print(names) # ['Stephanie', 'Cody', 'Dillan', 'James', 'Nick']
Если вы хотите добавить в список более одного элемента, используйте метод .extend() .
Он добавляет итерируемый объект в конец списка. Например, вы можете добавить новый список в конец уже существующего.
#general syntax list_name.extend(iterable) programming_languages = ["Python","JavaScript"] more_programming_languages = ["Java","C"] # add more_programming_languages to programming_languages programming_languages.extend(more_programming_languages) print(programming_languages) # ['Python', 'JavaScript', 'Java', 'C']
Как удалить элементы из списка в Python
В Python есть два встроенных метода для удаления элементов из списка.
Один из них – метод .remove() . Он удалит первое вхождение указанного вами элемента.
#general syntax list_name.remove(item) programming_languages = ["Python", "JavaScript", "Java", "C"] print(programming_languages) # ['Python', 'JavaScript', 'Java', 'C'] programming_languages.remove("Java") print(programming_languages) # ['Python', 'JavaScript', 'C'] # deletes only first occurence programming_languages = ["Python", "JavaScript", "Java", "C","Python"] programming_languages.remove("Python") print(programming_languages) # ['JavaScript', 'Java', 'C', 'Python']
Второй метод — .pop() .
Без передачи аргумента он удалит последний элемент в списке.
Также можно передать в pop() в качестве аргумента индекс конкретного элемента, который необходимо удалить.
В обоих случаях удаленное значение возвращается, что полезно. При желании вы можете сохранить его в отдельной переменной для дальнейшего использования.
programming_languages = ["Python", "JavaScript", "Java", "C"] programming_languages.pop() # 'C' print(programming_languages) # ['Python', 'JavaScript', 'Java'] # store returned value in a variable programming_languages = ["Python", "JavaScript", "Java", "C"] fave_language = programming_languages.pop(0) print(fave_language) # Python
Заключение
Итак, мы разобрали, чем отличается кортеж от списка в Python. Кроме того, мы обсудили, как работают кортежи и списки и как они обычно используются.
Повторим, что общего у списков и кортежей:
- В Python и список, и кортеж считаются объектами .
- Это контейнеры, используемые для хранения данных. И эти данные могут быть любого типа.
- Они оба упорядочены и поддерживают этот порядок все время. После определения порядка элементов он не изменится (т.е. не случится такого, что элемент с индексом 4 вдруг станет первым или наоборот).
- Как в кортежах, так и в списках вы можете получить доступ к отдельным элементам по их индексу.
А чем отличается кортеж от списка? Основное отличие — (не)изменяемость:
- Кортежи неизменяемы. Используйте их, когда вы точно знаете, что данные не изменятся в течение жизненного цикла вашей программы, или когда вам нужна гарантия неизменности данных.
- Списки изменяемы. Вы можете добавлять и удалять элементы. Списки растут и сокращаются на протяжении всего срока действия программы. Используйте их, когда предполагается, что ваши данные будут изменены.
Спасибо за чтение и успехов в написании кода!