Python面向对象的程序设计详情

1. 设计一个圆类,包括圆心位置、半径、颜色等属性。编写构造方法, 计算周长和面积。

import math
class circle:
    def __init__(self,o,r,colour):
        self.o = o
        self.r = r
        self.colour = colour
    def length(self): #周长
        c = math.pi*self.r*2
        return c
    def area(self):   #面积
        s = math.pi*self.r**2
        return s
 
if __name__ == "__main__":
    r=eval(input("请输入半径："))
    circle = circle((0,0),r,'blue') #坐标、半径、颜色
    c = circle.length()
    s = circle.area()
    print('圆周长为：{:.2f}'.format(c))
    print('圆面积为：{:.2f}'.format(s))

 2. 设计一个描述*落体运动的类，要求能获得任意时刻的速度及位移，并进行测试。已知重力加速度为 9.8m/s。

class free:
    def __init__(self,t): 
        self.t = t
    def getv(self): #速度函数
        v=9.8*self.t
        return v
    def getx(self): #位移函数
        x=0.5*9.8*self.t**2
        return x
    
if __name__ == "__main__":
    t=eval(input("请输入时刻t："))
    f=free(t) #调用
    print("t={} 时刻的".format(t),end='')
    print("速度为:{:.2f}".format(f.getv()))
    print("t={} 时刻的".format(t),end='')
    print("位移为:{:.2f}".format(f.getx()))

3. 为二次方程式 ax²+bx+c=0 设计一个名为 equation 的类，这个类包括:

• 代表 3 个系数的成员变量 a、b、c;
• 一个参数为 a、b、c 的构造方法;
• 一个名为 getdiscriminant1 的方法返回判别式的值;
• 一个名为 getroot1 和 getroot2 的方法返回等式的两个根, 如果判别式为负,这些方法返回0。

import math
class equation:
    def __init__(self,a,b,c):
        self.a = a
        self.b = b
        self.c = c
    def getdiscriminant1(self):  #判别式
        d=(self.b)**2 -(4*self.a*self.c)
        return d
    def getroot1(self):
        if self.getdiscriminant1()>=0:
            x1=(-self.b+math.sqrt(self.getdiscriminant1()))/2*self.a
            return x1
        else:
            return 0
    def getroot2(self):
        if self.getdiscriminant1()>=0:
            x2=(-self.b+math.sqrt(self.getdiscriminant1()))/2*self.a
            return x2
        else:
            return 0
    
if __name__ == "__main__":
    a=eval(input("请输入系数a："))
    b=eval(input("请输入系数b："))
    c=eval(input("请输入系数c："))
    f=equation(a,b,c)
    print("判别式：",f.getdiscriminant1())
    print("根1：",f.getroot1())
    print("根2：",f.getroot2())

4. 设计一个二维向量类，实现向量的加法、减法及向量与标量的乘法和除法运算，其中要求输入是元组。

class vector: 
    def __init__(self,a,b):
        self.a = a
        self.b = b
    def jia(self):
        c1 = (self.a[0] + self.b[0])
        c2 = (self.a[1] + self.b[1])
        return (c1,c2)
    def jian(self):
        c1 = (self.a[0] - self.b[0])
        c2 = (self.a[1] - self.b[1])
        return (c1,c2)
    def diancheng(self):
        c1 = (self.a[0] * self.b[0])
        c2 = (self.a[1] * self.b[1])
        return c1+c2
    #向量无除法
    
if __name__ == "__main__":
    a=eval(input("请输入向量a："))
    b=eval(input("请输入向量b："))
    f=vector(a,b)
    print("  加：",f.jia())
    print("  减：",f.jian())
    print("点乘：",f.diancheng())

 5. 设计一个课程类,包括课程编号、课程名称、任课教师、上课地点 等属性,把上课地点变量设为私有的,增加构造方法和显示课程信息的方法。

class course: 
    def __init__(self,cno,cname,teacher,local):
        self.cno = cno
        self.cname = cname
        self.teacher = teacher
        self.__local =local #把上课地点变量设为私有的
    def information(self):
        print("课程编号:",self.cno)
        print("课程名称:",self.cname)
        print("任课教师:",self.teacher)
        print("上课地点:",self.__local)
 
if __name__ == "__main__":
    f=course('no.','what','who','where')
    f.information()

6. 设计一个整形数组的封装类,要求实现下列功能:

• 显示全部数组数据
• 显示从某位置开始的一段连续数组数据。

import random
class list:
    def __init__(self,lis):
        self.__lis=lis
    def quanbu(self):     #全部数组数据
        return self.__lis
    def bufen(self,id):   #从部分位置开始的一段连续数组数据
        return self.__lis[id:]
 
f=list([random.randint(1,51) for i in range(20)])  #设置数组为20个1-50的随机数组合
print("显示全部数组数据:",f.quanbu())  
random_index = random.randint(0,21)  #随机选取从某一位置开始的索引号
print("显示从<第{}>位置开始的一段连续数组数据:".format(random_index),f.bufen(random_index))

到此这篇关于python面向对象的程序设计详情的文章就介绍到这了,更多相关python面向对象的程序设计内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！