#파이썬 기초 8일차_2

4. 메서드 확인하기

4.1 메소드(Method) 이해하기

4.1.1 인스턴스 메서드(instance method) 확인

 

• 인스턴스 메소드 정의하기
• 인스턴스의 메소드가 자동으로 self를 통해서 정의되는것을 인스턴스 메소드라고함
• 클래스 내부에서 self를 첫 번째 매개변수로 받아들이며, 이를 통해 해당 메소드가 호출된 인스턴스 자신을 참조할 수 있다

class Klass_ins :

    def set(self,name,value) :

        setattr(self,name,value)

ki = Klass_ins()

print(ki)

print(isinstance(ki, Klass_ins))

<__main__.Klass_ins object at 0x79db0214f910>

True

ki.set("name","춘식이")

ki.set("age",5)

print(ki.__dict__)

{'name': '춘식이', 'age': 5}

class Person :

    def __init__(self,name,age) :

        self.name = name

        self.age = age

p = Person("춘장",20)

print(p.__dict__)

{'name': '춘장', 'age': 20}

4.1.2 클래스 메서드 정의

• 클래스 메서드 정의하기
• 데코레이터를 이용해서 파이썬 메소드를 설명함
• 데코레이터(decorator)는 파이썬 함수나 클래스의 기능을 확장하거나 수정할 수 있는 강력한 도구로,  기존의 함수나 클래스를 쉽게 변경하지 않고 기능을 추가하거나 수정할 수 있도록 해준다.
• 여기서는 @classmethod가 데코레이털르 이용한 것이다.

class Klass_cls :

    @classmethod

    def set(cls,name,value) :

        setattr(cls,name,value)

 

클래스 이름이 바로 전달함(클래스 명을 통해서 값을 직접전달)

Klass_cls.set("name","클래스")

Klass_cls.set("age",50)

import pprint

pprint.pprint(Klass_cls.__dict__)

mappingproxy({'__dict__': <attribute '__dict__' of 'Klass_cls' objects>,
              '__doc__': None,
              '__module__': '__main__',
              '__weakref__': <attribute '__weakref__' of 'Klass_cls' objects>,
              'age': 50,
              'name': '클래스',
              'set': <classmethod(<function Klass_cls.set at 0x79db1e87a680>)>})

 

class Person :

    name = ""

    age = 0

    @classmethod

    def set(cls,name,value) :

        setattr(cls,name,value)

    @classmethod

    def get(cls) :

        return cls.name, cls.age

Person.set("name","클래스") # 인스턴스를 만들지 않고 바로 사용

Person.set("age",50)

print(Person.get())

('클래스', 50)

p = Person() # 인스턴스 만들어서 사용

print(p.get())

print(p.name)

('클래스', 50)

클래스

c = Person()

print(c.get())

c.name = "겨울"

c.age = 15

 

print(c.name)

print(c.__dict__)

('클래스', 50)

겨울

{'name': ' 겨울 ', 'age': 15}

 

 4.1.3 정적 메서드 정의

• 정적 메소드 정의하기

class Klass_st :

    name = ""

    age = 0

    def __init__(self,name,age) :

        self.name = name

        self.age = age

    @classmethod

    def set(cls,name,value) :

        setattr(cls,name,value)

    @staticmethod

    def get(obj) :

        return obj.name, obj.age

c = Klass_st("인스턴스",50)

Klass_st.set("name","클래스")

Klass_st.set("age",55)

print(c.get(c))

print(Klass_st.get(Klass_st))

('인스턴스', 50)

('클래스', 55)

print(c.get(Klass_st))

print(Klass_st.get(c))

('클래스', 55)

('인스턴스', 50)

4.2 self / cls 매개변수 이해하기

4.2.1 인스턴스 메서드 정의 이해하기

• 인스턴스 메소드 self 알아보기

class InsKlass :

    def __init__(self,name) :

        self.name = name

    def getname(self) :

        return self.name

print((InsKlass))

print(InsKlass.getname)

ins = InsKlass("인스턴스")

print(ins.getname)

<class '__main__.InsKlass'>

<function InsKlass.getname at 0x79db020a7130>

<bound method InsKlass.getname of <__main__.InsKlass object at 0x79db1e69faf0>>

s = set(dir(InsKlass.getname))

i = set(dir(ins.getname))

print(i - s)

print(s - i)

print(ins)

print(ins.getname.__self__)

print(InsKlass.getname)

print(ins.getname.__func__)

{'__func__', '__self__'}

{'__module__', '__closure__', '__qualname__', '__dict__', '__globals__', '__annotations__', '__name__', '__code__', '__defaults__', '__builtins__', '__kwdefaults__'}
<__main__.InsKlass object at 0x79db1e69faf0>
<__main__.InsKlass object at 0x79db1e69faf0>
<function InsKlass.getname at 0x79db020a7130>
<function InsKlass.getname at 0x79db020a7130>

4.2.2 클래스 메서드 내부 확인하기

• 클래스 메소드 cls 알아보기

class ClsKlass :

    name = "클래스"  # 인스턴스에게 영향을 받지 않음(인스턴스가 인스턴스 메소드를 통해 영향을 줄때)

    def __init__(self,name) :

        self.name = name

    @classmethod

    def getname(cls) :

        return cls.name

a = ClsKlass("인스턴스")

print(ClsKlass.getname())

print (a.name)

클래스

인스턴스

print(ClsKlass.getname)

<bound method ClsKlass.getname of <class '__main__.ClsKlass'>>

s = set(dir(ClsKlass.__init__))

c = set(dir(ClsKlass.getname))

print(c - s)

print(s - c)

{'__func__', '__self__'}
{'__module__', '__closure__', '__qualname__', '__dict__', '__globals__', '__annotations__', '__name__', '__code__', '__defaults__', '__builtins__', '__kwdefaults__'}

print(ClsKlass)

print(ClsKlass.getname.__self__) # 클래스 자체를 바로 가리킴

print(ClsKlass.getname.__func__) # 클래스를 벗어나서 해당하는 주소를 가르킴

<class '__main__.ClsKlass'>
<class '__main__.ClsKlass'>
<function ClsKlass.getname at 0x79db020a5fc0>

4.2.3 인스턴스 메서드의 self 매개변수 위치 이해하기

• self 변수를 미지정해서 인스턴스 메소드 알아보기
• s에대한 주소가 지속적으로 self에 전달되는 것을 확인함

class Self :

    attr = ("name","age")

    def __init__(*args) : # 아규먼트

        print("__self__ argument ",args[0])

        print("__self__ attribute ",args[0].__init__.__self__)

        for i in range(1,len(args)) :

            args[0].__dict__[Self.attr[i-1]] = args[i]

    def get(*args) :

        print("__self__ attribute ",args[0].get.__self__)

        return args[0].name, args[0].age

s = Self("Dahl",22)

print(s.__dict__)

print(s)

__self__ argument  <__main__.Self object at 0x79db0214cdf0>
__self__ attribute  <__main__.Self object at 0x79db0214cdf0>
{'name': 'Dahl', 'age': 22}
<__main__.Self object at 0x79db0214cdf0>

print(s.get())

__self__ attribute <__main__.Self object at 0x79db0214cdf0>

('Dahl', 22)

class Self_ :

    def __init__(self,name,age) :

        self.name = name

        self.age =  age

    def get(self) :

        return self.name, self.age

s = Self_("Dahl",22)

print(s.__dict__)

print(s)

print(s.get())

{'name': 'Dahl', 'age': 22}
<__main__.Self_ object at 0x79db0214da50>
('Dahl', 22)

4.3 외부 함수와 메서드를 동시에 사용하는 패턴 이해하기

4.3.1 외부 함수를 내부 인스턴스 메서드로 사용하기

• 외부 함수를 정의하고 클래스 내부에 할당하기

def getname(self) :

    return self.name

def getage(self) :

    return self.age

class Person :

    def __init__(self,name,age) :

        self.name = name

        self.age  = age

    getname = getname

    getage  = getage

p = Person("함수",11)

print(p.getname())

print(getname(p))

 

print(p.getage())

print(getage(p))

함수
함수
11
11

print("1 :",p.getname)

print("2 :",getname)

print("3 :",p.getname.__func__ is getname)

print("4 :",p.getage)

print("5 :",getage)

print("6 :",p.getage.__func__ is getage)

 

1 : <bound method getname of <__main__.Person object at 0x79db0214f6a0>>
2 : <function getname at 0x79db021e7d90>
3 : True
4 : <bound method getage of <__main__.Person object at 0x79db0214f6a0>>
5 : <function getage at 0x79db0211f250>
6 : True

• __ init __ 를 함수로 정의하고 클래스 내에 할당할 경우
• __init__의 경우 별도로 정의하지 말라고 권장하고 있다.

def __init__(self,name,age) :

    self.name = name

    self.age  = age

class Person :

    __init__ = __init__

p = Person("ChunSik",22)

print(p.__dict__)

{'name': ' ChunSik ', 'age': 22}

print(p.__init__.__func__)

print(__init__)

<function __init__ at 0x79db0211dea0>

<function __init__ at 0x79db0211dea0>

4.4 플루언트 인터페이스(Fluent Interface, → 메서드 체이닝)

• Method Chain 처리

class MethodChain :

    def __init__(self, content) :

        self.content = content

    def intent(self,space) :

        self.content = " "*space + self.content

        return self

    def suffix(self,content) :

        self.content = self.content + "-" + content

        return self

m = MethodChain("하늘과별과 시").intent(5).suffix("윤동주").content

print(m)

     하늘과별과 시-윤동주

# intent(5)는 스페이스 5칸 띄우라는 이야기

 

@ 추가 학습(인스턴스 메소드, set메소드, 클래스 메소드 각각 정리)

1. 인스턴스 메소드

• 정의: 인스턴스 메소드는 클래스의 각 인스턴스에서 호출할 수 있는 메소드.
• 주로 객체의 상태를 조작하거나 정보를 반환하는 데 사용

특징:

• 첫 번째 매개변수로 항상 인스턴스 자신을 참조하는 self를 사용
• 인스턴스를 통해 호출.
• 인스턴스의 상태(속성)을 읽거나 수정할 수 있다.

class MyClass:

    def __init__(self, value):

        self.value = value

   

    def instance_method(self):

        return f"The value is {self.value}"

# 인스턴스 생성

obj = MyClass(10)

print(obj.instance_method())  # 출력: The value is 10

The value is 10

2. 클래스 메소드

• 정의: 클래스 메소드는 클래스 자체에 바인딩되는 메소드
• 주로 클래스 레벨의 작업을 수행하거나 클래스 변수를 조작하는 데 사용

특징:

• 첫 번째 매개변수로 항상 클래스 자체를 참조하는 cls를 사용
• 클래스 메소드로 선언하려면 @classmethod 데코레이터를 사용해야 한다.
• 클래스 또는 인스턴스를 통해 호출될 수 있다.
• 클래스의 상태(클래스 변수)를 읽거나 수정할 수 있다.

class MyClass:

    class_variable = "Class Level Variable"

   

    @classmethod

    def class_method(cls):

        return f"The class variable is {cls.class_variable}"

# 클래스 메소드 호출

print(MyClass.class_method())  # 출력: The class variable is Class Level Variable

The class variable is Class Level Variable

3. 스태틱 메소드

• 정의: 스태틱 메소드는 클래스나 인스턴스와는 무관하게 동작하는 메소드
• 주로 클래스와 관련된 작업을 수행하지만, 클래스나 인스턴스의 상태를 읽거나 수정하지 않다.

특징:

• 첫 번째 매개변수로 self나 cls를 사용하지 않다.
• 스태틱 메소드로 선언하려면 @staticmethod 데코레이터를 사용해야 한다.
• 클래스 또는 인스턴스를 통해 호출될 수 있다.
• 클래스와 관련된 유틸리티 함수를 정의하는 데 사용된다.

class MyClass:

    @staticmethod

    def static_method():

        return "This is a static method"

# 스태틱 메소드 호출

print(MyClass.static_method())  # 출력: This is a static method

This is a static method

 

4. setattr 메소드

• 정의: setattr 메소드는 객체의 속성을 동적으로 설정하는 파이썬 내장 함수

특징:

• 객체, 속성 이름, 속성 값을 인자로 받는다.
• 주어진 객체의 속성을 동적으로 설정하거나 업데이트한다.
• 인스턴스, 클래스 어디서든 사용할 수 있다.

class MyClass:

    def __init__(self, value):

        self.value = value

obj = MyClass(10)

setattr(obj, 'new_attr', 20)

print(obj.new_attr)  # 출력: 20

20

 

 

• 인스턴스 메소드: 인스턴스의 속성이나 다른 인스턴스 메소드를 조작. 첫 번째 매개변수로 self를 받는다.
• 클래스 메소드: 클래스 변수를 조작하거나 클래스 레벨에서 작업을 수행, 첫 번째 매개변수로 cls를 받으며. @classmethod 데코레이터를 사용한다.
• 스태틱 메소드: 클래스나 인스턴스와 관련이 없는 작업을 수행. 첫 번째 매개변수를 받지 않으며, @staticmethod 데코레이터를 사용한다.