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

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

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
   

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

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

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

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

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

льготы для кортежей:

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

списки изменчивы; кортежи-нет.

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

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

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

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

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

Это было указано что разница в значительной степени семантическая: люди ожидают, что кортеж и список будут представлять разную информацию. Но это идет дальше, чем руководство; некоторые библиотеки на самом деле ведут себя по-разному на основе того, что они передаются. Возьмите 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 и кортежах-совершенно разные вещи.

это пример списков 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 " разница между ними заключается в том, что элементы конкретного кортежа неизменяемы, тогда как списки изменчивы (...поэтому только кортежи хэшируются и могут использоваться как ключи словаря/хэша!). Это приводит к различиям в том, как они могут или не могут быть использованы (принудительно априори синтаксисом) и различия в том, как люди предпочитают использовать их (поощряется как "лучшие практики", апостериори, это то, что умный программистов делать). Основное различие апостериори в дифференциации при использовании кортежей по сравнению с использованием списков заключается в том, что смысл люди дают порядок элементов.

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

для списков, "порядок" означает последовательность или направление. Второй элемент должен прийти после первый элемент, потому что он расположен на 2-м месте на основе определенного и общего масштаба или измерения. Элементы взяты в целом и в основном дают ответы на один вопрос, как правило, формы,для данного атрибута, как эти объекты/субъекты сравнивать? атрибут остается постоянным, объект/предмет отличается.

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

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

сходство:

1. дубликаты - кортежи и списки разрешить дубликаты

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

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

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

   >>> [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
   

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

1. синтаксис - использовать списки [], использовать кортежи ()

2. переменчивости - элементы в данном списке изменчивы, элементы в данном кортеже не изменчивы.

   # 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
   

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

   #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}
   

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

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

2. зацикливание против структур-хотя оба позволяют зацикливаться (для x в my_list...), это действительно имеет смысл сделать только для списка. Кортежи больше подходят для структурирования и представления информации (%s %S, проживающий в %s, является %s и в настоящее время %s % ("Джон","Уэйн",90210, "актер","мертвый"))

значения список можно изменить в любое время, но значения ОК невозможно изменить.

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

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

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

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

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

кортежи и списки как сходные типы последовательностей в Python.

1. буквальный синтаксис

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

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

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

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

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

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

4. расширения

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

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

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

   tup      = (1,2)
   list_    = [1,2] 
   
   c = {tup   : 1}     # ok
   c = {list_ : 1}     # error
   

6. семантика

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

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

• кортежи, упорядоченная последовательность элементов (которые могут содержать любой объект без проблем с псевдонимами)
  • неизменяемый (кортеж, int, float, str)
  • конкатенация с использованием + (новый Кортеж будет создан, конечно)
  • индексации
  • для нарезки
  • Синглтон (3,) # -> (3) вместо (3) # -> 3
• список (массив на других языках), упорядоченная последовательность значений
  • Мутабельный
  • Синглтон [3]
  • клонирование new_array = origin_array[:]
  • понимание дает вам [1,4,9,16,25,36] (не читаемо)

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

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

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

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

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

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

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

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

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 остается неизменной, без каких-либо исключений

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

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.

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

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

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

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