SMALL
1. 객체지향 프로그래밍
객체지향 프로그래밍(Object-Oriented Programming, OOP)은 소프트웨어를 설계하고 구현하는 데 사용되는 중요한 프로그래밍 패러다임 중 하나입니다. 이 패러다임은 프로그램을 "객체"라고 불리는 독립적인 개체로 나누고, 이러한 객체들 간의 상호작용을 통해 프로그램을 구성하는 개발 방법론입니다.
- 절차지향 프로그래밍
절차지향프로그래밍은 프로그램을 작성할 때 일련의 절차 또는 단계에 따라 코드를 구성하는 방식입니다. 이러한 단계나 절차들은 주로 함수나 서브루틴으로 나누어져 있으며, 각각의 함수는 특정한 작업을 수행합니다. 주로 '입력 - 처리 - 출력'의 순차적인 절차를 따르며, 코드를 위에서부터 아래로 실행하면서 데이터를 처리하는 방식으로 동작합니다. C 언어와 같은 프로그래밍 언어는 주로 절차지향적인 스타일을 따릅니다.
(프로그램을 짜는 방식이라고 할 수 있습니다. 따라서 자바나 파이썬에도 다 사용됩니다.) - 함수형 프로그래밍
함수형프로그래밍은 함수(function)를 최우선, 기반으로 취급하여 프로그램을 작성하는 패러다임입니다. 함수는 다른 함수에 전달되거나 반환될 수 있으며, 함수들 간의 조합을 통해 복잡한 작업을 수행합니다. 상태를 변경하지 않고 데이터를 처리하고, 부작용(side effect)을 최소화하려는 노력이 있습니다. 함수형 언어로는 Haskell, Lisp, Clojure 등이 있으며, 몇몇 다른 언어들도 함수형 프로그래밍을 지원합니다. 함수형 프로그래밍은 병렬처리와 상태 관리에 용이하며, 함수들을 조합하여 간결하고 안정적인 코드를 작성하는데 도움이 됩니다.
( 함수가 함수를 불러와서 쓰는 경우입니다.)
1. 클래스 만들기
파이썬에서 클래스를 정의하려면 class 키워드를 사용합니다. 클래스 이름은 관례적으로 대문자로 시작하는 것이 좋습니다. 클래스 내부에는 속성(멤버 변수)과 메서드(멤버 함수)를 정의할 수 있습니다.
- 객체(Object): 객체는 현실 세계에서의 실제 개체나 추상적인 개념을 모델링한 것입니다. 예를 들어, 자동차, 사람, 은행 계좌, 성적 등이 객체가 될 수 있습니다. 눈에 보이는 것과 보이지 않는 것 다 가능합니다. 객체를 만들 때는 그 대상을 설명하기 위한 명사, 표현하기 위한 동사가 필수적으로 필요합니다. 데이터(속성, 상태)와 메서드(동작, 함수)로 표현됩니다. 즉, 메모리에 올라가있는 변수와 함수의 집합이라고 할 수 있고, 필수적으로 타이틀 이름이 있습니다.
- 변수 : 데이터(속성, 상태)
- 메서드(함수) : 행동 명사 + 동사 - 클래스(Class): 클래스는 객체를 만들기 위한 템플릿 또는 설계도입니다. 메모리에 올라가기 전에 짜는 과정입니다. 클래스는 객체의 공통 속성과 동작을 정의하며, 객체를 생성하는데 사용됩니다. 예를 들어, "자동차" 클래스는 모든 자동차 객체가 가져야 하는 속성(색상, 속도)과 메서드(주행, 멈춤)를 정의할 수 있습니다.
(예) 클래스: 자동자 / 변수: 속도, 방향 / 함수: 코너링한다, 앞으로 간다, 뒤로 간다
클래스가 메모리에 올라가면 객체가 됩니다. 변수가 이 객체를 가리키게 됩니다. - 인스턴스(Instance): 클래스를 기반으로 실제로 생성된 객체를 인스턴스라고 합니다. 클래스는 여러 인스턴스를 생성할 수 있으며, 각 인스턴스는 독립적인 데이터와 메서드를 가집니다.
<< 클래스 속성(멤버 변수) 정의 >>
class 클래스이름:
속성1 = 초기값1 # 함수 바깥에 있기에 전역(global)변수
속성2 = 초기값2 # 객체를 만들지 않아도 사용가능
<< 생성자 메서드 (생략 가능) >>
def __init__(self, 매개변수1, 매개변수2, ...)
self.속성1 = 매개변수1 # 인스턴스 속성 초기화
self.속성2 = 매개변수2
<< 메서드(멤버 함수) 정의 >>
def 메서드1(self, 매개변수1, 매개변수2, ...):
pass # 메서드 동작 정의
def 메서드2(self, 매개변수1, 매개변수2, ...):
pass # 메서드 동작 정의
- 속성(Attributes) 또는 멤버 변수(Fields): 객체는 데이터를 저장하기 위한 속성을 가집니다. 이러한 속성은 객체의 상태나 특성을 나타내며 변수로 표현됩니다. 예를 들어, 자동차 객체의 속성은 색상, 속도, 모델 등이 될 수 있습니다.
- 메서드(Methods) 또는 멤버 함수(Functions): 객체는 데이터를 조작하거나 특정 작업을 수행하기 위한 메서드를 포함합니다. 이러한 메서드는 함수와 비슷하게 동작하지만, 객체의 상태에 접근하고 조작할 수 있습니다. 자동차 객체의 메서드로는 주행, 정지, 경적 울리기 등이 있을 수 있습니다.
2. 객체 인스턴스 생성하기
클래스를 정의한 후에는 이를 기반으로 객체(인스턴스)를 생성할 수 있습니다.
| 구분 | 인스턴스 변수 | 클래스 변수 |
| 목적 | 인스턴스마다 다른 값을 지정 | 인스턴스가 공유하는 값을 저장 |
| 접근방식 | 인스턴스 접근 (ㅇ) 클래스 접근(x) |
인스턴스 접근 (ㅇ) 클래스 접근 (ㅇ) _권장 |
1. 객체 인스턴스 생성하기
class Dog:
pass -> 내용이 없는 블록을 만들 때 사용
Rucy = Dog() -> 객체로 메모리에 올리기
Rucy = Dog() -> 메모리에 클래스를 객체로 올리기
print(Rucy) -> 메모리주소값 출력
print(type(Rucy)) -> 객체타입 출력
print(id(Rucy)) -> 객체 주소값 출력
PPomi = Dog()
print(PPomi)
print(type(PPomi))
print(id(PPomi))
| <__main__.Dog object at 0x7fac909112a0> <class '__main__.Dog'> 140379136529056 <__main__.Dog object at 0x7fac909103d0> <class '__main__.Dog'> 140379136525264 |
2. 객체 속성 초기화
객체를 생성한 후에는 객체의 속성을 초기화할 수 있습니다.
이를 위해 연산자를 사용하여 객체의 속성에 접근하고 값을 할당합니다.
class Dog:
name = ''
age = 0
family = ''
Rucy = Dog()
print(Rucy.name)
print(Rucy.age)
print(Rucy.family)
| 0 |
ㄴ객체는 저장되었지만 변수는 비어있습니다.
class Dog:
<< 변수 선언, 값없음, 비어있음 >>
name = ''
age = 0
family = ''
<< 객체생성 >>
Rucy = Dog()
<< 값을 저장 >>
Rucy.name = '루시'
Rucy.age = '14'
Rucy.family = '포메'
<< 값호출, 출력 >>
print(Rucy.name)
print(Rucy.age)
print(Rucy.family)
| 루시 14 포메 |
ㄴ변수에 값을 넣으면 호출할 수 있습니다.
class Dog:
name = ''
age = 0
family = ''
PPomi = Dog()
PPomi.name = '뽀미'
PPomi.age = '8'
PPomi.family = '폼피츠'
| 뽀미 8 폼피츠 |
ㄴ각각 다른 객체로 다른 메모리에 저장됩니다.
3. 객체 메서드 호출
객체의 메서드를 호출하려면 객체와 메서드를, 연산자를 사용하여 호출합니다.
class Dog:
name = ''
age = 0
family = ''
# 일반 함수에서 매개변수가 비어있어도 되지만,
클래스에 메서드는 매개변수가 없을시,
self로 입력해야 합니다.
# 메소드가 전역 변수들을 공유하기 때문에
def eat(self):
print('사료를 먹습니다!')
Rucy.eat() # 객체 메서드 호출
PPomi.eat()
| 사료를 먹습니다. 사료를 먹습니다. |
3. 생성자
파이썬에서 생성자(Constructor)는 클래스의 인스턴스가 생성될 때 자동으로 호출되는 특별한 메서드입니다. 생성자는 객체의 초기화를 담당하며, 객체가 생성될 때 필요한 속성을 초기화하고 설정하는 역할을 합니다. 파이썬에서 생성자 메서드는 __init__라고 이름이 정해져 있습니다. .
class 클래스이름:
def __init__(self, 매개변수1, 매개변수2):
self.속성1 = 매개변수1
self.속성2 = 매개변수2
# __init__ : 변수를 자동으로 호출, 초기화하는 메서드 ( 인스턴스 속성 초기화 )
# self: 다른 함수에서도 사용하는 전역(global)변수로 만들겠다.
- 생성자 메서드의 정의
생성자 메서드는 클래스 내부에 def __init__(self, 매개변수1, 매개변수2, ...):와 같이 정의됩니다. __init__ 메서드의 첫 번째 매개변수로 self를 사용합니다. self는 생성된 인스턴스 자신을 가리키며, 인스턴스의 속성을 초기화하는 데 사용됩니다. 나머지 매개변수는 인스턴스를 초기화하는 데 필요한 데이터를 전달받습니다. - 인스턴스의 생성
생성자를 호출하여 클래스의 인스턴스를 생성합니다. 생성자 메서드는 클래스의 이름을 호출하여 객체를 생성합니다. - 속성 초기화
생성자 메서드 내부에서 인스턴스의 속성을 초기화합니다. 속성은 self를 사용하여 접근하고 설정합니다. 이렇게 초기화된 속성은 객체가 생성될 때마다 다른 값을 가질 수 있습니다.
class Dog:
def __init__(self):
print(self, 'init 호출!')
Rucy = Dog()
| <__main__.Dog object at 0x7fac90911660> init 호출! |
ㄴ self 를 호출하면 주소값이 나옵니다.
class Dog:
def __init__(self):
self.name = ''
self.age = 0
Rucy = Dog()
print(Rucy) # 객체의 주소값
print(Rucy.name) # 초기화 했기 때문에 비어있음
print(Rucy.age) # 초기화 했기 때문에 비어있음
PPomi = Dog()
print(PPomi) # 객체의 주소값
print(PPomi.name) # 초기화 했기 때문에 비어있음
print(PPomi.age) # 초기화 했기 때문에 비어있음
| <__main__.Dog object at 0x7faca1178f10> 0 <__main__.Dog object at 0x7faca1179000> 0 |
class Dog:
def __init__(self):
self.name = ''
self.age = 0
family = '' # self가 없어서 다른 함수에서 부를 수 없음 (주소값이 없음)
self.temp = family # 변수에 넣고 self를 붙이면 호출이 됨
print(Rucy.family) # 부르면 에러가 남, 접근이 안됨
print(Rucy.temp) # 실행 가능
| 오류 비어있음 |
class Dog:
def __init__(self, name, age, nickname='닉네임없음'):
self.name = name
self.age = age
self.nickname = nickname
# Rucy = Dog()
Rucy = Dog('루시', 14, '포메')
print(Rucy.name)
print(Rucy.age)
print(Rucy.nickname)
PPomi = Dog('뽀미', 8) # family에 기본값이 들어감
print(PPomi.name)
print(PPomi.age)
print(PPomi.nickname)
| 루시 14 포메 뽀미 8 족보없음 |
4. 메서드
메서드(Method)는 객체지향 프로그래밍(OOP)에서 사용되는 함수와 비슷한 개념이지만, 클래스 내부에 정의되어 특정 객체에 연결된 함수입니다. 메서드는 해당 클래스의 모든 객체에서 공유되며, 객체의 동작을 정의하거나 특정 작업을 수행하는 데 사용됩니다. (누가 써야 하는지가 정해진, 객체가 정해진 메서드, 클래스 안에서 공유, 객체가 다 공유함)
1. 메서드 정의
class Counter:
def __init__(self): # 생성자 (켜면 0으로 뜨게 초기화)
self.num = 0
def increment(self): # 메서드 (버튼을 누르면 +1)
self.num += 1
def decrement(self): # 메서드 (버튼을 누르면 -1)
self.num -= 1
def current_value(self): # 메서드 (현재 값을 화면에 보여주기)
return self.num
def reset(self): # 메서드 (초기화버튼을 누르면 0으로 리셋)
self.num = 0
KBbank = Counter() # Counter 클래스를 가진 KBbank 객체 만들기
print(KBbank.num)
print(KBbank.current_value())
KBbank.increment()
KBbank.increment()
KBbank.increment()
print(KBbank.current_value()) # increment 버튼 3번 누르고 출력
KBbank.decrement()
print(KBbank.current_value()) # decrement 버튼 1번 누르고 출력
# 클래스 주의사항!
# 변수의 값을 바로 바꾸지 않기
# 메소드를 통해서 값을 바꿔라
# 메소드를 통해서 확인하라
# 다양한 방어 코드를 가진 메소드 활용
| 0 0 3 2 |
HanaBank = Counter() # Counter 클래스를 가진 HanaBank 객체 만들기
print(HanaBank.current_value())
HanaBank.increment()
HanaBank.increment()
HanaBank.increment()
HanaBank.increment()
HanaBank.increment()
print(HanaBank.current_value())
HanaBank.reset()
print(HanaBank.current_value())
print(f'현재 대기인원 : {HanaBank.current_value()}')
| 0 5 0 현재 대기인원 : 0 |
2. 메서드 타입
- 인스턴스 메서드(Instance Method): 객체의 상태를 조작하거나 객체에 특정 작업을 수행하는 메서드입니다. 대부분의 클래스 메서드는 인스턴스 메서드입니다. 위의 예제에서 보여진 __init__ 메서드도 인스턴스 메서드입니다.
- 클래스 메서드(Class Method): 클래스 레벨에서 동작하며, 모든 인스턴스가 공유하는 메서드입니다. 클래스 메서드는 @classmethod 데코레이터를 사용하여 정의하며, 첫 번째 매개변수로 cls를 사용합니다. (cls 이름 바꿀 수 있음)
- 정적 메서드(Static Method): 특정 클래스나 인스턴스와 관련이 없는 메서드로, 클래스 내부에 정의되어 있지만 클래스나 인스턴스와 독립적으로 호출될 수 있습니다. 정적 메서드는 @staticmethod 데코레이터를 사용하여 정의합니다.
구분 동적 메소드 정적 메소드 데코레이터 @classmethod @staticmethod 호출 인스턴스, 클래스
생성된 인스턴스 없어도 호출 가능인스턴스, 클래스
생성된 인스턴스 없어도 호출 가능매개변수 self (x) cls (o) 작성하지 않아도 됨
class Math:
def add(self, x, y):
return x + y
def multiply(self, x, y):
return x * y
math = Math() # 객체 생성
result1 = math.add(10, 3)
print(result1)
result2 = math.multiply(10, 3)
print(result2)
# Q. 수학적 식은 코드를 입력해서 사용하면되지 굳이 왜 객체를 만들까?
# A. 그래서 클래스 메소드가 등장
| 13 30 |
class Math:
@classmethod # 클래스 메소드 메모리에 입력
# 알고리즘이 들어있음
# 밑에 함수가 미리 제공된 기능을 제공받아 변화가 일어남
# 객체를 만들지 않고서도 클래스 메모리에 올라가있음 (객체 클래스 X)
def add(cls, x, y): # self -> cls 변경해줘야 함
return x + y
@classmethod
def multiply(cls, x, y):
return x * y
print(Math.add(10,3)) # 객체 생성하지 않고 클래스 이름으로 바로 접근
print(Math.multiply(10,3)) # 객체 생성하지 않고 클래스 이름으로 바로 접근
| 13 30 |
class Math:
str1 = 'Hello! ' # 클래스 메모리에 문자열을 저장
@classmethod
def hello(cls,name):
# return str1 + name # 클래스 매소드에 저장 (클래스에 있는 str1을 호출하면 오류)
return cls.str1 + name # cls: 클래스가 저장되어 있는 클래스 메모리로 찾아가게 됨
print(Math.hello('김사과'))
| Hello! 김사과 |
class Math: # 클래스 영역에 저장
def __init__(self, x,y):
self.x = x
self.y = y
# def add(self, x, y):
# return x + y
# def multiply(self, x, y):
# return x * y
def add(self):
return self.x + self.y
def multiply(self, x, y):
return self.x * self.y # static이랑 자료를 주고받을 수가 없음 (여기는 self가 있고 static에는 self가 없음)
@staticmethod # 객체를 생성하지 않고 메모리에 올라감, 바로 사용 가능
def substract(x, y) # 다른 자료와 소통을 하지 않고 독립적으로 관련 없는 메소드를 만들 때
return x * y
math = Math(10, 3) # 객체를 만들어서 사용가능한 상황
print(math.add())
print(math.multiply())
print(math.subtract()) # 오류
print(math.subtract(10,3)) # 값이 제대로 출력
class Calculator:
def add(self, x, y):
return x + y
@classmethod
def subtract(cls, x, y):
return x - y
@staticmethod
def multiply(x, y):
return x * y
# 인스턴스 생성
calc = Calculator()
# 인스턴스 메서드 호출
result1 = calc.add(5, 3)
print(result1)
# 클래스 메서드 호출
result2 = Calculator.subtract(10, 4)
print(result2)
# 정적 메서드 호출
result3 = Calculator.multiply(6, 2)
print(result3)
| 8 6 12 |
5. 클로저
클로저(Closure)는 프로그래밍 언어에서 중요한 개념 중 하나로, 함수와 그 함수가 참조하는 외부 변수(또는 자유 변수) 사이의 관계를 나타냅니다. 클로저는 함수의 내부에서 정의된 함수로, 내부 함수가 외부 함수의 변수에 접근할 수 있고, 외부 함수는 내부 함수를 반환할 수 있습니다. 이로 인해 함수와 그 함수가 참조하는 상태(변수)를 함께 저장하고 유지할 수 있습니다.
함수 안에 함수, 내부함수가 외부함수에 의해 리턴형이 됨
def mul2(n):
return n * 2
mul2(10)
mul2(5)
--------------------------------
def mul5(n):
return n * 5
mul5(10)
mul5(5)
# 함수 del 하지 않는 이상 사라지지 않음, 메모리가 작은 기기에서는 풀이 될 가능성 O
# 비슷한 역할을 하는 클래스를 만들어놓고, 객체를 생성해서 처리한다면?
| 25 |
class Mul:
def __init__(self, m):
self.m = m
def mul(self, n):
return self.m * n
mul2 = Mul(2) # m = 2
print(mul2.mul(10)) # n = 10
print(mul2.mul(5)) # n = 5
mul5 = Mul(5) # m = 5
print(mul5.mul(10)) # n = 10
print(mul5.mul(5)) # n = 5
# 함수를 매번 만들 필요가 없음
| 20 10 50 25 |
class Mul:
def __init__(self, m): # 객체를 생성할 때 자동으로 호출
print('생성자 호출') # 생성자는 객체를 만들 때 가장 먼저 호출되는 메소드(자동호출)
self.m = m
def __call__(self, n): # 객체를 실행할 때 자동으로 호출 (스페셜 메소드 중 하나: __call__)
print('call 호출') # 들어오는 값을 바로 n으로 넣어 실행해서 출력
return self.m * n
mul2 = Mul(2) # m = 2 (생성자 호출)
mul2(10) # n = 10 (call이 호출) mul2.mul(10) 이라고 작성X
mul5 = Mul(5) # m = 2 (생성자 호출)
mul5(10) # n = 10 (call이 호출) mul5.mul(10) 이라고 작성X
| 생성자 호출 call 호출 생성자 호출 call 호출 50 |
6. 데코레이터
데코레이터(Decorator)는 파이썬에서 함수나 메서드의 동작을 수정하거나 확장하기 위한 강력한 도구입니다. 데코레이터는 함수나 메서드를 래핑하거나 감싸서 추가 기능을 제공하며, 코드 재사용성과 가독성을 향상시킵니다. 데코레이터는 @ 기호를 사용하여 함수나 메서드 위에 적용됩니다.
import time # 시간에 관련된 기능들이 있는 모듈
def func1(a, b):
start = time.time() # time.time() : 현재 시간을 가져오는 함수
print('함수가 시작되었습니다')
print(start)
func1(1,2) # time stamp 시간의 흐름의 계산에 필요한 자료
| 함수가 시작되었습니다 1710809037.5023768 |
import time
def func1(a, b):
start = time.time()
print('함수가 시작되었습니다')
result = a + b
end = time.time()
print(f'함수 수행시간: {end - start}')
return result
result = func1(10, 3)
print(result)
------------------------------------------------------------------------------------------------------
def func2(a, b):
start = time.time()
print('함수가 시작되었습니다')
result = a * b
end = time.time()
print(f'함수 수행시간: {end - start}')
return result
result = func2(10, 3)
print(result)
| 함수가 시작되었습니다 함수 수행시간: 0.0016219615936279297 13 함수가 시작되었습니다 함수 수행시간: 0.0029647350311279297 30 |
# 데코레이터 만들기 (정석)
import time
def func1(a, b):
result = a + b
return result
def func2(a, b):
result = a * b
return result
def elapsed(func): # 외부함수 이름으로 데코레이터를 만들 수 있음
def wrapper(a, b): # 내부함수
start = time.time()
print('함수가 시작되었습니다')
result = func(a, b) # 함수와 a,b가 입력됨
end = time.time()
print(f'함수 수행시간: {end - start}')
return result
return wrapper
deco1 = elapsed(func1) # 덧셈하는 함수(fun1)를 넣어서 시간체크함수(wrapper)의 결과를 출력해줘
result = deco1(10, 3) # a에 10, b에 3을 넣어줘
print(result)
deco2 = elapsed(func2) # 곱셈하는 함수(fun2)를 넣어서 시간체크함수(wrapper)의 결과를 출력해줘
result = deco2(10, 3) # a에 10, b에 3을 넣어줘
print(result)
| 함수가 시작되었습니다 함수 수행시간: 0.0012736320495605469 13 함수가 시작되었습니다 함수 수행시간: 3.504753112792969e-05 30 |
# 데코레이터 만들기 (데코레이터 수정후)
import time
def elapsed(func):
def wrapper(a, b):
start = time.time()
print('함수가 시작되었습니다')
result = func(a, b)
end = time.time()
print(f'함수 수행시간: {end - start}')
return result
return wrapper
@elapsed # 외부함수(시간체크하는 함수)를 입혀줘
def func1(a, b):
result = a + b
return result
@elapsed # 외부함수(시간체크하는 함수)를 입혀줘
def func2(a, b):
result = a * b
return result
@elapsed
def func3(a,b) :
result = a - b
return result
result = func1(10, 3)
print(result)
result = func2(10, 3)
print(result)
result = func3(10, 3)
print(result)
| 함수가 시작되었습니다 함수 수행시간: 0.0030379295349121094 13 함수가 시작되었습니다 함수 수행시간: 0.0005362033843994141 30 함수가 시작되었습니다 함수 수행시간: 0.0006318092346191406 7 |
'Python > 개념' 카테고리의 다른 글
| Day 7-2. 파이썬 스페셜(매직) 메소드 (0) | 2024.03.18 |
|---|---|
| Day 7-1. 파이썬 상속 (0) | 2024.03.18 |
| Day 6-2. 콜백함수와 람다함수 (0) | 2024.03.15 |
| Day 6-1. 변수의 범위 (0) | 2024.03.15 |
| Day 5-2. 사용자 정의 함수 (0) | 2024.03.15 |
