์๋ฃ ๊ตฌ์กฐ์ ๊ธฐ๋ณธ ๋ด์ฉ์ ๋ํด ์ ๋ฆฌํด๋ณด์๋ค๋ฉด, ์ด๋ค ์ํฉ์์ ์ฐ์ด๋์ง์ ๋ํด ์ถ๊ฐ์ ์ผ๋ก ์ดํดํ๋ ๋จ๊ณ๊ฐ ํ์ํ ๊ฒ ๊ฐ๋ค. ์๋ฃ ๊ตฌ์กฐ์ ๋ํ ๊ธฐ๋ณธ์ ์ธ ์ฌ์ฉ ๋ฐฉ๋ฒ ์ธ์ ์๋ฃ ๊ตฌ์กฐ์ ๋ํด ์ถ๊ฐ์ ์ผ๋ก ์๊ฒ ๋๋ ๋ถ๋ถ์ ์ ๊ฒ์๋ฌผ์ ์ ๋ฆฌํ๋ ค๊ณ ํ๋ค ๐ฅ
"์ฝ๋ฉ์ ์๊ณ ๋ฆฌ์ฆ๊ณผ ์๋ฃ๊ตฌ์กฐ, ์ด ๋๊ฐ์ง๋ก ์ด๋ฃจ์ด์ง๋ค" by. Linus Torvalds
์๋ฃ ๊ตฌ์กฐ๋ ๋ฐ์ดํฐ์ ํธ๋ฆฌํ ์ ๊ทผ๊ณผ ์กฐ์์ ๊ฐ๋ฅํ๊ฒ ํ๋ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ฑฐ๋ ์กฐ์งํ๋ ๋ฐฉ๋ฒ์ด๋ค. ๋ฌธ๋งฅ๊ณผ ๋ฐ์ดํฐ์ ์ข
๋ฅ์ ๋ฐ๋ผ ์ ์ ํ ์๋ฃ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ์ ์ฒด ๊ฐ๋ฐ ์์คํ
์ ํฐ ์ํฅ์ ๋ผ์น๊ธฐ ๋๋ฌธ์, ์๋ฃ๊ตฌ์กฐ์ ๋ค์ํ ์ข
๋ฅ์ ๊ฐ๊ฐ์ ์ฅ์ ๊ณผ ํ๊ณ๋ฅผ ์ ์ดํดํ๊ณ ์ํฉ์ ๋ง๊ฒ ์ฌ๋ฐ๋ฅธ ์๋ฃ ๊ตฌ์กฐ๋ฅผ ์ ํํ๊ณ ์ฌ์ฉ
ํ๋ ๊ฒ์ด ์ค์ํ๋ค.
list ์ธ์๋ array๋ผ๋ ์๋ฃ ๊ตฌ์กฐ๊ฐ์๋ค. ๋ฉ๋ชจ๋ฆฌ ํจ์จ ๋ฉด์์๋ array๊ฐ ๋ ์ ๋ฆฌํ์ง๋ง ์ฌ์ฉํ๊ธฐ์๋ list๊ฐ ํธํ๋ค. array๋ ๋ชจ๋์ importํด์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค.
A = [[1,2,3], [11,12,13], [21,22,23]]
A[0][0] # output: 1
A[1][2] # output: 12
์ ๋ณด๊ฐ ์์ฃผ ์ญ์ ๋๊ฑฐ๋ ์ถ๊ฐ๋๋ ๋ฐ์ดํฐ๋ฅผ ๋ด๊ธฐ์๋ ์ ์ ํ์ง ์๋ค. ์์ฐจ์ ์ผ๋ก ๋์ด์๊ธฐ ๋๋ฌธ์ ์์๋ฅผ ์ญ์ ํ๋ฉด ๋ค์ ๊ฐ๋ค์ ๋ก๊ฒจ์ ์ธ๋ฑ์ค๋ฅผ ๋ค์ ์ง์ ํด์ผ ํ๋ค. ํด๋น ์ด์ ๋ก ๋ฉ๋ชจ๋ฆฌ ์์์ ์ด๋ฃจ์ด์ง๋ ์์ ์ด ๋ค๋ฅธ์๋ฃ ๊ตฌ์กฐ์ ๋นํด ํฌ๊ธฐ ๋๋ฌธ์, ์์๋ฅผ ์ญ์ ํ๋ ๊ฒ์ด ๋๋ฆด ์(expensive operation) ์๋ค.
์์ฃผ ๋์ด๋ ํ๋ฅ ์ด ๋์ ๋ฐ์ดํฐ๋ ์ ํฉํ์ง ์๋ค. pre-allocation์ ํ๊ธฐ ๋๋ฌธ์ ๋ฐฐ์ด์ด ๋์ด๋๋ฉด, ์๋ก์ด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์์ฑํ๊ณ ๊ฑฐ๊ธฐ์ ๊ธฐ์กด ๋ฐ์ดํฐ๋ฅผ ์์ฐจ์ ์ผ๋ก ๋ณต์ฌํ๊ธฐ ๋๋ฌธ์ re-sizing์ ์ ํฉํ์ง ์๋ค.
Array๋ฅผ ์ ์ฉ์ํค๋ฉด ์ข์ ์๋ก ์ฃผ์ ์ฐจํธ๊ฐ ์๋ค. ์ฃผ์ ์ฐจํธ์ ๋ํ ๋ฐ์ดํฐ๋
์ฆ, ์์๊ฐ ๊ต์ฅํ ์ค์ํ ๋ฐ์ดํฐ ์ด๋ฏ๋ก Array ๊ฐ์ด ์์๋ฅผ ๋ณด์กด ํด์ฃผ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค. ์ด์ ๊ฐ์ ๋ฐ์ดํฐ์ Array๋ฅผ ์ฌ์ฉํ์ง ์๋ ๊ฒฝ์ฐ, ์ฆ ์์๊ฐ ์๋ ์๋ฃ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ์๋ ๋ ์ง๋ณ ์ฃผ์ ๊ฐ๊ฒฉ์ ํ์ธํ๊ธฐ ์ด๋ ค์ฐ๋ฉฐ ๋งค๋ฒ ์ ์ฒด ์๋ฃ๋ฅผ ์ฝ์ด ๋ค์ด๊ณ ๋น๊ตํด์ผ ํ๋ ๋ฒ๊ฑฐ๋ก์์ด ๋ฐ์ํ๋ค.
list์ ๋ง์ฐฌ๊ฐ์ง๋ก ์์ฐจ์ ์ผ๋ก ๊ฐ์ ์ ์ฅํ์ง๋ง ํ ๋ฒ ์ ์ํ๊ณ ๋๋ฉด ์์ ํ ์ ์๋ค.
# Tuple์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ
[(1,2), (2,4)] # Array(List) ์์ Tuple
# Tuple์ ์ ์ฐ๋ ๊ฒฝ์ฐ์๋ class๋ฅผ ์์ฑํด์ผํจ
class cord:
def __init__(self, x, y):
self.x = x
self.y = y
set๋ array๋ list์ฒ๋ผ ์์ด ์๋ฃ๊ตฌ์กฐ(collection)์ด๋ค. ํ์ง๋ง ์์๋ผ๋ ๊ฐ๋
์ด ์กด์ฌํ์ง ์๋๋ค.
ํน์ ๊ฐ์ ํฌํจํ๊ณ ์๋์ง๋ฅผ ํ์ธ ํ๋๊ฒ์ ์ ์ฉํ๋ค. hash table์ด๋ผ๊ณ ์๋ ค์ง ์๋ฃ ๊ตฌ์กฐ ๋๋ถ์ ๊ฐ๋ฅํ ๋ถ๋ถ์ดใ
ใท.
e.g. 5 in my_set
set๊ฐ ์ ์ฅ๋ ๋ ๋ค์๊ณผ ๊ฐ์ ์์๋ก ์ ์ฅ๋๋ค.
๋ ๊ฐ์ set์์ ํฉ์งํฉ์ ๊ตฌํ๋ ๋ฐฉ๋ฒ. union ํจ์๋ | operator๋ฅผ ํตํด ๋ ๊ฐ์ set๋ฅผ ํฉ์น ์ ์๋ค. ๋ hash table values๋ ์์๋ฅผ ํฉ์ณ์ฃผ๊ณ , ์ค๋ณต๋ ์์ดํ ์ ์ญ์ ์ํจ๋ค.
people = {"Jay", "Idrish", "Archil"}
vampires = {"Karan", "Arjun"}
dracula = {"Deepanshu", "Raju"}
get_union1 = people.union(vampires)
# output : {'Idrish', 'Archil', 'Jay', 'Karan', 'Arjun'}
get_union_2 = people | dracula
# output : {'Idrish', 'Archil', 'Deepanshu', 'Raju', 'Jay'}
๋ ๊ฐ์ ์ธํธ์์ ๊ต์งํฉ์ ๊ตฌํ ์ ์๋ ๋ฐฉ๋ฒ. intersection ํจ์๋ & operator๋ก ๋ง๋ค ์ ์๋ค.
set1 = { 1,2,3,4,5 }
set2 = {3,4,5,6,7,8,9}
set3 = set1.intersection(set2)
set3 = set1 & set2
# output : {3,4,5}
๋ ๊ฐ์ ์ธํธ์์ ์ฐจ์งํฉ์ ๊ตฌํ ์ ์๋ ๋ฐฉ๋ฒ. difference ํจ์๋ - operator๋ก ๋ง๋ค ์ ์๋ค.
set1 = { 1,2,3,4,5 }
set2 = {3,4,5,6,7,8,9}
set3 = set1.difference(set2)
set1-set2 # output : {1, 2}
set2-set1 # output : {8, 9, 6, 7}
set ๋ด์ ์๋ element๋ฅผ ์ง์์ฃผ๋ ๊ธฐ๋ฅ
set3 = {3, 4, 5}
set3.clear() # output : set()
immutableํ ๊ฐ์ฒด. set๋ ์ธ์ ๋ ๋ฐ๋ ์ ์๋ ๋ฐ๋ฉด, frozen set์ ๋ง๋ค์ด์ง ๋ค์ ๋ณํ์ง ์๋๋ค.
frozen_set = frozenset(['a','b', 'c'])
frozen_set.add('h')
# File "<stdin>", line 1, in <module>
# AttributeError: 'frozenset' object has no attribute 'add'
์์์ ๋งํ๋ฏ ์์๊ฐ ์๊ณ , immutable type์ instance๋ง ์ถ๊ฐํ ์ ์๋ค.
- The set doesnโt maintain elements in any particular order.
- Only instances of immutable types can be added to a Python set.
๋จ๋ฐฉํฅ (one way) ์ํธํ. ๋จ๋ฐฉํฅ์ด๋ ํ๋ฒ ์ํธํ ํ๋ฉด ๋ณตํธํ๊ฐ ์๋๋ค๋ ๋ป์ด๋ค. ์ค์ ๊ฐ์ ๊ธธ์ด์ ์๊ด์์ด hash ๊ฐ์ ์ผ์ ํ ๊ธธ์ด๋ฅผ ๊ฐ์ง๋ค. ๊ทธ๋์ Hash๋ ์ฃผ๋ก ์์์ ๊ธธ์ด๋ฅผ ๊ฐ๋ ์์์ ๋ฐ์ดํฐ์ ๋ํด ๊ณ ์ ๋ ๊ธธ์ด์ ๋ฐ์ดํฐ๋ก ๋งคํํ ๋
์ฌ์ฉ๋๋ค.
SHA ํจ์๋ฅผ ์ด์ฉํด ๋ฌธ์์ด ๋ฐ์ดํฐ๋ฅผ ๋ฐ์ ํด์๊ฐ์ ๊ตฌํ ์ ์๋ค.
import hashlib
def sha1_hash(input_str):
hash_obj = hashlib.sha1(input_str.encode())
hash_value = hash_obj.hexdigest()
return hash_value
wecode_hash_value = sha1_hash('wecode')
print(wecode_hash_value)
# output : 283463014a3f8ab829fcf9087ff85d50da1d1bb6
print(len(wecode_hash_value))
# output : 40
hash_value_1234 = sha1_hash('1234')
print(hash_value_1234)
# output: 7110eda4d09e062aa5e4a390b0a572ac0d2c0220
print(len(hash_value_1234))
# output: 40
Dictionary (๋ค๋ฅธ ์ธ์ด์์๋ hashmap ์ด๋ hash table์ด๋ผ๊ณ ํ๊ธฐ๋ ํ๋ค)๋ Key-value ํํ์ ๊ฐ์ ์ ์ฅํ ์ ์๋ ์๋ฃ๊ตฌ์กฐ๋ค.