5-1 ํด๋์ค
ํด๋์ค๋ ์ ํ์ํ๊ฐ?
๊ณ์ฐ๊ธฐ ํ๋ก๊ทธ๋จ์ ๋ง๋ค๋ฉฐ ํด๋์ค ์์๋ณด๊ธฐ
- ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ฉด ํจ์๋ง ์ฌ์ฉํ ๋๋ณด๋ค ๊ฐ์ฒด๋ฅผ ์์ฑํ์ฌ ๊ฐ๋จํ๊ฒ ํ๋ก๊ทธ๋จ์ ์์ฑํ ์ ์์
class Calculator:
def __init__(self):
self.result = 0
def add(self, num):
self.result +=num
return self.result
cal1 = Calculator()
cal2 = Calculator()
print(cal1.add(3))
print(cal1.add(4))
print(cal2.add(3))
print(cal2.add(7))
ํด๋์ค์ ๊ฐ์ฒด
- ํด๋์ค(class) : ๋๊ฐ์ ๋ฌด์ธ๊ฐ๋ฅผ ๊ณ์ ๋ง๋ค์ด๋ผ ์ ์๋ ์ค๊ณ ๋๋ฉด(๊ณผ์ํ)
- ๊ฐ์ฒด(object) : ํด๋์ค๋ก ๋ง๋ค์ด๋ธ ํผ์กฐ๋ฌผ (๊ณผ์ ํ๋ก ์ฐ์ด๋ธ ๊ณผ์)
- ํด๋์ค๋ก ๋ง๋ ๊ฐ์ฒด๋ ๊ฐ์ฒด๋ง๋ค ๊ณ ์ ํ ์ฑ๊ฒฉ์ ๊ฐ์ง๋ค.
- 1๊ฐ์ ํด๋์ค๋ ๋ฌด์ํ ๋ง์ ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด๋ผ ์ ์๋ค.
class Cookie:
pass
#Cookie()์ ๊ฒฐ๊ณผ๊ฐ์ ๋ฆฌํด๋ฐ์ a,b๊ฐ ๊ฐ์ฒด์
a=Cookie()
b=Cookie()
๊ฐ์ฒด์ ์ธ์คํด์ค์ ์ฐจ์ด
class Cookie:
pass
a=Cookie()
- ์ธ์คํด์ค : ํน์ ๊ฐ์ฒด(a)๊ฐ ์ด๋ค ํด๋์ค(Cookie)์ ๊ฐ์ฒด์ธ์ง ๊ด๊ณ ์์ฃผ๋ก ์ค๋ช ํ ๋ ์ฌ์ฉ
- a๋ ๊ฐ์ฒด์ด๋ค.
- a๋ ์ฟ ํค์ ์ธ์คํด์ค์ด๋ค.
์ฌ์น์ฐ์ฐ ํด๋์ค ๋ง๋ค๊ธฐ
- ๋ฉ์๋ : ํด๋์ค ์์ ๊ตฌํ๋ ํจ์
- self: ์ ๋ฌ๋ ๊ฐ์ฒด (์ฒซ๋ฒ์งธ ๋งค๊ฐ๋ณ์ self์๋ ๋ฉ์๋๋ฅผ ํธ์ถํ ๊ฐ์ฒด๊ฐ ์๋์ผ๋ก ์ ๋ฌ๋จ)
- ํด๋์ค๋ก ๋ง๋ ๊ฐ์ฒด์ ๊ฐ์ฒด๋ณ์๋ ๋ค๋ฅธ ๊ฐ์ฒด์ ๊ฐ์ฒด๋ณ์์๋ ์๊ด์์ด ๋ ๋ฆฝ์ ์ธ ๊ฐ์ ์ ์งํจ
def setdata(self, first, second) :
self.first = first
self.second = second
class FourCal:
def setdata(self, first, second) :
self.first = first
self.second = second
def add(self):
result = self.first + self.second
return result
def sub(self):
result = self.first - self.second
return result
def mul(self):
result = self.first * self.second
return result
def div(self):
result = self.first / self.second
return result
a= FourCal()
a.setdata(4,2)
print(a.add())
print(a.sub())
print(a.mul())
print(a.div())
์์ฑ์
- ๊ฐ์ฒด๊ฐ ์์ฑ๋ ๋ ์๋์ผ๋ก ํธ์ถ๋๋ ๋ฉ์๋
- ๋ฉ์๋๋ช ์ผ๋ก __init__์ ์ฌ์ฉํ๋ฉด ์์ฑ์๊ฐ ๋จ
- ์ฒซ๋ฒ์งธ ๋งค๊ฐ๋ณ์ self์๋ ์์ฑ๋๋ ๊ฐ์ฒด๊ฐ ์๋์ผ๋ก ์ ๋ฌ๋จ
#๋ฉ์๋์ ๋ชจ๋ ๊ฒ ๋์ผํ์ง๋ง, ๋ฉ์๋๋ช
์ __init__์ผ๋ก ํ๋ฉด ์์ฑ์๋ก ์ธ์๋์ด
#๊ฐ์ฒด๊ฐ ์์ฑ๋๋ ์์ ์ ์๋์ผ๋ก ํธ์ถ๋๋ค.
def __init__(self, first, second) :
self.first = first
self.second = second
ํด๋์ค์ ์์
- ์์์ ์ด๋ค ํด๋์ค๋ฅผ ๋ง๋ค ๋ ๋ค๋ฅธ ํด๋์ค์ ๊ธฐ๋ฅ์ ๋ฌผ๋ ค๋ฐ์ ์ ์๊ฒ ๋ง๋๋ ๊ฒ์ด๋ค.
- ๋ณดํต ์์์ ๊ธฐ์กด ํด๋์ค๋ฅผ ๋ณ๊ฒฝํ์ง ์๊ณ 1)๊ธฐ๋ฅ์ ์ถ๊ฐํ๊ฑฐ๋, 2)๊ธฐ์กด ๊ธฐ๋ฅ์ ๋ณ๊ฒฝํ๋ ค๊ณ ํ ๋ ์ฌ์ฉํ๋ค.
- ๊ธฐ์กด ํด๋์ค๊ฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํํ๋ก ์ ๊ณต๋๊ฑฐ๋ ์์ ์ด ํ์ฉ๋์ง ์๋ ์ํฉ์ด๋ผ๋ฉด ์์์ ํด์ผ ํ๋ค.
class ํด๋์ค๋ช
(์์ํ _ํด๋์ค๋ช
)
---
class MoreFourCal(FourCal):
def pow(self):
result = self.first**self.second
return result
a= MoreFourCal(4,2)
print(a.pow()) # 16
print(a.add()) # 6
๋ฉ์๋ ์ค๋ฒ๋ผ์ด๋ฉ
- ๋ถ๋ชจ ํด๋์ค(์์ํ ํด๋์ค)์ ์๋ ๋ฉ์๋์ ๋์ผํ ์ด๋ฆ์ผ๋ก ๋ค์ ๋ง๋๋ ๊ฒ
- ๋ฉ์๋๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํ๋ฉด, ๋ถ๋ชจํด๋์ค์ ๋ฉ์๋ ๋์ ์ค๋ฒ๋ผ์ด๋ฉํ ๋ฉ์๋๊ฐ ํธ์ถ๋๋ค.
class SafeFourCal(FourCal):
def div(self):
if self.second ==0:
return 0
else:
return self.first/self.second
ํด๋์ค ๋ณ์
- ํด๋์ค ์์ ๋ณ์๋ฅผ ์ ์ธํ์ฌ ์์ฑํจ
- ํด๋์ค๋ณ์๋ ํด๋์ค๋ก ๋ง๋ ๋ชจ๋ ๊ฐ์ฒด์ ๊ณต์ ๋จ (๊ฐ์ฒด๋ณ์์ ๋ค๋ฆ)
- ํด๋์ค๋ช .ํด๋์ค๋ณ์๋ช ์ผ๋ก ์ฌ์ฉ ๊ฐ๋ฅํจ
- ํด๋์ค๋ก ๋ง๋ ๊ฐ์ฒด๋ฅผ ์ด์ฉํ์ฌ ์ฌ์ฉ ๊ฐ๋ฅํจ
- ๊ฐ์ฒด ๋ณ์๋ ํด๋์ค ๋ณ์์ ๋์ผํ ์ด๋ฆ์ผ๋ก ๋ฅผ ์์ฑํ ์ ์์ (๋์ผ ์ด๋ฆ์ ๊ฐ์ฒด๋ณ์๋ฅผ ์์ฑํ๋๋ผ๋ ํด๋์ค ๋ณ์์ ์๊ด ์์)
class Family:
lastname = "๊น"
#ํด๋์ค๋ช
.ํด๋์ค๋ณ์๋ช
a=Family.lastname
#๊ฐ์ฒด๋ฅผ ์ด์ฉ
b=Family().lastname
print(a)
print(b)
5-2 ๋ชจ๋
- ํจ์๋ ๋ณ์, ํด๋์ค๋ฅผ ๋ชจ์ ๋์ ํ์ด์ฌ ํ์ผ
- ๋ค๋ฅธ ํ์ด์ฌ ํ๋ก๊ทธ๋จ์์ ๋ถ๋ฌ์ ์ฌ์ฉํ ์ ์๋๋ก ๋ง๋ ํ์ด์ฌ ํ์ผ
- ํ์ด์ฌ ํ์ฅ์ .py๋ก ๋ง๋ ํ์ด์ฌ ํ์ผ๋ค์ ๋ชจ๋ ๋ชจ๋์ด๋ค.
๋ชจ๋ ๋ง๋ค๊ธฐ
- ํ์ด์ฌ ํ์ฅ์ .py๋ก ๋ง๋ ํ์ด์ฌ ํ์ผ๋ค์ ๋ชจ๋ ๋ชจ๋์ด๋ค.
๋ชจ๋ ๋ถ๋ฌ์ค๊ธฐ
- import ๋ช ๋ น์ด : ์ด๋ฏธ ๋ง๋ค์ด ๋์ ํ์ด์ฌ ๋ชจ๋์ ์ฌ์ฉํ ์ ์๊ฒ ํด์ฃผ๋ ๋ช ๋ น์ด (ํ์ด์ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ์ ์ฅ๋ ๋๋ ํ ๋ฆฌ์ ์๋ ๋ชจ๋์ด๋ ํ์ฌ ๋๋ ํ ๋ฆฌ์ ์๋ ํ์ผ๋ง ๋ถ๋ฌ์ฌ ์ ์์)
- import ์ฌ์ฉ : import ๋ชจ๋๋ช
- ๋ชจ๋ ๋ด ํจ์ ์ฌ์ฉ : ๋ชจ๋๋ช .ํจ์๋ช ( )
- ํ์ด์ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ : ํ์ด์ฌ์ ์ค์นํ ๋ ์๋์ผ๋ก ์ค์น๋๋ ํ์ด์ฌ ๋ชจ๋
C:\\python\\0228>python
>>> import mod1
>>> print(mod1.add(3,4))
7
>>> print(mod1.sub(4,2))
2
๋ชจ๋๋ช ์์ด ํจ์ ์ฌ์ฉ
#ํ์ํ ํจ์๋ง ์ํฌํธ
from ๋ชจ๋๋ช
import ํจ์๋ช
, ํจ์๋ช
,,
#๋ชจ๋ ํจ์ ์ํฌํธ
from ๋ชจ๋๋ช
import *
#๋ชจ๋๋ช
์์ด ํจ์ ์ฌ์ฉ
>>> from mod1 import add, sub
>>> add(3,4)
7
if__name__==”main”: ์ ์๋ฏธ
__name__๋ณ์๋?
- ํ์ด์ฌ์ด ๋ด๋ถ์ ์ผ๋ก ์ฌ์ฉํ๋ ํน๋ณํ ๋ณ์ ์ด๋ฆ
- ์ง์ mod1.py๋ฅผ ์คํ : __name__๋ณ์์ __main__๊ฐ ์ ์ฅ๋จ
- ๋ค๋ฅธ ํ์ด์ฌ ๋ชจ๋์์ import ํ๋ ๊ฒฝ์ฐ : __name__๋ณ์์ ๋ชจ๋๋ช ์ธ mod1์ด ์ ์ฅ๋จ
def add(a,b):
return a+b
def sub(a,b):
return a-b
if __name__ == "__main__":
print(add(1,4))
print(sub(4,2))
# ๋ชจ๋ ์ํฌํธ
>>> import mod1 #์ํฌํธ๋ง ํ๋๋ฐ๋ ๊ฐ์ด ์ถ๋ ฅ๋จ
5
2
#์์ ํ ๋ชจ๋ ์ํฌํธ (__name__์ด __main__์ด ์๋)
>>> import mod1
>>>
>>> mod1.__name__
'mod1'
ํด๋์ค๋ ๋ณ์ ๋ฑ์ ํฌํจํ ๋ชจ๋
#๋ณ์
PI = 3.141592
#์์ ๋์ด ๊ณ์ฐํ๋ ํด๋์ค
class Math:
def solv(self,r):
return PI*(r**2)
#ํจ์
def add(a,b):
return a+b
----------------------------------
>>> import mod2
>>> print(mod2.PI)
3.141592
>>> a=mod2.Math()
>>> print(a.solv(2))
12.566368
>>> print(mod2.add(mod2.PI,4.4))
7.5415920000000005
#๋ฐ์ง๋ฆ์ด 5์ธ ์์ ๋์ด ๊ตฌํ๊ธฐ
>>> import mod2
>>> a=mod2.Math().solv(5)
>>> a
78.5398
๋ค๋ฅธ ํ์ผ์์ ๋ชจ๋ ๋ถ๋ฌ์ค๊ธฐ
- ํ์ผ์ด ๋์ผํ ๋๋ ํ ๋ฆฌ ๋ด์ ์์ด์ผ ํจ
import mod2
result = mod2.add(3,4)
print(result)
๋ค๋ฅธ ๋๋ ํฐ๋ฆฌ์ ์๋ ๋ชจ๋์ ๋ถ๋ฌ์ค๋ ๋ฐฉ๋ฒ
sys.path.append ์ฌ์ฉํ๊ธฐ
- sys.path: ํ์ด์ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ์ค์น๋์ด ์๋ ๋๋ ํ ๋ฆฌ ๋ชฉ๋ก์ ๋ณด์ฌ์ค (์ด ๋๋ ํ ๋ฆฌ ์์ ์ ์ฅ๋ ๋ชจ๋์ ์ ์ฅ๋ ๋๋ ํ ๋ฆฌ๋ก ์ด๋ํ ํ์ ์์ด ๋ฐ๋ก ๋ถ๋ฌ ์ฌ์ฉํ ์ ์์)
- sys.path๋ ๋ฆฌ์คํธ์ด๋ฏ๋ก sys.path.append๋ฅผ ์ฌ์ฉํ์ฌ ๋๋ ํ ๋ฆฌ๋ฅผ ์ถ๊ฐ
C:\\python\\0228>mkdir mymod
C:\\python\\0228>move mod2.py mymod
1๊ฐ ํ์ผ์ ์ด๋ํ์ต๋๋ค.
C:\\python\\0228>python
>>> import sys
>>> sys.path
['', 'C:\\\\Users\\\\gyugl\\\\AppData\\\\Local\\\\Programs\\\\Python\\\\Python312\\\\python312.zip',
,,,
'C:\\\\Users\\\\gyugl\\\\AppData\\\\Local\\\\Programs\\\\Python\\\\Python312\\\\Lib\\\\site-packages']
>>> sys.path.append("C:\\\\python\\\\0228\\\\mymod")
>>> sys.path
['', 'C:\\\\Users\\\\gyugl\\\\AppData\\\\Local\\\\Programs\\\\Python\\\\Python312\\\\python312.zip',
,,,
'C:\\\\Users\\\\gyugl\\\\AppData\\\\Local\\\\Programs\\\\Python\\\\Python312\\\\Lib\\\\site-packages',
'C:\\\\python\\\\0228\\\\mymod'] #์ถ๊ฐ๋จ
>>> import mod2
>>> print(mod2.add(3,4))
7
PYTHONPATH ํ๊ฒฝ๋ณ์ ์ฌ์ฉํ๊ธฐ
- set ๋ช ๋ น์ด๋ฅผ ์ฌ์ฉํด PYTHONPATH ํ๊ฒฝ๋ณ์์ mod2.py๊ฐ ์๋ ๋๋ ํ ๋ฆฌ๋ฅผ ์ค์
- ๋๋ ํ ๋ฆฌ ์ด๋์ด๋ ๋ณ๋์ ๋ชจ๋ ์ถ๊ฐ ์์ ์์ด ํด๋น ๋๋ ํ ๋ฆฌ์ mod2๋ชจ๋์ ์ฌ์ฉํ ์ ์์
C:\\python\\0228>set PYTHONPATH=C:\\python\\0228\\mymod
C:\\python\\0228>python
>>> import mod2
>>> print(mod2.add(3,4))
7
5-3 ํจํค์ง
- ๊ด๋ จ ์๋ ๋ชจ๋์ ์งํฉ
- ํ์ด์ฌ ๋ชจ๋์ ๊ณ์ธต์ (๋๋ ํ ๋ฆฌ ๊ตฌ์กฐ)์ผ๋ก ๊ด๋ฆฌํ ์ ์๊ฒ ํด์ค
- ํจํค์ง๋ ๋๋ ํ ๋ฆฌ+ํ์ด์ฌ ๋ชจ๋๋ก ์ด๋ค์ง
#game์ด๋ผ๋ ํจํค์ง์ ๊ตฌ์กฐ
game : ๋ฃจํธ ๋๋ ํ ๋ฆฌ
sound, graphic, play : ์๋ธ๋๋ ํ ๋ฆฌ
.py ํ์ผ๋ค : ๋ชจ๋
game/
__init__.py
sound/
__init__.py
echo.py
graphic/
__init__.py
screen.py
render.py
play/
__init__.py
run.py
test.py
ํจํค์ง ๊ตฌ์กฐ๋ก ํ๋ก๊ทธ๋จ์ ๋ง๋ค๋ฉด
- ๊ณต๋์์ ์ด๋ ์ ์ง๋ณด์ ๋ฉด์์ ์ ๋ฆฌํจ
- ๋ค๋ฅธ ๋ชจ๋๊ณผ ์ด๋ฆ์ด ๊ฒน์น๋๋ผ๋ ๋ ์์ ํ๊ฒ ์ฌ์ฉํ ์ ์์
ํจํค์ง ๋ง๋ค๊ธฐ
ํจํค์ง ์์ ํจ์ ์คํํ๊ธฐ
C:\\Users\\gyugl>cd C:\\python
#ํ๊ฒฝ๋ณ์์ ์ถ๊ฐ
C:\\python>set PYTHONPATH=C:\\python\\game\\sound
echo ๋ชจ๋์ importํ์ฌ ์คํ
C:\\python>python
>>> import game.sound.echo
>>> game.sound.echo.echo_test()
echo
echo ๋ชจ๋์ด ์๋ ๋๋ ํ ๋ฆฌ๊น์ง๋ฅผ from…import ํ์ฌ ์คํ
C:\\python>python
>>> from game.sound import echo
>>> echo.echo_test()
echo
echo ๋ชจ๋์ echo_test ํจ์๋ฅผ ์ง์ importํ์ฌ ์คํ
C:\\python>python
>>> from game.sound.echo import echo_test
>>> echo_test()
echo
๋ค์์ ๋ถ๊ฐ๋ฅ
#game๋๋ ํ ๋ฆฌ์ __init__.py์ ์ ์ํ ๊ฒ๋ง ์ฐธ์กฐํ ์ ์์
>>> import game
>>> game.sound.echo.echo_test()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: module 'game' has no attribute 'sound'
๋ํธ ์ฐ์ฐ์ ์ฌ์ฉํ์ฌ import ์ ๊ฐ์ฅ ๋ง์ง๋ง ํญ๋ชฉ์ ๋ชจ๋ ๋๋ ํจํค์ง์ฌ์ผ ํจ
>>> import game.sound.echo.echo_test
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ModuleNotFoundError: No module named 'game.sound.echo.echo_test'; 'game.sound.echo' is not a package
init.py์ ์ฉ๋
- init.py ํ์ผ์ ํด๋น ๋๋ ํ ๋ฆฌ๊ฐ ํจํค์ง์ ์ผ๋ถ์์ ์๋ ค์ฃผ๋ ์ญํ ์ ํจ
- game, sound, graphic ๋๋ ํ ๋ฆฌ์ init.py ํ์ผ์ด ์๋ค๋ฉด ํจํค์ง๋ก ์ธ์๋์ง ์์
- init.py ํ์ผ์ ํจํค์ง์ ๊ด๋ จ๋ ์ค์ ์ด๋ ์ด๊ธฐํ ์ฝ๋๋ฅผ ํฌํจํ ์ ์์
ํจํค์ง ๋ณ์ ๋ฐ ํจ์ ์ ์
- ํจํค์ง ์์ค์์ ๋ณ์์ ํจ์๋ฅผ ์ ์ํ ์ ์์
VERSION = 3.5
def print_version_info():
print(f "The version of this game is {VERSION}.")
#ํจํค์ง์ __init__.py์ ์ ์๋ ๋ณ์, ํจ์ ์ฌ์ฉ
>>> import game
>>> print(game.VERSION) #๋ณ์ ์ถ๋ ฅ
3.5
>>> game.print_version_info() #ํจ์ ํธ์ถ
The version of this game is 3.5.
ํจํค์ง ๋ด ๋ชจ๋์ ๋ฏธ๋ฆฌ import
- init.py ํ์ผ์ ํจํค์ง ๋ด ๋ค๋ฅธ ๋ชจ๋์ ๋ฏธ๋ฆฌ importํ์ฌ ๊ฐํธํ๊ฒ ์ ๊ทผ ๊ฐ๋ฅ
- ํจํค์ง๋ฅผ importํ ๋ ํด๋น ํจํค์ง์ ํ์ ๋ชจ๋๋ ํจ๊ป ๊ฐ์ ธ์์ง (game ํจํค์ง๋ฅผ importํ๋ฉด graphic ํจํค์ง์ ๊ทธ ์์ render ๋ชจ๋๋ ํจ๊ป import๋์ด ํด๋น ๋ชจ๋์ ํจ์์ ์ ๊ทผํ ์ ์์)
from .graphic.render import render_test
----
>>> import game #game ํจํค์ง๋ฅผ importํ๋ฉด render ๋ชจ๋์ ํจ์์ ๋ฐ๋ก ์ ๊ทผ
>>> game.render_test()
render
ํจํค์ง ์ด๊ธฐํ
- ํจํค์ง๋ฅผ ์ฒ์ ๋ถ๋ฌ์ฌ ๋ ์คํ๋์ด์ผ ํ๋ ์ฝ๋๋ฅผ init.py ํ์ผ์ ์์ฑ
- ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฐ๊ฒฐ์ด๋ ์ค์ ํ์ผ ๋ก๋์ ๊ฐ์ ์์ ์ํ
- ์ด๊ธฐํ ์ฝ๋๋ ํ ๋ฒ ์คํ๋ ํ์๋ ๋ค์ import ํ๋๋ผ๋ ์คํ๋์ง ์์
#ํจํค์ง ์ด๊ธฐํ ์ฝ๋ ์์ฑ
print("Initializing game...")
------------
#ํจํค์ง๋ฅผ ์ํฌํธํ ๋ ์ด๊ธฐํ ์ฝ๋๊ฐ ์คํ๋จ
>>> import game
Initializing game...
#ํจํค์ง์ ํ์ ๋ชจ๋์ ํจ์๋ฅผ importํ ๋๋ ์ด๊ธฐํ ์ฝ๋ ์คํ๋จ
>>> from game.graphic.render import render_test
Initializing game...
all
- ํน์ ๋๋ ํ ๋ฆฌ์ ๋ชจ๋์ *๋ฅผ ์ฌ์ฉํ์ฌ importํ ๋๋ init.py ํ์ผ์ __all__๋ณ์๋ฅผ ์ค์ ํ๊ณ importํ ์ ์๋ ๋ชจ๋์ ์ ์ํด์ค์ผ ํจ
- all : *๋ฅผ ์ฌ์ฉํ์ฌ importํ ๊ฒฝ์ฐ, ์ด๊ณณ์ ์ ์๋ ๋ชจ๋(echo)๋ง imort๋๋ค๋ ์๋ฏธ
- all๊ณผ ์๊ด์์ด ๋ฌด์กฐ๊ฑด import๋๋ ๊ฒฝ์ฐ : ๋ง์ง๋ง ํญ๋ชฉ์ด ๋ชจ๋์ธ ๋
#ํด๋น ๋๋ ํ ๋ฆฌ์ __init__.py์ __all__๋ณ์ ์ค์ ํด์ผ ํจ
>>> from game.sound import *
Initializing game...
>>> echo.echo_test()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'echo' is not defined
----
__all__=['echo']
----
>>> from game.sound import *
Initializing game...
>>> echo.echo_test()
echo
relative ํจํค์ง
from game.sound.echo import echo_test
ํน์
from ..sound.echo import echo_test #..์ ๋ถ๋ชจ๋๋ ํ ๋ฆฌ ์๋ฏธ)
---
C:\\python>python
>>> from game.graphic.render import render_test
Initializing game...
>>> render_test()
render
echo
5-4 ์์ธ์ฒ๋ฆฌ
์ค๋ฅ๋ ์ธ์ ๋ฐ์ํ๋๊ฐ?
- FileNotFoundError : ์กด์ฌํ์ง ์๋ ํ์ผ์ ์ฌ์ฉํ๋ ค๊ณ ์๋ํ์ ๋
>>> f=open("์๋ ํ์ผ", 'r')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: '์๋ ํ์ผ'
- ZeroDivisionError : 0์ผ๋ก ๋๋๋ ค๊ณ ํ ๋
>>> 4/0
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
- IndexError : ์๋ ์์๋ฅผ ๊ฐ๋ฆฌํค๋ ค๊ณ ํ ๋
>>> a=[1,2,3]
>>> a[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
์ค๋ฅ ์์ธ ์ฒ๋ฆฌ ๊ธฐ๋ฒ
try-except๋ฌธ
- try ๋ธ๋ก ์ํ ์ค ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ฉด except ๋ธ๋ก์ด ์ํ๋จ
try:
...
except [๋ฐ์์ค๋ฅ [as ์ค๋ฅ๋ณ์]] #๊ดํธ ์์ ๋ด์ฉ์ ์๋ตํ ์ ์์
...
*except ๊ตฌ๋ถ์ 3๊ฐ์ง ๋ฐฉ๋ฒ
1.try-except๋ง ์ฌ์ฉ
try:
...
except:
...
2.๋ฐ์์ค๋ฅ๋ง ํฌํจํ except๋ฌธ
try:
...
except ๋ฐ์์ค๋ฅ:
...
3.๋ฐ์์ค๋ฅ์ ์ค๋ฅ๋ณ์๊น์ง ํฌํจํ except๋ฌธ
try:
...
except ๋ฐ์์ค๋ฅ as ์ค๋ฅ๋ณ์:
...
try:
4/0
except ZeroDivisionError as e:
print(e) # division by zero
try-finally๋ฌธ
- finally์ : try๋ฌธ ์ํ ๋์ค ์์ธ ๋ฐ์ ์ฌ๋ถ์ ์๊ด์์ด ํญ์ ์ํ๋จ
- ๋ณดํต ๋ฆฌ์์ค๋ฅผ closeํด์ผ ํ ๋ ๋ง์ด ์ฌ์ฉํจ
try:
f=open('foo.txt','w')
#๋ฌด์ธ๊ฐ๋ฅผ ์ํ
finally:
f.close() #์ค๊ฐ์ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋๋ผ๋ ๋ฌด์กฐ๊ฑด ์คํ
์ฌ๋ฌ ๊ฐ์ ์ค๋ฅ ์ฒ๋ฆฌํ๊ธฐ
try:
...
except ๋ฐ์์ค๋ฅ1:
...
except ๋ฐ์์ค๋ฅ2:
...
try:
a=[1,2]
print(a[3]) #์ธ๋ฑ์ฑ ์ค๋ฅ๊ฐ ๋จผ์ ๋ฐ์ํ์ฌ
4/0 #DivisionError ์ค๋ฅ๋ ๋ฐ์ํ์ง ์์
except ZeroDivisionError:
print("0์ผ๋ก ๋๋ ์ ์์ต๋๋ค.")
except IndexError:
print("์ธ๋ฑ์ฑํ ์ ์์ต๋๋ค.")
#์ถ๋ ฅ: ์ธ๋ฑ์ฑํ ์ ์์ต๋๋ค.
try:
a=[1,2]
print(a[3])
4/0
except ZeroDivisionError as e:
print(e)
except IndexError as e:
print(e)
#์ถ๋ ฅ : list index out of range
#2๊ฐ ์ด์์ ์ค๋ฅ๋ฅผ ๋์ผํ๊ฒ ๊ฐ์ด ์ฒ๋ฆฌ (๊ดํธ๋ฅผ ์ฌ์ฉ)
try:
a=[1,2]
print(a[3])
4/0
except (ZeroDivisionError, IndexError) as e:
print(e)
#์ถ๋ ฅ : list index out of range
try-else๋ฌธ
- try๋ฌธ ์ํ ์ค ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ฉด except์ , ์ค๋ฅ๊ฐ ๋ฐ์ํ์ง ์์ผ๋ฉด else์ ์ด ์ํ๋จ
try:
...
except [๋ฐ์์ค๋ฅ [as ์ค๋ฅ๋ณ์]]:
...
else: #์ค๋ฅ๊ฐ ์์ ๊ฒฝ์ฐ์๋ง ์ํ
...
try:
age=int(input("๋์ด๋ฅผ ์
๋ ฅํ์ธ์: "))
except:
print("์
๋ ฅ์ด ์ ํํ์ง ์์ต๋๋ค.") #์ซ์๊ฐ ์๋ ๋ค๋ฅธ๊ฐ ์
๋ ฅ์ ์ค๋ฅ ๋ฐ์
else: #์ค๋ฅ๊ฐ ์์ ๊ฒฝ์ฐ์๋ง else์ ์ํ
if age<=18:
print("๋ฏธ์ฑ๋
์๋ ์ถ์
๊ธ์ง")
else:
print("ํ์ํฉ๋๋ค")
์ค๋ฅ ํํผํ๊ธฐ
- ํน์ ์ค๋ฅ๊ฐ ๋ฐ์ํ ๊ฒฝ์ฐ ๊ทธ๋ฅ ํต๊ณผ์ํฌ ๋
try:
f=open("์๋ ํ์ผ",'r')
except FileNotFoundError: #ํ์ผ ์๋๋ผ๋ ํต๊ณผ (์ค๋ฅ ํํผ)
pass
์ค๋ฅ ์ผ๋ถ๋ฌ ๋ฐ์์ํค๊ธฐ
- raise ๋ช ๋ น์ด๋ฅผ ์ฌ์ฉํด ์ค๋ฅ๋ฅผ ๊ฐ์ ๋ก ๋ฐ์์ํด
class Bird:
def fly(self):
#๊ผญ ์์ฑํด์ผ ํ๋ ๋ถ๋ถ์ด ๊ตฌํ๋์ง ์์์ ๊ฒฝ์ฐ ์ผ๋ถ๋ฌ ์ค๋ฅ๋ฅผ ๋ฐ์์ํด
raise NotImplementedError
#Bird๋ฅผ ์์๋ฐ์์ผ๋, fly๋ฉ์๋๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํ์ฌ ๊ตฌํํ์ง ์์
class Eagle(Bird):
pass
eagle=Eagle()
#eagle์ fly ๋ฉ์๋๋ฅผ ์ํํ๋ ์๊ฐ Bird์ fly๋ฉ์๋๊ฐ ์ํ๋์ด NotImplementedError ๋ฐ์
eagle.fly()
---
Traceback (most recent call last):
File "c:\\python\\0228\\error_raise.py", line 10, in <module>
eagle.fly()
File "c:\\python\\0228\\error_raise.py", line 4, in fly
raise NotImplementedError
^^^^^^^^^^^^^^^^^^^^^^^^^
NotImplementedError
Eagle์ flyํจ์๋ฅผ ๊ตฌํ
class Eagle(Bird):
def fly(self):
print("very fast")
eagle=Eagle()
eagle.fly() #์ถ๋ ฅ: very fast
์์ธ ๋ง๋ค๊ธฐ
- ํ๋ก๊ทธ๋จ์ ์ํํ๋ค๊ฐ ํน์ํ ๊ฒฝ์ฐ์๋ง ์์ธ๋ฅผ ์ฒ๋ฆฌํ๋ ค๊ณ ์ข ์ข ์์ธ๋ฅผ ๋ง๋ค์ด์ ์ฌ์ฉํจ
- ํ์ด์ฌ ๋ด์ฅ ํด๋์ค์ธ Exception ํด๋์ค๋ฅผ ์์ํ์ฌ ์์ธ๋ฅผ ๋ง๋ค ์ ์์
class MyError(Exception):
pass
def say_nick(nick):
if nick=='๋ฐ๋ณด':
raise MyError()
print(nick)
say_nick("์ฒ์ฌ")
say_nick("๋ฐ๋ณด") #์ฌ๊ธฐ์์ MyError ๋ฐ์
----์ถ๋ ฅ
์ฒ์ฌ
Traceback (most recent call last):
File "c:\\python\\0228\\error_make.py", line 9, in <module>
say_nick("๋ฐ๋ณด")
File "c:\\python\\0228\\error_make.py", line 5, in say_nick
raise MyError()
MyError
#MyError ๋ฐ์์ ์์ธ์ฒ๋ฆฌ
try:
say_nick("์ฒ์ฌ")
say_nick("๋ฐ๋ณด")
except MyError:
print("ํ์ฉ๋์ง ์๋ ๋ณ๋ช
์
๋๋ค")
---์ถ๋ ฅ
์ฒ์ฌ
ํ์ฉ๋์ง ์๋ ๋ณ๋ช
์
๋๋ค
- ์ค๋ฅ ๋ฉ์์ง๊ฐ ์ถ๋ ฅ๋๊ฒ ํ๋ ค๋ฉด ์ค๋ฅ ํด๋์ค์ str ๋ฉ์๋ ๊ตฌํ
class MyError(Exception):
def __str__(self):
return "ํ์ฉ๋์ง ์๋ ๋ณ๋ช
์
๋๋ค."
try:
say_nick("์ฒ์ฌ")
say_nick("๋ฐ๋ณด")
except MyError as e:
print(e)
---์ถ๋ ฅ
์ฒ์ฌ
ํ์ฉ๋์ง ์๋ ๋ณ๋ช
์
๋๋ค
5-5 ๋ด์ฅํจ์
- ๋ชจ๋๊ณผ ๋ฌ๋ฆฌ import๊ฐ ํ์ํ์ง ์๊ธฐ ๋๋ฌธ์ ์๋ฌด๋ฐ ์ค์ ์์ด ๋ฐ๋ก ์ฌ์ฉํ ์ ์์
abs(x)
- ์ด๋ค ์ซ์๋ฅผ ์ ๋ ฅ๋ฐ์์ ๋ ๊ทธ ์ซ์์ ์ ๋๊ฐ์ ๋ฆฌํด
>>> abs(3)
3
>>> abs(-3)
3
>>> abs(-1.2)
1.2
all(x)
- ๋ฐ๋ณต ๊ฐ๋ฅํ ๋ฐ์ดํฐ x๋ฅผ ์ ๋ ฅ๊ฐ์ผ๋ก ๋ฐ์ผ๋ฉฐ, x์ ์์๊ฐ ๋ชจ๋ ์ฐธ์ด๋ฉด True, ๊ฑฐ์ง์ด ํ๋๋ผ๋ ์์ผ๋ฉด False๋ฅผ ๋ฆฌํด
>>> all([1,2,3])
True
#0์ ๊ฑฐ์ง์
>>> all([1,2,3,0])
False
#์
๋ ฅ ์ธ์๊ฐ ๋น๊ฐ์ธ ๊ฒฝ์ฐ True ๋ฆฌํด
>>> all([])
True
any(x)
- ๋ฐ๋ณต ๊ฐ๋ฅํ ๋ฐ์ดํฐ x๋ฅผ ์ ๋ ฅ๊ฐ์ผ๋ก ๋ฐ์ผ๋ฉฐ, x์ ์์ ์ฆ ํ๋๋ผ๋ ์ฐธ์ด ์์ผ๋ฉด True๋ฅผ ๋ฆฌํด, ๋ชจ๋๊ฐ ๊ฑฐ์ง์ผ ๋๋ง False๋ฅผ ๋ฆฌํด
>>> any([1,2,3,0])
True
#0๊ณผ ""๋ ๊ฑฐ์ง์
>>> any([0,""])
False
#์
๋ ฅ ์ธ์๊ฐ ๋น๊ฐ์ธ ๊ฒฝ์ฐ False ๋ฆฌํด
>>> any([])
False
chr(i)
- ์ ๋์ฝ๋ ์ซ์๊ฐ์ ๋ฐ์ ๊ทธ ์ฝ๋์ ํด๋นํ๋ ๋ฌธ์๋ฅผ ๋ฆฌํด
>>> chr(97)
'a'
>>> chr(44032)
'๊ฐ'
dir
- ๊ฐ์ฒด๊ฐ ์ง๋ ๋ณ์๋ ํจ์(๋ฉ์๋)๋ฅผ ๋ณด์ฌ์ค
#๋ฆฌ์คํธ๊ฐ ์ง๋ ํจ์๋ฅผ ๋ณด์ฌ์ค
>>> dir([1,2,3])
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
#๋์
๋๋ฆฌ๊ฐ ์ง๋ ํจ์๋ฅผ ๋ณด์ฌ์ค
>>> dir({'1':'a'})
['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
divmod(a,b)
- 2๊ฐ์ ์ซ์๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์ผ๋ฉฐ, a๋ฅผ b๋ก ๋๋ ๋ชซ๊ณผ ๋๋จธ์ง๋ฅผ ํํ๋ก ๋ฆฌํดํจ
>>> divmod(7,3)
(2, 1)
enumerate
- ์์๊ฐ ์๋ ๋ฐ์ดํฐ(๋ฆฌ์คํธ, ํํ, ๋ฌธ์์ด)๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์ ์ธ๋ฑ์ค ๊ฐ์ ํฌํจํ๋ enumerate ๊ฐ์ฒด๋ฅผ ๋ฆฌํด (๋ณดํต for๋ฌธ๊ณผ ํจ๊ป ์ฌ์ฉ)
- enumerate๋ฅผ for๋ฌธ๊ณผ ํจ๊ป ์ฌ์ฉํ๋ฉด ์๋ฃํ์ ํ์ฌ ์์(index)์ ๊ทธ ๊ฐ์ ์ฝ๊ฒ ์ ์ ์์
>>> for i, name in enumerate(['body','foo','bar']):
... print(i, name)
...
0 body
1 foo
2 bar
eval(expression)
- ๋ฌธ์์ด์ ํ์ด์ฌ ์ฝ๋๋ก ์คํํ์ฌ ๊ทธ ๊ฒฐ๊ณผ๊ฐ์ ๋ฆฌํด
>>> eval('1+2')
3
>>> eval("'hi'+'a'")
'hia'
>>> eval('divmod(4,3)')
(1, 1)
filter
- ์ฒซ ๋ฒ์งธ ์ธ์๋ก ํจ์, ๋๋ฒ์งธ ์ธ์๋ก ๊ทธ ํจ์์ ์ฐจ๋ก๋ก ๋ค์ด๊ฐ ๋ฐ๋ณต๊ฐ๋ฅํ ๋ฐ์ดํฐ๋ฅผ ๋ฐ์
- ๋ฐ๋ณต ๊ฐ๋ฅํ ๋ฐ์ดํฐ์ ์์ ์์๋๋ก ํจ์๋ฅผ ํธ์ถํ์ ๋ ๋ฆฌํด๊ฐ์ด ์ฐธ์ธ ๊ฒ๋ง ๋ฌถ์ด์(๊ฑธ๋ฌ๋ด์) ๋ฆฌํด
#๋ฆฌ์คํธ๋ฅผ ์
๋ ฅ์ผ๋ก ๋ฐ์ ๊ฐ ์์๋ฅผ ํ๋ณํ์ฌ ์์๊ฐ๋ง ๋ฆฌํด
def positive(l):
result=[] #์์๋ง ๊ฑธ๋ฌ๋ด์ ์ ์ฅํ ๋ณ์
for i in l:
if i>0:
result.append(i)
return result
print(positive([1,-3,2,0,-5,-6]))
#filter ํจ์ ์ฌ์ฉ
def positive(x):
return x>0
print(list(filter(positive,[1,-3,2,0,-5,-6])))
#๋๋ค๋ก ํํ
list(filter(lambda x: x>0, [1,-3,2,0,-5,-6]))
hex
- ์ ์๋ฅผ ์ ๋ ฅ๋ฐ์ 16์ง์ ๋ฌธ์์ด๋ก ๋ณํํ์ฌ ๋ฆฌํด
>>> hex(234)
'0xea'
>>> hex(3)
'0x3'
id(object)
- ๊ฐ์ฒด๋ฅผ ์ ๋ ฅ๋ฐ์ ๊ฐ์ฒด์ ๊ณ ์ ์ฃผ์๊ฐ(๋ ํผ๋ฐ์ค)๋ฅผ ๋ฆฌํด
>>> a=3
>>> id(3)
140715565074936
>>> id(a)
140715565074936
>>> b=a
>>> id(b)
140715565074936
input([prompt])
- ์ฌ์ฉ์ ์ ๋ ฅ์ ๋ฐ๋ ํจ์, ์ ๋ ฅ์ธ์๋ก ๋ฌธ์์ด์ ์ ๋ฌํ๋ฉด ๊ทธ ๋ฌธ์์ด์ ํ๋กฌํํธ๊ฐ ๋จ
>>> a=input()
hi
>>> a
'hi'
>>> b=input("Enter : ")
Enter : hi
>>> b
'hi'
int(x)
- ๋ฌธ์์ด ํํ์ ์ซ์๋ ์์์ ์ด ์๋ ์ซ์๋ฅผ ์ ์๋ก ๋ฆฌํด
>>> int('3')
3
>>> int(3.4)
3
isinstance(object,class)
- ์ฒซ๋ฒ์งธ ์ธ์๋ก ๊ฐ์ฒด, ๋๋ฒ์งธ ์ธ์๋ก ํด๋์ค๋ฅผ ๋ฐ์, ์ ๋ ฅ์ผ๋ก ๋ฐ์ ๊ฐ์ฒด๊ฐ ๊ทธ ํด๋์ค์ ์ธ์คํด์ค์ธ์ง๋ฅผ ํ๋จํ์ฌ ์ฐธ์ด๋ฉด True, ๊ฑฐ์ง์ด๋ฉด False๋ฅผ ๋ฆฌํด
>>> class Person: pass
...
>>> a=Person()
>>> isinstance(a,Person)
True
>>> b=3
>>> isinstance(b,Person)
False
len(s)
- ์ ๋ ฅ๊ฐ s์ ๊ธธ์ด(์์์ ์ ์ฒด๊ฐ์)๋ฅผ ๋ฆฌํด
>>> len("python")
6
>>> len([1,2,3])
3
>>> len((1,'a'))
2
list(iterable)
- ๋ฐ๋ณต๊ฐ๋ฅํ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ๋ฐ์ ๋ฆฌ์คํธ๋ก ๋ง๋ค์ด ๋ฆฌํด
>>> list("python")
['p', 'y', 't', 'h', 'o', 'n']
>>> list((1,2,3))
[1, 2, 3]
#๋ฆฌ์คํธ๋ฅผ ์
๋ ฅํ๋ฉด ๋๊ฐ์ ๋ฆฌ์คํธ๋ฅผ ๋ณต์ฌํ์ฌ ๋ฆฌํด
>>> a=[1,2,3]
>>> b=list(a)
>>> b
[1, 2, 3]
map(f, iterable)
- ํจ์(f)์ ๋ฐ๋ณต๊ฐ๋ฅํ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์, ์ ๋ ฅ๋ฐ์ ๋ฐ์ดํฐ์ ๊ฐ ์์์ ํจ์ f๋ฅผ ์ ์ฉํ ๊ฒฐ๊ณผ๋ฅผ ๋ฆฌํด
def two_times(numberList):
result=[]
for number in numberList:
result.append(number*2)
return result
result = two_times([1,2,3,4])
print(result) #[2, 4, 6, 8]
#๋๋ค
>>> list(map(lambda a: a*2, [1,2,3,4]))
[2, 4, 6, 8]
max(iterable)
- ๋ฐ๋ณต๊ฐ๋ฅํ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ๋ฐ์ ๊ทธ ์ต๋๊ฐ์ ๋ฆฌํด
- ๋ฌธ์์ด์ ๊ฒฝ์ฐ, ์ ๋์ฝ๋ ๊ฐ์ด ๊ฐ์ฅ ํฐ ๋ฌธ์๋ฅผ ๋ฆฌํด
>>> max([1,2,3])
3
>>> max("python")
'y'
min(iterable)
- ๋ฐ๋ณต๊ฐ๋ฅํ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ๋ฐ์ ๊ทธ ์ต์๊ฐ์ ๋ฆฌํด
>>> min([1,2,3])
1
>>> min("python")
'h'
oct(x)
- ์ ์๋ฅผ 8์ง์ ๋ฌธ์์ด๋ก ๋ฐ๊พธ์ด ๋ฆฌํด
>>> oct(34)
'0o42'
>>> oct(12345)
'0o30071'
open(filename, [mode])
- ํ์ผ์ด๋ฆ๊ณผ ์ฝ๊ธฐ๋ฐฉ๋ฒ์ ์ ๋ ฅ๋ฐ์ ํ์ผ ๊ฐ์ฒด๋ฅผ ๋ฆฌํด
- mode๋ฅผ ์๋ตํ๋ฉด ๊ธฐ๋ณธ๊ฐ์ธ ์ฝ๊ธฐ๋ชจ๋(r)๋ก ํ์ผ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด ๋ฆฌํด
- b๋ w, r, a(์ฐ๊ธฐ, ์ฝ๊ธฐ, ์ถ๊ฐ)์ ํจ๊ป ์ฌ์ฉํจ (rb๋ ๋ฐ์ด๋๋ฆฌ ์ฝ๊ธฐ๋ชจ๋)
>>> f=open("binary_file","rb")
ord(c)
- ๋ฌธ์์ ์ ๋์ฝ๋ ์ซ์ ๊ฐ์ ๋ฆฌํด (chr ํจ์์ ๋ฐ๋๋ก ๋์)
>>> ord('a')
97
>>> ord('๊ฐ')
44032
pow(x,y)
- x๋ฅผ y์ ๊ณฑํ ๊ฒฐ๊ณผ๋ฅผ ๋ฆฌํด
>>> pow(3,3)
27
>>> pow(2,4)
16
range([start,]stop[,step])
- ์ ๋ ฅ๋ฐ์ ์ซ์์ ํด๋นํ๋ ๋ฒ์๊ฐ์ ๋ฐ๋ณต๊ฐ๋ฅํ ๊ฐ์ฒด๋ก ๋ง๋ค์ด ๋ฆฌํด
#์ธ์๊ฐ ํ๋ (0๋ถํฐ ์์)
>>> list(range(5))
[0, 1, 2, 3, 4]
#์ธ์๊ฐ 2๊ฐ (์์์ซ์~๋์ซ์, ๋์ซ์๋ ๋ฒ์์ ํฌํจx)
>>> list(range(5,10))
[5, 6, 7, 8, 9]
#์ธ์๊ฐ 3๊ฐ (3๋ฒ์งธ๋ ์ซ์ ์ฌ์ด์ ๊ฑฐ๋ฆฌ)
>>> list(range(1,10,2)) #1๋ถํฐ 9๊น์ง, ์ซ์๊ฐ ๊ฑฐ๋ฆฌ 2
[1, 3, 5, 7, 9]
>>> list(range(0,-10,-1)) #0๋ถํฐ -9๊น์ง, ์ซ์๊ฐ ๊ฑฐ๋ฆฌ -1
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
round(number [,ndigits])
- ์ซ์๋ฅผ ์ ๋ ฅ๋ฐ์ ๋ฐ์ฌ๋ฆผํด ๋ฆฌํด
- ๋๋ฒ์งธ ์ธ์ : ๋ฐ์ฌ๋ฆผํ์ฌ ํ์ํ๊ณ ์ถ์ ์์์ ์ ์๋ฆฟ์
>>> round(4.6)
5
>>> round(4.2)
4
>>> round(5.678,2) #์์์ 2์๋ฆฌ๊น์ง๋ง, ๋ฐ์ฌ๋ฆผํ์ฌ ํ์
5.68
sorted(iterable)
- ์ ๋ ฅ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ ํ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ฆฌ์คํธ๋ก ๋ฆฌํด
- ๋ฆฌ์คํธ ์๋ฃํ์ sortํจ์๋ ๋ฆฌ์คํธ ๊ฐ์ฒด๋ฅผ ์ ๋ ฌ๋ง ํ ๋ฟ, ๊ฒฐ๊ณผ๋ฅผ ๋ฆฌํดํ์ง ์์
>>> 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(object)
- ๋ฌธ์์ด ํํ๋ก ๊ฐ์ฒด๋ฅผ ๋ณํํ์ฌ ๋ฆฌํด
>>> str(3)
'3'
>>> str('hi')
'hi'
sum(iterable)
- ์ ๋ ฅ ๋ฐ์ดํฐ์ ํฉ์ ๋ฆฌํด
>>> sum([1,2,3])
6
>>> sum((4,5,6))
15
tuple(iterable)
- ๋ฐ๋ณต๊ฐ๋ฅํ ๋ฐ์ดํฐ๋ฅผ ํํ๋ก ๋ฐ๊พธ์ด ๋ฆฌํด
>>> tuple("abc")
('a', 'b', 'c')
>>> tuple([1,2,3])
(1, 2, 3)
>>> tuple((1,2,3))
(1, 2, 3)
type(object)
- ์ ๋ ฅ๊ฐ์ ์๋ฃํ์ด ๋ฌด์์ธ์ง ์๋ ค์ค
>>> type("abc")
<class 'str'>
>>> type([])
<class 'list'>
>>> type(open("test",'w'))
<class '_io.TextIOWrapper'>
zip(*iterable)
- ๋์ผํ ๊ฐ์๋ก ์ด๋ฃจ์ด์ง ๋ฐ์ดํฐ๋ค์ ๋ฌถ์ด์ ๋ฆฌํด
- *iterable : ๋ฐ๋ณต๊ฐ๋ฅํ ๋ฐ์ดํฐ๋ฅผ ์ฌ๋ฌ ๊ฐ ์ ๋ ฅ ๊ฐ๋ฅ
>>> 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("abc","def"))
[('a', 'd'), ('b', 'e'), ('c', 'f')]
5-6 ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ
- ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ : ํ์ด์ฌ์ ์ค์นํ ๋ ์๋์ผ๋ก ์ปดํจํฐ์ ์ค์น๋จ
datetime.date
- ์ฐ, ์, ์ผ๋ก ๋ ์ง๋ฅผ ํํํ ๋ ์ฌ์ฉ
import datetime
import calendar #์ ์๋ฅผ ์ค์ ์์ผ ์ด๋ฆ์ผ๋ก ๋ณํ
import locale #์ง์ญํ๋ ๋ ์ง ๋ฐ ์๊ฐ ํํ์ ์ป์
#๋ ์ง ๋นผ๊ธฐ
day1 = datetime.date(2020, 1, 15)
day2 = datetime.date(2024,2,28)
#datetime.timedelta๋ ๋ ๋ ์ง ๋๋ ์๊ฐ ๊ฐ์ ์ฐจ์ด๋ฅผ ๋ํ๋ด๋ ๊ฐ์ฒด
diff = day2 -day1 #datetime ๋ชจ๋์ timedelta ๊ฐ์ฒด๊ฐ ๋ฆฌํด๋จ
#days ์์ฑ์ timedelta ๊ฐ์ฒด์ ์ผ(day) ๋ถ๋ถ
#์ข
๋ฃ ๋ ์ง๋ฅผ ํฌํจํด์ ์นด์ดํธํ๋ ค๋ฉด +1
diff = (day2 -day1).days +1
print(f"์ฐ์ ๋ฅผ ์์ํ์ง {diff}์ผ์งธ ์
๋๋ค.")
#ํ๊ตญ์ด๋ก ์ง์ญํ ์ค์
locale.setlocale(locale.LC_TIME, 'ko_KR')
#์์ผ
#weekday()๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ
metDay = day1.weekday()
day_name = calendar.day_name[metDay]
print(f"์ฒ์ ๋ง๋ฌ๋ ๋ ์ {day_name}์ด์์ต๋๋ค.")
#isoweekday()๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ
metDay = day1.isoweekday()
# ์์์ผ ์์์ด 1์ด๋ฏ๋ก ์ธ๋ฑ์ค๋ฅผ 1 ๊ฐ์์์ผ์ผ ํจ
day_name = calendar.day_name[metDay - 1]
print(f"์ฒ์ ๋ง๋ฌ๋ ๋ ์ {day_name}์ด์์ต๋๋ค.")
- weekday() ๋ฉ์๋:
- ์์์ผ๋ถํฐ ์ผ์์ผ๊น์ง์ ์์ผ์ 0(์์์ผ)์์ 6(์ผ์์ผ)๊น์ง์ ์ ์๋ก ๋ฐํํฉ๋๋ค.
- ์์์ผ์ด 0์ด๊ณ ์ผ์์ผ์ด 6์ ๋๋ค.
- isoweekday() ๋ฉ์๋:
- ์์์ผ๋ถํฐ ์ผ์์ผ๊น์ง์ ์์ผ์ 1(์์์ผ)์์ 7(์ผ์์ผ)๊น์ง์ ์ ์๋ก ๋ฐํํฉ๋๋ค.
- ์์์ผ์ด 1์ด๊ณ ์ผ์์ผ์ด 7์ ๋๋ค.
time
>>> import time
#ํ์ฌ ์๊ฐ์ ์ค์ํํ๋ก ๋ฆฌํด
>>> time.time()
1709105174.6867003
#์ค์ํํ๋ฅผ ํํํํ๋ก
>>> time.localtime(time.time())
time.struct_time(tm_year=2024, tm_mon=2, tm_mday=28, tm_hour=16, tm_min=27, tm_sec=0, tm_wday=2, tm_yday=59, tm_isdst=0)
#ํํ ํํ๋ฅผ ์์๋ณด๊ธฐ ์ฝ๊ฒ
>>> time.asctime(time.localtime(time.time()))
'Wed Feb 28 16:28:14 2024'
#ํ์ฌ์๊ฐ์ ์์๋ณด๊ธฐ ์ฝ๊ฒ
>>> time.ctime()
'Wed Feb 28 16:29:03 2024'
#์๊ฐ ํํ์ ํฌ๋งท์ฝ๋๋ฅผ ์ฌ์ฉํ์ฌ
>>> time.strftime('%x',time.localtime(time.time()))
'02/28/24' # %x๋ ์/์ผ/๋
>>> time.strftime('%c',time.localtime(time.time()))
'Wed Feb 28 16:31:10 2024' # %c๋ ๋ ์ง์ ์๊ฐ์ ์ถ๋ ฅ
#์ธ์์์ด timeํจ์ ์ฌ์ฉํ๊ธฐ
>>> time.localtime()
time.struct_time(tm_year=2024, tm_mon=2, tm_mday=28, tm_hour=16, tm_min=36, tm_sec=55, tm_wday=2, tm_yday=59, tm_isdst=0)
>>> time.asctime()
'Wed Feb 28 16:37:03 2024'
>>> time.strftime('%c')
'Wed Feb 28 16:37:14 2024'
time.time
- UTC(Universal time coordinated, ํ์ ์ธ๊ณ ํ์ค์)๋ฅผ ์ฌ์ฉํ์ฌ ํ์ฌ ์๊ฐ์ ์ค์ ํํ๋ก ๋ฆฌํด
- 1970๋ 1์ 1์ผ 0์ 0๋ถ 0์ด๋ฅผ ๊ธฐ์ค์ผ๋ก ์ง๋ ์๊ฐ์ ์ด๋จ์๋ก ๋ฆฌํดํจ
time.localtime
- time.time()์ด ๋ฆฌํดํ ์ค์ซ๊ฐ์ ์ฌ์ฉํด ์ฐ,์,์ผ,์,๋ถ,์ด์ ํํ๋ก ๋ฐ๊ฟ์ค
- ์ธ์์์ด ์ฌ์ฉํ ๊ฒฝ์ฐ ํ์ฌ์๊ฐ์ ๊ธฐ์ค์ผ๋ก ํจ์๊ฐ ์คํ๋จ
time.asctime
- time.localtime์ด ๋ฆฌํด๋ ํํ ํํ์ ๊ฐ์ ์ธ์๋ก ๋ฐ์ ๋ ์ง์ ์๊ฐ์ ์์๋ณด๊ธฐ ์ฌ์ด ํํ๋ก ๋ฆฌํด
- ์ธ์์์ด ์ฌ์ฉํ ๊ฒฝ์ฐ ํ์ฌ์๊ฐ์ ๊ธฐ์ค์ผ๋ก ํจ์๊ฐ ์คํ๋จ
time.ctime
- time.localtime(time.time())์ ๊ฐ๋จํ๊ฒ time.ctime()์ผ๋ก ํ์ํ ์ ์์
- asctime๊ณผ ๋ค๋ฅธ ์ ์ ํญ์ ํ์ฌ ์๊ฐ๋ง์ ๋ฆฌํดํจ
time.strftime
- ์๊ฐ์ ๊ด๊ณ๋ ๊ฒ์ ์ธ๋ฐํ๊ฒ ํํํ๋ ์ฌ๋ฌ๊ฐ์ง ํฌ๋งท์ฝ๋๋ฅผ ์ ๊ณตํจ
- ์ธ์์์ด ์ฌ์ฉํ ๊ฒฝ์ฐ ํ์ฌ์๊ฐ์ ๊ธฐ์ค์ผ๋ก ํจ์๊ฐ ์คํ๋จ
time.strftime('์ถ๋ ฅํ ํ์ ํฌ๋งท ์ฝ๋',time.localtime(time.time()))
time.sleep
- ์ฃผ๋ก ๋ฃจํ ์์์ ๋ง์ด ์ฌ์ฉํจ
- ์ผ์ ํ ์๊ฐ ๊ฐ๊ฒฉ์ ๋๊ณ ๋ฃจํ๋ฅผ ์คํํ ์ ์์
import time
for i in range(10):
print(i)
time.sleep(1)
math.gcd (greatest common divisor)
- ์ต๋๊ณต์ฝ์ ๊ตฌํ๊ธฐ
- ๊ณต์ฝ์ : ๋ ์ ์ด์์ ์ฌ๋ฌ ์์ ๊ณตํต๋ ์ฝ์
- ์ต๋๊ณต์ฝ์ : ๊ณต์ฝ์ ์ค ๊ฐ์ฅ ํฐ ์
"""
์ฌํ 60๊ฐ, ์ ค๋ฆฌ 80๊ฐ, ์ด์ฝ๋ฆฟ 100๊ฐ๋ฅผ ๋๊ฐ์ด ๋ด์ง์ ๋๋ ๋ด์ ๋
์ต๋ ๋ช ๋ด์ง? (๋๊ฐ์ด ๋๋ ์ ์๋ ์ต๋ ๋ด์ง ๊ฐ์)
"""
>>> import math
>>> math.gcd(60,80,100)
20
#ํ ๋ด์ง๋น ๊ฐ์
>>> 60/20, 80/20, 100/20
(3.0, 4.0, 5.0)
#์ฌํ 3๊ฐ, ์ ค๋ฆฌ 4๊ฐ, ์ด์ฝ๋ฆฟ 5๊ฐ์ฉ ๋ด๊ธฐ
math.lcm (least common multiple)
- ์ต์๊ณต๋ฐฐ์ ๊ตฌํ๊ธฐ
- ์ต์๊ณต๋ฐฐ์ : ๋ ์์ ๊ณตํต ๋ฐฐ์ ์ค ๊ฐ์ฅ ์์ ์
"""
์๋ด๋ฒ์ค๋ 15๋ถ, ๋ง์๋ฒ์ค๋ 25๋ถ๋ง๋ค ๋์ฐฉํ๋ค.
์คํ 1์์ ๋ ๋ฒ์ค๊ฐ ๋์์ ๋์ฐฉํ์ ๋, ๋ค์ ๋์์ ๋์ฐฉํ ์๊ฐ์?
"""
>>> import math
>>> math.lcm(15,25)
75
#๋ ๋ฒ์ค๊ฐ ๋์์ ๋์ฐฉํ ๋ค์ ์๊ฐ์ 75๋ถ ํ์ธ ์คํ 2์ 15๋ถ
random
- ๋์๋ฅผ ๋ฐ์์ํด
- random.choice ํจ์ : ์ ๋ ฅ์ผ๋ก ๋ฐ์ ๋ฆฌ์คํธ์์ ๋ฌด์์๋ก ํ๋์ ์์๋ฅผ ์ ํํ์ฌ ๋ฆฌํด
- random.sample ํจ์ : ๋ฆฌ์คํธ ํญ๋ชฉ์ ๋ฌด์์๋ก ์์
>>> import random
#0.0์์ 1.0 ์ฌ์ด์ ๋์
>>> random.random()
0.3640631163271081
#1์์ 10 ์ฌ์ด ์ ์
>>> random.randint(1,10)
8
#1์์ 55 ์ฌ์ด ์ ์
>>> random.randint(1,55)
46
#random.sample(๋ฆฌ์คํธ, ๋ฌด์์๋ก ์ถ์ถํ ์์์ ๊ฐ์)
>>> data=[1,2,3,4,5]
>>> random.sample(data,len(data))
[4, 5, 3, 1, 2]
import random
#random.choice(๋ฆฌ์คํธ)
def random_pop(data):
number = random.choice(data) #๋ฌด์์๋ก ํ๋์ ์์๋ฅผ ์ ํํ์ฌ ๋ฆฌํด
data.remove(number)
return number
#random.randint(์์์,๋์)
def random_pop(data):
number = random.randint(0,len(data)-1)
return data.pop(number) #์ธ๋ฑ์ค์ ํด๋นํ๋ ์์๋ฅผ ์ ๊ฑฐํ๊ณ ๋ฐํํจ
if __name__=="__main__":
data = [1,2,3,4,5]
while data: #5๋ฒ ๋ฐ๋ณต
print(random_pop(data))
itertools.zip_longest
- zipํจ์ : ๊ฐ์ ๊ฐ์์ ์๋ฃํ์ ๋ฌถ๋ ํ์ด์ฌ ๋ด์ฅ ํจ์
- intertools.zip_longest( ) ํจ์: ์ ๋ฌํ ๋ฐ๋ณต ๊ฐ๋ฅํ ๊ฐ์ฒด์ ๊ธธ์ด๊ฐ ์๋ก ๋ค๋ฅด๋ค๋ฉด, ๊ธด ๊ฐ์ฒด์ ๊ธธ์ด์ ๋ง์ถฐ fillvalue์ ์ค์ ํ ๊ฐ์ ์งง์ ๊ฐ์ฒด์ ์ฑ์ธ ์ ์์
#์ ์น์์ 5๋ช
์๊ฒ ๊ฐ์ ๋๋ ์ฃผ๊ธฐ
students =['ํ๋ฏผ์','ํฉ์ง๋ฏผ','์ด์์ฒ ','์ด๊ด์','๊น์น๋ฏผ']
snacks=['์ฌํ','์ด์ฝ๋ฆฟ','์ ค๋ฆฌ']
result = zip(students,snacks)
print(list(result))
#์ถ๋ ฅ
[('ํ๋ฏผ์', '์ฌํ'), ('ํฉ์ง๋ฏผ', '์ด์ฝ๋ฆฟ'), ('์ด์์ฒ ', '์ ค๋ฆฌ')]
import itertools
students =['ํ๋ฏผ์','ํฉ์ง๋ฏผ','์ด์์ฒ ','์ด๊ด์','๊น์น๋ฏผ']
snacks=['์ฌํ','์ด์ฝ๋ฆฟ','์ ค๋ฆฌ']
result = itertools.zip_longest(students,snacks,fillvalue='์์ฐ๊นก')
print(list(result))
#์ถ๋ ฅ
[('ํ๋ฏผ์', '์ฌํ'), ('ํฉ์ง๋ฏผ', '์ด์ฝ๋ฆฟ'), ('์ด์์ฒ ', '์ ค๋ฆฌ'), ('์ด๊ด์', '์์ฐ๊นก'), ('๊น์น๋ฏผ', ' ์์ฐ๊นก')]
itertools.permutation
- itertools.permutation : ๋ฐ๋ณต ๊ฐ๋ฅ ๊ฐ์ฒด ์ค์์ r๊ฐ๋ฅผ ์ ํํ ์์ด์ ์ดํฐ๋ ์ดํฐ(๋ฐ๋ณต ๊ฐ๋ฅํ ๊ฐ์ฒด)๋ก ๋ฆฌํด
- **itertools.permutations(iterable, r=None)**๋ itertools ๋ชจ๋์์ ์ ๊ณตํ๋ ํจ์๋ก, ์ฃผ์ด์ง iterable์์ r ๊ธธ์ด์ ๊ฐ๋ฅํ ์์ด์ ์์ฑํ๋ ์ดํฐ๋ ์ดํฐ๋ฅผ ๋ฐํ (iterable์ ์์ด์ ์์ฑํ๊ณ ์ ํ๋ ์์๋ค์ ์งํฉ, r์ ์์ฑํ๋ ค๋ ์์ด์ ๊ธธ์ด)
#1,2,3 ์ซ์ ์ค 2์ฅ์ ์นด๋๋ก ๋ง๋ค ์ ์๋ 2์๋ฆฌ ์ซ์๋ฅผ ๋ชจ๋ ๊ตฌํ๊ธฐ
#3์ฅ์ ์นด๋ ์ค ์์์ ์๊ด์์ด 2๊ฐ๋ฅผ ๋ฝ๋ ๊ฒฝ์ฐ์ ์๋ 3๊ฐ์ง์ด์ง๋ง,
#3๊ฐ์ง์ ์์๋ฅผ ๋ํด 6๊ฐ์ง๊ฐ ๋๋ค(์์ด)
>>> import itertools
# ๊ธธ์ด 2์ ๊ฐ๋ฅํ ์์ด ์์ฑ
>>> list(itertools.permutations(['1','2','3'],2))
[('1', '2'), ('1', '3'), ('2', '1'), ('2', '3'), ('3', '1'), ('3', '2')]
>>> for a,b in itertools.permutations(['1','2','3'],2):
... print(a+b)
...
12
13
21
23
31
32
itertools.combination
- itertools.combinations(iterable, r=None) ์ ๋ฐ๋ณต ๊ฐ๋ฅ ๊ฐ์ฒด ์ค์์ r๊ฐ๋ฅผ ์ ํํ ์กฐํฉ์ ์ดํฐ๋ ์ดํฐ๋ก ๋ฐํ
- itertools.combinations_with_replacement(iterable, r) ํจ์๋ ์ฃผ์ด์ง iterable์์ r ๊ธธ์ด์ ๊ฐ๋ฅํ ์ค๋ณต ์กฐํฉ์ ์์ฑํ๋ ์ดํฐ๋ ์ดํฐ๋ฅผ ๋ฐํ (๊ฐ์ ์ซ์๋ฅผ ํ์ฉํจ)
#1~45 ์ค ์๋ก ๋ค๋ฅธ ์ซ์ 6๊ฐ๋ฅผ ๋ฝ๋ ๋ก๋ ๋ฒํธ์ ๋ชจ๋ ๊ฒฝ์ฐ์ ์(์กฐํฉ)๋ฅผ ๊ตฌํ๊ณ ๊ฐ์ ์ถ๋ ฅ
import itertools
>>> it = itertools.combinations(range(1,46),6)
>>> len(list(itertools.combinations(range(1,46),6)))
8145060
#์ค๋ณต ์กฐํฉ์ ํ์ฉ ์
>>> len(list(itertools.combinations_with_replacement(range(1,46),6)))
15890700
functools.reduce
- functools.reduce(function, iterable) : ํจ์๋ฅผ ๋ฐ๋ณต๊ฐ๋ฅํ ๊ฐ์ฒด์ ์์์ ์ฐจ๋ก๋๋ก ๋์ ์ ์ฉํ์ฌ, ์ด ๊ฐ์ฒด๋ฅผ ํ๋์ ๊ฐ์ผ๋ก ์ค์ด๋ ํจ์
#data์ ์์๋ฅผ ๋ชจ๋ ๋ํ์ฌ ๋ฆฌํดํ๋ addํจ์
def add(data):
result=0
for i in data:
result +=i
return result
data = [1,2,3,4,5]
result = add(data)
print(result)
#functools.reduce ์ฌ์ฉ
import functools
data = [1,2,3,4,5]
result = functools.reduce(lambda x,y : x+y, data) #๋๋คํจ์๋ฅผ data ์์์ ์ฐจ๋ก๋๋ก ๋์ ์ ์ฉ
print(result)
#์ต๋๊ฐ ๊ตฌํ๊ธฐ
#์์๋ฅผ ๋๋คํจ์์ ์ ๋ฌ, ๋ ๊ฐ ์ค ํฐ ๊ฐ์ ์ ํํ๊ณ , ๋ง์ง๋ง์ ์ต๋๊ฐ ๋ฆฌํด
num_list=[3,2,8,1,6,7]
max_num=functools.reduce(lambda x,y : x if x>y else y, num_list)
print(max_num)
#์ต์๊ฐ ๊ตฌํ๊ธฐ
min_num=functools.reduce(lambda x,y : x if x<y else y, num_list)
print(min_num)
operator.itemgetter
- ์ฃผ๋ก sorted์ ๊ฐ์ ํจ์์ key๋งค๊ฐ๋ณ์์ ์ ์ฉํ์ฌ, ๋ค์ํ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ ์ ์๋๋ก ๋์์ฃผ๋ ๋ชจ๋์
- sorted(iterable, key=None, reverse=False)๋ iterable ๊ฐ์ฒด(๋ฆฌ์คํธ, ํํ ๋ฑ)์ ์์๋ค์ ์ ๋ ฌํ ์๋ก์ด ๋ฆฌ์คํธ๋ฅผ ๋ฐํํฉ๋๋ค. ์๋ณธ iterable ๊ฐ์ฒด๋ ๋ณ๊ฒฝ๋์ง ์์ต๋๋ค.
- iterable: ์ ๋ ฌํ๊ณ ์ ํ๋ iterable ๊ฐ์ฒด๋ฅผ ์ง์ ํฉ๋๋ค.
- key: ์ ๋ ฌ ๊ธฐ์ค์ ์ปค์คํฐ๋ง์ด์งํ๊ธฐ ์ํด key ์ธ์๋ฅผ ์ฌ์ฉ, ๊ธฐ๋ณธ๊ฐ์ **None**์ด๋ฉฐ, ์ด ๊ฒฝ์ฐ์๋ ์์ ์์ฒด์ ๊ธฐ๋ณธ ์์๋ก ์ ๋ ฌ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด, **key=len**์ ์์์ ๊ธธ์ด๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํฉ๋๋ค.
- reverse: ๊ธฐ๋ณธ๊ฐ์ **False**์ด๋ฉฐ, ์ด ๊ฒฝ์ฐ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋ฉ๋๋ค. **True**๋ก ์ค์ ํ๋ฉด ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ๋ฉ๋๋ค.
- **itemgetter(index)**์ operator ๋ชจ๋์์ ์ ๊ณตํ๋ ํจ์๋ก, ์ฃผ์ด์ง ๊ฐ์ฒด(ํํ, ๋ฆฌ์คํธ ๋ฑ)์์ ์ธ๋ฑ์ค์ ํด๋นํ๋ ์์๋ฅผ ๊ฐ์ ธ์ค๋ ํจ์
- ๋์ ๋๋ฆฌ์ ํค๋ฅผ ์ธ๋ฑ์ค์ฒ๋ผ ์ฌ์ฉํ์ฌ ๊ฐ์ ๊ฐ์ ธ์ฌ ์ ์์
from operator import itemgetter
students= [
("jane",22,'A'),
("dave",32,'B'),
("sally",17,'B')
]
#๋ฆฌ์คํธ๋ฅผ ๋์ด์์ผ๋ก ์ ๋ ฌ
#ํํ์ ์ธ๋ฑ์ค 1์ ๊ฐ์ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌ
result = sorted(students,key=itemgetter(1)) #2๋ก ํ๋ค๋ฉด ์ฑ์ ์ผ๋ก ์ ๋ ฌ๋จ
print(result)
#์ถ๋ ฅ
[('sally', 17, 'B'), ('jane', 22, 'A'), ('dave', 32, 'B')]
from operator import itemgetter
students = [
{"name": "jane", "age": 22, "grade": 'A'},
{"name": "dave", "age": 32, "grade": 'B'},
{"name": "sally", "age": 17, "grade": 'B'}
]
result = sorted(students,key=itemgetter('age')) #ํค๋ฅผ ์ฌ์ฉ
print(result)
#์ถ๋ ฅ
[{'name': 'sally', 'age': 17, 'grade': 'B'}, {'name': 'jane', 'age': 22, 'grade': 'A'}, {'name': 'dave', 'age': 32, 'grade': 'B'}]
- ์์๊ฐ ํด๋์ค์ ๊ฐ์ฒด๋ผ๋ฉด attrgetter()๋ฅผ ์ ์ฉํ์ฌ ์ ๋ ฌํด์ผ ํจ
"""
print ํจ์๋ ๊ฐ์ฒด์ **`__str__`** ๋ฉ์๋๋ฅผ ํธ์ถํจ
__str__ ๋ฉ์๋๊ฐ ์ ์๋์ด ์์ง ์๋ค๋ฉด, ๋์ ์ __repr__ ๋ฉ์๋๋ฅผ ํธ์ถํ๊ณ ,
ํด๋น ๊ฐ์ฒด์ ๊ธฐ๋ณธ์ ์ธ ๋ฌธ์์ด ํํ(ํด๋์ค์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์)์ด ์ถ๋ ฅ๋จ
[<__main__.Student object at 0x000001BB9E9DAE70>, <__main__.Student object at 0x000001BB9E9DA4B0>, <__main__.Student object at 0x000001BB9E9DA5A0>]
"""
from operator import attrgetter
class Student:
def __init__(self,name, age, grade):
self.name = name
self.age = age
self.grade =grade
#๊ฐ์ฒด๋ฅผ ๋ฌธ์์ด๋ก ๋ณํํ ๋ ์ฌ์ฉ๋๋ ๋ฉ์๋ (๋์
๋๋ฆฌ ํํ๋ก ์ถ๋ ฅ๋๋๋ก ์ ์)
def __str__(self):
return f"{{'name': '{self.name}', 'age': {self.age}, 'grade': '{self.grade}'}}"
students= [
Student("jane",22,'A'),
Student("dave",32,'B'),
Student("sally",17,'B')
]
result=sorted(students, key=attrgetter('age'))
for student in result:
print(student)
shutil
- ํ์ผ์ ๋ณต์ฌํ๊ฑฐ๋ ์ด๋ํ ๋ ์ฌ์ฉ
import shutil
#ํ์ผ ๋ฐฑ์
์ ์ํ ์นดํผ
shutil.copy("c:/python/a.txt","c:/python/temp/a.txt")
#ํ์ผ์ ํด์งํต์ผ๋ก ์ญ์
shutil.move("c:/python/a.txt","c:/python/temp/a.txt")
glob
- ํน์ ๋๋ ํ ๋ฆฌ ์์ ํ์ผ๋ค์ ์ฝ์ด์ ๋ฆฌํดํจ
- *(์์์ ๊ธธ์ด์ ๋ฌธ์์ด),?(1์๋ฆฌ ๋ฌธ์์ด) ๋ฑ์ ๋ฉํ ๋ฌธ์๋ฅผ ์จ์ ์ํ๋ ํ์ผ๋ง ์ฝ์ด๋ค์ผ ์ ์์
- ๋๋ ํ ๋ฆฌ์ ์๋ ํ์ผ๋ค์ ๋ฆฌ์คํธ๋ก ๋ง๋ค๊ธฐ - glob(pathname)
>>> import glob
#๋๋ ํ ๋ฆฌ์ ์๋ ํ์ผ ์ค ์ด๋ฆ์ด i๋ก ์์ํ๋ ํ์ผ๋ค์ ๋ชจ๋ ์ฝ์ด๋ค์
>>> glob.glob("C:\\\\python\\\\0229\\\\i*")
['C:\\\\python\\\\0229\\\\intertools_zip.py', 'C:\\\\python\\\\0229\\\\itemgetter1.py']
pickle
- ๊ฐ์ฒด์ ํํ๋ฅผ ๊ทธ๋๋ก ์ ์งํ๋ฉด์ ํ์ผ์ ์ ์ฅํ๊ณ ๋ถ๋ฌ์ฌ ์ ์๊ฒ ํ๋ ๋ชจ๋
- ํ์ด์ฌ ๊ฐ์ฒด๋ฅผ ์ง๋ ฌํ(serialize)ํ๊ฑฐ๋ ์ญ์ง๋ ฌํ(deserialize)ํ๋๋ฐ ์ฌ์ฉ๋๋ ๋ชจ๋์
๋๋ค.
- ์ง๋ ฌํ : ํ์ด์ฌ ๊ฐ์ฒด๋ฅผ ๋ฐ์ดํธ ์คํธ๋ฆผ์ผ๋ก ๋ณํ
- ์ญ์ง๋ ฌํ : ๋ฐ์ดํธ ์คํธ๋ฆผ์ ๋ค์ ํ์ด์ฌ ๊ฐ์ฒด๋ก ๋ณํ
- pickle ๋ชจ๋์ ์ด๋ฌํ ๊ณผ์ ์ ์ํํ๋ ํจ์๋ค์ ์ ๊ณตํฉ๋๋ค.
pickle.dump(obj, file, protocol=None, *, fix_imports=True, buffer_callback=None) :
ํ์ด์ฌ ๊ฐ์ฒด **obj**๋ฅผ ๋ฐ์ดํธ ์คํธ๋ฆผ์ผ๋ก ์ง๋ ฌํํ์ฌ, ํ์ผ **file**์ ์ฐ๋ ์ญํ ์ ํฉ๋๋ค.
- obj: ์ง๋ ฌํํ ํ์ด์ฌ ๊ฐ์ฒด์ ๋๋ค.
- file: ๊ฐ์ฒด๋ฅผ ์ ์ฅํ ํ์ผ ๊ฐ์ฒด์ ๋๋ค. ํ์ผ์ ์ด์ง ๋ชจ๋๋ก ์ด๋ ค์ผ ํฉ๋๋ค.
- protocol: ์ง๋ ฌํ ํ๋กํ ์ฝ์ ๋ํ๋ด๋ ์ซ์์ ๋๋ค. ๊ธฐ๋ณธ๊ฐ์ 3์ด๋ฉฐ, ๋ ๋ฎ์ ๊ฐ์ ํธํ์ฑ์ ์ ๊ณตํ์ง๋ง, ๋ ๋์ ๊ฐ์ ๋ ํจ์จ์ ์ธ ์ง๋ ฌํ๋ฅผ ์ ๊ณตํฉ๋๋ค.
- fix_imports: ํ์ด์ฌ 2์์ ์์ฑ๋ ๊ฐ์ฒด๋ฅผ ๋ก๋ํ ๋, **True**๋ก ์ค์ ํ๋ฉด ๋ชจ๋ ์ด๋ฆ์ ๋ฐ๊พธ์ด ํธํ์ฑ์ ์ ์งํฉ๋๋ค. ๊ธฐ๋ณธ๊ฐ์ **True**์ ๋๋ค.
- buffer_callback: Python 3.10 ์ดํ์ ์ถ๊ฐ๋ ์ฝ๋ฐฑ ํจ์๋ก, ๊ฐ์ฒด๋ฅผ ์ง๋ ฌํํ๋ ๋์ ๋ฒํผ๋ฅผ ์กฐ์ํ ์ ์์ต๋๋ค.
#pickle ๋ชจ๋์ dump ํจ์๋ฅผ ์ฌ์ฉ(๋์
๋๋ฆฌ ๊ฐ์ฒด๋ฅผ ๊ทธ๋๋ก ํ์ผ์ ์ ์ฅ)
>>> import pickle
>>> f=open("test.txt",'wb') #๋ฐ์ด๋๋ฆฌ ์ฐ๊ธฐ๋ชจ๋
>>> data = {1:'python',2:'you need'}
>>> pickle.dump(data,f)
>>> f.close()
#ํ์ผ ๋ด์ฉ
#pickle๋ก ์ ์ฅ๋ ๋ฐ์ดํฐ๋ ์ง๋ ฌํ๋ ์ด์ง ํํ๋ก ์ผ๋ฐ์ ์ธ ํ
์คํธ ์๋ํฐ๋ก ์ฝ๊ธฐ ๋ถ์ ํฉ
ย? }?K?python๋ด?you need๋ดด]
#pickle.load()๋ฅผ ์ฌ์ฉํ์ฌ ์๋์๋ ๋์
๋๋ฆฌ ๊ฐ์ฒด ์ํ ๊ทธ๋๋ก ๋ถ๋ฌ์ด
>>> f=open("test.txt",'rb') #๋ฐ์ด๋๋ฆฌ ์ฝ๊ธฐ๋ชจ๋
>>> data = pickle.load(f)
>>> print(data)
{1: 'python', 2: 'you need'}
os
- ํ๊ฒฝ๋ณ์, ๋๋ ํฐ๋ฆฌ, ํ์ผ ๋ฑ์ OS ์์์ ์ ์ดํ ์ ์๊ฒ ํด์ฃผ๋ ๋ชจ๋
- os.environ: ๋ด ์์คํ ์ ํ๊ฒฝ๋ณ์๊ฐ์ ์๊ณ ์ถ์ ๋
- ํ์ฌ ์์คํ ์ ํ๊ฒฝ๋ณ์์ ๋ํ ์ ๋ณด๋ฅผ ๋์ ๋๋ฆฌ ํํ๋ก ๊ตฌ์ฑ๋ environ๊ฐ์ฒด๋ก ๋ฆฌํดํจ
- ๋ฆฌํด๋ฐ์ ๊ฐ์ฒด๋ ํธ์ถํ์ฌ ์ฌ์ฉํ ์ ์์
>>> import os
>>> os.environ
environ({'ALLUSERSPROFILE': 'C:\\\\ProgramData', 'APPDATA': 'C:\\\\Users\\\\gyugl\\\\AppData\\\\Roaming',,,,})
#ํ์ฌ ์์คํ
์ 'PATH' ํ๊ฒฝ ๋ณ์ ๊ฐ ์ป์
>>> os.environ['PATH']
- os.chdir : ๋๋ ํ ๋ฆฌ ์์น ๋ณ๊ฒฝ
- os.getcwd : ๋๋ ํ ๋ฆฌ ์์น ๋๋ ค๋ฐ๊ธฐ
>>> import os
>>> os.chdir("c:/windows")
>>> os.getcwd()
'c:\\\\windows'
- os.system : ์์คํ ๋ช ๋ น์ด ํธ์ถ
- ์์คํ ์์ฒด์ ํ๋ก๊ทธ๋จ์ด๋ ๊ธฐํ ๋ช ๋ น์ด๋ฅผ ํ์ด์ฌ์์ ํธ์ถ
#ํ์ฌ ๋๋ ํ ๋ฆฌ์์ ์์คํ
๋ช
๋ น์ด dir๋ช
๋ น ์คํ
>>> os.system("dir")
C ๋๋ผ์ด๋ธ์ ๋ณผ๋ฅจ: OS
๋ณผ๋ฅจ ์ผ๋ จ ๋ฒํธ: E006-4E30
c:\\Windows ๋๋ ํฐ๋ฆฌ
2024-02-16 ์ค์ 09:41 <DIR> .
2024-01-16 ์คํ 09:21 <DIR>
- os.popen : ์คํํ ์์คํ ๋ช ๋ น์ด์ ๊ฒฐ๊ณผ๊ฐ ๋๋ ค๋ฐ๊ธฐ
- ์์คํ ๋ช ๋ น์ด๋ฅผ ์คํํ ๊ฒฐ๊ณผ๊ฐ์ ์ฝ๊ธฐ ๋ชจ๋ ํํ์ ํ์ผ ๊ฐ์ฒด๋ก ๋ฆฌํด
#ํ์ผ ๊ฐ์ฒด๋ก ๋ฆฌํด
>>> f=os.popen("dir")
#์ฝ์ด๋ค์ธ ํ์ผ ๊ฐ์ฒด ๋ด์ฉ ๋ณด๊ธฐ
>>> print(f.read())
C ๋๋ผ์ด๋ธ์ ๋ณผ๋ฅจ: OS
๋ณผ๋ฅจ ์ผ๋ จ ๋ฒํธ: E006-4E30
c:\\python ๋๋ ํฐ๋ฆฌ
2024-02-29 ์ค์ 10:57 <DIR> .
2024-02-16 ์คํ 01:27 <DIR> .vscode
2024-02-16 ์คํ 02:00 <DIR> 0216
2024-02-23 ์คํ 05:17 <DIR> 0223
2024-02-27 ์ค์ 09:57 <DIR> 0226
2024-02-27 ์ค์ 10:06 <DIR> 0227
2024-02-28 ์คํ 05:00 <DIR> 0228
2024-02-29 ์ค์ 11:11 <DIR> 0229
2024-02-29 ์ค์ 10:57 0 a.txt
2024-02-28 ์คํ 01:34 <DIR> game
2024-02-29 ์ค์ 10:57 <DIR> temp
2024-02-29 ์ค์ 11:09 40 test.txt
2๊ฐ ํ์ผ 40 ๋ฐ์ดํธ
10๊ฐ ๋๋ ํฐ๋ฆฌ 247,870,214,144 ๋ฐ์ดํธ ๋จ์
zipfile
- ์ฌ๋ฌ ๊ฐ์ ํ์ผ์ zip ํ์์ผ๋ก ํฉ์น๊ฑฐ๋, ์ด๋ฅผ ํด์ ํ ๋ ์ฌ์ฉ
- Zipfile ๊ฐ์ฒด์ write() ํจ์๋ก ๊ฐ๋ณ ํ์ผ์ ์ถ๊ฐ
- extractall() ํจ์๋ก ๋ชจ๋ ํ์ผ ํด์
- ํน์ ํ์ผ๋ง ํด์ ํ๊ณ ์ถ๋ค๋ฉด extract() ์ฌ์ฉ
import zipfile
#ํ์ผ ํฉ์น๊ธฐ
with zipfile.ZipFile('mytext.zip','w') as myzip:
myzip.write('a.txt')
myzip.write('b.txt')
myzip.write('c.txt')
#ํด์ ํ๊ธฐ
with zipfile.ZipFile('mytest.zip') as myzip:
myzip.extractall()
#ํน์ ํ์ผ๋ง ํด์
with zipfile.ZipFile('mytest.zip') as myzip:
myzip.extract('a.txt')
#ํ์ผ ์์ถํ์ฌ ๋ฌถ๊ธฐ
with zipfile.ZipFile('mytext.zip','w',compression=zipfile.ZIP_LZMA, compresslevel=9) as myzip:
...
- compression (4๊ฐ์ง)
- ZIP_STORED
- ZIP_DEFLATED
- ZIP_BZIP2
- ZIP_LZMA
- compressionlevel: ํฉ์ถ์์ค ์๋ฏธ, 1~9 ์ฌ์ฉ (1์ ์๋๊ฐ ๋น ๋ฅด์ง๋ง ์์ถ๋ฅ ๋ฎ์, 9๋ ์๋ ๋๋ฆฌ์ง๋ง ์์ถ๋ฅ ๋์)
threading
- ํ๋ก์ธ์ค: ์ปดํจํฐ์์ ๋์ํ๊ณ ์๋ ํ๋ก๊ทธ๋จ
- ์ค๋ ๋๋ฅผ ์ฌ์ฉํ๋ฉด ํ ํ๋ก์ธ์ค ์์์ 2๊ฐ์ง ๋๋ ๊ทธ ์ด์์ ์ผ์ ๋์์ ์ํ(๋ณดํต 1ํ๋ก์ธ์ค 1๊ฐ์ง ์ผ)
- Without Threads:
- ํจ์ ํธ์ถ์ด ์์ฐจ์ ์ผ๋ก ์งํ๋๊ธฐ ๋๋ฌธ์ ํ๋์ ํจ์๊ฐ ์๋ฃ๋ ๋๊น์ง ๋ค์ ํจ์๊ฐ ํธ์ถ๋์ง ์์ต๋๋ค.
- ๊ฐ ํจ์ ํธ์ถ์ ์ด์ ํจ์์ ๋๊ธฐ๊ฐ ๋๋ ํ์ ์คํ๋ฉ๋๋ค.
- With Threads:
- ์ค๋ ๋๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ํจ์๋ฅผ ๋ณ๋ ฌ๋ก ํธ์ถํ๋ฉด ๊ฐ ์ค๋ ๋๊ฐ ๋ ๋ฆฝ์ ์ผ๋ก ๋์ํ๋ฏ๋ก, 1์ด ๋๊ธฐ๊ฐ ์๋ ํจ์ ํธ์ถ์ด ๋์์ ์ด๋ฃจ์ด์ง๋๋ค.
- ๊ฒฐ๊ณผ์ ์ผ๋ก ๊ฐ ์ค๋ ๋๊ฐ 1์ด ๊ฐ๊ฒฉ์ผ๋ก ํจ์๋ฅผ ์คํํ๊ฒ ๋ฉ๋๋ค.
#5๊ฐ์ ์ค๋ ๋๋ฅผ ์์ฑํ์ฌ ๋์์ ์์
์ ์ํํ๊ณ , ๊ฐ ์ค๋ ๋์ ์์
์ด ์ข
๋ฃ๋ ๋๊น์ง ๋ฉ์ธ ์ค๋ ๋๊ฐ ๋๊ธฐ
import time
import threading
def long_task():
for i in range(5):
time.sleep(1) #1์ด ๋๊ธฐ
print("working:%s\\n" %i)
print("start")
threads=[]
#5๊ฐ์ ์ค๋ ๋๋ฅผ ์์ฑํ๊ณ , ๊ฐ ์ค๋ ๋์ ํจ์ ํ ๋น
#์์ฑ๋ ์ค๋ ๋ ๊ฐ์ฒด๋ฅผ ๋ฆฌ์คํธ์ ์ถ๊ฐ
for i in range(5):
#long_task()
t=threading.Thread(target=long_task) #์ค๋ ๋๋ฅผ ์์ฑ > ์ค๋ ๋ ๊ฐ์ฒด๊ฐ ๋์ ์์
์ ๊ฐ๋ฅํ๊ฒ ํจ
threads.append(t)
#๊ฐ ์ค๋ ๋๋ฅผ ์คํ, ํจ์ ์ํ
for t in threads:
t.start() #์ค๋ ๋๋ฅผ ์คํ
#๋ฉ์ธ ์ค๋ ๋๋ ๊ฐ ์ค๋ ๋์ ์คํ์ด ์ข
๋ฃ๋ ๋๊น์ง ๊ธฐ๋ค๋ฆผ
for t in threads:
t.join() #join์ผ๋ก ์ค๋ ๋๊ฐ ์ข
๋ฃ๋ ๋๊น์ง ๋๊ธฐ
print("End")
tempfile
- ํ์ผ์ ์์๋ก ๋ง๋ค์ด์ ์ฌ์ฉํ ๋ ์ ์ฉํจ
- tempfile.mkstemp() : ์ค๋ณต๋์ง ์๋ ์์ํ์ผ์ ์ด๋ฆ์ ๋ฌด์์๋ก ๋ง๋ค์ด์ ๋ฆฌํด
- tempfile.TemporaryFile() : ์์ ์ ์ฅ๊ณต๊ฐ์ผ๋ก ์ฌ์ฉํ ํ์ผ ๊ฐ์ฒด๋ฅผ ๋ฆฌํด, ์ด ํ์ผ์ ๊ธฐ๋ณธ์ ์ผ๋ก ๋ฐ์ด๋๋ฆฌ ์ฐ๊ธฐ ๋ชจ๋(wb)๋ฅผ ๊ฐ์ง (f.close()๊ฐ ํธ์ถ๋๋ฉด ์ด ํ์ผ์ ์๋์ผ๋ก ์ญ์ ๋จ)
>>> import tempfile
>>> filename=tempfile.mkstemp()
>>> filename
(3, 'C:\\\\Users\\\\gyugl\\\\AppData\\\\Local\\\\Temp\\\\tmprkmga2cz')
>>> f = tempfile.TemporaryFile()
>>> f.close()
traceback
- ํ๋ก๊ทธ๋จ ์คํ ์ค ๋ฐ์ํ ์ค๋ฅ๋ฅผ ์ถ์ ํ๊ณ ์ ํ ๋ ์ฌ์ฉ
- traceback.format_exc() : ์ค๋ฅ ์ถ์ ๊ฒฐ๊ณผ๋ฅผ ๋ฌธ์์ด๋ก ๋ฆฌํด
import traceback
def a():
return 11/0
def b():
a()
def main():
try:
b()
except:
print("์ค๋ฅ ๋ฐ์")
print(traceback.format_exc())
main()
---
#์ถ๋ ฅ
์ค๋ฅ ๋ฐ์
Traceback (most recent call last):
File "c:\\python\\0229\\8.traceback.py", line 11, in main
b()
File "c:\\python\\0229\\8.traceback.py", line 7, in b
a()
File "c:\\python\\0229\\8.traceback.py", line 4, in a
return 11/0
~~^~
ZeroDivisionError: division by zero
json
- JSON ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ฒ ์ฒ๋ฆฌํ๊ณ ์ ์ฌ์ฉํ๋ ๋ชจ๋
- json.load(ํ์ผ๊ฐ์ฒด) : JSON ํ์ผ ์ฝ๊ธฐ, loadํจ์๋ ์ฝ์ ๋ฐ์ดํฐ๋ฅผ ๋์ ๋๋ฆฌ ์๋ฃํ์ผ๋ก ๋ฆฌํด
- json.loads(JSON๋ฌธ์์ด) : JSON ๋ฌธ์์ด(์์คํคํํ) > ๋์ ๋๋ฆฌ๋ก ๋ณํ
- json.dump(๊ฐ์ฒด, ํ์ผ๊ฐ์ฒด) : ๊ฐ์ฒด > JSON ํ์์ ๋ฌธ์์ด๋ก ๋ณํํ์ฌ ํ์ผ ๊ฐ์ฒด์ ๊ธฐ๋ก
- json.dumps(๊ฐ์ฒด) : ๊ฐ์ฒด >JSON ํ์์ ๋ฌธ์์ด๋ก ์ง๋ ฌํํ์ฌ ๋ฐํ(๋ฉ๋ชจ๋ฆฌ ์์์ ์ฌ์ฉ๋จ)
- ensure_ascii=False : ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ๋ ์์คํค ํํ๋ก ๋ณํํ์ง ์์
- indent=2 : JSON ๋ฌธ์์ด์ ๋ณด๊ธฐ ์ข๊ฒ ์ ๋ ฌ
- ๋์ ๋๋ฆฌ, ๋ฆฌ์คํธ, ํํ ๋ฑ์ ์๋ฃํ์ JSON ๋ฌธ์์ด๋ก ๋ฐ๊ฟ ์ ์์
>>> import json
>>> with open('myinfo.json') as f:
... data=json.load(f)
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
File "C:\\Users\\gyugl\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\json\\__init__.py", line 293, in load
return loads(fp.read(),
^^^^^^^^^
UnicodeDecodeError: 'cp949' codec can't decode byte 0xed in position 15: illegal multibyte sequence
#JSONํ์ผ ์ฝ์ ๋ json.load(ํ์ผ๊ฐ์ฒด)
>>> with open('myinfo.json','r',encoding='utf-8') as f:
#์ฝ์ ๋ฐ์ดํฐ๋ฅผ ๋์
๋๋ฆฌ ์๋ฃํ์ผ๋ก ๋ฆฌํด
... data=json.load(f)
...
>>> type(data)
<class 'dict'>
>>> data
{'name': 'ํ๊ธธ๋', 'birth': '0525', 'age': 30}
#ํ์ด์ฌ ๋์
๋๋ฆฌ ์๋ฃํ์ JSON ํ์ผ๋ก ๋ง๋ค๊ธฐ
>>> data ={'name': 'ํ๊ธธ๋', 'birth': '0525', 'age': 30}
>>> with open('myinfo.json','w') as f:
... json.dump(data,f)
#ํ์ด์ฌ ์๋ฃํ ๋์
๋๋ฆฌ๋ฅผ JSON ๋ฌธ์์ด๋ก ๋ง๋ค๊ธฐ
>>> d ={'name': 'ํ๊ธธ๋', 'birth': '0525', 'age': 30
}
#dump, dumps๋ ๋ฐ์ดํฐ๋ฅผ ์์คํค ํํ๋ก ์ ์ฅํจ
#(์ ๋์ฝ๋ ๋ฌธ์์ด์ ์์คํค ํํ๋ก ์ ์ฅํ์ฌ ๋ง์น ๊นจ์ง ๊ฒ์ฒ๋ผ ๋ณด์)
>>> json_data = json.dumps(d)
>>> json_data
'{"name": "\\\\ud64d\\\\uae38\\\\ub3d9", "birth": "0525", "age": 30}'
>>> json.loads(json_data)
{'name': 'ํ๊ธธ๋', 'birth': '0525', 'age': 30} #JSON๋ฌธ์์ด>๋์
๋๋ฆฌ ์ญ๋ณํ ์ ๋ฌธ์ ์์
#์์คํค ํํ์ ๋ฌธ์์ด๋ก ๋ณ๊ฒฝ๋๋ ๊ฒ์ ๋ฐฉ์ง
>>> d ={'name': 'ํ๊ธธ๋', 'birth': '0525', 'age': 30}
#๋์
๋๋ฆฌ > JSON ํ์ผ๋ก
>>> json_data = json.dumps(d,ensure_ascii=False)
>>> json_data
'{"name": "ํ๊ธธ๋", "birth": "0525", "age": 30}'
#JSON ๋ฌธ์์ด > ๋์
๋๋ฆฌ๋ก ๋ณํ
>>> json.loads(json_data)
{'name': 'ํ๊ธธ๋', 'birth': '0525', 'age': 30}
#JSON ๋ฌธ์์ด ์ ๋ ฌ
>>> d ={'name': 'ํ๊ธธ๋', 'birth': '0525', 'age': 30}
>>> print(json.dumps(d,indent=2,ensure_ascii=False))
{
"name": "ํ๊ธธ๋",
"birth": "0525",
"age": 30
}
#๋ฆฌ์คํธ, ํํ ๋ฑ์ ์๋ฃํ > JSON ๋ฌธ์์ด
>>> json.dumps([1,2,3])
'[1, 2, 3]'
>>> json.dumps((4,5,6))
'[4, 5, 6]'
urlib
- URL์ ์ฝ๊ณ ๋ถ์ํ ๋ ์ฌ์ฉ
#URL์ ํธ์ถํ์ฌ ์ํ๋ ๋ฆฌ์์ค ์ป๊ธฐ
import urllib.request
def get_wikidocs(page):
resource = '<https://wikidocs.net/{}>'.format(page)
with urllib.request.urlopen(resource) as s:
with open('wikidocs_%s.html' %page, 'wb') as f:
f.write(s.read())
get_wikidocs(12) #12 ์นํ์ด์ง๋ฅผ htmlํ์ผ๋ก ์ ์ฅํจ
webbrowser
- open_new( ) : ํ์ด์ฌ์ผ๋ก ์น ํ์ด์ง ์ ์ฐฝ์ผ๋ก ์ด๊ธฐ
- open( ) : ์ด๋ฏธ ์ด๋ฆฐ ๋ธ๋ผ์ฐ์ ๋ก ์ํ๋ ์ฌ์ดํธ ์ด๊ธฐ
import webbrowser
# ํ์ด์ฌ์ผ๋ก ์น ํ์ด์ง ์ ์ฐฝ์ผ๋ก ์ด๊ธฐ
webbrowser.open_new('<http://python.org>')
#์ด๋ฏธ ์ด๋ฆฐ ๋ธ๋ผ์ฐ์ ๋ก ์ํ๋ ์ฌ์ดํธ ์ด๊ธฐ
webbrowser.open('<http://python.org>')
5-7 ์ธ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
- ์ธ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ pip ๋๊ตฌ๋ฅผ ์ด์ฉํ์ฌ ์ค์นํด์ผ ํจ
pip
- ํ์ด์ฌ ๋ชจ๋์ด๋ ํจํค์ง๋ฅผ ์ฝ๊ฒ ์ค์นํ ์ ์๋๋ก ๋์์ฃผ๋ ๋๊ตฌ
- ์์กด์ฑ ์๋ ๋ชจ๋์ด๋ ํจํค์ง๋ฅผ ํจ๊ป ์ค์นํด์ฃผ๊ธฐ ๋๋ฌธ์ ํธ๋ฆฌํจ
pip install
- PyPI : ํ์ด์ฌ ์ํํธ์จ์ด๊ฐ ๋ชจ์ธ ์ ์ฅ๊ณต๊ฐ
pip install ํจํค์ง๋ช
pip uninstall
- ์ค์นํ ํจํค์ง๋ฅผ ์ญ์
pip uninstall ํจํค์ง๋ช
ํน์ ๋ฒ์ ์ผ๋ก ์ค์นํ๊ธฐ
pip install ํจํค์ง๋ช
==1.0.4
#๋ฒ์ ์๋ต ์ ์ต์ ๋ฒ์ ์ค์น
์ต์ ๋ฒ์ ์ผ๋ก ์ ๊ทธ๋ ์ด๋ํ๊ธฐ
- —upgrade ์ต์ ์ผ๋ก ํจํค์ง๋ฅผ ์ต์ ๋ฒ์ ์ผ๋ก ์ ๊ทธ๋ ์ด๋
pip install --upgrade ํจํค์ง๋ช
์ค์น๋ ํจํค์ง ํ์ธํ๊ธฐ
- ์ค์นํ ํจํค์ง ๋ชฉ๋ก ์ถ๋ ฅ
pip list
Package Version
------- -------
pip 24.0
Faker
- ํ ์คํธ์ฉ ๊ฐ์ง ๋ฐ์ดํฐ๋ฅผ ์์ฑํ ๋ ์ฌ์ฉํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
C:\\>pip install Faker
Faker ์ฌ์ฉํด๋ณด๊ธฐ
>>> from faker import Faker
>>> fake = Faker()
>>> fake.name()
'Stephanie Lane'
>>> fake = Faker('ko_KR')
>>> fake.name()
'์ค์ฑ์'
>>> fake.address()
'๊ฐ์๋ ๊ณผ์ฒ์ ์ธ์ฃผ94๊ธธ (์์ค์กฐ๋ฆฌ)'
>>> test_data = [(fake.name(), fake.address()) for i
in range(30)]
>>> test_data
[('๋ฌธํ์ง', '์ธ์ข
ํน๋ณ์์น์ ๋
ธ์๊ตฌ ๋์ฐ๋๊ฑฐ๋ฆฌ (์ฃผ์ ๊น๋ง์)'), ('๊นํ์ฐ', '์์ธํน๋ณ์ ์ค๊ตฌ ์์ด๋๊ธธ (ํ ์๊น์ค์)'), ('์ด์์', '๊ฒฝ๊ธฐ๋ ์์ฐ์ ๊ฐ๋ฝ89๊ฑฐ๋ฆฌ'), ('๊ฐ์งํธ', '๋ถ์ฐ๊ด์ญ์ ์๋๋ฌธ๊ตฌ ์ค๊ธ๋ก (์์ฒ ์ต๊น์)'), ('์ ๋ฏผ์ค', '์ธ์ข
ํน๋ณ์์น์ ๊ฐ์๊ตฌ ์์ฌ์ฒ83๊ฑฐ๋ฆฌ'), ('๊น์ง์', '์ ์ฃผํน๋ณ์์น๋ ์ฉ์ธ์ ๋ฐํฌ๋๋ก (์๊ฒฝ์ด์)'), ('๋ฐ์คํ', '๊ฒฝ์๋จ๋ ์์ฐ์ ์๋ก๊ตฌ ๊ฐ๋ฝ354๊ฑฐ ๋ฆฌ'), ('๊น๋ฏธ์', '๋ถ์ฐ๊ด์ญ์ ๋
ธ์๊ตฌ ์์ฌ์ฒ651๊ธธ'), ('์ํ์', '๊ฒฝ์๋ถ๋ ํ์ฃผ์ ๋ฐํฌ๋5๊ฑฐ๋ฆฌ'), ('ํ์์ฅ', '๊ด์ฃผ๊ด์ญ์ ๋งํฌ๊ตฌ ์์ฌ์ฒ345๊ฐ'), ('๋ฐํ์', '๊ฒฝ์ ๋จ๋ ์ฒญ์ฃผ์ ์๋น๊ตฌ ๋์ฐ๋๊ธธ (์์งํ๋ฉด)'), ('๋ฅ์ ์', '์ ๋ผ๋ถ๋ ์์ฐ์ ๋จ์๊ตฌ ๋
ผํ485๊ฑฐ๋ฆฌ (์์ฐ์ด๋ง์)'), ('์ฌ์ฌํ', '์ธ์ฐ๊ด์ญ์ ๋์๊ตฌ ๊ฐ๋จ๋0๊ธธ (์ฌํ์ฑ๋)'), ('์ ์์', '์ถฉ์ฒญ๋จ๋ ์ฉ์ธ์ ๊ธฐํฅ๊ตฌ ์์ดํธ์๊ฑฐ๋ฆฌ (์์ฒ ์๋)'), ('์ ์ ๋จ', '์ธ์ฐ๊ด์ญ์ ๊ธ์ฒ๊ตฌ ๋์ฐ๋613๊ฐ'), ('์ด์์ง', '๊ฐ์๋ ํฌ์ฒ์ ๋
ผํ732๊ฑฐ๋ฆฌ (์์ฃผ์กฐ ์๋ง์)'), ('์ด์์ค', '์ถฉ์ฒญ๋ถ๋ ๊ณ ์์ ์ผ์ฐ๋๊ตฌ ๋์ฐ๋๊ฐ'), ('๊น์๊ธธ', '๋ถ์ฐ๊ด์ญ์ ๊ฐ๋จ๊ตฌ ๊ฐํฌ๊ฑฐ๋ฆฌ (๊ฑด์ฐ๊น์)'), ('ํ์ ๋จ', '์ถฉ์ฒญ๋ถ๋ ์ฅ์ฒ๊ตฐ ์ ๋ฆ๊ธธ (์งํ๋จ ๋)'), ('๋จ์์', '๊ฒฝ์๋ถ๋ ์ฑ๋จ์ ์์ ๊ตฌ ๋์ฐ๋๊ฑฐ๋ฆฌ (ํ์ง์ฅ๋ฆฌ)'), ('์ด์์ ', '์ธ์ฐ๊ด์ญ์ ๊ธ์ฒ๊ตฌ ๊ฐํฌ8๊ธธ'), ('๊น์ฑ์', '์ ์ฃผํน๋ณ์์น๋ ์์์ ์ญ์ผ๊ฑฐ๋ฆฌ'), ('์ดํ์', '์์ธํน๋ณ์ ๋๋๋ฌธ๊ตฌ ํ
ํค๋๊ฑฐ๋ฆฌ (๋ํ๋ฏผ์)'), ('์ด์ง๋ฏผ', '์ ์ฃผํน๋ณ์์น๋ ์ฌ์ฃผ์ ๋ฐฑ์ ๊ณ ๋ถ๋ก (์ง ๋ฏผ์ด์ต๋ฉด)'), ('๊น์ง์ฐ', '๋ถ์ฐ๊ด์ญ์ ์ํ๊ตฌ ๋
ผํ๋ก ( ์ฑ๋ฏผ์ด๋ฆฌ)'), ('์ฅ์ ์ง', '๊ฒฝ๊ธฐ๋ ๊ด๋ช
์ ๊ฐ๋ฝ๊ฐ'), (' ๋ฅ์ํ', '๊ฐ์๋ ์ถฉ์ฃผ์ ๋
ผํ๊ฐ (์ ์์ต์)'), ('๋ฐฐ์ค ํ', '์ ์ฃผํน๋ณ์์น๋ ํํ์ ํ๋๊ฑฐ๋ฆฌ (๋์ค์ฐจ์)'), ('์ด์์ค', '๊ฒฝ๊ธฐ๋ ์์์ ํ๋ฌ๊ตฌ ๋ด์์ฌ๊ฐ (์ํฌ์๋)'), ('๊น๊ฑด์ฐ', '๋์ ๊ด์ญ์ ๊ธ์ฒ๊ตฌ ๊ฐ๋จ๋893๊ธธ (์์ฒ ์ต๋ฉด)')]
Faker ํ์ฉํ๊ธฐ
sympy
- ๋ฐฉ์ ์ ๊ธฐํธ(symbol)๋ฅผ ์ฌ์ฉํ๊ฒ ํด์ฃผ๋ ์ธ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
C:\\>pip install sympy
- solve( ) ํจ์๋ ๊ฒฐ๊ณผ๊ฐ์ผ๋ก ๋ฆฌ์คํธ๋ฅผ ๋ฆฌํดํจ (๋ฐฉ์ ์์ ํด๋ ์ฌ๋ฌ ๊ฐ์ผ ์ ์์)
from fractions import Fraction # fractions ๋ชจ๋์์ Fraction ํด๋์ค๋ฅผ ๊ฐ์ ธ์ด
import sympy # sympy ๋ชจ๋์ ๊ฐ์ ธ์ด
x = sympy.symbols("x") # x๋ฅผ ๊ธฐํธ๋ก ์ ์ธ
# x * (2/5) = 1760์ ๋ํ๋ด๋ ๋ฐฉ์ ์์ ์์ฑ
f = sympy.Eq(x * Fraction('2/5'), 1760)
# ๋ฐฉ์ ์์ ํ์ด์ x์ ๊ฐ์ ์ฐพ์
result = sympy.solve(f)
# ๋จ์ ๋ ๊ณ์ฐ
remains = result[0] - 1760
# ๊ฒฐ๊ณผ ์ถ๋ ฅ : ๋จ์ ๋์ 2640์ ์
๋๋ค.
print('๋จ์ ๋์ {}์ ์
๋๋ค.'.format(remains))
sympy ํ์ฉํ๊ธฐ
>>> import sympy
#2์ฐจ ๋ฐฉ์ ์์ ํด ๊ตฌํ๊ธฐ
>>> x=sympy.symbols("x")
>>> f=sympy.Eq(x**2,1)
>>> sympy.solve(f)
[-1, 1]
#์ฐ๋ฆฝ ๋ฐฉ์ ์์ ํด ๊ตฌํ๊ธฐ
>>> x,y = sympy.symbols('x,y')
>>> f1 = sympy.Eq(x+y, 10)
>>> f2 = sympy.Eq(x-y, 4)
>>> sympy.solve([f1,f2])
#๋ฏธ์ง์๊ฐ 2๊ฐ ์ด์์ด๋ฉด, ๊ฒฐ๊ณผ๊ฐ์ด ๋์
๋๋ฆฌ์
{x: 7, y: 3}