목록과 튜플의 차이점은 무엇입니까?

목록과 튜플의 차이점은 무엇입니까?

---

차이점이 뭐야?

튜플 /리스트의 장단점은 무엇입니까?

---

튜플이 변경 불가능한 것 외에도 사용법을 안내해야하는 의미 적 구분이 있습니다. 튜플은 이기종 데이터 구조 (즉, 항목이 다른 의미를 가짐)이고 목록은 동종 시퀀스입니다. 튜플에는 구조가 있고 목록에는 순서가 있습니다.

이 구분을 사용하면 코드가 더 명확하고 이해하기 쉬워집니다.

한 가지 예는 책의 위치를 ​​참조하기위한 페이지 및 줄 번호 쌍입니다. 예 :

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

그런 다음이를 사전의 키로 사용하여 위치에 대한 메모를 저장할 수 있습니다. 반면에 목록은 여러 위치를 저장하는 데 사용될 수 있습니다. 당연히 목록에서 위치를 추가하거나 제거하고 싶을 수 있으므로 목록은 변경 가능합니다. 반면에 기존 위치에서 항목을 추가하거나 제거하는 것은 의미가 없으므로 튜플은 변경할 수 없습니다.

예를 들어 페이지의 행을 반복하는 경우와 같이 기존 위치 튜플 내에서 항목을 변경하려는 상황이있을 수 있습니다. 그러나 튜플 불변성은 각각의 새 값에 대해 새 위치 튜플을 만들도록합니다. 겉으로는 불편 해 보이지만 이와 같이 불변 데이터를 사용하는 것은 값 유형과 함수형 프로그래밍 기술의 초석이며 상당한 이점을 가질 수 있습니다.

이 문제에 대한 흥미로운 기사가 ​​있습니다. 예를 들면 "Python Tuples are Not Just Constant Lists" 또는 "Understanding tuples vs. lists in Python" . 공식 Python 문서 에서도 이것을 언급합니다.

"튜플은 불변이며 일반적으로 이기종 시퀀스를 포함합니다 ...".

Haskell 과 같은 정적으로 형식화 된 언어 에서 튜플의 값은 일반적으로 다른 형식을 가지며 튜플의 길이는 고정되어야합니다. 목록에서 값은 모두 동일한 유형을 가지며 길이는 고정되지 않습니다. 따라서 그 차이는 매우 분명합니다.

마지막으로 파이썬 에는 네임 튜플이 있는데, 튜플은 이미 구조를 가지고 있기 때문에 의미가 있습니다. 이것은 튜플이 클래스와 인스턴스에 대한 가벼운 대안이라는 생각을 강조합니다.

---

목록과 튜플의 차이점

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
   

   이는 또한 요소를 삭제하거나 튜플을 정렬 할 수 없음을 의미합니다. 그러나 요소를 추가하여 튜플의 ID를 변경하는 유일한 차이점을 제외하고 목록과 튜플에 새 요소를 추가 할 수 있습니다.

   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 Tuple은 해시 가능하지만 목록은 그렇지 않습니다. 해시 함수는 객체에 해시 값이있는 경우이를 반환합니다.

   

---

산책하러 갔다면 언제든지 (x,y)튜플 에서 좌표를 기록 할 수 있습니다 .

여행을 기록하려면 몇 초마다 위치를 목록에 추가 할 수 있습니다.

하지만 다른 방법으로는 할 수 없습니다.

---

주요 차이점은 튜플은 변경할 수 없다는 것입니다. 이는 튜플을 생성 한 후에는 튜플의 값을 변경할 수 없음을 의미합니다.

따라서 값을 변경해야하는 경우 목록을 사용하십시오.

튜플의 이점 :

1. 약간의 성능 향상.
2. 튜플은 불변이므로 사전에서 키로 사용할 수 있습니다.
3. 변경할 수없는 경우 다른 사람도 변경할 수 없습니다. 즉, 요청없이 튜플을 변경하는 API 함수 등에 대해 걱정할 필요가 없습니다.

---

목록은 변경 가능합니다. 튜플은 그렇지 않습니다.

에서 docs.python.org/2/tutorial/datastructures.html

튜플은 불변이며 일반적으로 언 패킹 (이 섹션의 뒷부분 참조) 또는 인덱싱 (또는 명명 된 튜플의 경우 속성에 의해 액세스 됨)을 통해 액세스되는 이기종 요소 시퀀스를 포함합니다. 목록은 변경 가능하며 해당 요소는 일반적으로 동종이며 목록을 반복하여 액세스합니다.

---

그 차이는 대체로 의미 론적이라는 언급 이 있습니다. 사람들은 튜플과 목록이 다른 정보를 나타내기를 기대합니다. 그러나 이것은 가이드 라인 이상입니다. 일부 라이브러리는 실제로 전달 된 내용에 따라 다르게 작동합니다. 예를 들어 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 목록과 튜플 내에서 완전히 다른 것입니다.

---

리스트는 루핑을위한 것이고, 튜플은 구조를위한 것 "%s %s" %tuple입니다.

목록은 일반적으로 동종이고 튜플은 일반적으로 이기종입니다.

목록은 가변 길 이용이고 튜플은 고정 길 이용입니다.

---

다음은 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")

파이썬 목록과 튜플은 둘 다 정렬 된 값 모음이라는 점에서 유사합니다. 괄호 "[..., ...]"를 사용하여 목록을 생성하고 괄호 "(..., ...)"를 사용하여 튜플을 생성한다는 얕은 차이 외에도 핵심 기술 "파이썬 구문으로 하드 코딩 된"차이점이 있습니다. 특정 튜플의 요소는 변경 불가능한 반면 목록은 변경 가능합니다 (... 따라서 튜플 만 해시 할 수 있으며 사전 / 해시 키로 사용할 수 있습니다!). 이로 인해 사용 방법 (구문 별 선험적으로 시행)과 사람들이 사용하는 방법 ( '모범 사례'로 권장, 사후, 스마트 프로그래머가 수행하는 작업)의 차이가 발생합니다. 사람들은 요소의 순서를 따릅니다.

튜플의 경우 '순서'는 정보 보유를위한 특정 '구조'에 지나지 않습니다. 첫 번째 필드에서 찾은 값은 각각 두 가지 다른 차원 또는 배율에 걸쳐 값을 제공하므로 두 번째 필드로 쉽게 전환 할 수 있습니다. 다양한 유형의 질문에 대한 답변을 제공하며 일반적으로 다음과 같은 형식입니다. 주어진 개체 / 주체에 대해 그 속성은 무엇입니까? 대상 / 주체는 일정하게 유지되고 속성은 다릅니다.

목록의 경우 '순서'는 순서 또는 방향을 나타냅니다. 두 번째 요소 는 특정 공통 척도 또는 치수에 따라 두 번째 위치에 있으므로 첫 번째 요소 뒤에 와야 합니다. 요소는 전체적으로 취해지며 일반적으로 주어진 속성에 대한 단일 질문에 대한 답변을 제공합니다. 이러한 개체 / 주체는 어떻게 비교됩니까? 속성은 일정하게 유지되고 대상 / 주체는 다릅니다.

이러한 차이를 따르지 않는 대중 문화의 사람들과 프로그래머의 수많은 예가 있으며 메인 코스에 샐러드 포크를 사용할 수있는 수많은 사람들이 있습니다. 하루가 끝나면 괜찮으며 둘 다 일반적으로 작업을 완료 할 수 있습니다.

더 세밀한 세부 사항을 요약하려면

유사점 :

1. 중복 -튜플과 목록 모두 중복 허용

2. Indexing, Selecting, & Slicing- 튜플과리스트 모두 괄호 안에있는 정수 값을 사용하여 인덱스를 나열합니다. 따라서 주어진 목록 또는 튜플의 처음 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. Hashtables (Dictionaries) - As hashtables (dictionaries) require that its keys are hashable and therefore immutable, only tuples can act as dictionary keys, not lists.

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

Differences - A posteriori, in usage

1. Homo vs. Heterogeneity of Elements - Generally list objects are homogenous and tuple objects are heterogeneous. That is, lists are used for objects/subjects of the same type (like all presidential candidates, or all songs, or all runners) whereas although it's not forced by), whereas tuples are more for heterogenous objects.

2. Looping vs. Structures - Although both allow for looping (for x in my_list...), it only really makes sense to do it for a list. Tuples are more appropriate for structuring and presenting information (%s %s residing in %s is an %s and presently %s % ("John","Wayne",90210, "Actor","Dead"))

---

The values of list can be changed any time but the values of tuples can't be change.

The advantages and disadvantages depends upon the use. If you have such a data which you never want to change then you should have to use tuple, otherwise list is the best option.

---

Difference between list and tuple

Tuples and lists are both seemingly similar sequence types in Python.

1. Literal syntax

   We use parenthesis () to construct tuples and square brackets [ ] to get a new list. Also, we can use call of the appropriate type to get required structure — tuple or list.

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

2. Mutability

   Tuples are immutable, while lists are mutable. This point is the base the for the following ones.

3. Memory usage

   Due to mutability, you need more memory for lists and less memory for tuples.

4. Extending

   You can add a new element to both tuples and lists with the only difference that the id of the tuple will be changed (i.e., we’ll have a new object).

5. Hashing

   Tuples are hashable and lists are not. It means that you can use a tuple as a key in a dictionary. The list can't be used as a key in a dictionary, whereas a tuple can be used

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

6. Semantics

   This point is more about best practice. You should use tuples as heterogeneous data structures, while lists are homogenous sequences.

---

Lists are intended to be homogeneous sequences, while tuples are heterogeneous data structures.

---

As people have already answered here that tuples are immutable while lists are mutable, but there is one important aspect of using tuples which we must remember

If the tuple contains a list or a dictionary inside it, those can be changed even if the tuple itself is immutable.

For example, let's assume we have a tuple which contains a list and a dictionary as

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

we can change the contents of the list as

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

which makes new tuple looks like

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

we can also change the dictionary inside tuple as

my_tuple[4]['a'] = 500

which will make the overall tuple looks like

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

This happens because list and dictionary are the objects and these objects are not changing, but the contents its pointing to.

So the tuple remains immutable without any exception

---

The PEP 484 -- Type Hints says that the types of elements of a tuple can be individually typed; so that you can say Tuple[str, int, float]; but a list, with List typing class can take only one type parameter: List[str], which hints that the difference of the 2 really is that the former is heterogeneous, whereas the latter intrinsically homogeneous.

Also, the standard library mostly uses the tuple as a return value from such standard functions where the C would return a struct.

---

A direction quotation from the documentation on 5.3. Tuples and Sequences:

Though tuples may seem similar to lists, they are often used in different situations and for different purposes. Tuples are immutable, and usually contain a heterogeneous sequence of elements that are accessed via unpacking (see later in this section) or indexing (or even by attribute in the case of namedtuples). Lists are mutable, and their elements are usually homogeneous and are accessed by iterating over the list.

---

First of all, they both are the non-scalar objects (also known as a compound objects) in Python.

• Tuples, ordered sequence of elements (which can contain any object with no aliasing issue)
  • Immutable (tuple, int, float, str)
  • Concatenation using + (brand new tuple will be created of course)
  • Indexing
  • Slicing
  • Singleton (3,) # -> (3) instead of (3) # -> 3
• List (Array in other languages), ordered sequence of values
  • Mutable
  • Singleton [3]
  • Cloning new_array = origin_array[:]
  • List comprehension [x**2 for x in range(1,7)] gives you [1,4,9,16,25,36] (Not readable)

Using list may also cause an aliasing bug (two distinct paths pointing to the same object).

---

Lists are mutable and tuples are immutable. Just consider this example.

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

Now change index values of list and 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.

Hence proved the following code is invalid with tuple, because we attempted to update a tuple, which is not allowed.

---

As people have already mentioned the differences I will write about why tuples.

Why tuples are preferred?

Allocation optimization for small tuples

To reduce memory fragmentation and speed up allocations, Python reuses old tuples. If a tuple no longer needed and has less than 20 items instead of deleting it permanently Python moves it to a free list.

A free list is divided into 20 groups, where each group represents a list of tuples of length n between 0 and 20. Each group can store up to 2 000 tuples. The first (zero) group contains only 1 element and represents an empty tuple.

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

In the example above we can see that a and b have the same id. That is because we immediately occupied a destroyed tuple which was on the free list.

Allocation optimization for lists

Since lists can be modified, Python does not use the same optimization as in tuples. However, Python lists also have a free list, but it is used only for empty objects. If an empty list is deleted or collected by GC, it can be reused later.

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

Source: https://rushter.com/blog/python-lists-and-tuples/

Why tuples are efficient than lists? -> https://stackoverflow.com/a/22140115

---

List is mutable and tuples is immutable. The main difference between mutable and immutable is memory usage when you are trying to append an item.

변수를 만들 때 일부 고정 메모리가 변수에 할당됩니다. 목록이면 실제 사용 된 것보다 더 많은 메모리가 할당됩니다. 예를 들어 현재 메모리 할당이 100 바이트 인 경우 101 번째 바이트를 추가하려는 경우 다른 100 바이트가 할당 될 수 있습니다 (이 경우 총 200 바이트).

그러나 새 요소를 자주 추가하지 않는다는 것을 알고 있다면 튜플을 사용해야합니다. 튜플은 필요한 메모리의 정확한 크기를 할당하므로 특히 큰 메모리 블록을 사용할 때 메모리를 절약합니다.

참고 URL : https://stackoverflow.com/questions/626759/whats-the-difference-between-lists-and-tuples