우리 FISA AI엔지니어링 2주차 과정

Monday (01.06)

오늘의 점심


별점 ⭐️⭐️⭐️

평범한 솥밥맛, 제육은 달다 ..

https://naver.me/FbzLw7AF

네이버 지도

 

 

 

타입 힌트

 

타입 힌트:  함수나 변수의 데이터 타입을 명시적으로 지정해주는 주석과 비슷한 개념

def add(a: int, b: int) -> int:
    return a + b
add('5', 3)  # 타입 힌트와 다르지만 실행은 됨

이때, 자료형 강제는 불가능함. 파이썬은 동적 타이핑 언어이기에 데이터 타입이 실행 중에 변경될 수 있다.

타입 힌트는 가독성을 위해 사용하며, 자료형 강제를 위한다면 라이브러리를 사용하면 된다.

 

전역변수, 지역변수

 

전역변수와 지역변수를 나눠서 사용하는 이유 → 전역변수는 위험하기 때문

지역변수 사용을 지향하며, 추가적으로 해당 지역변수를 전역변수화 시키고 싶다면, global 키워드를 사용하자

 

재귀함수

 

재귀함수를 기피하던 과거와 달리, 비정형 데이터의 수가 늘어남에 따라  현재는 재귀함수또한 자주 사용하는 추세이다.

함수는 스택메모리에서 실행이 되므로 LIFO구조에 따라 동작하여 마지막에 호출된 함수가 먼저 실행된다.

example = [[1,2,3], [4,[5,6]],7,[8,[9]]]
# output = [1,2,3,4,5,6,7,8,9]


def recur(example):
    arr=[]
    for item in example:
        if isinstance(item,list):
            arr.extend(recur(item))
        else:
            arr.append(item)
    return arr

print(recur(example))

 

이때, arr.extend(recur(item))를 써야한다. 처음에 arr.append(recur(item)) 쓰니까 안되는데

차원이 다른 리스트의 원소를 평탄화 하는 것이기에, 각 리스트의 항목을 개별적으로 풀어서 추가해야 한다.

extend()는 이 작업을 수행하는 반면, append()는 중첩된 리스트를 그대로 넣기때문에 리스트가 평탄화 적용이 안된다.

추가로 arr.extend(item)은 안된다.

 

• append, extend 모두 삽입하는 비슷한 역할을 하지만 차이점이 존재
• append는 리스트에 단일 항목 추가에 적용하는 반면 extend는 iterable 객체에만 적용할 수 있고,  
• append는 있는 그대로 넣는 반면 extend는 iterable 객체를 풀어서 넣는다.

 

함수형 문법에는 여러 종류가 있다.

 

• 고차 함수(함수를 인자로 받거나 반환)
• map(), filter(), reduce()
• lambda 함수
• 리스트/셋/제너레이터 컴프리헨션
• any(), all(), sorted()

이 중 몇가지를 정리해보자

익명함수

 

Lambda, 쓰고 버리는 함수로, 함수명을 가진 함수 또한 만들 수 있다.

사용법: lambda 파라미터:명령어

minus = lambda a,b:a-b
print(minus(4,3))

divide = lambda a,b:a//b
print(divide(12,3))

points = [(3,2),(1,0),(1,1),(3,2)]
#y좌표 순으로 정렬 -> lambda 사용
sorted(points, key = lambda points:points[1])

 

 

List Comprehension

기존 리스트로 다른 리스트를 만드는 방법 → 불필요한 메모리 할당 안함

for + append 를 사용하는 방법보다 속도가 빠르다.

사용법: [(변수에 적용할 수식) for (변수) in (for문이 돌아가는 범위) (조건문)]

#for 문을 활용해서 1~6 담긴 리스트
list1=[]
for i in range(1,7):
    list1.append(i)
print(list1)

#list comprehension 활용
list2 = [x for x in range(1,7)]
print(list2)

# 2의 배수
result =[ x for x in range(1,12) if x%2==0]
print(result)

num = '12345' # 외부반복문
word = 'ABCDE' # 내부반복문

arr=[]

# for문
for i in range(len(num)):
    for j in range(len(word)):
        if str(num[i])  != word[j]:
            arr.append(str(num[i]) + word[j])

#list comprehension
arr=[str(num[i]) + word[j] for i in range(len(num))  for j in range(len(word)) if str(num[i])  != word[j]]
print(arr)

 

 

map

 

• iterable객체의 각 요소에 동일한 함수를 적용할 때 사용, 메모리 효율적
• 람다와 함께 사용하기 편하다.

words = ['apple', 'banana', 'cherry']
list(map(str.upper,words)) #출력: ['APPLE', 'BANANA', 'CHERRY']

string_floats = ['1.1', '2.2', '3.3', '4.4', '5.5']
list(map(float,string_floats)) #출력: [1.1, 2.2, 3.3, 4.4, 5.5]

li = [1, 2, 3, 4, 5]
tuple(map(lambda x: x+1,li)) #출력: (2, 3, 4, 5, 6)

 

 

filter

• iterable객체의 각 요소에 대해 function이 참인 것만 반환

def even(x):
    if x%2 ==0:
        return x
list(map(even,li)) #조건 만족 안하는 방에는 None을 채워넣음 출력: [None, 2, None, 4, None]
list(filter(even,li)) #조건 만족 하는 것만 출력: [2, 4]

 

enumerate

• 리스트의 요소를 추출할 때 번호를 붙여서 추출 

list1 = ['사과', '바나나', '딸기', '포도', '키위']

for a,b in enumerate(list1):
    print(a+1,": ",b)
    
#출력
'''
1 :  사과
2 :  바나나
3 :  딸기
4 :  포도
5 :  키위
'''

 

zip

• zip(list,list):  2개 이상의 리스트를 합치며, 길이를 확인하지 않으면 누락될 수 있다는 주의점

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']

result = zip(list1, list2)
print(list(result))
# 출력: [(1, 'a'), (2, 'b'), (3, 'c')]

pairs = [(1, 'a'), (2, 'b'), (3, 'c')]

list1, list2 = zip(*pairs)
print(list1)
print(list2)

# 출력
# (1, 2, 3)
# ('a', 'b', 'c')

 

reduce

• 리스트의 원소들을 누적하여 더함
• 누적합 사용시 좋다. sum 이 있지만, 다른 차원의 계산도 할 수 있다는 점에서 유용하다.

from functools import reduce

nums = [1, 2, 3, 4]
result = reduce(lambda x, y: x + y, nums)  # 1+2 -> 3, 3+3 -> 6, 6+4 -> 10
print(result)  # 출력: 10

test = [{'name' : 'a', 'age' : 1}, {'name' : 'b', 'age' : 2}, {'name' : 'c', 'age' : 3}]

reduce(lambda x,y:x['age']+y['age'], test,0) #실패
reduce(lambda x,y:x+y['age'], test,0) #성공

 

실패코드

x['age'] + y['age'] 부분에서 x와 y가 딕셔너리일 때, x['age']와 y['age']를 더하는 방식으로 사용하려고 하기 때문

첫 번째 코드에서 x['age']를 사용하려면 x가 딕셔너리여야 하지만, 첫 번째 반복에서 x가 0이기 때문에 딕셔너리가 아님 ->  x['age']에서 오류 

 

성공코드

• 첫 번째 호출: x = 0, y = {'name': 'a', 'age': 1}
  x + y['age'] = 0 + 1 = 1
• 두 번째 호출: x = 1, y = {'name': 'b', 'age': 2}
  x + y['age'] = 1 + 2 = 3
• 세 번째 호출: x = 3, y = {'name': 'c', 'age': 3}
  x + y['age'] = 3 + 3 = 6
  
  
  

 

파이썬 파일

 

파일을 읽고 쓰는 2가지 방법 존재

• 1: 코드가 간결하고, 예외 처리와 파일 닫기를 자동으로 처리해 주기 때문에 더 안전 

with open('파일명', '모드') as file:
    print('내용', file=file)

• 2: 파일을 명시적으로 열고 닫을 수 있지만, 파일을 닫지 않는 실수가 발생할 수 있어 조심해야 한다.

# 1. 파일 생성 및 열기
file = open('파일명', '모드') 

# 2. 사용할 모드 지정 (r, w, a)
file.write("내용") 

# 3. 파일닫기
file.close()

f2 = open('test2.txt','w')
print("새로운 파일입니다",file=f2)
#닫기 전까지는 메모리에만 데이터 저장하다가, 파일 닫으면 그때 데이터 저장
f2.close()

#수정이 빈번하면 파일을 계속 열어놓고 변경사항을 바로 반영 -> 메모리 측면에서 비효율적

f2 = open('test2.txt','w')
print("새로운 파일입니다",file=f2, flush=True)

with open('test3.txt', 'r') as r_test:
    # read()
    content = r_test.read()
    print('read():', content)
    
    # readable() 
    print('readable():', r_test.readable())
    
    # readline()
    r_test.seek(0)  # 파일의 처음으로 이동 (readline은 한 번만 읽으므로)
    while True:
        line = r_test.readline()
        if line =='':
            break
        print('readline(): ',line, end='')

    
    # readlines()
    r_test.seek(0)  # 파일의 처음으로 이동
    lines = r_test.readlines()
    print('readlines():', lines)

# test3.txt 예시
Hello, this is the first line.
This is the second line.
And here is the third line.
Finally, the fourth line.


# read()
read(): Hello, this is the first line.
This is the second line.
And here is the third line.
Finally, the fourth line.

# readable()
readable(): True

# readline()
readline():  Hello, this is the first line.
readline():  This is the second line.
readline():  And here is the third line.
readline():  Finally, the fourth line.

# readlines()
readlines(): ['Hello, this is the first line.\n', 'This is the second line.\n', "And here is the third line.\n", 'Finally, the fourth line.\n']

 

 

추가: print()의 매개변수 end, sep 비교

 

end: 출력 뒤에 덧붙일 문자열을 설정, 기본값은 줄바꿈(\n) 

print("Hello", end=" ") → "Hello " 뒤에 공백을 추가하고 줄바꿈하지 않음.

sep: 여러 값을 출력할 때 각 값 사이에 들어갈 구분자를 설정, 기본값은 공백(' ') 

print("Hello", "world", sep="-") → "Hello-world"로 구분자를 -로 설정.

 

 

---

 

Tuesday (01.07)

 

웰컴 키트를 주셨다.(치약, 키링, 보조배터리, 거치대, 텀블러, 다이어리, 멀티포트) 야미

 

오늘의 점심


별점 ⭐️⭐️⭐️

돈까쓰는 뜨겁고 맛있었다. 밥이 바닥에 눌러붙은게 아쉬웠다.

 

https://naver.me/FQVUuFjc

네이버 지도

 

 

모듈

 '.py' 확장자를 가진 Python 파일로, 함수, 클래스, 변수를 정의하여 재사용 가능한 코드로 만듦

• 전체 모듈을 import

import math1   
print(math1.plus(3, 4))

 

• 특정 함수만 import

from math1 import plus  
print(plus(3, 4))  # 덧셈 함수 직접 사용

 

• 모듈 import하고 다시 import해도 불러온 모듈 재사용 -> 불필요한 모듈 로딩을 방지 

 

파일명은 모듈명으로 사용되기 때문에 '모듈 이름'과 '파일 이름'이 겹치지 않도록 주의

경로를 '.' '/' 로 구분하는 방식에 주의

• 파일 시스템에서 '/'를 사용해 디렉토리 및 파일을 구분 
  • %%writefile /content/drive/MyDrive/package/math1.py
• Python 에서  '.'을 사용해 경로 지정 
  • from drive.MyDrive.package import math1
• 별칭(alias) 사용

import math1 as m   
print(m.덧셈(3, 4))

 

패키지

여러 모듈을 묶어서 관리하는 디렉토리

 

Pytho 3.x 이전까지는 __init__ 파일이 있어야 패키지로 인식

-> 이후부터  __init__ 파일이 없어도 패키지로 인식하지만, 장고같은 전통적인 프레임워크는 __init__.py를 요구한다.

 

예외처리

 

코드 실행 중에 발생할 수 있는 문제를 미리 예측하거나, 발생한 후 이를 적절하게 처리 

1. 컴파일 에러
   • 개발자가 코드 실행 전에 발생하는 에러로 개발자가 수정 가능
   • ex) 문법 오류
2. 런타임 에러
   • 코드 실행 중 발생하는 에러로, 개발자가 실행 전에 해결 불가
   • 0으로 나누기, 파일 열 수 없는 문제

 

예외처리

런타임 에러를 발생 후 처리하는 방법

try: 예외가 발생할 수 있는 코드를 감시하는 블록
except: 예외가 발생하면 처리하는 블록
else: 예외가 발생하지 않으면 실행되는 블록 (선택적)
finally: 예외 발생 여부와 관계없이 항상 실행되는 블록 (선택적)

 

try:
    a = input('정수 입력: ')
    # ValueError: invalid literal for int() with base 10: '십일'
    if int(a) > 0:
        print('True')
    else:
        print('잘못 입력하셨습니다')
    # ValueError: invalid literal for int() with base 10: '백이십삼'
except ValueError as e:  # 숫자로 변환할 수 없는 값을 입력한 경우 처리
    print("정수로 입력")
    print(e)  # 발생한 에러 메시지 출력
except EOFError as e:  # 입력이 종료되었을 때 처리
    print("강제종료했네요")
    print(e)
except Exception as e:  # 위의 두 예외 외에 다른 예외를 처리
    print("뭔지 모를 에러 발생")
    print(e)

• try 블록
  • 사용자가 입력한 값을 int로 변환하려고 시도
  • 만약 사용자가 문자를 입력하면, ValueError가 발생하고, 이 예외는 except ValueError 블록에서 처리 됨
  • int(a)가 0 이하의 값을 입력받으면, "잘못 입력하셨습니다"를 출력
• except 블록
  •  except ValueError: 숫자로 변환 불가한 입력 발생 시 예외
  •  except EOFError: 사용자가 입력을 강제로 종료 했을 시 예외
  •  except Exception: 나머지 모든 예외에 대한 예외

 

예외 처리 우선순위

• 예외는 상위 예외부터 처리해야 한다. 예외 처리 시 하향식으로 실행되기에 세부적인 예외가 상위 예외보다 위에 위치해 있어야 한다.
• ex) Exception을 먼저 처리하고 ValueError가 아래에 있으면, ValueError가 적용되지 않는다.
  
  

문제 분석

def convert(a):
    return int(a[::-1])

try:
    num = input('정수 입력: ')
    print(convert(num))

except ValueError as e: 
    print("정수로 입력")
    print(e) 
except EOFError as e:
    print("강제종료했네요")
    print(e)
except Exception as e:
    print("뭔지 모를 에러 발생")
    print(e)

이때 -32라는 음수를 넣으면      print("뭔지 모를 에러 발생")가 출력된다.

의문이었던 건 num자체를 convert함수에 적용한걸 다른 변수에 할당받지 않았는데, 어째서 num이 convert에 적용되는지였다. 나는 단순히 프린트한것이라 생각했고, 강사님께 여쭤보니 print하기전에 convert가 먼저 적용되고, 하나의 함수로 적용되기에 num이 뒤집히게 된다.

즉, 단순히 프린트하는것이 아니라, convert(num) 함수 호출이 먼저 실행되기 때문이다.

num을 convert() 함수에 적용한 결과는 num이 아닌 함수의 반환값이므로, num이 직접 변경되는 것은 아니지, convert() 내부에서 뒤집히는 결과가 출력되는 것이다.

EAFP & LBYL

개발자 입장에서는 

• AttributeError - debug: EAFP 방식
• ValueError - 전통적 LBYL 방식

try, except만으로 모든 예외를 처리할 수는 없다. elif 구문처럼 예외를 여러개 처리할 수도 있다.

두가지 방식 모두 사용할 수 있어야 한다.

• EAFP (Easier to Ask for Forgiveness than Permission)
  • AttributeError 같은 예외는 try-except로 처리하며 먼저 시도하고 에러가 나면 처리한다.
• LBYL (Look Before You Leap)
  •  ValueError 같은 예외는 if로 확인하고 처리한다.

 

장고의 경우 ctrl+C 누르면 로컬 서버가 종료되는데, 이 예외를 이용하여 종료를 만들 수도 있다. 

raise를 써서 예외를 강제로 발생시켜 프로그램 흐름 제어 할 수도있다.

while True:
    try:
        read = input("c:\> ")
        print(read)
    except EOFError:
        print("실행 종료")
        break

 

클래스

클래스, 객체, 인스턴스의 관계

클래스는 객체 생성을 위한 설계도이다.  (인스턴스 = 객체 = 오브젝트)는 클래스를 토대로 실제로 만들어진 것

class Car:
    # 초기화 메서드 (객체 생성 시 자동으로 호출)
    def __init__(self, make, model, year):
        self.make = make 
        self.model = model  
        self.year = year  

    # start 메서드 (동작을 정의)
    def start(self):
        print(f"{self.year} {self.make} {self.model} is start")

# Car 클래스의 인스턴스
my_car = Car('Toyota', 'Corolla', 2020)  
your_car = Car('Honda', 'Civic', 2021)  

my_car.start()  #출력: 2020 Toyota Corolla is start
your_car.start()  #출력: 2021 Honda Civic is start

• 속성: 객체의 특성을 나타내는 변수
• 메소드: 클래스 내에 정의된 함수로, 객체의 행동 정의

 

클래스 변수 vs 인스턴스 변수 & 클래스 메서드 vs 인스턴스 메서드

 

• 클래스 변수: 클래스 자체에 속한 변수, 이 변수는 모든 인스턴스가 공유하는 변수
  • 클래스 이름으로 직접 접근할 수 있으며, 모든 인스턴스에서 공통으로 사용
• 인스턴스 변수: 각 인스턴스에 속한 변수, 각 객체가 생성될 때마다 self를 통해 초기화된 값을 가짐
  • 각 인스턴스마다 독립적으로 존재하고, 클래스와는 관계없이 개별적으로 관리됨

• 클래스 메서드: 클래스 자체에 적용되는 함수, 인스턴스와 관계없이 클래스 자체에서 동작
  • @classmethod 데코레이터를 사용하여 정의. 없으면 인스턴스 메서드로 간주
• 인스턴스 메서드: 인스턴스에 적용되는 함수, 이 메서드는 첫 번째 매개변수로 self를 받으며, self를 통해 인스턴스 변수에 접근하거나 메서드를 호출
  • 인스턴스 메서드는 객체가 생성될 때 해당 객체에 대해 동작 

class Dog:
    # 클래스 변수
    total_dogs = 0

    def __init__(self, name):
        # 인스턴스 변수
        self.name = name
        Dog.total_dogs += 1  # 인스턴스가 생성될 때마다 클래스 변수가 증가

    # 클래스 메서드
    @classmethod
    def get_total_dogs(cls):
        print(f"Total number of dogs: {cls.total_dogs}")

    # 인스턴스 메서드
    def speak(self):
        print(f"{self.name} says woof!")

# 인스턴스 생성
dog1 = Dog("Buddy")
dog2 = Dog("Bella")

# 인스턴스 메서드 호출
dog1.speak()  # 출력: Buddy says woof!
dog2.speak()  # 출력: Bella says woof!

# 클래스 메서드 호출
Dog.get_total_dogs()  # 출력: Total number of dogs: 2

 

---

 

Wednesday (01.08)

 

오늘의 점심

 

별점 ⭐️⭐️⭐️⭐️

맛도 있고, 가격도 저렴하다 !!

https://naver.me/FRLHdh2V

네이버 지도

 

 

객체지향의 특성

• 상속, 다형성, 추상화 캡슐화

 

• 상속: 부모 클래스를 바탕으로 새로운 클래스를 정의하는 방식
• 부모 클래스의 속성과 메소드를 상속받아 수정할 수 있어, 이를 통해 재사용성이 높아진다.

 

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):  
    def speak(self):
        print("Dog barks")

dog = Dog()
dog.speak()

 

• 다형성: 하나의 이름으로 여러 형태가 가능한 것, 같은 메서드로 다양한 방식으로 동작할 수 있다.
  • 메서드 오버로딩: 하나의 메서드 이름으로 여러 매개변수 처리
  • 메서드 오버라이딩: 상속받은 클래스에서 부모 클래스 메서드 재정의

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Dog barks")

class Cat(Animal):
    def speak(self):
        print("Cat meows")

def make_sound(animal: Animal):
    animal.speak()

dog = Dog()
cat = Cat()

make_sound(dog)  # 출력: Dog barks
make_sound(cat)  # 출력: Cat meows

 

• 추상화: 불필요한 세부 내용은 줄이고, 중요 부분만 노출하는 것
• 세부 구현은 서브클래스, 인터페이스에서 정의

 

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Dog barks")

dog = Dog()
dog.speak()  # 출력: Dog barks

 

• 캡슐화:  객체의 변수, 메서드를 하나로 묶고, 외부에서 접근을 제한하는 것으로, 이를 통해 정보은닉(객체 안전 관리) 
• 접근 제어자(private, protected, public)

 

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # __balance는 private 멤버

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def get_balance(self):
        return self.__balance

account = BankAccount(1000)
account.deposit(500)
print(account.get_balance())  # 출력: 1500

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound.")

class Dog(Animal):  # Animal 클래스를 상속받는 Dog 클래스
    def __init__(self, name, breed):
        super().__init__(name)  # 부모 클래스인 Animal의 __init__ 호출
        self.breed = breed

    def speak(self):  # 부모의 speak 메서드를 덮어씀 (오버라이딩)
        print(f"{self.name} barks!")

    def get_breed(self):
        print(f"{self.name} is a {self.breed}.")

# Dog 클래스의 인스턴스 생성
dog = Dog("Buddy", "Golden Retriever")
dog.speak()  # 부모 클래스에서 오버라이드된 메서드 호출
dog.get_breed()  # 자식 클래스에서 추가된 메서드 호출

#결과
#Buddy barks!
#Buddy is a Golden Retriever.

 

super()를 사용하여 부모 클래스의 __init__() 메서드를 호출하고, 추가적인 breed 속성 초기화

즉, speak() 메서드가 부모 클래스 내용 덮어쓰고, 자식 클래스에서 구현한 내용을 실행함

 

다중상속

 

class Animal:
    def speak(self):
        print("Animal makes a sound.")

class Flyable:
    def fly(self):
        print("Flying!")

class Bird(Animal, Flyable):  # Animal과 Flyable 클래스를 모두 상속받음
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} chirps!")

bird = Bird("Sparrow")
bird.speak()  # 부모 클래스에서 오버라이드된 메서드 호출
bird.fly()  # Flyable 클래스에서 상속된 메서드 호출

파이썬은 다른 언어와 달리 다중상숙이 허용되나, 객체지향 프로그래밍에서는 다중상속을 지양해야한다.

따라서 피할 수 있다면 다중상속을 사용하지 않도록하자

 

class BankAccount:
    # 클래스 변수
    customer_total=0

    def __init__(self, __account, __name, __balance, __password):
        # 인스턴스 변수
        self.__account = __account
        self.__name = __name
        self.__balance = __balance
        self.__password = __password
        BankAccount.customer_total+=1

    # 클래스 메서드
    @classmethod
    def customer_total_check(cls):
        print(f"현재까지 생성된 계좌 수는 {cls.customer_total} ")


    #금액을 입금하는 메서드(put_balance)
    def put_balance(self,balance):
        self.__balance += balance
        print(f'사용자가 입금한 금액은 {balance} 입니다.')
        print("입금완료")
        return self.__balance
    
    #금액 출금하는 메서드(out_balance)
    def out_balance(self,balance):
        if self.__balance<balance:
            print("돈이 부족하여 출금불가")
        else:
            self.__balance -= balance
            print(f'사용자가 출금한 금액은 {balance} 입니다.')
            print("출금완료")
        return self.__balance

    #금액 조회(get_balance)
    def get_balance(self):
        print(f"현재금액: {self.__balance}")
        print("금액 조회완료")

    #비밀번호 변경(set_pw)
    def set_pw(self,__password):
        self.__password = __password 
        print("비밀번호 변경완료")

    #비밀번호 조회(get_pw)
    
   def get_pw(self):
        print(f"현재 비밀번호: {self.__password}")
        print("비밀번호 조회완료")

    

# 인스턴스 생성
customer1 = BankAccount("1209","Kim",10000,"qwer")
customer2 = BankAccount("3487","Lee",20000,"asdf")
customer3 = BankAccount("5665","Park",30000,"zxcv")
customer4 = BankAccount("7843","Lim",40000,"uiop")


# 인스턴스 메서드 호출

customer1.get_balance()
customer1.get_pw()
customer1.put_balance(10000)
customer1.get_balance()
customer1.out_balance(10000)
customer1.get_balance()
customer1.set_pw("QWER")
customer1.get_pw()

BankAccount.customer_total_check()

입금과 출금과 같이 두 가지 이상의 동작을 처리해야 할 경우, 세터를 여러 개 사용하는 대신, 메서드로 각각 입금과 출금을 처리하는 것이 좋다.

@property 데코레이터를 사용하여 getter를 표현하고, 세터의 경우 @get_pw.setter 와 같이 표현하여 세터를 표현할 수 있다. 이를 통해 속성처럼 사용할 수 있고, 메서드 호출처럼 보이지 않아 직관적으로 접근 가능

 

맹글링

 

이름 변경을 가리키는 용어로 인스턴스 변수 앞에 더블 언더스코어(__)를 붙여 표현한다. 

맹글링을 사용하면 클래스 내부에서만 사용할 수 있도록 이름을 변경한다.

'__my_private_variable'과 '__my_private_method'는  '_MyClass__my_private_variable'과 '_MyClass__my_private_method'로 바뀐다. 

파이썬은 변수나 메서드를 비공개로 만들어도, 여전히 외부에서 접근이 되는데, 이를 숨기기 위해 맹글링을 사용한다.

class MyClass:
    def __init__(self):
        self.__my_private_variable = 42

    def __my_private_method(self):
        print("This is a private method.")

 

1. 속성값을 외부에서 접근하기 어렵게 할 때(like Private)

__secret은 실제로_MyClass__secret으로 변경되며, 외부에서 obj.__secret으로 접근할 수 없다. 이를 통해 속성 은닉이 가능하다.

class MyClass:
    def __init__(self):
        self.__secret = "이건 비밀이에요!"

    def reveal_secret(self):
        return self.__secret

# 객체 생성
obj = MyClass()

# 외부에서 __secret에 직접 접근하려고 하면 에러가 발생
try:
    print(obj.__secret)  # AttributeError: 'MyClass' object has no attribute '__secret'
except AttributeError as e:
    print(e)

# 내부 메서드를 통해 접근 가능
print(obj.reveal_secret())  # "이건 비밀이에요!"

 

2. 하위 클래스가 상위 클래스의 속성/메소드 오버라이딩을 막을 때

맹글링을 사용하면, 하위 클래스에서 상위 클래스의 속성을 오버라이딩하는 것을 막는다.

class Parent:
    def __init__(self):
        self.__data = "부모의 비밀"

    def show_data(self):
        return self.__data

class Child(Parent):
    def __init__(self):
        super().__init__()
        self.__data = "자식의 비밀"  # 부모 클래스의 __data를 오버라이딩하려고 시도

    def show_data(self):
        return self.__data  # 부모 클래스의 __data를 사용하려는 시도

# 객체 생성
child = Child()

# 부모 클래스의 __data는 오버라이딩되지 않음
try:
    print(child.show_data())  # AttributeError 발생: 'Child' object has no attribute '_Parent__data'
except AttributeError as e:
    print(e)

# 부모 클래스의 메서드 호출
parent = Parent()
print(parent.show_data())  # "부모의 비밀"

 

Parent 클래스의 __data 속성은 _Parent__data로 이름이 변경되고, Child에서 오버라이딩을 시도하지만, 안된다.

child.show_data() 호출 시, 부모 클래스에서의 __data에 접근하려고 시도하지만, 이미 이름이 변경되어 오버라이딩이 불가능해진다.

 

---

 

Thursday (01.09)

 

오늘의 점심


별점 ⭐️⭐️⭐️⭐️

 

날이 차서 사람들이 건물에서 식사를 하는 듯 했다. 그래서 20분 기다렸다 ㅜㅜ

배가 너무 고파서 급하게 먹느라, 사진도 못 찍었다.

짜글이는 평범했고, 두루치기가 불맛이 나서 맛있었다. 여기는 두루치기 맛집이다.

https://naver.me/FmfzQILO

네이버 지도

 

https://koreatstm.tistory.com/222

NumPy 정리

 

 

---

 

Friday (01.10)

오늘의 점심

 

별점 ⭐️ ⭐️ ⭐️

 

평범한 칼국수 맛

https://naver.me/FnmxyxfQ  

네이버 지도

 

 

https://koreatstm.tistory.com/223

Pandas 정리