Notion에서 정리한 내용을 공유용으로 옮긴 내용입니다.
양식과 구성의 어색함이 있을 수 있습니다.

04/07(월) ~ 04/08(화) 학습내용을 바탕으로 업로드하였음

하루 밀려서 오늘 싹 정리...

객체 지향 프로그래밍

이 부분 너무 어려워...나 울어...
기존에 문제 풀 때도 헤맸던...영상을 따로 찾아보고 했었는데 또 배워도 모르네

• 객체 지향 프로그래밍이란?

  • 객체를 지향하는 프로그래밍 방식

• 객체의 배경
  (방식의 발전?)

• 변수에서 시작 (v1, v2, v3...)

  • 이름만 정해주면 값 저장해 두었다가 이름으로 접근해서 가져오기
  • 학생 500명 → 변수가 너무 많아… → 배열 등장

• 배열/리스트/튜플 (묶어서 [v1, v2, v3...] 한번에 관리)

  • 국어, 수학, 등등 점수 배열이 많아짐
  • 마찬가지로 관리 귀찮음

• 딕셔너리

  • 학생 한 명을 딕셔너리에 담음
  • 그것들을 모아서 리스트로 → 이름을 가지고 관리 이거 괜찮네.
    

• 딕셔너리에서 객체로

  • 자동차의 이름, 연식 : 자동차의 데이터
  • 출력하기 위해 외부에 함수 만듦
    자동차의 데이터 전달 → 이 정보를 가지고 외부의 함수에서 출력됨
    
  • 즉, 자동차의 데이터 : 딕셔너리가 가지고 있음
    자동차의 데이터 처리 : 다른 함수에 할당되어 있음
    이걸 한 번에 묶어버리자! → ‘객체’
    

• 객체란?

  • 자동차
    • 자동차의 요소 : 엔진, 타이어, 등등 + 전진/후진/ 등등 처리하는 기능들
    • 누군가 자동차를 외부에서 밀지 않음 → 전부 자동차 객체에 담겨 있는 것
  • 비행기
    • 누군가 날리는 게 아님
    • 스스로 나는 것 ← 스스로 날 수 있는 기능 내장
  • 학생
    • 학생 객체 = 데이터 + 데이터에 할당된 기능
    • but 반드시 학생과 관련된 것만 담아야 함
    • 이렇게 만들면 학생 객체만 가져오면 그 안에 있는 데이터와 기능을 다 가져올 수 있음

객체

• 어떤 개체들을 구성하는 데이터 → 변수
• 데이터에 있는 값들을 처리하는 기능 → 함수(메서드)
• 객체는 객체와 관련 있는 데이터(데이터를 담는 변수) +거기에 담겨있는 변수를 처리하는 기능, 함수(메서드)로 구성
  
• 객체를 생성하기 위한 설계도 존재 → Class

클래스

개발자는 class 설계

이거 가지고 객체 만들어줘 요청하면 class 개수만큼의 객체 생성

학생 100개 만들어줘 100번 요청한다면 → 객체 100개

• 변수 : 각 객체마다 만들어짐
• 메서드 : 하나만
• class : 메모리에 올라감

객체를 아무리 많이 만들어도 변수만 만들어지기 때문에 메모리를 많이 먹지 않음

• 학생 객체는 각각 독립적
  학생 A의 ‘이름’에 김이 들어갔다고 모든 학생의 이름이 김인 건 아님
  

• 사람들이 객체 지향에서 가장 어려워하는 것
  • 뭘 작성해 줘야 하지 → 설계 어려워함
• 프로그램 상에서 필요한 기능들 정리하기
• 각 처리를 위해 필요한 기능 정리
• 관련 있는 것들 묶기 → 이게 바로 객체 지향
• 다른 곳에서 쓴다면 밖으로 빼기

클래스

시작이다

• 객체를 생성하기 위한 설계도

class TestClass1 :
    pass

• 객체 생성

# 객체를 생성한다.
t1 = TestClass1()
t2 = TestClass1()
print(t1)
print(t2)

<main.TestClass1 object at 0x0000016871104EC0>
<main.TestClass1 object at 0x0000016871104680>

• TestClass1 object : TestClass1의 객체이다.
• 뒤 주소값이 다름 → t1, t2는 다른 객체

# 비교
t3 = t2
print(t2)
print(t3)

<main.TestClass1 object at 0x0000016871104680>
<main.TestClass1 object at 0x0000016871104680>

→ t2, t3는 같은 객체

• 객체에 변수 추가

# 파이썬은 생성한 객체에 변수를 추가하는 것이 가능하다.
t1.a1 = 100
print(t1.a1)

100

• 객체의 독립성

# 객체에 변수를 추가한다고 하더라도 같은 클래스를 가지고 만든 다른 객체에는 추가되지 않는다.
# 객체는 독립적이기 때문이다.
print(t2.a1)

# 에러!

객체의 멤버

• 멤버 : 클래스나 객체 안에 들어 있는 것들
• 멤버 변수 : 객체가 가지고 있는 데이터
• 멤버 메서드 : 객체가 할 수 있는 동작(함수)

~~# 파이썬은 클래스를 통해 생성되는 객체의 멤버 변수를 정의할 수 없다. 헷갈려서 수정~~
# 파이썬은 클래스 정의 부분에 멤버 변수를 미리 선언하지 않는다.
# 클래스를 통해 객체를 생성하면 아무것도 가지고 있지 않는 텅 비어있는 객체가 생성된다.

# 이 객체에 변수를 추가해 줘야 한다.

class TestClass2 :
    # 생성자
    # self : 생성된 객체의 정보가 담기고 이를 통해 객체에 접근할 수 있다.
    def __init__(self) :
        print('init')
        print(f'self : {self}')
        # 객체가 가지고 있어야 할 변수를 여기에서 추가해준다.
        self.a1 = 100
        self.a2 = 200

생성자

• 클래스를 통해 객체를 생성할 때 자동으로 호출되는 함수(메서드)

• 파이썬에서는 클래스를 통해 객체를 생성할 경우 텅 비어있는 객체를 생성하고 생성자를 호출한다.

• 여기에서 객체에 변수를 추가하는 작업을 하면 클래스를 통해 만들어지는 모든 객체는 동일한 이름의 변수들을 가진 상태에서 사용할 수 있다.

• t1과 self의 주소값 같음

t1 = TestClass2() # 객체 생성 : 텅 빈 객체 생성 # -> 무조건 자동으로 __init__ 호출
# 객체의 주소값이 매개변수인 self 로 들어옴
print(f't1 : {t1}') 

init
self : <__main__.TestClass2 object at 0x00000168713D40B0> 
t1 : <__main__.TestClass2 object at 0x00000168713D40B0>

• 주소값, 객체에서 변수 호출해보기

t1 = TestClass2()
print(f't1 : {t1}')
# 객체가 가지고 있는 변수에 접근한다.
print(f't1.a1 : {t1.a1}')
print(f't1.a2 : {t1.a2}')

init
self : <__main__.TestClass2 object at 0x00000168711048C0>
t1 : <__main__.TestClass2 object at 0x00000168711048C0>
t1.a1 : 100
t1.a2 : 200

t2 = TestClass2()
print(f't2 : {t2}')
print(f't2.a1 : {t2.a1}')
print(f't2.a2 : {t2.a2}')

init
self : <__main__.TestClass2 object at 0x00000168713D4AD0>
t2 : <__main__.TestClass2 object at 0x00000168713D4AD0>
t2.a1 : 100
t2.a2 : 200

t1 실행시 self와 t1의 주소값, t2 실행시 self와 t2의 주소값 각각 같음

그러나 t1과 t2의 self의 주소값은 서로 다름 (독립적)

# (학습) 텅 빈 객체 만들어짐
class TestClass5:
    pass

t = TestClass5()
print(t.__dict__)  #객체 t가 가진 멤버 변수들을 딕셔너리 형태로 보여줘.

class TestClass2 :
    def __init__(self) :
        print('init')
        print(f'self : {self}')
        self.a1 = 100
        self.a2 = 200

t1 = TestClass2()
print(f't1 : {t1}') 

색깔 넣었다!!! 어휴 내가 파이썬하니 HTML하니

# 같은 클래스로 생성한 객체라고 하더라도 서로 독립적이므로
# 변수의 값이 항상 같지는 않다.
t1.a1 = 1000
print(f't1.a1 : {t1.a1}')
print(f't2.a1 : {t2.a1}')

→ t1.a1 : 1000
t2.a1 : 100

• 매개변수를 가진 생성자

# 생성자도 함수의 일종이므로 매개변수를 가질 수 있다.
# 단, 첫 번째 매개변수에는 생성된 객체의 주소 값으로 결정되기 때문에
# 두 번째 매개변수부터 값을 결정해 주면 된다. (기본값도 설정할 수 있다.)
class TestClass3 :
    # 생성자
    def __init__(self, v1, v2, v3 = 3) :
        self.a1 = v1
        self.a2 = v2
        self.a3 = v3

• 첫 번째 매개변수 → 무조건 객체의 주소값(self)이 들어옴

t1 = TestClass3(10, 20, 30)
print(t1.a1, t1.a2, t1.a3)

t2 = TestClass3(10, 20)
print(t2.a1, t2.a2, t2.a3)

→ 10 20 30
10 20 3

메서드

• 객체를 통해 호출하는 함수들

# 객체를 통해 호출하기 때문에 첫 번째 매개변수에는 객체의 주소값이 들어온다.
# 이를 통해 객체에 접근하여 객체가 가지고 있는 변수를 사용할 수 있다.
class TestClass4 :
    # 생성자
    def __init__(self, a1, a2) :
        self.v1 = a1
        self.v2 = a2

    # 메서드
    # 객체를 통해서 메서드를 호출하면 첫 번째 매개변수에 메서드를 호출하기 위해
    # 사용한 객체의 주소값이 들어온다.
    # 이를 통해 객체에 접근하여 객체의 변수를 사용할 수 있다.
    def test_method(self) :
        print(self.v1)
        print(self.v2)

t1 = TestClass4(10, 20)
t1.test_method()

t2 = TestClass4(100, 200)
t2.test_method()

→ 10
20
100
200

상속

각각의 특성을 알아보면

• 강아지
  • 다리가 4개
  • 꼬리 1개
  • 멍멍 짖는다
  • 사고친다
  • 먹은 사료 개수
• 구미호
  • 다리가 4개
  • 꼬리 9개
  • 변신한다
  • 사고친다
  • 먹은 간 개수
• class 마다 동일한 기능 있음

→ 동물 class 새로 생성

• 동물
  • 다리 개수
  • 꼬리 개수
  • 사고친다
• 그 후 강아지, 구미호 → 동물 상속
  
  

상속

• 클래스가 다른 클래스가 가진 것들을 물려받는 개념

• 상속 시켜 주는 클래스 : 부모 클래스

• 상속 받는 클래스 : 자식 클래스

• 자식 클래스는 부모가 가진 것들을 마치 자기 자신한테 있는 것 처럼 사용할 수 있다.
  
  

• 부모 클래스

class Animal :
    def __init__(self, _type) :
        self.animal_type = _type

    def eat(self) :
        print(f'{self.animal_type}가 사료를 먹습니다')

• 자식 클래스

class Dog(Animal) :
    def speaking(self) :
        print('멍멍')

class Cat(Animal) :
    def speaking(self) :
        print('냐옹 냐옹')

Animal이 변수 자리에

t1 = Dog('강아지')
print(t1.animal_type)
t1.eat()
t1.speaking()

t2 = Cat('고양이')
t2.eat()
t2.speaking()

강아지
강아지가 사료를 먹습니다
멍멍
고양이가 사료를 먹습니다
냐옹 냐옹

울음소리는 다르지만 먹는 것은 같으므로 애니멀 클래스(부모 클래스)에서 상속

• 부모 init이 먼저 호출, 그 다음 자식 init이 호출

예외처리

• 오류 발생 대비하려면
  • 발생할 가능성이 높은 것들 목록화
  • 실제로 그 작업이 일어나기 전에 먼저 확인하고 그 작업이 일어나지 않도록 중단시킴 → 예외
• 오류(error) ≠ 예외 (exception)
• 예외 : 사전에 미리 확인이 가능한 오류
• 오류 : 실행을 해 봐야 아는 것들
• PVM : 오류가 발생할 가능성이 동작할 경우 수행 중단
  • 튕기는 이유 : 주로 그 코드가 오류를 발생시킬 가능성이 있어서 virtual machine이 강제 중단 시키는 것
  • 개발자는 미리 대처해 놓아서 강제 종료되지 않고 잘 작동되게 함

ex) 키보드 입력받는 것 → 문자열로 받음

• 문자열 → 숫자로 바꾸는 과정이 있다면
  • 100 → 정상으로 바뀜
  • 안녕하세요 → 오류 → 강제 종료(튕김)

대응방법

• 사용자가 정상적으로 입력할 때까지 계속 받기

• 오류가 발생했거나 오류가 발생될 가능성을 만났을 때 프로그램이 강제 종료되는 것을 막고 돌아가도록 하는 것
• 다시 정상화하거나 오류 기록 후 종료할 수 있도록
  (가장 중요한 건 오류가 나지 않도록 코드를 잘 만드는 것)

발생되는 데이터에 대해서 문제가 있는 데이터를 동작시키기 전에 if 문으로 미리 검사
→ 문제가 있으면 return 등을 통해서 돌아가지 않도록 만들기

• 오류 발생시
  - 정상화
  - 오류 기록 후 종료
  - 만약 어디까지 했는지 기록하지 않으면 처음부터 해야 함
  
  

• 이런저런 오류들

• test 1)

ZeroDivisionError : 파이썬에서 만들어 목록화해놓은 일종의 “Class”

a1 = 10 / 0
print(a1)

print('이 부분이 수행될까요?')

→ 10 / 0 에서 중단
아래 수행은 되지 않음

• test 3)

try:
    a1 = 10 / 0
    print(a1)
except :
    print('오류가 발생하였습니다')

print('이 부분이 수행될까요?')

오류가 발생하였습니다
이 부분이 수행될까요?

잘 수행됨

용어

• try : 개발자가 작업하고자 하는 코드를 작성하는 부분
• except : try 부분에서 예외가 발생하면 try 부분의 수행을 중단하고 except 부분을 수행해 준다. 여기에 정상화를 위한 코드나 오류메시지 기록 등에 관련된 작업을 해준다.
  
• else : try 부분에서 예외가 발생하지 않고 모두 수행되었을 경우 동작하는 부분
• finally : try 부분에서 예외 발생 여부와 관계없이 무조건 동작하는 부분이다.
  (but finally 안 써도 코딩 가능)

진행 구조

• 예외가 발생하지 않았을 경우 : try 부분을 모두 수행
  • else가 있다면 else 부분 수행
  • finally가 있다면 finally 부분을 수행
• 예외가 발생했다면 : try 부분의 수행을 중단
  • except 부분을 수행
  • finally 부분이 있다면 finally 부분을 수행

• try
  • try에서 아무것도 문제 없으면 else
  • try에서 오류 있으면 except
  • 둘 중 한 쪽은 무조건 실행
• finally (없어도 됨)
  
  
  
  
• 구조 1)

try :
    a1 = 10 + 20
    print(a1)
except :
    print('예외가 발생하였습니다')
else :
    print('예외가 발생하지 않았습니다')
finally :
    print('무조건 동작하는 부분입니다')

30
예외가 발생하지 않았습니다
무조건 동작하는 부분입니다

try → else → finally 동작

• 구조 2)

try :
    a1 = 10 / 0
    print(a1)
except :
    print('예외가 발생하였습니다')
else :
    print('예외가 발생하지 않았습니다')
finally :
    print('무조건 동작하는 부분입니다')

예외가 발생하였습니다
무조건 동작하는 부분입니다

try → except → finally 동작

• 오류는 하나만 발생한다.

  • 오류가 여러 개여도 첫 번째 오류 발생하면 중단
  • 따라서 여러 except를 만들어서 구분
  • 구분 기준 : 오류 클래스
  • 오류가 발생하면 그 클래스에 대한 객체 생성됨
    • except Exception as e: 통해서 객체 받을 수 있음

• 오류 클래스

  • Exception
    • 모든 오류 클래스들은 Exception 상속받음
  • ZeroDivisionError
    • 0으로 나누는 에러
  • IndexError
    • 순서값 잘못 넣은 에러 (list len이 10인데 a1[20])

모듈

# 모듈
- 파이썬 코드를 작성하는 파일의 확장자는 py이다.
- 이 py 파일이 하나의 모듈이 된다.
- 파이썬 코드를 작성할 때 다른 py 파일에 작성되어 있는 것을
사용할 수 있다.

모듈 생성/작동

• 모듈 새로 생성 (test_module1)

# test_module1.py

print('test_module.py')
print('안녕하세요')

• 모듈 작동시켜보기

# test_module1.py 파일의 코드를 "실행"시킨다.
# (다른 언어와 다른 부분)
import test_module1

test_module.py
안녕하세요

• 이미 import한 모듈을 또 import 하면 아무런 일도 하지 않는다.

import test_module1

→ 출력 아무것도 안 됨

모듈의 변수, 함수, 클래스 사용하기

• 변수, 함수, 클래스를 가진 모듈 생성 (test_modul2)

# <test_modul2.py>

test2 = 100

def test2_function() :
    print('test2_function')

class TestClass2 :
    pass

• 다른 모듈에 있는 변수, 함수, 클래스 사용해 보기
  • 기본적으로는 모듈명과 같이 사용해야 함
  • 어느 모듈의 것인지 명시
  • 다른 모듈에 같은 이름일 경우 구분

import test_module2

print(test_module2.test2)
test_module2.test2_function()
t2 = test_module2.TestClass2()
print(t2)

100
test2_function
<test_module2.TestClass2 object at 0x000001BDEC44FBF0>

모듈명 쉽게 쓰기

• 쉽게 쓰는 방법
  1. (그냥) 생략하기
     • but 동일이름이 다른 모듈에 있을 수 있으니 주의
     • 두 모듈에서의 이름이 같은 경우 modul1의 것은 그냥 쓰고 modul2의 것은 module2.TestClass2( ) 처럼 붙여 쓰기
       
  2. 별칭 사용하기

별칭 사용하기

• test_module3 생성

# <test_module3.py>

test3 = 300

def test3_function() :
    print('test3_function')

class TestClass3 :
    pass

• 별칭은 import module as m1 의 형식으로 사용

# 별칭
# 모듈명이 너무 길다고 생각되면 별칭을 사용할 수 있다.
import test_module3 as m3
print(m3.test3)
m3.test3_function()
t3 = m3.TestClass3()
print(t3)

300
test3_function
<test_module3.TestClass3 object at 0x000001BDEC55AC60>

• 별칭을 부여해서 import 한 모듈은 모듈명으로는 사용할 수 없고 별칭으로만 사용해야 한다.

print(test_module3.test3)

→ NameError

모듈명 생략 : 부분 생략

• test_module4 생성

# <test_module4.py>

test4 = 400

def test4_function() :
    print('test4_function')

class TestClass4 :
    pass

• 모듈명 생략 : 사용하고 싶은 것에 대해서만 지정하기
• from 모듈명 import 함수명,변수명,클래스명 등

# 모듈명 생략 - 사용하고 싶은 것에 대해서만 지정하기
# from 모듈명 import 함수명,변수명,클래스명등
from test_module4 import test4
from test_module4 import test4_function, TestClass4

print(test4)
test4_function()
t4 = TestClass4()
print(t4)

400
test4_function
<test_module4.TestClass4 object at 0x000001BDEB92AF60>

모듈명 생략 : 전체 생략

• test_module5 생성

# <test_module5.py>

test5 = 500

def test5_function() :
    print('test5_function')

class TestClass5 :
    pass

• 모듈명 생략 : 전체 모듈명 생략

# 모듈에 있는 모든 요소들을 모듈명 생략하겠다라고 한다.

from test_module5 import *

print(test5)
test5_function()
t5 = TestClass5()
print(t5)

500
test5_function
<test_module5.TestClass5 object at 0x000001BDEA31C560>

패키지

• py 파일을 가지고 있는 디렉토리(폴더)
• 패키지 안에 있는 모듈을 사용할 때도 import 필요

패키지 내 모듈 import

• test_module6 생성

# <test_module6.py>

test6 = 600

def test6_function() :
    print('test6_function')

class TestClass6 :
    pass

• 패키지 내 모듈 사용시 package1.module1.xxx

# 패키지 내의 모듈을 import 한다.
import package1.test_module6

# 패키지 내의 모듈이 가지고 있는 요소를 사용할 때는 패키지명.모듈명을 해야 한다.
print(package1.test_module6.test6)
package1.test_module6.test6_function()
t6 = package1.test_module6.TestClass6()
print(t6)

600
test6_function
<package1.test_module6.TestClass6 object at 0x000001F6A6AD2600>

패키지명 생략, 모듈명 명시

• test_module7 생성

# <test_module7.py>

test7 = 700

def test7_function() :
    print('test7_function')

class TestClass7 :
    pass

• 패키지명 생략 → 모듈명 명시

# 패키지명을 생략하고 싶다면
# 모듈명은 명시해야 한다.
from package2 import test_module7
print(test_module7.test7)
test_module7.test7_function()
t7 = test_module7.TestClass7()
print(t7)

700
test7_function
<package2.test_module7.TestClass7 object at 0x000001F6A7FF7B30>

패키지명.모듈명 생략

• test_module8 생성

# <test_module8.py>

test8 = 800

def test8_function() :
    print('test8_function')

class TestClass8 :
    pass

• package.module로 패키지명+모듈명 생략

# 패키지명과 모듈명을 생략한다.
from package3.test_module8 import test8, test8_function, TestClass8

print(test8)
test8_function()
t8 = TestClass8()
print(t8)

800
test8_function
<package3.test_module8.TestClass8 object at 0x000001F6A7FA79B0>

모든 모듈의 패키지 생략 (from package import *)

• 주의
  - 패키지 내의 모든 모듈들을 패키지명을 생략하고 사용할 수 있도록 하기 위해 를 사용하면 __init__ .py 파일에 있는 __all__ 변수에 담긴 리스트를 확인
  - 이 리스트에 명시되어 있는 모듈들에 한해서만 패키지명을 생략하고 사용할 수 있음
  - 원래 과거의 파이썬에서는 __init__ .py 파일이 있는 폴더만 패키지로 인식을 하였으나버전이 업데이트 되면서 py만 있으면 패키지로 인식
  - but 를 통해 패키지명을 생락하고 싶은 모듈을 지정할 때는 __init__ .py 파일을 만들고 __all__ 변수에 모듈명이나 하위 패키지명을 문자열로 넣어 줘야 함
  
  

• __init__ .py 없을 때

from package4 import *

print(test_module9.test9)
print(test_module10.test10)

→ NameError

• package 내에
  • __init__ .py 파일 생성

    # * 를 통해 패키지명을 생략하고 사용할 수 있도록 허용해주고 싶은 모듈이나 하위 패키지명을
    # 리스트에 문자열로 작성해준다.
    __all__ = ['test_module9', 'test_module10']

  • test_module9 생성

    <test_module9.py>
    
    test9 = 900
    
    def test9_function() :
        print('test9_function')
    
    class TestClass9 :
        pass

  • test_module10 생성

    <test_module10.py>
    
    test10 = 1000
    
    def test10_function() :
        print('test10_function')
    
    class TestClass10 :
        pass

• 실행시키면 잘 작동한다.

from package4 import *

print(test_module9.test9)
print(test_module10.test10)

900
1000

진짜 끝

노션에서는 토글로 접어서 내보냈는데 다 들어갔네...
오래 전부터 필기에서 초록색으로 내 생각, 모르겠는 부분, 사족 적는 데 쓰는데
객체지향 부분 노션 페이지는 진짜 한 20~30%가 초록색ㅋㅋㅋ
이제 이해될 거 같긴 한데 또 실전 만나면 모르겠네

일단은 GPT가 많이 발전해서 다행이라는 생각만 드는 중

와 5시! 디코에 아무도 없음 당연하지
노는 시간이 길어서 늦어졌지만 어쨌든 마무리