python——语言程序设计_梁勇第七章习题答案

#		Rectangle
#	width:float
#	height:float
#	Rectangle(width=1,height=2:float)
#	getArea():float
#	getPerimeter():float
#	setRectangle(width,weight:float):returnType
import math
class Rectangle:
	def __init__(self,width=1,height=2):
		self.width=width
		self.height=height
	def getPerrimeter(self):
		return 2*(self.width+self.height)
	def getArea(self):
		return self.width*self.height
	def setRectangle(self,Rectangle):
		self.Rectangle
		
from Rectangle import Rectangle
def main():
	rectangle1=Rectangle()
	print("The area of the rectangle of ",
			rectangle1.width,rectangle1.height,"is",rectangle1.getArea())
	rectangle2=Rectangle(2,4)
	print("The area of the rectangle of ",
			rectangle2.width,rectangle2.height,"is",rectangle2.getArea())
if __name__ == '__main__':
	main()
	

class Stock:
	def __init__(self,symbol="Default",name="Default",previusClosingPrince=1,
		currentPrice=1,ChangePercent=0):
			self.__symbol=symbol
			self.__name=name
			self.__previusClosingPrince=previusClosingPrince
			self.__currentPrice=currentPrice
			self.ChangePercent=ChangePercent
	def getname(self):
		return self.__name
	def getsymbol(self):
		return self.__symbol
	def getpreviusClosingPrince(self):
		return self.__previusClosingPrince
	def getcurrentPrice(self):
		return self.__currentPrice
	def getChangePercent(self):
		return self.__previusClosingPrince/self.__currentPrice
	def setpreviusClosingPrince(self,previousClosingPrince):
		self.__previusClosingPrince=previusClosingPrince
	def setcurrentPrice(self,currentPrice):
		self.__currentPrice=currentPrice

from Stock import Stock 
def main():
	stock=Stock(symbol=str(input("Enter the symbol of the stock: ")),
		name=str(input("Enter the name of the stock: ")),
		previusClosingPrince=20.5,
		currentPrice=20.35,ChangePercent=0)
	print("The Name of the stock is",stock.getname())
	print("The symbol of the stock is",stock.getsymbol())
	print("The currentPrice of the stock is",stock.getcurrentPrice())
	print("The previousPrice of the stock is",stock.getpreviusClosingPrince())
	print(stock.getChangePercent())
if __name__ == '__main__':
	main()
	

class Account:
	def __init__(self,id=0,balance=100,annualInterestRate=0,deposit=0,
			withdraw=0):
		self.__id=id
		self.__balance=balance
		self.__annualInterestRate=annualInterestRate
		self.__deposit=deposit
		self.__withdraw=withdraw
		
	def getid(self):
		return self.__id
	def getbalance(self):
		return self.__balance
	def getannualInterestRate(self):
		return self.__annualInterestRate
	def setid(self,id):
		self.__id=id
	def setbalance(self,balance):
		self.__balance=balance
	def setannualInterestRate(self,annualInterestRate):
		self.__annualInterestRate
	def getMonthlyInterestRate(self):
		MonthlyInterestRate=self.__annualInterestRate/12
		return MonthlyInterestRate
	def getMonthlyInterest(self):
		MonthlyInterest=self.__balance*self.__annualInterestRate/12
		return MonthlyInterest
	def getwithdraw(self):
		return self.__withdraw
	def getdeposit(self):
		return self.__deposit
	def getCurrentNumber(self):
		CurrentNumber=self.__deposit-self.__withdraw
		return CurrentNumber
from Account import Account
def main():
	account=Account(id=1122,balance=20000,annualInterestRate=0.0045,
	withdraw=2500,deposit=3000)
	
	print("ID number:",account.getid(),"Account Number:",account.getbalance()
	,"MonthlyInterestRate",account.getMonthlyInterestRate(),
	"MonthlyInterest",account.getMonthlyInterest(),
	"CurrentNumber",account.getbalance()+account.getCurrentNumber())

if __name__ == '__main__':
	main()
	

class Fan:
	def __init__(self,speed=0,radius=5,color='blue',on=False):
		self.__speed=speed
		self.__radius=radius
		self.__color=color
		self.__on=on
	def getspeed(self):
		if self.__speed==1:
			return 'SLOW'
		elif self.__speed==2:
			return 'MEDIUM'
		else:
			return 'FAST'
	def geton(self):
		if self.__on:
			return 'on'
		else:
			return 'off'
	def getradius(self):
		return self.__radius
	def getcolor(self):
		return self.__color
	def setspeed(self,speed):
		self.__speed=speed

	def seton(self,on):
		self.__on=on
	def setradius(self,radius):
		self.__radius=radius
	def setcolor(self,color):
		self.__color=color
from Fan import Fan
def main():
	fan1=Fan(speed=3,radius=10,color='yellow',on=True)
	
	fan2=Fan(speed=1,radius=5,color='blue',on=False)
	
	print("The Speed of the fan1 is",fan1.getspeed(),"Radius: ",
	fan1.getradius(),"color: ",fan1.getcolor(),"on/off:",fan1.geton(),
	end='\n',sep=' ')
	print("The Speed of the fan2 is",fan2.getspeed(),"Radius: ",
	fan2.getradius(),"color: ",fan2.getcolor(),"on/off:",fan2.geton(),
	end='\n',sep=' ')
	

if __name__ == '__main__':
	main()

import math
class RegularPolygon:
	def __init__(self,n=3,side=1,x=0,y=0):
		self.__n=n
		self.__side=side
		self.__x=x
		self.__y=y
	def getn(self):
		return self.__n
	def getside(self):
		return self.__side
	def getx(self):
		return self.__x
	def gety(self):
		return self.__y
	def setn(self,n):
		self.__n=n
	def setside(self,side):
		self.__side=side
	def setx(self,x):
		self.__x=x
	def sety(self,y):
		self.__y=y
	def getPerimeter(self):
		getPerimeter=self.__n*self.__side
		return getPerimeter
	def getArea(self):
		Area=(self.__n*self.__side**2)/(4*math.tan(math.pi/self.__n))
	
from RegularPolygon import RegularPolygon
def main():
	RP1=RegularPolygon()
	RP2=RegularPolygon(6,4)
	RP3=RegularPolygon(10,4,5.6,7.8)
	print("The ",RP1.getn(),"edge shape Area is",RP1.getArea())
	print("The ",RP1.getn(),"edge shape Primeter is",RP1.getPerimeter())
	print("The ",RP2.getn(),"edge shape Area is",RP2.getArea())
	print("The ",RP2.getn(),"edge shape Primeter is",RP2.getPerimeter())
	print("The ",RP3.getn(),"edge shape Area is",RP3.getArea())
	print("The ",RP3.getn(),"edge shape Primeter is",RP3.getPerimeter())
if __name__ == '__main__':
	main()

import math
class QuadraticEquation:
	def __init__(self,a=1,b=2,c=1):
		self.__a=a
		self.__b=b
		self.__c=c
	def geta(self):
		return self.__a
	def getb(self):
		return self.__b
	def getc(self):
		return self.__c
	def seta(self,a):
		self.__a=a
	def setb(self,b):
		self.__b=b
	def setc(self,c):
		self.__c=c
	def getDescriminant(self):
		return self.__b**2-4*self.__a*self.__c
	def getroot1(self):
		r1=(-self.__b+math.sqrt(self.__b**2-4*self.__a*self.__c))/2*self.__a
		return r1
	def getroot2(self):
		r2=(-self.__b-math.sqrt(self.__b**2-4*self.__a*self.__c))/2*self.__a
		return r2
from Sqrt import QuadraticEquation
def main():
	a,b,c=eval(input("Enter a,b,c: "))
	QE=QuadraticEquation(a,b,c)
	if QE.getDescriminant()>0:
		print("The roots are",QE.getroot1(),"and",QE.getroot2())
	elif QE.getDescriminant()==0:
		print("The root is",QE.getroot1())
	else:
		print("The equation has no real roots")
		
main()

class LinearEquation:
	def __init__(self,a,b,c,d,e,f):
		self.__a=a
		self.__b=b
		self.__c=c
		self.__d=d
		self.__e=e
		self.__f=f
	def geta(self):
		return self.__a
	def getb(self):
		return self.__b
	def getc(self):
		return self.__c
	def getd(self):
		return self.__d
	def gete(self):
		return self.__e
	def getf(self):
		return self.__f
	def seta(self,a):
		self.__a=a
	def setb(self,b):
		self.__b=b
	def setc(self,c):
		self.__c=c
	def setd(self,d):
		self.__d=d
	def sete(self,e):
		self.__b=b
	def setf(self,f):
		self.__f=f
	def isSolvable(self):
		if self.__a*self.__d-self.__b*self.__c!=0:
			return True
		else:
			return False
	def getX(self):
		X=(self.__e*self.__d-self.__b*self.__f)/(self.__a*self.__d-self.__b*self.__c)
		return X
	def getY(self):
		Y=(self.__a*self.__f-self.__e*self.__c)/(self.__a*self.__d-self.__b*self.__c)
		return Y
		
from LinearEquation import LinearEquation
def main():
	a,b,c,d,e,f=eval(input("Enter the LinearEquation's number: (5 Number)"))
	le=LinearEquation(a,b,c,d,e,f)
	if le.isSolvable()==True:
		print("X is: ",le.getX(),"and Y is:",le.getY())
	else:
		print("The equation has no solution")

main()

import time
class StopWatch:
	def __init__(self,startTime=0,stopTime=0):
		self.__startTime=startTime
		self.__stopTime=stopTime
	def getstartTime(self):
		return self.__startTime
	def getstopTime(self):
		return self.__stopTime
	def setstartTime(self,startTime):
		self.__startTime=startTime
	def setstopTime(self,stopTime):
		self.__stopTime=stopTime
	def getElapsedTime(self):
		start=time.time()
		for i in range(self.__startTime,self.__stopTime):
			pass
		stop=time.time()
		return (stop-start)*1000
from StopWatch import StopWatch
def main():
	a,b=eval(input("Enter the starttime and the stoptime: "))
	stopwatch=StopWatch(a,b)
	print(stopwatch.getElapsedTime())

main()

from LinearEquation import LinearEquation
def main():
	x1,y1,x2,y2=eval(input("Enter the endpoints of the first line segment: "))
	x3,y3,x4,y4=eval(input("Enter the endpoints of the second line segment:"))
	k1=(y2-y1)/(x2-x1)
	a=-k1
	b=1
	e=y1-k1*x1
	k2=(y4-y3)/(x4-x3)
	c=-k2
	d=1
	f=y3-y3*x3
	LE=LinearEquation(a,b,c,d,e,f)
	if LE.isSolvable():
		print("The intersecting point is: ","(",LE.getX(),",",LE.getY(),")")
		
main()

import time
class Time:
	def __init__(self,hour=0,minute=0,second=0):
		self.__hour=hour
		self.__minute=minute
		self.__second=second
	def gethour(self):
		return self.__hour
	def getminute(self):
		return self.__minute
	def getsecond(self):
		return self.__second
	def sethour(self,hour):
		self.__hour=hour
	def setminute(self,minute):
		self.__minute=minute
	def setscond(self,second):
		self.__second=second
	def getelapseTime(self):
		runTime=eval(input("Enter the elapsed time: "))
		Ts=int(runTime)
		Cs=Ts%60
		tM=Ts//60
		cM=tM%60
		tH=tM//60
		currentHour=tH%24
		self.__Hour=currentHour
		self.__minute=cM
		self.__second=Cs
		print("Current time is",self.__Hour,":",
		self.__minute,":",self.__second)
	def getCurrentTime(self):
		currentTime=time.time()
		totalSeconds=int(currentTime)
		currentSencond=totalSeconds%60
		totalMinutes=totalSeconds//60
		currentMinute=totalMinutes%60
		totalHours=totalMinutes//60+8
		currentHour=totalHours%24
		print("Current time is",currentHour,":",
		currentMinute,":",currentSencond)
		
from Time import Time 
def main():
	time=Time()
	print(time.getCurrentTime())
	print(time.getelapseTime())
main()