零基础入门学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 * num
adult = 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 math
class 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.y
class 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.len
p1 = 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() 从栈顶弹出一个数据项（并在栈中删除）
# 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()) # True
s.push('1')
s.push('2')
s.push('3')
s.push('4')
s.push('5')
s.push('6')
print(s.showStack())
print(s.top()) # 栈顶是5
s.pop() # 5被弹出，栈顶变成4
print(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.a
class 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
>>>