----
layout: single
title: Fundamuntal 13. 나만의 n면체 주사위 만들기
----

나만의 n면체 주사위 위젯 만들기

• 파이썬 클래스 문법 익히자
• 객체 지향 프로그래밍에 대해 배우자

객체란?

파이썬(Python)에서 모든 것은 객체(object)다. 그리고 대부분의 객체는 속성(attributes)과 메서드(methods)를 갖는다
Everything is an Object
문자열을 반환하는 내장 속성을 doc를 가지고 있다.

먼저 변수를 이야기해보자. 왜????

myvar = 3
myvar

3

변수라는 이름을 붙이는 것.

• 진짜 객체를 변수명으로 가리켜 참조할 수 있도록 하는 것.
  • 길면 짧게 표시할 수 있다는 거지.
  • 이름이 길면 부르기 힘드니까

myname = '박하늘별님구름햇님보다사랑스러우리씨'
myname

'박하늘별님구름햇님보다사랑스러우리씨'

위 이름은 한국에서 가장 긴 이름인데 저걸 myname이라는 걸로 줄여버리는 것.

모든 문자열 클래스에는 upper(0) 이라는 메소드가 있다.

myword = 'cat'
myword

'cat'

myword.upper()

'CAT'

'cat'.upper()

'CAT'

myword이 가리키는 문자열과 'cat'이라는 값이 같다

id()라는 함수

• 객체의 identity를 확인하는 내장 함수
• 각 객체의 고유값
• 메모리에 부여된 유일한 값
• 메모리 주소라고 함.

var = 4
var

4

print(id(var), id(4)) #id 값은 pc마다 다릅니다.

4482629968 4482629968

얕은 복사, 깊은 복사

copy DeepCopoy

1. • 어떤 값(4)이 있고 이것에 이름(var)을 붙여준다.
   • 어떤 값은 고유의 주소(4482629968)를 가지고 있다.
   • 어떤 이름(var)이 값(4)을 가르키는 것을 참조한다고 한다.
2. • mutable 은 주소값이 그대로인채 값이 변한다. (원본 자체가 바뀐다는 뜻이다)
     - list(순서가 있다), set(순서가 없다), dict(순서 없이, key, value가 있다)
   • Immutable 은 값이 바뀌면 주소값도 바뀐다. (원본이 남아있다는 뜻이다)
     - bool, int, float, tuple, str, frozenset(Immutable Set)
3. • copy (shallow copy)
     • 객체의 주소를 복사
   • deepcopy : 붕어빵 기계 같은거 : 새로운 걸 찍어낸다.
     • 객체의 값을 복사

import copy
a = [1,2,3,4]
b = copy.deepcopy(a)
print(a,b)
print(id(a), id(b))
b[1] = 0
print(a,b)
print(id(a), id(b))

[1, 2, 3, 4] [1, 2, 3, 4]
4544586880 4544587712
[1, 2, 3, 4] [1, 0, 3, 4]
4544586880 4544587712

import copy
c = [1,2,3,4]
d = copy.copy(a)
print(c,d)
print(id(c), id(d))
d[1] = 0
print(c,d)
print(id(c), id(d))

[1, 2, 3, 4] [1, 2, 3, 4]
4544587776 4544767104
[1, 2, 3, 4] [1, 0, 3, 4]
4544587776 4544767104

import copy
e = [1,2,3,4]
f = a.copy()
print(e,f)
print(id(e), id(f))
f[1] = 0
print(e,f)
print(id(e), id(f))

[1, 2, 3, 4] [1, 2, 3, 4]
4544585280 4526864000
[1, 2, 3, 4] [1, 0, 3, 4]
4544585280 4526864000

# 변수 var에 리스트 변수 mylist 를 할당.
mylist = [1,2,3]
var = mylist
var

[1, 2, 3]

# mylist에 append()메소드를 이용하여 원소 4 추가
mylist.append(4)
print(mylist)

[1, 2, 3, 4]

객체지향 프로그래밍이란

• 변수(a_tire, b_tire,...)가 너무 많아지고, 함수{a_run(), b_run(),....) 가 많아져서 복잡함
• 하나로 묶어서 표현 -> 클래스 car -> 클래스에 묶인 객체 car_a_tire / 함수 car_a_run()

클래스 선언 및 인스턴스화

클래스 선언하기 class

class Car:
    pass

class Car():
    pass

#id(Car)는 여러번 호출해도 같은 값이 얻어집니다. 
print(id(Car))
print(id(Car))

#id(Car())는 Car()가 호출될 때마다 다른 값이 얻어집니다. 
print(id(Car()))
print(id(Car()))

# 두 객체의 type을 살펴봅니다. 
print(type(Car))
print(type(Car()))

140582709239360
140582709239360
4526845680
4526834832
<class 'type'>
<class '__main__.Car'>

car()는 type유형의 객체
id(car())은 main.car 유형 ????
car의 id는 고정 / car()의 id는 호출할때 마다 생성
car 는 그대로 car 이지만 car()는 호출할때마다 새로운 car 타입의 객체가 생성
id(car())은 호출될때마다 다른 id

클래스 사용 - 객체 인스턴스화

• 클래스를 이용하기 위해 객체로 만들어줘야 한다
• -> 인스턴스화
• 선언한 클래스에 ()를 붙여준다.

class Car:
    pass

mycar = Car()
mycar2 = Car()
print(id(mycar))
print(id(mycar2))

4526846112
4526845152

1. 클래스명에 괄호를 추가해 객체로

2. mycar 와 mycar2라는 변수에 Car 클래스의 인스턴스를 할당 -> 클래스를 call했다.

• Car 클래스를 호출하기 위해 mycar라는 인스턴스를 사용
• mycar 인스턴스를 이용해 Car 클래스 사용
• Car 안의 다양한 메소드를 사용하기 위해

표기법

1. 클래스 각 단어의 앞 글자를 대문자로 쓸 것.
   • mycar -> MyCar
   • 주로 명사로
2. 함수 단어는 소문자로 쓰고 각 단어의 연결은 언더바로 할것
   • mycar -> my_car
     함수명은 주로 동사로

클래스 속성과 메소드

클래스의 속성과 메소드

• 클래스 속상은 상태(state)를 표현
• 속성은 변수로 나타냄
• 메소드는 동작(behavior)을 표현
• 메소드는 def 키워드로 나타냄 -> 어떻게 동작할 지 정의를 해줘야 함.

Car 클래스를 코딩해보자

\색상(color)\ 은 "red" \종류(category)\는 "sports car" 라는 속성을 가지고
\주행\과 \가속\이라는 동작 을 갖는 클래스

• 여기서 속성은 color, category
  • color = 'red'
  • category = 'sports car'
• 동작은 메소드 -> def를 사용
  • def driving():
    pass
    def accel():
    pass

class Car:
    color = 'red'
    category = 'sports car'

    def drive(self):
        print("I'm driving")

    def accel(self, speed_up, current_speed=10):
        self.speed_up = speed_up
        self.current_speed = current_speed + speed_up
        print("speed up", self.speed_up, "driving at", self.current_speed)

# Car 클래스입니다.
class Car:
    '''
    속성은 클래스의 상태를 나타냅니다.
    색상: 빨강
    종류: 스포츠 카
    '''
    color = 'red'
    category = 'sports car'
		
    '''
    동작은 메서드로 나타냅니다.

    

        주행 메서드
        '''
    def drive(self):
        '''
        작동 내용
        '''
        print("I'm driving")
        '''
        가속 메서드
        :param speed_up: 현재속도    / :type speed_up: string
        :param current_speed: 가속  / :type current_speed: string      

        '''		
    def accel(self, speed_up, current_speed=10):
        '''   
        '''
        self.speed_up = speed_up
        self.current_speed = current_speed + speed_up
        print("speed up", self.speed_up, "driving at", self.current_speed)

속성

• 클래스의 상태는 속성이라고 부르며, 변수로 선언합니다.
• color에는 'red'를 category에는 'sports car'를 할당합니다.

메소드

• 동작은 메서드로 나타내고 메서드 선언은 함수와 똑같이 def 키워드를 이용합니다.
• 클래스의 메서드는 첫 번째 인자는 self 값을 적어 주어야 합니다. (self 에 대한 설명은 나중에 하겠습니다)
• 주행은 drive() 라는 메서드명으로 정의하고 self외에 인자는 없습니다.
• 가속은 accel() 라는 메서드명으로 정의하고 현재 속도와 가속할 값을 인자로 받습니다.
  • 현재속도 인자명 = current_speed, 가속 인자명 = speed_up
  • accel 메서드에 self.speed_up, self.current_speed 를 인자로 줍니다.

클래스의 속성과 메소드 사용

속성. :

인스턴스명 = 클래스명() / mycar = Car()

인스턴스.속성명 / mycar.color

• 인스턴스.속성명

mycar = Car() # 인스턴스명 = 클래스명()

print(mycar.color) # 인스턴스명.속성명

red

mycar.price

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

AttributeError                            Traceback (most recent call last)

/var/folders/nv/7gm32z8n6cz1dzxgymhz5lmh0000gn/T/ipykernel_13457/4236691067.py in <module>
----> 1 mycar.price


AttributeError: 'Car' object has no attribute 'price'

없는 속성값에 접근하면 에러가 발생

메소드

• 메서드 호출 (feat. 인터프리터에서 벌어지는 일)
• 인스턴스.메소드명() / 메소드는 함수인거.
  • 함수에는 인자와 값이 있어야지.-> 인자가 없으면 그냥 지가 있는 거.

#  mycar.drive() 코드는 인터프리터 내부에서는 Car.drive(mycar)로 동작

mycar.drive() # car라는 클래스를 mycar 라는 인스턴스가 drive 라는 메소드로 동작

# 이렇게 사용하기 위해서는 mycar 인스턴스가 Car의 클래스임을 먼저 선언

I'm driving

mycar.accel(5)

speed up 5 driving at 15

mycar.drive() 코드는 인터프리터 내부에서는 Car.drive(mycar)로 동작

이것이 작동할 수 있도록 하는 것이 self

class Test:
    def run1(self):
        print("run1")

    def run2():
        print("run2")

t = Test()

# 이렇게는 잘 동작하지만
t.run1()

run1

# 이렇게는 동작하지 않음
t.run2()

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

TypeError                                 Traceback (most recent call last)

/var/folders/nv/7gm32z8n6cz1dzxgymhz5lmh0000gn/T/ipykernel_13457/1561068890.py in <module>
      1 # 이렇게는 동작하지 않음
----> 2 t.run2()


TypeError: Test.run2() takes 0 positional arguments but 1 was given

접두사 self

• 인스턴스 속성으로 사용하고 싶은 변수는 self.를 사용
• self 인자를 통해 선언된 객체의 값이란 의미

class Test2:
    def run1(self, a):
        self.a = float(a) * 10
        print(self.a)

    def run2(self, b):
        b = float(b) + 10
        print(self.b)
        
t = Test2()

t.run1(1)

10.0

t.run2(1) # self 를 이용하여 참조하지 않았기 떄문에 밖에서는 안됨

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

AttributeError                            Traceback (most recent call last)

/var/folders/nv/7gm32z8n6cz1dzxgymhz5lmh0000gn/T/ipykernel_13457/25985708.py in <module>
----> 1 t.run2(1)


/var/folders/nv/7gm32z8n6cz1dzxgymhz5lmh0000gn/T/ipykernel_13457/3234681881.py in run2(self, b)
      6     def run2(self, b):
      7         b = float(b) + 10
----> 8         print(self.b)
      9 
     10 t = Test2()


AttributeError: 'Test2' object has no attribute 'b'

class Test2:
    def run1(self, a):
        self.a = float(a) * 10
        print(self.a)

    def run2(self, b):
        b = float(b) + 10
        print(b)           #요기서 self를 없애고 출력
        
t = Test2()
t.run2(1)

11.0

class Test2:
    def run1(self, a):
        self.a = float(a) * 10
        print(self.a)

    def run2(b):
        b = float(b) + 10
        print(b)
        
t = Test2()
t.run2(1)

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

TypeError                                 Traceback (most recent call last)

/var/folders/nv/7gm32z8n6cz1dzxgymhz5lmh0000gn/T/ipykernel_13457/4213503736.py in <module>
      9 
     10 t = Test2()
---> 11 t.run2(b)


TypeError: Test2.run2() takes 1 positional argument but 2 were given

• self는 자기 자신입니다.
• 클래스에 의해 생성된 객체(인스턴스)를 가리킵니다.
• 클래스의 메서드는 인자로 해당 인스턴스(self)를 받아야 합니다.
• 메서드를 호출할 때는 self 인자를 전달하지 않습니다. self의 값은 인터프리터가 제공합니다.
• 인스턴스 변수를 정의할 때에는 접두사 self.을 붙여줍니다.

생성자

생성자 int

• 클래스에 의해 만든 인스턴스 객체의 속성값을 초기화
• 클래스를 만들 떄부터 속성을 지정해주고 그 값을 전달.

class Car:
    color = 'red'
    category = 'sports car'

    def drive(self):
        print("I'm driving")

    def accel(self, speed_up, current_speed=10):
        self.speed_up = speed_up
        self.current_speed = current_speed + self.speed_up
        print("speed up", self.speed_up, "driving at", self.current_speed)

##### 아래는 color과 category를 초기화하도록 변경한 코드
class Car2:
    def __init__(self, color, category):
        self.color = color
        self.category = category

    def drive(self):
        print("I'm driving")

    def accel(self, speed_up, current_speed=10):
        self.speed_up = speed_up
        self.current_speed = current_speed + self.speed_up
        print("speed up", self.speed_up, "driving at", self.current_speed)

• init 메서드 안에 인자를 전달함으로써 인스턴스 객체의 속성을 초기화할 수 있습니다.
• init 메서드 안에 정의된 속성(변수) color와 category는 클래스를 인스턴스화할 때 값을 설정할 수 있습니다.
• 이를 인스턴스 객체의 초기화 (initializing instance) 라고 히고, init함수는 생성자(constructor)라고 합니다.
• init 역시 def 키워드로 정의합니다. 즉, 클래스 안의 메서드이므로 self 문법 잊지 마세요!

#인스턴스 객체 선언
car1 = Car()
car2 = Car2('yellow', 'sedan')

car1.color

'red'

car2.color

'yellow'

car1.category

'sports car'

car2.category

'sedan'

# 아래처럼 키워드 인자 지정이 가능
class Car2:
    def __init__(self, color='red', category='sprots car'):
        self.color = color
        self.category = category

요약

• init이라고 쓰고, "던더(Double Under) 이닛"이라고 발음합니다.
• 다른 객체 지향 언어를 알고 있는 독자라면 생성자라는 말을 들으면 객체 인스턴스화와 초기화 2가지 작업을 생각할 수 있습니다.
• 파이썬의 생성자는 초기화만 수행합니다. 그럼 객체 인스턴스화는 누가 할까요? 기억나시나요? 네, 바로 클래스 사용 시 변수 할당을 통해 이루어집니다.
• init처럼 앞뒤에 언더바(_)가 두 개씩 있는 메서드를 매직 메서드 라고 합니다.

클래스 변수와 인스턴스 변수

class Car:
    Manufacture = "India"   
    # Manufacture 라는 변수, Manufacture 라는 인스턴스 가 아님(뒤에 클래스가 아니니까.) 
    # 그냥 클래스에 있는 변수라 함. 클래스 변수 

    def __init__(self, color, category='sedan'):
        self.color = color
        self.category = category
        # self.color 라는 변수, self.color이라는 인스턴스  -> 인스턴스 변수

car1 = Car('red','sports car')
car2 = Car('white')
print(car1.Manufacture, car1.color, car1.category)
print(car2.Manufacture, car2.color, car2.category)

India red sports car
India white sedan

구분이유는 객체 단위로 바뀌냐 안바뀌냐

• 초기화가 가능하게 하는 게 인스턴스 변수

클래스 변수

• 클래스에 바로 선언된 속성을 클래스 변수라고 하며 클래스에 의해 생성된 모든 객체에서 같은 값을 조회할 때 가능합니다.
• Manufacture는 클래스 변수에요.
• Manufacture 속성은 car1과 car2가 공유

인스턴스 변수

• init() 안에서 self를 사용해 선언된 변수를 인스턴스 변수라고 합니다. 객체가 인스턴스화될 때마다 새로운 값이 할당되며 서로 다른 객체 간에는 값을 공유할 수 없습니다.
• color와 category는 인스턴스 변수에요.
• color와 category 속성은 car1과 car2가 공유하지 않습니다.

상속

클래스에 메서드 기능 몇개만 추가하고 싶을 때.

class Car:
    Manufacture = "India"

    def __init__(self, color='red', category='sedan'):
        self.color = color
        self.category = category

    def drive(self):
        print("I'm driving")

    def accel(self, speed_up, current_speed=10):
        self.speed_up = speed_up
        self.current_speed = current_speed + self.speed_up
        print("speed up", self.speed_up, "driving at", self.current_speed)

Car 클래스의 기능은 유지한 채 maker 속성만 추가된 새로운 클래스 NewCar를 선언하고 싶다

소괄호 안에 상속받을 클래스 이름

class 클래스명(원조클래스)

class NewCar(Car):
    pass

car = NewCar()
car.drive()
car.accel(10)

I'm driving
speed up 10 driving at 20

class NewCar(Car):
    maker = 'Porsche'

car = NewCar()
car.maker

'Porsche'

자식 클래스, 부모 클래스

• 상속받은 클래스
  • "자식 클래스", "서브 클래스(sub class)", "파생된 클래스(derived class)"
• 기존 클래스
  • "부모 클래스", "슈퍼 클래스(super class)", "베이스 클래스(base class)"

상속 사용하기

• 상속은 기존에 있는 코드를 재사용(상속) 하기 위한 기능

메서드 추가하기(add)

class NewCar(Car):
    def fly(self):
        print("I'm flying!! This is the new car!!")

메서드 재정의하기(override)

• 기존의 메소드를 수정

class NewCar(Car):
    def fly(self):
        print("I'm flying!! This is the new car!!")

    def drive(self):
        print("I'm driving and can fly")

부모 메서드 호출하기(super())

def (부모클래스의)메서드이름():
_ super().메서드이름()

class NewCar(Car):
    def __init__(self, color, category, maker):
        super().__init__(color, category)
        self.maker = maker

    def fly(self):
        print("I'm flying!! This is the new car!!")

    def accel(self, speed_up, level=1, current_speed=10):
        self.boost[level] = {1 : 0, 2 : 30, 3 : 50}
        self.speed_up = speed_up + self.boost[level]
        self.current_speed = current_speed + self.speed_up
        print("speed up", self.speed_up, "driving at", self.current_speed)

class NewCar(Car):
_ def init(self, color, category, maker):
____ ____ self.color = color
____ ____ self.category = category
____ ____ self.maker = maker

지금은 부모 클래스에서 color를 이름으로 받지만 color를 RGB 값으로 받도록 바꾸고 싶다고 합시다. 자동차 클래스를 상속받은 모든 클래스에서 color는 RGB 값으로 받게 하고 싶습니다. 만약 메서드를 오버라이드 했다면 상속받은 클래스 하나하나의 초기화 코드를 변경해 주어야 할 겁니다. 이렇게 super() 를 사용해 변수를 초기화하면 부모 클래스만 변경하면 되겠죠?

class Car:
    Manufacture = "India"

    def __init__(self, color='red', category='sedan'):
        self.color = color 
        self.category = '2020Y '+ category


class NewCar(Car):
    def __init__(self, color, category, maker):
        super().__init__(color, category)
        self.maker = maker

newcar = NewCar('red','sports car', 'Kia')
print(newcar.category)

2020Y sports car

정리

1. 클래스 선언

2. 클래스 사용

   • "객체의 인스턴스"

3. 클래스는 동작과 상태를 갖는다.

   • 상태(State): 속성(Attribute)로 표현, 일명 변수

   • 동작(Behavior): Methode로 표현, 일명 함수

   • 객체는 동작은 공유하지만 상태는 공유하지 않는다.

4. 생성자 __ init __

5. 클래스 변수와 인스턴스 변수

   • 클래스에 선언된 속성은 클래스 변수라고 하며 이 클래스에 의해 생성된 모든 객체에 대해 같은 속성(값)을 갖는다.
   • 객체가 인스턴스화될 때마다 새로운 값이 할당되며 서로 다른 객체 간에는 속성(값)을 공유할 수 없다.

6. 상속

   • 메서드 추가, 메서드 오버라이드, 부모 메서드 호출하기

n면체 주사위 만들기

준비 템플릿

1. 기획

---

n면체 주사위

2. 기능

---

• 주사위 면의 개수 n 입력
• 던지면 1~n 눈의 수 중에서 랜덤으로 갖을 출력

3. 정리

---

• 객체

  • 주사위 : class FunnyDice():

• 상태

  • 주사위 면 : n
  • 주사위 면에 할당 숫자 : np

• 동작

  • 던지기 : throw
  • 랜덤 선택 : randval -> setval
  • 값 출력 : prtval -> getval

  main 만들기

  입력받기 n = get_input()

• n 이라는 변수명에 주사위 면의 수를 입력

• 이 변수는 get_input() 함수를 호출해서 받기

  주사위 만들기 mydice = FunnyDice(n)

• 주사위는 FunnyDice 클래스의 인스턴스 mydice

• mydice 를 FunnyDice의 클래스로부터 인스턴스 객체로(넌 니 주사위 써)

• mydice 의 객체는 변수 n를 인자로 받아 객체의 속성으로 추기화시킬 수 있도록

def main():
    n = get_inputs()
    mydice = FunnyDice(n)
    mydice.throw()
    print("행운의 숫자는? {}".format(mydice.getval()))

FunnyDice 클래스

FunnyDice 클래스 만들기

class FunnyDice:
    def __init__(self, n):
            self.n = n
    
    def throw(self):
        pass
    
    def getval(self):
        pass

    def setval(self, val):
        pass

랜덤으로 숫자를 생성해주는 모듈 import

from random import randrange

생성자 __ int __ 구현

from random import randrange

class FunnyDice:
    def __init__(self, n=6):                  # n의 디폴트 값 6 
        self.n = int(n)                       # 오류방지를 위해 정수로 형변환
        self.numbers = list(range(1, n+1))    # 주사위 눈숫자들 : 숫자를 리스트로 1 ~ n+1
        self.index = randrange(0, self.n)     # number 리스트의 인덱스. 
                                              #    숫자가 랜덤으로 나올 수 있도록 인덱스 변수 추가
                                              #    파이썬의 random 모듈의 randrange()함수를 이용해서 랜덤으로 나오게
        self.val = self.numbers[self.index]   # 주사위의 눈

1. 파라미터 n

   • n의 디폴트 값으로 6을 지정.
   • 이렇게 하면 인스턴스 객체를 만들 때 인자를 주지 않으면 6면체 주사위가 만들어짐
   • 그리고 혹시 몰라 n을 정수로 형변환

2. 인스턴스 변수

   • 인스턴스 변수에 numbers, index, val을 추가
   • self.numbers는 주사위 눈들. range() 함수를 이용해서 1부터 n+1까지의 리스트를 만듦.
   • self.index 는 number 리스트의 인덱스에요. 주사위를 던지기 전 눈의 수를 위해 인덱스 변수도 추가했어요.
   • 인덱스는 파이썬 random 모듈의 randrange()함수를 이용해서 랜덤으로 나오게 했습니다.
   • self.val은 주사위의 눈이에요.

throw 와 getval 메소드

from random import randrange

class FunnyDice:
    def throw(self):
        self.index = randrange(0, self.n)
        self.val = self.numbers[self.index]
    
    def getval(self):
        return self.val

1. throw

   • 랜덤으로 주사위 눈이 나오게 합니다.

2. getval

   • 주사위 눈 변수 val을 반환합니다. getval 메서드를 호출하면 주사위 눈의 값을 얻을 수 있습니다.
   • (주사위 눈 속성에 바로 접근할 수도 있지만 일반적으로 이렇게 속성에 접근하는 메서드를 구현하여 제공합니다. 파이썬 클린 코드, Design Pattern 관련된 내용이니 참고하세요)

setval 메소드

from random import randrange

class FunnyDice:    
    def setval(self, val:int):
        if val <= self.n:
            self.val = val
        else:
            msg = "주사위에 없는 숫자입니다. 주사위는 1 ~ {0}까지 있습니다. ".format(self.n)
            raise ValueError(msg)

사용자가 주사위 눈을 세팅할 수 있게끔 하는 메서드입니다.
만약 범위 밖의 숫자를 세팅하려고 하면
에러를 발생시키는 로직을 조건문을 이용해 구현

전체 코드

class FunnyDice:
    def __init__(self, n=6):
        self.n = int(n)
        self.numbers = list(range(1, n+1))
        self.index = randrange(0, self.n)
        self.val = self.numbers[self.index]

    def throw(self):
        self.index = randrange(0, self.n)
        self.val = self.numbers[self.index]

    def getval(self):
        return self.val

    def setval(self, val):
        if val <= self.n:
            self.val = val
        else:
            msg = "주사위에 없는 숫자입니다. 주사위는 1 ~ {0}까지 있습니다. ".format(self.n)
            raise ValueError(msg)

throw = FunnyDice()
lucknum = FunnyDice()
lucknum.throw()
print(lucknum.getval())
lucknum.setval(7)

5



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

ValueError                                Traceback (most recent call last)

/var/folders/nv/7gm32z8n6cz1dzxgymhz5lmh0000gn/T/ipykernel_13457/2180569561.py in <module>
      3 lucknum.throw()
      4 print(lucknum.getval())
----> 5 lucknum.setval(7)


/var/folders/nv/7gm32z8n6cz1dzxgymhz5lmh0000gn/T/ipykernel_13457/1290511724.py in setval(self, val)
     18         else:
     19             msg = "주사위에 없는 숫자입니다. 주사위는 1 ~ {0}까지 있습니다. ".format(self.n)
---> 20             raise ValueError(msg)


ValueError: 주사위에 없는 숫자입니다. 주사위는 1 ~ 6까지 있습니다. 

get_input() 함수 만들어 보기

main() 함수를 설계할 때, get_inputs()에서 사용자로부터 n면체 숫자 n값을 받게

def get_inputs():
    n = int(input("주사위 면의 개수를 입력하세요: "))
    return n

최종 결과

# funnydice.py

from random import randrange

class FunnyDice:
    def __init__(self, n=6):
        self.n = n
        self.options = list(range(1, n+1))
        self.index = randrange(0, self.n)
        self.val = self.options[self.index]
    
    def throw(self):
        self.index = randrange(0, self.n)
        self.val = self.options[self.index]
    
    def getval(self):
        return self.val
    
    def setval(self, val):
        if val <= self.n:
            self.val = val
        else:
            msg = "주사위에 없는 숫자입니다. 주사위는 1 ~ {0}까지 있습니다. ".format(self.n)
            raise ValueError(msg)

def get_inputs():
    n = int(input("주사위 면의 개수를 입력하세요: "))
    return n

def main():
    n = get_inputs()
    mydice = FunnyDice(n)
    mydice.throw()
    print("행운의 숫자는? {0}".format(mydice.getval()))

if __name__ == '__main__':
    main()

주사위 면의 개수를 입력하세요: 83
행운의 숫자는? 65