面向对象——异常处理

Dataset

本文的数据集是关于研究人员对筷子不同长度的舒适度体验信息：

• Food pinching efficiency：十进制数，值越高，表示筷子越好。（夹食物效率越好）
• Individual：独一无二的标识，标识使用这个筷子的人
• Chopstick length：毫米

Organizing Our Code

• 创建一个记录对象，每一个对象代表这个实验记录：

# Define the Trial class here
class Trial(object):
    def __init__(self, datarow):
        self.efficiency = float(datarow[0])
        self.individual = int(datarow[1])
        self.chopstick_length = int(datarow[2])
first_trial = Trial(chopsticks[0])

The Chopstick Class

• 创建一个筷子类，包含了一个筷子长度属性：

class Chopstick(object):
    def __init__(self, length):
        self.length = length
mini_chopstick = Chopstick(100)

Storing The Trials

• 在筷子类中创建一个新的属性：记录列表。将筷子长度相同的记录都存储在这个列表中。

class Trial(object):
    def __init__(self, datarow):
        self.efficiency = float(datarow[0])
        self.individual = int(datarow[1])
        self.chopstick_length = int(datarow[2])
class Chopstick(object):
    def __init__(self, length):
        self.length = length
        self.trials = []
        for row in chopsticks:
            if int(row[2]) == self.length:
                self.trials.append(Trial(row))        
medium_chopstick = Chopstick(240)

Average Efficiency

• 然后计算每个长度的筷子的平均效率：

class Trial(object):
    def __init__(self, datarow):
        self.efficiency = float(datarow[0])
        self.individual = int(datarow[1])
        self.chopstick_length = int(datarow[2])
class Chopstick(object):
    def __init__(self, length):
        self.length = length
        self.trials = []
        for row in chopsticks:
            if int(row[2]) == self.length:
                self.trials.append(Trial(row))
    def num_trials(self):
        return len(self.trials)
    def avg_efficiency(self):
        efficiency_sum = 0
        for trial in self.trials:
            efficiency_sum += trial.efficiency
        return efficiency_sum / self.num_trials()
avg_eff_210 = Chopstick(210).avg_efficiency()

Exceptions

异常处理：程序的异常信息是对程序执行错误的一个宽泛的描述。异常出现在程序运行过程中，比如一个语句是对的出发操作，但是执行过程中除以了0就会出现异常。而单纯的语法错误通常是因为忘记一个冒号等。

• 由于我们的数据集可能有缺失值等，因此需要进行异常处理。

class Trial(object):
    def __init__(self, datarow):
        try:
            self.efficiency = float(datarow[0])
            self.individual = int(datarow[1])
            self.chopstick_length = int(datarow[2])
        except ValueError:
            self.efficiency = -1.0
            self.individual = -1
            self.chopstick_length = -1
'''
最后一行数据： ['Not a float', 'Individual', 'Length']]
'''
bad_trial = Trial(chopsticks[-1])

• 调整了异常数据的处理后，也需要对记录做一个修改，将不正确的记录剔除掉。其实也可以不用调整，因为这个长度不可能是-1，只要创建筷子时不将长度设置为-1就行。

class Trial(object):
    def __init__(self, datarow):
        try:
            self.efficiency = float(datarow[0])
            self.individual = int(datarow[1])
            self.chopstick_length = int(datarow[2])
        except:
            self.efficiency = -1
            self.individual = -1
            self.chopstick_length = -1
class Chopstick(object):
    def __init__(self, length):
        self.length = length
        self.trials = []
        for row in chopsticks:
            if int(row[2]) == self.length:
                trial = Trial(row)
                # Verify that the data is good
                if trial.efficiency != -1 and trial.individual != -1 and trial.chopstick_length != -1:
                    # Add the trial to trials if it is good
                    self.trials.append(trial)
    def num_trials(self):
        return len(self.trials)
    def avg_efficiency(self):
        efficiency_sum = 0
        for trial in self.trials:
            efficiency_sum += trial.efficiency
        return efficiency_sum / self.num_trials()

bad_chopstick = Chopstick(400)

Division By Zero

• 养成一个好习惯，在进行除法操作时必须要进行异常处理操作：

class Trial(object):
    def __init__(self, datarow):
        try:
            self.efficiency = float(datarow[0])
            self.individual = int(datarow[1])
            self.chopstick_length = int(datarow[2])
        except:
            self.efficiency = -1
            self.individual = -1
            self.chopstick_length = -1
class Chopstick(object):
    def __init__(self, length):
        self.length = length
        self.trials = []
        for row in chopsticks:
            if int(row[2]) == self.length:
                trial = Trial(row)
                if trial.individual >= 0:
                    self.trials.append(trial)
    def num_trials(self):
        return len(self.trials)
    def avg_efficiency(self):
        efficiency_sum = 0
        for trial in self.trials:
            efficiency_sum += trial.efficiency
        try:
            return efficiency_sum / self.num_trials()
        except ZeroDivisionError:
            return -1.0
bad_average = Chopstick(100).avg_efficiency()

Most Efficient Chopsticks

• 找到效率最高的筷子的长度，由于这是在对象之间进行比较，因此要采用上一篇的操作符重载方法：

class Trial(object):
    def __init__(self, datarow):
        try:
            self.efficiency = float(datarow[0])
            self.individual = int(datarow[1])
            self.chopstick_length = int(datarow[2])
        except:
            self.efficiency = -1
            self.individual = -1
            self.chopstick_length = -1
class Chopstick(object):
    def __init__(self, length):
        self.length = length
        self.trials = []
        for row in chopsticks:
            if int(row[2]) == self.length:
                trial = Trial(row)
                if trial.individual >= 0:
                    self.trials.append(trial)
    def num_trials(self):
        return len(self.trials)
    def avg_efficiency(self):
        efficiency_sum = 0
        for trial in self.trials:
            efficiency_sum += trial.efficiency
        try:
            return efficiency_sum / self.num_trials()
        except ZeroDivisionError:
            return -1.0
    def __lt__(self, other):
        return self.avg_efficiency() < other.avg_efficiency()
    def __gt__(self, other):
        return self.avg_efficiency() > other.avg_efficiency()
    def __le__(self, other):
        return self.avg_efficiency() <= other.avg_efficiency()
    def __ge__(self, other):
        return self.avg_efficiency() >= other.avg_efficiency()
    def __eq__(self, other):
        return self.avg_efficiency() == other.avg_efficiency()
    def __ne__(self, other):
        return self.avg_efficiency() != other.avg_efficiency()
chopstick_lengths = [180, 195, 210, 225, 240, 255, 270, 285, 300, 315, 330]    
chopstick_list = [Chopstick(length) for length in chopstick_lengths]
most_efficient = max(chopstick_list)