Какая разница между списками и кортежами?

Какая разница?

В чем преимущества/недостатки кортежей/списков?

Ответы

Ответ 1

Помимо неизменности кортежей, существует также семантическое различие, которое должно служить руководством для их использования. Кортежи представляют собой разнородные структуры данных (т.е. Их записи имеют разные значения), а списки - однородные последовательности. Кортежи имеют структуру, списки имеют порядок.

Использование этого различия делает код более явным и понятным.

В качестве примера можно привести пары номеров страниц и строк для ссылок в книге, например:

my_location = (42, 11)  # page number, line number

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

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

Есть несколько интересных статей по этой проблеме, например: "Кортежи Python - это не просто списки констант" или "Понимание кортежей и списков в Python". Официальная документация Python также упоминает это

"Кортежи неизменяемы и обычно содержат гетерогенную последовательность...".

На статически типизированном языке, таком как Haskell, значения в кортеже обычно имеют разные типы и длина кортежа должна быть исправлена. В списке все значения имеют один и тот же тип, а длина не фиксирована. Поэтому разница очень очевидна.

Наконец, в Python есть namedtuple, что имеет смысл, поскольку кортеж уже должен иметь структуру. Это подчеркивает мысль о том, что кортежи представляют собой легкую альтернативу классам и экземплярам.

Ответ 2

Разница между списком и кортежем

  1. Буквальное

    someTuple = (1,2)
someList  = [1,2]

  2. Размер

    a = tuple(range(1000))
b = list(range(1000))

a.__sizeof__() # 8024
b.__sizeof__() # 9088

    Из-за меньшего размера операции с кортежем она становится немного быстрее, но упоминать не так много, пока у вас не будет огромное количество элементов.

  3. Разрешенные операции

    b    = [1,2]   
b[0] = 3       # [3, 2]

a    = (1,2)
a[0] = 3       # Error

    Это также означает, что вы не можете удалить элемент или отсортировать кортеж. Однако вы можете добавить новый элемент в список и кортеж с той лишь разницей, что вы измените идентификатор кортежа, добавив элемент

    a     = (1,2)
b     = [1,2]  

id(a)          # 140230916716520
id(b)          # 748527696

a   += (3,)    # (1, 2, 3)
b   += [3]     # [1, 2, 3]

id(a)          # 140230916878160
id(b)          # 748527696

  4. ИспользованиеПоскольку список является изменчивым, его нельзя использовать в качестве ключа в словаре, тогда как кортеж можно использовать.

    a    = (1,2)
b    = [1,2] 

c = {a: 1}     # OK
c = {b: 1}     # Error

  5. Hashable  Кортеж является хэшируемым, а список - нет. Хэш-функции возвращают значение хеш-функции объекта, если оно есть.

    Hashability of list and tuple.

Ответ 3

Если вы отправились на прогулку, вы могли бы отметить ваши координаты в любой момент в корте (x,y).

Если вы хотите записать свое путешествие, вы можете добавить свое местоположение каждые несколько секунд в список.

Но ты не мог сделать это наоборот.

Ответ 4

Ключевым отличием является то, что кортежи неизменяемы. Это означает, что вы не можете изменить значения в кортеже после его создания.

Итак, если вам нужно изменить значения, используйте List.

Преимущества для кортежей:

  • Небольшое улучшение производительности.
  • Поскольку кортеж является неизменным, он может использоваться как ключ в словаре.
  • Если вы не можете его изменить, ни один другой не может сказать, что вам не нужно беспокоиться о каких-либо функциях API и т.д., изменяя свой кортеж, не спрашивая.

Ответ 5

Списки изменяются; Кортежи не являются.

От docs.python.org/2/tutorial/datastructures.html

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

Ответ 6

Было отмечено , что разница в значительной степени семантическая: люди ожидают, что кортеж и список будут представлять различную информацию. Но это идет дальше, чем руководство; некоторые библиотеки фактически ведут себя по-разному на основе того, что они передают. Возьмите NumPy, например (скопированный из еще один пост, где я прошу больше примеров):

>>> import numpy as np
>>> a = np.arange(9).reshape(3,3)
>>> a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> idx = (1,1)
>>> a[idx]
4
>>> idx = [1,1]
>>> a[idx]
array([[3, 4, 5],
       [3, 4, 5]])

Дело в том, что NumPy не может быть частью стандартной библиотеки, это большая библиотека Python, а в списках NumPy и кортежах совершенно разные вещи.

Ответ 7

Списки для циклизации, кортежи для структур, т.е. "%s %s" %tuple.

Списки обычно однородны, кортежи обычно неоднородны.

Списки для переменной длины, кортежи для фиксированной длины.

Ответ 8

Это пример списков Python:

my_list = [0,1,2,3,4]
top_rock_list = ["Bohemian Rhapsody","Kashmir","Sweet Emotion", "Fortunate Son"]

Это пример кортежа Python:

my_tuple = (a,b,c,d,e)
celebrity_tuple = ("John", "Wayne", 90210, "Actor", "Male", "Dead")

Списки и кортежи Python аналогичны, поскольку оба они являются упорядоченными наборами значений. Помимо неглубокой разницы, списки создаются с помощью скобок "[...,...]" и кортежей с использованием круглых скобок "(...,...)", основной технический "жестко закодированный в синтаксисе Python", разница между ними состоит в том, что элементы определенного кортежа являются неизменяемыми, тогда как списки являются изменяемыми (... поэтому только кортежи являются хешируемыми и могут использоваться как ключи словаря/хэша!). Это приводит к различиям в том, как они могут или не могут быть использованы (усилены априорно по синтаксису) и различиям в том, как люди предпочитают их использовать (поощряемые как "лучшие практики", апостериор, это то, что делают умные программисты). Основное различие апостериор в дифференцировании при использовании кортежей в сравнении с используемыми списками заключается в том, что люди дают порядку элементов.

Для кортежей "порядок" означает не что иное, как просто определенную "структуру" для хранения информации. Какие значения находятся в первом поле, можно легко переключить во второе поле, поскольку каждый из них дает значения в двух разных измерениях или масштабах. Они дают ответы на различные типы вопросов и обычно имеют форму: для данного объекта/предмета, каковы его атрибуты? Объект/объект остается постоянным, атрибуты отличаются.

Для списков "порядок" означает последовательность или направленность. Второй элемент ДОЛЖЕН прибыть после первого элемента, потому что он позиционируется во втором месте на основе конкретного и общего масштаба или измерения. Элементы берутся в целом и в основном дают ответы на один вопрос, типично формы, для данного атрибута, как эти объекты/предметы сравниваются? Атрибут остается постоянным, объект/объект отличается.

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

Чтобы обобщить некоторые более тонкие детали

Сходства:

  • Дубликаты. Оба кортежа и списки допускают дубликаты.

  • Индексирование, выбор и разбиение на разделы - как кортежи, так и списки индексов с использованием целочисленных значений, найденных в скобках. Итак, если вы хотите получить первые 3 значения данного списка или кортежа, синтаксис будет таким же:

    >>> my_list[0:3]
[0,1,2]
>>> my_tuple[0:3]
[a,b,c]

  • Сравнение и сортировка. Два кортежа или два списка сравниваются по их первому элементу, а если есть связь, то второй элемент и т.д. Никакое дополнительное внимание не уделяется последующим элементам после того, как предыдущие элементы показывают разницу.

    >>> [0,2,0,0,0,0]>[0,0,0,0,0,500]
True
>>> (0,2,0,0,0,0)>(0,0,0,0,0,500)
True

Различия: - априори, по определению

  • Синтаксис - списки используют [], кортежи use()

  • Mutability - Элементы в данном списке изменяемы, элементы в данном наборе НЕ изменяемы.

    # Lists are mutable:
>>> top_rock_list
['Bohemian Rhapsody', 'Kashmir', 'Sweet Emotion', 'Fortunate Son']
>>> top_rock_list[1]
'Kashmir'
>>> top_rock_list[1] = "Stairway to Heaven"
>>> top_rock_list
['Bohemian Rhapsody', 'Stairway to Heaven', 'Sweet Emotion', 'Fortunate Son']

# Tuples are NOT mutable:       
>>> celebrity_tuple
('John', 'Wayne', 90210, 'Actor', 'Male', 'Dead')
>>> celebrity_tuple[5]
'Dead'
>>> celebrity_tuple[5]="Alive"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

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

    #Lists CAN'T act as keys for hashtables(dictionaries)
>>> my_dict = {[a,b,c]:"some value"}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

#Tuples CAN act as keys for hashtables(dictionaries)
>>> my_dict = {("John","Wayne"): 90210}
>>> my_dict
{('John', 'Wayne'): 90210}

Различия - апостериор, в использовании

  • Гомо и гетерогенность элементов. Обычно объекты списка однородны, а кортежи - гетерогенные. То есть, списки используются для объектов/предметов того же типа (например, всех кандидатов в президенты, или всех песен, или всех бегунов), хотя, хотя это и не принудительно), в то время как кортежи больше подходят для гетерогенных объектов.

  • Looping vs. Structures. Хотя оба позволяют цикл (для x в my_list...), действительно имеет смысл сделать это для списка. Корреспонденты более подходят для структурирования и представления информации (% s% s, проживающих в% s,% s и в настоящее время% s% ( "Джон", "Уэйн", 90210, "Актер", "Мертвый" ))

Ответ 9

Значения list могут быть изменены в любое время, но значения кортежей не могут быть изменены.

Преимущества и недостатки зависят от использования. Если у вас есть такие данные, которые вы никогда не захотите менять, вам придется использовать кортеж, иначе список - лучший вариант.

Ответ 10

Разница между списком и кортежем

Кортежи и списки являются, по-видимому, похожими типами последовательностей в Python.

  1. Литеральный синтаксис

    Мы используем скобки (), чтобы построить кортежи и квадратные скобки [ ] чтобы получить новый список. Кроме того, мы можем использовать вызов соответствующего типа, чтобы получить требуемую структуру - кортеж или список.

    someTuple = (4,6)
someList  = [2,6]

  2. переменчивость

    Кортежи неизменяемы, а списки изменяемы. Эта точка является основой для следующих.

  3. Использование памяти

    Из-за изменчивости вам нужно больше памяти для списков и меньше памяти для кортежей.

  4. простирающийся

    Вы можете добавить новый элемент как к кортежам, так и к спискам с той лишь разницей, что идентификатор кортежа будет изменен (т.е. Будет иметь новый объект).

  5. хеширования

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

    tup      = (1,2)
list_    = [1,2] 

c = {tup   : 1}     # ok
c = {list_ : 1}     # error

  6. Семантика

    Этот момент больше посвящен лучшей практике. Вы должны использовать кортежи как гетерогенные структуры данных, а списки - однородные последовательности.

Ответ 11

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

Ответ 12

Поскольку люди уже ответили здесь, что tuples неизменяемы, а lists изменяемы, но есть один важный аспект использования кортежей, которые мы должны помнить

Если tuple содержит list или dictionary внутри него, они могут быть изменены, даже если сам tuple является неизменным.

Например, предположим, что у нас есть кортеж, который содержит список и словарь как

my_tuple = (10,20,30,[40,50],{ 'a' : 10})

мы можем изменить содержание списка как

my_tuple[3][0] = 400
my_tuple[3][1] = 500

что делает новый кортеж похожим на

(10, 20, 30, [400, 500], {'a': 10})

мы также можем изменить словарь внутри кортежа как

my_tuple[4]['a'] = 500

который заставит общий кортеж выглядеть так:

(10, 20, 30, [400, 500], {'a': 500})

Это происходит потому, что list и dictionary являются объектами, и эти объекты не меняются, а содержимое, на которое оно указывает.

Таким образом, tuple остается неизменным без каких-либо исключений

Ответ 13

PEP 484 - подсказки типа говорит, что типы элементов tuple могут быть индивидуально напечатаны; так что вы можете сказать Tuple[str, int, float]; но list, с классом list для ввода может принимать только один параметр типа: List[str], который намекает на то, что различие 2 действительно состоит в том, что первое является гетерогенным, тогда как последнее по своей сути однородно.

Кроме того, стандартная библиотека в основном использует кортеж как возвращаемое значение из таких стандартных функций, где C вернет a struct.

Ответ 14

цитата из документации по 5.3. Кортежи и последовательности:

Хотя кортежи могут казаться похожими на списки, они часто используются в разных ситуациях и для разных целей. Кортежи неизменяемы и обычно содержат гетерогенную последовательность элементов, к которым осуществляется доступ через распаковку (см. Далее в этом разделе) или индексирование (или даже атрибут в случае namedtuples). Списки изменяются, и их элементы обычно однородны и к ним обращаются путем повторения списка.

Ответ 15

Прежде всего, они оба являются нескалярными объектами (также называемыми составными объектами) в Python.

  • Кортежи, упорядоченная последовательность элементов (которая может содержать любой объект без проблемы с псевдонимом)
    • Неизменяемый (tuple, int, float, str)
    • Конкатенация с использованием + (конечно же, будет создан новый кортеж)
    • Индексация
    • Нарезка
    • Синглтон (3,) # -> (3) вместо (3) # -> 3
  • Список (массив на других языках), упорядоченная последовательность значений
    • Mutable
    • Singleton [3]
    • Клонирование new_array = origin_array[:]
    • Понимание списка [x**2 for x in range(1,7)] дает вам [1,4,9,16,25,36] (Не читается)

Использование списка также может вызвать ошибку псевдонимов (два разных пути указывая на тот же объект).

Ответ 16

Списки изменяемы, а кортежи неизменяемы. Просто рассмотрите этот пример.

a = ["1", "2", "ra", "sa"]    #list
b = ("1", "2", "ra", "sa")    #tuple

Теперь измените значения индекса списка и кортежа.

a[2] = 1000
print a     #output : ['1', '2', 1000, 'sa']
b[2] = 1000
print b     #output : TypeError: 'tuple' object does not support item assignment.

Следовательно, доказал, что следующий код недействителен с кортежем, потому что мы попытались обновить кортеж, который не разрешен.

Ответ 17

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

Различия в синтаксисе

Синтаксис списка и кортежа несколько отличается. Списки окружены квадратными скобками [], а кортежи окружены скобкой().

Пример 1.1: Создание списка или создание кортежа

list_num = [1,2,3,4]
tup_num = (1,2,3,4)

print(list_num)
print(tup_num)

Выход:

[1,2,3,4]
(1,2,3,4)

Переменный список против неизменяемых кортежей

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

Пример 2.1: Изменить список элементов по сравнению с кортежем

list_num[2] = 5
print(list_num)

tup_num[2] = 5

Выход:

[1,2,5,4]
Traceback (most recent call last): 
 File "python", line 6, in <module> 
TypeError: 'tuple' object does not support item assignment

Доступные операции

Списки имеют больше встроенной функции, чем функция кортежа. Мы можем использовать встроенную функцию dir ([object]) для получения всех связанных функций для списка и кортежа.

Пример 3.1: Список каталогов

dir(list_num)
dir(tup_num)

Сравнение размеров

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

Пример 5.1: Вычислить размер списка по сравнению с кортежем

a= (1,2,3,4,5,6,7,8,9,0)
b= [1,2,3,4,5,6,7,8,9,0]

print('a=',a.__sizeof__())
print('b=',b.__sizeof__())

Выход:

a= 104
b= 120

Различные случаи использования

  • На первый взгляд может показаться, что списки всегда могут заменять кортежи. Но кортежи - чрезвычайно полезные структуры данных
  • Использование кортежа вместо списка может дать программисту и интерпретатору намек на то, что данные не должны быть изменены.
  • Кортежи обычно используются как эквивалент словаря без ключей для хранения данных.

Ключевые моменты, которые следует помнить:

  • Литеральный синтаксис кортежей показан скобками(), тогда как литеральный синтаксис списков показан квадратными скобками [].
  • Списки имеют переменную длину, кортеж имеет фиксированную длину.
  • Список имеет изменчивую природу, кортеж имеет неизменную природу.
  • Список имеет больше функциональности, чем кортеж.

Ответ 18

Поскольку люди уже упоминали о различиях, я напишу о том, почему кортежи.

Почему кортежи предпочтительнее?

Allocation optimization for small tuples

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

Свободный список делится на 20 групп, где каждая группа представляет список кортежей длиной n от 0 до 20. Каждая группа может хранить до до 2 000 кортежей. Первая (нулевая) группа содержит только 1 элемент и представляет пустой кортеж.

>>> a = (1,2,3)
>>> id(a)
4427578104
>>> del a
>>> b = (1,2,4)
>>> id(b)
4427578104

В приведенном выше примере мы видим, что a и b имеют одинаковый идентификатор. Это потому что мы сразу же заняли разрушенный кортеж, который был на свободный список.

Allocation optimization for lists

Поскольку списки могут быть изменены, Python не использует ту же оптимизацию, что и в кортежах. Тем не мение, Списки Python также имеют свободный список, но он используется только для пустых объекты. Если пустой список удален или собран GC, он может быть используется позже.

>>> a = []
>>> id(a)
4465566792
>>> del a
>>> b = []
>>> id(b)
4465566792

Источник: https://rushter.com/blog/python-lists-and-tuples/

Почему кортежи эффективнее списков? → fooobar.com/questions/41654/...

Ответ 19

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

При создании переменной фиксированная память назначается переменной. Если это список, больше памяти назначается, чем фактически используется. Например. если текущее присвоение памяти составляет 100 байт, если вы хотите добавить 101-й байт, возможно, потребуется еще 100 байт (в этом случае всего 200 байт).

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

Ответ 20

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