List & Tuple : an ordered collection of objects

List & Tuple : an ordered collection of objects
realpython

List 특징

1. Lists Are Ordered

>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False

2. Lists Can Contain Arbitrary Objects

[21.42, 'foobar', 3, 4, 'bark', False, 3.14159]

>>> a = [int, len, foo, math]
>>> a
[<class 'int'>, <built-in function len>, <function foo at 0x02CA2618>,
<module 'math' (built-in)>]

3. List Elements Can Be Accessed by Index

: to accessing individual characters in a string

• len()

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> print(a[2:], a[2:len(a)])
['baz', 'qux', 'quux', 'corge'] ['baz', 'qux', 'quux', 'corge']

• stride

>>> a[0:6:2]
['foo', 'baz', 'quux']
>>> a[1:6:2]
['bar', 'qux', 'corge']
>>> a[6:0:-2]
['corge', 'qux', 'bar']

• reverse

>>> a[::-1]
['corge', 'quux', 'qux', 'baz', 'bar', 'foo']

>>> 'If Comrade Napoleon says it, it must be right.'[::-1]
'.thgir eb tsum ti ,ti syas noelopaN edarmoC fI'

• how the [:] syntax works with a string
  : If s is a string, s[:] returns a reference to the same object:

>>> s = 'foobar'
>>> s[:]
'foobar'
>>> s[:] is s
True

: Conversely, if a is a list, a[:] returns a new object that is a copy of a:

>>> a[:]
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[:] is a
False

• built-in functions

## in/not in
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> 'qux' in a
True
>>> 'thud' not in a
True

## concatenation(+) ,replication(*)
>>> a + ['grault', 'garply']
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 'grault', 'garply']
>>> a * 2
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 'foo', 'bar', 'baz',
'qux', 'quux', 'corge']

## The len(), min(), and max() functions:
>>> len(a)
6
>>> min(a)
'bar'
>>> max(a)
'qux'

4. Lists Can Be Nested

>>> x = ['a', ['bb', ['ccc', 'ddd'], 'ee', 'ff'], 'g', ['hh', 'ii'], 'j']

>>> x[1]
['bb', ['ccc', 'ddd'], 'ee', 'ff']

>>> x[1][1]
['ccc', 'ddd']

>>> print(x[3][0], x[3][1])
hh ii

>>> x[1][1:3]
[['ccc', 'ddd'], 'ee']
>>> x[3][::-1]
['ii', 'hh']

5. Lists Are Mutable

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a[2] = 10
>>> a[-1] = 20
>>> a
['foo', 'bar', 10, 'qux', 'quux', 20]

>>> del a[3]
>>> a
['foo', 'bar', 'baz', 'quux', 'corge']

• insert multiple elements using a slice

>>> a = [1, 2, 3]
>>> a[1:2] = [2.1, 2.2, 2.3]
>>> a
[1, 2.1, 2.2, 2.3, 3]

• insert multiple elements using a list

>>> a = [1, 2, 3]
>>> a[1] = [2.1, 2.2, 2.3]
>>> a
[1, [2.1, 2.2, 2.3], 3]

• insert elements into a list without removing anything

>>> a = [1, 2, 7, 8]
>>> a[2:2] = [3, 4, 5, 6]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8]

• delete multiple elements

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[1:5] = []
>>> a
['foo', 'corge']

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> del a[1:5]
>>> a
['foo', 'corge']

• Prepending(접두) or Appending(첨부) Items to a list

>>> a += ['grault', 'garply']
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 'grault', 'garply']

>>> a = [10, 20] + a
>>> a
[10, 20, 'foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a += 'corge'
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'c', 'o', 'r', 'g', 'e']

• a.append(obj)
  : 제자리에서 수정, 새로운 리스트를 만들지않는다

a = ['a', 'b']
>>> a.append(123)
>>> a
['a', 'b', 123]

>>> x = a.append(123)
>>> print(x)
None
>>> a
['a', 'b', 123]

• concatenation(+) vs Prepending(+=) vs .append vs .extend

>>> a = ['a', 'b']
>>> a + [1, 2, 3]
['a', 'b', 1, 2, 3]

>>> a.append([1, 2, 3])
>>> a
['a', 'b', [1, 2, 3]]

# Thus, with .append(), you can append a string as a single entity:
>>> a.append('foo')
>>> a
['a', 'b', 'foo']

>>> a.extend([1, 2, 3])
>>> a
['a', 'b', 1, 2, 3]

>>> a += [1, 2, 3]
>>> a
['a', 'b', 1, 2, 3]

• .insert(index, obj)

>>> a.insert(3, 3.14159)
>>> a[3]
3.14159
>>> a
['foo', 'bar', 'baz', 3.14159, 'qux', 'quux', 'corge']

• .remove(obj)

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a.remove('baz')
>>> a
['foo', 'bar', 'qux', 'quux', 'corge']

• .pip(defalt=-1)

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a.pop()
'corge'
>>> a
['foo', 'bar', 'baz', 'qux', 'quux']

>>> a.pop()
'quux'
>>> a
['foo', 'bar', 'baz', 'qux']

6. Lists Are Dynamic

: When items are added to a list, it grows as needed

>>> a[2:2] = [1, 2, 3]
>>> a += [3.14159]
>>> a
['foo', 'bar', 1, 2, 3, 'baz', 'qux', 'quux', 'corge', 3.14159]

>>> a[2:3] = []
>>> del a[0]
>>> a
['bar', 'qux', 'quux', 'corge']

Tuple

: 튜플은 아래 2가지만 빼고 List와 동일하다.

• ()를 사용
• Tuples are immutable.

List 대신 Tuple 을 사용하는 이유

• 튜플이 리스트보다 프로그램 실행이 더 빠르다. (리스트나 튜플의 크기가 클 때)
• 데이터 수정을 원하지 않는 경우. 컬렉션의 값이 프로그램을 실행하는 동안 데이터 값이 일정하게 유지 되도록 하며 우발적인 수정을 방지할 수 있습니다.
• 또 다른 파이썬 데이터 유형 dictionary의 구성요소 중 KEY는 불변의 값을 필요로합니다. 이 목적으로 튜플을 사용할 수 있지만 리스트는 사용할 수 없습니다.

튜플의 특징

: 튜플은 [ ]대신 괄호(parentheses)를 사용하지만, string, list와 마찬가지로 인덱스와 슬라이스를 사용할 수 있다.

>>> t = ('foo', 'bar', 'baz', 'qux', 'quux', 'corge')

>>> t[0]
'foo'
>>> t[-1]
'corge'
>>> t[1::2]
('bar', 'qux', 'corge')

>>> t[::-1]
('corge', 'quux', 'qux', 'baz', 'bar', 'foo')

• 1개의 item만 사용하는 경우 콤마(,)사용

>>> t = (2)
>>> type(t)
<class 'int'>

>>> t = (2,)
>>> type(t)
<class 'tuple'>
>>> t[0]
2
>>> t[-1]
2

Tuple Assignment, Packing, and Unpacking

• Assignment

>>> t = ('foo', 'bar', 'baz', 'qux')

• Packing
  the items in the tuple have been “packed” into the object:
  

>>> t
('foo', 'bar', 'baz', 'qux')
>>> t[0]
'foo'
>>> t[-1]
'qux'

• Unpakcing
  If that “packed” object is subsequently assigned to a new tuple, the individual items are “unpacked” into the objects in the tuple:
  

>>> (s1, s2, s3, s4) = t
>>> s1
'foo'
>>> s2
'bar'
>>> s3
'baz'
>>> s4
'qux'

• swap
  

요약 및 정리

리스트

• 인덱스와 메소드를 활용하기 때문에 동적으로 값의 수정 및 정렬이 쉽다.
• 기본적으로 [ ] 대괄호 사용
• 동적이다. 저장, 수정 삭제가 용이
• 튜플과의 차이점 : 리스트는 메소드를 활용해 값을 마음대로 수정할 수 있지만 튜플은 수정안됨
• 딕셔너리와의 차이점 : 리스트는 인덱스로 값에 접근할 수 있지만 딕셔너리는 인덱스 사용 불가. (key로 값에 접근함)
• 파이썬 리스트는 연산에 대한 메소드를 가지고 있어 단순 자료형이 아닌 자료구조의 형태를 갖는다.
• 배열의 기능 : 여러개의 값 저장
• 모든 데이터 타입 사용 가능
• 다차원 리스트 (리스트 안 리스트)
  다차원 리스트는 게입개발, 대규모 머신러닝 알고리즘에서 사용된다
• 특정변수에 리스트 저장가능