220603 Python -11

###Python

##Class★
: 클래스= 멤버변수+멤버함수(생성자, 메소드)
: 파이썬은 파일명과 클래스명이 서로 달라도 된다

ex. Animal.py
class Animal:
    name = 'dog'              # 멤버변수 초기화
    age = 5

# 객체 생성
a1 = Animal()
# print(name)                 # 오류 발생 (지역변수에 name이 존재하지 않기 때문)
print(a1.name)                # dog
print(a1.age)                  # 5

a1.name = 'cat'              # a1객체의 변수를 새로운 값으로 초기화
a1.age = 10
print(a1.name)                # cat : 새로 저장한 값이 출력
print(a1.age)                 # 10

# 객체 생성
a2 = Animal()                # 또다른 객체 a2 생성
print(a2.name)                # dog : 따로 값을 저장하지 않았기 때문에 기존 Animal 클래스의 값이 출력
print(a2.age)                 # 5

## 생성자
: 객체가 생성될 때 호출된다
: 생성자는 멤버변수를 초기화시키는 역할

# ★생성자 : __init__()
1. 객체가 생성된 후 가장 먼저 호출되는 메소드
2. 첫번째 매개변수는 self이고, 이후 사용자 정의 매개변수 추가 가능
3. self 이외 매개변수가 있는 생성자를 만들 경우 인스턴스를 생성할 때 매개변수를 넘겨주어야 함
4. 멤버 변수의 초기화 코드를 주로 작성

# 소멸자 : __del__()
1. 객체가 소멸될 때 호출되는 메소드
2. 외부 자원을 사용하는 경우 해제하는 코드를 주로 작성
3. self 이외의 매개변수를 받지 않음
 
ex. Car.py
class Car:
    def __init__(self):             # 생성자(Constructor) : __init__ 이어야 함
       self.color = 'red'           # 바디의 색깔
       self.wheel_size = 16         # 바퀴의 크기
       self.displacement = 2000     # 배기량

             # 1. 메소드 : 클래스 내부에 존재하는 함수는 메소드라고 부름
             # 2. 클래스 내부 메소드는 반드시 첫번째 매개변수로 현재 클래스의 객체(self)를 지정해야 함
   def forward(self): 
        print('전진')
    def backward(self):
        print('후진')
    def turn_left(self):
        print('좌회전')
    def turn_right(self):
        print('우회전')

# 객체 생성
# 생성자가 존재하는 경우 new를 이용해 객체를 생성하지 않음 (하면 오류)
# 이미 변수와 메소드가 초기화되어있기 때문에 호출해서 불러와 사용하는 느낌?
 
car1 = Car()                        # 생성자 호출
# 멤버변수에 접근
print(car1.color)                   # red
print(car1.wheel_size)              # 16
print(car1.displacement)            # 2000

# 메소드 호출
car1.forward()                      # 전진
car1.backward()                     # 후진
car1.turn_left()                    # 좌회전
car1.turn_right()                   # 우회전

## 매개변수가 있는 생성자
ex. ContactInfo.py
class ContactInfo:
     # 첫번째 매개변수는 self
     # 뒤에 사용자 정의 매개변수를 추가할 경우 self.name=name ---> 객체 생성 시 추가한 매개변수로 값을 초기화
    def __init__(self, name, email):       
        self.name = name                        # name = '홍길동'
        self.email = email                      # email = 'hong@naver.com'

    def print_info(self):
        print('{0} : {1}'.format(self.name, self.email))

if __name__=='__main__':
    ahn = ContactInfo('홍길동','hong@naver.com')  # 객체생성 : 생성자 호출
    ahn.print_info()
    print('name:', ahn.name)           # name: 홍길동
    print('email:', ahn.email)            # email: hong@naver.com


## 메소드
# 클래스 메소드
1. @classmethod 데코레이터로 수식
2. 정적 메소드와 유사하지만 첫번째 매개변수로 클래스 객체가 전달됨
3. cls 매개변수 사용
class 클래스명:
   @classmethod
   def 메소드명(cls):   # 메소드 매개변수를 하나 이상 정의
      pass

# ★정적 메소드(Static method)
: 인스턴스를 생성하지 않고 클래스를 이용해 직접 호출할 수 있는 메소드
: 메소드 내에서 멤버 변수를 호출할 수 없지만, 클래스 변수는 호출할 수 있음
1. 정적 메소드는 공유를 목적으로 하는 경우에 사용한다.
2. 정적 메소드를 만들기 위해서는 메소드 위에 @staticmethod 데코레이터를 붙여서 만든다.
3. 정적 메소드는 객체를 생성하지 않고, 클래스명.정적메소드 형식으로 호출한다.
4. 정적 메소드는 self를 사용하지 않는다.

ex. Calculator.py
class Calculator:

    @staticmethod
    def plus(a,b):                  # 정적 메소드는 위에 @staticmethod 붙임
        return a+b

    @staticmethod
    def minus(a,b):
        return a-b

    @staticmethod
    def multiply(a,b):
        return a*b

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

if __name__=='__main__':             # 정적 메소드 호출
    print('{0}+{1}={2}'.format(7,4, Calculator.plus(7,4)))
    print('{0}-{1}={2}'.format(7,4, Calculator.minus(7,4)))
    print('{0}*{1}={2}'.format(7,4, Calculator.multiply(7,4)))
    print('{0}/{1}={2}'.format(7,4, Calculator.divide(7,4)))


## 사용자 정의 모듈 파일 생성
# if __name__=='__main__':
1. __name__ : 현재 모듈 이름을 가진 내장변수
2. 외부에서 import해서 사용하지 못하고★, 현재의 인터프리터에 의해서 직접 실행하고 싶은 경우에 사용한다.

ex. mode1의 내용을 call1이 import하는 경우
mode1.py
def add(a, b):
    return a+b

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

print(add(20, 10))              # 30
print(sub(20, 10))              # 10

-------> call1.py 에서 import mode1로 임포트하는 경우 print까지 전부 실행됨

ex. mode2의 내용을 call2가 import하는 경우
mode2.py
def add(a, b):
    return a+b

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

if __name__=='__main__':
    print(add(20, 10))              # 30
    print(sub(20, 10))              # 10

-------> call2.py 에서 import mode2를 한 경우 print는 실행되지 않음
-------> if __name__=='__main__' 조건이 있을 경우 외부에서 import해서 사용하지 못하게 막을 수 있음!

ex. 클래스 내부 메소드를 이용해 생성자 멤버변수를 초기화
class InstanceVar:
    def __init__(self):             # 생성자
        self.text_list = []         # 멤버변수 : 비어있는 리스트

    def add(self, *text):           # 메소드 : 리스트에 값을 추가 (가변매개변수 이용)
        self.text_list.append(text)

    def print_list(self):           # 메소드 : 리스트를 출력
        print(self.text_list)

if __name__=='__main__':
    a = InstanceVar()               # 객체 생성 : 생성자 호출
    a.add('파이썬','오라클','스프링')   # 클래스 메소드의 매개변수로 값을 전달해 생성자 매개변수(리스트)에 값을 저장
    a.print_list()                  # 리스트 출력 메소드 [('파이썬', '오라클', '스프링')]
    print(a.text_list)              # 일반 출력 [('파이썬', '오라클', '스프링')]

-----> 가변 매개변수로 '파이썬','오라클','스프링'이 tuple 형태로 넘어감 -> list에 저장됨
즉
len(text_list)=1
text_list[0]=('파이썬', '오라클', '스프링')
type(text_list[0]) = tuple


## 상속(Inheritance)
: 부모 클래스의 메소드는 상속된다 + 생성자는 상속되지 않는다
: 상속하는 클래스는 Super(상위)클래스, 상속받는 클래스는 Sub(하위)클래스

ex1.
class Base:                     # 부모 클래스, 기반 클래스
    def base_method(self):
        print('부모 메소드')

# Base 클래스를 상속받겠다고 선언함 (클래스 괄호 안에 상속할 클래스를 적음)
class Derived(Base):            # 자식 클래스, 파생 클래스
    pass                # 선언만 미리 해놓겠다는 뜻

base = Base()                   # 부모 클래스로 객체 생성
base.base_method()              # 메소드 호출

derived = Derived()             # 자식 클래스로 객체 생성
derived.base_method()           # 상속 받은 메소드 호출


ex2.
class Add:                          # 부모 클래스, 기반 클래스
    def add(self, n1, n2):
        return n1 + n2

class Calculator(Add):              # 자식 클래스, 파생 클래스
    def sub(self, n1, n2):            # 자기 메소드 정의해놓음
        return n1 - n2

# 부모 클래스로 객체 생성
ob = Add()
print(ob.add(100, 200))             # 300
# print(ob.sub(100, 200))           # 부모 클래스로 객체 생성하면 자식 클래스의 메소드는 사용할 수 없음

# 자식 클래스로 객체 생성
obj = Calculator()
print(obj.add(10, 20))              # 30 : 자식 클래스로 객체 생성하면 부모 클래스 메소드+자기 메소드 사용 가능
print(obj.sub(10, 20))              # -10


## 상속에서의 생성자
1. 생성자는 상속되지 않는다
2. 자식클래스로 객체를 생성할 때 자식클래스의 생성자가 호출된다
  --> 자식클래스의 생성자가 존재하는 경우 부모클래스의 기본생성자는 자동으로 호출되지 않음
  --> 자식클래스에서 부모클래스의 생성자를 호출 : super() 이용
        ex. super().__init__()
3. 자식클래스에 생성자가 없는 경우 기본생성자를 만들어줌
  --> 이때 자동으로 생성된 자식클래스의 기본생성자가 호출되면 부모클래스의 기본생성자를 연쇄적으로 호출함

ex. 2번 예시
class A:                                # 부모 클래스
    def __init__(self):                 # 기본 생성자
        print('부모 생성자')
        self.message = 'Hello'

class B(A):                             # 자식 클래스
    def __init__(self):                 # 기본 생성자
        print('자식 생성자')
        super().__init__()              # 부모 클래스의 생성자 호출 (super() 이용)
        print(self.message)

if __name__=='__main__':
    b = B()

ex. 3번 예시
class A:                                # 부모 클래스
    def __init__(self):                 # 기본 생성자
        self.message = 'Hello World'

    def print_message(self):            # 메소드
        print(self.message)

class B(A):                             # 자식 클래스
    pass

if __name__=='__main__':
    b = B()
    b.print_message()      # 부모 클래스 A의 생성자가 호출되면서 self.message='Hello'로 초기화되고 그 값을 print함


## 클래스 다중상속 --- java는 안되는데 파이썬은 된댜
: 2개 이상의 부모 클래스를 상속받는 것

class Add:                          # 부모 클래스1
    def add(self, n1, n2):
        print('Add')
        return n1 + n2

class Multiply:                     # 부모 클래스2
    def add(self, n1, n2):
        print('Muliply')
        return n1 + n2
    def multiply(self, n1, n2):
        return n1 * n2

               # 클래스의 다중상속 : Add, Multiply 클래스를 둘 다 상속받음
class Calculator(Add, Multiply):    # 자식 클래스
    def sub(self, n1, n2):
        return n1 - n2

obj = Calculator()                  # 자식클래스로 객체 생성하면 다 가져오기 쌉가능
print(obj.add(10, 20))              # 30 : Add클래스의 add()실행
print(obj.multiply(10, 20))         # 200
print(obj.sub(10, 20))              # -10

------> 단, 두 부모클래스에 각각 add메소드가 존재하는 이런 경우 오류가 발생할 수 있음 (원하는 메소드를 제대로 불러오지 못할 수 있단 뜻)


## ★메소드 오버라이딩(Method Overriding)
1. 부모클래스로 부터 상속받은 메소드를 자식클래스에서 재정의 해서 사용하는 것을 의미한다.
2. 부모클래스의 메소드 이름과 형식을 그대로 가지면서, 내용만 다르게 기술하는 것을 의미한다.
3. 메소드 오버라이딩을 하면, 메소드 오버라이딩된 메소드만 호출된다.
4. 부모클래스의 은닉된 메소드를 호출하려면, 자식클래스의 메소드 안에서 super()를 이용해서 호출한다.   ex)  super().mymethod()

class A:                            # 부모 클래스
    def mymethod(self):             # 은닉 메소드
        print('부모 메소드')

class B(A):                         # 자식 클래스
    def mymethod(self):             # 메소드 오버라이딩
        super().mymethod()          # 부모 클래스의 은닉 메소드를 호출함
        print('B클래스의 메소드')

class C(A):                         # 자식 클래스
    def mymethod(self):             # 메소드 오버라이딩
        print('C클래스의 메소드')



## 예외처리
 예외 : 프로그램상에서 발생하는 예상하지 못한 오류
 예외처리 : 프로그램을 안전하게 종료시키기 위해 예외처리를 한다.
 형식 : try ~ except

try:
      n = int(input('정수를 입력 하세요?'))

      if n%2 == 0:
          print('짝수')
      else:
          print('홀수')
except:
      print('예외가 발생 했습니다.')


# 예외 처리 : try ~ except ~ except
 : Exception 클래스로 예외를 받으면 다른 except로 넘어가지 않으므로 가장 마지막에 배치할 것


# 예외처리 : try ~ except ~ else
 : try에 대한 else가 아니라, except에 대한 else

try:
     예외가 발생할 가능성이 있는 문장
except:
    예외가 발생 했을때 실행될 문장
else:
    except절이 실행되지 않는 경우에 실행될 문장


# 예외처리 : try ~ except ~ finally
'''
try:
    예외가 발생할 가능성이 있는 문장
except:
    예외가 발생 했을때 실행될 문장
finally:
    예외 유무에 상관없이 무조건 실행됨
    파일 닫기, 데이터베이스와 연결을 끊는 내용


# raise문: 프로그래머가 강제로 예외를 발생
def some_function():
    num = int(input('1~10 사이의 정수를 입력하세요?'))
    if num<1 or num>10:     # 강제로 예외발생 시킴
        raise  Exception('유효하지 않는 숫자입니다.{0}'.format(num))
    else:
        print('입력한 숫자는 {0}입니다.'.format(num))

+ 사용자 정의 예외 클래스도 생성 가능