오즈코딩스쿨 초격차캠프 백엔드 5일차

Hyemin Kim·2023년 12월 13일

오즈코딩스쿨 초격차캠프 백엔드

목록 보기

5/16

✅ 1. 객체지향에 대해서 설명해주세요

객체지향 프로그래밍(Object-Oriented Programming, OOP)은 소프트웨어를 개발하기 위한 프로그래밍 패러다임 중 하나로, 현실 세계의 사물을 모델링하여 소프트웨어를 구현하는 방법론입니다. 객체지향 프로그래밍은 코드를 재사용하고 유지보수하기 쉽게 만들어주며, 프로그램의 구조를 논리적이고 모듈화된 형태로 설계할 수 있도록 돕습니다.

객체지향 프로그래밍에서는 다음과 같은 주요 개념이 사용됩니다:

클래스(Class):
- 클래스는 객체를 생성하기 위한 설계도 또는 틀로, 비슷한 특징을 가지는 객체들의 집합을 정의합니다. 클래스에는 속성(멤버 변수)과 행동(메서드)이 포함됩니다.
객체(Object):
- 객체는 클래스의 인스턴스로, 클래스를 기반으로 실제로 메모리에 할당된 데이터를 가지고 있습니다. 객체는 속성을 통해 상태를 나타내며, 메서드를 통해 행동을 수행할 수 있습니다.
캡슐화(Encapsulation):
- 캡슐화는 객체의 상태를 나타내는 데이터와 그 데이터를 다루는 메서드를 하나로 묶는 것을 말합니다. 객체의 내부 구현을 외부에서 감추고, 외부에서는 객체에 미리 정의된 메서드를 통해서만 객체의 상태를 조작할 수 있도록 합니다.
상속(Inheritance):
- 상속은 이미 존재하는 클래스를 기반으로 새로운 클래스를 만드는 개념입니다. 상속을 통해 기존 클래스의 특징과 동작을 새로운 클래스에 재사용할 수 있습니다. 상속을 통해 코드의 재사용성을 높이고, 계층 구조를 통해 유지보수가 용이해집니다.
다형성(Polymorphism):
- 다형성은 동일한 인터페이스를 사용하여 다양한 형태의 객체를 다룰 수 있는 능력을 의미합니다. 다형성을 통해 코드의 일반성을 유지하면서 다양한 객체들을 처리할 수 있습니다.

객체지향 프로그래밍은 실제 세계의 모델을 따르기 때문에 문제 해결과 소프트웨어 설계가 보다 직관적이고 유연해집니다. 이러한 특징으로 코드의 가독성과 유지보수성을 높일 수 있으며, 대규모 소프트웨어 개발에 적합한 방법론 중 하나로 평가받고 있습니다.

- Please explain object orientation

Object-oriented programming (OOP) is a programming paradigm that uses objects, which are instances of classes, to organize code. It is based on the concept of "objects," which can contain data in the form of fields (attributes or properties) and code in the form of procedures (methods or functions). The primary goals of object-oriented programming are encapsulation, inheritance, and polymorphism.

Here are the key concepts in object-oriented programming:

Classes and Objects:
- Class: A class is a blueprint or template for creating objects. It defines the attributes and methods that will be common to all objects of that type.
```
class Car:
    def __init__(self, make, model):
        self.make = make
        self.model = model

    def start_engine(self):
        print(f"The {self.make} {self.model}'s engine is running.")
```
- Object: An object is an instance of a class. It represents a real-world entity and has its own state (attributes) and behavior (methods).
```
my_car = Car("Toyota", "Camry")
my_car.start_engine()
```
Encapsulation:
- Encapsulation is the bundling of data (attributes) and the methods that operate on the data into a single unit, called a class. It helps in hiding the internal details of an object and exposing only what is necessary.
Inheritance:
- Inheritance is a mechanism where a new class inherits properties and behaviors from an existing class. The existing class is called the superclass or parent class, and the new class is called the subclass or child class. It promotes code reuse and allows for the creation of a hierarchy of classes.
```
class ElectricCar(Car):
    def charge_battery(self):
        print(f"The {self.make} {self.model}'s battery is charging.")
```
Polymorphism:
- Polymorphism allows objects of different classes to be treated as objects of a common base class. It allows methods to be written to process objects of a base class, and those methods can be overridden in derived classes to provide specific implementations.
```
def accelerate(vehicle):
    print(f"The {vehicle.make} {vehicle.model} is accelerating.")

accelerate(my_car)
accelerate(electric_car)
```
Abstraction:
- Abstraction is the process of simplifying complex systems by modeling classes based on the essential properties and behaviors an object should have. It hides the unnecessary details while exposing what is essential.

These principles, when applied correctly, help in creating modular, reusable, and maintainable code. Object-oriented programming is widely used in many programming languages, including Python, Java, C++, and others, to design and build complex software systems.

✅ 2. 클래스 상속에 대해 설명해주세요

클래스 상속은 객체 지향 프로그래밍에서 중요한 개념 중 하나로, 이미 정의된 클래스의 특성을 다른 클래스에서 재사용하는 메커니즘을 제공합니다. 상속을 사용하면 기존 클래스의 속성과 메서드를 가져와 새로운 클래스에서 사용할 수 있습니다. 이때, 기존 클래스는 부모 클래스 또는 상위 클래스라고 하고, 새로운 클래스는 자식 클래스 또는 하위 클래스라고 합니다.

상속의 주요 이점은 코드 재사용과 구조적인 정리에 있습니다. 부모 클래스에서 정의된 속성과 메서드를 자식 클래스에서 중복 작성하지 않고 사용할 수 있습니다. 또한, 자식 클래스에서는 부모 클래스에서 상속받은 기능을 확장하거나 수정할 수 있습니다.

간단한 클래스 상속의 예시를 통해 설명하겠습니다:

# 부모 클래스
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("Subclasses must implement the speak method")

# 자식 클래스
class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

# 다른 자식 클래스
class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

이 예시에서 Animal 클래스는 모든 동물이 가져야 하는 기본 특성을 정의하고, Dog와 Cat 클래스는 Animal 클래스를 상속받아 각각 고유한 speak 메서드를 구현합니다.

사용 예시:

dog = Dog("Buddy")
cat = Cat("Whiskers")

print(dog.speak())  # 출력: Buddy says Woof!
print(cat.speak())  # 출력: Whiskers says Meow!

이렇게 하면 Dog와 Cat 클래스는 Animal 클래스의 모든 속성과 메서드를 상속받아 사용할 수 있습니다. 이렇게 상속을 통해 클래스를 설계하면 코드의 재사용성이 높아지며, 프로그램의 구조가 더욱 모듈화되고 유지보수가 쉬워집니다.

- Please explain class inheritance

Class inheritance is a fundamental concept in object-oriented programming that allows a new class to inherit attributes and methods from an existing class. The existing class is referred to as the "base class," "superclass," or "parent class," and the new class is called the "derived class," "subclass," or "child class." Inheritance facilitates code reuse and the creation of a hierarchy of classes, where more specialized classes inherit properties and behaviors from more general classes.

Here are key points about class inheritance:

Creating a Base Class:

A base class is defined with attributes and methods.

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

    def speak(self):
        pass  # Placeholder for the speak method

# Instances of the base class
cat = Animal("Whiskers")
dog = Animal("Buddy")

Creating a Derived Class:

A derived class is created by specifying the base class in parentheses after the class name. The derived class inherits attributes and methods from the base class.

class Dog(Animal):
    def speak(self):
        return f"{self.name} barks"

class Cat(Animal):
    def speak(self):
        return f"{self.name} meows"

Method Overriding:
- In the derived class, methods with the same name as those in the base class can be overridden to provide a specific implementation.
```
print(dog.speak())  # Output: "Buddy barks"
print(cat.speak())  # Output: "Whiskers meows"
```

Access to Base Class Methods:

The derived class can call methods from the base class using the super() function.

class Cat(Animal):
    def speak(self):
        base_speak = super().speak()
        return f"{base_speak} and purrs"

Multiple Inheritance:
- A class can inherit from more than one base class, allowing it to inherit attributes and methods from multiple sources. However, multiple inheritance can lead to complexities and is used cautiously.
```
class Pet(Dog, Cat):
    pass

my_pet = Pet("Fluffy")
print(my_pet.speak())  # Output: "Fluffy barks"
```

Abstract Base Classes:

Abstract base classes provide a way to define a common interface for a group of related classes. They often have abstract methods that must be implemented by the derived classes.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

Inheritance is a powerful mechanism that promotes code reuse, modularity, and the creation of well-organized class hierarchies. However, it should be used judiciously to avoid creating overly complex and tightly coupled code.

✅ 3. 클래스 다중 상속과 관련된 MRO에 대해 설명해주세요

MRO (Method Resolution Order)는 파이썬에서 다중 상속을 사용할 때 어떤 순서로 부모 클래스의 메서드를 찾을지를 결정하는 규칙입니다. MRO는 클래스 간의 상속 관계가 복잡할 때 메서드가 어떤 순서로 호출되는지를 결정하는데 중요한 역할을 합니다.

파이썬에서 클래스 다중 상속을 사용하면 여러 부모 클래스로부터 상속받을 수 있습니다. 이때 MRO는 클래스 간의 상속 관계를 명확하게 정의하여 메서드 호출 순서를 결정합니다. MRO는 __mro__ 속성이나 mro() 메서드를 통해 확인할 수 있습니다.

간단한 예제를 통해 설명하겠습니다:

class A:
    def method(self):
        print("A method")

class B(A):
    def method(self):
        print("B method")

class C(A):
    def method(self):
        print("C method")

class D(B, C):
    pass

obj = D()
obj.method()

위의 코드에서 D 클래스는 B와 C 클래스로부터 상속받습니다. 그리고 B와 C 클래스는 모두 A 클래스를 상속받습니다.

이때 D 클래스의 객체에서 method()를 호출하면 어떤 클래스의 method()가 호출될까요? 이때 MRO가 사용됩니다.

파이썬의 MRO는 C3 선형화 알고리즘을 사용합니다. MRO는 다음과 같은 규칙을 따릅니다:

현재 클래스를 먼저 확인합니다.
다음으로 부모 클래스들을 왼쪽에서 오른쪽으로 순서대로 확인합니다.
부모 클래스들은 상속의 순서에 따라 검사됩니다.

위의 코드에서 D 클래스의 MRO는 다음과 같습니다: [D, B, C, A]. 따라서 obj.method()를 호출하면 B 클래스의 method()가 호출됩니다.

D 클래스의 MRO를 확인하는 방법은 다음과 같습니다:

print(D.mro())  # 결과: [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>]

이러한 MRO 메커니즘을 이해하면 다중 상속을 사용할 때 메서드 호출 순서를 예측할 수 있고, 충돌을 방지하며 코드를 더욱 안정적으로 유지할 수 있습니다.

The Method Resolution Order (MRO) in Python is a set of rules used to determine the order in which base classes are searched when looking for a method in a class hierarchy. MRO becomes particularly important in the context of multiple inheritance, where a class inherits from more than one base class.

Python uses the C3 linearization algorithm to compute the MRO. The linearization algorithm ensures a consistent and predictable order for method resolution in the presence of multiple inheritance.

Here are the key principles of MRO related to class multi-inheritance:

Depth-First, Left-to-Right (DPLR) Order:
- In the presence of multiple inheritance, the MRO follows a depth-first search from left to right. This means that when searching for a method, Python starts with the current class, then moves to the leftmost parent, and then follows the hierarchy down in a depth-first manner before moving to the next parent class.
C3 Linearization Algorithm:
- The C3 linearization algorithm ensures that the MRO is consistent and respects the order in which base classes are listed. It avoids ambiguities and provides a clear and deterministic order for method resolution.
The __mro__ Attribute:
- The MRO for a class can be accessed using the __mro__ attribute or the mro() method. This attribute provides a tuple representing the order in which classes will be searched for a particular method.
```
class A:
    pass

class B(A):
    pass

class C(A):
    pass

class D(B, C):
    pass

print(D.mro())
```

Diamond Inheritance Problem:

MRO helps resolve the diamond inheritance problem, where a class inherits from two classes that have a common ancestor. The MRO ensures that the common ancestor is not visited multiple times.

class A:
    def method(self):
        print("A method")

class B(A):
    def method(self):
        print("B method")

class C(A):
    def method(self):
        print("C method")

class D(B, C):
    pass

obj = D()
obj.method()  # Output: "B method"

In this example, the MRO of D is [D, B, C, A], so the method from class B is called.

Understanding MRO is crucial for working with multiple inheritance in Python. It helps developers predict the order in which base classes are searched for methods and avoids ambiguities that could arise from complex class hierarchies.

✅ 4. init 메소드에 대해 설명해주세요

__init__ 메소드는 파이썬 클래스에서 특별한 역할을 하는 메소드로서, 객체가 생성될 때 자동으로 호출되는 초기화 메소드입니다. __init__은 "initialize"의 약자로, 객체의 속성(attribute)을 초기화하거나 다른 초기화 작업을 수행하는 데 사용됩니다.

__init__ 메소드를 사용하면 클래스로부터 객체를 생성할 때 초기값을 설정하거나 필요한 초기화 작업을 수행할 수 있습니다. 이 메소드는 생성자(Constructor)로서, 객체가 생성될 때 자동으로 호출되기 때문에 초기화 작업을 수행하는 데 유용합니다.

다음은 간단한 클래스와 __init__ 메소드의 예제입니다:

class Person:
    def __init__(self, name, age):
        # 객체가 생성될 때 자동으로 호출되는 초기화 메소드
        self.name = name
        self.age = age

# Person 클래스의 객체를 생성하면서 __init__ 메소드가 호출됨
person1 = Person("Alice", 30)

# 객체의 속성에 접근
print(person1.name)  # 출력: "Alice"
print(person1.age)   # 출력: 30

위의 예제에서 Person 클래스의 __init__ 메소드는 name과 age라는 두 개의 매개변수를 받아서 객체의 속성으로 설정합니다. 객체가 생성될 때 __init__ 메소드가 호출되며, 이를 통해 초기값이 설정되어 객체가 사용될 수 있게 됩니다.

__init__ 메소드는 필수적인 것은 아니지만, 객체가 생성될 때 필요한 초기화 작업이 있다면 자주 사용되는 메소드입니다.

- Please explain the init method

The __init__ method in Python is a special method used in classes to perform initialization tasks when an object is created. It is often referred to as the "constructor" method because it is automatically called when an instance of the class is created. The purpose of __init__ is to initialize the attributes of the object and perform any setup that is required.

Here's a breakdown of the __init__ method:

Method Signature:
- The __init__ method has a special name with double underscores before and after "init." It takes at least one parameter, conventionally named self, which refers to the instance being created. Additional parameters can be added to pass values for initialization.
```
def __init__(self, param1, param2, ...):
```
Initialization Code:
- Inside the __init__ method, you write code to initialize the attributes of the object. These attributes are typically defined within the class and represent the object's state.
```
class MyClass:
    def __init__(self, attribute1, attribute2):
        self.attribute1 = attribute1
        self.attribute2 = attribute2
```
Automatic Invocation:
- The __init__ method is automatically called when an object is created from the class. It initializes the object's attributes based on the values passed during the object creation.
```
obj = MyClass(value1, value2)
```
Self Parameter:
- The self parameter is a reference to the instance of the class. It is automatically passed when the method is called, and it allows you to access and modify the object's attributes.
```
def __init__(self, attribute1, attribute2):
    self.attribute1 = attribute1
    self.attribute2 = attribute2
```
Initialization of Attributes:
- You can use the values passed as parameters to initialize the object's attributes. This step ensures that each instance of the class has its own unique state.
```
obj = MyClass(value1, value2)
print(obj.attribute1)  # Accessing the initialized attribute
```

The __init__ method is a fundamental part of object-oriented programming in Python. It allows you to set the initial state of objects, making them ready for use after creation. Keep in mind that while __init__ is a common convention, it is not mandatory for a class to have an __init__ method. Classes without an __init__ method inherit an empty one from their base class.

✅ 5. Self는 어떤 키워드 인가요?

self는 파이썬에서 객체 지향 프로그래밍 (OOP)을 구현할 때 사용되는 특별한 키워드입니다. self는 현재 인스턴스를 나타냅니다. 파이썬의 클래스에서 메서드를 정의할 때, 메서드의 첫 번째 매개변수로 항상 self를 사용해야 합니다.

self를 사용하는 이유는 각각의 객체 인스턴스가 자신의 상태를 관리할 수 있도록 하기 위함입니다. 파이썬에서 클래스를 사용하여 객체를 생성할 때마다 해당 객체는 고유의 상태를 가지며, 이 상태를 관리하기 위해 self를 사용합니다.

간단한 클래스와 메서드의 예제를 통해 self를 설명하겠습니다:

class MyClass:
    def __init__(self, value):
        # __init__ 메서드는 객체가 생성될 때 호출되며, 초기화를 수행합니다.
        self.my_attribute = value  # self를 사용하여 현재 인스턴스의 속성을 설정합니다.

    def print_attribute(self):
        # print_attribute 메서드는 현재 인스턴스의 속성을 출력합니다.
        print(self.my_attribute)

# MyClass의 인스턴스를 생성합니다.
obj1 = MyClass(42)
obj2 = MyClass(99)

# print_attribute 메서드를 호출하면서 self로 현재 인스턴스를 전달합니다.
obj1.print_attribute()  # 출력: 42
obj2.print_attribute()  # 출력: 99

위의 예제에서 __init__ 메서드와 print_attribute 메서드에서 self를 사용하여 현재 객체 인스턴스를 참조하고 있습니다. 이를 통해 각 객체는 자체의 my_attribute 속성을 가지며, 서로 독립적으로 상태를 관리할 수 있습니다.

- What kind of keyword is Self?

self is not a keyword in Python; rather, it is a conventional name used for the first parameter of instance methods in a class. The choice of the name self is a convention, and you could technically use any valid variable name in its place. However, it is a widely followed convention in the Python community to use self as the name for the first parameter in instance methods.

When defining methods within a class, the first parameter is reserved to refer to the instance of the class. This parameter is usually named self to indicate that it refers to the instance itself. The name self is not enforced by the Python interpreter; it's simply a convention that makes the code more readable and understandable.

Here's a brief overview of how self is used:

Instance Methods:

self is used as the first parameter in instance methods to refer to the instance of the class.

class MyClass:
    def __init__(self, value):
        self.my_attribute = value

    def print_attribute(self):
        print(self.my_attribute)

Constructor (__init__) Method:
- In the constructor method (__init__), self is used to refer to the instance being created.
```
obj = MyClass(42)
```
Method Invocation:
- When calling methods on an instance, self is implicitly passed, and you don't need to provide a value for it.
```
obj.print_attribute()
```

In summary, self is not a keyword; it's a naming convention for the first parameter of instance methods in a class. It's used to reference the instance itself within the methods of that instance.

Hyemin Kim

Full Stack Web Developer

이전 포스트

오즈코딩스쿨 초격차캠프 백엔드 4일차

다음 포스트

오즈코딩스쿨 초격차캠프 백엔드 5일차