Python编程练习（七）：61 - 70

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

61. 编写程序：定义一个类，当实例化该类的时候，自动判断传入了多少个参数，并显示出来。

# 定义一个类，当实例化该类的时候，自动判断传入了多少个参数，并显示出来。

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
  >>>

62. 编写程序：定义一个单词（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
  >>>

63. 编写程序：定义一个定时器的类。

# 如果开始计时的时间为（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秒
  计时结束
  >>>

64. 编写程序：定义一个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
  >>>

65. 编写程序：先定义一个温度类，再定义两个描述符类用于描述摄氏度和华氏度两个属性，两个属性能实现自动转化。

# 先定义一个温度类，再定义两个描述符类用于描述摄氏度和华氏度两个属性，两个属性会自动转化。

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
  >>>

66. 编写程序：定义描述符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
  >>>

67. 编写程序：定义描述符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
  >>>

68. 编写程序：定义描述符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
  >>>

69. 编写程序：定制一个列表，要求记录列表中每个元素被访问的次数，同时希望定制的列表能支持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)
  []
  >>>

70. 编写程序：写一个迭代器，要求输出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
  >>>