260331_강의정리

■ 객체지향프로그래밍(OOP - Object Oriented Programming)

• 프로그램을 명령어 목록이 아닌, 데이터와 기능(메드)을 묶은 독립적인 ‘객체’들의 상호작용으로 구성하는 방식
• class는 사용자 정의 데이터 타입
• 멤버변수에는 다양한 데이터 타입 지정 가능
• class는 이질적 데이터를 저장 : list와 다른 점은 list는 index에 의한 접근이지만 class는 이름에 의한 접근
• 특징
  • 추상화 (Abstraction)
    • 현실 세계의 개념(객체, 속성, 행동)을 프로그래밍 객체(Object)로 표현하는 과정
    • 필요한 정보와 기능만 노출하고, 내부 구현은 감춤
    • (ex. 자동차라는 객체 생성 => 시동걸기, 주행 같은 기능 제공 but 엔진 내부 작동 방식 숨김)
  • 캡슐화 (Encapsulation)
    
    • 데이터와 메소드를 하나의 객체로 묶고, 외부에서 함부로 접근하지 못하게 보호
    • 접근 제어자(접근 지정자) : 외부코드로부터 객체 상태 보호 + 인터페이스를 통한 안전한 사용보장 
      • public : Python에서 기본 (ex. obj.name)
      • protected : 권장하지 않지만 접근 가능 (ex. _name)
      • private : 외부에서 접근 어려움 (ex. __name)
  • 다형성 (Polymorphism)
    • 하나의 객체나 메소드가 다양한 형태를 가질 수 있는 능력
    • overloading
      • 함수 이름은 같지만 매개변수의 타입과 개수가 다르면 다른 함수로 인식
      • Python에서는 일반적인 오버로딩을 지원하지 않음
    • overriding
      • 부모의 함수 이름이 같고 형태도 동일한데 재정의를 통해서 다른 작업이 가능
      • 상속에서 사용되는 개념
  • 상속 (Inheritance)
    • 기존에 존재하던 클래스의 멤버 변수와 메소드를 그대로 물려받아, 멤버 변수 및 메서드를 추가하거나 재정의하여 새로운 클래스를 정의
    • 코드 재사용과 계층 구조 형성
    • 공통 부분을 부모로 정의하고 상속하면 코드 재사용 가능
    • 부모 타입 변수에 자식 객체 할당 가능

 

■ class

• 사용자 정의 자료구조(데이터 타입)
• 객체는 메모리(heap)에 저장
  • C, Java에서는 new로 생성
  • Python에서는 그냥 생성
• 데이터(변수) + 관계 + 동작(함수)를 하나로 묶은 구조
• 데이터와 메소드(함수)를 묶은 형태
• Python은 실시간으로 추가/삭제 가능 (C, Java는 한번 클래스가 선언이 되면 변경 불가)
• 구성
  • 지역 변수 : 함수 내에서만 사용되는 변수
  • 멤버 변수
    • 클래스 내부에 정의된 변수(다양한 타입 가능)
    • 어떤 함수에서도 self를 붙여주면 멤버 변수(C, Java에서는 구성 요소로 설계)
    • 클래스 변수
      • class에 소속된 변수
      • 모든 객체가 공유 (class 내에서 공유)
    • 인스턴스 변수
      • 객체(instance)마다 별도로 존재
      • self.을 붙여서 정의
      • 생성자(__init__)에서 초기화하는 경우가 많음
  • 생성자
    • Python에서는 __init__으로 생성 (C, Java에서는 생성자에서 반드시 초기화)
    • 객체 생성 시 자동 실행
    • 인스턴스 변수 초기화 역할
    • 객체 생성 시 필요한 초기값 설정 가능
  • 메소드
    • class 내부 함수
    • 멤버함수는 반드시 첫 번째 매개변수가 self

class MyClass:
    class_var = 0  # 클래스 변수

    def __init__(self, value):
        self.instance_var = value  # 인스턴스 변수

    def instance_method(self):
        local_var = 10  # 지역변수
        return self.instance_var + local_var

    @classmethod
    def class_method(cls):
        return cls.class_var

    @staticmethod
    def static_method(x):
        return x * 2

 

※ Static Method

• @staticmethod
• 클래스 내부에 존재하지만 인스턴스나 클래스 자체와 무관하게 동작
• 인스턴스 없이 호출 가능
• 클래스 속성이나 인스턴스 속성 접근 불가

※ Class Method

• @classmethod
• 클래스 자체를 첫 번째 인자로 받음(cls)
• 인스턴스 없이 호출 가능
• 클래스 속성이나 클래스 생성자 등에 접근 가능

 

※ property

• 클래스의 멤버 변수를 직접 접근하지 않고, 메소드를 통해 접근하게 하는 기능
• Getter / Setter / Deleter => 외부에서는 변수처럼 활용 가능
• 캡슐화 유지 => 내부 데이터 보호
• 데이터 검증 가능 => 값을 설정할 때 조건을 통한 검사 가능
• 인터페이스 일관성 유지 => 변수 접근 방법을 변경하지 않고 내부 변경 가능

# 기본적으로 Python의 접근 지정자는 public
# 데이터를 보호하기 위해서 getter, setter, deleter 사용
# 변수에 속성을 주는 것 : property
class C:
  def __init__(self): # 생성자
    self._x = None # 멤버변수
  def getx(self): # getter
    return self._x
  def setx(self, value): # setter
    if value > 120:
      value = 120
    self._x = value
  def delx(self): # deleter
    del self._x # 메모리 해제함수
  x = property(getx, setx, delx, "I'm the 'x' property.")
  
test = C()
test.x = 100 # 속성을 사용하면 간접 접근
print(test.x) # 100

 

※ 인스턴스(instance)화

• 사용할 수 있는 객체를 메모리에 올리는 것
• 인스턴스화를 하면, 인스턴스 변수만 해당 객체의 메모리에 공간이 할당
• 클래스 변수는 클래스 자체에 존재하므로 인스턴스화해도 따로 공간이 늘어나지 않음

※ 메소드 체이닝(method chaining)

• 여러 메소드를 한 줄로 이어서 호출
• 각 메소드가 self를 반환하도록 설계되어야 가능

# chaining

class Person:
    # 현재 생성자는 초기화(__init__)가 없어서 name, age 속성 없음
    # name()과 age() 호출 시 동적으로 속성 생성
    def name(self, value):
        self.name = value
        return self  # 메서드 체이닝을 위해 self 반환

    def age(self, value):
        self.age = value
        return self  # 메서드 체이닝을 위해 self 반환

    def introduce(self):
        print("이름 : ", self.name, ", 나이 : ", self.age)

person = Person()
person.name("에이콘").age(21).introduce()

 

■ 클래스 설계 규칙

• 단일 책임 원칙 (SRP, Single Resposibility Principle)
  • 클래스는 하나의 기능을 구현 (즉, 한 클래스는 하나의 책임만 가져야 함)
  • 테스트 용이, 코드 재사용성 향상

■ 객체 복사

• 얕은 복사 (Shallow Copy)
  • 객체의 최상위 구조만 새로 만들고, 내부 객체들은 원본과 같은 참조 공유
• 깊은 복사 (Deep Copy)
  • 객체와 그 안에 포함된 모든 객체를 새로 생성

import copy

# 얕은 복사
original = [[1, 2], [3, 4]]
shallow = copy.copy(original)

shallow[0][0] = 100
print(original)  # [[100, 2], [3, 4]] → 내부 리스트까지 같이 변경됨

# 깊은 복사
original = [[1, 2], [3, 4]]
deep = copy.deepcopy(original)

deep[0][0] = 100
print(original)  # [[1, 2], [3, 4]] → 원본은 그대로