Python 기본 문법 정리

 

 

람다 함수 

`lambda` 키워드를 사용하여 정의하는 익명 함수 
- 함수 이름 없이 짧고 단순한 로직을 작성할 때 유용 

• 언제 사용?
  • 상황 : 짧은 함수를 한줄로 표현하고 싶을 때, map() filter() sort() 등과 함께 사용 
  • 사용 이유 : 코드의 간결성, 간단한 변환을 쉽게 적용 

# 일반 함수 정의
def add(x, y):
    return x + y

# 람다 함수 정의
add_lambda = lambda x, y: x + y

# 결과 확인
print(add(3, 5))        # 출력: 8
print(add_lambda(3, 5)) # 출력: 8

# 함수 이름 없이 바로 사용 (정렬 활용)
data = [(1, 2), (3, 1), (5, 0)]

# 두 번째 값을 기준으로 정렬
sorted_data = sorted(data, key=lambda x: x[1])
print(sorted_data)  # 출력: [(5, 0), (3, 1), (1, 2)]

 

 

클래스, 인스턴스, 속성

클래스

• 클래스 = 설계도
• 객체 (인스턴스)를 만들기 위한 틀로, 속성과 메서드를 정의함

class Person:
    def __init__(self, name, age):
        self.name = name  # 이름 속성
        self.age = age    # 나이 속성

    def say_hello(self):  # 메서드 (동작)
        print(f"안녕하세요, 제 이름은 {self.name}입니다!")

인스턴스

• 클래스를 기반으로 생성된 실제 객체
• 클래스 = 설계도, 인스턴스 = 설계도를 바탕으로 만들어진 실제 물건

person1 = Person("지영", 25)  # 인스턴스 생성
person2 = Person("민수", 30)  # 인스턴스 생성

# 각 인스턴스는 독립적으로 존재
print(person1.name)  # 출력: 지영
print(person2.name)  # 출력: 민수

속성

: 클래스나 인스턴스가 저장하고 있는 데이터

 

1. 클래스 속성

• 클래스 자체에 속한 변수
• 모든 인스턴스가 공유하는 값
• 클래스를 설계할 때 정의하며, 인스턴스를 새로 만들어도 값이 변하지 않음

class MyClass:
    number = 100  # 클래스 속성

obj1 = MyClass()
obj2 = MyClass()

print(obj1.number)  # 출력: 100 (클래스 속성 참조)
print(obj2.number)  # 출력: 100 (클래스 속성 참조)

MyClass.number += 10  # 클래스 속성 변경
print(obj1.number)  # 출력: 110 (모든 인스턴스에서 공유됨)
print(obj2.number)  # 출력: 110

 

2. 인스턴스 속성

• 인스턴스에 속한 변수
• 각 인스턴스가 독립적으로 저장하는 값으로, 다른 인스턴스와 공유하지 않음
• __init__ 메서드에서 정의

class MyClass:
    def __init__(self, value):
        self.value = value  # 인스턴스 속성

obj1 = MyClass(100)
obj2 = MyClass(200)

print(obj1.value)  # 출력: 100 (obj1의 속성)
print(obj2.value)  # 출력: 200 (obj2의 속성)

obj1.value += 10  # obj1의 속성 변경
print(obj1.value)  # 출력: 110
print(obj2.value)  # 출력: 200 (obj2는 영향을 받지 않음)

 

클래스 상속

기존 클래스의 속성과 메서드를 새로운 클래스 (자식 클래스)가 물려 받는 것을 의미함
- 코드의 재사용성과 유지보수성을 높일 수 있음

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def printinfo(self):
        print(self.name, self.age)

    def getinfo(self):
        return self.name + ', ' + str(self.age)

class Student(Person):
    def __init__(self, name, age, department, id):
        super().__init__(name, age) # 꼭 모든 인자를 전달 받아야함 (1개만 받기 안됨)
        self.department = department
        self.id = id
    
    def printstuinfo(self):
        name_age = super().getinfo() # 부모클래스의 getinfo() 메서드 호출하여 정보를 반환 받음
        print(name_age)
        print('%s님의 학과:%s, 학번:%s' % (self.name, self.department, self.id))

x = Student('홍지수', 20, '소프트웨어공학과', '2014') 
x.printinfo() # 홍지수 20
x.printstuinfo() # 홍지수, 20 / 홍지수님의 학과:소프트웨어공학과, 학번:2014

• super().__init__(name)을 통해 부모 클래스의 init 메서드를 호출하여 속성을 초기화

- super() : 부모 클래스의 메서드를 호출할 때 사용오버라이딩
- overriding : 자식 클래스가 부모 클래스의 메서드를 재정의하는 것 

 

 

 

Decorator

기존 함수의 코드를 직접 수정하지 않고 새로운 기능을 추가
- 함수 안에 반복되는 로직을 간결하게 구현할 수 있음

• 기능
  • 함수 안에 해줘야 되는 내용들을 간결하게 구현해 낼 수 있음 
  • 코드의 재사용성 측면에서 굉장히 좋다
  • 함수의 실행 전후에 필요한게 있으면 `decorator` 기능 활용하면 좋다 

def my_decorator(func):
  def wrapper():
    print('함수 호출 전')
    func()
    print('함수 호출 후')
  return wrapper

def say_hello():
  print('안녕하세요!')

say_hello(); print() # 안녕하세요
say_hello = my_decorator(say_hello); say_hello() # 함수호출전, 안녕하세요, 함수호출후


# ----- decorator 적용하면 -----
@my_decorator
def say_hello():
  print('안녕하세요!')

say_hello() # 함수호출전, 안녕하세요, 함수호출후

 

* 좀더 활용 예시 

def validate_positive_number(func):
    def wrapper(arg):
        if arg < 0:  # 인자가 0보다 작으면 예외 발생
            raise ValueError("인자는 0보다 커야(positive) 합니다.")
        return func(arg)  # 조건을 만족하면 원래 함수 실행
    return wrapper

def validate_integer(func):
    def wrapper(arg):
        if not isinstance(arg, int) or arg < 0:  # 정수가 아니거나 음수일 경우 예외 발생
            raise ValueError("인자는 자연수(integer)여야 합니다.")
        return func(arg)  # 조건을 만족하면 원래 함수 실행
    return wrapper


# ----- 중첩해서 사용 가능 -----
@validate_positive_number
@validate_integer
def process_number(num):
    print(f"숫자 검증: {num}")

process_number(1.1) # 에러 발생 : 두번째 (validate_integer) 만족 안함