'''
여러줄 주석
'''

# 한줄주석

print('type(자료형)확인')
print(3, type(3))
print(3+4j, type(3+4j))
print(True, type(True))

print('Hi, my name is YoungJin Kang')

print('출력1', end = ' ') # end를 쓰면 줄바꿈이 일어나지 않음
print('출력2')
print('출력1', \
      end = ' ') # 가독성을 위해 \를 넣는다
print('출력2')

a = 10
b = 20.5
c = b
d = 10
print(a,b,c,d)
print('주소 출력 : ', id(a),id(b),id(c),id(d))    # id(a)는 a의주소를 반환한다
print(a is b) # 주소 비교 명령어 is
print(a == b) # 값 비교 명령어 ==

v1 = 1,2,3
print(v1)    # 튜플 형태로 반환

print()
v1, v2 = 10, 20
print(v1, v2)
v2, v1 = v1, v2
print(v1, v2)

print()
v1, *v2 = 1, 2, 3, 4, 5     # *은 paking 연산
print(v1)
print(v2)

print("안녕하세요. \n제 이름은 홍길동 \t입니다.\\ \\'")

print(12414.5678) 
print(format(12414.5678, '0.2f'))    # 소수점 둘째자리까지 표현   
print('냥이의 나이는 %d이다'%3)     # 문자열(%s), 정수(%d), 소수(%f)
print('냥이의 나이는 %s이다'%'세살') 
print('냥이의 나이는 %d이며 장난감은  %s %s'%(2, '공', '마우스'))  # 여러개일때는 튜플형식으로 써야함

#다른방법
print()
print('이름은 {}, 나이는 {}살'.format('tom', 22))
print('이름은 {1}, 나이는 {0}살'.format(22, 'tom'))

a = 'Life is too short'

print(a.count("i"))    # a에서 i의 개수
print(a.find("i"))     # 첫번째로 i가 나오는 위치
print("9".join(a))     # a의 모든 문자 사이에 9를 집어 넣는다
print(a.lower())       # 소문자 변환
print(a.upper())       # 대문자 변환
print(a.swapcase())    # 소문자는 대문자로, 대문자는 소문자로
print(a.replace("Life","My leg"))    # a안에 모든 Life를 My leg로 바꾼다
print(a.split("i"))    # a 를 i를 기준으로 나누기

print(10, oct(10), hex(10), bin(10)) # 10진수, 8진수, 16진수, 2진수
print(10, 0o12, 0xa, 0b1010)

print(5 + 3)    # 더하기
print(5 - 3)    # 빼기
print(5 * 3)    # 곱하기
print(5 / 3)    # 나누기
print(5 // 3)   # 몫
print(5 % 3)    # 나머지
print(divmod(5, 3))  # (몫,나머지)

family = ['엄마', '아빠', '나', '여동생']

print(len(family))

family.append('남동생')        
print(family)

family.insert(0, '할아버지')   
print(family)

family.extend(['삼촌', '조카'])
print(family)

family += ['이모', '고모']
print(family)

family.remove('나')  
print(family)

del family[1]
print(family)

family.reverse()
print(family)

import copy
name = ['tom','james','oscar']
name3 = copy.deepcopy(name)     # 깊은 복사, 완전 별개의 list가됨
print(name3)

# 튜플의 요솟값을 삭제할 때는 슬라이싱으로 삭제 해야 한다.

t1 = (1,2,"a","b")

# a 를 삭제하기
t1 = t1[:2]+t1[3:]
print(t1)

t1 = (1,2,"a","b")
t2 = (3,4)

# 튜플 더하기
print(t1 + t2)

# 튜플곱하기
print(t2 * 3)

# 튜플 길이
print(len(t1))

a = {1, 2, 3, 1}
b = {3, 4}

print(a, len(a))
print(a.union(b))         # 합집합
print(a.intersection(b))  # 교집합
print(a | b)              # 합집합
print(a & b)              # 교집합
print(a - b)              # 차집합

dic = {'파이썬':'뱀', '자바':'커피', '컴퓨터':'AI'}

# 요소 추가
dic['오라클'] = '예언자'  
print(dic)

# 수정
dic['자바'] = '프로그래밍 언어' 
print(dic)

#삭제
del dic['오라클']  
print(dic)

# 삭제
dic.pop('파이썬') 
print(dic)

# 전체 삭제
dic.clear()
print(dic)

friend = {'boy':'한국인', 'girl':'한송이', 'guy':'손오공'}

# friend 안에서 key 값 반환
print(friend.keys())

# friend 안에서 value 값 반환
print(friend.values())

# key가 friend 안에 있는지 조사
print('boy' in friend)

# key로 value 얻기
print(friend.get('boy'))

# key값을 기준으로 오름차순
pi_list1= []
for key, value in sorted(pi.items(), key=lambda x:x[0]):
    pi_list1.append(key+":"+str(value))
print(pi_list1)

# key값을 기준으로 내림차순
pi_list2 = []
for key, value in sorted(pi.items(), reverse=True, key=lambda x:x[0]):
# key값이 정수라면 이렇게도 가능 for key, value in sorted(pi.items(), key=lambda x:-x[0]):  
    pi_list2.append(key+":"+str(value))
print(pi_list2)

# value값을 기준으로 오름차순
pi_list3 = []
for key, value in sorted(pi.items(), key=lambda x:x[1]):
# key까지 오름차순 하고 싶으면 for key, value in sorted(pi.items(), key=lambda x:(x[1],x[0])):
    pi_list3.append(key+":"+str(value))
print(pi_list3)

# value값을 기준으로 내림차순
pi_list4 = []
for key, value in sorted(pi.items(), key=lambda x:-x[1]):
    pi_list4.append(key+":"+str(value))
print(pi_list4)

# 조건 판단문 if

var = 5
var2 = 10
if var >= 3 and var2 >= 5:    # and 는 두개의 조건을 모두 만족해야함 
    print('크구나')    # 들여쓰기는 tap 또는 띄어쓰기4번
    print('참일 때 수행\n')

if var <= 3 or var2 >= 2 + 3:    # or 은 둘중 하나의 조건만 만족하면됨
    print('크구나2')
    print('참일 때 수행2\n')
else:
    print('ㅠㅠ 작아')
    print('거짓말일 때 수행')

money = 200
age = 23

if money >= 500:
    item = 'apple'
    if age <= 30:
        msg = 'young'
    else:
        msg = 'old'
        msg += 'good'
else:
    item = 'banana'
    if age >= 20:
        msg = '성인'
    else:
        msg = '아이'
        msg += '귀여워'

print(item, msg)
print('프로그램 종료')

jum = int(input('점수 입력 : '))    # int() 문자를 숫자화
print(jum, type(jum))

if jum >= 50:
    print('성공')
else:
    print('실패 이유는 입력 값이 ' + str(jum)+ '이기때문')

a  = 3
if a > 5:
    res = a * 2
else:
    res = a + 2
print('res : ', res)

res = a * 2 if a > 5 else a + 2
print('res : ',res)

print((a + 2,a * 2)[a > 5])

a = 1 
while a <= 5:    # a 가 5보다 작으면 계속 수행
    print(a, end = ' ')
    a += 1
print()
print('while 문 수행 후 a : ',a)
print('종료')

a = 1
hap = 0    # 누적값을 여기다가 저장
while a <= 10:
    print(a, end = ' ')
    hap += a
    a += 1 
print('\n합은 ' + str(hap))
print('종료')

a = 1
hap = 0
while a <= 10:
    if a % 2 == 0:    # '2로 나누었을때 나머지가 0일때' 라는 조건
        print(a)
        hap += 1
    a += 1    

i = 1
while i <= 3:   # 총 3번 순환
    j = 1
    while j <= 4:     # 총 4번 순환
        print('i: ' + str(i) + ' j=' + str(j))
        j += 1
    i += 1
    print('---')
print('종료')

colors = ['red', 'green', 'blue', 'yellow']    # 리스트
a = 0
while a < len(colors):   # a가 list의 길이보다 작을 때 
    print('colors : ',colors[a])    # colors 리스트 안의 a번째 원소 (시작은 0)
    a = a + 1
print('colors 크기 : ', len(colors))
print('종료')

i = 1    # i 초기값 1
while i <= 10:
    j = 1    # j 초기값 1
    disp = ''
    while j <= i:    # j 가 i 보다 작을때 
        disp = disp + "*"
        j += 1
    print(disp)
    i += 1

import time    # 인터벌을 줄 수 있음

sw = input('스위치를 누를까요?[y/n]')    # 타입을 안적으면 str이 기본
if sw == 'Y' or sw == 'y':
    count = 5
    while 1 <= count:
        print('%d초 남았어요'%count)
        time.sleep(1)    # 1초 연기
        count -= 1
    print('폭발!!!')
elif sw == 'N' or sw == 'n':
    print('작업취소')
else:
    print('y 또는 n을 누르시오')

a = 0
while a < 10:
    a += 1
    if a == 5: continue    # 밑에거 실행을 안하고 다시 while로 감
    if a == 7: break       # 반복문의 무조건 탈출
    print(a)
else:
    print('while 정상 수행')
print('while 처리 후 a : %d'%a)

while True:
    aa = int(input('짝홀수 확인할 숫자:'))
    if aa == 0:
        print('안녕')
        break
    elif aa % 2 == 0:
        print('%d는 짝수'%aa)
        # continue
    elif aa % 2 == 1:
        print('%d는 홀수'%aa)
        # continue

import random    # 난수 관련 모듈

# random.seed()    # 난수표 선택
print(random.random())    # 0 ~ 1 사이의 난수 발생
print(random.randint(1,10))    # 1 ~ 10 사이의 정수 발생

friend = ['tom', 'james', 'oscar']
print(random.choice(friend))
print(random.sample(friend, 2))
random.shuffle(friend)
print(friend)

num = random.randint(1, 10)
while True:
    print('1 ~ 10 사이의 컴이 가진 정수 예상 숫자 입력: ')
    guess = input()
    su = int(guess)
    if su == num:
        print('성공 ~~~')
        break
    elif su < num:
        print('더 큰 수 입력해')
    elif su > num:
        print('더 작은 수 입력해')

for i in [1, 2, 3, 4, 5]:
    print(i, end = ' ')
print()

# List
colors = ['r', 'g', 'b']
for c in colors:
    print(c, end = ' ')
print()

# Set
colors = {'r', 'g', 'b', 'b', 'r'}
for c in colors:
    print(c, end = ' ')
print()

# Tuple
colors = ('r', 'g', 'b')
for c in colors:
    print(c, end = ' ')
print()

# Dictionary
soft = {'jave':'웹용언어', 'python':'만능언어', 'MariaDB':'데이터베이스'}
for i in soft.items():
    print(i[0] + ' ' + i[1])
print()

for k, v in soft.items():    #  변수 두개로도 받을 수 있다.
    print(k, ' , ', v)
print()

for k in soft.keys():
    print(k, end = ' ')
print()

for v in soft.values():
    print(v, end = ' ')

li = ['a', 'b', 'c']
for i, d in enumerate(li):
    print(i, d)

datas = [1, 2, 3, 4, 5]
for i in datas:
    if i == 3:
        # break
        continue
    print(i, end = ' ')
else:
    print('\nfor문 정상 처리')

l1= [3, 4, 5]
l2 = [0.5, 1, 2]
datas = [a + b for a in l1 for b in l2]
print(datas)

import re

ss = """
테슬라와 스페이스X를 이끌고 있는 일론 머스크가 NBC 방송의 인기 코미디 쇼 ‘새너데이나이트 라이브(SNL)’ 진행자로 나선다.
일론 머스크가 오는 5월8일(이하 현지시간) SNL 진행자를 맡기로 했다고 씨넷을 비롯한 주요 외신들이 24일 보도했다.
이날 방송에는 유명 가수이자 배우인 마일리 사이러스가 게스트로 출연한다.
일론 머스크가 SNL 진행을 맡는 것은 이번이 처음이다. 반면 마일리 사이러스는 그 동안 SNL에 다섯번 출연했으며, 이번이 여섯 번째다.
"""

ss2 = re.sub(r'[^가-힝\s]','',ss)
print(ss2)

for test_str in ["111-1234", "일이삼-사오육칠", "222-2222"]:
    if re.match(r"^\d{3}-\d{4}", test_str): #^\d{3}-\d{4} 숫자 3자리, 숫자 4자리
        print(test_str, "전화번호 맞네용")
    else:
        print(test_str, "전화번호 아니네용")

from time import localtime
action = {6:'잠', 9:'아침먹고 출근', 18:'일하기', 24:'휴식', 20:'야근'}
print(action)
print(sorted(action.keys()))    # key 오름차순 정리

hour = localtime().tm_hour
print('현재 시간은 ', hour)

for action_time in sorted(action.keys()):
    if hour < action_time:
        print(action[action_time])
        break

price = {'사과':1000, '배':2000, '수박': 15000}    # 오늘의 과일 시세
guest = {'사과':2, '수박':1}
bill = sum(price[f] * guest[f] for f in guest)
print('손님이 구매한 과일 가격 총액 {}원'.format(bill))

for i in range(6):
    print(i, end = ' ')
print()

tot = 0
for i in range(1, 11):    # range(시작부분, 끝나는부분, 간격)
    tot += i
print('결과 : ', tot)
print('결과 : ', sum(range(1, 11)))

# 런타임 에러 잡기

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

try:
    c = divide(5, 2)    # ZeroDivisionError 
    print(c)
    
    aa = [1, 2]
    print(aa[0])
    print(aa[3])    # IndexError

except ZeroDivisionError:
    print('두번째 숫자는 0을 주면 안돼요')
    
except IndexError as err:    # 시스템이 제공하는 에러 정보를 얻고자 할때
    print('참조 범위 오류 : ', err.args)
    
except Exception as e:    # 위에 지정된 에러 이외는 모두 여기서 처리
    print('에러 발생 : ', e)
    
finally:
    print('에러에 상관없이 반드시 수행되는 영역')

def DoFunc1():
    print('DoFunc1 수행')

print('뭔가를 다시 하다가 함수 호출 1회')
DoFunc1()

print('뭔가를 다시 하다가 함수 호출 2회')
DoFunc1()

print('함수의 이름은 객체의 주소 : ', DoFunc1)
OtherFunc = DoFunc1
OtherFunc()

def DoFunc2(msg):    # 매개변수, parameter
    print('DoFunc2 수행')
    print(msg)
DoFunc2('good')    # 인수, 인자, arguments
DoFunc2(123)

print(DoFunc2(123))    # None이 출력 (def 안에 return None이 생략되있음)

def Area_tri(a,b): 
    c = a * b / 2 #c는 Area_tri에서만 쓸수 있음
    Area_print(c) #함수가 다른 함수를 호출
    print("면적출력 후 돌아옴")
    
def Area_print(cc):
    print("삼각형의 면적은 ",cc)
    
Area_tri(10, 20)

player = '전국대표'    # 전역변수 (모듈의 어디서든 통용)

def FuncSoccer():
    name = '홍길동'
    player = '지역대표'    # 지역변수 (특정 블럭 내에서만 유효)
    print(name, player)
    
print(player)
FuncSoccer()
# print(name)   # NameError : name 'name' is not defined


# 함수 내부에 함수 작성

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

def func1():
    a = 40
    b = 50
    def func2():
        global c    # global 은 변수를 전역 수준으로 끌어올림
        nonlocal b    # nonlocal 은 변수를 함수 수준으로 끌어올림
        print('출력2=> a:{}, b:{}, c:{}'.format(a, b, c))
        c = 60   
        b = 70
    func2()
    print(b)
func1()
print('출력3=> a:{}, b:{}, c:{}'.format(a, b, c))

def ShowGugu(start, end = 5):
    for dan in range(start, end + 1):
        print(str(dan) + '단 출력')

ShowGugu(2, 3)
print()
ShowGugu(3)
print()
ShowGugu(end = 3, start = 2)

def func1(*ar):    # * 을 쓰면 Tuple 형식으로 받아들임
    for i in ar:
        print('음식 : ' + i, end = ' ')
func1('비빔밥')
print()
func1('비빔밥', '김밥', '공기밥')    # Tuple 형식으로 반환됨

def func3(w, h, **other):     # ** 을 쓰면 Dict 형식으로 받아들임
    print('몸무게:{}, 키:{}'.format(w, h))
    print('기타 : ', other)
func3(65, 177, irum = '지구인', nai = 23, addr = '강남')

def func4(a, b, *v1, **v2):
    print(a, b)
    print(v1)
    print(v2)
func4(1,2,3,m = 4,n = 5)

# 클로저를 사용하지 않은 경우

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

# 클로저를 사용한 경우

def outer():
    count = 0
    def inner():
        nonlocal count
        count += 1
        return count
    return inner    # <- 요게 클로저 : 내부 함수의 주소 반환
var1 = outer()
print(var1)    # inner 함수객체의 주소
print(var1())
print(var1())
print(var1())

# def로 표현
def Hap(x, y):
    return x + y
print(Hap(1, 2))

# lambda로 표현
print((lambda x, y:x + y)(1, 2))

juso = lambda x, y:x + y
print(juso(1, 2))

# lambda도 매개변수에 초기치 사용 가능
kbs = lambda a, su = 10:a + su
print(kbs(5))
print(kbs(5, 6))

# filter 사용  filter(함수, 묶음형 자료)
print(list(filter(lambda a:a < 5, range(1,11))))
print(list(filter(lambda a:a % 2, range(1,11))))

def make2(fn):
    return lambda:'안녕 ' + fn()    # argument는 없음

def make1(fn):
    return lambda:'반가워 ' + fn()

def hello():
    return "홍길동"

# 장식자를 사용하지 않고 함수 처리하기
hi = make2(make1(hello))
print(hi())

# 장식자를 사용하여 함수 처리하기
@make2    # make2 가 make1을 감싸고
@make1    # make1 이 hello2를 감싼다
def hello2():
    return '신기해'
print(hello2())

def CountDown(n):
    if n == 0:
        print('완료')
    else:
        print(n, end = ' ')
        CountDown(n - 1)
CountDown(5)

# 표준 모듈

import sys
print(sys.path)
# print(sys.exit())

import math
print(math.pi)
print(math.sin(math.degrees(30)))

import calendar
calendar.setfirstweekday(6)    # 일요일을 첫 요일로 설정
calendar.prmonth(2021,4)

import random    
from random import randint    # randint() 로 실행가능
from random import *     # random 모듈안에 있는 모든 함수를 random. 안쓰고 사용가능

# 메인 모듈: 응용프로그램의 시작
# 다른 모듈에 있는 함수 끌어다 쓰기

"""
import 패키지이름.모듈이름       # 패키지가 경로 설정이 되어있으면, 패키지이름 생략하고 모듈이름으로만 import 가능
                                   이클립스 경로 설정 방법 Preferences -> pydev -> interpreters -> python interpreters

패키지이름.모듈이름.함수이름()
"""

print('TestClass.memberVar : ',TestClass.memberVar)    # 클래스의 이름으로 멤버 변수 호출
#TestClass.memberMethod()    # 클래스의 이름으로 멤버 메소드는 호출 X

print()
test = TestClass()    # 객체 생성
print(test)    
print(type(test))    # <class '__main__.TestClass'> class 는 타입 생성기이다

print()
test.memberMethod()    # 객체변수.메소드명() 하면 자동으로 객체변수 인수로 담겨서 호출이 진행이 된다. Bound method call
TestClass.memberMethod(test)    # 클래스명.메소드(객체변수) Unbound method call

test2 = TestClass()    # TestClass 클래스 타입의 새로운 객체 생성
print(type(test2), id(test2))    # 각 객체는 다른 주소를 가짐

print()
test3 = TestClass()
print(type(test3), id(test3))

print()
print(isinstance(test2, TestClass))    # type 확인

car1 = Car('tom', 10)
print(car1.handle, car1.speed, car1.name)
print(car1.showData())
car1.color = '검정'    # car1 객체에 멤버 추가
print('car1.color : ', car1.color)

print()
car2 = Car('james', 30)
print(car2.handle, car2.speed, car2.name)
print(car2.showData())

print('car1 멤버 : ', car1.__dict__)
print('car2 멤버 : ', car2.__dict__)

print()
car1.speed = 50
car2.speed = 100
print("car1 :", car1.showData())
print("car2 :", car2.showData())

kor = 100    # 전역변수

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

class My:
    kor = 90    # 지역변수
    
    def abc(self):
        print('메소드')
    
    def showData(self):
        kor = 88
        print(self.kor)
        print(kor)    # 지역변수를 찾고 없으면 멤버의 전역변수를 찾음
        
        self.abc()    # 메소드 호출
        abc()    # 함수 호출

my = My()
my.showData()

class Animal:
    __slots__ = ['name', 'nai']    # 멤버변수를 고정시켰기 때문에, 다른 멤버변수를 추가 할수 없다.
    
    def printData(self):
        print(self.name, self.nai)
        
ani = Animal()
ani.name = 'tiger'
ani.nai = 3
ani.printData()
# ani.eat = '동물'    # 멤버변수 추가할 수 없음

class PohamCar:
    turnShow = '정지'
    
    def __init__(self, ownerName):
        self.ownerName = ownerName
        self.handle = PohamHandle()    # 상속
    
    def turnHandle(self, q):    # 운전을 하며 핸들을 움직이는 메소드
        # 회전량이 0이면 직진, 양수이면 우회전, 음수이면 좌회전
        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__':    # 실행함수, 이 조건은 항상 True
    tom = PohamCar('톰')
    tom.turnHandle(10)
    print(tom.ownerName + '의 회전량은 ' + tom.turnShow + str(tom.handle.quantity))
    tom.turnHandle(-20)
    print(tom.ownerName + '의 회전량은 ' + tom.turnShow + str(tom.handle.quantity))
    oscar = PohamCar('오스카')
    oscar.turnHandle(0)
    print(oscar.ownerName + '의 회전량은 ' + oscar.turnShow + str(oscar.handle.quantity))

class LottoShow:
    def __init__(self):
        self.machine = LottoMachine()    # 클래스의 포함
    
    def playLotto(self):
        input('로또 볼을 뽑으려면 엔터키를 누르세요')
        selectBalls = self.machine.selectBall()
        print('\n당첨번호')
        for ball in selectBalls:
            print('%d'%ball.num)
if __name__ == '__main__':
    LottoShow().playLotto()
        

fr = Fridge()
apple = FoodData('사과', '2021-5-5')
fr.open()
fr.put(apple)
fr.close()

print()
cola = FoodData('콜라', '2022-5-15')
fr.open()
fr.put(cola)
fr.close()

# 이곳은 다른 모듈이라고 가정

# from pack3.c19_etc import Robot    # 다른 모듈에 있는 class를 불러올 수 있다

robot1 = Robot()
print('이름 : ', robot1.name)
print('에너지 : ', robot1.energy)
print('공격 필살기 : ', robot1.attack())

print()
robot2 = Robot
robot2.name = '아이언맨'    # 여기서 프로토 타입을 변경시켰음
print('이름 : ', robot2.name)
print('에너지 : ', robot2.energy)
print('공격 필살기 : ', robot2.attack(robot2))

print()
print('이름 : ', robot1.name)

dog1 = Dog()    # 자신의 생성자를 실행하는데, 자신의 생성자가 없으면 부모의 생성자를 실행한다!!!!!!!!!!! 매우 중요!!!!
print(dog1.age)
dog1.my()
dog1.move()
print()

class Horse(Animal):
    pass

horse1 = Horse()    # 자신의 생성자를 실행하는데, 자신의 생성자가 없으면 부모의 생성자를 실행한다!!!!!!!!!!! 매우 중요!!!!
horse1.move()

class Employee(Person):
    say = '일하는 동물'    # 부모와 같은 멤버 변수에 다른 값이 기억되어 있다
    subject = '근로자'    # Employee 고유 멤버 변수
    def __init__(self):
        print('Employee 생성자')
    
    def EprintInfo(self):
        self.printInfo()    # 현재 클래스에서 메소드를 찾고 없으면 부모 메소드에서 찾아라
        super().printInfo()    # super()에 의해 부모 메소드를 참조한다
        print(self.say)
        print(super().say)
        
    def printInfo(self):
        print('오버라이딩 : 부모와 같은 이름의 메소드를 자식에서도 선언')

empl = Employee()
print()
print(empl.say, empl.nai)
print()
empl.EprintInfo()

class Worker(Person):

    def __init__(self, nai):
        print('Worker 생성자')
        super().__init__(nai)    # 워커의 부모 생성자를 호출!!!  ※ 중요 ※  (이부분이 없으면 Worker 클래스의 생성자만 실행됨)
        
    def WprintInfo(self):
        self.printInfo()

work = Worker(31)
work.WprintInfo()

class Programmer(Worker):
    def __init__(self, nai):
        print('Programmer 생성자')
        super().__init__(nai)    # Worker.__init__(self, nai) 처럼 Unbound call 방식으로 써도 된다
    
    def PprintInfo(self):
        self.printInfo()

pr = Programmer(33)
print(pr.say, pr.nai)

# 클래스 타입 확인
print(type(work))
print(Programmer.__bases__)    # 부모 클래스 확인
print(Worker.__bases__)
print(Person.__bases__)    # 모든 클래스의 최상위 클래스는 object 이다

class Parent:
    def PrintData(self):
        pass
        
class Child1(Parent):
    def PrintData(self):
        print('Child1 에서 override')

class Child2(Parent):
    def PrintData(self):
        print('Child2 에서 override')
        print('부모 메소드와 동일한 이름이지만 수행하는 내용은 다르다')
        
c1 = Child1()
c1.PrintData()
c2 = Child2()
c2.PrintData()

class Liger1(Tiger, Lion):    # 다중 상속, 먼저 적은게 우선순위 높음
    pass

lig1 = Liger1()
print(lig1.data)
lig1.Cry()    # Tiger를 먼저 상속함
lig1.Eat()
lig1.Hobby()

def Hobby():
    print('모듈의 멤버 함수')

class Liger2(Lion, Tiger):    
    data = '라이거 만세'
    
    def Play(self):
        print('라이거 고유 메소드')
        
    def Hobby(self):
        print('라이거는 초원 걷기를 좋아함 ')
        
    def Display(self):
        self.Hobby()
        super().Hobby()
        Hobby()
        print(self.data + ", " + super().data)

lig2 = Liger2()
lig2.Display()

from abc import ABCMeta, abstractmethod

class AbstractClass(metaclass = ABCMeta):    # 추상 클래스가 된다
    
    @abstractmethod
    def absMethod(self):    # 추상 메소드  (오버라이딩 해야지 추상에서 벗어남)
        pass
        
    def normalMethod(self):
        print('추상 클래스 내의 일반 메소드')

# ab = AbstractClass()    # Can't instantiate abstract class

class Child1(AbstractClass):
    name = '난 Child1 ~'

# c1 = Child1()    # Can't instantiate abstract class

class Child2(AbstractClass):
    name = '난 Child2 ~'
    
    def absMethod(self):
        print('추상 메소드를 오버라이딩 함')

c2 = Child2()
print(c2.name)
c2.absMethod()
c2.normalMethod()
print()

class Child3(AbstractClass):
    def absMethod(self):
        print('추상 메소드를 재정의 함, 추상의 마법에서 벗어 날 수 있게 된다')
        
    def normalMethod(self):
        print('추상 클래스의 일반 메소드를 오버라이딩 함')

c3 = Child3()
c3.absMethod()
c3.normalMethod()

john = John('존', '테헤란로')
john.printName()
john.printAddr()
john.hobby()

print()
chris = Chris('크리스', '중구 필동')
chris.printName()
chris.hobby()

print()
fr = [john, chris]
for f in fr:
    f.hobby()
    

import os
print(os.getcwd())    # 지금 작업하고 있는 파일 위치 반환

try:
    # 파일 읽기
    f1 = open("C:/Users/kyjma/OneDrive/바탕 화면/work/psou/ftest.txt", encoding="utf-8")    # encoding 추가를 안하면 'cp949' 오류가 뜸                                                                                           
    # f1 = open(os.getcwd() + "/ftest.txt")  이렇게 해도됨
    print(f1)
    print(f1.read())    # 파일의 끝을 만날 때 까지 계속 행 단위로 읽기
    f1.close()
    print()
    
    # 파일 저장
    f2 = open("ftest2.txt", mode = 'w', encoding='utf-8')    # 같은 폴더안에 있으면 파일명만 입력해도 됨
    f2.write("My friends\n")
    f2.write("홍길동, 한국인")
    f2.close()
    print('친구 자료 저장 완료')
    
    # 파일 추가
    f2 = open("ftest2.txt", mode = 'a', encoding="utf-8")
    f2.write('\n사오정')
    f2.write('\n저팔계')
    f2.write('\n손오공')
    f2.close()
    print('친구 자료 추가 완료')
 
    
    # 친구자료 파일 읽기
    f3 = open('ftest2.txt', mode = 'r', encoding="utf-8")
    print(f3.read())
    f3.close()
    print()
    
    # 한행씩 읽기
    f3 = open('ftest2.txt', mode = 'r', encoding="utf-8")
    print(f3.readline())
    print(f3.readline())
    print(f3.readline(1))    # 한 행 중 정해진 숫자 만큼의 문자 열 읽기
    print(f3.readline(2))
    lines = f3.readlines()    # 리스트로 모든 행 읽기
    print(lines)
    f3.close()
    
except Exception as e:
    print('에러 : ', e)
    

import pickle

try:
    dicData = {"tom":'111-1111', '길동':'222-2222'}
    listData = ['파이썬', '자바']
    tupleData = (dicData, listData)
    
    # 객체를 파일로 저장 (binary 형식으로 저장)
    with open('hello.dat', mode = 'wb') as objf1:    # with 구문 사용 : close()를 적지 않아도 된다
        pickle.dump(tupleData, objf1)
        pickle.dump(listData, objf1)
    print('객체 저장 완료')    # 현재 모듈 이외의 어디서든 저장된 객체를 재사용 가능
    
    # 저장된 객체 읽기
    with open('hello.dat', mode = 'wb') as objf2:
        a, b = pickle.load(objf2)    # pickle.load(파일객체)
        print(a)
        print(b)

except Exception as e:
    print('에러 : ', e)