๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ฅผ ์์์ผํ๋ ์ด์
๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฒด(Object)๋ผ๋ ๋จ์๋ก ๋ฌถ๊ณ , ๊ทธ ๊ฐ์ฒด๋ค ๊ฐ ์ํธ์์ฉ์ผ๋ก ํ๋ก๊ทธ๋จ์ ๊ตฌ์ฑํ๋ ๋ฐฉ์์ OOP(Object Oriented Programming Language)๋ผ๊ณ ํ๋ค.
Python, Java, C++, Kotlin ๋ฑ ๋๋ถ๋ถ ์ฐ๋ฆฌ๊ฐ ์ ํ๋ ๋ชจ๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๊ฐ ์ฌ๊ธฐ์ ํด๋นํ๊ธฐ ๋๋ฌธ์, ์ธ์ด์ ๋ํด์ ๊ตฌ์ฒด์ ์ผ๋ก ๋ฐฐ์ฐ๊ธฐ ์ ์ ๊ณตํต ๊ฐ๋ ์ผ๋ก ์ก๊ณ ๊ฐ๋ฉด ์ข์ ๊ฒ ๊ฐ์์ ๊ณต๋ถํด๋ณด์๋ค. ๋๋ถ๋ถ์ ์ธ์ด๊ฐ OOP์ธ ๊น๋ญ์ ์ด๋ฏธ ์ด ์ฝ๋๋ฅผ ์์/์บก์ํ ๋ฑ์ ๋ฐฉ๋ฒ์ผ๋ก ์ฌ์ฌ์ฉ์ด ์ฉ์ดํ๊ณ , ์ฝ๋์ ์ ์ง๋ณด์์ฑ ๋ฐ ํ์ฅ์ฑ์ด ์ข๊ธฐ ๋๋ฌธ์ด๋ผ๊ณ ํ๋ค.
์ฐ์ ๋ง์ด ์ฌ์ฉํ์ง ์์ง๋ง OOP์ ๋ฐ๋๋๋ ์ธ์ด๋ ์ ์ฐจ ์งํฅ ํ๋ก๊ทธ๋๋ฐ(POP)๋ผ๊ณ ํ๋ค. ๋ช ๋ น์ด ์ค์ฌ์ผ๋ก ํ๋ก๊ทธ๋๋ฐ ๋์ด ์์ด ์ฝ๋ ์ฌ์ฌ์ฉ์ด ์ด๋ ต๊ณ , ์ ์ง ๋ณด์๊ฐ ์ด๋ ต๋ค๋ ๋จ์ ์ด ์๋ค. ์ด๋ ต๋ค๊ณ ์๋ ค์ง C ์ธ์ด๊ฐ ๋ฐ๋ก ์ด ํํ์ด๋ค.
๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ํต์ฌ ๊ฐ๋
OOP๋ ๋ฐ์ดํฐ๋ฅผ "๊ฐ์ฒด(Object)๋ผ๋ ๋จ์๋ก ๋ฌถ๋๋ค๋ ๊ฒ์ด ํต์ฌ์ด๋ค.
OOP์์ ๋ฑ์ฅํ๋ ํต์ฌ ์ฉ์ด๋ค์ ๋ค์๊ณผ ๊ฐ๋ค.
Class (ํด๋์ค) : ๊ฐ์ฒด๋ฅผ ๋ง๋ค๊ธฐ ์ํ ์ค๊ณ๋
Object (๊ฐ์ฒด) : ํด๋์ค์์ ๋ง๋ค์ด์ง ์ค์ฒด.
Attribute (์ดํธ๋ฆฌ๋ทฐํธ) : ๊ฐ์ฒด์ ์์ฑ (๋ฐ์ดํฐ)
Method (๋ฉ์๋) : ๊ฐ์ฒด๊ฐ ์ํํ ์ ์๋ ๋์ (ํจ์)
์๋ฅผ๋ค์ด, ๋ํ์ ์ธ OOP์ธ ํ์ด์ฌ์์์ ์ฌ๋ก๋ฅผ ํตํด ๊ฐ๊ฐ์ ๊ฐ๋ ์ ์ ์ํด๋ณด์.
# ํด๋์ค ์ ์
class Car:
def __init__(self, brand, model):
self.brand = brand # ์ดํธ๋ฆฌ๋ทฐํธ
self.model = model # ์ดํธ๋ฆฌ๋ทฐํธ
def drive(self): # ๋ฉ์๋
return f"{self.brand} {self.model} is driving!"
# ๊ฐ์ฒด ์์ฑ
car1 = Car("Toyota", "Corolla")
car2 = Car("Tesla", "Model S")
# ์ดํธ๋ฆฌ๋ทฐํธ ์ ๊ทผ ๋ฐ ๋ฉ์๋ ํธ์ถ
print(car1.brand) # Toyota
print(car2.model) # Model S
print(car1.drive()) # Toyota Corolla is driving!
1. ์ฐ์ , ์ ๋ฐ์ ์ธ ์ค๊ณ๋์ธ ํด๋์ค๋ฅผ ์ ์ํ์๋ค. ํด๋์ค๋ ํ์ค์ธ๊ณ์ ์ฌ๋ฌผ์ ์ฝ๋๋ฅผ ํํํ๊ธฐ ์ํด์ ์ฌ์ฉ๋๋ค๊ณ ์๊ฐํ๋ฉด ์ข๋ค. ์ด ์์์์๋ '์๋์ฐจ'๋ผ๋ ์ฌ๋ฌผ์ ์ฝ๋๋ก ํํํ๊ธฐ ์ํด 'Car'์ด๋ผ๋ ํด๋์ค๋ฅผ ์์ฑํ๋ค. ํด๋์ค ๋ด๋ถ์๋ ์์ฑ์(__init__)์ ๋ฉ์๋(drive())๊ฐ ํฌํจ๋์ด ์๋ค.
*๋ณดํต ํด๋์ค๋ ๋๋ฌธ์๋ก ์์ํ๋ค.
2. ์์ฑ์(Constructor)๋ ๋ฉ์๋ ์ค ํ๋๋ก, ์กฐ๊ธ์ ํน๋ณํ ๋ฉ์๋์ด๋ค. ๊ฐ์ฒด๊ฐ ์์ฑ๋ ๋ ์๋์ผ๋ก ํธ์ถ๋๋ ํน์ฑ์ ๊ฐ์ง๋ฉฐ, ์ฃผ๋ก ๊ฐ์ฒด์ ๋ณ์(์์ฑ)์ ์ด๊ธฐํ๋ฅผ ๋ด๋นํ๋ค. ํ์ด์ฌ์์๋ __init__๋ฅผ ์ฌ์ฉํ์ง๋ง, ๋๋ถ๋ถ์ ์ธ์ด์์๋ ์์ฑ์์ ์ด๋ฆ์ด ํด๋์ค ์ด๋ฆ๊ณผ ๊ฐ๋ค๊ณ ํ๋ค. ์ด ์์์์๋ __init ๋ฉ์๋๋ฅผ ํด๋์ค์์ ์ฒซ๋ฒ์งธ๋ก ์ ์ํ์๊ณ , ํ์ฌ ๊ฐ์ฒด ์์ฒด๋ฅผ ๊ฐ๋ฆฌํค๋ ์ฐธ์กฐ์ฉ ๋งค๊ฐ๋ณ์์ธ self์ ์๋์ฒด์ ๋ํ ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋ ์ ๋ฌํ ๋ฐ์ดํฐ๋ค์ธ brand์ model์ด ๋งค๊ฐ๋ณ์๋ก ๋ค์ด๊ฐ์๋ค.
2-1. ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ ์ฝ๋์ธ car1= Car("Toyota, "Corolla")๋ฅผ ํตํด์ ์์ฑ์๊ฐ ์๋ํ๋ ๋ฐฉ์์ ์ ์ ์๋ค. Car()๋ฅผ ํธ์ถํ๋ฉด __init__๊ฐ ์๋์ผ๋ก ํธ์ถ๋์ด ์คํ๋๋ค. self๋ ์ฐธ์กฐ์ฉ์ด๋ ๋๊ธฐ๊ณ , Toyota๊ฐ brand์, Corolla๊ฐ model์ ์ ์ฅ๋ car1์ด๋ผ๋ ๊ฐ์ฒด๊ฐ ์๊ฒจ๋๋ค.
3. ๋ฉ์๋๋ ๊ฐ์ฒด๊ฐ ์ํํ ์ ์๋ ๋์(ํจ์)์ด๋ค. ()๊ฐ ๋ค์ ๋ถ์ด์์ผ๋ฉด ๋ฉ์๋๋ผ๊ณ ์๊ฐํด๋ ์ข๋ค. ํด๋์ค ๋ด๋ถ์์ ์ ์๋๊ณ , ์ฒซ๋ฒ์งธ ๋งค๊ฐ๋ณ์๋ก ํญ์ self๋ฅผ ๋ฐ๋๋ค. ๊ฐ์ฒด ๋ด์์ ๋ฉ์๋๋ฅผ ์ํํ๊ณ ์ถ์ผ๋ฉด ๊ฐ์ฒด์ด๋ฆ ๋ค์ .(dot)์ ๋ถ์ด๊ณ ๋ฉ์๋ ์ด๋ฆ์ ๋ถ์ฌ๋ฃ์ด๋ณด์.
3-1. def drive(self): return f"{self.brand} {self.model} is driving!" ์ฝ๋๋ฅผ ๋ณด์. drive()๊ฐ ๋ฉ์๋ ์ด๋ฆ์ด๊ณ , ์ด ๋ฉ์๋๊ฐ ์คํ๋๋ฉด ๋ธ๋๋๋ช +๋ชจ๋ธ๋ช ๊ณผ ํจ๊ป ์ด์ ์ค์ด๋ผ๋ ๋ฉํธ๊ฐ ํ๋ฆฐํธ ๋ ๊ฒ์ด๋ค.
3-2. print(car1.drive()) ์ฝ๋๋ฅผ ๋ณด์. car1 ๊ฐ์ฒด์ ๋ํด์ .(dot)์ ๋ถ์ด๊ณ drive()๋ผ๋ ๋ฉ์๋๋ฅผ ๋ํ๊ณ , ์ด๊ฒ์ print()๋ผ๋ ํ๋ฆฐํธํ๋ผ๋ ๊ธฐ๋ณธ ํ์ด์ฌ ๋ฉ์๋์ ๋ฃ์๋ค. ๊ฒฐ๊ณผ๋ ์์ Toyota Corolla is driving์ผ๋ก ๋์ฌ ๊ฒ์ด๋ค.
4. ์ดํธ๋ฆฌ๋ทฐํธ(Attribute)๋ ๊ฐ์ฒด์ ์์ฑ(๋ฐ์ดํฐ)๋ก, ํด๋์ค ๋ด๋ถ์์ self๋ฅผ ํตํด์ ์ ์๋๋ฉฐ ๊ฐ์ฒด๋ณ๋ก ๊ณ ์ ํ ๊ฐ์ ๊ฐ์ง ์ ์๋ค.
4-1. ์๋ฅผ ๋ค์ด, ์ด ์ฝ๋์์๋ car1 ๊ฐ์ฒด์ brand ์ดํธ๋ฆฌ๋ทฐํธ๋ Toyota์ด๊ณ , car2 ๊ฐ์ฒด์ model ์ดํธ๋ฆฌ๋ทฐํธ๋ Model S๋ผ๊ณ ํ ์ ์๋ค. ํ์ธํด๋ณด๊ณ ์ถ์ผ๋ฉด ์ญ์ print(car1.brand)์ฒ๋ผ ๊ฐ์ฒด ๋ค์ .(dot)์ ๋ถ์ด๊ณ ํ์ธํ๊ณ ์ถ์ ๋งค๊ฐ๋ณ์๋ฅผ ๋ถ์ด๋ฉด ์ ์ ์๋ค.
4-2. ์ด๋ฏธ ๊ฐ์ฒด๊ฐ ์์ฑ๋ ํ์, ์๋ก์ด ์ดํธ๋ฆฌ๋ทฐํธ๋ฅผ ์ถ๊ฐํ ์๋ ์๋ค. ์๋ฅผ ๋ค์ด, car1์ ์์ ๋นจ๊ฐ์์ด๋ผ๊ณ ์ถ๊ฐํ๊ณ ์ถ์ผ๋ฉด car1.color = "Red" ๋ผ๊ณ ํ๋ฉด ์ถ๊ฐ๊ฐ ๋ ์ ์๋ค.
์ด ์ฝ๋๋ฅผ ํตํด์ ์๊ฒ ๋ ์๋ก์ด OOP์ ๋ํ ์ฉ์ด๋ค์ ๋ค์ ์ ๋ฆฌํด๋ณด์!
1. Variable vs Attribute
Variable (๋ณ์): ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๊ณต๊ฐ์ผ๋ก, OOP ๋ฟ๋ง ์๋๋ผ ํ๋ก๊ทธ๋๋ฐ ์ ๋ฐ์์ ํ์ฉ๋๋ ์ผ๋ฐ์ ์ธ ๊ฐ๋ ์ด๋ค.
* Atrribute(์์ฑ): ์์์ ์์ฑ์ ํด๋์ค ๋๋ ๊ฐ์ฒด์ ์์ฑ(๋ฐ์ดํฐ)๋ฅผ ์๋ฏธํ๋ค๊ณ ํ์๋ค. ์ฆ ์์ฑ์ ๊ฐ์ฒด์ ๋ณ์๋ผ๊ณ ์๊ฐํ๋ฉด ๋๋ค. ๋ณ์๋ ๋ฉ์๋ ์, ํด๋์ค ๋ฐ์ด๋ ์ด๋์๋ ์ฌ์ฉ ๊ฐ๋ฅํ๋ ์์ฑ์ ํด๋์ค๋ ๊ฐ์ฒด ๋ด๋ถ์ ์กด์ฌํ๋ค๋ ์ฐจ์ด์ ์ด ์๋ค๊ณ ํ๋ค.
* ์๋ฅผ ๋ค์ด, ์๋ ์ฝ๋์์ x๋ ๊ทธ๋ฅ Variable์ด์ง๋ง, self.name๊ณผ self.age๋ Person class์์ ์์ฑํ๋ ๊ฐ์ฒด๋ค์ ์์ฑ(Attribute)์ธ ๊ฒ์ด๋ค.
# ์ผ๋ฐ ๋ณ์
x = 10 # ๊ทธ๋ฅ ๋ณ์ (Variable)
# ํด๋์ค์ ๊ฐ์ฒด์ ์์ฑ (Attribute)
class Person:
def __init__(self, name, age):
self.name = name # name์ ๊ฐ์ฒด์ ์์ฑ(Attribute)
self.age = age # age๋ ์์ฑ(Attribute)
2. Object vs Instance
ํด๋์ค๊ฐ ์ค๊ณ๋๋ผ๋ฉด ๊ฐ์ฒด(Object)๋ ์ค๊ณ๋๋ก ๋ง๋ ์ ํ์ด๋ผ๊ณ ์์์ ์ธ๊ธํ๋ค. ์ธ์คํด์ค(Instance)๋ ํด๋์ค๋ผ๋ ์ค๊ณ๋๋ก ๋ง๋ ๊ตฌ์ฒด์ ์ธ ์ค์ฒด(๊ฐ์ฒด)๋ฅผ ์๋ฏธํ๋ค. ์ค์ ๋ก ๋์ ๊ตฌ๋ถ๋์ง ์๊ณ ์ฌ์ฉ๋๊ธฐ๋ ํ์ง๋ง ๊ฐ๋ ์ ์ผ๋ก๋ ์ฝ๊ฐ ๋ค๋ฅด๋ค๊ณ ํ๋ค.
3. Parameter(๋งค๊ฐ๋ณ์)์ Argument(์ธ์)
๋์ ๋ฉ์๋ ์๊ธฐํ๋ค๊ฐ ๋์จ ๊ฐ๋ ์ด๋ค. ๋งค๊ฐ๋ณ์๋ ๋ฉ์๋๋ฅผ ์ ์ํ ๋ ๋ฐ์ ๊ฐ์ ์ด๋ฆ์ ์ง์ ํ๋ ๊ฒ์ด๊ณ , ์ธ์๋ ํจ์๋ฅผ ํธ์ถํ ๋ ์ค์ ๋ก ์ ๋ฌํ๋ ๊ฐ์ ์๋ฏธํ๋ค.
์๋ ์ฝ๋์์๋ name์ด ๋งค๊ฐ๋ณ์, Bob์ด ์ธ์๊ฐ ๋๋ ๊ฒ์ด๋ค.
def greet(name): # 'name'์ ๋งค๊ฐ๋ณ์(Parameter)
print(f"Hello, {name}!")
greet("Bob") # "Bob"์ ์ธ์(Argument)
๋ค์ ํธ์๋ OOP ์ธ์ด๋ค์ ์ฅ์ ์ ๋ํด์ ์ ๋ฆฌํด๋ณด๊ฒ ๋ค!
์บก์ํ / ์์ / ๋คํ์ฑ / ์ถ์ํ