header-img
Info :
728x90

νŒŒμ΄μ¬μ—μ„œ list 와 dictionary λŠ” 거의 ν•„μˆ˜μ μΈ μš”μ†Œ. 이거 λ‘κ°œλŠ” κ°œλ…μ„ κΌ­ 짚고 λ„˜μ–΄κ°€μ•Όκ² λ‹€.

λ‘κ°œ λ‹€ λ‚΄μž₯ μžλ£Œν˜• type

 

1. 리슀트의 νŠΉμ§•

- μ—¬λŸ¬ 데이터λ₯Ό μˆœμ„œμžˆκ²Œ λ‹΄κΈ° μœ„ν•΄μ„œ μ‚¬μš©λ˜λŠ” μžλ£Œν˜•

- 타 μ–Έμ–΄μ˜ array 와 μœ μ‚¬ν•˜λ‚˜ μžλ£Œν˜•μ— μ œν•œμ΄ μ—†μŒ

- νŒŒμ΄μ¬μ—μ„œ κ°€μž₯ λ²”μš©μ μœΌλ‘œ μ‚¬μš©λœλ‹€κ³  ν•  수 있음

- κ°€λ³€(mutable) μžλ£Œν˜•μ΄κΈ° λ•Œλ¬Έμ— 리슀트 생성 후에 자유둭게 μƒˆλ‘œμš΄ 데이터λ₯Ό μΆ”κ°€ν•˜κ±°λ‚˜, κΈ°μ‘΄ 데이터λ₯Ό λ³€κ²½ λ˜λŠ” μ œκ±°ν•  수 있음

- 파이썬의 νŠΉμ§•μΈ 동적 타이핑(dynamic typing) 덕에 이 list μ•ˆμ— μ—¬λŸ¬ νƒ€μž…μ˜ 데이터λ₯Ό μ €μž₯ν•  수 있음

   * dynamic typing 동적 타이핑 : μ €μž₯ν•  데이터 νƒ€μž…μ„ λͺ…μ‹œν•˜μ§€ μ•Šκ³ λ„ μ„ μ–Έν•  수 μžˆλŠ”..

   * 고둜 기쑴에 μ‚¬μš©ν•˜λ˜ μ–Έμ–΄(js..)μ—μ„œ array 와 μœ μ‚¬ν•˜λ‹€κ³  μƒκ°ν•˜κΈ° μ‰¬μš΄λ° array 처럼 μžλ£Œν˜• fix μ‹œν‚€κ³  μ‹ΆμœΌλ©΄ νŠœν”Œ(tuple) μ‚¬μš©ν•΄μ•Όν•¨

2. 리슀트 생성

- [] μ•ˆμ— μ‰Όν‘œ(,) 둜 κ΅¬λΆ„ν•΄μ„œ λ‚˜μ—΄ ν•˜λ©΄ λœλ‹€.

- μ•žμ—μ„œ λ§ν–ˆλ“―μ΄ type 에 ꡬ애λ₯Ό 받지 μ•ŠμœΌλ―€λ‘œ λ‹€μ–‘ν•œ 데이터λ₯Ό 지정할 수 μžˆλ‹€.

>>> [1, 3.14, 'A', True, None, {'b': 2}, ['c', 'd'], lambda x: x * x]
[1, 3.14, 'A', True, None, {'b': 2}, ['c', 'd'], <function <lambda> at 0x1012471a0>]

- μ•žμœΌλ‘œ μ–΄λ–€ data λ₯Ό λ°›μ•„μ˜€κΈ° μœ„ν•΄μ„œ 빈 list λ₯Ό μ„ μ–Έν•˜κ³  μ‹Άλ‹€λ©΄ [] 곡백 list λ₯Ό μ„ μ–Έν•˜κ±°λ‚˜ κ·Έλƒ₯ list() λ‚΄μž₯ ν•¨μˆ˜λ₯Ό ν˜ΈμΆœν•΄μ£Όλ©΄ λœλ‹€.

>>> []
[]
>>> list()
[]

- κ·Έ μ΄μ™Έμ˜ list ν™œμš©λ²•

>>> list({'A', 'B', 'C'}) # νŠœν”Œμ„ 리슀트둜 λ³€ν™˜
['A', 'B', 'C']
>>> list(range(10)) # range 객체λ₯Ό 리슀트둜 λ³€ν™˜
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(enumerate(['A', 'B', 'C'])) # enumerate 객체λ₯Ό 리슀트둜 λ³€ν™˜
[(0, 'A'), (1, 'B'), (2, 'C')]

μžλ£Œν˜•μ΄ μ§€μ •λ˜μ–΄μžˆλŠ” 것(tuple)도 λ¦¬μŠ€νŠΈμ— 넣을 수 있고, range ν•¨μˆ˜ ν†΅ν•΄μ„œ 숫자 λ‚˜μ—΄λœ κ±Έ λ¦¬μŠ€νŠΈμ— 넣을 μˆ˜λ„ μžˆλ‹€. 

λ˜ν•œ μˆœμ„œκ°€ μžˆλŠ” μžλ£Œν˜•(list, set, tuple, dictionary, string)을 μž…λ ₯으둜 λ°›μ•„ 인덱슀 값을 ν¬ν•¨ν•˜λŠ” enumerate 객체도 list 에 λ„£μ–΄μ„œ 보관할 수 μžˆλ‹€. κ·Έλƒ₯ λ‹€ λ“€μ–΄κ°€λŠ” λ°”κ΅¬λ‹ˆ 라고 μƒκ°ν•˜λ©΄ 될 λ“―.

3. 데이터 μΆ”κ°€

- js μ—μ„œ .push κ°€ μžˆλ“―μ΄ python μ—μ„œλŠ” append() κ°€ μžˆλ‹€. : 뒀에 계속 μŒ“λŠ” 것

>>> fruits = []
>>> fruits.append('Apple')
>>> fruits.append('Banana')
>>> fruits.append('Cherry')
>>> fruits
['Apple', 'Banana', 'Cherry']

- 근데 또 λ‚΄κ°€ μ›ν•˜λŠ” μœ„μΉ˜μ— 값을 λ„£μ–΄μ€˜μ•Ό ν•  λ•Œκ°€ μžˆλŠ”λ°.. κ·Έλ•ŒλŠ” insert() λ©”μ„œλ“œλ₯Ό μ‚¬μš©ν•΄λ³΄μž.

>>> fruits.insert(0, 'Mango')
>>> fruits
['Mango', 'Apple', 'Banana', 'Cherry']
>>> fruits.insert(1, 'Orange')
>>> fruits
['Mango', 'Orange', 'Apple', 'Banana', 'Cherry']

* insert() μ‚¬μš© μ‹œ 주의 점 : 파이썬의 list 의 경우 random access(λ¬΄μž‘μœ„ μ ‘κ·Ό)에 μ΅œμ ν™”λœ 자료 κ΅¬μ‘°μ—¬μ„œ insert() μ‚¬μš©ν•˜κ²Œ 되면.. κΈ°μ‘΄ λ°°μ—΄ 내에 있던 λ’€μ˜ λ§Žμ€ data 듀을 μ­‰- ν•œμΉΈμ”© λ’€λ‘œ 땑기라고 ν•΄μ•Όν•΄μ„œ μ„±λŠ₯상 λΆˆλ¦¬ν•˜λ‹€.

   -> ν•΄κ²° 방법 : λ§Œμ•½μ— list μ•ž μͺ½μ— data λ₯Ό 밀어넣을 κ²½μš°κ°€ λ§Žλ‹€λ©΄? deque 와 queue 같은 μžλ£Œν˜•μ„ 고렀해보도둝 ν•˜μž.

4. 데이터 μ ‘κ·Ό

- index μ‚¬μš©ν•΄μ„œ μ ‘κ·Όν•œλ‹€. list[index] ν˜•μ‹μœΌλ‘œ μ ‘κ·Ό.

>>> fruits[0]
'Mongo'
>>> fruits[2]
'Apple'

- python 의 κ²½μš°λŠ” 음수 index 도 지원. 음수 인덱슀의 경우 λ’€μ—μ„œ λͺ‡λ²ˆμ§Έμ— μžˆλŠ”μ§€ 가지고 μ˜¨λ‹€.

   μ¦‰. list[-index] = list[len(list)-index] 의 의미

>>> fruits[-1] # fruits[len(fruits) - 1]
'Cherry'
>>> fruits[-3] # fruits[len(fruits) - 3]
'Apple'

5. 리슀트 μŠ¬λΌμ΄μ‹±

- νŠΉμ • λ²”μœ„μ˜ 데이터 접근을 νŽΈν•˜κ²Œ ... .~!!!

- λŒ€κ΄„ν˜Έ μ•ˆμ— : 기호 μ‚¬μš©ν•΄μ„œ μ ‘κ·Ό μ›ν•˜λŠ” λ²”μœ„ μ‹œμž‘ index 와 μ’…λ£Œ index λͺ…μ‹œ ν•΄μ£Όλ©΄ 됨.

>>> fruits = ['Mongo', 'Orange', 'Apple', 'Banana', 'Cherry']
>>> fruits[1:3]
['Orange', 'Apple']

- μ‘μš© ver 1 : μ‹œμž‘ 인덱슀 μƒλž΅ μ‹œ μ²˜μŒλΆ€ν„° μ‹œμž‘, μ’…λ£Œ 인덱슀 μƒλž΅ μ‹œ list λ§ˆμ§€λ§‰ κΉŒμ§€ λ²”μœ„μ— 포함

>>> fruits[:3]
['Mongo', 'Orange', 'Apple']
>>> fruits[1:]
['Orange', 'Apple', 'Banana', 'Cherry']

- μ‘μš© ver 2 : λŒ€κ΄„ν˜Έ 기호 ν•œλ²ˆ 더 μ¨μ„œ μ›μ†Œ 사이 간격 지정도 κ°€λŠ₯ ::

>>> fruits[::2]
['Mongo', 'Apple', 'Cherry']

- μ‘μš© ver 3 : μ‘μš© ver2 의 κ°œλ…μ„ μ‚¬μš©ν•΄μ„œ 리슀트 거꾸둜 뒀집은 볡사본도 μ‰½κ²Œ λ±‰μ–΄λ‚΄μ€Œ

>>> fruits[::-1]
['Cherry', 'Banana', 'Apple', 'Orange', 'Mongo']

6. 데이터 κ°±μ‹ 

- 기쑴의 μΈλ±μŠ€μ— κ°’ 집어 λ„£μ–΄μ£Όλ©΄ error 없이 κ·Έλƒ₯ κ·Έ μœ„μΉ˜μ˜ data κ°€ μΉ˜ν™˜λ¨

- μœ„μ˜ μŠ¬λΌμ΄μ‹± 기법을 μ‚¬μš©ν•΄μ„œ μ—¬λŸ¬ 데이터λ₯Ό ν•œκΊΌλ²ˆμ— κ°±μ‹ ν•  μˆ˜λ„ 있음

>>> fruits[1] = 'Kiwi'
>>> fruits
['Mongo', 'Kiwi', 'Apple', 'Banana', 'Cherry']

>>> fruits[2:4] = ['Lemon', 'Grape']
>>> fruits
['Mongo', 'Kiwi', 'Lemon', 'Grape', 'Cherry']

7. 데이터 μ‚­μ œ

- 방법 1. remove(data) 둜 dataλ₯Ό 인수둜 λ„˜κΈ°λŠ” 방법

- 방법 2. pop() λ©”μ„œλ“œ μ‚¬μš©ν•΄μ„œ index λ„˜κΈ°λŠ” 방법

>>> fruits = ['Mongo', 'Kiwi', 'Apple', 'Banana', 'Cherry']
>>> fruits.remove('Kiwi')
>>> fruits
['Mongo', 'Apple', 'Banana', 'Cherry']

// 인수 지정 μ•ˆν•΄μ£Όλ©΄ 맨 λ’€μ˜ 데이터 μ‚­μ œν•¨
>>> fruits.pop()
'Cherry'
>>> fruits
['Mongo', 'Apple', 'Banana']

>>> fruits.pop()
'Cherry'
>>> fruits
['Mongo', 'Apple', 'Banana']

- 방법 3. pop 처럼 데이터λ₯Ό μ‚­μ œ ν•˜λ˜, μ‚­μ œν•œ 데이터λ₯Ό μ–»κ³  싢지 μ•Šμ€ κ²½μš°λŠ” del μ—°μ‚°μž μ‚¬μš©ν•΄λ„ 됨.

>>> del fruits[1]
>>> fruits
['Mongo', 'Banana']

8. 리슀트 순회

- λ¦¬μŠ€νŠΈμ— μžˆλŠ” data κ°’ 전체 가지고 였고 μ‹ΆμœΌλ©΄ ? for .. in.. 루프 νƒœμš°λ©΄ 됨

>>> fruits = ['Mongo', 'Apple', 'Banana']
>>> for fruit in fruits:
...     print(fruit)
...
Mongo
Apple
Banana

- 인덱슀 λ²ˆν˜Έλž‘ 같이 가지고 였고 μ‹ΆμœΌλ©΄ enumerate() ν•¨μˆ˜ ν™œμš©ν•  것

for idx, fruit in enumerate(fruits):
...     print(idx, fruit)
...
0 Mongo
1 Apple
2 Banana

9. 데이터 쑴재 μ—¬λΆ€ 확인

- in μ—°μ‚°μžλ₯Ό μ‚¬μš©ν•˜λ©΄ νŠΉμ • 데이터가 λ¦¬μŠ€νŠΈμ— λ“€μ–΄μžˆλŠ”μ§€ 확인할 수 있음.

- ν™œμš© tip: 값을 true/false 둜 λ±‰μ–΄μ£Όλ―€λ‘œ 이 속성을 μ΄μš©ν•΄ if λ¬Έ μ‚¬μš©ν•˜λ©΄ 됨.

>>> fruits = ['Mongo', 'Apple', 'Banana']
>>> "Apple" in fruits
True
>>> "Lemon" in fruits
False
>>> "Lemon" not in fruits
True

10. 리슀트 병합

- μ—¬λŸ¬ 개 리슀트 ν•©μΉ  λ•Œ λ‹¨μˆœν•˜κ²Œ λ”ν•˜κΈ°(+) μ—°μ‚°μž μ‚¬μš©ν•΄μ£Όλ©΄ 됨

- js 의 ... μ—°μ‚°μž (μ „κ°œ μ—°μ‚°μž) 와 λΉ„μŠ·ν•œ 문법도 μžˆλŠ”λ°  * μ—°μ‚°μž μ‚¬μš©ν•΄μ„œ λŒ€κ΄„ν˜Έ μ•ˆμ— ν•©μΉ  리슀트λ₯Ό ,둜 κ΅¬λΆ„ν•˜μ—¬ λ‚˜μ—΄ν•˜λ©΄ 됨

>>> li1 = ["A", "B"]
>>> li2 = ["C", "D"]
>>> li1 + li2
['A', 'B', 'C', 'D']

>>> [*li1, *li2]
['A', 'B', 'C', 'D']

- ν™œμš©μ„ μž˜ν•˜λ©΄ 더 효율적으둜 μ‚¬μš©ν•  수 있게 λ˜λŠ”λ°. κ·Έ μ˜ˆμ‹œ

>>> [1, 2, *li1, 3, 4, *li2] # [1, 2] + li1 + [3, 4] + li2
[1, 2, 'A', 'B', 3, 4, 'C', 'D']

11. 리슀트 볡제

- κ³±ν•˜κΈ°(*) μ—°μ‚°μž μ‚¬μš©ν•˜λ©΄ 같은 리슀트 μ—¬λŸ¬ 번 볡제 κ°€λŠ₯

>>> li = ["A", "B", "C"]
>>> li * 1
['A', 'B', 'C']
>>> li * 2
['A', 'B', 'C', 'A', 'B', 'C']

12. 리슀트 ν™•μž₯

ν•˜λ‚˜μ˜ λ¦¬μŠ€νŠΈμ— λ‹€λ₯Έ 리슀트의 λͺ¨λ“  데이터λ₯Ό μΆ”κ°€ν•˜κ³  μ‹ΆμœΌλ©΄ extend() λ©”μ„œλ“œλ₯Ό μ‚¬μš©ν•˜λ©΄ 됨

>>> li1 = ["A", "B"]
>>> li2 = ["C", "D"]
>>> li1.extend(li2)
>>> li1
['A', 'B', 'C', 'D']

13. 리슀트 동등성 확인

- 리슀트의 경우 μˆœμ„œκ°€ μžˆμ–΄μ„œ.. 같은 data 여도 μˆœμ„œκ°€ λ‹€λ₯΄λ©΄ λ‹€λ₯Έ 리슀트둜 인식함 (λ‹Ήμ—°ν•œ κ±°μž„)

14. λ¦¬μŠ€νŠΈμ™€ ν•¨κ»˜ μ“Έ 수 μžˆλŠ” λ‚΄μž₯ ν•¨μˆ˜

- len(list) : 리슀트 길이 κ°’ λ°˜ν™˜

- min(list) : λ¦¬μŠ€νŠΈμ—μ„œ κ°€μž₯ μž‘μ€ data κ°€ λ°˜ν™˜

- max(list) : λ¦¬μŠ€νŠΈμ—μ„œ κ°€μž₯ 큰 data κ°€ λ°˜ν™˜

- JS μ—μ„œλ„ κ·Έλ ‡λ“― filter() λ‚˜ map() 잘 ν™œμš©ν•˜λŠ” 것도 쒋을 λ“― 

 


python 은 ν™•μž₯성도 μ’‹κ³  μ§€μ›ν•΄μ£ΌλŠ” κΈ°λŠ₯도 많음

근데 자료 λͺ…μ‹œκ°€ μ•ˆλ˜λ‹ˆκΉŒ 데이터 집어 넣어쀄 λ•Œ 확인이 ν•„μˆ˜ 일 것 κ°™λ‹€.

λ‹Ήμž₯의 였λ₯˜λ₯Ό μ•ˆ 뱉을 뿐 후에 데이터 κ°€κ³΅ν•˜λŠ” λΆ€λΆ„μ—μ„œ 였λ₯˜λΌλ„ 터져버리면 ν•˜λ‚˜ν•˜λ‚˜ μ°Ύμ•„μ•Όν• ν…Œλ‹ˆ

 

λ‹€μŒμ—λŠ” μ‹œκ°„μ΄ 되면 python μ—μ„œ list 와 μ–‘λŒ€μ‚°λ§₯이라고 ν•˜λŠ” dictionary 도 ν¬μŠ€νŒ…ν•΄λ³΄λ„λ‘ ν•˜κ² λ”°

dictionary λŠ” λ‹€λ₯Έ κ°œλ°œν•  λ•ŒλŠ” 많이 μ ‘ν•  κΈ°νšŒκ°€ μ—†μ—ˆλŠ”λ° λ‚˜λŠ” RPA κ°œλ°œμ—μ„œ 많이 μ‚¬μš©ν•œ 전적이 μžˆμ–΄μ„œ μ•„λ¬΄λž˜λ„ 이해와 μ„€λͺ…이 쉽지 μ•Šμ„κΉŒ μ‹Άλ‹€.

728x90
더보기
FRONTEND/곡뢀