1) List
- ์ฌ๋ฌ ํ์ ์ ๊ฐ์ ํจ๊ป ๋ชจ์์ ์ ์ฅํ๊ณ (์ค๋ณต ํ์ฉ) ๊ฐ์ ๋ณ๊ฒฝํ ์ ์์ผ๋ฉฐ ์์๊ฐ ์กด์ฌํ๋ค. (Java์ ArrayList์ ์ ์ฌ)
[์์ฑ] - Create
numList = [] // ๋น ๋ฆฌ์คํธ ์ ์ธ
numList = list() // ๋น ๋ฆฌ์คํธ ์ ์ธ
numList = [1,2,3,4]
[์ ๊ทผ] - Read
print(numList[0])
→ list์ 0๋ฒ์งธ ์์์ ๊ฐ์ ๊ฐ์ ธ์ด
list[0:2]
→ list์ 0, 1๋ฒ์งธ ์์๋ฅผ ๋ฆฌ์คํธ ํํ๋ก ๋ฆฌํด
list[:7]
→ list์ 0 ~ 6๋ฒ์งธ ์์๋ฅผ ๋ฆฌ์คํธ ํํ๋ก ๋ฆฌํด
list[::-1]
→ list์ ๋ง์ง๋ง ~ 0๋ฒ์งธ ์์๋ฅผ ๋ฆฌ์คํธ ํํ๋ก ๋ฆฌํด (reverse)
list.index(data)
→ ํด๋น ๋ฐ์ดํฐ๊ฐ list ๋ด์ ๋ช ๋ฒ์งธ ์์์ ์์นํด์๋์ง ์ธ๋ฑ์ค ๊ฐ์ ๋ฆฌํดํ๋ฉฐ ์ค๋ณต๋ ๊ฐ์ด ์กด์ฌํ๋ ๊ฒฝ์ฐ, ๊ฐ์ฅ ๋งจ ์์ ์๋ ๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ๋ฆฌํด + data๊ฐ ์๋ ๊ฒฝ์ฐ ValueError ๋ฐ์
[์์ ] - Update
list[0] = “hello”
→ list์ 0๋ฒ์งธ ์์์ ๊ฐ์ “hello” ๋ฌธ์์ด๋ก ์์
list.append(data)
→ list์ ํด๋น data๋ฅผ ์ถ๊ฐ (๋งจ ๋ค์ชฝ์)
list.insert(index, data)
→ list์ ์ธ์๋ก ์ ๋ฌ๋ฐ์ ์ธ๋ฑ์ค์ data ๊ฐ์ ์ถ๊ฐ
list.extend(list2)
→ list์ list2๋ฅผ ๋ณํฉ --> list = list + list2 ๋ก ํด๋ ๋จ
[์ญ์ ] - Delete
list.pop()
→ list์ ๋ง์ง๋ง ์์๋ฅผ ๋ฆฌํดํ ๋ค์ ์ญ์ → ์ธ์๋ก ์ธ๋ฑ์ค๊ฐ์ ์ฃผ๋ฉด ํด๋น ์ธ๋ฑ์ค ๊ฐ์ ๋ฆฌํดํ๊ณ ์ญ์
list.clear()
→ list์ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ์ญ์ →ใ๋น ๋ฆฌ์คํธ๋ก ๋ง๋ฌ
list.remove(data)
→ ํด๋น ๋ฐ์ดํฐ๋ฅผ list์์ ์ ๊ฑฐํ๋ฉฐ ์ค๋ณต๋ ๊ฐ์ด ์๋ ๊ฒฝ์ฐ ๋งจ ์์ ์๋ ๊ฒ์ ์ญ์
del list[index]
→ ํด๋น index ๋ฒ์งธ ์์๋ฅผ ๋ฆฌ์คํธ์์ ์ ๊ฑฐ (์ธ๋ฑ์ค ์์ด “del list“์, ํด๋น list ๊ฐ์ฒด๋ฅผ ์ญ์ )
→ del list[list.index(data)] == list.remove(data)
[๊ธฐํ]
len(list)
→ list์ ๊ธธ์ด๋ฅผ ๋ฆฌํด
list.count(data)
→ list์ ํด๋น ๋ฐ์ดํฐ๊ฐ ๋ช ๊ฐ ์๋์ง ๊ฐฏ์๋ฅผ ๋ฆฌํดํจ (์ค๋ณต๋ ๊ฐ ๊ฐฏ์ ์ฒดํฌ)
list.sort()
→ list๋ฅผ ์ ๋ ฌ
list.reverse()
→ list๋ฅผ ๊ฑฐ๊พธ๋ก ๋ค์ง์
- ์ธ๋ฑ์ฑ, ์ฌ๋ผ์ด์ฑ์์ ๋ค๋ฅธ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ์ธ๋ฑ์ค๋ ๋ฌด์กฐ๊ฑด 0~์์ ์ ์๋ง ์ฌ์ฉํ ์ ์์ง๋ง ํ์ด์ฌ์ ์ธ๋ฑ์ค์ ์์ ํํ์ ์ฌ์ฉํ ์ ์๋ค.
- ์์๋ฅผ ๊ฐ์ง ์ธ๋ฑ์ค๋ ์์ด ์๋ ๋งจ ๋ค์์ Countํ๋ค
2) Tuple
- ์ฌ๋ฌ ํ์ ์ ๊ฐ์ ํจ๊ป ๋ชจ์์ ์ ์ฅํ๊ณ (์ค๋ณต ํ์ฉ) ๊ฐ์ ๋ณ๊ฒฝํ ์ ์์ผ๋ฉฐ ์์๊ฐ ์กด์ฌํ๋ค.
- ๋ฆฌ์คํธ์ ๋ฌ๋ฆฌ ์ด๊ธฐํ ์ดํ ๊ฐ์ ์ถ๊ฐํ๊ฑฐ๋ ์์ ํ ์ ์๋ค.
[์์ฑ] - Create
tup = () // ๋น ํํ ์ ์ธ
tup = tuple() // ๋น ํํ ์ ์ธ
tup = (1, 2, “hi”, True)
[์ ๊ทผ] - Read
print(tup[0])
→ tup์ 0๋ฒ์งธ ์์์ ๊ฐ์ ๊ฐ์ ธ์ด
tuple[0:2]
→ tuple์ 0, 1๋ฒ์งธ ์์๋ฅผ ๋ฆฌ์คํธ ํํ๋ก ๋ฆฌํด
tuple[:7]
→ tuple์ 0 ~ 6๋ฒ์งธ ์์๋ฅผ ๋ฆฌ์คํธ ํํ๋ก ๋ฆฌํด
tuple[::-1]
→ tuple์ ๋ง์ง๋ง ~ 0๋ฒ์งธ ์์๋ฅผ ๋ฆฌ์คํธ ํํ๋ก ๋ฆฌํด (reverse)
tuple.index(data)
→ ํด๋น ๋ฐ์ดํฐ๊ฐ tuple ๋ด์ ๋ช ๋ฒ์งธ ์์์ ์์นํด์๋์ง ์ธ๋ฑ์ค ๊ฐ์ ๋ฆฌํดํ๋ฉฐ ์ค๋ณต๋ ๊ฐ์ด ์กด์ฌํ๋ ๊ฒฝ์ฐ, ๊ฐ์ฅ ๋งจ ์์ ์๋ ๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ๋ฆฌํด + data๊ฐ ์๋ ๊ฒฝ์ฐ ValueError ๋ฐ์
[์์ , ์ญ์ ] - ๋ถ๊ฐ๋ฅ
del tuple
→ tuple ๊ฐ์ฒด๋ฅผ ์ญ์ tuple ๊ฐ์ฒด ์์ฒด๋ฅผ ์ญ์ ํ๋ ๊ฒ์ ๊ฐ๋ฅ
[๊ธฐํ]
len(tuple)
→ tuple์ ๊ธธ์ด๋ฅผ ๋ฆฌํด
tuple.count(data)
→ tuple์ ํด๋น ๋ฐ์ดํฐ๊ฐ ๋ช ๊ฐ ์๋์ง ๊ฐฏ์๋ฅผ ๋ฆฌํดํจ (์ค๋ณต๋ ๊ฐ ๊ฐฏ์ ์ฒดํฌ)
3) Set
- ์ฌ๋ฌ ํ์ ์ ๊ฐ์ ํจ๊ป ๋ชจ์์ ์ ์ฅํ์ง๋ง ๋ฆฌ์คํธ์ ํํ๊ณผ ๋ฌ๋ฆฌ ์ค๋ณต์ ํ์ฉํ์ง ์์ผ๋ฉฐ ์์ ๋ํ ์กด์ฌํ์ง ์๋๋ค.
[์์ฑ] - Create
st = set() // ๋น ์
์ ์ธ
set = {1,2,3,4,5} // set = {}๋ก ์ ์ธํ๊ฒ ๋๋ฉด ๋น ๋์
๋๋ฆฌ๊ฐ ์์ฑ๋๋ค!
[์ ๊ทผ] - Read
for n in set:
print(n)
→ Set๊ณผ ๋ค์์ ๋ฐฐ์ธ Dictionary๋ list, tuple๊ณผ ๋ฌ๋ฆฌ ์์๊ฐ ์๊ธฐ ๋๋ฌธ์ ์ธ๋ฑ์ฑ, ์ฌ๋ผ์ด์ฑ์ ์ง์ํ์ง ์์
→ set ์๋ฃํ์ ์ ์ฅ๋ ๊ฐ์ ์ธ๋ฑ์ฑ์ผ๋ก ์ ๊ทผํ๋ ค๋ฉด list๋ tuple ์๋ฃํ์ผ๋ก ๋ณํํ ํ์ ์ ๊ทผํด์ผ ํ๋ค.
→ ๋ฐ๋ผ์, set ์๋ฃํ์ ์ ์ฅ๋ ๊ฐ์ ์ ๊ทผํ๋ ค๋ฉด for ๋ฐ๋ณต๋ฌธ์ ์ด์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ์ผ๋ฐ์ ์ด๋ค.
→ li = list(set), tup = tuple(set) | st = set(list), st = set(tuple)
[์์ ] - Update
set.add(data)
→ set์ ํด๋น data๋ฅผ ์ถ๊ฐ
set.update(list or tuple)
→ set์ ์ฌ๋ฌ ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐ (์ธ์๋ list or tuple ์๋ฃํ)
[์ญ์ ] - Delete
set.remove(data)
→ ํด๋น ๋ฐ์ดํฐ๋ฅผ set์์ ์ ๊ฑฐ
set.pop()
→ set์ ์ ์ฅ๋ ์์์ ๋ฐ์ดํฐ๋ฅผ ์ ๊ฑฐ
set.clear()
→ set์ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ์ญ์ (๋น ์
์ผ๋ก ๋ง๋ฌ)
del set
→ set ๊ฐ์ฒด๋ฅผ ์ญ์
[๊ธฐํ]
len(set)
→ set์ ๊ธธ์ด๋ฅผ ๋ฆฌํด
[์งํฉ ํํ]
set1 = {“python”, “java”, “c++”, “javascript”}
set2 = {“python”, “c”, “javascript”, “php”}
[๊ต์งํฉ]
set1 & set2
→ set1๊ณผ set2์ ๊ต์งํฉ์ set ์๋ฃํ์ผ๋ก ๋ฆฌํด
set1.intersection(set2)
→ ์์ ๋์ผ
[ํฉ์งํฉ]
set1 | set2
→ set1๊ณผ set2์ ํฉ์งํฉ์ set ์๋ฃํ์ผ๋ก ๋ฆฌํด
set1.union(set2)
→ ์์ ๋์ผ
[์ฐจ์งํฉ]
tuple - tupel2
→ set1๊ณผ set2์ ์ฐจ์งํฉ์ set ์๋ฃํ์ผ๋ก ๋ฆฌํด
set1.difference(set2)
→ ์์ ๋์ผ
4) Dictionary
- ์ฌ๋ฌ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ key-value ํํ๋ก ์ ์ฅํ๊ณ key-value์์ key๊ฐ์ ์ค๋ณต์ ํ์ฉํ์ง ์์ง๋ง values ๊ฐ์ ์ค๋ณต์ ํ์ฉํ๋ค.
- ๋ํ, ์์๊ฐ ์กด์ฌํ์ง ์์ผ๋ฉฐ Java์ Hashmap๊ณผ ์ ์ฌํ๋ค.
[์์ฑ] - Create
dt = dict()
→ ๋น ๋์
๋๋ฆฌ ์ ์ธ
dict = {}
→ ๋น ๋์
๋๋ฆฌ ์ ์ธ
dict = {“1” : 2, 345 : “hi”}
[์ ๊ทผ] - Read
dict[key]
→ dict์ key์ ์ ์ฅ๋ value๋ฅผ ๊ฐ์ ธ์จ๋ค.
dict.get(key)
→ ์์ ๋์ผํ์ง๋ง ์์ ๋ฐฉ์์ ์กด์ฌํ์ง ์๋ ํค๋ฅผ ์ธ์๋ก ๋ฃ์ ๊ฒฝ์ฐ, ์๋ฌ๊ฐ ๋ฐ์ํจ
→ get(key) ํจ์ ์ฌ์ฉ ์, ์กด์ฌํ์ง ์๋ ํค๋ฉด None์ ๋ฆฌํดํ๊ณ None ๋์ ๋ค๋ฅธ ๋ฌธ์์ด์ ์ฌ์ฉํ๊ณ ์ถ๋ค๋ฉด get(key, str) ๋ ๋ฒ์งธ ์ธ์์ ๋์ ํ ๋ฌธ์์ด ๊ฐ์ ๋ฃ์ด์ฃผ๋ฉด ๋๋ค.
[์์ ] - Update
dict[key] = value
→ dict์ ํด๋น key๊ฐ ์กด์ฌํ๋ฉด ํด๋น value๋ก ์
๋ฐ์ดํธ, ์กด์ฌํ์ง ์์ผ๋ฉด ์ถ๊ฐ (ํ ๊ฐ)
dict.update(dict2)
→ dict์ ๋ค๋ฅธ dict๋ฅผ ๋ฃ์ด key๊ฐ ์กด์ฌํ๋ฉด ์
๋ฐ์ดํธ, ์กด์ฌํ์ง ์์ผ๋ฉด ์ถ๊ฐ (์ฌ๋ฌ ๊ฐ)
[์ญ์ ] - Delete
del dict[key]
→ ํด๋น key๋ฅผ dict์์ ์ ๊ฑฐ (key ์์ด “del dict”์, ํด๋น dict ๊ฐ์ฒด๋ฅผ ์ญ์ )
dict.pop(key)
→ ํด๋น key๋ฅผ dict์์ ์ ๊ฑฐ, ์์ ๋์ผ
dict.clear()
→ dict์ ์ ์ฅ๋ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ์ ๊ฑฐ
[๊ธฐํ]
len(dict)
→ dict์ ๊ธธ์ด๋ฅผ ๋ฆฌํด (key๊ฐ ๊ธฐ์ค)
dict.keys()
→ dict์ ๋ชจ๋ key๋ฅผ ๋ฆฌํด
dict.values()
→ dict์ ๋ชจ๋ value๋ฅผ ๋ฆฌํด
dict.items()
→ dict์ ๋ชจ๋ key, value๋ฅผ ๋ฆฌํด
[์ฐธ๊ณ ] mutable ๋ฐ immutable ๊ฐ์ฒด
- mutable : list, set, dict (์์ ๊ฐ๋ฅ)
- immutable : bool, int, float, tuple, string, frozenset (์์ ๋ถ๊ฐ๋ฅ)
- Java์์๋ List,Set,Map.of()๋ฅผ ํตํด immutableํ ๊ฐ์ฒด๋ฅผ ์์ฑํ ์ ์๋ค.
๋ฐ์ํ
'๐ง Programming > Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Python - ํจ์ (Function) ์ ์ธ (0) | 2023.08.08 |
---|---|
Python - ํ ์ค ๋ณตํฉ๋ฌธ (if, for) (0) | 2023.08.04 |
Python - ํ ์ค for๋ฌธ (Comprehension) (0) | 2023.08.04 |
Python - ํ ์ค if๋ฌธ (0) | 2023.08.04 |
Python 3.x ๋ฒ์ ์ค์นํ๊ธฐ (0) | 2023.08.04 |