1. 객체지향 프로그래밍

문제를 여러개의 객체 단위로 나눠 작업하는 방식

1-1. 객체(Object)란?

물리적으로 존재하거나 추상적으로 생각할 수 있는 것 중에서 자신의 속성을 가지고 있고 다른 것과 식별 가능한 것을 말함

1-2. 클래스(class)란?

객체를 생성하기 위한 일종의 설계도와 같음
클래스는 프로퍼티(필드), 메소드(함수)
- 프로퍼티(Property): 데이터가 저장되는 곳
- 메소드(Method): 객체의 동작에 해당하는 실행 블록

1-3. 클래스와 객체

건축 설계도가 클래스라면, 실제로 지어진 집은 객체
객체는 클래스로 생성되러 구체화된 인스턴스
실제로 클래스가 인스턴스롸 되어 메모리에 상주하는 형태를 객체라고 부름
파이썬의 모든 변수와 함수는 객체로 저장

2. 클래스 만들기

class 클래스명:
  프로퍼티명1 = 값1
  프로퍼티명2 = 값2
  ...

  def 메소드명1(self, 변수1, 변수2 ...):
    메소드가 호출되면 실행할 문장
    ...

  def 메소드명2(self, 변수1, 변수2 ...):
    메소드가 호출되면 실행할 문장
    ...

클래스를 통해 호출되는 변수를 프로퍼티(필드)라고 부름
클래스를 통해 호출되는 함수를 메소드라고 부름
self: 클래스의 각 호출한 객체를 가리킴

In [28]:

class Dog:
  pass # 내용이 없는 블록을 만들 때 사용

In [29]:

def func1():
  pass

In [30]:

# 클래스를 통해 객체를 생성
Rucy = Dog()
print(Rucy)
print(type(Rucy))

<__main__.Dog object at 0x7f5e747a1790>
<class '__main__.Dog'>

In [31]:

li1 = list([1, 2, 3, 4, 5])
print(li1)
print(type(li1))
print(id(li1))

[1, 2, 3, 4, 5]
<class 'list'>
140043657787072

In [32]:

PPomi = Dog()
print(PPomi)
print(type(PPomi))

<__main__.Dog object at 0x7f5e76101850>
<class '__main__.Dog'>

In [33]:

li2 = list([1, 2, 3, 4, 5])
print(li2)
print(type(li2))
print(id(li2))

[1, 2, 3, 4, 5]
<class 'list'>
140043657772160

In [34]:

class Dog:
  name = '루시'
  age = 13
  family = '포메'

  def eat(self):
    print(self)
    print('사료를 먹습니다!')

In [35]:

Rucy = Dog()
print(Rucy.name)
print(Rucy.age)
print(Rucy.family)
Rucy.eat()
print(Rucy)

루시
13
포메
<__main__.Dog object at 0x7f5e74792e50>
사료를 먹습니다!
<__main__.Dog object at 0x7f5e74792e50>

In [36]:

PPomi = Dog()
print(PPomi.name)
print(PPomi.age)
print(PPomi.family)
PPomi.eat()
print(PPomi)

루시
13
포메
<__main__.Dog object at 0x7f5e747a17c0>
사료를 먹습니다!
<__main__.Dog object at 0x7f5e747a17c0>

3. 생성자(Constructor)

클래스를 객체화 시킬 때 가장 먼저 자동으로 실행되는 메소드
__init__ (self)
생성자에서는 해당 클래스가 다루는 데이터를 정의하고 초기화함

In [37]:

class Dog:
  def __init__(self):
    print(self, 'init 호출!')

In [38]:

Rucy = Dog()

<__main__.Dog object at 0x7f5e74792760> init 호출!

In [39]:

class Dog:
  def __init__(self):
    self.name = '이름없음'
    self.age = 0

In [40]:

Rucy = Dog()
print(Rucy)
print(Rucy.name)
print(Rucy.age)

<__main__.Dog object at 0x7f5e74792550>
이름없음
0

In [41]:

PPomi = Dog()
print(PPomi)
print(PPomi.name)
print(PPomi.age)

<__main__.Dog object at 0x7f5e7451c0d0>
이름없음
0

In [42]:

Rucy.name = '루시'
Rucy.age = 13

In [43]:

PPomi.name = '뽀미'
PPomi.age = 7

In [44]:

print(Rucy)
print(Rucy.name)
print(Rucy.age)

<__main__.Dog object at 0x7f5e74792550>
루시
13

In [45]:

print(PPomi)
print(PPomi.name)
print(PPomi.age)

<__main__.Dog object at 0x7f5e7451c0d0>
뽀미
7

In [46]:

class Dog:
  def __init__(self):
    self.name = '이름없음'
    self.age = 0
    # nickname = '닉네임 없음' # 메소드 안에서만 사용할 수 있는 지역변수
    self.nickname = '닉네임 없음'
    # print(f'{nickname} 객체가 생성됨')

  # def go(self):
  #   print(f'{nickname}가 달립니다!') # NameError: name 'nickname' is not defined

  def go(self):
    print(f'{self.nickname}가 달립니다!')

In [47]:

Rucy = Dog()
Rucy.name = '루시'
Rucy.go()

닉네임 없음가 달립니다!

In [48]:

PPomi = Dog()
PPomi.name = '뽀미'
PPomi.go()

닉네임 없음가 달립니다!

In [49]:

class Dog:
  def __init__(self, name, age, nickname='닉네임없음'):
    self.name = name
    self.age = age
    self.nickname = nickname

In [50]:

Rucy = Dog() # TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-50-389e38b1f391> in <module>
----> 1 Rucy = Dog() # TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'

TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'

In [51]:

Rucy = Dog('루시', 13)

In [52]:

print(Rucy.name)
print(Rucy.age)
print(Rucy.nickname)

루시
13
닉네임없음

In [53]:

PPomi = Dog('뽀미', 7)

In [55]:

print(PPomi.name)
print(PPomi.age)
print(PPomi.nickname)

뽀미
7
닉네임없음

4. 메소드 정의하기

해당 클래스의 객체에서만 호출가능한 함수
해당 객체의 속성에 대한 연산을 행함
객체이름.메소드명() 형태로 호출됨

4-1. 메소드 정의하기

In [80]:

class Counter:
  def __init__(self):
    self.num = 0
  def increment(self):
    self.num += 1
  def decrement(self):
    self.num -= 1
  def current_value(self):
    return self.num
  def reset(self):
    self.num = 0

In [81]:

KBbank = Counter()
print(KBbank.num)

In [82]:

KBbank.increment()
print(KBbank.num)

In [83]:

KBbank.decrement()
print(KBbank.num)

In [84]:

print(KBbank.current_value())

In [85]:

KBbank.increment()
KBbank.increment()
KBbank.increment()
KBbank.increment()
KBbank.increment()
print(f'현재 대기인원 : {KBbank.current_value()}')

현재 대기인원 : 5

In [86]:

HanaBank = Counter()
print(f'현재 대기인원 : {HanaBank.current_value()}')

현재 대기인원 : 0

In [87]:

HanaBank.increment()
HanaBank.increment()
HanaBank.increment()
print(f'현재 대기인원 : {HanaBank.current_value()}')

현재 대기인원 : 3

In [88]:

HanaBank.reset()
print(f'현재 대기인원 : {HanaBank.current_value()}')

현재 대기인원 : 0

4-2. 메소드 타입

instance method: 객체 형태로 호출되기 때문에 해당 메소드를 호출한 객체에서만 영향을 미침
class method: 클래스 이름으로 호출하는 메소드(메소드 선언 위에 @staticmethod라고 표시)

In [89]:

class Math:
  def add(self, x, y):
    return x + y
  def multiply(slef, x, y):
    return x * y

In [90]:

math = Math()

In [91]:

result1 = math.add(10, 3)
print(result1)

In [93]:

result2 = math.multiply(10, 3)
print(result2)

In [94]:

class Math:
  @staticmethod
  def add(x, y):
    return x + y
  @staticmethod
  def multiply(x, y):
    return x * y

- 클래스 메소드는 객체를 선언하지 않아도 메소드 사용이 가능하다.

In [95]:

result1 = Math.add(10, 3)
print(result1)

In [96]:

result2 = Math.multiply(10, 3)
print(result2)

In [101]:

class Math:
  @staticmethod
  def add(x, y):
    return x + y
  @staticmethod
  def multiply(x, y):
    return x * y

  def div(self, x, y):
    return x / y

In [103]:

math = Math()
result3 = math.div(10, 3)
print(result3)

3.3333333333333335

(파이썬) 객체지향과 클래스