Qu'est-ce que getattr() exactement et comment puis-je l'utiliser?

Objets en Python peuvent avoir des attributs -- données d'attributs et de fonctions pour travailler avec ceux (les méthodes). En fait, chaque objet a intégré dans les attributs.

Par exemple, vous avez un objet person, qui possède plusieurs attributs: name, gender, etc.

Vous accéder à ces attributs (que ce soit des méthodes ou des objets de données), généralement écrit: person.name, person.gender, person.the_method(), etc.

Mais que faire si vous ne connaissez pas le nom de l'attribut à la fois que vous écrivez le programme? Par exemple, vous avez de l'attribut nom stocké dans une variable appelée attr_name.

si

attr_name = 'gender'

alors, au lieu d'écrire

gender = person.gender

vous pouvez écrire

gender = getattr(person, attr_name)

Un peu de pratique:

Python 3.4.0 (default, Apr 11 2014, 13:05:11)

>>> class Person():
...     name = 'Victor'
...     def say(self, what):
...         print(self.name, what)
... 
>>> getattr(Person, 'name')
'Victor'
>>> attr_name = 'name'
>>> person = Person()
>>> getattr(person, attr_name)
'Victor'
>>> getattr(person, 'say')('Hello')
Victor Hello

getattr va augmenter AttributeError si l'attribut avec le nom donné n'existe pas dans l'objet:

>>> getattr(person, 'age')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Person' object has no attribute 'age'

Mais vous pouvez passer une valeur par défaut en tant que troisième argument, qui sera restituée si tel attribut n'existe pas:

>>> getattr(person, 'age', 0)
0

Vous pouvez utiliser getattr avec dir pour itérer sur tous les noms d'attribut et d'obtenir leurs valeurs:

>>> dir(1000)
['__abs__', '__add__', ..., '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

>>> obj = 1000
>>> for attr_name in dir(obj):
...     attr_value = getattr(obj, attr_name)
...     print(attr_name, attr_value, callable(attr_value))
... 
__abs__ <method-wrapper '__abs__' of int object at 0x7f4e927c2f90> True
...
bit_length <built-in method bit_length of int object at 0x7f4e927c2f90> True
...

>>> getattr(1000, 'bit_length')()
10

Une utilisation pratique pour ce serait de trouver toutes les méthodes dont le nom commence par test et appeler.

Similaire à getattr il est setattr qui vous permet de définir un attribut d'un objet ayant son nom:

>>> setattr(person, 'name', 'Andrew')
>>> person.name  # accessing instance attribute
'Andrew'
>>> Person.name  # accessing class attribute
'Victor'
>>>

Un assez commun en cas d'utilisation de getattr est la cartographie de données pour les fonctions.

Par exemple, dans un framework web comme Django ou des Pylônes, getattr fait, il est aisé de carte une requête web de l'URL à la fonction qui va gérer. Si vous regardez sous le capot de Pylônes de routage, par exemple, vous verrez que (par défaut, au moins), il côtelettes d'une demande de l'URL, comme:

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

en "clients" et "liste". Ensuite, il recherche un contrôleur de classe nommée CustomerController. S'il trouve la classe, il crée une instance de la classe, puis utilise getattr pour obtenir son list méthode. Il appelle ensuite la méthode, en lui transmettant la demande comme un argument.

Une fois que vous comprendre cette idée, il devient très facile d'étendre les fonctionnalités d'une application web: il suffit d'ajouter de nouvelles méthodes pour les classes de contrôleur, puis de créer des liens dans vos pages qui utilisent l'Url de ces méthodes. Tout cela est rendu possible par getattr.

À l'exclusion de tous les étonnantes réponses ici, il y a un moyen d'utiliser getattr pour enregistrer copieux lignes de code et de le garder bien en place. Cette pensée m'est venue à la suite de la terrible représentation de code qui pourrait parfois être une nécessité.

Scénario

Supposons que votre structure de répertoire est comme suit:

- superheroes.py
- properties.py

Et, vous avez des fonctions pour obtenir des informations sur Thor, Iron Man, Doctor Strange dans superheroes.py. Vous très intelligemment écrire les propriétés de chacun d'eux dans properties.py dans un compact dict, puis d'y accéder.

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'],
}

Maintenant, disons que vous voulez retourner les capacités de chacun d'eux sur la demande dans superheroes.py. Donc, il y a des fonctions comme

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

...et bien d'autres fonctions retournant des valeurs différentes sur les touches et les super-héros.

Avec l'aide de getattr, vous pourriez faire quelque chose comme:

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

Vous considérablement réduit le nombre de lignes de code, les fonctions de répétition et de!

Oh, et bien sûr, si vous avez de mauvais noms comme properties_of_thor pour les variables , ils peuvent être réalisés et accessible simplement en faisant

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

REMARQUE: Pour ce problème particulier, il peut y avoir des moyens plus intelligents pour faire face à la situation, mais l'idée est de donner un aperçu sur l'utilisation de getattr dans les bons endroits pour écrire nettoyeur de code.

Assez souvent quand je suis en création d'un fichier XML à partir de données stockées dans une classe, je voudrais recevoir fréquemment des erreurs si l'attribut n'existe pas ou a été de type None. Dans ce cas, ma question n'était pas de ne pas savoir ce que le nom de l'attribut a été, comme indiqué dans votre question, mais plutôt de données stockée dans cet attribut.

class Pet:
    def __init__(self):
        self.hair = None
        self.color = None

Si j'ai utilisé hasattr pour ce faire, il serait de retour True même si la valeur de l'attribut est de type None et ce serait la cause de mon ElementTree set de commande à l'échec.

hasattr(temp, 'hair')
>>True

Si la valeur de l'attribut est de type None, getattr serait également de retour lui qui serait la cause de mon ElementTree set de commande à l'échec.

c = getattr(temp, 'hair')
type(c)
>> NoneType

- Je utiliser la méthode suivante pour prendre soin de ces cas maintenant:

def getRealAttr(class_obj, class_attr, default = ''):
    temp = getattr(class_obj, class_attr, default)
    if temp is None:
        temp = default
    elif type(temp) != str:
        temp = str(temp)
    return temp

C'est quand et comment j'utilise getattr.

Une autre utilisation de getattr() dans la mise en œuvre d'une instruction switch en Python. Il utilise à la fois la réflexion pour obtenir le type de cas.

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