[코딩] Circle Square

8. 함수(function)

9. 변수의 생존 범위

10. closure(클로저)

11. 일급함수

12. Module

13. 사용자 정의 모듈

14. turtle

15. 외부 모듈 사용

16. Class

17. 포함관계 (has a 관계)

18. 상속

19. 메소드 오버라이딩

---

8. 함수(function)

 : 여러개의 명령문을 하나의 묶음으로 만든 실행단위.

* test07_func

 - 내장함수

 - sum(a), bin(a), int(a), float(a), str(a)

print(sum([3, 5, 7]))
print(bin(8))
print(int(1.7), float(7), str(5) + '오')

 

eval(문자열) : 문자열을 계산 

a = 10
b = eval('a + 5')
print(b)

 

zip(a, b) : tuple로 묶어준다.

x = [10, 20, 30]
y = ['a', 'b']
for i in zip(x, y):
    print(i)
# (10, 'a')
# (20, 'b')

 

 

- 사용자 정의 함수

def DoFunc1():
    print('사용자정의 함수 1')
    
print("do1")
DoFunc1()
print("do2")
DoFunc1()
print(DoFunc1)       # 함수 이름은 객체(함수 본체)의 주소를 기억함수
print(type(DoFunc1)) # function
otherFunc = DoFunc1  # 주소 치환
otherFunc()

globals() : 모든 전역 변수 출력

print(globals()) # 모든 전역 변수 출력

 

def DoFunc2(name):
    print('hi', name)
    
DoFunc2('tom')
#DoFunc2('tom', 'tom2') # error
DoFunc2(100)

 

def DoFunc3(ar1, ar2):
    temp = ar1 + ar2
    print('temp', temp)
    # return None # default : None
    #return temp
    a = 2
    if a % 2 ==1:
        return
    else:
        return a
    print('dead')

    
DoFunc3(10, 20)
DoFunc3('kbs', 'mbc')
print(DoFunc3('kbs', 'mbc'))

 

def area_tri(a, b):
    c = a * b / 2
    if a == 0:
        return # 함수 탈출
    area_print(c) # 함수는 함수 호출가능
    
def area_print(c):
    print('삼각형의 넓이는 ',c)

area_tri(20, 30) # 삼각형의 넓이는  300.0

 

def abc():
    pass

 

def exam(a, b):
    ss = str(a) + '+' + str(b) + '=의 답은 : '
    ans = input(ss)
    return a + b == int(ans)

if(exam(5, 2)):
    print('good')
else:
    print('sad')

 

def swap(a, b):
    return b, a

a = 10; b = 20
print(swap(a, b)) # (20, 10)

 

def isOdd(arg):
    return arg % 2 == 1

print(isOdd(3)) # True
print(isOdd(4)) # False

myDict = {x:x*x for x in range(11) if isOdd(x)}
print(myDict) # {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

---

9. 변수의 생존 범위

 Local < Enclosing function > Global

* test08_func

player = '전국대표'        # Global Variable

def funcSoccer():
    player = '지역대표'    # Local Variable
    name = '한국인'       # Local Variable
    print(name, player)

funcSoccer()
# print(name, player) # 지역변수는 해당 블록에서만 사용 가능. Error

global a : 블록 내의 지역변수가 아닌 전역변수를 사용하도록 한다.
nonlocal a : 블록 내의 지역변수가 아닌 가까운 함수의 변수를 사용하도록 한다.

a = 10; b = 20; c = 30
print('1) a:{}, b:{}, c:{}'.format(a,b,c))

def Foo():
    a = 40
    b = 50
    def Bar():
        #c = 60
        global c # 블록 내의 지역변수가 아닌 전역변수를 사용하도록 한다.
        nonlocal b # 블록 내의 지역변수가 아닌 가까운 함수의 변수를 사용하도록 한다.
        print('2) a:{}, b:{}, c:{}'.format(a,b,c)) # Enclosing function
        c = 60   # UnboundLocalError: local variable 'c' referenced before assignment
        b = 70
    Bar()

Foo()
#Foo().Bar()
print('3) a:{}, b:{}, c:{}'.format(a,b,c))
print()

 

 - argument 키워드로 매칭

def ShowGugu(start = 1, end = 5):
    print(start, end)

ShowGugu(2, 8)      # 2 8
ShowGugu()          # 1 5
ShowGugu(2)         # 2 5
ShowGugu(start = 2) # 2 5
ShowGugu(end = 10)  # 1 10
ShowGugu(start = 2, end = 7)
ShowGugu(end = 7, start = 2)
#ShowGugu(start = 2, 7) # SyntaxError: positional argument follows keyword argument
ShowGugu(2, end = 7)

 

 - 가변인수 : 인수의 개수가 부정확한 경우

def func1(*ar):
    print(ar)
    for i in ar:
        print('음식 : ' + i)

func1('비비비')
func1('비비비','이이이','트트트트')

 

def func2(a, *ar):
#def func2(*ar, a): # TypeError
    print(a)
    print(ar)
    for i in ar:
        print('음식 : ' + i)

func2('비비비')
func2('비비비','이이이','트트트트')

 

re = 0
def selectProcess(choice, *ar):
    if choice == '+':
        re = 0
        for i in ar:
            re += i
    elif choice == '*':
        re = 1
        for i in ar:
            re *= i
    return re

print(selectProcess('+',1,2,3,4,5))
print(selectProcess('*',1,2,3,4,5))

 

def func3(w, h, **ect):
    print('몸무게 {}, 키 {}'.format(w, h))
    print(ect)
    
func3(65, 175, name = '홍길동')
func3(65, 178, name = '고길동', age = 22)
func3(w=80, h=175, name = '김길동')

 

def func4(a, b, *v1, **v2):
    print(a, b)
    print(v1)
    print(v2)
    
func4(1, 2)
func4(1, 2, 3, 4, 5)
func4(1, 2, 3, 4, 5, k=9, s=5)

---

10. closure(클로저)

 : 내부 함수의 주소를 반환해서 함수의 멤버를 계속적으로 참조

* test09_closure

def out():
    count = 0
    def inn():
        nonlocal count
        count += 1
        return count
    print(inn())

#print(count)
out() # 1
out() # 1

def outer():
    count = 0
    def inner():
        nonlocal count
        count += 1
        return count
    return inner     # 클로저(내부 함수의 주소를 반환)

obj1 = outer() # inner의 주소를 치환
print(obj1)
print(obj1()) # 1

result = obj1()
print(result) # 2

print(obj1()) # 3
print()

 

 - 수량 * 단가 * 세급 결과 출력

def outer2(tax):
    def inner2(su, dan):
        amount = su * dan * tax
        return amount
    return inner2 # 클로저

q1 = outer2(0.1)  # tax = 0.1
print(q1)
result1 = q1(5, 10000)
print(result1)    # 5000.0

result2 = q1(10, 20000)
print(result2)    # 20000.0

q2 = outer2(0.05) # tax = 0.05
result3 = q2(5, 10000)
print(result3)    # 2500.0

result4 = q2(10, 20000)
print(result4)    # 10000.0

 

 - 재귀함수 - 반복처리

def CountDown(n):
    if n == 0:
        print('처리완료')
    else:
        print(n, end = ' ')
        CountDown(n - 1) # 함수가 자신을 호출
        
CountDown(5) # 5 4 3 2 1 처리완료

def totFunc(su):
    if su == 1:
        print('처리 끝')
        return 1
    return su + totFunc(su - 1)

re = totFunc(10)
print('10까지의 합은 : ', re) # 10까지의 합은 :  55

---

11. 일급함수

 : 함수 안에 함수 선언 가능, 인자로 함수 사용, 반환값이 함수 가능

def func1(a, b):
    return a + b

func2 = func1      # 함수의 주소를 치환
print(func1(2,3))  # 5
print(func2(2,3))  # 5

def func3(func):   # 인자로 함수 사용
    def func4():   # 함수 안에 함수 선언 가능
        print('내부함수')
    func4()
    return func    # 반환값이 함수 가능

mbc = func3(func1) # func1
print(mbc(3, 4))   # 내부함수 7

 

 - Lambda : 이름이 없는 한 줄짜리 함수
형식 : lambda arg, ... :표현식   => return문 없이 결과 반환

def hap(x, y):
    return x + y
print(hap(2, 4))   # 6

aa = lambda x, y: x + y
print(aa(2, 4))    # 6

kbs = lambda a, su = 10: a + su
print(kbs(5))      # 15
print(kbs(5, 6))   # 11

sbs = lambda a, *tu, **di : print(a, tu, di)
sbs(1,2,3,tvn=3, ytn=24) # 1 (2, 3) {'tvn': 3, 'ytn': 24}

li = [lambda a, b:a+b, lambda a, b:a*b]
print(li[0](3,4))  # 7
print(li[1](3,4))  # 12

 

 - 다른 함수에서 인자 값으로 람다를 사용
filter(함수, 집합형 자료) : 자료의 요소 하나씩를 함수에 입력하여 결과값을 집합형으로 출력

print(list(filter(lambda a: a < 5, range(10))))  # [0, 1, 2, 3, 4]
print(tuple(filter(lambda a: a % 2, range(10)))) # (1, 3, 5, 7, 9)

 

 - 함수 장식자 - meta 기능을 가짐. @함수명

def make2(fn):
    return lambda : 'hi '+ fn()

def make1(fn):
    return lambda : 'hello '+ fn()

def hello():
    return '이이이'

hi = make2(make1(hello))
print(hi()) # hi hello 이이이
print()

@make2
@make1
def hello2():
    return '리리리'

print(hello2()) # hi hello 리리리

hi2 = hello2()
print(hi2)

hi3 = hello2
print(hi3)
print(hi3())

---

12. Module

 : 소스 코드의 재사용을 가능하게 하며, 소스 코드를 하나의 이름 공간으로 구분하고 관리할 수 있다.
멤버 : 일반 명령문, 함수, 모듈, 클래스
하나의 파일로 처리된다.
내장된 표준 모듈, 사용자 정의 모듈, 제 3자 모듈(third party)

 

* test11_module

 -  내장된 표준 모듈(로딩 필요 없음) 일부 사용해 보기
 작업 중 외부모듈이 필요한 경우 import 모듈명하여 사용

print(sum([2, 3])) # 내장된 표준모듈

import sys
print('모듈 경로 : ',sys.path)
sys.exit() # 프로그램 강제 종료
print('프로그램  종료')

import math
print(math.pi)# 3.141592653589793
print(math.sin(math.radians(30))) # 0.49999999999999994

import calendar
calendar.setfirstweekday(6) # 첫주 시작을 일요일로 변경
calendar.prmonth(2021,2)    # 달력 출력
#    February 2021
# Mo Tu We Th Fr Sa Su
#  1  2  3  4  5  6  7
#  8  9 10 11 12 13 14
# 15 16 17 18 19 20 21
# 22 23 24 25 26 27 28

 

 - 난수 출력

import random
print(random.random())       # 난수 출력 
print(random.randint(1, 10)) # 1~10 사이의 난수

from random import random
print(random())

from random import randint
from random import *
print(randint(1, 10))

---

13. 사용자 정의 모듈

* test12_my (동일 패키지)

# 사용자 정의 모듈
tot = 123 # 전역변수

def ListHap(*ar):
    print(ar)
    
    if __name__ == "__main__":
        print('응용프로그램이 시작되는 모듈')
    
    
def kbs():
    ch = 9
    print('공영방송', ch)
    
def mbc():
    print('문화방송')

 

* test12_our (다른 패키지)

# 사용자 정의 모듈
def Hap(a, b):
    return a + b

def Cha(a, b):
    return a - b

* test12_our2 (lib폴더 경로)

# 사용자 정의 모듈
def Gop(a, b):
    return a * b

def Nanugi(a, b):
    return a / b

* test12_module

# 사용자 정의 모듈
a = 10
print(a)

def aa():
    print('aa 출력')
    
# 외부 모듈의 멤버 사용하기1
import pack2.test12_my  # 경로

print('tot : ', pack2.test12_my.tot) # tot :  123

li1 =[1, 2]
li2 =[3, 4]
pack2.test12_my.ListHap(li1, li2)


def abc():
    if __name__ == "__main__":
        print('응용프로그램이 시작되는 모듈')
        
abc()

pack2.test12_my.kbs()
print()

# 외부 모듈의 멤버 사용하기2
from pack2 import test12_my
test12_my.mbc() 

from pack2.test12_my import mbc
mbc() 

from pack2.test12_my import mbc, kbs, tot
mbc()
kbs()
print(tot)
print()

# 외부 모듈의 멤버 사용하기3 - package가 다른 경우
from other.test12_our import Hap, Cha
print(Hap(5, 3)) # 8
print(Cha(5, 3)) # 2

# C:\anaconda3\Lib 경로의 모듈 사용
import test12_our2
print(test12_our2.Gop(5, 3))
print(test12_our2.Nanugi(5, 3))

import math
print(math.pi)

from test12_our2 import Gop
print(Gop(5, 3))

from math import pi
print(pi)

window - Preferences - PyDev - Interpreters - Python Interpreters - Libraries Tab 선택 안의 경로에 추가시 import 할 수 있다. 

---

14. turtle

 : Graphic 지원 모듈 사용 - turtle

* test13_graphic

import turtle
from turtle import *
pen = Pen()
pen.color('red', 'yellow')
pen.begin_fill()
while True:
    pen.forward(200)
    pen.left(170)
    if abs(pen.pos()) < 1:
        break
pen.end_fill()
done()

---

15. 외부 모듈 사용

* test14

① http://www.lfd.uci.edu/~gohlke/pythonlibs/ 사이트에서 모듈 다운로드하여 lib경로에 설치 

② 시작  - anconda prompt - pip install pygame

import pygame

---

16. Class

: OOP 기법 구사
: 클래스는 새로운 이름 공간을 지원하는 단위. 멤버는 변수, 메소드, 생성자로 구성. 접근 지정자X, 메소드 오버로딩X

 

* test15_class

print('do')

def func():
    print('함수')

class TestClass: # 원형 클래스  - prototype (객체가 실행과 동시에 생성. new 미사용)
    abc = 1 # 멤버변수(전역변수)
    
    def __init__(self):
        print('생성자')
        
    def __del__(self):
        print('소멸자')
        
    def printMsg(self): # 메소드
        name = '홍길동'
        print(name)
        print(self.abc)
        self.show()
        
    def show(self):
        print('show')

print(TestClass.abc) # 원형 클래스의 멤버 변수 호출
TestClass.printMsg(self) # NameError: name 'self' is not defined

test = TestClass() # 생성자 호출된 후 객체 생성(instance)
# 생성자
print(test.abc) # 1
test.printMsg()          # 1. Bound method call
# 홍길동 1 show
TestClass.printMsg(test) # 2. UnBound Method call
# 홍길동 1 show

print('클래스 타입확인 : ', type(1))    # int
print('클래스 타입확인 : ', type(test)) # __main__.TestClass
print(id(test))      # 2502643056496
print(id(TestClass)) # 2502639316704

 

 * test16_class

class Car:
    handle = 0 # 멤버 변수(필드). 클래스 내 전역
    speed = 0
    
    def __init__(self, name, speed): # 생성자 오버로딩 불가
        self.name = name
        self.speed = speed
        
    def showData(self): # 메소드 오버로딩 불가
        km = ' 킬로미터' # 지역변수
        msg = '속도 : ' + str(self.speed) + km
        return msg

# car1    
car1  = Car('tom', 10)
print(car1.handle, car1.name, car1.speed) # 0 tom 10
car1.color = '핑크'
print('car1.color : ', car1.color)

# car2
car2 = Car('james', 30)
print(car2.handle, car2.name, car2.speed) # 0 james 30
print('car2.color : ', car2.color) # AttributeError: 'Car' object has no attribute 'color'

# __dict__ : 해당 인스턴스의 멤버변수 dict
print(car1.__dict__) # {'name': 'tom', 'speed': 10, 'color': '핑크'}
print(car2.__dict__) # {'name': 'james', 'speed': 30}

# method
print('car1 - ', car1.showData()) # car1 -  속도 : 10 킬로미터
print('car2 - ', car2.showData()) # car2 -  속도 : 30 킬로미터
car1.speed = 100
car2.speed = 200
print('car1 - ', car1.showData()) # car1 -  속도 : 100 킬로미터
print('car2 - ', car2.showData()) # car2 -  속도 : 200 킬로미터

print(Car.speed)  # 0
print(car1.speed) # 100
print(car2.speed) # 200

print(Car.color)  # AttributeError: type object 'Car' has no attribute 'color'
print(car1.color)  # 핑크
print(car2.color) # AttributeError: type object 'Car' has no attribute 'color'

 

* test17_class

kor = 100 # 모듈의 전역변수

def abc():
    print('모듈의 멤버 함수')
    
class MyClass:
    kor = 88
    """
    def __init__(self): # 기본 생성
        pass
    """
    def abc(self):
        print('클래스의 멤버 메소드')
       
    def showData(self):
        print(kor) # 메소드 내에서 없을 경우 모듈의 전역변수를 찾는다. 
        print(self.kor) 
        self.abc() # 현재 클래스 내의 메소드 콜
        abc()      # 모듈의 함수 콜

obj = MyClass()
obj.showData()
# 100
# 88
# 클래스의 멤버 메소드
# 모듈의 멤버 함수

class My:
    a = 1

print(My.a) # 1

my1 = My # 주소
print(my1.a) # 1

my2 = My() # 인스턴스 생성
my2.a = 100
print(my2.a) # 100

my3 = My() # 인스턴스 생성
my3.a = 200
print(my3.a) # 200
my3.b = 123
print(my3.b) # 123

print(My.b)  # Error
print(my1.b) # Error
print(my2.b) # Error

---

* test18_class

# 클래스 = 설계도
# Singer가 갖추어야 할 기본 속성, 행위를 설계도(원형클래스)로 만든 후 모든 가수들은 Singer type으로 존재하면 됨

class Singer:
    title_song ='노래제목' # 멤버 변수
    
    def __init__(self):
        pass
    
    def sing(self):
        msg = '노래는'
        print(msg, self.title_song)
        
# 편의 상 아래에서 객체를 만들지만 별도의 모듈에서 Singer를 호출하여 사용하는 것이 일반적        
bts = Singer()
bts.sing()              # 노래는 노래제목
bts.title_song = '다이너마이트'
bts.sing()              # 노래는 다이너마이트
bts.co = '빅히트'
print('소속사 :', bts.co) # 소속사 : 빅히트

* test18_class2

# 클래스 연습
print('do')
a = 10
def aa():
    print(a)
    
# 새로운 가수 타입의 객체 필요
import pack2.test18_class

print('-----------------')
twice = pack2.test18_class.Singer()
twice.sing() # 노래는 노래제목
twice.title_song = '우아하게'
twice.sing() # 노래는 우아하게
print('소속사 :', twice.co) # error

---

17. 포함관계 (has a 관계)

 * test19_handle

# 움직이는 기계에 사용할 부품 클래스

class PohamHandle:
    quantity = 0 # 회전량
    
    def LeftTurn(self, quantify):
        self.quantity = quantify
        return '좌회전'
    
    def RightTurn(self, quantify):
        self.quantity = quantify
        return '우회전'

 

 * test19_car

# Car 클래스 : 여러개의 부품(클래스)을 조립해서 완성된 차를 생성
class PohamCar:
    speed = 0
    turnShow = '정지'
    
    def __init__(self, ownerName):  # ownerName 인스턴트에만 존재. 원형클래스에는 없음
        self.owerName = ownerName
        self.handle = PohamHandle() # 클래스의 포함 관계
        
    def TurnHandle(self, q):        # PohamCar 메소드로 핸들을 움직이는 행위
        if q > 0:
            self.turnShow = self.handle.RightTurn(q)
        elif q < 0:
            self.turnShow = self.handle.LeftTurn(q)
        elif q == 0:
            self.turnShow = '직진'
            
if __name__ == '__main__':
    tom = PohamCar('톰')
    tom.TurnHandle(10)
    print(tom.owerName+'의 회전량은 ' + tom.turnShow + str(tom.handle.quantity)) # 톰의 회전량은 우회전10
    tom.TurnHandle(0)
    print(tom.owerName+'의 회전량은 ' + tom.turnShow) # 톰의 회전량은 우회전10
    print()
    
    oscar = PohamCar('오스카')
    oscar.TurnHandle(-5)
    print(oscar.owerName+'의 회전량은 ' + oscar.turnShow + str(oscar.handle.quantity))
    # 오스카의 회전량은 좌회전-5
    

---

 * test20_has_a

 - 냉장고(class)에 음식(class)을 저장

class FoodData:
    def __init__(self, name, expiry):
        self.name = name
        self.expiry = expiry

class Fridge:
    isOpend = False # 냉장고 문 개폐 여부
    foods = []      # 리스트
    
    def open(self):
        self.isOpend = True
        print('냉장고 문이 열렸습니다.')
        
    def close(self):
        self.isOpend = False
        print('냉장고 문이 닫혔습니다.')
        
    def put(self, thing):
        if self.isOpend == True:
            self.foods.append(thing) # 클래스의 포함
            print('냉장고에 음식을 저장하였습니다.')
            self.listFood()
        else:
            print('냉장고 문이 닫혀있어 음식을 담을 수 없습니다.')
        
    def listFood(self):
        for f in self.foods:
            print('-', f.name, f.expiry)

f = Fridge()
apple = FoodData('사과', '2021-3-5')
f.put(apple)    # 냉장고 문이 닫혀있어 음식을 담을 수 없습니다.
f.open()        # 냉장고 문이 열렸습니다.
f.put(apple)    # 냉장고에 음식을 저장하였습니다.
                # - 사과 2021-3-5
f.close()       # 냉장고 문이 닫혔습니다.

cola = FoodData('콜라', '2022-12-5')
f.open()        # 냉장고 문이 열렸습니다.
f.put(cola)     # 냉장고에 음식을 저장하였습니다.
                # - 사과 2021-3-5
                # - 콜라 2022-12-5
f.close()       # 냉장고 문이 닫혔습니다.

---

18. 상속

: 클래스가 다른 클래스의 멤버를 활용 - 상속 : 다형성을 구사

* test21_inherit

class Animal: # 별도의 모듈에서 작성하고 호출하였다고 가정
    age = 0
    
    def __init__(self):
        print('Animal 생성자')
    
    def move(self):
        print('움직이는 생물')

class Dog(Animal): # 상속
    age = 10
    
    def __init__(self):
        print('Dog 생성자')
    
    def dogShow(self):
        age = 2
        print('개')
        print('age :', age)         # 지역변수
        print('age :', self.age)    # 클래스 -> 부모
        print('age :', super().age) # 부모

dog1 = Dog()    # 자식 생성자가 있을 경우 자식 생성자만 수행
                # 자식 생성자가 없을 경우 부모 생성자가 수행
print('dog1.age :',dog1.age) # dog1.age : 0
dog1.move()                  # 움직이는 생물
dog1.dogShow()
# 개
# age : 2
# age : 10
# age : 0

class Horse(Animal):
    pass

horse = Horse()
horse.move()

---

 클래스 상속 연습

* test22_inherit

class Person:
    say = '사람'
    age = 20
    __kbs = '공영방송' # __변수명 : private 멤버 - 현재 클래스에서만 호출 가능
    
    def __init__(self, age):
        print('Person 생성자')
        self.age = age
        
    def printInfo(self):
        print('나이 :{}, 이야기:{}'.format(self.age, self.say))
    
    def hello(self):
        print('hello')
        print('hello : ', self.say, self.__kbs)
        
        
pe = Person(22) # Person 생성자
pe.printInfo()  # 나이 :22, 이야기:사람
pe.hello()
# hello
# hello :  사람 공영방송

class Employee(Person):
    say = "직원"          # 자식과 동일한 멤버변수에 의해 부모의 say가 숨겨짐
    subject = '근로자'     # Employee 고유 멤버 변수
    
    def __init__(self):
        print("Employee 생성자")
        
    def printInfo(self): # 자식과 동일한 메소드에 의해 부모의 메소드가 숨겨짐. 메소드 오버라이드
        print('Employee printInfo 메소드')
        
    def empShow(self):
        say = "empShow"
        print(say)
        print(self.say)
        self.printInfo()    # 자식 -> 부모
        super().printInfo() # 부모
        

emp = Employee()         # Employee 생성자
print(emp.say, emp.age)  # 직원 20
print(emp.subject)       # 근로자
emp.printInfo()          
# 나이 :20, 이야기:직원
# Employee printInfo 메소드
emp.empShow()
# empShow
# 직원
# Employee printInfo 메소드
# 나이 :20, 이야기:직원

class Worker(Person):
    pass

wo = Worker(33)       # Person 생성자
print(wo.say, wo.age) # 사람 33
wo.printInfo()        # 나이 :33, 이야기:사람

class Worker(Person):
    hobby = '코딩'
    
    def __init__(self, age):
        print('Worker 생성자')
        #super().__init__(age) # 부모의 생성자 호출. Bound call
        Person.__init__(self, age) # UnBound call
    
    def woShow(self):
        self.printInfo()
        super().printInfo()
        
wo = Worker(27)
# Worker 생성자
# Person 생성자
wo.woShow()
# 나이 :27, 이야기:사람
# 나이 :27, 이야기:사람

class Programmer(Worker):
    def __init__(self, age):
        print('Programmer 생성자')
        Worker.__init__(self, age)
        
    def prShow(self):
        self.printInfo()
        super().printInfo()
        
    def kbsShow(self):
        print(self.say)
        #print(self.__kbs) # AttributeError: 'Programmer' object has no attribute '_Programmer__kbs'

pr = Programmer(25)
# Programmer 생성자
# Worker 생성자
# Person 생성자
print(pr.say, pr.age) # 사람 25
pr.prShow()
# 나이 :25, 이야기:사람
# 나이 :25, 이야기:사람
pr.hello()
# hello
# hello :  사람 공영방송
pr.kbsShow()

# 클래스 타입확인
a = 3
print(type(a)) # int
print(type(pr)) # __main__.Programmer
print(Programmer.__bases__) # 부모클래스 확인. __main__.Worker
print(Worker.__bases__) # __main__.Person
print(Person.__bases__) # object

---

19. 메소드 오버라이딩

: 부모 클래스의 메소드와 동일한 이름의 메소드를 자식 클래스에서 만듦(재정의)
다형성의 근거를 제시

* test23_override

class Parent:
    def printData(self): # 추상 메소드와 유사. 강제하지않음.
        pass
    
    def displayData(self):
        print('Parent의 displayData')

class Child1(Parent):
    def printData(self): # 메소드 오버라이딩
        a = 10
        b = 20
        print(str(a + b) + " 출력")

class Child2(Parent):
    def printData(self):   # override
        print('Child2 printData')
        
    def displayData(self): # override 부모 메소드를 재정의
        print('Child2 displayData')
        
    def c2method(self):    # Child2 고유 메소드
        print('Child2 c2method')

c1 = Child1()
c1.printData()   # 30 출력
c1.displayData() # Parent의 displayData
c2 = Child2()
print()
c2.printData()   # Child2 printData
c2.displayData() # Child2 displayData
print()

# 다형성
par = Parent()
par = c1          # 자식객체의 주소를 치환
par.printData()   # 30 출력
par.displayData() # Parent의 displayData
print()

par = c2          # 자식객체의 주소를 치환
par.printData()   # Child2 printData
par.displayData() # Child2 displayData
par.c2method()    # 오버라이딩 하지않은 메소드도 호출 가능
print()

# 자바와 파이썬 차이
sbs = c1          # 주소 치환시 같은 타입이 아니더라도 객체 및 메소드 사용가능
sbs.printData()
sbs.displayData()
print()
sbs = c2
sbs.printData()
sbs.displayData()
sbs.c2method()
print()

plist = [c1, c2]
for i in plist:
    i.printData()