先做一个案例：不利用反射，计算2个点之间的距离

import math

class Point():
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # 计算两点之间的直线距离
    def distance(self, other):
        return math.hypot(self.x - other.x, self.y - other.y)


if __name__ == '__main__':
    p1 = Point(2, 3)
    p2 = Point(0, 0)
    print(p1.distance(p2))

执行结果：3.6055512754639896

方法一： 利用反射，最简单的情况，可以使用 getattr()

动态编程才会用到反射

场景：假如原始的一个Point类中定义了distance方法，之后由于业务需求我又在类中又偷偷的定义了distance2方法，但是其他程序员不知道我做了什么改动，我直接告诉他函数名和函数实现的方法就可以了，当他调用类中的distance2方法时就不需要看代码逻辑了。

import math
class Point():
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # 计算两点之间的直线距离
    def distance(self, other):
        return math.hypot(self.x - other.x, self.y - other.y)

    # 计算两点之间的直线距离
    def distance2(self, other):      新加的方法
        return math.hypot(self.x - other.x, self.y - other.y)


调用任意对象中的任意函数
def method_call(o,method_name,args):
    return getattr(o,method_name)(args)


# todo 下面的代码早就写好了
if __name__ == '__main__':
    p1 = Point(2, 3)
    p2 = Point(0, 0)            #原点

    #动态编程才会用到反射
    print(method_call(p1,'distance2',p2))

方法二：利用反射，operator.methodcaller

methodcaller：返回一个在操作数上调用 name 方法的可调用对象。 如果给出额外的参数和/或关键字参数，它们也将被传给该方法。

import  math
import operator
class Point():

    def __init__(self, x, y):
        self.x = x
        self.y = y

    # 计算两点之间的直线距离
    def distance(self, other):
        return math.hypot(self.x - other.x, self.y - other.y)

    # 计算两点之间的直线距离
    def distance2(self, other):  # todo 新加的方法
        return math.hypot(self.x - other.x, self.y - other.y)

# todo 下面的代码早就写好了
if __name__ == '__main__':
    p1 = Point(2, 3)
    p2 = Point(0, 0)            #原点

    import operator
    print(operator.methodcaller('distance2',p2)(p1))