20230310 KDT 학습일지

1. 객체지향 프로그래밍

• 문제를 여러개의 객체 단위로 나눠 작업하는 방식

1-1. 객체(object)란?

• 물리적으로 존재하거나 추상적으로 생각할 수 있는 것 중에서 자신의 속성을 가지고 있고 다른 것과 식별 가능한 것을 말함

1-2. 클래스(class)란?

• 객체를 생성하기 위한 일종의 설계도와 같음
• 클래스는 프로퍼티(필드), 메소드(함수)로 구성되어 있음
  • 프로퍼티(property): 데이터가 저장되는 곳
  • 메소드(method): 객체의 동작에 해당하는 실행 블록

1-3.클래스와 객체

• 건축 설계도가 클래스라면, 실체로 지어진 집은 객체
• 객체는 클래스로 생성되어 구체화된 인스턴스
• 실제로 클래스가 인스턴스화 되어 메모리에 상주하는 형태를 객체라고 부른다.
• 파이썬의 모든 변수와 함수는 객체로 저장

2. 클래스 만들기

```

class 클래스명:

    프로퍼티명1 = 값1

    프로퍼티명2 = 값2

    ...

 

    def 메소드명1(self,변수1,변수2,.):

        메소드가 호출되면 실행할 문장

        ...

    def 메소드명2(self,변수1, 변수2...):

        메소드가 호출되면 실행할 문장

 

        ...     

• 클래스를 통해 호출되는 변수를 프로퍼티(필드)라고 부름
• 클래스를 통해 호출되는 함수를 메소드라고 부름
• self 클래스의 각 호출한 객체를 가리킴
• 클래스의 앞글자는 항상 대문자로 쓴다

class Dog:

    pass # 내용이 없는 블록을 만들 때 사용

 

def func1():

    pass

 

#클래스를 통해 객체를 생성

Rucy = Dog()

print(Rucy)

print(type(Rucy))

-

<__main__.Dog object at 0x7f3fd0265be0>
<class '__main__.Dog'>

 

 

li1 = list([1,2,3,4,5])

print(li1)

print(type(li1))

- [1, 2, 3, 4, 5]

   <class 'list'>

 

PPomi = Dog()

print(PPomi)

print(type(PPomi))

- <__main__.Dog object at 0x7f3fb96f6d90>

   <class '__main__.Dog'>

 

li2 = list([1,2,3,4,5])

print(li2)

print(type(li2))

print(id(li2))

- [1, 2, 3, 4, 5]

   <class 'list'>

   139911670626880

 

class Dog:

    name = '루시'

    age = 13

    family = '포메'

    def eat(self):

      print(self)

      print('사료를 잘먹습니다!')

 

Rucy = Dog()

print(Rucy.name)

print(Rucy.age)

print(Rucy.family)

Rucy.eat()

print(Rucy)

-

루시
13
포메
<__main__.Dog object at 0x7f3fd0265e50>
사료를 잘먹습니다!
<__main__.Dog object at 0x7f3fd0265e50>

PPomi =Dog()

print(PPomi.name)

print(PPomi.age)

print(PPomi.family)

PPomi.eat()

print(PPomi)

- 루시

   13

   포메

   사료를 잘먹습니다!

   <__main__.Dog object at 0x7f3fd02650a0>

3. 생성자(constructor)

• 클래스를 객체화 시킬 대 가장 먼저 실행되는 메소드
• _ init _(self)
• 생성자에서는 해당 클래스가 다루는 데이터를 정의하고 초기화 함

class Dog:

  def _init_(self):

    print(self, ' init 호출!')

 

Rucy = Dog()

 

class Dog:

  def __init__(self):

      self.name = '이름없음'

      self.age = 0

 

Rucy = Dog()

print(Rucy)

print(Rucy.name)

print(Rucy.age)

-

<__main__.Dog object at 0x7fea0c5aa0d0>
이름없음
0

 

Rucy.name = '루시'

Rucy.age = 13

PPomi.name = '뽀미'

PPomi.age = '뽀미'

print(PPomi)

print(PPomi.name)

print(PPomi.age)

- <__main__.Dog object at 0x7f3fb96abe20>

   뽀미

   뽀미

 

class Dog:

  def __init__(self):

      self.name = '이름없음'

      self.age = 0

      #nickname = '닉네임 없음'# 메소드 안에서만 사용할 수 있는 지역변수

      self.nickname = '닉네임 없음'# 메소드 안에서만 사용할 수 있는 지역변수

     # print(f'{nickname}객체가 생성됨')

 # def go(self):

  #    print(f'{nickname}가 달립니다!')

  def go(self):

      print(f'{self.nickname}가 달립니다!')

 

Rucy = Dog()

Rucy. name = '루시'

Rucy.go()

- 닉네임 없음가 달립니다!

 

class Dog:

  def __init__(self,name,age,nickname=''):

    self.name = name

    self.age = age

    self.nickname = nickname

 

Rucy = Dog() #매개변수를 보내지 않아 에러가 발생!

Rucy = Dog('루시', 13)

print(Rucy.name)

print(Rucy.age)

print(Rucy.nickname)

- 루시

   13

 

PPomi = Dog('뽀미',7)

print(PPomi.name)

print(PPomi.age)

print(PPomi.nickname)

- 뽀미

   7

4.메소드 정의하기

• 해당 클래스의 객체에서만 호출가능한 함수
• 해당 객체의 속성에 대한 연산을 행함
• 객체이름. 메소드명() 형태로 호출됨

4-1 메소드 정의하기

class Counter:

    def __init__(self):

        self.num  = 0

    def increment(self):

        self.num+=1

    def decrement(self):

        self.num-= 1

    def current_value(self):

        return self.num

    def reset(self):

        self.num = 0

 

KBbank = Counter()

print(KBbank.num)

- 0

 

KBbank. increment()

print(KBbank.num)

- 1

 

KBbank .decrement()

print(KBbank.num)

- 0

 

print(KBbank.current_value())

- 0

KBbank.increment()

KBbank.increment()

KBbank.increment()

KBbank.increment()

KBbank.increment()

print(f'현재 대기인원 :{KBbank.current_value()}')

- 현재 대기인원 :5

 

HanaBank = Counter()

print(f'현재 대기인원 : {HanaBank.current_value()}')

- 현재 대기인원 : 0

 

HanaBank.reset()

print(f'현재 대기인원: {HanaBank.current_value()}')

- 현재 대기인원 : 0

4-2. 메소드 타입

• intance method: 객체 형태로 호출되기 때문에 해댕 메소드를 호출한 객체에만 영향을 미침
• class method:클래스 이름으로 호출하는 메소드(메소드 선언 위에 @staticmethod)

class Math:

  def add(self, x, y):

      return x + y

  def multiply(self,x,y):

        return x*y

math = Math()

 

result1 = math.add(10,3)

print(result1)

- 13

 

result2= math.multiply(10,3)

print(result2)

 -30

 

class Math:

  @staticmethod

  def add(x,y):

      return x+y

  @staticmethod 

  def multiply(x,y):

      return x+y

 

result1 = Math.add(10,3)

print(result1)

-13

 

result2 =Math.multiply(10,3)

print(result2)

- 13

 

class Math:

  @staticmethod

  def add(x,y):

      return x+y

  @staticmethod 

  def multiply(x,y):

      return x*y

  def div(self,x,y):

      return x / y

 

math = Math()

result3 = m

-----ath.div(10,3)

print(result3)

---

1. 상속

• 기존의 정의해둔 클래스의 기능을 그대로 물려받음
• 기존 클래스에 기능 일부를 추가하거나, 변경하여 새로운 클래스를 정의함
• 코드를 재사용할 수 있게 됨
• 안정적이고 유지보수에 용이함
• 상속을 받고자 하는 대상인 기존 클래스를 부모, parent, super, base 클래스라고 부름
• 상속을 받는 새로운 클래스는 자식, child,sub클래스라고 부름

class Animal:

   def __init__(self,name,age):

      self.name = name

      self. age=  age

   def eat (self,food):

      print(f'{self.name}는 {food}를 먹습니다')

   def sleep (self,hour):

      print(f'{self.name}는 {hour}시간 동안 잠을 잡니다. ')

 

animal = Animal ('동물',10)

animal.eat('먹이')

animal.sleep(14)

-

동물는 먹이를 먹습니다
동물는 14시간 동안 잠을 잡니다. 

 

class Dog (Animal): # Animal 클래스를 상속

  pass

 

Rucy = Dog()#Animal 클래스의 생성자를 상속받았기 때문에

 

Rucy = Dog('루시',12)

 

Rucy.eat('사료')

- 루시는 사료를 먹습니다

 

Rucy.sleep(10)

-루시는 10시간 동안 잠을 잡니다.

2.메소드 오버라이딩

• 부모 클래스의 method를 재정의
• 자식 클래스의 인스턴스로 호출시 재정의된 메소드가 호출됨

class Animal:

   def __init__(self,name,age):

      self.name = name

      self. age=  age

   def eat (self,food):

      print(f'{self.name}는 {food}를 먹습니다')

   def sleep (self,hour):

      print(f'{self.name}는 {hour}시간 동안 잠을 잡니다. ')

 

class Dog(Animal):

  def run(self):

    print(f'{self.name}는 달립니다. ')

  def eat(self,food):# 메소드 오버라이딩

    print(f'{self.name}는 {food}를 아주 맛있게 먹습니다.')

  def superEat(self,food):

    super().eat(food)

Rucy = Dog('루시',12)

Rucy.eat('사료')

Rucy.run()

- 루시는 사료를 아주 맛있게 먹습니다.

  루시는 달립니다.

 

Rucy.eat('사료')

- 루시는 사료를 아주 맛있게 먹습니다.

 

animal = Animal('동물',10)

animal.eat('먹이') 

animal.run()# 자식 클래스의 객체 메소드를 사용할 수 없음

- 동물는 먹이를 먹습니다

 

Rucy.superEat('사료')

- 루시는 사료를 먹습니다

3. 다중 상속

• c#, java는 다중상속이 불가능
• 파이썬은 c++과 같이 다중상속이 가능
• 여러 클래스를 상속(개수에 제한이 없음)

class Animal:

   def __init__(self,name,age):

      self.name = name

      self. age=  age

   def eat (self,food):

      print(f'{self.name}는 {food}를 먹습니다')

   def sleep (self,hour):

      print(f'{self.name}는 {hour}시간 동안 잠을 잡니다. ')

 

class Human:

  def __init__(self, name, age):

    self. name= name

    self.age = age

  def study(self,hour):

    print(f'{self.name}는 {hour}시간 동안 공부를 합니다')

 

 

class KimApple(Animal,Human):

  pass

kim= KimApple('김사과', 20)

 

kim.eat('밥')

- 김사과는 밥를 먹습니다

 

kim.study(2)

- 김사과는 2시간 동안 공부를 합니다

 

KimApple .mro()

- [__main__.KimApple, __main__.Animal, __main__.Human, object]

1. 스페셜 메소드(Special Method)

• __로 시작해서 __로 끝나는 특수함수
• 해당 메소드들을 재구현하면 객체에 여러가지 파이썬 내장 함수나 연산자에 원하는 기능을 부여할 수 있음

class Point:

  def __init__(self, x, y):

      self.x = x

      self.y = y

  def print_point(self): #(3 , 4)

    print(f'({self.x},{self.y})')

  def __str__(self):#str()함수를 오버라이딩

    return(f'({self.x},{self.y})')

  def __add__ (self,pt): # + 연산자를 오버라이딩(객체 + 객체)

    new_x = self.x + pt.x

    new_y = self.y + pt.y

    return Point(new_x, new_y)

  

  def __sub__(self, pt): #- 연산자를 오버라이딩 (객체 -객체)

    

    new_x = self.x - pt.x

    new_y = self.y - pt.y

    return Point(new_x, new_y)

  def __len__(self): #len()

    return self.x + self.y

  def __getitem__(self,index): #인덱싱을 오버라이딩(객체[인덱스])

    if index == 0:

      return self.x

    elif index == 1:

      return self.y

    else:   

       return -1

 

p1= Point( 3 , 4 )

 

p1.print_point()

- (3,4)

 

print((p1)) #str() 생략

- (3,4)

 

print(str(p1))

- (3,4)

num1= 10

num2= 20

print(num1 + num2)

- 30

print(str(p1))

- (3,4)

 

p2 = Point(5,8)

 

print(p1,p2)

- (3,4) (5,8)

 

p3= p1-p2 

print(p3)

- (-2,-4)

 

print(len(p1))

- 7

 

print(p1[0],p1[1],p1[100])

- 3 4 -1

 

---

 

1. 모듈

• 클래스 또는 함수를 모아 놓은 파일
• 모든 파이썬 파일(.py)은 모듈

#모든 모듈의 전체 함수 가져오기

improt 모듈명

#사용

모듈명.함수명()

import util

 

util.total(1,100)

-5050

 

util.calc(10,3)-

(13, 7, 30, 3.3333333333333335)

# 특정 함수만 골라서 가져오기

from 모듈명 import 함수1, 함수2...

 

# 사용

함수명()

 

from util import calc

 

_, _, _, result = calc(10,3)

print(result)

- 3.3333333333333335

 

# 모든 모듈의 함수 가져오기

from 모듈명 import *

# 사용

함수명()

 

from util import *

 

total(1,100)

-5050

 

calc(10,3)

- (13, 7, 30, 3.3333333333333335)

 

#모듈에 별명 붙여 불러오기

import 모듈명 as 별명

# 사용

별명.함수명()

 

import util as ut

 

ut.total(1,100)

- 5050

 

ut.calc(10,3)

- (13, 7, 30, 3.3333333333333335)

 

2. 구글드라이브 활용

util = '/content/drive/MyDrive/Colab Notebooks'

import sys

sys.path.append(util)

3.클래스를 포함한 모듈

import util2 as ut2

- 3.141592

 

math = ut2.Math()

 

math.circle(5)

-78.5398

 

math.add(10,4)

-14

 

4. 패키지

• 모듈의 상위개념
• 모듈이 모여있는 디렉토리

4-1, 패키지 관리자

• 외부 모듈을 설치 또는 삭제하기 위한 프로그램
• pip 명령을 사용(파이썬을 설치하면 pip가 함께 설치됨)
• 윈도우 명령 프롬프트 또는 터미널에서 사용
• pip --version 으로 버전을 확인할 수 있음

---

머리가 엄청 아팠다 하지만 도움을 받아서 해냈지만 그래도 포기 안하고 열심히 했다는것에 행복함을 느꼈다.

주말에 더 열심히 해야겠다.