Python编程练习（六）：51 - 60

概述零基础入门学Python系列内容对应的所有编程练习题目→\rightarrow→Python编程练习题目汇总。编写程序：定义一个矩形类并生成类实例对象。classRectangle:length=5

零基础入门学Python系列内容对应的所有编程练习题目 → \rightarrow →Python编程练习题目汇总。

编写程序：定义一个矩形类并生成类实例对象。

class Rectangle:    length = 5    wIDth = 4    def setRect(self):        print("请输入矩形的长和宽")        self.length = float(input("长："))        self.wIDth = float(input("宽："))    def getRect(self):        print("这个矩形的长是：%.2f，宽是：%.2f" % (self.length, self.wIDth))    def getArea(self):        return self.length * self.wIDth

  >>>
  >>> rect = Rectangle()
  >>> rect.getRect()
  这个矩形的长是：5.00，宽是：4.00
  >>> rect.setRect()
  请输入矩形的长和宽
  长：3
  宽：2
  >>> rect.getRect()
  这个矩形的长是：3.00，宽是：2.00
  >>> rect.getArea()
  6.0
  >>>

编写程序：定义一个游乐园门票的类并计算票价。

# 按照以下要求定义一个游乐园门票的类，并尝试计算2个成人+1个小孩票价。# 平日票价100元# 周末票价为平日的120%# 儿童半票class Ticket:    def __init__(self,weekend=False,child=False):        self.price = 100        if weekend:            self.increase = 1.2        else:            self.increase = 1        if child:            self.discount = 0.5        else:            self.discount = 1    def calcPrice(self,num):        return self.price * self.increase * self.discount * numadult = Ticket()child  = Ticket(child=True)print("2个大人 + 1个小孩平日票价为：%.2f" % (adult.calcPrice(2) + child.calcPrice(1)))adult2 = Ticket(weekend=True)child2 = Ticket(weekend=True, child=True)print("2个大人 + 1个小孩周末票价为：%.2f" % (adult2.calcPrice(2) + child2.calcPrice(1)))

  >>>
  2个大人 + 1个小孩平日票价为：250.00
  2个大人 + 1个小孩周末票价为：300.00
  >>>

编写程序：定义一个点类和直线类并获得直线的长度。

#定义一个点（Point）类和直线（line）类，使用getLen方法可以获得直线的长度。#提示：#1.设点A(X1,Y1)、B(X2,Y2)，则两点构成的直线长度为|AB| = √(X1-X2)^2 + (Y1-Y2)^2#2.ython中计算开根号可使用math模块中的sqrt函数#3.直线需有两点构成，因此初始化时需要有两个点（Point）对象作为参数import mathclass Point():    def __init__(self, x=0, y=0):        self.x = x        self.y = y    def getX(self):        return self.x    def getY(self):        return self.yclass line():    def __init__(self, p1, p2):        self.x = p1.getX() - p2.getX()        self.y = p1.getY() - p2.getY()    def getLen(self):        self.len = math.sqrt(self.x * self.x + self.y * self.y)        return self.lenp1 = Point(1, 1)p2 = Point(4, 4)line = line(p1, p2)print(line.getLen())

  >>>
  4.242640687119285
  >>>

编写程序：定义一个栈（Stack）类，用于模拟一种具有后进先出（liFO）特征的数据结构。

# 定义一个栈（Stack）类，用于模拟一种具有后进先出（liFO）特征的数据结构。# 至少需要有以下办法：# 方法名 	含义# isEmpty() 	判断当前栈是否为空（返回True或False）# push() 	往栈的顶部压入一个数据项# pop() 	从栈顶d出一个数据项（并在栈中删除）# top() 	显示当前栈顶的一个数据项# bottom() 	显示当前栈底的一个数据项class Stack():    def __init__(self, start=[]):#1、为啥开始要赋值个start为空列表的默认值，而下面又用了个self.stack变量为空的列表？                                 #形参和实参的关系。定义类时start是形参，实例化之后self.stack就是实参了；                                 #因为是列表，下面 *** 作的一系列相关都是针对列表的 *** 作（增减），所以需要复制一份列表出来。                self.stack = []          #2、为啥要定义栈为空？                                 #因为一系列的增减都是针对列表的，当列表为空的时候，是没办法索引的。                for x in start:          #3、为啥要用个for循环？直接self.push(x)不行吗？            self.push(x)         #for循环是为了保证你实例化时传入非空列表进行迭代用。                                 #传入的实参分两种情况，一种是空列表【 】；一种是带元素的列表，如【1，2，3，4，5】。                                 #比如c=Stack([1,2,3,4,5]) print(c.stack)这一种情况想要压栈的话，就必须一个个压进去，for循环的作用就在这了。    def isEmpty(self):  # 判断是否为空        return not self.stack    def push(self, obj):  # 入栈        print("成功入栈数据：", obj)        self.stack.append(obj)    def pop(self):  # 出栈        if not self.stack:            print("警告：栈为空！")        else:            print("成功出栈数据：", self.stack[-1])            return self.stack.pop()    def top(self):  # 显示第一个栈顶数据        if not self.stack:            print("警告：栈为空！")        else:            print("栈顶数据为：", end="")            return self.stack[-1] #取出目前stack中最新的元素#index倒1，最后一位元素    def bottom(self):  # 显示栈底数据        if not self.stack:            print("警告：栈为空！")        else:            print("栈底数据为：", end="")            return self.stack[0]    def showStack(self): # 展示栈内的所有数据（自己附加上去的方法，为了方便看栈内还有哪些数据）        print("目前栈内的所有数据为：", end="")        return self.stack[:]s = Stack([])print('当前栈是否为空：', s.isEmpty())  # Trues.push('1')s.push('2')s.push('3')s.push('4')s.push('5')s.push('6')print(s.showStack())print(s.top())  # 栈顶是5s.pop()  # 5被d出，栈顶变成4print(s.showStack())print(s.top())print(s.bottom())

  >>>
  当前栈是否为空： True
  成功入栈数据： 1
  成功入栈数据： 2
  成功入栈数据： 3
  成功入栈数据： 4
  成功入栈数据： 5
  成功入栈数据： 6
  目前栈内的所有数据为：[‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’]
  栈顶数据为：6
  成功出栈数据： 6
  目前栈内的所有数据为：[‘1’, ‘2’, ‘3’, ‘4’, ‘5’]
  栈顶数据为：5
  栈底数据为：1
  >>>

编写程序：定义一个类实现摄氏度到华氏度的转换。

#定义一个类实现摄氏度到华氏度的转换（转换公式：华氏度=摄氏度*1.8+32）.class C2F(float):    "摄氏度转换为华氏度"    def __new__(cls, arg=0.0):        return float.__new__(cls, arg * 1.8 + 32)

  >>>
  >>> print(C2F(10))
  50
  >>>

编写程序：定义一个类继承于int类型，并当传入的参数是字符串的时候，返回该字符串中所有字符的ASCII码的和。

# 定义一个类继承于int类型，并实现一个特殊功能：当传入的参数是字符串的时候，返回该字符串中所有字符的ASCII码的和（使用ord()获取一个字符的ASCII码值）。class Nint(int):    def __new__(cls, arg=0):        if isinstance(arg, str):            total = 0            for each in arg:                total += ord(each)            arg = total        return int.__new__(cls, arg)

  >>>
  >>> print(Nint(123))
  123
  >>> print(Nint(1.5))
  1
  >>> print(Nint(‘A’))
  65
  >>> print(Nint(‘Python’))
  642
  >>>

编写程序：定义一个Nstr类，支持字符串的相减 *** 作：A - B，从A中去除所有B的子字符串。

# 定义一个Nstr类，支持字符串的相减 *** 作：A - B，从A中去除所有B的子字符串。class Nstr(str):    def __sub__(self,other):        return self.replace(other,'')

  >>>
  >>> a = Nstr(‘Hello, Python!’)
  >>> a = Nstr(‘Hello, Python!aaa’)
  >>> b = Nstr(‘a’)
  >>> a - b
  ‘Hello, Python!’
  >>>

编写程序：定义一个新的类Nstr，支持移位 *** 作符的运算。

# 移位 *** 作符是应用于二进制 *** 作数的，现在定义一个新的类Nstr，也支持移位 *** 作符的运算。class Nstr(str):    def __lshift__(self,other):        return self[other:] + self[:other] #0 1 2  3 ...    def __rshift__(self,other):        return self[-other:] + self[:-other]#... -3 -2 -1

  >>>
  >>> a = Nstr(‘Hello, Python!’)
  >>> a << 3
  ‘lo, Python!Hel’
  >>> a >> 3
  ‘on!Hello, Pyth’
  >>>

编写程序：定义一个类Nstr，当该类的实例对象间发生的加、减、乘、除运算时，将该对象的所有字符串的ASCII码之和进行运算。

# 定义一个类Nstr，当该类的实例对象间发生的加、减、乘、除运算时，将该对象的所有字符串的ASCII码之和进行运算。class Nstr(str):    def __init__(self,arg=''):        if isinstance(arg,str):            self.total = 0            for each in arg:                self.total += ord(each)        else:            print("参数错误")    def __add__(self,other):        return self.total + other.total    def __sub__(self,other):        return self.total - other.total    def __mul__(self,other):        return self.total * other.total    def __truediv__(self,other):        return self.total / other.total    def __floordiv__(self,other):        return self.total // other.total

  >>>
  >>> a = Nstr(‘Python’)
  >>> b = Nstr(‘Hello’)
  >>> a + b
  1142
  >>> a - b
  142
  >>> a * b
  321000
  >>> a / b
  1.284
  >>> a // b
  1
  >>>

编写程序：在继承的类中调用基类的方法(使用super()这个BIF函数)。

class A(object):    def __init__(self, a=0):        self.a = a    def get(self):        return self.aclass B(A):    def __init__(self, b):        super(B, self).__init__(b)    def get(self):        return super(B, self).get()if __name__ == '__main__':    b = B(10)    print(b.get())

  >>>
  10
  >>>

总结

以上是内存溢出为你收集整理的Python编程练习（六）：51 - 60全部内容，希望文章能够帮你解决Python编程练习（六）：51 - 60所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。