Chapter 9 / 9과

Classes / 클래스

Classes are a way of grouping functions and data together.
클래스는 함수와 데이터를 묶는 방법이다.
Classes are a blueprint for creating objects, based on real-world objects.
클래스는 실제 세계의 객체를 기반으로 객체를 만드는 청사진이다.
You instantiate (create) an object from a class.
클래스에서 객체를 인스턴스화 (생성)한다.
These objects are called instances of the class.
이러한 객체를 클래스의 인스턴스라고 한다.
This is called object-oriented programming.
이것은 객체 지향 프로그래밍이라고 한다.

9.1 Creating a class / 클래스 만들기

Classes are defined with the class keyword, and class names are capitalized.
클래스는 class 키워드로 정의되며, 클래스 이름은 대문자로 시작한다.
Classes can have attributes (variables) and methods (functions).
클래스는 속성 (변수)과 메소드 (함수)를 가질 수 있다.

# Dog.py
class Dog:
    """A simple attempt to model a dog."""

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print(f"{self.name} barks!")

    def sit(self):
        print(f"{self.name} sits!")

    def roll_over(self):
        print(f"{self.name} rolls over!")

`init()`

The __init__() method is called when an object is created.
__init__() 메소드는 객체가 생성될 때 호출된다.
The self parameter refers to the object itself, and is always the first parameter.
self 매개변수는 객체 자체를 가리키며, 항상 첫 번째 매개변수이다.
The self parameter is used to access attributes and methods of the object, but is not passed to the method.
self 매개변수는 객체의 속성과 메소드에 액세스하는 데 사용되지만 메소드에 전달되지는 않는다.

Creating Class Instances / 클래스 인스턴스 생성

To create an instance of a class, call the class name as if it were a function.
클래스의 인스턴스를 생성하려면, 함수처럼 클래스 이름을 호출한다.

# 9.1_my_dog.py
import Dog

my_dog = Dog("Willie", 6)

Accessing Attributes and Calling Methods / 속성에 액세스하고 메소드 호출하기

Use the dot operator (.) to access attributes and call methods.
속성에 액세스하고 메소드를 호출하려면 점 연산자 (.)를 사용한다.

# 9.1_my_dog.py
print(f"My dog's name is {my_dog.name}.")
print(f"My dog is {my_dog.age} years old.")

my_dog.bark()
my_dog.sit()
my_dog.roll_over()

You can create as many instances of a class as you want.
클래스의 인스턴스를 원하는 만큼 만들 수 있다.

# 9.1_my_dog.py
your_dog = Dog("Lucy", 3)

print(f"Your dog's name is {your_dog.name}.")
print(f"Your dog is {your_dog.age} years old.")

your_dog.bark()
your_dog.sit()
your_dog.roll_over()

9.2 Working with Classes and Instances / 클래스와 인스턴스 작업

Let’s create a class to represent a car.
자동차를 나타내는 클래스를 만들어 보자.

# Car.py
class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def get_descriptive_name(self):
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()

Set a Default Attribute Value / 기본 속성 값 설정

You can provide a default value for an attribute.
속성에 기본 값을 제공할 수 있다.

# Car.py
class Car:
    """A simple attempt to represent a car."""

    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descriptive_name(self):
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()

    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")

Modify an Attribute Directly / 속성 직접 수정

You can modify an attribute’s value directly.
속성의 값을 직접 수정할 수 있다.

# 9.2_my_car.py
import Car

my_new_car = Car("audi", "a4", 2019)
print(my_new_car.get_descriptive_name())

my_new_car.odometer_reading = 23
my_new_car.read_odometer()

Modify an Attribute Through a Method / 메소드를 통한 속성 수정

You can also modify an attribute’s value through a method.
메소드를 통해서도 속성의 값을 수정할 수 있다.

# Car.py
class Car:
    # ...
    def update_odometer(self, mileage):
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")

# 9.2_my_car.py
import Car

my_new_car = Car("audi", "a4", 2019)
print(my_new_car.get_descriptive_name())

my_new_car.update_odometer(23)
my_new_car.read_odometer()

Increment an Attribute’s Value Through a Method / 메소드를 통한 속성 값 증가

You can also increment an attribute’s value through a method.
메소드를 통해서도 속성의 값을 증가시킬 수 있다.

# Car.py
class Car:
    # ...
    def increment_odometer(self, miles):
        self.odometer_reading += miles

# 9.2_my_car.py
import Car

my_used_car = Car("subaru", "outback", 2015)
print(my_used_car.get_descriptive_name())

my_used_car.update_odometer(23500)
my_used_car.read_odometer()

my_used_car.increment_odometer(100)
my_used_car.read_odometer()

9.3 Inheritance / 상속

You can create a class that inherits from another class.
다른 클래스를 상속하는 클래스를 만들 수 있다.
This means that the new class automatically gets all the attributes and methods of the parent class.
이는 새 클래스가 자동으로 부모 클래스의 모든 속성과 메소드를 가져오는 것을 의미한다.
The original class is called the parent class, and the new class is called the child class.
원래 클래스를 부모 클래스라고 하고, 새 클래스를 자식 클래스라고 한다.
We use the super() function to call the parent class’s __init__() method.
super() 함수를 사용하여 부모 클래스의 __init__() 메소드를 호출한다.

# ElectricCar.py
import Car

class ElectricCar(Car):
    """Represent aspects of a car, specific to electric vehicles."""

    def __init__(self, make, model, year):
        super().__init__(make, model, year)

Defining Child Class Attributes and Methods / 자식 클래스 속성과 메소드 정의

You can define attributes and methods specific to the child class.
자식 클래스에 특정한 속성과 메소드를 정의할 수 있다.

# ElectricCar.py
import Car

class ElectricCar(Car):
    # ...
    def __init__(self, make, model, year):
        super().__init__(make, model, year)
        self.battery_size = 75

    def describe_battery(self):
        print(f"This car has a {self.battery_size}-kWh battery.")

Override Methods from the Parent Class / 부모 클래스의 메소드 재정의

You can override methods from the parent class.
부모 클래스의 메소드를 재정의할 수 있다.
This means that the child class uses a parent class method in a different way.
이는 자식 클래스가 부모 클래스의 메소드를 다른 방식으로 사용한다는 것을 의미한다.

# ElectricCar.py
import Car

class ElectricCar(Car):
    # ...
    def fill_gas_tank(self):
        """Electric cars don't have gas tanks."""
        print("This car doesn't need a gas tank!")

Instances as Attributes / 인스턴스를 속성으로

Sometimes, you recognize that part of a class can be written as a separate class.
때로는 클래스의 일부를 별도의 클래스로 작성할 수 있다.
Then we can use an instance of that class as an attribute in the original class.
그런 다음 원래 클래스의 속성으로 그 클래스의 인스턴스를 사용할 수 있다.

# ElectricCar.py
import Car

class Battery:
    """A simple attempt to model a battery for an electric car."""

    def __init__(self, battery_size=75):
        """Initialize the battery's attributes."""
        self.battery_size = battery_size

    def describe_battery(self):
        """Print a statement describing the battery size."""
        print(f"This car has a {self.battery_size}-kWh battery.")

    def get_range(self):
        """Print a statement about the range this battery provides."""
        if self.battery_size == 75:
            range = 260
        elif self.battery_size == 100:
            range = 315

        print(f"This car can go about {range} miles on a full charge.")

class ElectricCar(Car):
    # ...
    def __init__(self, make, model, year):
        super().__init__(make, model, year)
        self.battery = Battery()

# 9.3_my_electric_car.py
import ElectricCar

my_tesla = ElectricCar("tesla", "model s", 2019)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()

Modeling Real-World Objects / 실제 세계 객체 모델링

When you wrestle with questions about how to model real-world objects, you may find yourself changing your approach several times.
실제 세계 객체를 모델링하는 방법에 대해 고민할 때, 여러 번 접근 방식을 변경해야 할 수도 있다.
Each time you run into a new challenge, you will find you are growing as a programmer.
새로운 도전에 부딪힐 때마다, 프로그래머로서 성장하고 있다는 것을 알게 될 것이다.

9.4 Importing Classes / 클래스 임포트

You can store classes in modules and import them into your main program.
클래스를 모듈에 저장하고, 메인 프로그램으로 임포트할 수 있다.
You can import an entire module, multiple classes, or just the class you need.
모듈 전체, 여러 클래스 또는 필요한 클래스만 임포트할 수 있다.
This is a good way to keep your code organized.
이는 코드를 정리하는 좋은 방법이다.

Importing a Single Class / 단일 클래스 임포트

# 9.2_my_car.py
from Car import Car

my_new_car = Car("audi", "a4", 2019)
print(my_new_car.get_descriptive_name())

my_new_car.odometer_reading = 23
my_new_car.read_odometer()

You can store multiple classes in a module if they are related in some way.
어떤 방식으로든 관련이 있는 경우 모듈에 여러 클래스를 저장할 수 있다.
You can import multiple classes from a module using a comma-separated list.
쉼표로 구분된 목록을 사용하여 모듈에서 여러 클래스를 임포트할 수 있다.

# 9.4_my_cars.py
from Car import Car, ElectricCar

my_beetle = Car("volkswagen", "beetle", 2019)
print(my_beetle.get_descriptive_name())

my_tesla = ElectricCar("tesla", "roadster", 2019)
print(my_tesla.get_descriptive_name())

If you import an entire module, you can access the classes using dot notation.
모듈 전체를 임포트하면 점 표기법을 사용하여 클래스에 액세스할 수 있다.

# 9.4_my_cars.py
import Car

my_beetle = Car.Car("volkswagen", "beetle", 2019)
print(my_beetle.get_descriptive_name())

my_tesla = Car.ElectricCar("tesla", "roadster", 2019)
print(my_tesla.get_descriptive_name())

Remember you can also import all classes from a module using the asterisk (*) operator, but this is not recommended.
애스터리스크 (*) 연산자를 사용하여 모듈에서 모든 클래스를 임포트할 수도 있지만, 권장하지 않는다.
You can also use an alias for a module or class name.
모듈 또는 클래스 이름에 별칭을 사용할 수도 있다.

# 9.4_my_cars.py
from Car import Car as C

my_beetle = C("volkswagen", "beetle", 2019)
print(my_beetle.get_descriptive_name())

9.5 Python Standard Library / 파이썬 표준 라이브러리

The Python standard library is a set of modules included with every Python installation.
파이썬 표준 라이브러리는 모든 파이썬 설치에 포함된 모듈의 집합이다.
You can use any of these modules and their functions when writing your programs.
프로그램을 작성할 때 이러한 모듈과 함수를 사용할 수 있다.
Two interesting functions we will look at are randint() and choice() from the random module.
우리가 살펴볼 두 가지 흥미로운 함수는 random 모듈의 randint()와 choice()이다.

# 9.5_randint_choice.py
from random import randint, choice

x = randint(1, 6)
y = choice(["apple", "banana", "cherry"])

print(x)
print(y)

9.6 Styling Classes / 클래스 스타일링

Keep the following PEP8 styling guidelines in mind when writing classes.
클래스를 작성할 때 다음 PEP8 스타일 가이드를 염두에 두어라.

Class names should be written in CamelCase.
클래스 이름은 CamelCase로 작성한다.
Instance and module names should be written in lowercase with underscores between words.
인스턴스와 모듈 이름은 단어 사이에 밑줄을 사용하여 소문자로 작성한다.
Every class should have a docstring immediately following the class definition.
모든 클래스는 클래스 정의 바로 다음에 독스트링을 가져야 한다.
You can use blank lines to organize code, but don’t use them excessively. Use two blanks lines to separate classes.
코드를 정리하기 위해 빈 줄을 사용할 수 있지만, 과도하게 사용하지는 않는다. 클래스를 구분하기 위해 두 줄을 사용한다.
If you need to import a module, place the import statement first.
모듈을 임포트해야 하는 경우, 임포트 문을 먼저 놓는다.

Classes / 클래스

9.1 Creating a class / 클래스 만들기

__init__()

Creating Class Instances / 클래스 인스턴스 생성

Accessing Attributes and Calling Methods / 속성에 액세스하고 메소드 호출하기

9.2 Working with Classes and Instances / 클래스와 인스턴스 작업

Set a Default Attribute Value / 기본 속성 값 설정

Modify an Attribute Directly / 속성 직접 수정

Modify an Attribute Through a Method / 메소드를 통한 속성 수정

Increment an Attribute’s Value Through a Method / 메소드를 통한 속성 값 증가

9.3 Inheritance / 상속

Defining Child Class Attributes and Methods / 자식 클래스 속성과 메소드 정의

Override Methods from the Parent Class / 부모 클래스의 메소드 재정의

Instances as Attributes / 인스턴스를 속성으로

Modeling Real-World Objects / 실제 세계 객체 모델링

9.4 Importing Classes / 클래스 임포트

Importing a Single Class / 단일 클래스 임포트

9.5 Python Standard Library / 파이썬 표준 라이브러리

9.6 Styling Classes / 클래스 스타일링

`init()`