Python 의 객체 지향 프로그래밍 (OOP) 기능은 표현력 있고 사용자 정의된 객체를 생성하기 위한 강력한 도구를 제공합니다. 이 중, 특수 메서드 __init__, __str__, 그리고 __repr__은 Python 객체의 동작과 표현을 정의하는 데 중요한 역할을 합니다.
이 튜토리얼에서는 이러한 특수 메서드를 살펴보고, 그 목적을 이해하며, Python 클래스에서 효과적으로 구현하는 방법을 배웁니다. 이 랩을 마치면, 더욱 직관적이고 사용자 친화적인 Python 객체를 만들 수 있게 될 것입니다.
__init__ 메서드를 사용하여 클래스 생성하기우리가 살펴볼 첫 번째 특수 메서드는 객체가 생성될 때 호출되는 __init__입니다. 이 메서드를 사용하면 객체의 속성을 초기화할 수 있습니다.
__init__ 메서드 이해하기생성자 (constructor) 라고도 알려진 __init__ 메서드는 클래스의 새 인스턴스를 생성할 때 자동으로 호출됩니다. 이 메서드의 주요 목적은 속성에 값을 할당하여 객체의 초기 상태를 설정하는 것입니다.
__init__ 메서드를 사용하여 간단한 Python 클래스를 생성하는 것으로 시작해 보겠습니다.
LabEx 환경에서 터미널을 엽니다.
프로젝트 디렉토리로 이동합니다.
cd ~/project코드 편집기를 사용하여 person.py라는 새 Python 파일을 생성합니다.
편집기에서 다음 코드를 person.py에 추가합니다.
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
## Create a Person object
person1 = Person("Alice", 30)
## Access the attributes
print(f"Name: {person1.name}")
print(f"Age: {person1.age}")파일을 저장합니다.
Python 스크립트를 실행합니다.
python3 person.py다음과 같은 출력을 볼 수 있습니다.
Name: Alice
Age: 30__init__ 메서드 설명위의 코드에서:
name과 age의 세 가지 매개변수를 사용하는 __init__ 메서드가 있는 Person 클래스를 정의했습니다.self 매개변수는 생성 중인 인스턴스를 참조하며, 객체가 생성될 때 자동으로 전달됩니다.__init__ 메서드 내에서 self.name 및 self.age를 사용하여 name과 age의 값을 객체의 속성에 할당합니다.person1 = Person("Alice", 30)으로 새 Person 객체를 생성하면 __init__ 메서드가 자동으로 호출됩니다.person1.name 및 person1.age.현재 연도와 사람의 나이를 기준으로 출생 연도를 계산하는 메서드를 추가하여 Person 클래스를 향상시켜 보겠습니다.
편집기에서 person.py를 엽니다.
출생 연도를 계산하는 메서드를 포함하도록 코드를 업데이트합니다.
import datetime
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def birth_year(self):
current_year = datetime.datetime.now().year
return current_year - self.age
## Create a Person object
person1 = Person("Alice", 30)
## Access the attributes and call the method
print(f"Name: {person1.name}")
print(f"Age: {person1.age}")
print(f"Birth Year: {person1.birth_year()}")파일을 저장합니다.
Python 스크립트를 실행합니다.
python3 person.py이제 출력에 계산된 출생 연도가 포함되어야 합니다.
Name: Alice
Age: 30
Birth Year: 1993(실제 출생 연도는 스크립트를 실행하는 현재 연도에 따라 달라집니다.)
이제 객체 속성을 초기화하기 위해 __init__ 메서드를 사용하고 해당 속성을 기반으로 계산을 수행하는 메서드를 추가하여 Python 클래스를 만들었습니다.
__str__ 메서드 구현하기이제 __init__ 메서드를 사용하여 클래스를 만드는 방법을 이해했으므로, __str__이라는 또 다른 특수 메서드를 살펴보겠습니다. 이 메서드를 사용하면 객체를 문자열로 표현하는 방법을 정의할 수 있습니다.
__str__ 메서드 이해하기__str__ 메서드는 객체에 대해 str() 함수를 사용하거나 print() 함수를 사용하여 객체를 인쇄할 때 호출됩니다. 이 메서드는 객체의 사람이 읽을 수 있는 문자열 표현을 반환해야 합니다.
__str__ 메서드를 포함하도록 Person 클래스를 업데이트해 보겠습니다.
편집기에서 person.py를 엽니다.
__str__ 메서드를 포함하도록 코드를 업데이트합니다.
import datetime
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def birth_year(self):
current_year = datetime.datetime.now().year
return current_year - self.age
def __str__(self):
return f"{self.name}, {self.age} years old"
## Create a Person object
person1 = Person("Alice", 30)
## Access the attributes and call the method
print(f"Name: {person1.name}")
print(f"Age: {person1.age}")
print(f"Birth Year: {person1.birth_year()}")
## Use the __str__ method implicitly
print("\nString representation of the object:")
print(person1)
## Use the __str__ method explicitly
print("\nExplicit string conversion:")
print(str(person1))파일을 저장합니다.
Python 스크립트를 실행합니다.
python3 person.py다음과 유사한 출력을 볼 수 있습니다.
Name: Alice
Age: 30
Birth Year: 1993
String representation of the object:
Alice, 30 years old
Explicit string conversion:
Alice, 30 years old__str__의 작동 방식위의 코드에서:
__str__ 메서드를 정의했습니다.print(person1)을 호출하면 Python 은 표시할 내용을 결정하기 위해 자동으로 __str__ 메서드를 호출합니다.str(person1)을 사용하여 객체를 문자열로 명시적으로 변환할 수도 있으며, 이 또한 __str__ 메서드를 호출합니다.__str__이 없으면 어떻게 될까요?__str__ 메서드의 중요성을 이해하기 위해, 이 메서드를 정의하지 않으면 어떻게 되는지 살펴보겠습니다.
without_str.py라는 새 파일을 생성합니다.
다음 코드를 추가합니다.
class SimpleClass:
def __init__(self, value):
self.value = value
## Create an object
obj = SimpleClass(42)
## Print the object
print(obj)파일을 저장합니다.
스크립트를 실행합니다.
python3 without_str.py다음과 같은 출력을 볼 수 있습니다.
<__main__.SimpleClass object at 0x7f2d8c3e9d90>출력이 그다지 유익하지 않습니다. 클래스 이름과 객체의 메모리 주소를 표시하지만, 내용은 표시하지 않습니다. 이것이 객체를 더 사용자 친화적으로 만들기 위해 적절한 __str__ 메서드를 구현하는 것이 중요한 이유입니다.
__str__ 메서드가 있는 Book이라는 새 클래스를 만들어 보겠습니다.
book.py라는 새 파일을 생성합니다.
다음 코드를 추가합니다.
class Book:
def __init__(self, title, author, pages):
self.title = title
self.author = author
self.pages = pages
def __str__(self):
return f'"{self.title}" by {self.author} ({self.pages} pages)'
## Create book objects
book1 = Book("The Great Gatsby", "F. Scott Fitzgerald", 180)
book2 = Book("To Kill a Mockingbird", "Harper Lee", 281)
## Print the books
print(book1)
print(book2)파일을 저장합니다.
스크립트를 실행합니다.
python3 book.py출력은 다음과 같아야 합니다.
"The Great Gatsby" by F. Scott Fitzgerald (180 pages)
"To Kill a Mockingbird" by Harper Lee (281 pages)이제 __str__ 메서드를 사용하여 객체의 사람이 읽을 수 있는 문자열 표현을 만드는 방법을 이해했습니다.
__repr__ 메서드 구현하기__str__ 외에도 Python 은 문자열 표현을 위한 또 다른 특수 메서드인 __repr__을 제공합니다. __str__이 사람이 읽을 수 있는 표현을 제공하기 위한 것이라면, __repr__은 가능한 경우 객체를 다시 생성하는 데 사용할 수 있는 객체의 모호하지 않은 표현을 제공하기 위한 것입니다.
__repr__ 메서드 이해하기__repr__ 메서드는 객체에 대해 repr() 함수를 사용하거나 대화형 세션에서 객체를 표시할 때 호출됩니다. 이 메서드는 eval()에 전달될 때 (가능한 경우) 동등한 객체를 생성하는 문자열을 반환해야 합니다.
__repr__ 메서드를 포함하도록 Book 클래스를 업데이트해 보겠습니다.
편집기에서 book.py를 엽니다.
__repr__ 메서드를 포함하도록 코드를 업데이트합니다.
class Book:
def __init__(self, title, author, pages):
self.title = title
self.author = author
self.pages = pages
def __str__(self):
return f'"{self.title}" by {self.author} ({self.pages} pages)'
def __repr__(self):
return f'Book("{self.title}", "{self.author}", {self.pages})'
## Create book objects
book1 = Book("The Great Gatsby", "F. Scott Fitzgerald", 180)
book2 = Book("To Kill a Mockingbird", "Harper Lee", 281)
## Print the books (uses __str__)
print("String representation (using __str__):")
print(book1)
print(book2)
## Get the representation (uses __repr__)
print("\nRepresentation (using __repr__):")
print(repr(book1))
print(repr(book2))파일을 저장합니다.
스크립트를 실행합니다.
python3 book.py다음과 같은 출력을 볼 수 있습니다.
String representation (using __str__):
"The Great Gatsby" by F. Scott Fitzgerald (180 pages)
"To Kill a Mockingbird" by Harper Lee (281 pages)
Representation (using __repr__):
Book("The Great Gatsby", "F. Scott Fitzgerald", 180)
Book("To Kill a Mockingbird", "Harper Lee", 281)__str__과 __repr__의 차이점__str__과 __repr__의 주요 차이점은 다음과 같습니다.
__str__은 사람이 읽을 수 있는 출력을 위한 것이고, __repr__은 개발자 및 디버깅을 위한 것입니다.__str__이 정의되지 않았지만 __repr__이 정의된 경우, Python 은 str() 또는 print()에 대한 대체로 __repr__을 사용합니다.__repr__은 이상적으로 eval()에 전달될 때 객체를 다시 생성할 수 있는 문자열을 반환해야 하지만, 이것이 항상 가능하거나 필요한 것은 아닙니다.__repr__과 함께 eval() 함수 사용하기올바르게 구현되면 __repr__에서 반환된 문자열을 eval()과 함께 사용하여 객체를 다시 생성할 수 있습니다. 이를 실제로 살펴보겠습니다.
repr_eval.py라는 새 파일을 생성합니다.
다음 코드를 추가합니다.
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return f"Point at ({self.x}, {self.y})"
def __repr__(self):
return f"Point({self.x}, {self.y})"
## Create a point
p1 = Point(3, 4)
## Get the repr string
repr_str = repr(p1)
print(f"Representation: {repr_str}")
## Use eval to recreate the object
p2 = eval(repr_str)
print(f"Recreated object: {p2}")
## Verify they have the same values
print(f"p1.x = {p1.x}, p1.y = {p1.y}")
print(f"p2.x = {p2.x}, p2.y = {p2.y}")파일을 저장합니다.
스크립트를 실행합니다.
python3 repr_eval.py다음과 같은 출력을 볼 수 있습니다.
Representation: Point(3, 4)
Recreated object: Point at (3, 4)
p1.x = 3, p1.y = 4
p2.x = 3, p2.y = 4이것은 __repr__에서 반환된 문자열과 eval() 함수를 사용하여 원래 객체를 다시 생성할 수 있음을 보여줍니다.
__init__을 사용합니다.__str__을 사용합니다.__repr__을 사용합니다.세 가지 특수 메서드 모두를 사용하여 Rectangle 클래스를 만들어 보겠습니다.
rectangle.py라는 새 파일을 생성합니다.
다음 코드를 추가합니다.
class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
def perimeter(self):
return 2 * (self.width + self.height)
def __str__(self):
return f"Rectangle with width {self.width} and height {self.height}"
def __repr__(self):
return f"Rectangle({self.width}, {self.height})"
## Create rectangles
rect1 = Rectangle(5, 10)
rect2 = Rectangle(3, 7)
## Display information about the rectangles
print(f"Rectangle 1: {rect1}")
print(f"Area: {rect1.area()}")
print(f"Perimeter: {rect1.perimeter()}")
print(f"Representation: {repr(rect1)}")
print("\nRectangle 2: {0}".format(rect2))
print(f"Area: {rect2.area()}")
print(f"Perimeter: {rect2.perimeter()}")
print(f"Representation: {repr(rect2)}")
## Recreate a rectangle using eval
rect3 = eval(repr(rect1))
print(f"\nRecreated rectangle: {rect3}")
print(f"Is it the same area? {rect3.area() == rect1.area()}")파일을 저장합니다.
스크립트를 실행합니다.
python3 rectangle.py다음과 같은 출력을 볼 수 있습니다.
Rectangle 1: Rectangle with width 5 and height 10
Area: 50
Perimeter: 30
Representation: Rectangle(5, 10)
Rectangle 2: Rectangle with width 3 and height 7
Area: 21
Perimeter: 20
Representation: Rectangle(3, 7)
Recreated rectangle: Rectangle with width 5 and height 10
Is it the same area? True이 예제는 세 가지 특수 메서드 (__init__, __str__, __repr__) 가 함께 작동하여 잘 설계된 클래스를 만드는 방법을 보여줍니다.
이제 세 가지 특수 메서드 __init__, __str__, __repr__을 이해했으므로, 실제 시나리오에서 이러한 메서드의 사용을 보여주는 더 실용적인 애플리케이션을 만들어 보겠습니다. BankAccount 클래스를 사용하여 간단한 은행 시스템을 만들 것입니다.
bank_account.py라는 새 파일을 생성합니다.
다음 코드를 추가합니다.
class BankAccount:
def __init__(self, account_number, owner_name, balance=0.0):
self.account_number = account_number
self.owner_name = owner_name
self.balance = balance
self.transactions = []
def deposit(self, amount):
if amount <= 0:
print("Deposit amount must be positive")
return False
self.balance += amount
self.transactions.append(f"Deposit: +${amount:.2f}")
return True
def withdraw(self, amount):
if amount <= 0:
print("Withdrawal amount must be positive")
return False
if amount > self.balance:
print("Insufficient funds")
return False
self.balance -= amount
self.transactions.append(f"Withdrawal: -${amount:.2f}")
return True
def get_transaction_history(self):
return self.transactions
def __str__(self):
return f"Account {self.account_number} | Owner: {self.owner_name} | Balance: ${self.balance:.2f}"
def __repr__(self):
return f'BankAccount("{self.account_number}", "{self.owner_name}", {self.balance})'파일을 저장합니다.
이제 BankAccount 클래스를 테스트해 보겠습니다.
bank_test.py라는 새 파일을 생성합니다.
다음 코드를 추가합니다.
from bank_account import BankAccount
## Create bank accounts
account1 = BankAccount("12345", "John Doe", 1000.0)
account2 = BankAccount("67890", "Jane Smith", 500.0)
## Display initial account information
print("Initial Account Status:")
print(account1)
print(account2)
## Perform transactions
print("\nPerforming transactions...")
## Deposit to account1
print("\nDepositing $250 to account1:")
account1.deposit(250)
print(account1)
## Withdraw from account2
print("\nWithdrawing $100 from account2:")
account2.withdraw(100)
print(account2)
## Try to withdraw too much from account2
print("\nTrying to withdraw $1000 from account2:")
account2.withdraw(1000)
print(account2)
## Try to deposit a negative amount to account1
print("\nTrying to deposit -$50 to account1:")
account1.deposit(-50)
print(account1)
## Display transaction history
print("\nTransaction history for account1:")
for transaction in account1.get_transaction_history():
print(f"- {transaction}")
print("\nTransaction history for account2:")
for transaction in account2.get_transaction_history():
print(f"- {transaction}")
## Recreate an account using repr
print("\nRecreating account1 using repr:")
account1_repr = repr(account1)
print(f"Representation: {account1_repr}")
recreated_account = eval(account1_repr)
print(f"Recreated account: {recreated_account}")파일을 저장합니다.
스크립트를 실행합니다.
python3 bank_test.py다음과 유사한 출력을 볼 수 있습니다.
Initial Account Status:
Account 12345 | Owner: John Doe | Balance: $1000.00
Account 67890 | Owner: Jane Smith | Balance: $500.00
Performing transactions...
Depositing $250 to account1:
Account 12345 | Owner: John Doe | Balance: $1250.00
Withdrawing $100 from account2:
Account 67890 | Owner: Jane Smith | Balance: $400.00
Trying to withdraw $1000 from account2:
Insufficient funds
Account 67890 | Owner: Jane Smith | Balance: $400.00
Trying to deposit -$50 to account1:
Deposit amount must be positive
Account 12345 | Owner: John Doe | Balance: $1250.00
Transaction history for account1:
- Deposit: +$250.00
Transaction history for account2:
- Withdrawal: -$100.00
Recreating account1 using repr:
Representation: BankAccount("12345", "John Doe", 1250.0)
Recreated account: Account 12345 | Owner: John Doe | Balance: $1250.00이 은행 애플리케이션에서:
__init__ 메서드는 계좌 번호, 소유자 이름 및 선택적 초기 잔액으로 은행 계좌를 초기화합니다. 또한 거래를 추적하기 위해 빈 목록을 만듭니다.
deposit 및 withdraw 메서드는 거래를 처리하고 잔액 및 거래 내역을 업데이트합니다.
__str__ 메서드는 계좌 번호, 소유자 이름 및 현재 잔액을 표시하여 계좌의 사용자 친화적인 표현을 제공합니다.
__repr__ 메서드는 계좌 객체를 다시 생성할 수 있는 문자열을 제공합니다 (하지만 이 구현에서는 거래 내역이 유지되지 않습니다).
이 예제는 이러한 특수 메서드를 실용적인 애플리케이션에서 사용하여 보다 직관적이고 사용자 친화적인 객체를 만드는 방법을 보여줍니다.
마지막 연습으로, 여러 계정을 관리하는 간단한 은행 시스템을 만들어 보겠습니다.
banking_system.py라는 새 파일을 생성합니다.
다음 코드를 추가합니다.
from bank_account import BankAccount
class BankingSystem:
def __init__(self, bank_name):
self.bank_name = bank_name
self.accounts = {}
def create_account(self, account_number, owner_name, initial_balance=0.0):
if account_number in self.accounts:
print(f"Account {account_number} already exists")
return None
account = BankAccount(account_number, owner_name, initial_balance)
self.accounts[account_number] = account
return account
def get_account(self, account_number):
return self.accounts.get(account_number)
def list_accounts(self):
return list(self.accounts.values())
def __str__(self):
return f"{self.bank_name} - Managing {len(self.accounts)} accounts"
def __repr__(self):
return f'BankingSystem("{self.bank_name}")'
## Create a banking system
bank = BankingSystem("Python First Bank")
print(bank)
## Create some accounts
bank.create_account("A001", "John Doe", 1000)
bank.create_account("A002", "Jane Smith", 500)
bank.create_account("A003", "Bob Johnson", 250)
## List all accounts
print("\nAll accounts:")
for account in bank.list_accounts():
print(account)
## Make some transactions
account = bank.get_account("A001")
if account:
print(f"\nBefore deposit: {account}")
account.deposit(500)
print(f"After deposit: {account}")
account = bank.get_account("A002")
if account:
print(f"\nBefore withdrawal: {account}")
account.withdraw(200)
print(f"After withdrawal: {account}")
## Try to create an existing account
print("\nTrying to create an existing account:")
bank.create_account("A001", "Someone Else", 300)
## Final state of the banking system
print(f"\n{bank}")파일을 저장합니다.
스크립트를 실행합니다.
python3 banking_system.py다음과 유사한 출력을 볼 수 있습니다.
Python First Bank - Managing 0 accounts
All accounts:
Account A001 | Owner: John Doe | Balance: $1000.00
Account A002 | Owner: Jane Smith | Balance: $500.00
Account A003 | Owner: Bob Johnson | Balance: $250.00
Before deposit: Account A001 | Owner: John Doe | Balance: $1000.00
After deposit: Account A001 | Owner: John Doe | Balance: $1500.00
Before withdrawal: Account A002 | Owner: Jane Smith | Balance: $500.00
After withdrawal: Account A002 | Owner: Jane Smith | Balance: $300.00
Trying to create an existing account:
Account A001 already exists
Python First Bank - Managing 3 accounts이 예제는 이전에 만든 BankAccount 클래스를 보다 완벽한 애플리케이션에서 사용하는 방법을 보여줍니다. __init__, __str__, __repr__과 같은 특수 메서드가 직관적이고 사용자 친화적인 클래스를 만드는 데 어떻게 탄탄한 기반을 제공하는지 보여줍니다.
이 랩에서는 더 표현력이 풍부하고 사용자 친화적인 객체를 만드는 데 도움이 되는 Python 의 세 가지 필수 특수 메서드에 대해 배웠습니다.
__init__: 객체가 생성될 때 객체의 속성을 초기화하는 생성자 메서드입니다.
__str__: 주로 최종 사용자를 위해 객체의 사람이 읽을 수 있는 문자열 표현을 제공하는 메서드입니다.
__repr__: 주로 개발자 및 디버깅을 위해 객체의 모호하지 않은 문자열 표현을 제공하는 메서드입니다.
Person 및 Book과 같은 간단한 클래스부터 은행 시스템과 같은 더 복잡한 애플리케이션까지, 여러 예제에서 이러한 메서드를 구현했습니다. 또한 __str__과 __repr__의 차이점과 각 메서드를 언제 사용해야 하는지 배웠습니다.
이러한 특수 메서드를 마스터함으로써 언어의 내장 기능과 원활하게 통합되는 보다 직관적이고 사용자 정의된 Python 객체를 만들 수 있습니다. 이 지식은 Python 에서 객체 지향 프로그래밍의 필수적인 부분을 형성하며, 더 깨끗하고 유지 관리 가능한 코드를 작성하는 데 도움이 될 것입니다.
Python 여정을 계속 진행하면서, 객체의 동작을 더욱 사용자 정의할 수 있는 다른 많은 특수 메서드가 있다는 것을 기억하십시오. 이러한 메서드를 탐색하면 다양한 컨텍스트에서 객체가 어떻게 동작하는지에 대한 더 많은 제어 권한을 얻을 수 있습니다.
