除了这里所有令人惊叹的答案之外，还有一种方法可以使用getattr来节省大量代码行并保持舒适。这种想法源于代码的可怕表示，有时可能是必要的。

场景

假设你的目录结构如下:

- superheroes.py
- properties.py

你可以在superheroes。py中获得关于雷神，钢铁侠，奇异博士的信息。你很聪明地在一个紧凑字典的properties.py中写下它们的所有属性，然后访问它们。

properties.py

thor = {
    'about': 'Asgardian god of thunder',
    'weapon': 'Mjolnir',
    'powers': ['invulnerability', 'keen senses', 'vortex breath'], # and many more
}
iron_man = {
    'about': 'A wealthy American business magnate, playboy, and ingenious scientist',
    'weapon': 'Armor',
    'powers': ['intellect', 'armor suit', 'interface with wireless connections', 'money'],
}
doctor_strange = {
    'about': ' primary protector of Earth against magical and mystical threats',
    'weapon': 'Magic',
    'powers': ['magic', 'intellect', 'martial arts'],
}

现在，假设您希望在superheroes.py中按需返回它们各自的能力。有这样的函数

from .properties import thor, iron_man, doctor_strange


def get_thor_weapon():
    return thor['weapon']


def get_iron_man_bio():
    return iron_man['about']


def get_thor_powers():
    return thor['powers']

.．.以及更多基于键和超级英雄返回不同值的函数。

在getattr的帮助下，你可以这样做:

from . import properties


def get_superhero_weapon(hero):
    superhero = getattr(properties, hero)
    return superhero['weapon']


def get_superhero_powers(hero):
    superhero = getattr(properties, hero)
    return superhero['powers']

你大大减少了代码行数、函数和重复!

哦，当然，如果你的变量有像properties_of_thor这样的坏名字，它们可以通过简单的操作来创建和访问

def get_superhero_weapon(hero):
    superhero = 'properties_of_{}'.format(hero)
    all_properties = getattr(properties, superhero)
    return all_properties['weapon']

注意:对于这个特殊的问题，可以有更聪明的方法来处理这种情况，但是我们的想法是在正确的地方使用getattr来编写更清晰的代码。

getattr()在Python中实现switch语句的另一种用法。它使用两个反射来获取大小写类型。

import sys

class SwitchStatement(object):
    """ a class to implement switch statement and a way to show how to use gettattr in Pythion"""

    def case_1(self):
        return "value for case_1"

    def case_2(self):
        return "value for case_2"

    def case_3(self):
        return "value for case_3"

    def case_4(self):
        return "value for case_4"

    def case_value(self, case_type=1):
        """This is the main dispatchmethod, that uses gettattr"""
        case_method = 'case_' + str(case_type)
        # fetch the relevant method name
        # Get the method from 'self'. Default to a lambda.
        method = getattr(self, case_method, lambda: "Invalid case type")
        # Call the method as we return it
        return method()

def main(_):
    switch = SwitchStatement()
    print swtich.case_value(_)

if __name__ == '__main__':
    main(int(sys.argv[1]))

# getattr

class hithere():

    def french(self):
        print 'bonjour'

    def english(self):
        print 'hello'

    def german(self):
        print 'hallo'

    def czech(self):
        print 'ahoj'

    def noidea(self):
        print 'unknown language'


def dispatch(language):
    try:
        getattr(hithere(),language)()
    except:
        getattr(hithere(),'noidea')()
        # note, do better error handling than this

dispatch('french')
dispatch('english')
dispatch('german')
dispatch('czech')
dispatch('spanish')

setattr ()

我们使用setattr向类实例添加一个属性。我们传递类实例、属性名和值。

getattr ()

使用getattr可以检索这些值

例如

Employee = type("Employee", (object,), dict())

employee = Employee()

# Set salary to 1000
setattr(employee,"salary", 1000 )

# Get the Salary
value = getattr(employee, "salary")

print(value)

getattr的一个非常常见的用例是将数据映射到函数。

例如，在Django或Pylons这样的web框架中，getattr可以直接将web请求的URL映射到将要处理它的函数。例如，如果你看一下Pylons的路由，你会发现(至少在默认情况下)它分割了一个请求的URL，比如:

http://www.example.com/customers/list

分为“客户”和“列表”。然后它搜索名为CustomerController的控制器类。假设它找到该类，它创建该类的实例，然后使用getattr获取其list方法。然后调用该方法，将请求作为参数传递给它。

一旦你掌握了这个思想，扩展web应用程序的功能就变得非常容易:只需向控制器类添加新的方法，然后在页面中创建链接，为这些方法使用适当的url。所有这些都是由getattr实现的。

我有时使用getattr(..)在代码中使用属性之前惰性地初始化次要属性。

比较以下内容:

class Graph(object):
    def __init__(self):
        self.n_calls_to_plot = 0

    #...
    #A lot of code here
    #...

    def plot(self):
        self.n_calls_to_plot += 1

:

class Graph(object):
    def plot(self):
        self.n_calls_to_plot = 1 + getattr(self, "n_calls_to_plot", 0)

The advantage of the second way is that n_calls_to_plot only appears around the place in the code where it is used. This is good for readability, because (1) you can immediately see what value it starts with when reading how it's used, (2) it doesn't introduce a distraction into the __init__(..) method, which ideally should be about the conceptual state of the class, rather than some utility counter that is only used by one of the function's methods for technical reasons, such as optimisation, and has nothing to do with the meaning of the object.