๐ ํ์: ๊น์ธ์ธ ๋ฐ์คํ ๋ฐ์งํธ ์์ ์ธ ์ธ์ํ
์์ฑ์ : ๊น์ธ์ธ
์์ฑ์ผ : 240401
๋ฒ์ : ํด๋์ค
05-1 ํด๋์ค
1. ํด๋์ค์ ๊ฐ์ฒด
๊ฐ์ฒด ์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ์ํด ํ์ํ ๊ฐ๋ !
ํด๋์ค๋ ๊ฐ์ฒด๋ฅผ ์ฐ์ด๋ด๋ ํ๋ก, ํ๋ง๋ค ๊ณ ์ ํ ํน์ฑ๋ค์ ๊ฐ์ง๊ณ ์๋ค.
์ด ํ๋ก ์ฐ์ด๋ธ ๊ฐ์ฒด๋ ๊ฐ์ฒด๋ง๋ค ๊ณ ์ ํ ํน์ฑ์ ๊ฐ์ง๊ณ , ๊ฐ์ฒด๋ผ๋ฆฌ๋ ์ํฅ์ ์ฃผ์ง ์๋๋ค.
๊ฐ์ฒด๋ง๋ค ๊ณ ์ ํ ํน์ฑ์ ๊ฐ์ง!
๊ธฐ๋ณธ์ ์ผ๋ก ๊ณต์ ํ๋ ๋ด์ฉ์ ๋์ผ.
2. ํ์ด์ฌ ํด๋์ค ๊ธฐ๋ณธ ์ฌ์ฉ๋ฒ
1) ํด๋์ค์ ๋ฉ์๋ ๋ง๋ค๊ธฐ
class ํด๋์ค๋ช :
[์ฝ๋]
์ด ํด๋์ค๋ก ์์ฑ๋ ๊ฐ์ฒด๋ [์ฝ๋]์ ๋ด์ฉ์ ์คํํ๋ค.
.
class ํด๋์ค๋ช :
def ๋ฉ์๋๋ช (self, ...):
[๋ฉ์๋ ์ฝ๋]
ํด๋์ค ์์ ๊ตฌํ๋ ํจ์๋ ๋ค๋ฅธ ๋ง๋ก ๋ฉ์๋(method)๋ผ๊ณ ๋ถ๋ฅธ๋ค.
์ด ํด๋์ค๋ ์ฌ๋ฌ๊ฐ์ง ๊ฐ์ ๋ฐ์ [๋ฉ์๋ ์ฝ๋]์ ๊ธฐ๋ฅ์ ์คํํ๋ค.
๊ดํธ ์์๋ ๋งค๊ฐ๋ณ์๋ก ํญ์ self๋ฅผ ํฌํจํ๋๋ฐ, ์ด๋ ์๊ธฐ ์์ , ๊ทธ๋ฌ๋๊น ๊ฐ์ฒด๋ฅผ ์๋ฏธํ๋ค.
์ด ๋ฉ์๋๋ ์ด ํ์ ๋ด๊ฐ ๋ฃ๊ณ ์ถ์ ๊ธฐ๋ฅ์ ์๋งํผ ์ฌ๋ฌ๊ฐ ์ถ๊ฐํ ์ ์๋ค.
2) ๋ฉ์๋์ ํ ์ข ๋ฅ์ธ ์์ฑ์ ์ดํดํ๊ธฐ
์์ฑ์(constructor)๋ ๊ฐ์ฒด๊ฐ ์์ฑ๋ ๋ ์๋์ผ๋ก ํธ์ถ๋๋ ๋ฉ์๋๋ฅผ ์๋ฏธํ๋ค.
ํ์ด์ฌ ๋ฉ์๋๋ช ์ผ๋ก __init__๋ฅผ ์ฌ์ฉํ๋ฉด ์ด ๋ฉ์๋๋ ์์ฑ์๊ฐ ๋๋ค.
๋ฉ์๋ ์ด๋ฆ์ __init__๋ก ํ๊ธฐ ๋๋ฌธ์ ์์ฑ์๋ก ์ธ์๋์ด ๊ฐ์ฒด๊ฐ ์์ฑ๋๋ ์์ ์ ์๋์ผ๋ก ํธ์ถ๋๋ค๋ ์ฐจ์ด๊ฐ ์๋ค.
class ํด๋์ค๋ช :
def __init__(self, ...):
[๋ฉ์๋ ์ฝ๋]
3) ์์์ ๊ฐ๋ ์ดํดํ๊ธฐ
์ด๋ค ํด๋์ค๋ฅผ ๋ง๋ค ๋ ๋ค๋ฅธ ํด๋์ค์ ๊ธฐ๋ฅ์ ๋ฌผ๋ ค๋ฐ์ ์ ์๊ฒ ๋ง๋๋ ๊ฒ์ด ์์์ด๋ค. ๋ณดํต ์์์ ๊ธฐ์กด ํด๋์ค๋ฅผ ๋ณ๊ฒฝํ์ง ์๊ณ ๊ธฐ๋ฅ์ ์ถ๊ฐํ๊ฑฐ๋ ๊ธฐ์กด ๊ธฐ๋ฅ์ ๋ณ๊ฒฝํ๋ ค๊ณ ํ ๋ ์ฌ์ฉํ๋ค.
class ํด๋์ค๋ช (์์ํ ํด๋์ค ์ด๋ฆ)
4) ํด๋์ค ๋ณ์์ ๊ฐ๋ ์ดํดํ๊ธฐ
ํด๋์ค๋ณ์๋ ํด๋์ค ์์ ํจ์๋ฅผ ์ ์ธํ๋ ๊ฒ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ํด๋์ค ์์ ๋ณ์๋ฅผ ์ ์ธํ์ฌ ์์ฑํ๋ค.
class ํด๋์ค๋ช :
ํด๋์ค ๋ณ์๋ช = ๊ฐ
print(ํด๋์ค.ํด๋์ค ๋ณ์)
>> ๊ฐ
+ ํด๋์ค ๋ณ์ / ๊ฐ์ฒด ๋ณ์ ์ดํดํ
(1) ์ธ์คํด์ค ๋ณ์(Instance variable)
- ํด๋์ค์์ ์ ์๋ ๋ณ์๋ก ์ด๋ฅผ ์ํด ๊ฐ๊ฐ ์ธ์คํด์คํ๋ ํด๋์ค์ ๊ฐ์ฒด๋ค์ ๊ฐ๋ณ์ ์ธ ์ ์ฅ ๊ณต๊ฐ
- ๊ฐ ์ธ์คํด์ค๋ง๋ค ๋ค๋ฅธ ๊ฐ์ ์ ์ฅ
(2) ํด๋์ค ๋ณ์(Class variable)
- ๋์ผํ ํด๋์ค์ ๋ชจ๋ ์ธ์คํด์ค๋ค์ด ๊ณต์ ํ๋ ๋ณ์ (๋ชจ๋ ์ธ์คํด์ค๊ฐ ๊ณตํต๋ ๊ฐ์ ๊ณต์ )
๋ฐ๋ผ์, ์์ฑ๋ ๊ฐ ๊ฐ์ฒด(์ธ์คํด์ค)๋ค์ด ๊ณตํต์ ์ธ ๊ฐ์ ๊ฐ์ ธ์ผ ํ ๋ ํด๋์ค ๋ณ์๋ฅผ ์ ์ธ
- ์ธ์คํด์ค ์์ฑ ์์ด, "ํด๋์ค๋ช .ํด๋์ค ๋ณ์๋ช "์ผ๋ก ์ ๊ทผ ๊ฐ๋ฅํ๋ค.
5) ๊ฐ์ฒด ๋ง๋ค๊ธฐ / ์์
.
์์ฑ์ : ๋ฐ์คํ
์์ฑ์ผ : 24/04/01
์ง๋ : [5-2, 3]
[5-2 ๋ชจ๋]
๋ชจ๋์ด๋?
๋ชจ๋์ด๋, ์ฐ๋ฆฌ๊ฐ ๋ง๋๋ ๊ฐ๊ฐ์ '.py' ํ์ผ์ ์๋ฏธํ๋ค.
๋ชจ๋์ ๋ถ๋ฌ์ด์ผ๋ก์จ ์ฐ๋ฆฌ๋ ๊ฐ ํ์ผ ์์ ๋ค์ด์๋ ํจ์๋ ํด๋์ค, ๋ณ์ ๋ฑ์ ์ฌํ์ฉํ ์ ์๋ค !
์ด๋ฅผ ํตํด ์ฐ๋ฆฌ๋ ๋ ํ์ฑํ๊ฒ ์ฝ๋๋ฅผ ์งค ์ ์๊ณ , ํ๋ ฅํด์ ํ๋ก๊ทธ๋๋ฐ์ ํ๋ ๊ฒ๋ ๊ฐ๋ฅํ๋ค.
๊ทธ๋ ๋ค๋ฉด ์ด๋ป๊ฒ ๋ชจ๋์ ์ ์ฅํ๊ณ , ๋ชจ๋์ ๋ถ๋ฌ์ฌ ์ ์์๊น?
๋ชจ๋ ๋ถ๋ฌ์ค๊ธฐ ์ธํ ๊ณผ์
๋ชจ๋์ ๋ถ๋ฌ์ค๊ธฐ ์ํด, ์ฐ์ ์ฐ๋ฆฌ๋ ๊ฐ๋จํ ๋ชจ๋์ ๋ง๋ค์ด ๋ณผ ๊ฒ์ด๋ค.
๊ฐ๋จํ addํจ์์ subํจ์๋ฅผ ๋ง๋ค์ด๋ณด์.
์ฃผ์ ! : ์ด๋ ํ์ผ์ IDLE์๋ํฐ๋ฅผ ํตํด .py๋ก ์ ์ฅํ ๊ฒ์ด๋ค. ๊ตฌ๊ธ ์ฝ๋ฉ์ ์ด์ฉํ .ipnynbํ์ผ์ ๋ชจ๋์ด ๋ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. (ํ์ง๋ง ์ด๋ฏธ ๋ง๋ค์ด์ง .py๋ชจ๋์ ์ฝ๋ฉ์ผ๋ก ๋ถ๋ฌ์ฌ ์ ์๋ค.)
IDLE์๋ํฐ๋ฅผ ํค๊ณ ํจ์๋ฅผ ์ ์ํด์ฃผ์.
#mod1
def add(a, b):
return a + b
def sub(a, b):
return a - b
์ด๋ฅผ ๋ด๊ฐ ๋ง๋ค์ด ๋์ ๊ฒฝ๋ก์ธ C:\PythonStudy(C๋๋ผ์ด๋ธ ์์ ์๋ PythonStudy ํด๋) ์ mod1.py๋ก ์ ์ฅํด์ฃผ์.
์ด์ ๋ชจ๋์ ๋ถ๋ฌ์ค๊ธฐ ์ํด, ์ปดํจํฐ ๋ด์ ๋ด์ฅ๋์ด ์๋ ๋ช ๋ น ํ๋กฌํํธ ์ฐฝ์ ์ด์ด์ฃผ์.
๊ทธ๋ฆฌ๊ณ , ์ฐ๋ฆฌ๊ฐ ์์ ๋ง๋ ๋ชจ๋์ ์ ์ฅํ ํ์ผ๋ก ์ด๋ํด์ค ํ
python๋ช ๋ น์ด๋ฅผ ์ณ์ ๋ช ๋ นํ ํ๋กฌํํธ ๋ด์์ python์ ์คํํด์ฃผ์.
์ ๊ณผ์ ์ ๋ชจ๋ ๊ฑฐ์ณค๋ค๋ฉด, ๋ชจ๋์ ๋ถ๋ฌ์ฌ ํ์ผ ๋ด์์ python์ ์คํํ ํ๊ฒฝ์ด ๋ง๋ค์ด์ง๋ค.
๋ชจ๋ ๋ถ๋ฌ์ค๊ธฐ
์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ๋ชจ๋์ ๋ถ๋ฌ์๋ณด์.
๊ทธ ์ ์ ์ฐ๋ฆฌ๋ import๋ผ๋ ๋ช ๋ น์ด์ ๋ํด์ ์์๋ณด์์ผ ํ๋ค.
import : ํ์ฌ ๋๋ ํ ๋ฆฌ์ ์๋ ํ์ผ์ด๋, ํ์ด์ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ(๋ด์ฅํ)์ ์ ์ฅ๋ ๋ชจ๋์ ๋ถ๋ฌ์ฌ ์ ์๋ ๋ช ๋ น์ด
์ฐ๋ฆฌ๋ ์์ ๊ณผ์ ์์ ๋ฏธ๋ฆฌ ๋ถ๋ฌ์ฌ ๋ชจ๋์ด ์๋ ๋๋ ํ ๋ฆฌ์ ์ ์ํ ์ํ์ด๊ธฐ์ import๋ฅผ ํตํด ๋ชจ๋์ ๋ถ๋ฌ์ฌ ์ ์๋ค!
>>> import mod1
>>> print(mod1.add(5, 9))
14
import๋ ๋ชจ๋ ๊ทธ ์์ฒด๋ฅผ ๋ถ๋ฌ์จ๋ค.
๋ฐ๋ผ์ ์ฐ๋ฆฌ๋ ๋ฏธ๋ฆฌ ์ ์ฅํ mod1๋ชจ๋ ๋ด์ ์๋ ์ฐ๋ฆฌ๊ฐ ์ ์ํ addํจ์๋ฅผ ์ฌ์ฉํ ์ ์๊ฒ ๋์๋ค.
์ด๋ mod1.add()์ฒ๋ผ mod1.๋ฅผ ๋ถ์ด๋ ๊ฒ์ด ๋ฒ๊ฑฐ๋กญ๋ค๋ฉด, ์ด๋ฒ์๋ mod1 ๋ชจ๋ ๋ด์ ์๋ addํจ์ ์์ฒด๋ฅผ ๋ถ๋ฌ์๋ณด์.
>>> from mod1 import add, sub
>>> print(add(3, 5))
8
>>> print(sub(5, 3))
2
import๋ฅผ ํตํด ํจ์ ์์ฒด๋ฅผ ๋ถ๋ฌ์จ๋ค๋ฉด, ๋ฒ๊ฑฐ๋กญ๊ฒ mod1.์ ๋ถ์ฌ์ฃผ์ง ์์๋ ๋๋ค.
๋ชจ๋์ ํตํด ํด๋์ค๋ ๋ณ์ ๋ถ๋ฌ์ค๊ธฐ
์์ ๋ฐฐ์ด ๋ชจ๋์ ํตํด, ์ฐ๋ฆฌ๋ ํจ์ ๋ฟ ์๋๋ผ ํด๋์ค์ ๋ณ์ ๋ํ ๋ถ๋ฌ์ฌ ์ ์๋ค.
#mod2
PI = 3.141592
class Math:
def solv(self, r):
return 2 * PI * r
def add(a, b):
return a + b
์๋ ๋ฐ์ง๋ฆ(r)์ด ์ฃผ์ด์ก์ ๋, ์์ ์์ฃผ๋ฅผ ๊ตฌํ๋ ํด๋์ค์ด๋ค. ์ด๋ฅผ mod2 ๋ผ๋ ์ด๋ฆ์ผ๋ก C:\PythonStudy ์ ์ ์ฅํด์ฃผ์.
์์ ๋๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก ํด๋์ค๋ฅผ ๋ถ๋ฌ์์ฃผ์!
>>> import mod2
>>> a = mod2.Math()
>>> print(a.solv(3))
18.849552000000003
r = 3์ผ๋ ์์ฃผ๋ฅผ ์์ฃผ ํธ๋ฆฌํ๊ฒ ๊ตฌํ ์ ์๋ค.
๋ค๋ฅธ ๋๋ ํ ๋ฆฌ์ ์๋ ๋ชจ๋ ๋ถ๋ฌ์ค๊ธฐ
์ง๊ธ๊น์ง๋ ๋ชจ๋ ๊ฐ์ ๋๋ ํ ๋ฆฌ์ ์๋ ๋ชจ๋์ ๋ถ๋ฌ์ ๋ณด์๋ค. ํ์ง๋ง, ๋ค๋ฅธ ๋๋ ํ ๋ฆฌ์ ์๋ ํ์ผ์ ๋ถ๋ฌ์ค๊ณ ์ถ์ ๋๋ ์ด๋ป๊ฒ ํด์ผํ ๊น?
์ฐ๋ฆฌ๋ PYTHONPATH ํ๊ฒฝ ๋ณ์๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
๋ค์ ์์๋ฅผ ์ดํด๋ณด์.
์ฐ์ PythonStudy ๋๋ ํ ๋ฆฌ ์์ etcํด๋๋ฅผ ํ๋ ๋ง๋ค์ด ์ค ํ
์ ์ ๋ง๋ mod1 ํ์ผ์ etcํด๋๋ก ์ฎ๊ฒจ์ค๋ค.
๊ทธ ํ ๋ช ๋ น ํ๋กฌํฌํธ์์
๋ค์๊ณผ ๊ฐ์ด ์คํํด์ค๋ค.
์ด์ ๋ค๋ฅธ ๋๋ ํ ๋ฆฌ์ ์๋ ํ์ผ๋ ์คํ ๊ฐ๋ฅํ๋ค!
๋ชจ๋์ด๋ผ๋ ์์คํ ์ ํ์ฉํ๋ฉด, ํจ์ฌ ๋ค์ฑ๋ก์ด ์ฝ๋ฉ์ด ๊ฐ๋ฅํ ๊ฒ ๊ฐ๋ค. ํ์ง๋ง ์ฐ๋ฆฌ๊ฐ ์์ฃผ ์ฐ๋ ๊ตฌ๊ธ ์ฝ๋ฉ์ ํตํด์๋ ์ ์ฉ์ด ์ด๋ ค์์ ๊ตฌ๊ธ ์ฝ๋ฉ์์ ipnyb์ ํตํด์ ๋ชจ๋์ ๋ก๋ํ๋ ๋ฐฉ๋ฒ์ ๋ ์์๋ณด์์ผ๊ฒ ๋ค.
[5-3 ํจํค์ง]
ํจํค์ง๋?
ํจํค์ง๋ ๋๋ ํ ๋ฆฌ์ ๊ฐ๊ฐ์ ๋ชจ๋๋ก ์ด๋ฃจ์ด์ง ํ๋์ ๋จ์์ด๋ค.
์ฆ ์ฌ๋ฌ ๊ฐ์ ๋ชจ๋๋ค์ด ๋๋ ํ ๋ฆฌ๋ผ๋ ์ง์์ ๋ฐ๋ผ ์ ๋ ฌ๋ ๊ฒ์ด ํจํค์ง์ด๋ค.
ํจํค์ง๋ฅผ ์ง์ ๋ง๋ค์ด๋ณด์
์ ์ ๋ชจ๋๋ ๋ง๋ ํ์ผ ๋ง๊ณ C๋๋ผ์ด๋ธ์ ์๋ก์ด ํ์ผ์ ๋ง๋ค์ด๋ณด์.
C:\game
\game\__init__.py
\game\character
\game\character\__init__.py
\game\item
\game\item\ __init__.py
\game\map
\game\map\ __init__.py
๊ผด๋ก ํ์ผ์ ๋ง๋ค์ด์ฃผ์.
(์ด๋ __init__.py๋ ์ผ๋จ ๋น์๋๊ณ ์์ฑํ์)
์ด๋ ๊ฒ ๋ง๋ ๊ฐ๊ฐ์ ํ์ผ์ด ํจํค์ง์ ์ง์์ธ '๋๋ ํ ๋ฆฌ'์ด๋ค.
์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ํจํค์ง์์ ๋ชจ๋์ ๋ง๋ค์ด๋ณด์.
ํจํค์ง ์ ์ฉํ๊ธฐ
๋ฏธ๋ฆฌ ๋ง๋ค์ด๋ character๋๋ ํ ๋ฆฌ ์์ ์๋ก์ด ๋ชจ๋์ ๋ง๋ค์ด๋ณด์.
#model.py
def model_test():
print('model')
์์ ๊ฐ์ ์ฝ๋๋ฅผ model.py๋ผ๋ ์ด๋ฆ์ผ๋ก character๋๋ ํ ๋ฆฌ์ ์ ์ฅํด์ฃผ์.
์ด์ ์์ฑ๋ ๋ชจ๋์ ๋ถ๋ฌ์๋ณด์.
๊ทธ ์ ์ ๊ฐ๊ฐ์ ๋๋ ํ ๋ฆฌ์ ์๋ ๋ชจ๋๋ค์ ์์ ๋กญ๊ฒ ์ฐธ์กฐํ๊ธฐ ์ํด PYTHONPATH ํ๊ฒฝ ๋ณ์๋ฅผ ์ถ๊ฐํด์ฃผ์.
C:\> set PYTHONPATH=C:/game
C:\> python
>>>
์ด์ ๊ฐ ๋๋ ํ ๋ฆฌ์ ์๋ ๋ชจ๋๋ค์ importํ์.
>>> import game.character.model
>>> print(game.character.model.model_test())
model
์์ ๋ฐฐ์ด ๋ฐฉ๋ฒ์ผ๋ก ํจ์ ์์ฒด๋ฅผ ๋ถ๋ฌ์ฌ ์๋ ์๋ค.
>>> from game.character.model import model_test
>>> print(model_test())
model
relative ํจํค์ง
์ด์ item๋๋ ํ ๋ฆฌ์ food.py๋ฅผ ๋ง๋ค์ด๋ณด์.
#food.py
def food_test():
print('food')
์ด๋ food.py์์์ ์์์ ์ฐ๋ฆฌ๊ฐ ๋ง๋ ๋ค๋ฅธ ๋๋ ํ ๋ฆฌ์ ์กด์ฌํ๋ model ๋ชจ๋์ ๋ถ๋ฌ์ค๊ณ ์ถ๋ค๋ฉด, ์ฐ๋ฆฌ๋ ๊ฐ๋จํ๊ฒ ๋ถ๋ฌ์ฌ ์ ์์ ๊ฒ์ด๋ค.
>>> from game.character import model
>>> print(model.model_test())
model
์ด๋ ์์ ๊ฐ์ด importํ๋ ๊ฒ๋ ๊ฐ๋ฅํ์ง๋ง, relativeํ๊ฒ importํ ์๋ ์๋ค !
>>> from ..character import model
>>> print(model.model_test())
model
์ด๋ ..์ ๋ถ๋ชจ ๋๋ ํฐ๋ฆฌ๋ฅผ ์๋ฏธํ๊ณ , .์ ํ์ฌ ๋๋ ํ ๋ฆฌ๋ฅผ ์๋ฏธํ๋ค.
(food.py ์ ํ์ฌ ๋๋ ํ ๋ฆฌ๋ item์ด๊ณ , ๋ถ๋ชจ ๋๋ ํ ๋ฆฌ๋ game์ด๋ค.)
ํ์ด์ฌ์ ๊ธฐ์ด๋ ์๋ฃํ์ด๊ณ , ์ ๋๋ก ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค๊ธฐ ์ํด์ ์์์ผํ๋๊ฒ์ ํจ์๋ผ๊ณ ์๊ฐํ๋ค.
ํ์ง๋ง ๋ง ๊ทธ๋๋ก ํ์ด์ฌ์ ๋ ํจ์จ์ ์ผ๋ก ๋ง๋ค๊ธฐ ์ํด์๋ ํด๋์ค์ ๋ชจ๋์๋ํ ์ดํด๊ฐ ํ์์ ์ด๋ผ๊ณ ์๊ฐํ๋ค.
ํด๋์ค, ํจํค์ง, ๋ชจ๋๋ ๊ณต๋ถ๋ฅผ ์ํํ ํ๋ฉด ์๋ ๊ฒ ๊ฐ๋ค.
- ์์ฑ์ : ์ธ์ํ
- ์ง๋ : 05 - 5 ๋ด์ฅ ํจ์
์ง๊ธ๊น์ง import๋ฅผ ํตํด ๋ช ๋ น์ด๋ฅผ ์ฌ์ฉํ๋ ํ์ด์ฌ ๋ชจ๋์ ๋ฐฐ์ ๋ค. ์ด๋ฒ ๋จ์์์๋ import๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ๋ ํ์ด์ฌ์์ ์ฌ์ฉํ ์ ์๋ ๋ด์ฅ ํจ์๋ฅผ ์์๋ณด๊ณ ์ ํ๋ค. ๋ด์ฅ ํจ์๋ ์ ๋ง ๋ง์ ์ข ๋ฅ๊ฐ ์๋ค. ์ฌ๊ธฐ์๋ ์ค์ํ ํจ์ ์์ฃผ๋ก ์๊ฐํด๋ณด๊ณ ์ ํ๋ค.
abs(x)
abs(x)๋ ์ด๋ค ์ซ์๋ฅผ ์ ๋ ฅ๋ฐ์์ ๋ ๊ทธ ์ซ์์ ์ ๋๊ฐ์ ๋ฆฌํดํ๋ ํจ์์ด๋ค.
>>> abs(3)
3
>>> abs(-3)
3
>>> abs(-1.7)
1.7
all(x)
all(x)๋ ๋ฐ๋ณต ๊ฐ๋ฅํ ๋ฐ์ดํฐ x๋ฅผ ์ ๋ ฅ๊ฐ์ผ๋ก ๋ฐ์ผ๋ฉฐ ์ด x์ ์์๊ฐ ๋ชจ๋ ์ฐธ์ด๋ฉด True, ๊ฑฐ์ง์ด ํ๋๋ผ๋ ์์ผ๋ฉด False๋ฅผ ๋ฆฌํดํ๋ค.
โ ์๋ฃํ์ ์ฐธ๊ณผ ๊ฑฐ์ง์ ์ ๋จ์์์ ๋ค๋ฃฌ ๋ฐ ์๋ค.
>>> all([1, 2, 3])
True
>>> all([1, 2, 3, 0])
False
divmod
divmod๋ ์ซ์ ๋๊ฐ๋ฅผ ์ ๋ ฅ๋ฐ์ ๋ชซ๊ณผ ๋๋จธ์ง๋ฅผ ๋ฐํํ๋ ํจ์์ด๋ค.
(๋ชซ, ๋๋จธ์ง) ํํ๋ก ๋ฐํ๋๋ค.
>>> divmod(8, 3)
(2, 2)
enumerate
enumerate๋ '์ด๊ฑฐํ๋ค' ๋ผ๋ ๋ป์ผ๋ก ๋ฆฌ์คํธ ๋ฑ์ ์์๊ฐ ์๋ ์๋ฃํ์ ์ธ๋ฑ์ค์ ํจ๊ป ๋ฐํํ๋ค.
>>> for i, name in enumerate(['a', 'b', 'c']):
... print(i, name)
...
0 a
1 b
2 c
id
id๋ ๊ฐ์ฒด๋ฅผ ์ ๋ ฅ๋ฐ์ ๊ฐ์ฒด์ ๋ ํผ๋ฐ์ค๋ฅผ ๋ฆฌํดํ๋ ํจ์์ด๋ค.
>>> a = 3
>>> id(3)
135072304
>>> id(a)
135072304
>>> b = a
>>> id(b)
135072304
int
int๋ ๋ค๋ฅธ ์๋ฃํ์ ์ ์ํ์ผ๋ก ๋ฐํํด์ฃผ๋ ํจ์์ด๋ค.
>>> int('3')
3
>>> int(3.4)
3
len
length์ ์ค์๋ง๋ก ์ ๋ ฅ๊ฐ์ ๊ธธ์ด๋ฅผ ์ธ์ด ๋ฐํํ๋ ํจ์์ด๋ค.
>>> len("python")
6
>>> len([1,2,3])
3
>>> len((1, 'a'))
2
list
๋ค๋ฅธ ํํ์ ์๋ฃํ์ ๋ฆฌ์คํธ ํํ์ ์๋ฃํ์ผ๋ก ๋ง๋ค์ด์ฃผ๋ ํจ์์ด๋ค.
>>> list("python")
['p', 'y', 't', 'h', 'o', 'n']
>>> list((1,2,3))
[1, 2, 3]
map
map(f, iterable)์ ํจ์(f)์ ๋ฐ๋ณต ๊ฐ๋ฅํ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ๋๋ค. map์ ์ ๋ ฅ๋ฐ์ ๋ฐ์ดํฐ์ ๊ฐ ์์์ ํจ์ f๋ฅผ ์ ์ฉํ ๊ฒฐ๊ณผ๋ฅผ ๋ฆฌํดํ๋ ํจ์์ด๋ค.
>>> def two_times(x):
... return x*2
...
>>> list(map(two_times, [1, 2, 3, 4]))
[2, 4, 6, 8]
๋ ๋ฐฐ๋ฅผ ํด์ฃผ๋ ํจ์๋ฅผ ์ ์ํ๊ณ , ์ด๋ฅผ map ํจ์๋ฅผ ํตํด ๋ฆฌ์คํธ์ ๊ฐ ๋ด์ฉ์ ์ ์ฉ์ํจ ๊ฒฐ๊ณผ์ด๋ค.
open
open(filename, [mode])์ ‘ํ์ผ ์ด๋ฆ’๊ณผ ‘์ฝ๊ธฐ ๋ฐฉ๋ฒ’์ ์ ๋ ฅ๋ฐ์ ํ์ผ ๊ฐ์ฒด๋ฅผ ๋ฆฌํดํ๋ ํจ์์ด๋ค. ์ฝ๊ธฐ ๋ฐฉ๋ฒ(mode)์ ์๋ตํ๋ฉด ๊ธฐ๋ณธ๊ฐ์ธ ์ฝ๊ธฐ ๋ชจ๋(r)๋ก ํ์ผ ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด ๋ฆฌํดํ๋ค.
>>> f = open("test_file", "r")
r์ ์ฝ๊ธฐ ๋ชจ๋, w๋ ์ฐ๊ธฐ ๋ชจ๋, a๋ ์ถ๊ฐ ๋ชจ๋, b๋ ๋ฐ์ด๋๋ฆฌ ๋ชจ๋์ด๋ค.
pow
pow(x, y)๋ x๋ฅผ y์ ๊ณฑํ ๊ฒฐ๊ด๊ฐ์ ๋ฆฌํดํ๋ ํจ์์ด๋ค.
>>> pow(2, 5)
32
>>> pow(3, 2)
9
sorted
sorted(iterable)๋ ์ ๋ ฅ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ ํ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ฆฌ์คํธ๋ก ๋ฆฌํดํ๋ ํจ์์ด๋ค.
>>> sorted([3, 1, 2])
[1, 2, 3]
>>> sorted(['a', 'c', 'b'])
['a', 'b', 'c']
>>> sorted("zero")
['e', 'o', 'r', 'z']
>>> sorted((3, 2, 1))
[1, 2, 3]
str
str์ ๋ค๋ฅธ ์๋ฃํ์ ๋ฌธ์์ด๋ก ๋ฐ๊พธ์ด์ฃผ๋ ํจ์์ด๋ค.
>>> str(3)
'3'
>>> str('hi')
'hi'
sum
sum์ ์ ๋ ฅ๊ฐ์ ํฉ์ ๋ฐํํด์ฃผ๋ ํจ์์ด๋ค.
>>> sum([1,2,3])
6
>>> sum((4,5,6))
15
type
type๋ ์ ๋ ฅ๊ฐ์ ์๋ฃํ์ ๋ฐํํด์ฃผ๋ ํจ์์ด๋ค.
>>> type("BDA")
<class 'str'>
>>> type([ ])
<class 'list'>
zip
zip์ ๊ฐ์ ์๋ก ์ด๋ฃจ์ด์ง๋ ๋ฐ์ดํฐ๋ฅผ ๋ฌถ์ด์ ๋ฐํํด์ฃผ๋ ํจ์์ด๋ค.
>>> list(zip([1, 2, 3], [4, 5, 6]))
[(1, 4), (2, 5), (3, 6)]
>>> list(zip([1, 2, 3], [4, 5, 6], [7, 8, 9]))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>> list(zip("123", "456"))
[('1', '4'), ('2', '5'), ('3', '6')]
์์ฑ์: ์์ ์ธ
์์ฑ์ผ: 24/04/01
<05-4. ์์ธ ์ฒ๋ฆฌ>
์ค๋ฅ๋ ์ธ์ ๋ฐ์ํ๋๊ฐ?
-> ์๋ ํ์ผ์ ์ด๋ ค๊ณ ์๋ํ ๋
-> ์ด๋ค ์ซ์๋ฅผ 0์ผ๋ก ๋๋ ๋
-> ๋ฆฌ์คํธ์ ์กด์ฌํ๋ ๊ฐ์ ๊ฐ์๋ณด๋ค ํฐ ๊ฐฏ์์ ์์๊ฐ์ ๊ฐ๋ฆฌํฌ ๋
์ค๋ฅ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ
1. try-except๋ฌธ
try ๋ธ๋ก ์ํ ์ค ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ฉด except ๋ธ๋ก์ด ์ํ๋๋ค. ํ์ง๋ง try ๋ธ๋ก์์ ์ค๋ฅ๊ฐ ๋ฐ์ํ์ง ์๋๋ค๋ฉด except ๋ธ๋ก์ ์ํ๋์ง ์๋๋ค.
2. try-finally๋ฌธ
3. try-else ๋ฌธ
์ค๋ฅ ํํผํ๊ธฐ
-> ์ค๋ฅ๋ pass ๋ฅผ ์ฌ์ฉํ์ฌ ํํผํ ์ ์๋ค
์ค๋ฅ ์ผ๋ถ๋ฌ ๋ฐ์์ํค๊ธฐ
-> ํ์ด์ฌ์ raise ๋ช ๋ น์ด๋ฅผ ์ฌ์ฉํด ์ค๋ฅ๋ฅผ ๊ฐ์ ๋ก ๋ฐ์์ํฌ ์ ์๋ค.
cf. NotImplementedError๋ ํ์ด์ฌ์ ์ด๋ฏธ ์ ์๋์ด ์๋ ์ค๋ฅ๋ก, ๊ผญ ์์ฑํด์ผ ํ๋ ๋ถ๋ถ์ด ๊ตฌํ๋์ง ์์์ ๊ฒฝ์ฐ ์ผ๋ถ๋ฌ ์ค๋ฅ๋ฅผ ๋ฐ์์ํค๊ธฐ ์ํด ์ฌ์ฉํ๋ค.
์์ธ ๋ง๋ค๊ธฐ
-> ์์ธ๋ ํ์ด์ฌ ๋ด์ฅ ํด๋์ค์ธ Exception ํด๋์ค๋ฅผ ์์ํ์ฌ ๋ง๋ค ์ ์๋ค.
์์ฑ์: ๋ฐ์งํธ
์์ฑ์ผ: 24/04/01
์ง๋: 05-6 ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ
[05-6 ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ]
ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ?
์ ์ธ๊ณ์ ํ์ด์ฌ ์ด์ฉ์๋ค์ด ๋ง๋ ํ๋ก๊ทธ๋จ์ ๋ชจ์๋์ ๊ฒ
datetime.date
datetime.date ํจ์๋ ๋ ์ง ํํ๊ณผ ๊ด๋ จ๋ ํจ์์ด๋ค.
1. ๋ ๋ ์ง์ ์ฐจ์ด ๊ณ์ฐํ๊ธฐ
>>> import datetime
>>> day1 = datetime.date(2023, 5, 9)
>>> day2 = datetime.date(2024, 4, 1)
>>> diff = day2 - day1
>>> diff.days
328
๋ง์ฝ 23๋ 5์ 9์ผ์ ๊ธฐ์ค์ผ๋ก ๋ฉฐ์น ์ด ์ง๋ฌ๋์ง๋ฅผ ์์๋ณด๊ณ ์ถ๋ค๋ฉด datetime.date ํจ์๋ฅผ ํตํด ๋ ๋ ์ง์ ์ฐจ์ด๋ฅผ ๊ณ์ฐํ ์ ์๋ค.
์ ์์์์๋ day1์ 2023๋ 5์ 9์ผ์ ํ ๋นํ๊ณ , ์ค๋ ๋ ์ง๋ฅผ day2์ ํ ๋นํ ํ
๋ ๋ ์ง์ ์ฐจ์ด๋ฅผ diff ๋ณ์์ ๋์ ํด ๊ณ์ฐํ ๊ฒ์ด๋ค.
2. ์์ผ ์์๋ด๊ธฐ
>>> day1.weekday()
>>> 1
๊ทธ๋ ๋ค๋ฉด ์ด๋ฒ์๋ 23๋ 5์ 9์ผ์ ์์ผ์ ํ ๋ฒ ์์๋ด๋ณด์.
์์ ๊ฐ์ด weekday ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ์ํ๋ ๋ ์ง์ ์์ผ์ ์์๋ผ ์ ์๋ค.
์ด๋ 0๋ถํฐ 6๊น์ง ์์๋๋ก ์์์ผ, ํ์์ผ, ... ์ด ๋๋ค.
* ๋ง์ฝ, 1๋ถํฐ ์์ผ์ ์ธ๊ณ ์ถ๋ค๋ฉด isoweekday ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค.
time
time ๋ชจ๋์๋ ์๊ฐ๊ณผ ๊ด๋ จ๋ ํจ์๋ค์ด ๋ชจ์ฌ์๋ค.
1. time.time
: ํ์ฌ ์๊ฐ์ UTC(ํ์ ์ธ๊ณ ํ์ค์)๋ฅผ ์ฌ์ฉํด ์ค์ ํํ๋ก ๋ฆฌํด
(1970๋ 1์ 1์ผ 0์ 0๋ถ 0์ด๋ฅผ ๊ธฐ์ค์ผ๋ก ์ง๋ ์๊ฐ์ ์ด ๋จ์๋ก ์๋ ค์ค)
>>> import time
>>> time.time()
1711971649.872514
2. time.localtime
: ์์ time.time ํจ์๊ฐ ๋ฆฌํดํ ๊ฐ์ ์ฐ, ์, ์ผ, ์, ๋ถ, ์ด ๋ฑ์ ํํ๋ก ๋ฐ๊ฟ์ค
>>> time.localtime(time.time())
time.struct_time(tm_year=2024, tm_mon=4, tm_mday=1,
tm_hour=20, tm_min=43, tm_sec=41, tm_wday=0, tm_yday=92, tm_isdst=0)
3. time.asctime
: ์์ time.localtime์ ํํ ๊ฐ์ ํ์ฉํด ๋ ์ง์ ์๊ฐ์ ์ข ๋ ์๊ธฐ ์ฝ๊ฒ ๋ฐ๊ฟ์ค
>>> time.asctime(time.localtime(time.time()))
'Mon Apr 1 20:46:40 2024'
4. time.ctime
: time.asctime(time.localtime(time.time())) = time.ctime
๊ทธ๋ฌ๋ ctime์ ํญ์ ํ์ฌ ์๊ฐ๋ง์ ๋ฆฌํดํจ
>>> time.ctime()
'Mon Apr 1 20:49:26 2024'
5. time.strftime
: ์๊ฐ๊ณผ ๊ด๊ณ๋ ์ฌ๋ฌ ํฌ๋งท ์ฝ๋ ์ ๊ณต
%a: ์์ผ์ ์ค์๋ง
%A: ์์ผ
%b: ๋ฌ์ ์ค์๋ง
%B: ๋ฌ
%c: ๋ ์ง์ ์๊ฐ
%d: ์ผ
%H: ์๊ฐ(24์๊ฐ ํํ)
%I: ์๊ฐ (12์๊ฐ ํํ)
%j: 1๋ ์ค ๋์ ๋ ์ง
%m: ๋ฌ(์ซ์๋ก)
%M: ๋ถ
%p: AM/PM
%S: ์ด
%U: 1๋ ์ค ๋์ ์ฃผ(์ผ์์ผ ์์)
%w: ์ซ์๋ก ๋ ์์ผ(0๋ถํฐ ์ผ)
%W: 1๋ ์ค ๋์ ์ฃผ(์์์ผ ์์)
%x: ํ์ฌ ์ค์ ์ง์ญ์ ๋ ์ง
%X: ํ์ฌ ์ค์ ์ง์ญ์ ์๊ฐ
%Y: ์ฐ๋
%Z: ์๊ฐ๋
%%: ๋ฌธ์ %
%y: ์ธ๊ธฐ ์ ์ธ ์ฐ๋
์์ ํฌ๋งท ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ์ด ์ฌ์ฉํ ์ ์๋ค.
time.strftime('์ํ๋ ํฌ๋งท ์ฝ๋', time.localtime(time.time()))
6. time.sleep
: ์ผ์ ํ ์๊ฐ ๊ฐ๊ฒฉ์ ๋๊ณ ๋ฃจํ๋ฅผ ์คํํ ๋ ์ฌ์ฉ
for i in range(10):
print(i)
time.sleep(5)
0
1
2
3
4
5
6
7
8
9
์ ์์์์๋ 1๋ถํฐ 9๊น์ง์ ์ซ์๊ฐ 5์ด ๊ฐ๊ฒฉ์ผ๋ก ์ถ๋ ฅ๋๋ค.
* time.sleep ํจ์์ ์ธ์๋ ์ค์ ํํ ์ฌ์ฉ ๊ฐ๋ฅ
๐ time ํจ์๋ฅผ ()์ ๊ฐ์ด ์ ๋ ฅ ์ธ์ ์์ด ์ฌ์ฉํ ๊ฒฝ์ฐ, ํ์ฌ ์๊ฐ์ ๊ธฐ์ค์ผ๋ก ํจ์๊ฐ ์ํ๋จ
math
math ๋ชจ๋์๋ ์ต๋ ๊ณต์ฝ์์ ์ต์ ๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ๋ ํจ์๊ฐ ๋ค์ด์๋ค.
1. math.gcd
: ์ต๋ ๊ณต์ฝ์ ๊ตฌํ๊ธฐ
>>> import math
>>> math.gcd(77, 55)
11
์์ ๊ฐ์ด ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด 77๊ณผ 55์ ์ต๋ ๊ณต์ฝ์๋ฅผ ๊ตฌํ ์ ์๋ค.
2. math.lcm
: ์ต์ ๊ณต๋ฐฐ์ ๊ตฌํ๊ธฐ
>>> math.lcm(77, 55)
385
์์ ๊ฐ์ ํจ์๋ฅผ ํตํด ๋์ ์ต์ ๊ณต๋ฐฐ์๋ ๊ตฌํ ์ ์๋ค.
random
random ๋ชจ๋์ ๋๋คํ ์๋ฅผ ๋ฐ์์ํค๋ ํจ์๋ฅผ ํฌํจํ๊ณ ์๋ค.
1. random.random
: 0.0์์ 1.0 ์ฌ์ด์ ์ค์ ์ค ๋๋ค ๊ฐ ๋ฆฌํด
>>> import random
>>> random.random()
0.7950837231675663
2. random.randint
: ์ ํด์ค ๋ฒ์ ๋ด์ ์ ์ ์ค ๋๋ค ๊ฐ ๋ฆฌํด
>>> random.randint(1, 50)
25
itertools
1. itertools.zip_longest
: zip ํจ์์ ๋์ผํ ๋ฐฉ์์ผ๋ก ๋์
๊ทธ๋ฌ๋ itertools.zip_longest ํจ์๋ ๋ฐ๋ณต ๊ฐ๋ฅ ๊ฐ์ฒด์ ๊ธธ์ด๊ฐ ์๋ก ๋ค๋ฅผ ๊ฒฝ์ฐ, ๊ธด ๊ฐ์ฒด์ ๊ธธ์ด์ ๋ง์ถฐ fillvalue์ ์ค์ ํ ๊ฐ์ ์งง์ ๊ฐ์ฒด์ ๋น ๊ณต๊ฐ์ ์ฑ์ด๋ค.
>>> import itertools
>>> teammember = ['๋ฐ์งํธ', '์์ ์ธ', '๊น์ธ์ธ', '๋ฐ์คํ', '์ธ์ํ']
>>> snacks = ['์์ฐ๊นก', '๊ผฌ๊น์ฝ', '๋ง์ด๊ตฌ๋ฏธ']
>>> result = itertools.zip_longest(teammember, snacks, fillvalue = 'ํ ๋ ํ')
>>> print(list(result))
[('๋ฐ์งํธ', '์์ฐ๊นก'), ('์์ ์ธ', '๊ผฌ๊น์ฝ'), ('๊น์ธ์ธ', '๋ง์ด๊ตฌ๋ฏธ'), ('๋ฐ์คํ', 'ํ ๋ ํ'), ('์ธ์ํ', 'ํ ๋ ํ')]
์์ ์์์์๋ ํ ๊ตฌ์ฑ์์ ์๊ฐ ๊ฐ์์ ์๋ณด๋ค ๋ง์ผ๋ฏ๋ก
fillvalue๋ก ์ง์ ๋ 'ํ ๋ ํ'๋ก ๊ฐ์์ ๋น ๋ถ๋ถ์ ์ฑ์ด ๊ฒ์ ํ์ธํ ์ ์๋ค.
2. itertools.permutation
: ๋ฐ๋ณต ๊ฐ๋ฅ ๊ฐ์ฒด ์ค r๊ฐ๋ฅผ ์ ํํ '์์ด'์ ๋ฆฌํด
3. itertools.combination
: ๋ฐ๋ณต ๊ฐ๋ฅ ๊ฐ์ฒด ์ค r๊ฐ๋ฅผ ์ ํํ '์กฐํฉ'์ ๋ฆฌํด
functools.reduce
functools.reduce ํจ์๋ ํจ์๋ฅผ ๋ฐ๋ณต ๊ฐ๋ฅ ๊ฐ์ฒด ์์์ ์ฐจ๋ก๋๋ก ๋์ ์ ์ฉํ ์ ์๋๋ก ํ๋ค.
>>> import functools
>>> data = [5, 7, 10, 12, 24]
>>> result = functools.reduce(lambda x, y: x + y, data)
>>> print(result)
58
์์ ๊ฐ์ด functools.reduce ํจ์๋ฅผ ์ ์ฉํ๋ฉด add ํจ์์์ ์์๋ค์ ๋์ ํฉ์ ๊ตฌํ๋ ๊ฒ๊ณผ ๋์ผํ ๊ฒฐ๊ณผ๋ฅผ ๋์ถํ ์ ์๋ค.
operator.itemgetter
operator.itemgetter ๋ชจ๋์ ๋ค์ํ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ ์ ์๋๋ก ๋์์ฃผ๋ ๋ชจ๋์ด๋ค.
sorted ํจ์์ key ๋งค๊ฐ๋ณ์์ itemgetter()๋ฅผ ์ ์ฉํ๋ฉด ๋๋ค.
>>> from operator import itemgetter
>>> celebrity = [
('์กฐ์ ์', 43, 'M'),
('pH-1', 34, 'M'),
('๊ณต์ ', 44, 'M'),
('๊ณ ์ค์ ', 27, 'F'),
]
>>> result = sorted(celebrity, key = itemgetter(1))
>>> print(result)
[('๊ณ ์ค์ ', 27, 'F'), ('pH-1', 34, 'M'), ('์กฐ์ ์', 43, 'M'), ('๊ณต์ ', 44, 'M')]
์ ์์๋ operator.itemgetter ๋ชจ๋์ ํ์ฉํด
celebrity = [ ('์กฐ์ ์', 43, 'M'), ('pH-1', 34, 'M'), ('๊ณต์ ', 44, 'M'), ('๊ณ ์ค์ ', 27, 'F'), ]
์ ๊ฐ์ ๋ฆฌ์คํธ๋ฅผ ๋์ด์์ผ๋ก ์ ๋ ฌํ ๊ฒ์ด๋ค.
์ด๋ itemgetter()์ ๊ดํธ ์ ์ซ์๋ 0์ผ ๊ฒฝ์ฐ ์ฒซ ๋ฒ์งธ ์์, 1์ผ ๊ฒฝ์ฐ ๋ ๋ฒ์งธ ์์, 2์ผ ๊ฒฝ์ฐ ์ธ ๋ฒ์งธ ์์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ๊ฒ ๋ค๋ ์๋ฏธ์ด๋ค.
๋ฐ๋ผ์ ์ด๋๋ 1๋ก ๋ ๋ฒ์งธ ์์์ธ ๋์ด๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ ๊ฒ์ด๋ค.
* ์ ๋ ฌํ๊ณ ์ ํ๋ ๋ฐ์ดํฐ๊ฐ ๋์ ๋๋ฆฌ์ผ ๊ฒฝ์ฐ, temgetter()์ ๊ดํธ ์์ ๋์ ๋๋ฆฌ์ ํค๋ฅผ ์ ๋ ฅํ๋ฉด ๋๋ค.
shutil
shutil์ ํ์ผ์ ๋ณต์ฌํ๊ฑฐ๋ ์ด๋ํ ๋ ์ฌ์ฉํ๋ ๋ชจ๋์ด๋ค.
ํ์ผ์ ๋ณต์ฌํ๊ธฐ ์ํด์๋ shutil.copy ํจ์๋ฅผ,
์ด๋์ ์ํด์๋ shutil.move ํจ์๋ฅผ ํ์ฉํ๋ฉด ๋๋ค.
glob
glob ๋ชจ๋์ ํน์ ๋๋ ํฐ๋ฆฌ ์์ ํ์ผ๋ค์ ์ฝ์ด์ ๋ฆฌํดํ๋ค.
*๋ ? ๋ฑ์ ๋ฉํ ๋ฌธ์๋ฅผ ์จ์ ์ํ๋ ํ์ผ๋ง ์ฝ์ด ๋ค์ผ ์๋ ์๋ค.
?์ 1์๋ฆฌ ๋ฌธ์์ด, *์ ์์์ ๊ธธ์ด์ ๋ฌธ์์ด์ ์๋ฏธํ๋ค.
pickle
pickle ๋ชจ๋์ ๊ฐ์ฒด์ ํํ๋ฅผ ๊ทธ๋๋ก ์ ์งํ๋ฉด์ ํ์ผ์ ์ ์ฅํ๊ณ ๋ถ๋ฌ์ฌ ์ ์๊ฒ ํ๋ค.
1. pickle.dump
: ๊ฐ์ฒด๋ฅผ ํ์ผ์ ์ ์ฅ
2. pickle.load
: ์ ์ฅํ ๊ฐ์ฒด ๋ถ๋ฌ์ค๊ธฐ
* ์ด๋ค ์๋ฃํ์ด๋ ๊ฐ๋ฅ !
os
os ๋ชจ๋์ os ์์์ ์ ์ดํ ์ ์๊ฒ ํด์ค๋ค.
1. os.environ
: ํ์ฌ ์์คํ ์ ํ๊ฒฝ ๋ณ์ซ๊ฐ ๋ฆฌํด
(๋์ ๋๋ฆฌ ํํ๋ก ๊ตฌ์ฑ๋ environ ๊ฐ์ฒด๋ก ๋ฆฌํด)
2. ds.chdir
: ํ์ฌ ๋๋ ํฐ๋ฆฌ์ ์์น๋ฅผ ๋ณ๊ฒฝ
3. os.getcwd
: ํ์ฌ ์์ ์ ๋๋ ํฐ๋ฆฌ ์์น ๋ฆฌํด
zipfile
zipfile ๋ชจ๋์ ์ฌ๋ฌ ๊ฐ์ ํ์ผ์ zip ํ์์ผ๋ก ํฉ์น๊ฑฐ๋ ํด์ ํ ๋ ์ฌ์ฉํ๋ค.
1. write()
: zipfile์ ๊ฐ๋ณ ํ์ผ์ ์ถ๊ฐ
2. extreactall()
: zipfile ์ ๋ชจ๋ ํ์ผ์ ํด์
3. compression, compresslevel
: ํ์ผ์ ์์ถํ์ฌ ๋ฌถ๊ธฐ
* compression์ 4๊ฐ์ง ์ข ๋ฅ: ZIP_STORED, ZIP_DEFLATED, ZIP_BZIP2, ZIP_LZMA
* compresslevel์ ์์ถ ์์ค์ ๋ํ๋ด๋ ๊ฐ์ผ๋ก, 1~9๋ก ๋ํ๋ธ๋ค. ์ด๋ 1์ ์๋๊ฐ ๊ฐ์ฅ ๋น ๋ฅด์ง๋ง ์์ถ๋ฅ ์ด ๋ฎ๊ณ , ๋ฐ๋๋ก 9๋ ์๋๋ ๊ฐ์ฅ ๋๋ฆฌ์ง๋ง ์์ถ๋ฅ ์ด ๋๋ค.
tempfile
tempfile ๋ชจ๋์ ํ์ผ์ ์์๋ก ๋ง๋ค์ด์ ์ฌ์ฉํ ์ ์๋๋ก ํ๋ค.
1. tempfile.mkstemp()
: ์ค๋ณต๋์ง ์๋ ์์ ํ์ผ์ ์ด๋ฆ์ ๋ฌด์์๋ก ๋ง๋ค์ด์ ๋ฆฌํด
2. tempfile.TemporaryFile()
: ์์ ์ ์ฅ ๊ณต๊ฐ์ผ๋ก ์ฌ์ฉํ ํ์ผ ๊ฐ์ฒด๋ฅผ ๋ฆฌํด
f.close()๊ฐ ํธ์ถ๋๋ฉด ํ์ผ ์๋ ์ญ์
traceback
traceback ๋ชจ๋์ ํ๋ก๊ทธ๋จ ์คํ ์ค ๋ฐ์ํ ์ค๋ฅ๋ฅผ ์ถ์ ํ ๋ ์ฌ์ฉํ๋ค.
์ด๋ ์ค๋ฅ๊ฐ ๋ฐ์ํ ์์น์ print(traceback.format_exc()) ๋ฌธ์ฅ์ ์ถ๊ฐํ๋ฉด ์ค๋ฅ ์ถ์ ๊ฒฐ๊ณผ๋ฅผ ๋ฌธ์์ด๋ก ๋ฆฌํดํ๋ค.
urllib
urllib ๋ชจ๋์ URL์ ์ฝ๊ณ ๋ถ์ํ ๋ ์ฌ์ฉํ๋ค.
webbrowser
webbrowser ๋ชจ๋์ ํ์ด์ฌ ํ๋ก๊ทธ๋จ์ ํตํด ์์คํ ๋ธ๋ผ์ฐ์ ๋ฅผ ํธ์ถํ ๋ ์ฌ์ฉํ๋ค.
์น ํ์ด์ง๋ฅผ ์ ์ฐฝ์ผ๋ก ์ด๊ธฐ ์ํด์๋ webbrowser.open_new() ํจ์๋ฅผ ํ์ฉํ๋ฉด ๋๋ค.
* ์ด๋ฏธ ์ด๋ฆฐ ๋ธ๋ผ์ฐ์ ๋ก ์น ํ์ด์ง๋ฅผ ์ด๊ธฐ ์ํด์๋ open_new() ๋์ open()์ ์ฌ์ฉํ๋ฉด ๋๋ค.
์์ฑ์: ์์ ์ธ
์์ฑ์ผ: 24/04/01
<5-7. ์ธ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ>
pip
-> pip์ ํ์ด์ฌ ๋ชจ๋์ด๋ ํจํค์ง๋ฅผ ์ฝ๊ฒ ์ค์นํ ์ ์๋๋ก ๋์์ฃผ๋ ๋๊ตฌ์ด๋ค. pip์ผ๋ก ํ์ด์ฌ ํ๋ก๊ทธ๋จ์ ์ค์นํ๋ฉด ์์กด์ฑ ์๋ ๋ชจ๋์ด๋ ํจํค์ง๋ฅผ ํจ๊ป ์ค์นํด ์ฃผ๊ธฐ ๋๋ฌธ์ ๋งค์ฐ ํธ๋ฆฌํ๋ค.
pip install
-> PyPI๋ ํ์ด์ฌ ์ํํธ์จ์ด๊ฐ ๋ชจ์ธ ์ ์ฅ ๊ณต๊ฐ์ด๋ค. ํ์ฌ ์ด๊ณณ์๋ 10๋ง๊ฑด ์ด์์ ํ์ด์ฌ ํจํค์ง๊ฐ ๋ฑ๋ก๋์ด ์์ผ๋ฉฐ ์ด๊ณณ์ ๋ฑ๋ก๋ ํ์ด์ฌ ํจํค์ง๋ ๋๊ตฌ๋ ๋ด๋ ค๋ฐ์ ์ฌ์ฉํ ์ ์๋ค.
-> pip install SomePackage
pip uninstall
-> ์ค์นํ ํจํค์ง๋ฅผ ์ญ์ ํ๊ณ ์ถ๋ค๋ฉด ๋ค์ ๋ช ๋ น์ด๋ก ์ญ์ ํ ์ ์๋ค.
-> pip uninstall SomePackage
ํน์ ๋ฒ์ ์ผ๋ก ์ค์นํ๊ธฐ
-> pip install SomePackage==1.0.4
์ต์ ๋ฒ์ ์ผ๋ก ์ ๊ทธ๋ ์ด๋ํ๊ธฐ
-> pip install --upgrade SomePackage
์ค์น๋ ํจํค์ง ํ์ธํ๊ธฐ
-> pip list
Faker
-> C:๏ผผ pip install Faker
Faker ์ฌ์ฉํด ๋ณด๊ธฐ
-> ํ ์คํธ ๋ฐ์ดํฐ๋ Faker๋ฅผ ์ฌ์ฉํ๋ฉด ๋งค์ฐ ์ฝ๊ฒ ๋ง๋ค ์ ์๋ค.
Faker ํ์ฉํ๊ธฐ
->
sympy
-> sympy๋ ๋ฐฉ์ ์ ๊ธฐํธ(symbol)๋ฅผ ์ฌ์ฉํ๊ฒ ํด ์ฃผ๋ ์ธ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ด๋ค. ๋ง์ฐฌ๊ฐ์ง๋ก pip์ ์ด์ฉํ์ฌ sympy๋ฅผ ์ค์นํ์.
'Study > CODE 3๊ธฐ [Jump to python]' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ ๋น๋น๋น ] Python Study #4 (0) | 2024.04.01 |
---|---|
[๊น์ด๊น์ด๋] python ์คํฐ๋ 4์ฃผ์ฐจ (0) | 2024.03.31 |
[2์กฐ:ACE] Python ์คํฐ๋ #4 (1) | 2024.03.29 |
[5์กฐ C5DE] Python Study #3 (1) | 2024.03.25 |
[๋ถ์ฌ์กฐ] Python study (3) (0) | 2024.03.24 |