본문 바로가기
Programming/Python

인프런 파이썬 공부4 (완강)

밍동니 2021. 3. 31. 20:50 
class Unit:
	def __init__(self, name, hp, damage): #필요한 값들 정의하기
		self.name=name
		self.hp=hp
		self.damage=damage
		print("{0} 유닛이 생성되었습니다.".format(self.name))
		print("체력{0} , 공력력 {1}".format(self.hp, self.damage))
# marine1=Unit("마린", 40 , 5)
# marine2=Unit("마린", 40, 5)
# tank=Unit("탱크", 150, 35)

#레이스 : 공중 유닛, 비행기, 클로킹(상대방에게 보이지 않음)
wraith1=Unit("레이스", 80, 5)
print("유닛 이름:{0}, 공격력 : {1}".format(wraith1.name, wraith1.damage))

#마인드 컨트롤 : 상대방 유닛을 내 것으로 만드는 것 (빼앗음)
wraith2=Unit("빼앗은 레이스", 80, 5)
wraith2.clocking = True #외부에서 추가로 할당

if wraith2.clocking==True:
	print("{0}는 현재 클로킹 상태입니다".format(wraith2.name))

if wraith1.clocking==True:
	print("{0}는 현재 클로킹 상태입니다".format(wraith2.name))

class Unit:
	def __init__(self, name, hp, damage): #필요한 값들 정의하기
		self.name=name
		self.hp=hp
		self.damage=damage
		print("{0} 유닛이 생성되었습니다.".format(self.name))
		print("체력{0} , 공력력 {1}".format(self.hp, self.damage))

#공격 유닛
class AttackUnit:
	def __init__(self, name, hp, damage): #self는 자기 자신을 의미.클래스 내에서 메소드 앞에선 항상 self씀
		self.name=name
		self.hp=hp
		self.damage=damage

	def attack(self, location): #공격하는 함수
		print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 {2}]"\
			.format(self.name, location, self.damage)) #self.name과 damage는 위에서 전달받은 인자 쓴다는 의미 location은 바로위에서 전달받은거 사용

	def damaged(self, damage): #공격 받는 함수
		print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
		self.hp-=damage
		print("{0}: 현재 체력은 {1}입니다.".format(self.name, self.hp))
		if self.hp <=0:
			print("{0}: 파괴되었습니다.".format(self.name))

#파이어뱃 : 공격 유닛, 화염 방사기
firebet1=AttackUnit("파이어뱃", 50, 16)
firebet1.attack("5시")

#공격 2번 받는다고 가정
firebet1.damaged(25)
firebet1.damaged(25)

 

 

#일반 유닛
class Unit:
	def __init__(self, name, hp): #필요한 값들 정의하기
		self.name=name
		self.hp=hp

#공격 유닛
class AttackUnit(Unit): #Unit상속 받아서 만들어짐
	def __init__(self, name, hp, damage): #self는 자기 자신을 의미.클래스 내에서 메소드 앞에선 항상 self씀
		#self.name=name 상속 받으므로 쓸 필요 없엄
		#self.hp=hp 상속 받으므로 쓸 필요 없엄
		Unit.__init__(self, name, hp) #상속으로 위에 두줄 지우고 일케 상속 받아오기
		self.damage=damage

	def attack(self, location): #공격하는 함수
		print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 {2}]"\
			.format(self.name, location, self.damage)) #self.name과 damage는 위에서 전달받은 인자 쓴다는 의미 location은 바로위에서 전달받은거 사용

	def damaged(self, damage): #공격 받는 함수
		print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
		self.hp-=damage
		print("{0}: 현재 체력은 {1}입니다.".format(self.name, self.hp))
		if self.hp <=0:
			print("{0}: 파괴되었습니다.".format(self.name))

#파이어뱃 : 공격 유닛, 화염 방사기
firebet1=AttackUnit("파이어뱃", 50, 16)
firebet1.attack("5시")

#공격 2번 받는다고 가정
firebet1.damaged(25)
firebet1.damaged(25)

# 파이어뱃 : 5시 방향으로 적군을 공격합니다. [공격력 16]
# 파이어뱃 : 25 데미지를 입었습니다.
# 파이어뱃: 현재 체력은 25입니다.
# 파이어뱃 : 25 데미지를 입었습니다.
# 파이어뱃: 현재 체력은 0입니다.
# 파이어뱃: 파괴되었습니다.
#일반 유닛 부모
class Unit:
	def __init__(self, name, hp): #필요한 값들 정의하기
		self.name=name
		self.hp=hp

#공격 유닛
class AttackUnit(Unit): #Unit상속 받아서 만들어짐 -받는 건 보통 자식
	def __init__(self, name, hp, damage): #self는 자기 자신을 의미.클래스 내에서 메소드 앞에선 항상 self씀
		#self.name=name 상속 받으므로 쓸 필요 없엄
		#self.hp=hp 상속 받으므로 쓸 필요 없엄
		Unit.__init__(self, name, hp) #상속으로 위에 두줄 지우고 일케 상속 받아오기
		self.damage=damage

	def attack(self, location): #공격하는 함수
		print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 {2}]"\
			.format(self.name, location, self.damage)) #self.name과 damage는 위에서 전달받은 인자 쓴다는 의미 location은 바로위에서 전달받은거 사용

	def damaged(self, damage): #공격 받는 함수
		print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
		self.hp-=damage
		print("{0}: 현재 체력은 {1}입니다.".format(self.name, self.hp))
		if self.hp <=0:
			print("{0}: 파괴되었습니다.".format(self.name))

#드랍쉽 : 공중 유닛,  수송기, 마린/ 파이어뱃/탱크 등을 수송, 공격x

#날 수 있는 기능을 가진 클래스
class Flyable:
	def __init__(self, flying_speed):
		self.flying_speed=flying_speed

	def fly(self, name, location):
		print("{0} : {1} 방향으로 날아갑니다. [속도 {2}]"\
			.format(name, location, self.flying_speed))

# 공중 공격 유닛 클래스
class FlyableAttackUnit(AttackUnit, Flyable):
    def __init__(self, name, hp, damage, flying_speed):
        AttackUnit.__init__(self, name, hp, damage)
        Flyable.__init__(self, flying_speed)

# 발키리 : 공중 공격 유닛, 한 번에 14발 미사일 발사.
valkyrie = FlyableAttackUnit("발키리", 200, 6, 5)
valkyrie.fly(valkyrie.name, "3시")


#9-7 메소드 오버라이딩
#일반 유닛 부모
class Unit:
	def __init__(self, name, hp, speed): #필요한 값들 정의하기
		self.name=name
		self.hp=hp
		self.speed=speed

	def move(self, location):
		print("[지상 유닛 이동]")
		print("{0} : {1} 방향으로 이동합니다. [속도{2}]"\
			.format(self.name, location, self.speed))

#공격 유닛
class AttackUnit(Unit): #Unit상속 받아서 만들어짐 -받는 건 보통 자식
	def __init__(self, name, hp, speed , damage): #self는 자기 자신을 의미.클래스 내에서 메소드 앞에선 항상 self씀
		#self.name=name 상속 받으므로 쓸 필요 없엄
		#self.hp=hp 상속 받으므로 쓸 필요 없엄
		Unit.__init__(self, name, hp, speed) #상속으로 위에 두줄 지우고 일케 상속 받아오기
		self.damage=damage

	def attack(self, location): #공격하는 함수
		print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 {2}]"\
			.format(self.name, location, self.damage)) #self.name과 damage는 위에서 전달받은 인자 쓴다는 의미 location은 바로위에서 전달받은거 사용

	def damaged(self, damage): #공격 받는 함수
		print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
		self.hp-=damage
		print("{0}: 현재 체력은 {1}입니다.".format(self.name, self.hp))
		if self.hp <=0:
			print("{0}: 파괴되었습니다.".format(self.name))

#드랍쉽 : 공중 유닛,  수송기, 마린/ 파이어뱃/탱크 등을 수송, 공격x

#날 수 있는 기능을 가진 클래스
class Flyable:
	def __init__(self, flying_speed):
		self.flying_speed=flying_speed

	def fly(self, name, location):
		print("{0} : {1} 방향으로 날아갑니다. [속도 {2}]"\
			.format(name, location, self.flying_speed))

# 공중 공격 유닛 클래스
class FlyableAttackUnit(AttackUnit, Flyable):
    def __init__(self, name, hp, damage, flying_speed):
        AttackUnit.__init__(self, name, hp,0,damage) #지상 스피드는 0
        Flyable.__init__(self, flying_speed)

    def move(self, location):
        print("[공중 유닛 이동]")
        self.fly(self.name, location)

#벌쳐 : 지상 유닛, 기동성이 좋음
vulture = AttackUnit("벌쳐", 80, 10, 20)
#배틀 크루저: 공중 유닛, 체력도 굉장히 좋음, 공격력도 좋음
battlecruiser=FlyableAttackUnit("배틀크루저", 500, 25, 3)

vulture.move("11시")
#battlecruiser.fly(battlecruiser.name, "9시")
battlecruiser.move( "9시")

[지상 유닛 이동]
벌쳐 : 11시 방향으로 이동합니다. [속도10]
[공중 유닛 이동]
배틀크루저 : 9시 방향으로 날아갑니다. [속도 3]

#9-8 pass 아무것도 안하고 일단 넘어간다
#일반 유닛 부모
class Unit:
	def __init__(self, name, hp, speed): #필요한 값들 정의하기
		self.name=name
		self.hp=hp
		self.speed=speed

	def move(self, location):
		print("[지상 유닛 이동]")
		print("{0} : {1} 방향으로 이동합니다. [속도{2}]"\
			.format(self.name, location, self.speed))

#공격 유닛
class AttackUnit(Unit): #Unit상속 받아서 만들어짐 -받는 건 보통 자식
	def __init__(self, name, hp, speed , damage): #self는 자기 자신을 의미.클래스 내에서 메소드 앞에선 항상 self씀
		#self.name=name 상속 받으므로 쓸 필요 없엄
		#self.hp=hp 상속 받으므로 쓸 필요 없엄
		Unit.__init__(self, name, hp, speed) #상속으로 위에 두줄 지우고 일케 상속 받아오기
		self.damage=damage

	def attack(self, location): #공격하는 함수
		print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 {2}]"\
			.format(self.name, location, self.damage)) #self.name과 damage는 위에서 전달받은 인자 쓴다는 의미 location은 바로위에서 전달받은거 사용

	def damaged(self, damage): #공격 받는 함수
		print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
		self.hp-=damage
		print("{0}: 현재 체력은 {1}입니다.".format(self.name, self.hp))
		if self.hp <=0:
			print("{0}: 파괴되었습니다.".format(self.name))

#드랍쉽 : 공중 유닛,  수송기, 마린/ 파이어뱃/탱크 등을 수송, 공격x

#날 수 있는 기능을 가진 클래스
class Flyable:
	def __init__(self, flying_speed):
		self.flying_speed=flying_speed

	def fly(self, name, location):
		print("{0} : {1} 방향으로 날아갑니다. [속도 {2}]"\
			.format(name, location, self.flying_speed))

# 공중 공격 유닛 클래스
class FlyableAttackUnit(AttackUnit, Flyable):
    def __init__(self, name, hp, damage, flying_speed):
        AttackUnit.__init__(self, name, hp,0,damage) #지상 스피드는 0
        Flyable.__init__(self, flying_speed)

    def move(self, location):
        print("[공중 유닛 이동]")
        self.fly(self.name, location)

#건물
class BuildingUnit(Unit):
	def __init__(self, name, hp, location):
		pass

#서플라이 디폿 : 건물, 1개 건물 =8 유닛 생성 가능
supply_depot=BuildingUnit("서플라이 디폿", 500 , "7시")


def game_start():
	print("[알림] 새로운 게임을 시작합니다.")

def game_over():
	pass

game_start()
game_over()

class Unit:
	def __init__(self):
		print("Unit 생성자")

class Flyable:
	def __init__(self):
		print("Flyable 생성자")

class FlyableUnit(Unit, Flyable):
	def __init__(self):
		#super().__init__()  self 통해 다중상속 하면 맨 처음만 전달 됨..
		Unit.__init__(self)
		Flyable.__init__(self) #두번을 통해 상속 하세요... 그래야

# Unit 생성자
# Flyable 생성자 라는 두줄 결과 나옴니다

#드랍쉽
dropship = FlyableUnit()

#9-10 스타크래프트 전/반전 텍스트 기반으로 마치 겜하는거처럼!


#일반 유닛 부모
class Unit:
	def __init__(self, name, hp, speed): #필요한 값들 정의하기
		self.name=name
		self.hp=hp
		self.speed=speed
		print("{0} 유닛이 생성되었습니다.".format(name))

	def move(self, location):
		print("[지상 유닛 이동]")
		print("{0} : {1} 방향으로 이동합니다. [속도{2}]"\
			.format(self.name, location, self.speed))

	def damaged(self, damage): #공격 받는 함수
		print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
		self.hp-=damage
		print("{0}: 현재 체력은 {1}입니다.".format(self.name, self.hp))
		if self.hp <=0:
			print("{0}: 파괴되었습니다.".format(self.name))

#공격 유닛
class AttackUnit(Unit): #Unit상속 받아서 만들어짐 -받는 건 보통 자식
	def __init__(self, name, hp, speed , damage): #self는 자기 자신을 의미.클래스 내에서 메소드 앞에선 항상 self씀
		#self.name=name 상속 받으므로 쓸 필요 없엄
		#self.hp=hp 상속 받으므로 쓸 필요 없엄
		Unit.__init__(self, name, hp, speed) #상속으로 위에 두줄 지우고 일케 상속 받아오기
		self.damage=damage

	def attack(self, location): #공격하는 함수
		print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 {2}]"\
			.format(self.name, location, self.damage)) #self.name과 damage는 위에서 전달받은 인자 쓴다는 의미 location은 바로위에서 전달받은거 사용

#마린
class Marine(AttackUnit):
	def __init__(self):
		AttackUnit.__init__(self, "마린", 40, 1, 5)

	#스팀팩:일정 시간 동안 공격 속도 증가,  체력 10 감소
	def stimpack(self):
		if self.hp > 10:
			self.hp -=10
			print("{0} : 스팀팩을 사용합니다. (HP 10감소)".format(self.name))
		else:
			print("{0}: 체력이 부족하여 스팀팩을 사용하지 않습니다.".format(self.name))
#탱크
class Tank(AttackUnit):
	#시즈 모드 : 탱크를 지상에 고정시켜, 더 높은 파워로 공격 가능. 이동 불가
	seize_developed = False #시즈 모드 개발 여부

	def __init__(self):
		AttackUnit.__init__(self,"탱크", 150, 1, 35)
		self.seize_mode=False

	def set_seize_mode(self):
		if Tank.seize_developed==False:
			return

		#현재 시즈 모드가 아닐 때 -> 시즈모드
		if self.seize_mode ==False:
			print("{0}: 시즈모드로 전환합니다.".format(self.name))
			self.demage *=2
			self.seize_mode= True

		#현재 시즈 모드 일 떄 -> 시즈모드 해제
		else:
			print("{0}: 시즈모드를 해제합니다.".format(self.name))
			self.demage /=2
			self.seize_mode= False




#드랍쉽 : 공중 유닛,  수송기, 마린/ 파이어뱃/탱크 등을 수송, 공격x

#날 수 있는 기능을 가진 클래스
class Flyable:
	def __init__(self, flying_speed):
		self.flying_speed=flying_speed

	def fly(self, name, location):
		print("{0} : {1} 방향으로 날아갑니다. [속도 {2}]"\
			.format(name, location, self.flying_speed))

# 공중 공격 유닛 클래스
class FlyableAttackUnit(AttackUnit, Flyable):
    def __init__(self, name, hp, damage, flying_speed):
        AttackUnit.__init__(self, name, hp,0,damage) #지상 스피드는 0
        Flyable.__init__(self, flying_speed)

    def move(self, location):
        print("[공중 유닛 이동]")
        self.fly(self.name, location)

#레이스
class Wraith(FlyableAttackUnit):
	def __init__(self):
		FlyableAttackUnit.__init__(self, "레이스", 80, 20, 5)
		self.clocked=False #클로킹 모드(해제 상태)

	def clocking(self):
		if self.clocked==True #클로킹 모드->모드 해제
			print("{0} : 클로킹 모드 해제 합니다.".format(self.name))
			self.clocked=False
		else: #클로킹 모드 해제 -> 모드 설정
			print("{0}:클로킹 설정 합니다.".format(self.name))
			self.clocked=True

#9-11 스타크래프트 전/후반전 텍스트 기반으로 마치 겜하는거처럼!

from random import *

#일반 유닛 부모
class Unit:
	def __init__(self, name, hp, speed): #필요한 값들 정의하기
		self.name=name
		self.hp=hp
		self.speed=speed
		print("{0} 유닛이 생성되었습니다.".format(name))

	def move(self, location):
		#print("[지상 유닛 이동]")
		print("{0} : {1} 방향으로 이동합니다. [속도{2}]"\
			.format(self.name, location, self.speed))

	def damaged(self, damage): #공격 받는 함수
		print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
		self.hp-=damage
		print("{0}: 현재 체력은 {1}입니다.".format(self.name, self.hp))
		if self.hp <=0:
			print("{0}: 파괴되었습니다.".format(self.name))

#공격 유닛
class AttackUnit(Unit): #Unit상속 받아서 만들어짐 -받는 건 보통 자식
	def __init__(self, name, hp, speed , damage): #self는 자기 자신을 의미.클래스 내에서 메소드 앞에선 항상 self씀
		#self.name=name 상속 받으므로 쓸 필요 없엄
		#self.hp=hp 상속 받으므로 쓸 필요 없엄
		Unit.__init__(self, name, hp, speed) #상속으로 위에 두줄 지우고 일케 상속 받아오기
		self.damage=damage

	def attack(self, location): #공격하는 함수
		print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 {2}]"\
			.format(self.name, location, self.damage)) #self.name과 damage는 위에서 전달받은 인자 쓴다는 의미 location은 바로위에서 전달받은거 사용

#마린
class Marine(AttackUnit):
	def __init__(self):
		AttackUnit.__init__(self, "마린", 40, 1, 5)

	#스팀팩:일정 시간 동안 공격 속도 증가,  체력 10 감소
	def stimpack(self):
		if self.hp > 10:
			self.hp -=10
			print("{0} : 스팀팩을 사용합니다. (HP 10감소)".format(self.name))
		else:
			print("{0}: 체력이 부족하여 스팀팩을 사용하지 않습니다.".format(self.name))
#탱크
class Tank(AttackUnit):
	#시즈 모드 : 탱크를 지상에 고정시켜, 더 높은 파워로 공격 가능. 이동 불가
	seize_developed = False #시즈 모드 개발 여부
	demage=False

	def __init__(self):
		AttackUnit.__init__(self,"탱크", 150, 1, 35)
		self.seize_mode=False

	def set_seize_mode(self):
		if Tank.seize_developed==False:
			return

		#현재 시즈 모드가 아닐 때 -> 시즈모드
		if self.seize_mode ==False:
			print("{0}: 시즈모드로 전환합니다.".format(self.name))
			self.demage *=2
			self.seize_mode= True

		#현재 시즈 모드 일 떄 -> 시즈모드 해제
		else:
			print("{0}: 시즈모드를 해제합니다.".format(self.name))
			self.demage /=2
			self.seize_mode= False




#드랍쉽 : 공중 유닛,  수송기, 마린/ 파이어뱃/탱크 등을 수송, 공격x

#날 수 있는 기능을 가진 클래스
class Flyable:
	def __init__(self, flying_speed):
		self.flying_speed=flying_speed

	def fly(self, name, location):
		print("{0} : {1} 방향으로 날아갑니다. [속도 {2}]"\
			.format(name, location, self.flying_speed))

# 공중 공격 유닛 클래스
class FlyableAttackUnit(AttackUnit, Flyable):
    def __init__(self, name, hp, damage, flying_speed):
        AttackUnit.__init__(self, name, hp,0,damage) #지상 스피드는 0
        Flyable.__init__(self, flying_speed)

    def move(self, location):
        #print("[공중 유닛 이동]")
        self.fly(self.name, location)

# 레이스
class Wraith(FlyableAttackUnit):
    def __init__(self):
        FlyableAttackUnit.__init__(self, "레이스", 80, 20, 5)
        self.clocked = False # 클로킹 모드 (해제 상태)

    def clocking(self):
        if self.clocked == True: # 클로킹 모드 -> 모드 해제
            print("{0} : 클로킹 모드 해제합니다.".format(self.name))
            self.clocked = False
        else: # 클로킹 모드 해제 -> 모드 설정
            print("{0} : 클로킹 모드 설정합니다.".format(self.name))
            self.clocked = True

def game_start():
	print("[알림] 새로운 게임을 시작합니다.")
def game_over():
	print("Player:gg") #good game
	print("[Plyer]님이 게임에서 퇴장하셨습니다.")

#실제 게임 시작
game_start()

#마린 3마리 생성
m1 = Marine()
m2 = Marine()
m3 = Marine()

#탱그 2기 생성
t1 = Tank()
t2 = Tank()

#레이스 1기 생성
w1 = Wraith()

#유닛 일괄 관리(생성된 모든 유닛 append)
attack_units=[]
attack_units.append(m1)
attack_units.append(m2)
attack_units.append(m3)
attack_units.append(t1)
attack_units.append(t2)
attack_units.append(w1)

#전군 이동
for unit in attack_units:
	unit.move("1시")

#탱크 시즈모드 개발
Tank.seize_developed=True
print("[알림] 탱크 시즈모드 개발이 왼료되었습니다.")

#공격 모드 준비(마린 : 스팀팩, 탱크: 시즈모드, 레이스:클로킹)
for unit in attack_units:
	if isinstance(unit, Marine): #지금 만들어진 객체가 어떤 클래스의 인스턴스인지 확인
		#현재 유닛이 마린이면 스팀팩 쓴다.
		unit.stimpack()
	elif isinstance(unit, Tank):
		unit.set_seize_mode()
	elif isinstance(unit, Wraith):
		unit.clocking()

#전국 공격
for unit in attack_units:
	unit.attack("1시")

#전군 피해
for unit in attack_units:
	unit.damaged(randint(5, 20)) #공격은 랜덤으로 받음 (5~20)

#게임 종료
game_over()


[알림] 새로운 게임을 시작합니다.
마린 유닛이 생성되었습니다.
마린 유닛이 생성되었습니다.
마린 유닛이 생성되었습니다.
탱크 유닛이 생성되었습니다.
탱크 유닛이 생성되었습니다.
레이스 유닛이 생성되었습니다.
마린 : 1시 방향으로 이동합니다. [속도1]
마린 : 1시 방향으로 이동합니다. [속도1]
마린 : 1시 방향으로 이동합니다. [속도1]
탱크 : 1시 방향으로 이동합니다. [속도1]
탱크 : 1시 방향으로 이동합니다. [속도1]
레이스 : 1시 방향으로 날아갑니다. [속도 5]
[알림] 탱크 시즈모드 개발이 왼료되었습니다.
마린 : 스팀팩을 사용합니다. (HP 10감소)
마린 : 스팀팩을 사용합니다. (HP 10감소)
마린 : 스팀팩을 사용합니다. (HP 10감소)
탱크: 시즈모드로 전환합니다.
탱크: 시즈모드로 전환합니다.
레이스 : 클로킹 모드 설정합니다.
마린 : 1시 방향으로 적군을 공격합니다. [공격력 5]
마린 : 1시 방향으로 적군을 공격합니다. [공격력 5]
마린 : 1시 방향으로 적군을 공격합니다. [공격력 5]
탱크 : 1시 방향으로 적군을 공격합니다. [공격력 35]
탱크 : 1시 방향으로 적군을 공격합니다. [공격력 35]
레이스 : 1시 방향으로 적군을 공격합니다. [공격력 20]
마린 : 10 데미지를 입었습니다.
마린: 현재 체력은 20입니다.
마린 : 16 데미지를 입었습니다.
마린: 현재 체력은 14입니다.
마린 : 6 데미지를 입었습니다.
마린: 현재 체력은 24입니다.
탱크 : 9 데미지를 입었습니다.
탱크: 현재 체력은 141입니다.
탱크 : 9 데미지를 입었습니다.
탱크: 현재 체력은 141입니다.
레이스 : 5 데미지를 입었습니다.
레이스: 현재 체력은 75입니다.
Player:gg
[Plyer]님이 게임에서 퇴장하셨습니다.

#퀴즈 8

class House:
	#매물 초기화
	def __init__(self, location, house_type, deal_type, price, completion_year):
		self.location=location
		self.house_type=house_type
		self.deal_type=deal_type
		self.price=price
		self.completion_year=completion_year

	#매물 정보 표시
	def show_detail(self):
		 print(self.location, self.house_type, self.deal_type,self.price, self.completion_year)
		#틀린 나의 코드 print("{0} {1} {2} {3} {4}".format(self.location, self.house_type, self.deal_type,self.price, self.completion_year))

houses=[] #요거도 써줘야해
houses1 = House("강남", "아파트","매매" ,"10억", "2010년")
houses2 = House("마포", "오피스텔","전세" ,"5억", "2007년")
houses3 = House("송파", "빌라","월세", "500/50", "2000년")

houses.append(houses1)
houses.append(houses2)
houses.append(houses3)

print("총 {0}대의 매물이 있습니다.".format(len(houses)))
for house in houses:
	house.show_detail() #출력까지 하기 위해 필요한 구문.

#10-1 예외 처리

try:
	print("나누기 전용 계산기입니다.")
	nums=[]
	nums.append(int(input("첫 번째 숫자를 입력하세요: ")))
	nums.append(int(input("두 번째 숫자를 입력하세요: ")))
	#nums.appned(int(nums[0] / nums[1]))
	print("{0} / {1} = {2}".format(nums[0], nums[1], nums[2]))
except ValueError:
	print("에러! 잘못된 값을 입력했어요")
except ZeroDivisionError as err:
	print(err)
except Exception as err:
	print("알 수 없는 에러가 발생하였습니다. ")
	print(err)

	나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요: 6
두 번째 숫자를 입력하세요: 5
알 수 없는 에러가 발생하였습니다.
list index out of range



#10-2 에러 발생 시키기
#한자리만 나누기 허용하는 계산기

try:
	print("한 자리 숫자 나누기 전용 계산기입니다.")
	num1=int(input("첫 번째 숫자 입력하세요: "))
	num2=int(input("두 번째 숫자 입력하세요: "))
	if num1 >=10 or num2>=10:
		raise ValueError
	print("{0} / {1} = {2}".format(num1, num2, int(num1/num2)))
except ValueError:
	print("잘못된 값을 입력하였습니다. 한 자리 숫자만 입력하세요")

한 자리 숫자 나누기 전용 계산기입니다.
첫 번째 숫자 입력하세요: 6
두 번째 숫자 입력하세요: 3
6 / 3 = 2

한 자리 숫자 나누기 전용 계산기입니다.
첫 번째 숫자 입력하세요: 100
두 번째 숫자 입력하세요30
잘못된 값을 입력하였습니다. 한 자리 숫자만 입력하세요
#10-3 사용자 정의 예외 처리

class BigNumberError(Exception):
	def __init__(self, msg):
		self.msg=msg
	def __str__(self):
		return self.msg

try:
	print("한 자리 숫자 나누기 전용 계산기입니다.")
	num1=int(input("첫 번째 숫자 입력하세요: "))
	num2=int(input("두 번째 숫자 입력하세요: "))
	if num1 >=10 or num2>=10:
		raise BigNumberError("입력값 : {0}, {1}".format(num1, num2))
	print("{0} / {1} = {2}".format(num1, num2, int(num1/num2)))
except ValueError:
	print("잘못된 값을 입력하였습니다. 한 자리 숫자만 입력하세요")
except BigNumberError as err:
	print("에러 발생, 한 자리 숫자만 입력해")
	print(err)

한 자리 숫자 나누기 전용 계산기입니다.
첫 번째 숫자 입력하세요: 10
두 번째 숫자 입력하세요: 5
에러 발생, 한 자리 숫자만 입력해
입력값 : 10, 5
#10-4 finally
#정상이건 오류건 무조건 실행된다.

class BigNumberError(Exception):
	def __init__(self, msg):
		self.msg=msg
	def __str__(self):
		return self.msg

try:
	print("한 자리 숫자 나누기 전용 계산기입니다.")
	num1=int(input("첫 번째 숫자 입력하세요: "))
	num2=int(input("두 번째 숫자 입력하세요: "))
	if num1 >=10 or num2>=10:
		raise BigNumberError("입력값 : {0}, {1}".format(num1, num2))
	print("{0} / {1} = {2}".format(num1, num2, int(num1/num2)))
except ValueError:
	print("잘못된 값을 입력하였습니다. 한 자리 숫자만 입력하세요")
except BigNumberError as err:
	print("에러 발생, 한 자리 숫자만 입력해")
	print(err)

finally:
	print("계산기를 이용해 주셔서 감사합니다.")

# 한 자리 숫자 나누기 전용 계산기입니다.
# 첫 번째 숫자 입력하세요: 10
# 두 번째 숫자 입력하세요: 5
# 에러 발생, 한 자리 숫자만 입력해
# 입력값 : 10, 5
# 계산기를 이용해 주셔서 감사합니다.

# 조건1: 1보다 작거나 숫자 아닌경우 ValueError
#  출력 메시지 :  잘못된 값 입력했어요
# 조건2: 대기손님 주문 치킨량은 총 10마리로 한정
# 치킨 소진 시 사용자 정의 에러
# 출력 메시지 : 재고가 소진되어 더이상 주문 x

class SoldOutError(Exception):
    pass

chicken = 10
waiting = 1 # 홀 안에는 현재 만석, 대기번호 1부터 시작
while(True):
    try:
        print("[남은 치킨 : {0}]".format(chicken))
        order = int(input("치킨 몇 마리 주문하시겠습니까? "))
        if order > chicken: # 남은 치킨보다 주문량이 많을 때
            print("재료가 부족합니다.")
        elif order <= 0:
            raise ValueError
        else:
            print("[대기번호 {0}] {1}마리 주문이 완료되었습니다.".format(waiting, order))
            waiting += 1
            chicken -= order

        if chicken == 0:
            raise SoldOutError
    except ValueError:
        print("잘못된 값을 입력하였습니다.")
    except SoldOutError:
        print("재고가 소진되어 더 이상 주문을 받지 않습니다.")
        break

 

 

 

#theater_module.py

11-1 모듈
#일반 가격
def price(people) :
	print("{0}명 가격은  {1}원.".format(people, people * 10000))

#조조할인가격
def price_morning(people):
	print("{0}명 조조할인가격은 {1}원.".format(people, people * 6000))

#군인할인 가격
def price_soldier(people):
	print("{0}명 군인할인 가격 {1}원".format(people, people*4000))

import theater_module
theater_module.price(3) #3명이서 영화보러 갔을 때 가격
theater_module.price_morning(4) #4명 조조 할인 영화 보러갓을때
theater_module.price_soldier(5) #5명 군인이 영화보러갔을때

3명 가격은  30000원.
4명 조조할인가격은 24000원.
5명 군인할인 가격 20000원
import theater_module as mv #mv라고 별명주기
mv.price(3)
mv.price_morning(4)
mv.price_soldier(5)
from theater_module import *
#from random import *
price(3)
price_morning(4)
price_soldier(5)

from theater_module import price, price_morning
price(5)
price_morning(6)
# price_soldier(7)
# import theater_module
# theater_module.price(3) #3명이서 영화보러 갔을 때 가격
# theater_module.price_morning(4) #4명 조조 할인 영화 보러갓을때
# theater_module.price_soldier(5) #5명 군인이 영화보러갔을때

import theater_module as mv #mv라고 별명주기
mv.price(3)
mv.price_morning(4)
mv.price_soldier(5)

from theater_module import *
#from random import *
price(3)
price_morning(4)
price_soldier(5)

from theater_module import price, price_morning
price(5)
price_morning(6)
# price_soldier(7)

from theater_module import price_soldier as price
price(5)

 

 

# import travel.thailand
# import travel.thailand.ThailandPackage  사용 불가
trip_to=travel.thailand.ThailandPackage()
trip_to.detail()
from travel.thailand import ThailandPackage
trip_to=ThailandPackage()
trip_to.detail()

from travel import vietnam
trip_to=vietnam.VietnamPackage()
trip_to.detail()

11-3 __all__

travel 안에 thailand.py, vietnam.py, __init__.py

 

 

#11-3 __all__

from travel import *
trip_to=vietnam.VietnamPackage()
trip_to=thailand.VietnamPackage()
trip_to.detail()

--practice.py--
__all__ = ["vietnam","thailand"]

-- __init__.py --
class ThailandPackage:
	def detail(self):
		print("[태국 패키지 3박 5일] 방콕, 파타야 여행(야시장 투어) 50만원")

-- thailnad.py --
class VietnamPackage:
	def detail(self):
		print("[베트남 패키지 3박 5일] 다낭 효도 여행 60만원")

--vietnam.py--

11-4 모듈 직접 실행

class ThailandPackage:
	def detail(self):
		print("[태국 패키지 3박 5일] 방콕, 파타야 여행(야시장 투어) 50만원")

if __name__ =="__main__" :
	print("Thailand 모듈을 직접 실행")
	print("이 문장은 모듈을 직접 실행할 때만 실행돼요")
	trip_to=ThailandPackage()
	trip_to.detail()

else:
	print("Thailand외부에서 모듈 호출")

-- thailnad.py --

# --practice.py--

import inspect
import random
print(inspect.getfile(random))
#C:\Users\alswj\AppData\Local\Programs\Python\Python39\lib\random.py

print(inspect.getfile(thailand))

11-6 pip install

필요한 패키지 여기서 검색해보세요

pypi.org/

 

PyPI · The Python Package Index

The Python Package Index (PyPI) is a repository of software for the Python programming language.

pypi.org

터미널에서 pip install beautifulsoup4 입력하면 다운이 됨

 

pip show beautifulsoup4

 

-- beautifulsoup4 에 대한 정보

 

 

pip list

--리스트 

 

 pip install --upgrade beautifulsoup4

--업그레이드 하기

 

pip uninstall beautifulsoup4 

-삭제하기

 

 

 

11-7 내장함수

docs.python.org/3/library/functions.html

 

Built-in Functions — Python 3.9.2 documentation

Built-in Functions The Python interpreter has a number of functions and types built into it that are always available. They are listed here in alphabetical order. abs(x) Return the absolute value of a number. The argument may be an integer, a floating poin

docs.python.org

#11-7내장 함수
#따로 import 할 필요없이 사용 가능
#input : 사용자 입력을 받는 함수
# language=input("무슨 언어를 좋아하세요?")
# print("{0}은 아주 좋은 언어입니다!".format(language))
#dir : 어떤 객체를 넘겨줬을 때 그 객체가 어떤 변수와 함수를 가지고 있는지 표시


# print(dir())
import random #외장 함수
# print(dir())
# import pickle
# print(dir())

# print(dir(random))
# lst=[1,2,3]
# print(dir(lst))

name = "jim"
print(dir(name))

11- 8 외장함수

docs.python.org/3/py-modindex.html

 

Python Module Index — Python 3.9.2 documentation

numbers Numeric abstract base classes (Complex, Real, Integral, etc.).

docs.python.org

#11-8외장함수

#glob : 경로 내의 폴더 / 파일 목록 조회(윈도우 dir)

import glob
print(glob.glob("*.py")) #확장자가 py인 모든 파일

#os : 운영 체제에서 제공하는 기본 기능
import os
print(os.getcwd()) #현재 디렉토리

folder="sample_dir"
if os.path.exists(folder):
	print("이미 존재하는 폴더입니다.")
	os.rmdir(folder)
	print(folder,"폴더를 삭제하였습니다.")

else:
	os.makedirs(folder) #폴더 생성
	print(folder, "폴더를 생성하였습니다.")
print(os.listdir())

#time: 시간 관련 함수
import time
print(time.localtime())
print(time.strftime("%Y-%m-%d %H:%M:%S"))
#2021-04-01 00:25:52

import datetime
print("오늘 날짜는 " , datetime.date.today())

#timedelta : 두 날짜 사이의 간격
today=datetime.date.today() #오늘 날짜 저장
td=datetime.timedelta(days=100) #100일 저장
print("우리가 만난지 100일은 ", today+td) #오늘부터 100일 후

ㅁ

퀴즈

byme.py

def sign():
	print("이 프로그램은 나도코딩에 의해 만들어졌어요")
	print("유튜브 : http://youtube.com ")
	print("이메일 : dfasdf")

practice.py

import byme
byme.sign()

이 프로그램은 나도코딩에 의해 만들어졌어요
유튜브 : http://youtube.com
이메일 : dfasdf

ㅇ

'Programming > Python' 카테고리의 다른 글

파이썬 무료 강의 (활용편1) - 추억의 오락실 게임 만들기 (3시간)  (2) 2021.04.06
인프런 파이썬 강의3  (2) 2021.03.29
인프런 파이썬 공부2  (0) 2021.03.27
인프런 파이썬 강의  (1) 2021.03.27
[이코테]2. 그리디 & 구현  (0) 2021.01.14

'Programming/Python' Related Articles

티스토리툴바