(Python) Class 공부. 2

채널, 볼륨, 켜짐유무를 확인하는 class를 생성해보았다.

class Television:
    def __init__(self, channel, volume, on):
        self.channel = channel
        self.volume = volume
        self.on = on
 
    def show(self):
        print(self.channel, self.volume, self.on)
 
    def setChannel(self, chann1. el):
        self.channel = channel
 
    def getChannel(self):
        return self.channel

 

호출방식은 다음과 같다.

t = Television(9, 10, True)  # 't'라는 객체를 생성해주고 매개변수로 값들을 넘겨준다.

t.show()  # method를 호출한다.
--> 9 10 True

 

또한 채널을 바꾸고 싶으면 setChannel method를 호출해서 바꾸면 된다.

t.setChannel(11)

t.show()

현재 채널값을 불러오고 싶으면 getChannel을 이용하면 된다.

t.getChannel()
--> 11

------------------------------------------------------------------------------------------------------------------------------

학생들을 관리하는 Class를 만들어보자. method는 age, Name 두 개를 사용한다.

"""
인스턴스 변수값을 반환하는 접근자(gatters)
인스턴스 변수값을 설정하는 설정자(setters)
"""
class student:
    def __init__(self, name=None, age=0):
        self.__name = name
        self.__age = age
    
    def getAge(self):
        return self.__age
    
    def getName(self):
        return self.__name
    
    def setAge(self, age):
        self.__age = age
        
    def setName(self, name):
        self.__name = name
 
obj = student("Hong", 20)
obj2 = student("OH", 42)
obj.getName(), obj2.getName()

 

즉, 비공개속성이라고 이해하면 될 것 같다.

 

self.__age 부분을 self.age로 고치고 obj.age = 10 을 입력 후 obj.getAge()를 하면 10으로 바꾸는 것을 확인할 수 있다.

 

obj 변수에는 'Hong'과 '20', obj2 변수에는 'OH'와 '42'를 입력한다.

obj.getName()
 --> Hong

obj2.getName()
 --> OH

이렇게 우리는 학생들을 Class를 이용하여 손쉽게 관리할 수 있다.

 

------------------------------------------------------------------------------------------------------------------------------

원의 반지름, 넓이, 둘레를 구하는 Class를 만들어보자

import math
 
 
class Circle:
    def __init__(self, radius, area, round_):  # 반지름, 넓이, 둘레
        self.radius = radius
        self.area = math.pi * radius * radius
        self.round_ = 2 * math.pi * radius
 
    def to_radius(self):
        print("원의 반지름 =", self.radius)
 
    def to_area(self):
        print("원의 넓이 =", self.area)
 
    def to_round_(self):
        print("원의 둘레 =", self.round_)

1. 파이썬의 math 함수를 import 시킨다.

 

2. Class를 생성하고, __init__에 radius, area, round_를 준다. (round가 반올림함수로 존재하기에 _를 붙인다.)

 

3. 각각 계산식들을 변수명에 대입한다. 

 

4. 인스턴스값을 반환해주는 반환값 메서드를 생성한다.

Circles = Circle(10, area=0, round_=0)
Circles.to_radius()
Circles.to_area()
Circles.to_round_()
print()
Circles2 = Circle(5, area=0, round_=0)
Circles2.to_radius()
Circles2.to_area()
Circles2.to_round_()

5. 결과

 

------------------------------------------------------------------------------------------------------------------------------

은행시스템을 Class로 한 번 만들어보자

class bank:
    def __init__(self, balance):  # 현재 잔액
        self.__balance = balance
 
    def withdraw(self, withdraw):  # 인출
        self.__withdraw = withdraw  # 인출금
        self.__balance = self.__balance - withdraw  # 현재잔액
        print(f"통장에서 {self.__withdraw}만원이 출금되었음")
        print(f"현재 남은 잔액 {self.__balance}만원 입니다.")
 
    def deposit(self, deposit):  # 예금
        self.__balance = deposit + self.__balance
        print(f"통장에 {deposit}만원이 입금되었음")
        print(f"현재 남은 잔액 {self.__balance} 만원 입니다.")
        
    def get_amount(self):
        return print("현재 잔액은", self.__balance, "만원 입니다.")

1. Class이름은 bank로 두고 balance라는 잔액변수를 생성한다.

 

2. withdraw는 인출금, deposit은 예수금을 뜻한다. 각각 메서드를 생성한다.

 

3. 인출금은 '현재잔액 - 인출금' 이기때문에 식을 세우고 print문으로 남은 잔액을 알려준다.

 

4. 예금은 '현재잔액 + 예금액' 이기에 똑같은 방식으로 값을 알려준다.

 

5. 여기서 인출을하고 예금을 했을 때, 현재잔액이 바뀌도록하기 위해 withdraw 메서드에 현재잔액을 balance - withdraw로 바뀌게해두었다.

 

6. 그리고 접근자를 생성하여 현재 잔액을 출력한다.

banking = bank(60)
banking.withdraw(50)
banking.deposit(100)
banking.get_amount()

7. 결과

 

------------------------------------------------------------------------------------------------------------------------------

고양이 이름을 Class로 관리하기

class Cat_name:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age
    
    def maching_name(self):
        return self.__name
    
    def maching_age(self):
        return self.__age
 
a = Cat_name("Missy", 3)
b = Cat_name("Lucky", 5)
 
a.maching_name(), a.maching_age(), b.maching_name()

--> Missy, 3, Lucky

 

------------------------------------------------------------------------------------------------------------------------------

상자의 가로, 세로, 높이를 받아서 부피를 출력하는 Claass를 생성하자

class box:
    def __init__(self, row, column, high):  # 가로, 세로, 높이
        self.__row = row
        self.__column = column
        self.__high = high
 
    def set_row(self):
        self.__row = row
 
    def set_column(self):
        self.__column = column
 
    def set_high(self):
        self.__high = high
 
    def sum_box(self):
        return print(f"상자의 부피는 {self.__row * self.__column * self.__high} 입니다.")
    
    def __str__(self):  # init에 들어간 변수 자체를 출력할 때 사용한다.
        return print(f"{self.__row}, {self.__column}, {self.__high}")

1. Class명은 box로 잡고 __init__에는 row, column, high를 매개변수로 둔다.

 

2. 설정자를 3개 생성한다.

 

3. 박스의 부피를 구하는 식을 세운다.

 

4. __str__에 각 값들의 출력을 담아둔다.

 

'__str__'은 '__repr__'은 class안에서 자주쓰인다 두 메서드는 객체의 문자열 표현을 반환한다. 마치 print문이라고 생각하면 될 것 같다. 자세한 것은 구글에 검색하는 것을 추천한다.

size = box(100, 100, 100)
size.sum_box()
size.__str__()

--> 상자의 부피는 1000000 입니다.
--> 100, 100, 100

 

------------------------------------------------------------------------------------------------------------------------------

사각형의 넓이를 구하는 식을 Class로 짜보자

class Rectangle:
    def __init__(self, side=0):
        self.side = side
 
    def getArea(self):
        return self.side * self.side
 
 
def printAreas(r, n):
    while n >= 1:
        print(r.side, "\t", r.getArea())
        r.side = r.side + 1
        n = n - 1

여기서는 class안에 메서드와 함수를 사용하였다.

 

함수는 class안에 side와 getArea()를 호출할 수 있는데 한 번 설명해보겠다.

 

1. 먼저 Rectangle이라는 Class를 생성하고 __init__에 side값을 담는다.

 

2. getArea()에는 넓이를 구하는 공식을 적는다

 

3.  그리고 함수 printAreas를 선언 후 매개변수로 'r', 'n'을 준다.

 

4. while문을 돌리는데 r.side 즉 매개변수 'r' 값을 side로 주고, 마찬가지로 getArea값도 'r'로 준다.

 

5.  myRect = Rectangle()로 객체를 생성한다.

 

6. count = 5로 주고 printAreas를 호출한다.

 

7. 결과값(side값에 따라 사각형의 넓이를 구해준다.)

myRect = Rectangle()
count = 5
printAreas(myRect, count)

------------------------------------------------------------------------------------------------------------------------------

자동차 Class를 만들고 자동차 Class를 상속받는 Truck Class를 만들어보자

"""
상속 inheritance
"""
 
# 부모 클래스
class Vehicle:
    def __init__(self, make, model, color, price):
        self.make = make
        self.model = model
        self.color = color
        self.price = price
 
    def setMake(self, make):
        self.make = make
 
    def getMake(self):
        return self.make
 
    def getDesc(self):
        return "차량 =("+str(self.make)+"," +\
            str(self.model)+"," +\
            str(self.color)+"," +\
            str(self.price)+")"
 
# 자식 클래스
class Truck(Vehicle):
    def __init__(self, make, model, color, price, payload):
        super().__init__(make, model, color, price)
        self.payload = payload
 
    def setPayload(self, payload):
        self.payload = payload
 
    def getPayload(self):
        return self.payload
 
 
def main():
    myTruck = Truck("Tisla", "Model S", "white", 10000, 20000)
    myTruck.setMake("Tesla")
    myTruck.setPayload(2000)
    print(myTruck.getDesc())
 
 
main()

class Car:
    def __init__(self, speed):
        self.speed = speed
 
    def setSpeed(self):
        self.speed = speed
 
    def getSpeed(self):
        return self.seped
 
    def getDesc(self):
        print(f"차량 속도는: {self.speed} 입니다. turbo는 {self.turbo} 입니다.")
 
 
class SportsCar(Car):
    def __init__(self, speed, turbo):
        super().__init__(speed)
        self.turbo = turbo
 
    def setTurbo(self, turbo):
        self.turbo = turbo
 
    def getTurbo(self):
        return self.turbo

마찬가지로 부모클래스의 Car를 상속받는 SportsCar를 생성해서 접근자와 설정자 메서드를 생성하면 손쉽게 구현할 수 있다.

Ferari = SportsCar(10, True)

Ferari.getDesc()
 --> 차량 속도는: 10 입니다. turbo는 True 입니다.

Ferari.setTurbo(False)

Ferari.getDesc()
--> 차량 속도는: 10 입니다. turbo는 False 입니다.

 

------------------------------------------------------------------------------------------------------------------------------

사각형의 둘레와 넓이를 구하는 Class를 만들자

class Shape:
    def __init__(self, x, y):
        self.x = x
        self.y = y
 
    def area(self):
        print("계산할 수 없음!")
 
    def perimeter(self):
        print("계산할 수 없음!")
 
 
class Rectangel(Shape):
    def __init__(self, x, y, w, h):
        super().__init__(x, y)
        self.w = w
        self.h = h
 
    def area(self):
        return self.w * self.h
 
    def perimeter(self):
        return 2*(self.w+self.h)
 
 
def main():
    r = Rectangel(0, 0, 100, 200)
    print(r.area())
    print(r.perimeter())
    
main()

 

-----------------------------------------------------------------------------------------------------------------------------

학생들의 이름, 주민번호, 수강과목, 평점을 관리하는 Class를 만들어보자

class Person:
    def __init__(self, name, resident_number):
        self.name = name
        self.resident_number = resident_number
 
    def setName(self):
        self.name = name
 
#     def getDesc(self):
#         print(f"이름은 {self.name}이고, 주민번호는 {self.resident_number} 입니다.")
 
 
class Student(Person):
    def __init__(self, name, resident_number, study, grade):
        super().__init__(name, resident_number)
        self.study = study
        self.grade = grade
 
    def setStudy(self):
        self.study = study
 
    def setGrade(self):
        self.grade = grade
    
    def getDesc(self):
        print(f"이름={self.name}\n주민번호={self.resident_number}\n수강과목={self.study}\n평점={self.grade}")
 
 
class Teacher(Person):
    def __init__(self, name, resident_number, lec, salary):
        super().__init__(name, resident_number)
        self.lec = lec
        self.salary = salary
 
    def setLec(self):
        self.lec = lec
 
    def setSalary(self):
        self.salary = salary
 
    def getDesc(self):
        print()
        print(f"이름={self.name}\n주민번호={self.resident_number}\n강의과목={self.lec}\n월급={self.salary}")
        
    def __str__(self):
        return f"{self.name}"

1. 먼저 부모클래스인 Person를 생성한다 Person은 이름과 주민번호를 인스턴스변수로 가진다.

 

2. Person를 상속받는 Student는 수강과목과 평점을 설정자를 생성하여 관리한다. 

 

3. Person를 상속받는 Teacher는 강의과목과 월급을 설정자를 생성하여 관리한다.

 

4. __str__를 써가지고 내가 입력한 값들을 볼 수 있다.

 

5. 입력 & 결과 값

Minsu = Student("민수", 12345678, "['자료구조']", 0)
Minsu.getDesc()
 --> 이름=민수
 --> 주민번호=12345678
 --> 수강과목=['자료구조']
 --> 평점=0

Michael = Teacher("마이클", 1234567890, "['Python']", 30000000)
Michael.getDesc
 --> 이름=마이클
 --> 주민번호=1234567890
 --> 강의과목=['python']
 --> 월급=30000000

print(Michael.__str__())
 --> 마이클

 

-----------------------------------------------------------------------------------------------------------------------------

method overridng를 구현하는 Class를 만들어보자

# method overriding
class BankAccount:
    def __init__(self, name, number, balance):
        self.balance = balance
        self.name = name
        self.number = number
 
    def withdraw(self, amount):
        self.balance -= amount
        return self.balance
 
    def deposit(self, amount):
        self.balance += amount
        return self.balance
 
 
class SavingsAccount(BankAccount):
    def __init__(self, name, number, balance, interest_rate):
        super().__init__(name, number, balance)
        self.interest_rate = interest_rate
 
    def set_interest_rate(self, interest_rate):
        self.interest_rate = interest_rate
 
    def get_interest_rate(self):
        return self.interest_rate
 
    def add_interest(self):
        self.balance += self.balance * self.interest_rate
 
 
class CheckingAccount(BankAccount):
    def __init__(self, name, number, balance):
        super().__init__(name, number, balance)
        self.withdraw_charge = 10000
 
    def withdraw(self, amount):
        return BankAccount.withdraw(self, amount + self.withdraw_charge)

1.  부모클래스인 BankAccount를 만들고 인스턴스 변수 'balance', 'name', 'number'를 만든다.

 

2. 출금에는 현재잔액(balance) - amount 식을 세운 뒤 메서드 생성, 입금도 마찬가지로 생성한다

 

3. 자식클래스인 SavingsAccount를 생성하고 이자율을 주기위한 설정자, 접근자를 생성한다.

 

4. 마찬가지로 CheckingAccount에는 출금 수수료를 10000원 붙이고 amount값에 10000원을 추가한다.

 

5. return BankAccount.withdraw(self, amount + self.withdraw_charge) 이 부분이 부모클래스의 withdraw에 amount에 + 10000원 된다고 보면된다.

 

6. 입력 및 결과값

a1 = SavingsAccount("홍길동", 123456, 10000, 0.05)
a1.add_interest()
print("저축예금의 잔액=", a1.balance)
 --> 저축예금의 잔액 = 10500.0

a2 = CheckingAccount("김철수", 123457, 2000000)
a2.withdraw(100000)
print("당좌예금의 금액=", a2.balance)
 --> 당좌예금의 금액 = 1890000

 

-----------------------------------------------------------------------------------------------------------------------------

간단하게 동물과 개를 이용한 메서드 오버라이딩을 구현한 Class를 써보자

# method overriding example
class Animal:
    def __init__(self, name=""):
        self.name = name
    
    def eat(self):
        print("동물이 먹고 있습니다.")
        
class Dog(Animal):
    def __init__(self):
        super().__init__()
        
    def eat(self):
        print("강아지가 먹고 있습니당")
        
d = Dog()
d.eat()

1. Animal에 eat 메서드는 '동물이 먹고 있습니다.' 를 설정한다.

 

2. 자식클래스 Dog에 eat 메서드는 '강아지가 먹고 있습니다'로 부모클래스의 eat를 재정의해준다.

 

3. 입력 및 결과 값

d = Dog()
d.eat()
 --> 강아지가 먹고 있습니당

 

-----------------------------------------------------------------------------------------------------------------------------

고용인과 매니저간의 관계를 Class로 만들어보자

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
 
    def getSalary(self, salary):
        self.salary = salary
        return salary
 
 
class Manager(Employee):
    def __init__(self, name, salary, bonus):
        super().__init__(name, salary)
        self.bonus = bonus
 
#     def getSalary(self, salary):
#         return Employee.getSalary(self, salary + self.bonus)
 
    # 교수님 코딩
    def getSalary(self):
        salary = super().getSalary()
        return salary + self.bonus
 
    def __repr__(self):
        return "이름 " + self.name + "; 월급: " + str(self.salary) +\
            "; 보너스: "+str(self.bonus)
 
 
# Manager_Minsu = Manager("민수", 2000000, 1234000)
# Manager_Minsu.getSalary(1000000)
 
kim = Manager("김철수", 2000000, 1000000)
print(kim)
print(__name__)

 

-----------------------------------------------------------------------------------------------------------------------------

객체를 생성할 때 List를 써 서 Class에 접근해보자

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return '알 수 없음'
    
class Dog(Animal):
    def speak(self):
        return '멍멍!'
    
class Cat(Animal):
    def speak(self):
        return '야옹!'
    
animalList = [Dog('dog1'),
             Dog('dog2'),
             Cat('cat1')]
 
for a in animalList:
    print(a.name +':' + a.speak())
    
print(animalList)

1. 부모클래스인 Animal을 생성한다.

 

2. 자식클래스인 Dog은 멍멍, Cat은 야옹을 넣는다.

 

3. animalList에 'dog1', 'dog2', 'cat1'을 생성한다.

 

4. for문을 이용해 출력해본다

 

5. 입력 및 결과 값

for a in animalList:
    print(a.name +':' + a.speak())
 --> dog1: 멍멍!
 --> dog2: 멍멍!
 --> cat1: 야옹!
 
print(animalList)
 --> 각 객체들의 주소값들이 담겨있다.

 

-----------------------------------------------------------------------------------------------------------------------------

마지막으로 Class을 이용해 'Card'와 'Deck'를 구현해보자

 카드 모양: ['클러버', '다이아몬드', '하트', '스페이드']

 카드 숫자: ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '잭', '퀸', '킹', '에이스']

class Card:
    suitNames = ['클럽', '다이아몬드', '하트', '스페이드']
    rankNames = [None, '에이스', '2', '3', '4', '5',
                 '6', '7', '8', '9', '10', '잭', '퀸', '킹']
 
    def __init__(self, suit, rank):
        self.suit = suit
        self.rank = rank
 
    def __str__(self):
        return Card.suitNames[self.suit]+"" +\
            Card.rankNames[self.rank]
 
 
class Deck:
    def __init__(self):
        self.cards = []
 
        for suit in range(4):
            for rank in range(1, 14):
                card = Card(suit, rank)
                self.cards.append(card)
 
    def __str__(self):
        lst = [str(card) for card in self.cards]
        return str(lst)
 
 
deck = Deck()
deck.__str__()

※ 사실 이 코드는 이해가 되지 않는 부분이 많다 디버깅을 하면서 하나하나 분석해봐야겠다.

 

※ 여기 적힌 코드들은 모두 달라질 수 있습니다

 

※ 잘못된 내용이 있을수도 있습니다! 지적해주시면 감사합니다. 사랑~

 

 

감사합니다. Thank you!