클래스(Class)와 객체(Object)

• Class : 객체를 생성하기 위한 정의 파일
• Object : Class를 통해 생성된 instance

클래스

• 속성(Attribute)과 행위(Action)로 구성
• 속성은 변수로 행위는 함수로 정의 = > 맴버(변수, 메소드)
• 함수(Function) : 독립된 기능을 수행하는 명령문들의 집합
• 메서드(Method) : 클래스에 포함되어 있는 함수
• __init__(self) : 생성자

'''
class 클래스 :
     멤버(member) : 변수, 함수 
     생성자 : 객체 생성 
'''

함수 VS 클래스

# 함수 정의
def calc_func(a, b): # outer 
    # 자료(data)
    x = a # 10
    y = b # 20
    
    # inner
    def plus():
        p = x + y
        return p
    
    def minus():
        m = x - y
        return m

    return plus, minus

p, m = calc_func(10, 20)
print('plus =', p())
print('minus=', m())

plus = 30
minus= -10

# 클래스 정의
class calc_class :
    # 변수 선언
    x = y = 0
    
    # 생성자 : 객체 생성 + [멤버변수 초기화] 
    def __init__(self, a, b):
        print('~~객체 생성~~')
        self.x = a # 10
        self.y = b # 20
    
    # 멤버 함수(기능)
    def plus(self): # self : 멤버(변수+함수) 참조 객체 
        p = self.x + self.y
        '''
        p : 지역변수 
        self.x, self.y : 전역변수  
        '''
        return p 
    
    def minus(self):
        m = self.x - self.y
        return m

# class(1) -> object(n) 생성 
obj1 = calc_class(10, 20) # 생성자 -> 객체1  

~~객체 생성~~

# object.member()  
print('plus = ', obj1.plus()) # plus =  30
print('minus =', obj1.minus()) # minus = -10

plus =  30
minus = -10

obj2 = calc_class(100, 50) # 생성자 -> 객체2
print('plus = ', obj2.plus()) # plus =  150
print('minus =', obj2.minus()) # minus = 50

print(id(obj1), id(obj2)) # 9498096 9498000

~~객체 생성~~
plus =  150
minus = 50
1569025398664 1569025399240

# (2) 클래스 구성요소
class Car:
    # 멤버 변수
    cc = 0 # 엔진 cc
    door = 0 # 문짝 개수
    carType = None # null

    # 생성자
    def __init__(self, cc, door, carType):
        # 멤버 변수 초기화
        self.cc = cc
        self.door = door
        self.carType = carType # 승용차, SUV

    # 멤버 메소드
    def display(self):
        print("자동차는 %d cc이고, 문짝은 %d개, 타입은 %s 이다."
              % (self.cc, self.door, self.carType))

# object 생성
car1 = Car(2000, 4, "승용차")  # 객체 생성 + 초기화
# object.member()
car1.display()  # info(kind) -> display(kind)

car2 = Car(3000, 5, "SUV")
car2.display()

자동차는 2000 cc이고, 문짝은 4개, 타입은 승용차 이다.
자동차는 3000 cc이고, 문짝은 5개, 타입은 SUV 이다.

# (3) 내장 클래스
import  datetime
from datetime import date, time # from 모듈 import 내장 클래스

today = date(2019, 10, 23) # 생성자 -> object
print(today) # 2019-10-23

2019-10-23

# object.member : 변수
print(today.year) # 2019
print(today.month) # 10
print(today.day) # 23

2019
10
23

# object.member() : 함수 
w = today.weekday() # Monday == 0 ... Sunday == 6
print('요일 정보 : ', w) # 요일 정보 :  0(월)~6(일)

요일 정보 :  2

# time()
currTime = time(21,4,30)
'''
datetime.time(0, 0) ~ datetime.time(23, 59, 59, 999999)
'''
print(currTime) # 21:04:00

print(currTime.hour) # 21
print(currTime.minute) # 4
print(currTime.second) # 0

isoTime = currTime.isoformat() # HH:MM:SS
print(isoTime) # 21:04:00

21:04:30
21
4
30
21:04:30

생성자 Constructor

• 객체가 생성될 때 자동으로 실행
• 멤버변수 초기화 역할
• 초기화 불필요시 생략 가능 => 기본 생성자로 자동 생성됨
• self : 생성자와 메서드 필수 매개변수

# (1) 생성자 이용 멤버변수 초기화
class multiply :
    # 멤버 변수
    x = y = 0

    # 생성자 : 초기화
    def __init__(self, x, y): # 객체만 생성
        self.x = x
        self.y = y

    def mul(self):
        return self.x * self.y

    # 소멸자
    def __del__(self):
        del self.x
        del self.y

obj = multiply(10, 20) # 기본 생성자
print('곱셈 =', obj.mul()) # mul = 200

곱셈 = 200

# (2) 메서드 이용 멤버변수 초기화
class multiply2 :
    # 멤버 변수
    x = y = 0

    # 생성자 없음 : 기본 생성자 제공
    def __init__(self):
        pass

    # 멤버변수 초기화
    def data(self, x, y):
        self.x = x
        self.y = y

    def mul(self):
        return self.x * self.y

obj = multiply2() # 기본 생성자
obj.data(10, 20)
print('곱셈 =', obj.mul()) # mul = 200

곱셈 = 200

self

• 생성자와 매서드 생성시 self 인수 생략시 오류남
• 멤버 변수와 멤버 메서드 호출 시 필요
• self.멤버변수ㅣ self.멤버메서드()

# (3) self 명령어
class multiply3 :
    # 멤버변수 없음
    # 생성자 없음
   
    # 동적 멤버변수 생성/초기화
    def data(self, x, y):
        self.x = x
        self.y = y

    # 곱셈 연산
    def mul(self):
        result = self.x * self.y
        self.display(result) # 메서드 호출

    # 결과 출력
    def display(self, result):
        print("곱셈 = %d" %(result) )


obj = multiply3() # 기본 생성자
obj.data(10, 20)
obj.mul()

곱셈 = 200

클래스 멤버

• 클래스 이름으로 호출
• 객체 생성 불필요
• 클래스이름.변수, 클래스이름.메서드()
• cls라는 기본 인수 사용
• @classmethod 사용

class DatePro :
    # 멤버 변수 or 클래스 변수
    content = "날짜 처리 클래스"

    # 생성자
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day        
        
    # 객체 메서드(instance method)
    def display(self):
        print("%d-%d-%d"%(self.year, self.month, self.day))
        
    # 클래스 메서드(class method)
    @classmethod # 함수 장식자 
    def date_string(cls, dateStr): # '19951025'
        year = dateStr[:4]
        month = dateStr[4:6]
        day = dateStr[6:]
        
        print(f"{year}년 {month}월 {day}일") # 1995년 10월 25일

# 객체 멤버
date = DatePro(1995, 10, 25) #  생성자
print(date.content) # 날짜 처리 클래스
print(date.year) # 1995
date.display() # 1995-10-25

날짜 처리 클래스
1995
1995-10-25

DatePro.display() # error

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-27-5c5f293590e1> in <module>
----> 1 DatePro.display()

TypeError: display() missing 1 required positional argument: 'self'

# 클래스 멤버
print(DatePro.content) # 날짜 처리 클래스
#print(DatePro.year) # AttributeError
DatePro.date_string('19951025') # 1995년 10월 25일

날짜 처리 클래스
1995년 10월 25일

객체지향 기법

캡슐화 encapsulation

• 공용 인터페이스() 만으로 접근을 제한하여 객체의 세부 내용을 외부로 부터 감추는 기법
• __변수 : 은닉변수(private)
• 접근 : getter(), setter()

class Account:  # outer -> class
    # 은닉 멤버 변수
    __balance = 0  # 잔액
    __accName = None # 예금주
    __accNo = None # 계좌번호

    # 생성자 : 초기화
    def __init__(self, bal, name, no):
        self.__balance = bal  # 잔액 초기화
        self.__accName = name  # 예금주
        self.__accNo = no  # 계좌번호

    # 계좌정보 확인 : getter
    def getBalance(self):
        return self.__balance, self.__accName, self.__accNo

    # 입금하기 : setter
    def deposit(self, money):
        if money < 0:
            print('금액 확인')
            return  # 함수 종료(exit)

        self.__balance += money

    # 출금하기 : setter
    def withdraw(self, money):
        if self.balance < money:
            print('잔액 부족')
            return  # 함수 종료(exit)

        self.__balance -= money

# object 생성
acc = Account(1000, '홍길동', '125-152-4125-41') # 생성자

# object.member()
#acc.__balance # error
bal = acc.getBalance()
print('계좌정보 : ', bal) # 계좌정보 :  (1000, '홍길동', '125-152-4125-41')

계좌정보 :  (11000, '홍길동', '125-152-4125-41')

# 10,000원 입금
acc.deposit(10000)
bal = acc.getBalance()
print('계좌정보 : ', bal)

계좌정보 :  (21000, '홍길동', '125-152-4125-41')

상속 inheritance

• 클래스간 계층적인 관계를 구성
• 코드 재사용성과 다형성을 가능하게 함
• 부모 클래스에 자식 클래스에서 공통으로 사용할 멤버들 선언

'''
class child_class(parent_class) :
     멤버 변수
     생성자
     멤버 함수
'''

# 부모 클래스 
class Super :

    # 생성자 : 동적멤버 생성
    def __init__(self, name, age):
        self.name = name 
        self.age = age
    
    # 멤버 함수 
    def display(self):
        print('name : %s, age : %d'%(self.name, self.age))

sup = Super('부모', 55)
sup.display() # 부모 멤버 호출     

name : 부모, age : 55

#  자식 클래스
class Sub(Super) : # 클래스 상속
    gender = None # 자식 멤버
       
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age 
        self.gender = gender
        
    # 메서드 확장
    def display(self):
        print('name : %s, age : %d, gender : %s'
              %(self.name, self.age, self.gender))
    
sub = Sub('자식', 25, '여자')
sub.display() # 자식 멤버 호출 

name : 자식, age : 25, gender : 여자

super 클래스

• 부모 클래스의 생성자를 호출하기 위해 제공
• super().init()

# (1) 부모클래스 정의
class Parent :

    # 생성자 : 객체 + 초기화 
    def __init__(self, name, job):
        self.name = name
        self.job = job
        
    # 멤버 함수(method)
    def display(self):
        print('name : {}, job : {}'.format(self.name, self.job))

# 부모 클래스 객체 생성
p = Parent('홍길동', '회사원')
p.display()

name : 홍길동, job : 회사원

# (2) 자식 클래스 생성
class Children(Parent): # Parent(member) -> Childen1(member)
    gender = None # 추가 멤버
    
    # 생성자
    def __init__(self, name, job, gender):
        # 부모 생성자 호출 
        super().__init__(name, job) # name, job 초기화
        self.gender = gender # 자식 멤버

    # 멤버 함수(method) 
    def display(self): # 함수 재정의 
        print('name : {}, job : {}, gender : {}'
              .format(self.name, self.job, self.gender))

# 자식 클래스 객체 생성
chil = Children("이순신", "해군 장군", "남자")
chil.display()

name : 이순신, job : 해군 장군, gender : 남자

메서드 재정의 Method Overriding

• 상속받은 메서드를 자식 클래스에서 다시 정의 하는 것

# (1) 부모클래스
class Employee:
    name = None
    pay = 0

    def __init__(self, name):
        self.name = name

    def pay_calc(self):
        pass

# (2) 자식클래스 : 정규직
class Permanent(Employee):
    def __init__(self, name):
        super().__init__(name)  # 부모 생성자 호출

    def pay_calc(self, base, bonus):
        self.pay = base + bonus  # 급여 = 기본급+상여금
        print('총 수령액 : ', format(self.pay, '3,d'),'원')

# (3) 자식클래스 : 임시직
class Temporary(Employee):
    def __init__(self, name):
        super().__init__(name)  # 부모 생성자 호출

    def pay_calc(self, tpay, time):
        self.pay = tpay * time # 급여 = 작업시간*시급
        print('총 수령액 : ', format(self.pay, '3,d'),'원')

# (4) 객체 생성
p = Permanent("이순신")
p.pay_calc(3000000, 200000)

t = Temporary("홍길동")
t.pay_calc(15000, 80)

총 수령액 :  3,200,000 원
총 수령액 :  1,200,000 원

다형성 Polymorphism

• 하나의 참조변수로 여러 타입의 객체를 참조
• 부모 객체의 참조변수로 자식 객체들을 참조

# (1) 부모 클래스
class Flight:

    # 부모 원형 함수
    def fly(self):
        print('날다, fly 원형 메서드')


# (2) 자식 클래스 : 비행기
class Airplane(Flight) :

    # 함수 재정의
    def fly(self):
        print('비행기가 날다.')

# (2) 자식 클래스 : 새
class Bird(Flight) :

    # 함수 재정의
    def fly(self):
        print('새가 날다.')

# (2) 자식 클래스 : 종이비행기
class PaperAirplane(Flight) :

    # 함수 재정의
    def fly(self):
        print('종이 비행기가 날다.')

# (3) 객체 생성
# 부모 객체 = 자식 객체(자식1, 자식2)
flight = Flight()  # 부모 클래스 객체
air = Airplane()  # 자식1 클래스 객체
bird = Bird()  # 자식2 클래스 객체
paper = PaperAirplane()  # 자식3 클래스 객체

# (4) 다형성
flight.fly() # 날다, fly 원형 메서드

flight = air
flight.fly() # 비행기가 날다.

flight = bird
flight.fly() # 새가 날다.

flight = paper
flight.fly() # 종이 비행기가 날다.

날다, fly 원형 메서드
비행기가 날다.
새가 날다.
종이 비행기가 날다.

내장 클래스

builtins모듈 내장 클래스

• import 없이 사용

# enumerate() : 열거형 자료 색인과 값 반환
lst = [1,3,5]
for i, c in enumerate(lst) :
    print('색인 : ', i, end=', ')
    print('내용 :', c)

색인 :  0, 내용 : 1
색인 :  1, 내용 : 3
색인 :  2, 내용 : 5

dit = {'name' : '홍길동', 'job': '회사원', 'addr':'서울시'}
for i, k in enumerate(dit) :
    print('색인 : ', i, end=', ')
    print('키 :', k, end=', ')
    print('값 :', dit[k])

색인 :  0, 키 : name, 값 : 홍길동
색인 :  1, 키 : job, 값 : 회사원
색인 :  2, 키 : addr, 값 : 서울시

패키지와 모듈

• 패키지(Package) = 폴더

  • 유사한 모듈(python file)을 꾸러미로 묶어놓은 단위

• 모듈(Module) = 파일

  • 함수와 클래스로 구성된 python file(*.py)

• 파이썬 파일은 모듈이면서 실행 파일 임

• 모듈로 사용시 주의 해야함

# chap06/source/MyModule.py
myVar = 100

class MyClass:
    def myMethod(self):
        print('MyMethod')

def myDef():
    print('MyDef')

모듈 사용 1 : import 모듈

# chap06/source/Test01.py
import MyModule

print(MyModule.myVar)
myClass = MyModule.MyClass()
myClass.myMethod()
MyModule.myDef()

모듈 사용 2 : from 모듈 import 변수,객체,함수

# chap06/source/Test02.py
from MyModule import MyClass,myDef,myVar

print(myVar)
myClass = MyClass()
myClass.myMethod()
myDef()

패키지 사용 1 : from 패키지 import 모듈

# chap06/source/MyPackage/MyModule.py 복사
# chap06/source/Test03.py
from MyPackage import MyModule

print(MyModule.myVar)
myClass = MyModule.MyClass()
myClass.myMethod()
MyModule.myDef()

패키지 사용 2 : from 패키지.모듈 import 변수,객체,함수

# chap06/source/Test04.py
#from MyPackage.MyModule import MyClass,myDef,myVar
from MyPackage.MyModule import *
print(myVar)
myClass = MyClass()
myClass.myMethod()
myDef()

패키지 사용 3 : import 패키지.모듈 as 별명

import MyPackage.MyModule as mm

print(mm.myVar)
myClass = mm.MyClass()
myClass.myMethod()
mm.myDef()

# chap06/source/MyPackage/scattering.py 생성

from statistics import mean
from math import sqrt


# 산술평균 함수
def Avg(data):
    avg = mean(data)
    return avg


# 분산/표준편차 함수
def var_sd(data):  # [2,4,5,6,1,8] - avg
    avg = Avg(data)  # 함수 호출
    # list 내포
    diff = [(d - avg) ** 2 for d in data]

    var = sum(diff) / (len(data) - 1)
    sd = sqrt(var)

    return var, sd

data = [1, 3, 5, 7]
print('평균=', Avg(data))
var, sd = var_sd(data)
print('분산=', var)
print('표준편차=', sd)

평균= 4
분산= 6.666666666666667
표준편차= 2.581988897471611

# chap06/source/module_import.py 생성

import myPackage.scattering

name 값 확인

• import 해서 모듈로 사용되면 패키지.모듈명
• python 으로 실행 시키면 main
• if name == "main" 이용 해서 실행 시 처리

# chap06/source/MyPackage/scattering.py 변경

from statistics import mean
from math import sqrt


# 산술평균 함수
def Avg(data):
    avg = mean(data)
    return avg


# 분산/표준편차 함수
def var_sd(data):  # [2,4,5,6,1,8] - avg
    avg = Avg(data)  # 함수 호출
    # list 내포
    diff = [(d - avg) ** 2 for d in data]

    var = sum(diff) / (len(data) - 1)
    sd = sqrt(var)

    return var, sd

# 프로그램 시작점
if __name__ == "__main__" :
    data = [1, 3, 5, 7]
    print('평균=', Avg(data))
    var, sd = var_sd(data)
    print('분산=', var)
    print('표준편차=', sd)

평균= 4
분산= 6.666666666666667
표준편차= 2.581988897471611

__name__

'__main__'