주민등록번호 판별 실습

import datetime
from datetime import datetime, date
from re import findall, match, sub
#jumin = '202229-3234567'
jumin = '990101-3034918'
#jumin = input('주민등록번호를 입력하세요(하이픈 포함)')
print('입력한 주민등록번호는 : ', jumin, '입니다')
flag = {}
if int(jumin[7]) == 1 or int(jumin[7]) == 2: year = int(jumin[0:2]) + 1900
if int(jumin[7]) == 3 or int(jumin[7]) == 4: year = int(jumin[0:2]) + 2000
#
if year % 4 ==0 :
    if year % 100 == 0 :
        if year % 400 == 0:
            year = '윤년' 
            month = [31,29,31,30,31,30,31,31,30,31,30,31]
        else:
            year = '평년'
            month = [31,28,31,30,31,30,31,31,30,31,30,31]
    else:
        year = '윤년'
        month = [31,29,31,30,31,30,31,31,30,31,30,31]
else:
    year = '평년'
    month = [31,28,31,30,31,30,31,31,30,31,30,31]
#
# print('평년/윤년 ---> ',year)  # 서비스코드
#
result = match('[0-9]{6}-[1-4][0-9]{6}', jumin)
if len(jumin[0:]) > 14 :
    flag['flag1'] = '년도의 자리수 또는 뒷자리의 첫 숫자오류'
    flag1 = False
else:
    flag['flag1'] = '*'
    flag1 = True
#
if 1 <= int(jumin[2:4]) <= 12 :  # 월의 숫자를 필터링
    flag['flag2'] = ''
    flag2 = True
else:
    flag['flag2'] = '앞자리의 월 오류'
    flag2 = False
#
if len(jumin[7:]) > 7 :
    flag['flag3'] = '뒷자리의 글자수 오류'
    flag3 = False
else:
    flag['flag3'] = '*'
    flag3 = True
#
if result and flag1 and flag2 and flag3 :
    print('****주민번호 필터링 성공 ')
else :
    print('잘못된 주민번호')
    print('flag[flag1] : ', flag['flag1'])
    print('flag[flag2] : ', flag['flag2'])
    print('flag[flag3] : ', flag['flag3'])

윤년 판정

if year % 4 ==0 :
    if year % 100 == 0 :
        if year % 400 == 0:
            year = '윤년' 
            month = [31,29,31,30,31,30,31,31,30,31,30,31]
        else:
            year = '평년'
            month = [31,28,31,30,31,30,31,31,30,31,30,31]
    else:
        year = '윤년'
        month = [31,29,31,30,31,30,31,31,30,31,30,31]
else:
    year = '평년'
    month = [31,28,31,30,31,30,31,31,30,31,30,31]

필터 1

if len(jumin[0:]) > 14 :
    flag['flag1'] = '년도의 자리수 또는 뒷자리의 첫 숫자오류'
    flag1 = False
else:
    flag['flag1'] = '*'
    flag1 = True

필터 2

if 1 <= int(jumin[2:4]) <= 12 :  # 월의 숫자를 필터링
    flag['flag2'] = ''
    flag2 = True
else:
    flag['flag2'] = '앞자리의 월 오류'
    flag2 = False

필터 3

if 1 <= int(jumin[2:4]) <= 12 :  # 월의 숫자를 필터링
    flag['flag2'] = ''
    flag2 = True
else:
    flag['flag2'] = '앞자리의 월 오류'
    flag2 = False
#
if len(jumin[7:]) > 7 :
    flag['flag3'] = '뒷자리의 글자수 오류'
    flag3 = False
else:
    flag['flag3'] = '*'
    flag3 = True

주민번호 필터링 기법 고도화

프로그램 소스를 기준으로 외부에서 입력된 수많은 형식의 데이터가 있습니다.
csv형식, text형식, json형식 등이 있습니다.
개발자는 이러한 형식의 데이터가 자신의 코드를 실행하는데 문제를 일으키지 않도록 점검해야 합니다.
이러한 과정을 필터링이라고 합니다.
숙련된 개발자로 인정받기 위한 좋은 방법은 자신만의 필터링 경험을 축적하는 것입니다.
다른 개발자에 비하여 고급스런 결과물을 만들어 내기 위해 필터링을 고도화 하려는 태도는 매우 바람직합니다.

# 맨 위 코드에 이어서 추가
if 1 <= int(jumin[4:6]) <= month[(int(jumin[2:4]))-1] :  # (1)
    flag['flag4'] = '*'
    flag4 = True
else:
    flag4 = False
    flag['flag4'] = '앞자리중 월에 대한 일자 오류'
#
 
###
if result and flag1 and flag2 and flag3 and flag4 and flag4 :
    print('****주민번호 필터링 성공 ')
else :
    print('잘못된 주민번호')
    print('flag[flag1] : ', flag['flag1'])
    print('flag[flag2] : ', flag['flag2'])
    print('flag[flag3] : ', flag['flag3'])
    print('flag[flag4] : ', flag['flag4'])

(1) 일의 숫자가 1 이상이면서 month 리스트의 해당 인덱스 요소의 숫자 이하인지 필터링
→ 앞선 코드에서 아래와 같이 작성한 이유가 여기에 있음

논리의 분기점을 만드는 로직을 만들어야 할 때 이런 방식으로 동작하는 방법도 있다는 걸 알아두면 좋아요.

객체지향프로그래밍

클래스와 객체

• 클래스(Class)
  • 프로그램을 이용해 객체를 만들어주는 역할
• 객체(Object)
  • 클래스에 의해 만들어지는 결과물(instance)

클래스

• 속성(Attribute)과 행위(Action)으로 구성
  • 속성: 자료(data)를 나타냄
    • 객체변수/멤버변수
    • 명사 형태로 기술
  • 행위: 기능을 정의하는 함수로 표현
    • 메서드
    • 자료를 연산하거나 조작하는 역할
    • 동사 형태로 기술
• 예: 자동차 클래스 다이어그램
  • 앞부분의 (+, -)는 외부에서 접근 가능 여부: -는 은닉(private), +는 공용화(public)
    

객체

• 클래스에 의해서 만들어지는 결과물
  • 클래스의 속성에 실제 자료가 들어가고, 실제 자료를 동작시키는 함수가 하나로 묶여진 단위 → 자료(Data)와 메서드(Method)가 하나로 묶여 만들어진 결과물!

→ 클래스와 객체는 1:N의 관계

• 클래스를 만들었으나 객체를 만들지 않으면 클래스의 멤버(변수, 메소드)를 쓸 수 없음

함수(Function) vs. 메서드(Method) ★★
함수는 독립된 기능을 수행하는 코드(명령문)들의 집합
메서드는 클래스에 포함되어 있는 함수
→ 기능적으로는 매우 비슷
→ 그러나 어느 곳에 존재하는지에 따라 메서드와 함수는 구분해야 함!

클래스 구성

함수와 클래스

• 함수
  • 독립적인 기능을 수행할 수 있는 코드의 집합
• 클래스
  • 공통 기능을 갖는 함수들을 하나로 묶을 수 있는 단위
  • 변수와 함수들을 하나로 묶어놓은 집합체
    • 기존 C언어의 구조체와 비슷한 역할을 하는 일종의 자료구조
  • 객체지향의 주요 특징을 구현할 수 있는 메커니즘(Mechanism) 제공

중첩 함수와 클래스 선언 형식 비교

# 중첩 함수 형식
def outer_func(매개변수):
	변수 선언
    def inner_func(매개변수):
    	명령문
        return 값
    return 내부함수

외부함수(인수)

# 클래스 형식
class ClassName:
	변수 선언
    def 생성자(매개변수):
    	명령문
    def 함수명(매개변수):
    	명령문

# 여기서 함수명 == 메서드명
# def 함수, def 메서드 둘 다 ok

→ 객체를 생성하기 위해 '생성자'라는 특수한 함수를 포함

생성자(Constructor)
객체 지향 프로그래밍에서 객체가 생성될 때 초기화시켜주는 함수
파이썬 생성자 이해하기
클래스 내에서 특별한 이름(__init__)을 갖기만 하면 객체가 생성될 때 자동으로 호출되는 함수 → 객체가 생성될 때 자동으로 생성자인 __init__()이 호출됨
생성자는 객체가 생성될 때 사용자가 따로 호출하지 않아도 자동으로 호출되기 때문에 객체를 초기화하거나 초깃값을 설정하는데 유용하게 사용됩니다
클래스 생성자

실습

함수의 정의 및 호출

# (1) 함수 정의
def calc_func(a, b): # 외부함수
    # 변수 선언: 자료 저장
    x = a # 10
    y = b # 20
    
    def plus(): # 내부함수
        p = x + y
        return p
    
    def minus(): # 내부함수
        m = x - y
        return m
    
    return plus, minus
    
# (2) 함수 호출
p, m = calc_func(10, 20)
print("plus =", p())
print("minus =", m())

• 중첩함수에 대한 예시
  • 클래스의 기능(클래스 정의 → 객체 생성 → 멤버 호출)과 비교하기 위해 기술했지만 잘 사용하지 않는 개념임
  • 함수 내에 또 다른 함수를 정의

(1) 함수 정의

• 매개변수 x, y를 대상으로 덧셈과 뺄셈을 수행하는 plus()와 minus()의 내부함수를 포함하는 중첩함수

(2) 함수 호출

• 실인수(argument) 10과 20으로 중첩함수를 호출하고, 함수 클로저(내부함수)를 반환받아서 덧셈과 뺄셈 연산 결과 출력

클래스의 정의 → 객체의 생성 → 멤버 호출

# (3) 클래스 정의
class CalcClass:
    # 클래스 변수: 자료 저장
    x = y = 0
    
    # 생성자: 객체 생성+[멤버변수 초기화]
    def __init__(self, a, b): # A
        self.x = a # 10
        self.y = b # 20
        
    # 클래스 함수 / 멤버 함수(기능)
    def plus(self): # B
        p = self.x + self.y # 변수 연산 C
        return p
    
    # 클래스 함수 / 멤버 함수(기능)
    def minus(self):
        m = self.x - self.y # 변수 연산
        return m
    
# (4) 객체 생성: 생성자 → 객체 1
obj = CalcClass(10, 20) # D

# (5) 멤버 호출 # obj.member()	
print("plus = ", obj.plus()) # plus = 30
print("minus = ", obj.minus()) # minus = -10

# 추가
obj2 = CalcClass(100, 50) # 생성자 → 객체2
print("plus = ", obj.plus()) # plus = 30
print("minus = ", obj.minus()) # minus = -10

print(id(obj), id(obj2))

(3) 클래스 정의

• 함수의 매개변수 x,y를 클래스 변수로 선언
• 생성자를 선언
  • 객체 생성
  • 클래스 변수 값 초기화
• 덧셈과 뺄셈을 수행하는 plus()와 minus()를 클래스 매서드(클래스 함수)로 정의
  • function이 class 내부로 들어오면 method

(4) 객체 생성

• 클래스의 생성자를 이용해 객체를 생성하고 클래스 변수에 실인수(argument) 10과 20을 할당하여 자료를 만들

(5) 멤버 호출

• 생성된 객체(obj)를 이용해 클래스에서 정의한 메서드를 호출하고 연산 결과를 출력

"내가 그의 이름을 불러주었을 때, 그는 내게로 와서 꽃이 되었다."의 싯구를 코드에 대응하면 다음과 같습니다:
시인의 이상향
→ class CalcClass:의 클래스 선언: line 2-19
→ 문서에 해당하는 것(문서 중 아직 이론적으로만 존재하고 현실적이지 않은 것: 사진의 점선)
→ 프로그램에서 읽기 참조/쓰기 참조 불가
이름을 부르는 행위
→ CalcClass(10, 20)의 객체 생성
→ 객체가 만들어졌다 == 클래스 안에 정의된 여러 개의 멤버를 실제로 참조할 수 있는 상태다
내게로 와서 꽃이 된 그
→ obj 참조변수가 가리키는 곳에 존재하는 오브젝트

※ A: 괄호 안의 a와 b는 함수의 선언과 호출 중에서 함수 선언의 매개변수에 해당함

※ B: self → 멤버(변수+함수) 참조 객체

※ C: p → 지역변수, self.x, self.y → 전역변수

※ D: 괄호 안 10과 20은 함수의 선언과 호출 중에서 함수 호출의 인수에 해당함

Q. obj = CalcClass(10, 20)에서 CalcClass(10, 20)가 함수 호출이면 앞의 obj는 뭔가요?
A. 참조변수입니다.

• 변수
  • 필요한 자료를 일시적으로 보관하거나 처리 결과를 담을 수 있는 기억장소 역할
  • 실제 값을 저장하는 메모리(Memory) 이름으로 할당됨
    • 메모리에 값이 저장된다는 것은 변수에 값이 저장된다는 의미
• 파이썬 변수는 변수에 저장될 값이 먼저 메모리에 객체(Object) 저장된 후 객체의 주소가 변수에 저장됨 → 실제값이 저장되지 않고, 실제값이 저장된 "주소"를 기억하는 참조형 변수가 됨
• 참조형 변수의 특징
  • 객체의 자료형에 의해서 변수의 자료형이 결정되기 때문에 변수 선언 시 별도의 자료형을 선언하지 않음
• 파이썬 변수와 메모리 주소 관계
  
  • X 변수에 3.14159를 초기화 할 경우 메모리에 3.14159가 객체로 저장된 후 메모리 주소 12345가 X변수에 할당됨
  • 파이썬 변수는 방대한 자료, 함수, 그리고 차드 등 다양한 유형의 객체를 담을 수 있는 막강한 역할을 함

• 생성자
  • 특수한 매서드
  • 객체 생성 시 자동으로 호출되도록 예약되어 있음
• 객체 생성 시 여러 가지 동작과 개념이 한 문장에서 일어남
  • class라는 개념(이론)으로부터 실존하는 object(객쳬) 만들어지고 메모리에 저장
  • 동시에 처음 실행해야 하는 생성자의 동작까지 이루어짐
    • 생성자라는 매서드가 함수의 특징을 고스란히 가지고 있음을 보여주는 흔적: a, b(위 코드에서 10, 20에 해당)
      → 10과 20이 매개변수에 할당되어 a를 self.x에 할당하고 b를 self.y에 할당함
  • 참조변수에 객체의 주소를 넣음

※ 추가
obj = CalcClass(10, 20)과는 별개로 또 하나의 객체를 생성함
해당 객체는 obj2라는 참조변수로 참조
→ obj 참조변수의 주소와 obj2 참조변수의 주소는 다름!

클래스 구성요소

• 클래스 구성요소: 멤버(Member)+생성자(Constructor)
• 멤버: 멤버변수(자료 저장) + 메서드(처리 기능)
  • 파이썬에서 제공하는 클래스는 일반 변수나 함수와 구분하기 위해 클래스 선언부(header)에서 선언한 변수는 멤버변수, 클래스 본체(body)에서 정의하는 함수는 메서드(Method)라고 함
    • 멤버변수와 메서드를 간편하게 클래스의 멤버(Member)라고 부름
  • 생성자(Constructor)는 함수 형태로 선언하지만 __init__이라는 별도의 이름을 가짐

실습

class Car:
    # (1) 멤버변수
    cc = 0 # 엔진 cc
    door = 0 # 문짝 개수
    carType = None # null
    
    # (2) 생성자
    def __init__(self, cc, door, carType):
        # 멤버 변수 초기화
        self.cc = cc
        self.door = door
        self.carType = carType # 승용차, SUV
        
    # (3) 메서드
    def display(self):
        print("자동차는 %d cc이고 문짝은 %d개, 타입은 %s"
              %(self.cc, self.door, self.carType))
    
# (4) 객체 생성
car1 = Car(2000, 4, "승용차") # 객체 생성 + 초기화
car2 = Car(3000, 5, "SUV")

# (5) 멤버 호출: object.member()
car1.display() # car1 멤버 호출
car2.display() # car2 멤버 호출

(1) 멤버변수

• Car 클래스의 선언부에 3개의 멤버변수(cc, door, carType)를 선언
• 초기값은 0과 null

(2) 생성자

• 함수의 선언과 유사
  • 차이점
    1. 이름이 정해져 있음
    2. self라는 매개변수를 사용함
• def 명령어 다음에 __init__이라는 이름과 self 매개변수를 이용하여 선언
  • self 매개변수는 생성자 내에서 클래스의 멤버를 호출하는 데 이용
• self 매개변수 다음에 오는 3개의 매개변수는 3개의 멤버변수(cc, door, carType)에 값을 초기화하기 위한 매개변수
• 매개변수는 객체가 생성되는 시점에서 외부의 실인수(argument)를 받아서 멤버변수에 초기화하는 역할

실인수(argument)라는 개념은 가인수(parameter)의 상대적인 개념
→ 인수를 말할 때 용어를 구별해서 사용해야 함!
실인수(argument; actual parameters): 호출하는 곳, 실제값이 주어지는 곳
가인수(parameter; formal parameters): 호출받는 곳, 값을 받는 곳

(3) 메서드

• 함수의 선언과 동일
  • 차이점: self라는 정해진 매개변수를 포함하고 있음
• 코드에서 display() 메서드는 self를 이용해 멤버변수 3개의 내용을 출력하는 역할

(4) 객체 생성

• 클래스의 생성자를 이용하여 객체를 생성
  • 참조변수 = Car(실인수)
    • Car(): Car 클래스의 생성자
    • 실인수: 생성자의 매개변수에 전달할 실제값
• 한 개의 클래스에 의해 다수의 객체 생성 가능
• Car(2000, 4, "승용차") 형식의 명령문은 3개의 멤버변수에 각각 cc=2000, door=4, carType="승용차"가 할당되어 car1 참조변수를 가지는 객체가 생성됨

(5) 멤버 호출

• 생성된 객체의 참조변수를 이용하여 객체의 멤버를 호출
  • 참조변수.멤버(멤버변수 or 메서드)

생성자(Constructor)

• __init__()이란 이름으로 제공
• 객체가 생성될 때 자동으로 실행
• 객체 생성 시 멤버변수에 값을 초기화하는 역할
  • 초기화 작업이 필요 없는 경우 생략 가능
• 모든 클래스는 객체를 생성하는 것이 목적이므로 반드시 생성자를 가지고 있어야 함
  • 생성자를 생략할 경우 파이썬에서 기본 생성자를 만들어 주고 이를 통해 객체가 생성되도록 함

참조변수 = 클래스이름(실인수)
객체를 생성할 때는 생성자가 포함된 클래스이름 뒤에 괄호()를 붙이고 매개변수에 전달될 실인수를 괄호에 넣어 함수를 호출하듯 객체를 생성
→ 생성된 객체의 주소는 참조변수에 할당됨
→ 참조변수를 이용해 객체의 멤버 호출 가능

실습

# (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
    
obj = Multiply(10, 20) # 생성자
print("곱셈 = ", obj.mul())

(1) 생성자 이용 멤버변수 초기화

• 두 개의 멤버변수 (x, y)에 값을 초기화하기 위해 두 개의 매개변수를 갖는 생성자 __init__(self, x, y)를 정의
• 객체가 생성되는 시점에서 실인수 2개가 매개변수로 할당되어 멤버변수 x, y에 초기화됨

# (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())

(2) 메서드 이용 멤버변수 초기화

• data() 메서드에 의해 초기화
• 생성자를 생략하면 기본 생성자(묵시적 생성자)가 자동으로 생성됨
  • pass 명령어는 블록의 내용이 없는 경우 쓸 수 있는 명령어
  • 기본 생성자는 실행문이 없는 단지 객체만 생성하는 용도로 사용됨
  • 코드가 보이지 않아도 암시적으로 클래스에 만들어지기 때문에 묵시적 생성자라고도 함
• 기본 생성자 형태

def __init__(self):
	pass

소멸자(Destructor)
→ 생성자의 반대 역할
→ __del__()이란 이름으로 제공
객체 사용이 완료되면 자동으로 실행되어 객체를 메모리에서 소멸시키는 역할
파이썬 자체에서 메모리 관리를 자동으로 해주기 때문에 많이 사용되지는 않음

# 소멸자 사용 예시
class Multiply:
	# 생성자: 객체 생성 + 멤버변수 초기화
    def __init__(self, x, y):
    	self.x = x
        self.y = y
        
    # 소멸자: 객체 소멸    
	def __del__(self):
    	del self.x
        del self.y

self

• 클래스의 생성자와 메서드 → self 매개변수 생략하면 오류 발생
• self 매개변수의 역할
  • 클래스를 구성하는 멤버들, 즉 멤버변수와 메서드를 호출하는 역할
    • 생성자 안에서 멤버변수 값을 초기화
    • 메서드 안에서 멤버변수를 참조
    • 다른 메서드를 호출
• self 명령문 형식

self.멤버변수
self.메서드()

실습

class Multiply3:
    # 멤버변수 없음 → 이전의 소스코드(x = y = 0)와 비교해볼 것
    # 생성자 없음 → def __init__(self): 없음
    
    # 동적 멤버변수 생성/초기화
    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()

• 멤버변수와 생성자를 모두 정의하지 않았음
  • 기본 생성자가 자동으로 만들어짐
• 클래스 선언부(header)에 멤버변수가 정의되지 않았기 때문에 data() 메서드가 호출되는 시점에서 self.x, self.y 명령문에 의해 동적으로 멤버변수가 만들어지고 매개변수에 의해 값이 초기화됨

클래스 멤버

• 클래스 이름으로 호출할 수 있는 클래스 변수와 클래스 메서드를 말함
  • 클래스 이름으로 호출할 수 있기 때문에 클래스 멤버를 호출하기 위해 객체를 생성할 필요는 없음
    • cf. 객체는 클래스의 생성자를 이용해 만들어지고 객체를 구성하는 객체 멤버는 객체 변수, 객체 메서드임 → 객체(참조변수)를 통해 호출 가능
• 클래스 매서드는 cls라는 기본 매개변수를 사용하고 @classmethod라는 함수 장식자를 이용해 선언

실습

class DatePro:
    # (1) 멤버 변수
    content = "날짜 처리 클래스"
    
    # (2) 생성자
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day
        
    # (3) 객체 메서드(instance method)
    def display(self):
        print("%d-%d-%d"%(self.year, self.month, self.day))
    
    # (4) 클래스 메서드(class method)
    @classmethod # 함수 장식자
    def date_string(cls, dateStr): # '19951025'
        year = dateStr[:4]
        month = dateStr[4:6]
        day = dateStr[6:]
        
        print(f"{year}년 {month}년 {day}일")
        
# (5) 객체 멤버
date = DatePro(1995, 10, 25) # 생성자 ★
print(date.content) # 날짜 처리 클래스
print(date.year) # 1995
date.display() # 1995-10-25

# (6) 클래스 멤버
print(DatePro.content) # 날짜 처리 클래스
# print(DatePro.year) # AttributeError: year는 객체의 멤버변수이기 때문
DatePro.date_string("19951025") # 1995년 10월 25일

(1) 멤버 변수

• 클래스 선언부(header)에 선언된 content 변수는 객체의 멤버변수도 되고 클래스 멤버변수도 됨

(2) 생성자

• 생성자에서 self.멤버변수로 선언된 변수는 객체 멤버변수만 됨
  • 클래스 멤버변수는 될 수 없음에 유의

(3) 객체 메서드(instance method)

• 기본 인수 self를 포함아여 함수 정의
  • 생성자를 이용해 객체를 생성하고, 객체의 참조변수에 의해 호출

(4) 클래스 메서드(class method)

• @classmethod라는 함수 장식자(decorator, 데코레이터)를 이용해 먼저 선언한 후 클래스 메서드를 정의
• 기본 매개변수 cls를 포함
• 이러한 매서드는 클래스이름으로 호출됨
  • 참조변수를 이용하지 않음

(5) 객체 멤버

• 생성자를 이용하여 객체를 생성하고, 객체 멤버변수와 객체 메서드를 호출하여 날짜 정보 출력
• self로 지정되지 않은 content 멤버변수도 객체 멤버가 됨
  ★ date는 '참조변수'(또는 '객체'라고 부르기도 함)
  DatePro(1995, 10, 25)는 객체 생성: 생성자 호출

(6) 클래스 멤버

• 클래스이름으로 클래스 멤버 호출
  • self로 지정되지 않은 content
  • 함수장식자에 의해 선언된 date_string()