0%

클래스

Posted on Edited on In Disqus:

클래스

변수와 함수를 묶어 놓은 개념입니다.

사용방법 1. 변수와 함수가 들어있는 클래스를 선언합니다. 2. 클래스를 객체로 만들어서 클래스 안에 선언된 변수와 함수를 사용합니다.

기본 클래스의 사용

클래스의 선언 

1
2
3
4
5
6
7
8
9
10
11
# 클래스에서 사용되는 함수의 첫번째 파라미터는 self를 쓴다
class Calculator:
     
    num1 = 1
    num2 = 2
    
    def plus(self):
        return self.num1 + self.num2
    
    def minus(self):
        return self.num1 - self.num2
클래스의 사용 
1
2
3
calc = Calculator()
calc
# 위의 클래스의 선언에서 self는 함수가 포함된 객체 여기서는 calc
1
2
3
4
calc.num1, calc.num2, calc.plus(), calc.minus()

# 1, 2, 3, -1
# 객체로 만들어 클래서에서 선언한 함수를 가져다 쓴다.

객체지향

실제 세계를 코드에 반영해서 개발하는 방법입니다. - 여러명의 개발자가 코드를 효율적으로 작성해서 프로젝트를 완성시키기 위한 방법 - 설계도 작성(class) -> 실제 물건(object) 

1
2
3
obj = "python" 
#문자열 데이터 타입을 가지는 '객체' (기본 데이터 타입)
obj.upper()

생성자

클래스가 객체로 생성될때 실행되는 함수이며, 변수(재료)를 추가할때 사용합니다. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Calculator:
    
    # 생성자 함수 : __init__
    def __init__(self,num1,num2=10): #키워드 아규먼트, 디폴트파라미터 사용가능 
        self.num1 = num1
        self.num2 = num2
    
    def plus(self):
        return self.num1 + self.num2
    
    def minus(self):
        return self.num1 - self.num2

calc = Calculator(2,3)
calc.plus()

# 5

상속

클래스의 기능을 가져다가 기능을 수정하거나 추가할때 사용하는 방법 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Calculator1:
    
    def __init__(self,num1,num2):
        self.num1 = num1
        self.num2 = num2
        
    def plus(self):
        return self.num1 + self.num2
    
    def minus(self):
        return self.num1 - self.num2

calc1 = Calculator1(1,2)
calc1.plus(), calc1.minus()

# 3,-1
> 매서드 오버라이딩 : 부모 클래스에서 상속받은 매서드를 수정 
1
2
3
4
5
6
7
8
9
# 상속을 사용하여 minus 함수 추가
class Calculator2(Calculator):
    def minus(self):
        return self.num1 * self.num2

calc2 = Calculator2(1,2)
calc2.plus(),calc2.minus()     

# 3, 2
Calcultor1이 가지고 있는 plus매서드를 그대로 상속받았고, minus매서드는 오버라이딩을 통해 곱해주는 기능으로 바꿨습니다.

다중 상속

여러개의 클래스를 상속받을수 있습니다. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Iphone1:
    def calling(self):
        print("Calling")

class Iphone2:    
    def send_msg(self):
        print("SendMsg")

class Iphone3(Iphone1,Iphone2):
    def internet(self):
        print("Internet")


iphone = Iphone3()
iphone3.calling(),iphone3.send_msg(),iphone3.internet()

# Calling, SendMsg, Internet

Super

부모 클래스에서 사용된 함수의 안의 코드를 가져다가 자식 클래스의 함수에서 재사용할때 사용합니다. 

1
2
3
4
5
6
7
8
class Iphone4(Iphone3):
    def question(self):
        super().calling()

iphone4 = Iphone4()
iphone4.question()

# calling
상속받은 부모클래스의 calling 매서드의 코드를 가져왔습니다.

class의 getter, setter

객체의 내부 변수에 접근할때 특정 로직(제약 조건)을 거쳐서 접근시키는 방법입니다. > property(geeter,setter)로 제약을 줍니다. 

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
class User:
    
    def __init__(self,first_name):
        self.first_name = first_name
        
    def setter(self,first_name):
        print("Setter")
        self.first_name = first_name

    def getter(self):
        print("Getter")
        return self.first_name
    
    def disp(self):
        print(self.first_name)
        
    name = property(getter,setter)

user1 = User("andy")
user1.disp()

# andy

user1.name = "john"
# Setter
user1.name
# Getter
# 'john'

non public

'mangling' 이라는 방식으로 다이렉트로 객체의 변수와 매서드에 접근하지 못하게 하는 방법입니다. 변수 앞에 __붙이는 방식으로 구현합니다. 

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
class Calculator:
    
    def __init__(self,num1,num2):
        self.num1 = num1
        self.__num2 = num2 
        #실제로는 객체가 선언 될떄는 self._Caculator__num2라는 이름으로 바뀜
        
    def getter(self):
        return self.__num2
    
    def setter(self,__num2):
        # num2에 0이 들어가지 않도록 함
        if num2 == 0:
             num2 = 1
        self.__num2 = num2
        
    def __disp(self):
        print(self.num1,self.__num2)

    def div(self):
        self.__disp()
        return self.num1 / self.__num2
        
        
    number2 = property(getter,setter)
> 매서드 
1
2
3
4
5
6
7
8
9
10
11
12
13
calc = Calculator(1,2)
calc.div()

# div()매서드에서 __disp()라는 mangling 방식으로 처리된 매서드를 실행해서 1 2 라는 출력이 나오고, div가 리턴하는 0.5라는 값도 함께 나옴
# 1 2
# 0.5

calc.__disp()
# 실행안됨. 

calc._Calculator__disp()
# 위의 이름으로 실행할수 있음.
# 1 2
> 변수 
1
2
3
4
5
6
7
calc.num2 = 0 
#위에 클래스에서는 num2라는 이름의 변수는 없음, 대신 새로 만들어 지게 됨
calc.__num2 = 0 
# 역시 __num2 라는  새로운 변수를 생성
calc._Calculator__num2 
# 2
# 클래스 안의 __num2와 같음
## is a 와 has a 클래스를 설계하는 두가지 개념 입니다. > A is a B >> A는 B이다. 상속을 이용해서 클래스를 만드는 방법 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# is a 개념으로 설계
class Person():
    def __init__(self,name,email):
        self.name = name
        self.email = email


class Person2(Person):
    def info(self):
        print(self.name,self.email)

p = Person2("andy","andy@gmail.com")

p.info()
# andy andy@gmail.com
> A has a B >> A는 B를 가진다. A가 B객체를 가지고 클래스를 만드는 방법 
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
# has a 개념으로 설계 : 객체안에 객체를 가지고 있다
class Name:
    def __init__(self,name):
        self.name_str = name
class Email:
    def __init__(self,email):
        self.email_str = email


class Person:
    def __init__(self,name_obj,email_obj):
        self.name = name_obj
        self.email = email_obj
        
    def info(self):
        print(name.name_str,email.email_str)


name = Name("andy")
email = Email("andy@gmail.com")
#객체 안에 객체를 가지고 있다
p = Person(email,name)

p.info()
# andy andy@gmail.com

Magic(Special) Method

비교연산자 - __eq__ : == - __ne__ : != - __lt__ : <

산술연산자 - __add__ : + - __sub__ : - - __repr__: 객체의 내용을 출력(개발자용) - __str__ : 객체의 내용을 출력

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
29
class Txt:
    def __init__(self,txt):
        self.txt = txt
    
    def __eq__(self,txt_obj):
        return self.txt.lower() == txt_obj.txt.lower()
        # 소문자로 변환해서 비교 언산자를 실행합니다.

    def __repr__(self):
        return "Txt(txt={})".format(self)
    
    def __str__(self):
        return self.txt


t1 = Txt("python")
t2 = Txt("PYTHON")
t3 = t1

t1 == t2, t1 == t3, t2 == t3
# __eq__ 실행
# (True, True, True)

t1
# __repr__  실행
# Txt(txt=python)

print(t1)
# python