J'ai un Personmodèle qui a une relation de clé étrangère avec Book, qui a un certain nombre de champs, mais je suis le plus préoccupé par author(un CharField standard).

Cela étant dit, dans mon PersonAdminmodèle, je voudrais afficher en book.authorutilisant list_display:

class PersonAdmin(admin.ModelAdmin):
    list_display = ['book.author',]

J'ai essayé toutes les méthodes évidentes pour le faire, mais rien ne semble fonctionner.

Aucune suggestion?

Comme autre option, vous pouvez faire des recherches comme:

class UserAdmin(admin.ModelAdmin):
    list_display = (..., 'get_author')

    def get_author(self, obj):
        return obj.book.author
    get_author.short_description = 'Author'
    get_author.admin_order_field = 'book__author'

Malgré toutes les bonnes réponses ci-dessus et étant donné que j'étais nouveau à Django, j'étais toujours coincé. Voici mon explication d'un point de vue très novice.

models.py

class Author(models.Model):
    name = models.CharField(max_length=255)

class Book(models.Model):
    author = models.ForeignKey(Author)
    title = models.CharField(max_length=255)

admin.py (Incorrect Way) - vous pensez que cela fonctionnerait en utilisant 'model__field' pour faire référence, mais cela ne fonctionne pas

class BookAdmin(admin.ModelAdmin):
    model = Book
    list_display = ['title', 'author__name', ]

admin.site.register(Book, BookAdmin)

admin.py (Correct Way) - c'est ainsi que vous référencez un nom de clé étrangère à la manière de Django

class BookAdmin(admin.ModelAdmin):
    model = Book
    list_display = ['title', 'get_name', ]

    def get_name(self, obj):
        return obj.author.name
    get_name.admin_order_field  = 'author'  #Allows column order sorting
    get_name.short_description = 'Author Name'  #Renames column head

    #Filtering on side - for some reason, this works
    #list_filter = ['title', 'author__name']

admin.site.register(Book, BookAdmin)

Pour des références supplémentaires, voir le lien du modèle Django ici

Comme le reste, je suis allé avec des callables aussi. Mais ils ont un inconvénient: par défaut, vous ne pouvez pas commander sur eux. Heureusement, il existe une solution pour cela:

Django> = 1,8

def author(self, obj):
    return obj.book.author
author.admin_order_field  = 'book__author'

Django <1,8

def author(self):
    return self.book.author
author.admin_order_field  = 'book__author'

Veuillez noter que l'ajout de la get_authorfonction ralentirait le list_display dans l'admin, car afficher chaque personne ferait une requête SQL.

Pour éviter cela, vous devez modifier la get_querysetméthode dans PersonAdmin, par exemple:

def get_queryset(self, request):
    return super(PersonAdmin,self).get_queryset(request).select_related('book')

Avant: 73 requêtes en 36,02 ms (67 requêtes dupliquées en admin)

Après: 6 requêtes en 10,81 ms

Selon la documentation, vous ne pouvez afficher que la __unicode__représentation d'une clé étrangère:

http://docs.djangoproject.com/en/dev/ref/contrib/admin/#list-display

Semble étrange qu'il ne prend pas en charge le 'book__author'format de style qui est utilisé partout ailleurs dans l'API DB.

Il s'avère qu'il y a un ticket pour cette fonctionnalité , qui est marqué comme ne sera pas réparé.

Je viens de publier un extrait de code qui permet à admin.ModelAdmin de prendre en charge la syntaxe '__':

http://djangosnippets.org/snippets/2887/

Vous pouvez donc faire:

class PersonAdmin(RelatedFieldAdmin):
    list_display = ['book__author',]

Il s'agit essentiellement de faire la même chose que celle décrite dans les autres réponses, mais cela prend automatiquement en charge (1) la configuration admin_order_field (2) la configuration short_description et (3) la modification du jeu de requêtes pour éviter un accès à la base de données pour chaque ligne.

Vous pouvez afficher tout ce que vous voulez dans l'affichage de la liste en utilisant un appelable. Cela ressemblerait à ceci:

def book_author (objet):
  renvoyer object.book.author

classe PersonAdmin (admin.ModelAdmin):
  list_display = [book_author,]

Celui-ci est déjà accepté, mais s'il y a d'autres mannequins (comme moi) qui ne l'ont pas immédiatement obtenu de la réponse actuellement acceptée , voici un peu plus de détails.

La classe de modèle référencée par le ForeignKeybesoin d'avoir une __unicode__méthode en elle, comme ici:

class Category(models.Model):
    name = models.CharField(max_length=50)

    def __unicode__(self):
        return self.name

Cela a fait la différence pour moi et devrait s'appliquer au scénario ci-dessus. Cela fonctionne sur Django 1.0.2.

Si vous avez beaucoup de champs d'attributs de relation à utiliser list_displayet que vous ne voulez pas créer une fonction (et ses attributs) pour chacun, une solution simple mais sale serait de remplacer la méthode ModelAdmininstace __getattr__, créant les callables à la volée:

class DynamicLookupMixin(object):
    '''
    a mixin to add dynamic callable attributes like 'book__author' which
    return a function that return the instance.book.author value
    '''

    def __getattr__(self, attr):
        if ('__' in attr
            and not attr.startswith('_')
            and not attr.endswith('_boolean')
            and not attr.endswith('_short_description')):

            def dyn_lookup(instance):
                # traverse all __ lookups
                return reduce(lambda parent, child: getattr(parent, child),
                              attr.split('__'),
                              instance)

            # get admin_order_field, boolean and short_description
            dyn_lookup.admin_order_field = attr
            dyn_lookup.boolean = getattr(self, '{}_boolean'.format(attr), False)
            dyn_lookup.short_description = getattr(
                self, '{}_short_description'.format(attr),
                attr.replace('_', ' ').capitalize())

            return dyn_lookup

        # not dynamic lookup, default behaviour
        return self.__getattribute__(attr)


# use examples    

@admin.register(models.Person)
class PersonAdmin(admin.ModelAdmin, DynamicLookupMixin):
    list_display = ['book__author', 'book__publisher__name',
                    'book__publisher__country']

    # custom short description
    book__publisher__country_short_description = 'Publisher Country'


@admin.register(models.Product)
class ProductAdmin(admin.ModelAdmin, DynamicLookupMixin):
    list_display = ('name', 'category__is_new')

    # to show as boolean field
    category__is_new_boolean = True

Comme l' essentiel ici

Les attributs spéciaux appelables comme booleanet short_descriptiondoivent être définis comme des ModelAdminattributs, par exemple book__author_verbose_name = 'Author name'et category__is_new_boolean = True.

L' admin_order_fieldattribut callable est défini automatiquement.

N'oubliez pas d'utiliser l' attribut list_select_related dans votre ModelAdminpour que Django évite les requêtes supplémentaires.

Il existe un package très facile à utiliser disponible dans PyPI qui gère exactement cela: django-related-admin . Vous pouvez également voir le code dans GitHub .

En utilisant cela, ce que vous voulez réaliser est aussi simple que:

class PersonAdmin(RelatedFieldAdmin):
    list_display = ['book__author',]

Les deux liens contiennent tous les détails de l'installation et de l'utilisation, donc je ne les collerai pas ici au cas où ils changeraient.

Tout comme une note de côté, si vous utilisez déjà autre chose que model.Admin(par exemple , j'utilisais à la SimpleHistoryAdminplace), vous pouvez le faire: class MyAdmin(SimpleHistoryAdmin, RelatedFieldAdmin).

si vous l'essayez en ligne, vous ne réussirez pas sauf si:

dans votre ligne:

class AddInline(admin.TabularInline):
    readonly_fields = ['localname',]
    model = MyModel
    fields = ('localname',)

dans votre modèle (MyModel):

class MyModel(models.Model):
    localization = models.ForeignKey(Localizations)

    def localname(self):
        return self.localization.name

La réponse d'AlexRobbins a fonctionné pour moi, sauf que les deux premières lignes doivent être dans le modèle (peut-être que cela a été supposé?), Et devraient se référencer soi-même:

def book_author(self):
  return self.book.author

Ensuite, la partie admin fonctionne bien.

Je préfère ça:

class CoolAdmin(admin.ModelAdmin):
    list_display = ('pk', 'submodel__field')

    @staticmethod
    def submodel__field(obj):
        return obj.submodel.field