零基础入门学Python系列内容对应的所有编程练习题目 → \rightarrow →Python编程练习题目汇总。
- 编写程序：定义一个类，当实例化该类的时候，自动判断传入了多少个参数，并显示出来。
# 定义一个类，当实例化该类的时候，自动判断传入了多少个参数，并显示出来。
class C:
def __init__(self, *args):
if not args:
print("并没有传入参数")
else:
print("传入了%d个参数，分别是：" % len(args), end=' ')
for each in args:
print(each, end=' ')
>>>
>>> c = C()
并没有传入参数
>>> c = C(‘Python’)
传入了1个参数，分别是： Python
>>> c = C(‘Hello’,‘Python’)
传入了2个参数，分别是： Hello Python
>>>
- 编写程序：定义一个单词（Word）类继承自字符串，重写比较操作符，当两个Word类对象进行比较时，根据单词的长度来进行比较大小。
# 定义一个单词（Word）类继承自字符串，重写比较操作符，当两个Word类对象进行比较时，根据单词的长度来进行比较大小。
# 加分要求：实例化时如果传入的是带空格的字符串，则取第一个空格前的单词作为参数。
# 加分要求可以通过重载__ new__方法来实现（因为字符串是不可变类型），通过重写__ gt__、__ lt__、__ ge__、__ le__方法来定义Word类在比较操作中的表现。
class Word(str):
'''存储单词的类，定义比较单词的几种方法'''
def __new__(cls, word):
# 注意我们必须要用到__new__方法，因为str是不可变类型
# 所以我们必须在创建的时候将它初始化
if ' ' in word:
print("Value contains spaces. Truncating to first space.")
word = word[:word.index(' ')] # 单词是第一个空格之前的所有字符
return str.__new__(cls, word)
def __gt__(self, other):
return len(self) > len(other)
def __lt__(self, other):
return len(self) < len(other)
def __ge__(self, other):
return len(self) >= len(other)
def __le__(self, other):
return len(self) <= len(other)
w1 = Word('abcd')
w2 = Word('abca vsdv')
if w1 >= w2:
print(True)
else:
print(False)
>>>
Value contains spaces. Truncating to first space.
True
>>>
- 编写程序：定义一个定时器的类。
# 如果开始计时的时间为（2022年2月22日16:30:30），停止时间是（2025年1月23日15:30:30）
# 那按照我们用停止时间减去开始时间的计算方式就会出现负数，应该对此做一些转换。
import time as t
class MyTimer:
def __init__(self):
self.prompt = "未开始计时"
self.lasted = 0.0
self.begin = 0
self.end = 0
self.default_timer = t.perf_counter
def __str__(self):
return self.prompt
__repr__ = __str__
def __add__(self, other):
result = self.lasted + other.lasted
prompt = "总共运行了%0.2f秒" % result
return prompt
def start(self):
self.begin = self.default_timer()
self.prompt = "提示：请先调用stop()停止计时！"
print("计时开始！")
def stop(self):
if not self.begin:
print("提示：请先调用start()运行计时！")
else:
self.end = self.default_timer()
self._calc()
print("计时结束")
def _calc(self):
self.lasted = self.end - self.begin
self.prompt = "总共运行了%0.2f秒" % self.lasted
print(self.prompt)
self.begin = 0
self.end = 0
def set_timer(self, timer):
if timer == 'process_time':#perf_counter()返回计时器的精准时间（系统的运行时间）
self.default_timer = t.process_time
elif timer == 'perf_counter':#process_time()返回当前进程执行CPU的时间总和
self.default_timer = t.perf_counter
else:
print("输入无效")
>>>
>>> t1 = MyTimer()
>>> t1.start()
计时开始！
>>> t1.stop()
总共运行了5.02秒
计时结束
>>>
- 编写程序：定义一个Counter类，用于实时检测对象有多少个属性。
# 编写一个Counter类，用于实时检测对象有多少个属性
class Counter:
def __init__(self):
super().__setattr__('counter', 0)
def __setattr__(self, name, value):
super().__setattr__('counter', self.counter + 1)
super().__setattr__(name, value)
def __delattr__(self, name):
super().__setattr__('counter', self.counter - 1)
super().__delattr__(name)
>>>
>>> c = Counter()
>>> c.x = 1
>>> c.counter
1
>>> c.y = 1
>>> c.z = 1
>>> c.counter
3
>>> del c.x
>>> c.counter
2
>>>
- 编写程序：先定义一个温度类，再定义两个描述符类用于描述摄氏度和华氏度两个属性，两个属性能实现自动转化。
# 先定义一个温度类，再定义两个描述符类用于描述摄氏度和华氏度两个属性，两个属性会自动转化。
class Celsius:
def __init__(self,value = 26.0):
self.value = float(value)
def __get__(self,instance,owner):
return self.value
def __set__(self,instance,value):
self.value = float(value)
class Fahrenheit:
def __get__(self,instance,owner):
return instance.cel * 1.8 + 32
def __set__(self,instance,value):
instance.cel = (float(value) - 32) / 1.8
class Temperature:
cel = Celsius()
fah = Fahrenheit()
>>>
>>> t = Temperature()
>>> t.cel
26.0
>>> t.fah
78.80000000000001
>>>
- 编写程序：定义描述符MyDes，当类的属性被访问、修改或设置的时候，分别作出提醒。
# 编写描述符MyDes：当类的属性被访问、修改或设置的时候，分别作出提醒。
class MyDes:
def __init__(self, initval=None, name=None):
self.val = initval
self.name = name
def __get__(self, instance, owner):
print("正在获取变量：", self.name)
return self.val
def __set__(self, instance, value):
print("正在修改变量：", self.name)
self.val = value
def __delete__(self, instance):
print("正在删除变量：", self.name)
print("┗|｀O′|┛ 嗷~~这个变量没法删除~")
class Test:
x = MyDes(10,'x')
>>>
>>> t = Test()
>>> t.x
正在获取变量： x
10
>>> t.x = 8
正在修改变量： x
>>> del t.x
正在删除变量： x
┗|｀O′|┛ 嗷~~这个变量没法删除~
>>> t.x
正在获取变量： x
8
>>>
- 编写程序：定义描述符MyDes，记录指定变量的读取和写入操作，并将记录以及触发时间保存到文件。
# 编写描述符MyDes：记录指定变量的读取和写入操作，并将记录以及触发时间保存到文件。
import time
class Record:
def __init__(self, initval=None, name='x'):
self.val = initval
self.name = name
self.filename = "record.txt"
def __get__(self, instance, owner):
with open(self.filename, 'a', encoding='utf-8') as f:
f.write("%s 变量于北京时间 %s 被读取，%s = %s\n" % \
(self.name, time.ctime(), self.name, str(self.val)))
return self.val
def __set__(self, instance, value):
filename = "%s_record.txt" % self.name
with open(self.filename, 'a', encoding='utf-8') as f: #open(路径+文件名, 读写模式, 编码)a :追加
#将字符串以utf-8格式保存在txt文件中
f.write("%s 变量于北京时间 %s 被修改，%s = %s\n" % \
(self.name, time.ctime(), self.name, str(value)))
self.val = value
class Test:
x = Record(10,'x')
y = Record(8.8,'y')
>>>
>>> t = Test()
>>> t.x
10
>>> t.y
8.8
>>>
- 编写程序：定义描述符MyDes，使用文件来存储属性，属性的值会直接存储到对应的pickle的文件中。
# 描述符MyDes，使用文件来存储属性，属性的值会直接存储到对应的pickle的文件中。
# 如果属性被删除了，文件也会同时被删除，属性的名字也会被注销。
import os
import pickle
class MyDes:
saved = []
def __init__(self, name='11'):
self.name = name
self.filename = self.name + '.pkl'
def __get__(self, instance, owner):
if self.name not in MyDes.saved:
raise AttributeError("%s 属性还没有赋值！" % self.name)
with open(self.filename, 'rb') as f:
value = pickle.load(f)
return value
def __set__(self, instance, value):
with open(self.filename, 'wb') as f:
pickle.dump(value, f)
MyDes.saved.append(self.name)
def __delete__(self, instance):
os.remove(self.filename)
MyDes.saved.remove(self.name)
class Test:
x = MyDes('x')
y = MyDes('y')
>>>
>>> t = Test()
>>> t.x = 123
>>> t.y = “Hello, Python!”
>>> t.x
123
>>> t.y
‘Hello, Python!’
>>>
>>> del t.x
>>>
- 编写程序：定制一个列表，要求记录列表中每个元素被访问的次数，同时希望定制的列表能支持append()、pop()、extend()原生列表所拥有的方法。
# 定制一个列表，要求记录列表中每个元素被访问的次数，同时希望定制的列表能支持append()、pop()、extend()原生列表所拥有的方法。
#要求1：实现获取、设置和删除一个元素的行为（删除一个元素的时候对应的计数器也会被删除）
#要求2：增加counter(index)方法，返回index参数所指定的元素次数的访问次数
#要求3：实现append()、pop()、remove()、insert()、clear()和reverse()方法（重写这些方法时注意考虑计数器的对应改变）
class CountList(list):
def __init__(self, *args):
super().__init__(args)
self.count = []
for i in args:
self.count.append(0)
def __len__(self):
return len(self.count)
def __getitem__(self, key):
self.count[key] += 1
return super().__getitem__(key)
def __setitem__(self, key, value):
self.count[key] += 1
super().__setitem__(key, value)
def __delitem__(self, key):
del self.count[key]
super().__delitem__(key)
def counter(self, key): # 根据下标返回访问的次数#返回列表元素出现的次数
return self.count[key]
def append(self, value):#表示追加至列表结尾
self.count.append(0)
super().append(value)
def pop(self, key=-1):#默认后面删除，列表没有元素会报错
del self.count[key]
return super().pop(key)
def remove(self, value):#当列表出现多个相同的值时，删除第一个
key = super().index(value)
del self.count[key]
super().remove(value)
def insert(self, key, value):#指定位置插入元素
self.count.insert(key, 0)
super().insert(key, value)
def clear(self):#删除列表所有元素
self.count.clear()
super().clear()
def reverse(self):#是列表的内置方法，无参数，无返回值，会改变列表（原地反转）
self.count.reverse()
super().reverse()
>>>
>>> c1 = CountList(1, 2, 3, 4, 5, 6)
>>> c1[1]
2
>>> c1[1]
2
>>> c1[1]
2
>>> print(c1)
[1, 2, 3, 4, 5, 6]
>>> print(c1.count)
[0, 3, 0, 0, 0, 0]
>>> print(c1.counter(1))
3
>>> c1.append(99)
>>> print(c1)
[1, 2, 3, 4, 5, 6, 99]
>>> print(c1.count)
[0, 3, 0, 0, 0, 0, 0]
>>> c1.pop()
99
>>> print(c1)
[1, 2, 3, 4, 5, 6]
>>> print(c1.count)
[0, 3, 0, 0, 0, 0]
>>> c1.remove(5)
>>> print(c1)
[1, 2, 3, 4, 6]
>>> print(c1.count)
[0, 3, 0, 0, 0]
>>> c1.insert(2, 55)
>>> print(c1)
[1, 2, 55, 3, 4, 6]
>>> print(c1.count)
[0, 3, 0, 0, 0, 0]
>>> c1.reverse()
>>> print(c1)
[6, 4, 3, 55, 2, 1]
>>> print(c1.count)
[0, 0, 0, 0, 3, 0]
>>> c1.clear()
>>> print(c1)
[]
>>> print(c1.count)
[]
>>>
- 编写程序：写一个迭代器，要求输出2000至今的所有闰年。
# 写一个迭代器，要求输出至今为止的所有闰年
import datetime as dt
class LeapYear:
def __init__(self):
self.now = dt.date.today().year #返回一个表示当前本地日期的date对象
def isLeapYear(self, year):
if (year%4 == 0 and year%100 != 0) or (year%400 == 0):
return True
else:
return False
def __iter__(self):
return self
def __next__(self):
while not self.isLeapYear(self.now):
self.now -= 1
temp = self.now
self.now -= 1
return temp
ly = LeapYear()
for i in ly:
if i > 2000:
print(i)
else:
break
>>>
2020
2016
2012
2008
2004
>>>