๐ ๋ณ์(Variable)์ ๋ฆฌ์คํธ(List)
๐ ํฐ ๋ ธ์ด๋ง ๊ตฌ์กฐ(Von Neumann Structure)
User๊ฐ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ ๋๋ ํ๋ก๊ทธ๋จ์ ์คํ์ํฌ ๊ฒฝ์ฐ,
ํด๋น ์ ๋ณด๋ฅผ ๋จผ์ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅํ ๋ค์,
CPU๊ฐ ์์ฐจ์ ์ผ๋ก ๊ทธ ์ ๋ณด๋ฅผ ํด์ํ๊ณ ๊ณ์ฐํด ์ถ๋ ฅ
๐ฅ ๋ณ์(Variable): Data(๊ฐ)์ ์ ์ฅํ๊ธฐ ์ํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํ๋ก๊ทธ๋จ์ ์ด๋ฆ
ex) a = 5 --> 5๋ผ๋ ๊ฐ์ a์ ๋ฃ์ด๋ผ
๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๊ฐ์ง๊ณ ์์(์ ์ธ ์ ๋ฉ๋ชจ๋ฆฌ ํน์ ์์ญ์ ๋ฌผ๋ฆฌ์ ๊ณต๊ฐ์ผ๋ก ํ ๋น)
- ์์ฑ๋ฒ: ์ํ๋ฒณ, ์ซ์, ์ธ๋ ์ค์ฝ์ด(_)๋ก ์ ์ธ
์๋ฏธ์๋ ๋จ์ด๋ก ํ ๊ฒ
๋ ์๋ฌธ์ ๊ตฌ๋ถ
์์ฝ์ด ์ฌ์ฉ X
- ๊ธฐ๋ณธ ์๋ฃํ: ์์น ์๋ฃํ - ์ ์(integer, ์์/์์), ์ค์(float, ์์์ )
๋ฌธ์ํ(String)
๋ ผ๋ฆฌ ์๋ฃํ(Boolean) - ์ฐธ(True) / ๊ฑฐ์ง(False)
** C, JAVA์ ๊ฐ์ ์ธ์ด์ ๋ค๋ฅด๊ฒ Python์ ๋ณ์ํ์ ์ ์ธํด ์ค ํ์ X
- ์ฐ์ฐ์, ํผ์ฐ์ฐ์(Operator, Operand)
์ฐ์ฐ์: + - * / **(์ ๊ณฑ) %(๋๋จธ์ง) += -= ๋ฑ
ํผ์ฐ์ฐ์: ์ฐ์ฐ์์ ์ํด ๊ณ์ฐ๋๋ ์ซ์, ๋ฌธ์
** ๋ฌธ์๊ฐ +์ฐ์ฐ ๊ฐ๋ฅ(Concatenate)
- ํ ๋ณํ: int์๋ฃํ์ float์ผ๋ก ๋ณํํ๊ฑฐ๋ ๋ฐ๋๋ก ๋ณํ์ด ๊ฐ๋ฅ(ํ์ฌ ๋ณ์ํ์ type()ํจ์๋ก ํ์ธ ๊ฐ๋ฅ)
ex) a = 10 --> intํ ๋ณ์ b = float(a) -->floatํ ๋ณ์(print์ 10.0์ผ๋ก ์ถ๋ ฅ)
๐ ์ปดํจํฐ๋ ์ 2์ง์๋ฅผ ์ฌ์ฉํ ๊น?
-> ์ปดํจํฐ๋ ์ค๋ฆฌ์ฝ์ด๋ผ๋ ์ฌ๋ฃ๋ก ๋ง๋ ๋ฐ๋์ฒด๋ก ๊ตฌ์ฑ๋์ด ์๋ค. ์ด ๋ฐ๋์ฒด์ ํน์ง์ ํน์ ์๊ทน์์ ์ ๊ธฐ๊ฐ ํตํ๋๋ฐ ์ด๊ฒ์ ํ์ฉํ์ฌ ์ ๊ธฐ์ ํ๋ฆ์ ์ ์ดํ ์ ์๋ค. ๋ฐ๋ผ์ ์ ๋ฅ๊ฐ ํ๋ฅผ ๋๋ฅผ 1, ํ๋ฅด์ง ์์ ๋๋ฅผ 0์ด๋ผ๋ ์ซ์๋ก ํ๊ธฐ๊ฐ ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ด๋ค. ํ์ฌ ์์์ปดํจํฐ๋ฑ์ ๊ณ๋ฐํ๊ณ ์๋ ๊ฒ์ ์ด๋ฌํ ํ๋ ์์ ๋ฒ์ด๋๊ธฐ ์ํจ์ด๋ผ๊ณ ํ๋ค.
๐ฅ ๋ฆฌ์คํธ(List): ๋ฆฌ์คํธ, ์ํ์ค ์๋ฃํ์ผ๋ก ์ฌ๋ฌ ๋ฐ์ดํฐ๋ค์ ์งํฉ(๋ค์ํ ๋ฐ์ดํฐ ํ์ ์ ํฌํจ - int, float, string ๋ฑ)
- ์ธ๋ฑ์ฑ(Indexing): ๋ฆฌ์คํธ์์ ๊ฐ๋ค์ ์ฃผ์(Offset)์ ๊ฐ์ง -> ์ฃผ์๋ฅผ ์ฌ์ฉํด ํ ๋น ๊ฐ์ ํธ์ถํ ์ ์์
- ์ฌ๋ผ์ด์ฑ(Slicing): ๋ฆฌ์คํธ์ ๊ฐ์ ์๋ผ์ ์ฌ์ฉํ๋ ๊ฒ. ์ฃผ์ ๊ฐ์ ๊ธฐ๋ฐ์ผ๋ก ๋ถ๋ถ๊ฐ์ ๋ฐํ [start : end : stop]
- ์ฐ์ฐ: append, extend, insert, remove, del ๋ฑ์ ์ฌ์ฉํ์ฌ ์ฐ์ฐ์ ํ ์ ์์.
- ๋ฉ๋ชจ๋ฆฌ ์ ์ฅ ๋ฐฉ์: ํด๋น ๋ฆฌ์คํธ ๋ณ์์๋ ๋ฆฌ์คํธ ์ฃผ์ ๊ฐ์ด ์ ์ฅ๋จ(ex. a= [1, 2, 3] - a์๋ [...]์ ์ฃผ์ ๊ฐ์ด ์ ์ฅ)
**๋ณต์ฌ์ ์ฃผ์๋ฅผ ๋ณต์ฌํ์ง ์๊ณ ๊ฐ๋ค์ ๋ณต์ฌํ์ง ์๊ธฐ ์ํด์ ์ฌ๋ผ์ด์ฑ([:])์ด๋ deepcopy ์ฌ์ฉ
- ํจํน: ํ ๋ณ์์ ์ฌ๋ฌ ๊ฐ์ ๋ฐ์ดํฐ ๋ฃ์ t = [1, 2, 3]
- ์ธํจํน: ํ ๋ณ์์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ๊ฐ์ ๋ณ์๋ก ๋ฐํ a, b, c = t
- ์ด์ฐจ์ ๋ฆฌ์คํธ: ๋ฆฌ์คํธ ์์ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์ด ํ๋ ฌ(matrix) ์์ฑ
** ๋ณต์ฌ์ 1์ฐจ์ ๋ฆฌ์คํธ์ ๋ค๋ฅด๊ฒ deepcopy๋ง ์ฌ์ฉํด์ผ ๊ฐ๋ฅํจ
๐ ํจ์(Function)์ ์ฝ์(Console) I/O
๐ฅ ํจ์(Function): ์ด๋ค ์ผ์ ์ํํ๋ ์ฝ๋์ ๋ฉ์ด๋ฆฌ
๋ฐ๋ณต์ ์ธ ์ํ์ 1ํ๋ง ์์ฑ ํ ํธ์ถ
์ฝ๋๋ฅผ ๋ ผ๋ฆฌ์ ์ธ ๋จ์๋ก ํธ์ถ
์บก์ํ: ์ฌ์ฉ์๊ฐ ์ธํฐํ์ด์ค๋ง ์๋ฉด ํ์ธ์ ์ฝ๋ ์ฌ์ฉ
- ์ ์ธ๋ฐฉ๋ฒ: ์ด๋ฆ, parameter, indentation, return value(optional)
def ํจ์์ด๋ฆ(parameter(s)):
์ํ๋ฌธ(๋ค)(statement(s))
return ๋ฐํ๊ฐ
** parameter: ํจ์์ ์ ๋ ฅ ๊ฐ ์ธํฐํ์ด์ค / argument: ์ค์ parameter์ ๋์ ๋ ๊ฐ
** ๋๋ถ๋ถ parameter๋ก ํต์ผํด์ ๋ถ๋ฅธ๋ค๊ณ ํ๋ค.
- ์ํ์์: ํจ์๋ฅผ ์ ์ธํ ๋ฉ์ธํ๋ก๊ทธ๋จ๋ถํฐ ์์, ํจ์ ํธ์ถ์ ํจ์ ๋ถ๋ถ์ผ๋ก ๊ฐ์ ์ํ ํ ๋์์ด
- ํจ์ํํ: parameter ์ ๋ฌด์ ๋ฐํ๊ฐ(return)์ ๋ฐ๋ผ ํจ์์ ํํ๊ฐ ๋ค๋ฆ
Parameter X |
Parameter O |
|
Return X |
ํจ์ ๋ด์ ์ํ๋ฌธ๋ง ์ํ |
parameter ์ฌ์ฉํด ์ํ๋ฌธ ์ํ |
Return O |
parameter์์ด ์ํ๋ฌธ ์ํ ํ ๊ฒฐ๊ณผ๊ฐ ๋ฐํ |
parameter๋ฅผ ์ฌ์ฉํด ์ํ๋ฌธ ์ํ ํ ๊ฒฐ๊ณผ๊ฐ ๋ฐํ |
๐ฅ ์ฝ์(Console) I/O
- Input: input()ํจ์๋ ์ฝ์์ฐฝ์์ ๋ฌธ์์ด์ ์ ๋ ฅ๋ฐ๋ ํจ์(input("question") ํ์์ด๋ก ์ฌ์ฉ ๊ฐ๋ฅ)
- Output: print()ํจ์๋ ์ฝ์์ฐฝ์ ์ถ๋ ฅํ๋ ํจ์, ์ฝค๋ง(,)์ฌ์ฉ์ ๋์ด์ฐ๊ธฐ๋ก ์ฐ๊ฒฐ
- formatting: print()๋ ๊ธฐ๋ณธ์ ์ธ ์ถ๋ ฅ ์ธ์ ์ถ๋ ฅ ์์(ํ์)์ ์ง์ ํด ์ค ์ ์์
1) % - print(%d %s %f %(1, 'one', 1.0)): %d(10์ง์), %f(์ค์) %s(๋ฌธ์์ด) ๋ฑ
2) format() - print("... {} {} ...".format('one', 'two')
3) fstring - Python 3.6๋ฒ์ ์ดํ PEP498์ ๊ทผ๊ฑฐํ formatting ๊ธฐ๋ฒ. name = 'abc' print(f' ..., {name}')
๐ ์กฐ๊ฑด๋ฌธ(Conditionals)๊ณผ ๋ฐ๋ณต๋ฌธ(Loops)
๐ฅ ์กฐ๊ฑด๋ฌธ: ์กฐ๊ฑด์ ๋ฐ๋ผ ํน์ ๋์ํ๋ ๋ช ๋ น์ด(ex. ํด๋ํฐ ํจํด์ด 5ํ ํ๋ฆฌ๋ฉด 20์ด ๋๊ธฐ)
์กฐ๊ฑด์ ๋ํ๋ด๋ ๊ธฐ์ค๊ณผ ์คํํด์ผ ํ ๋ช ๋ น์ผ๋ก ๊ตฌ์ฑ. if, else, elif ์ฌ์ฉ
if ์กฐ๊ฑด:
์ํ๋ช ๋ น
elif ์กฐ๊ฑด:
์ํ๋ช ๋ น
else:
์ํ๋ช ๋ น
- ํ๋จ ๋ฐฉ๋ฒ: ๋น๊ต ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด ์ฐธ๊ณผ ๊ฑฐ์ง์ ํ๋จ
๐ฅ ๋ฐ๋ณต๋ฌธ: ์ ํด์ง ๋์์ ๋ฐ๋ณตํ๋ ๋ช ๋ น๋ฌธ(ex. 100๋ช ์ ํ์์ ํ๊ท ์ ๊ตฌํ๊ธฐ)
๋ฐ๋ณต ์์ ์กฐ๊ฑด, ์ข ๋ฃ ์กฐ๊ฑด, ์ํ๋ช ๋ น์ผ๋ก ๊ตฌ์ฑ(for, while๋ฌธ)
break(์ค๊ฐ์ ๋ฐ๋ณต๋ฌธ ํ์ถ), continue(๋ค์์ผ๋ก ๋์ด๊ฐ), else(๋ฐ๋ณต๋ฌธ ๋ฐ๋ณต ํ ์คํ)
๐ฅ ๋๋ฒ๊น : ์ฝ๋์ ์ค๋ฅ๋ฅผ ๋ฐ๊ฒฌํ์ฌ ์์ ํ๋ ๊ณผ์ , ์ค๋ฅ์ ์์ธ์ ์๊ณ ํด๊ฒฐ์ฑ ์ ์ฐพ์์ผํจ
- ๋ฌธ๋ฒ์ ์ค๋ฅ: ์๋ฌ ๋ฉ์ธ์ง ๋ถ์
- ๋ ผ๋ฆฌ์ ์ค๋ฅ: ํ ์คํธ๋ฅผ ํตํ ํด๊ฒฐ(print๋ฌธ ์ฐ์ด๋ณด๊ธฐ ๋ฑ)
๐ ๋ฌธ์์ด(String)๊ณผ ํจ์ ๋ ๋์๊ฐ๊ธฐ(Advanced function concept)
๐ฅ ๋ฌธ์์ด: ์ํ์ค ์๋ฃํ์ผ๋ก ๋ฌธ์ํ data๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅ. ์๋ฌธ์ ํ๋๋ 1byte์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ฌ์ฉ
- ํน์ง: ๋ฆฌ์คํธ์ ๋น์ท(์ธ๋ฑ์ค๋ฅผ ๊ฐ์ง๊ณ ์ฌ๋ผ์ด์ฑ์ด ๊ฐ๋ฅ)
upper(), lower() count(), find()๋ฑ์ ํจ์๊ฐ ์กด์ฌ
๋์ค ์ด์ ์ ์ฅ์ ์๋ฐ์ดํ(")๋ ๋ฐ์ดํ(')๋ฅผ 3๊ฐ ๋ถ์ด๊ฑฐ๋ \n์ผ๋ก ์ฌ๋ฌ ์ค ์ ๋ ฅ ๊ฐ๋ฅ
raw string - ๋ฌธ์์ด์ ๋ง๋ค๋ r์ ์ฌ์ฉํ๋ฉด \n, \t๋ฑ์ ๊ทธ๋๋ก ์ ์ฅํ ์ ์์
๐ฅ ํจ์
- Call by value: ๊ฐ๋ง ๋๊ธฐ๋ ํ๋ผ๋ฏธํฐ ์ ๋ฌ ๋ฐฉ์, ํธ์ถ์์ ์ํฅ X
- Call by reference: ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๋๊ธฐ๋ ํ๋ผ๋ฏธํฐ ์ ๋ฌ ๋ฐฉ์, ํธ์ถ์์ ์ํฅ O
- Call by object reference: ๊ฐ์ฒด ์ฃผ์๊ฐ ํจ์๋ก ์ ๋ฌ, ํธ์ถ์์๊ฒ๋ ์ฐธ์กฐ ๋ณ๊ฒฝ์ ์ํฅ O, ์๋ก์ด ๊ฐ์ฒด์ ๊ฒฝ์ฐ ์ํฅ X
- ๋ณ์ ๋ฒ์(Scoping rule)
1) ์ง์ญ ๋ณ์: ํจ์ ๋ด์์๋ง ์ฌ์ฉ๊ฐ๋ฅ(Local variable)
2) ์ ์ญ ๋ณ์: ํ๋ก๊ทธ๋จ ์ ์ฒด์์ ์ฌ์ฉ๊ฐ๋ฅ(Global variable), ํจ์ ๋ด์์ ์ฌ์ฉ์ global ํค์๋ ์ฌ์ฉ
- ์ฌ๊ท ํจ์(Recursive function): ์๊ธฐ ์์ ์ ํธ์ถํ๋ ํจ์, ์ ํ์๊ณผ ๊ฐ์ ์ฌ๊ท์ ์ํ ๋ชจํ์ ํํ
- Function Type Hints: Python์ ๋ค์ด๋๋ฏน ํ์ดํ(Dynamic Typing)์ง์ -> ์ฒ์ ํจ์๋ฅผ ์ฌ์ฉํ๋ ์ฌ๋์ interface ํ์ ์ด ์ด๋ ค์ -> ํ์ด์ฌ 3.5๋ฒ์ ์ดํ์๋ type hints๋ฅผ ์ ๊ณต
def do_func(var_name: var_type) -> return type: => def exam(name: str) -> str:
- Docstring: ํจ์์ ๋ํ ์์ธ ์คํ์ ์ฌ์ ์ ์์ฑํ์ฌ ์ฌ์ฉ์์ ์ดํด๋์ ๋์์ ์ค. ํจ์๋ช ์๋ ๋ฐ์ดํ 3๊ฐ๋ก ์์ญ์ ํ์
- ์์ฑ ๊ฐ์ด๋: ๊ฐ๋ฅํ๋ฉด ์งง๊ฒ
ํจ์ ์ด๋ฆ์ ํจ์ ์ญํ , ์๋๊ฐ ๋ช ํํ ๋ค์ด๋ผ ๊ฒ
ํ๋์ ํจ์์๋ ์ ์ฌํ ์ญํ ์ ํ๋ ์ฝ๋๋ง ์ ์ ๊ฒ
์ธ์๋ก ๋ฐ์ ๊ฐ ์์ฒด๋ฅผ ๋ฐ๊พธ์ง ๋ง ๊ฒ(์์ ๋ณ์ ์ ์ธ)
- ์ธ์ ๋ง๋๋๊ฐ?: ๊ณตํต ์ฝ๋๊ฐ ์๊ธฐ๊ฑฐ๋ ๋ณต์กํ ์์, ์กฐ๊ฑด์ด ์์ ๋ ์ฌ์ฉ์๊ฐ ์ดํดํ๊ธฐ ์ฝ๊ฒํ๊ธฐ ์ํด ์์ฑ
๐if __name__ == '__main__'
-> ๋จผ์ , __name__์ด๋ผ๋ ๋ณ์๋ ํ์ฌ ๋ชจ๋์ ์ด๋ฆ์ ๋ด๊ณ ์๋ ํ์ด์ฌ ๋ด์ฅ ๋ณ์์ด๋ค. ํด๋น ๋ณ์๋ ์ฌ์ฉ์๊ฐ ์คํ์ํจ ๋ชจ๋์ __main__์ด๋ผ๋ ๊ฐ์ ๊ฐ์ง๊ณ import๋๋ ๋ชจ๋์๋ ํ์ผ๋ช ์ด ์ ์ฅ๋๋ค. ๋ฐ๋ผ์ ํด๋น ์กฐ๊ฑด๋ฌธ์ ๋ฃ์ด์ฃผ๋ฉด ์ฌ์ฉ์๊ฐ ์ง์ ์คํ์์ผฐ์๋ ์คํ์ํค๊ณ ์ถ์ ์ฝ๋๋ฅผ ๋ฃ์ด ๋ ์ ์๋ ๊ณต๊ฐ์ด๋ค.
'์ธ๊ณต์ง๋ฅ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Day 6] Math for AI - 1. numpy (0) | 2021.01.25 |
---|---|
[Day 5] Python (2) | 2021.01.22 |
[Day 4] Python (0) | 2021.01.21 |
[Day 3] Python (0) | 2021.01.20 |
[Day 1] Python (0) | 2021.01.18 |