{"id":1086,"date":"2021-03-18T14:25:56","date_gmt":"2021-03-18T13:25:56","guid":{"rendered":"https:\/\/www.bartbarnard.nl\/blog\/?p=1086"},"modified":"2021-03-18T14:25:56","modified_gmt":"2021-03-18T13:25:56","slug":"python-string-representaties","status":"publish","type":"post","link":"https:\/\/www.bartbarnard.nl\/blog\/python-string-representaties\/","title":{"rendered":"Python string representaties"},"content":{"rendered":"

Inleiding<\/h2>\n

Vaak vragen studenten wat het verschil is tussen de dunders __str__<\/code> en __repr__<\/code> in een Python-klasse. Een begrijpelijke vraag, want intu\u00eftief doen beide methoden hetzelfde: ze geven een string-representatie van het object in kwestie. Dus wat zijn<\/em> inderdaad de overeenkomsten en verschillen?<\/p>\n

Er zijn natuurlijk al diverse blog-posts die dit uitleggen. Zo is er een uitgebreide beschrijving op journaldev.com<\/a>, of deze uitleg op StackOverflow<\/a>. Maar het leek me handig om een Nederlandstalige beschrijving te maken, waarbij ook wordt ingegaan op de momenten waarop beide methoden worden aangeroepen.<\/p>\n

Wat zegt de documentatie?<\/h1>\n

De documentatie op python.org lijkt in eerste instantie duidelijk. De __repr__<\/code>-methode geeft de ‘offici\u00eble’ string-represenatie<\/em> van het object terug<\/a>, terwijl de __str__<\/code>-methode de ‘informele’ of netjes afdrukbare representatie<\/em> van het object terug moet geven<\/a>. Let op dat deze documentatie gebruik maakt van apostrofen om aan te geven dat zij ook niet precies defini\u00ebren wat een ‘officie\u00eble’ of ‘informele’ is.<\/p>\n

Hoewel, dat is niet helemaal waar. De documentatie bij __repr__<\/code>vervolgt met de opmerking dat de string die deze methode teruggeeft een valide Python-expressie<\/em> is die in het ideale geval gebruikt kan worden om het object opnieuw te genereren. In die betekenis is __repr__<\/code> dus een soort serialisatie<\/em> methode.<\/p>\n

Een verschil in aanroepen<\/h1>\n

Laten we eens kijken wanneer de verschillende methoden worden aangeroepen.<\/p>\n

In [1<\/span>]: class Demo:\n   ...:     pass\n   ...: \n   ...: d = Demo()\n   ...: print (d)\n   ...: \n   ...: print (d.__repr__())\n   ...: print (d.__str__())\n\n<__main__.Demo<\/span> object<\/span> at 0<\/span>x7f8a1441bf70>\n<__main__.Demo<\/span> object<\/span> at 0<\/span>x7f8a1441bf70>\n<__main__.Demo<\/span> object<\/span> at 0<\/span>x7f8a1441bf70>\n\nIn [2<\/span>]:\n<\/code><\/pre>\n
De output van al deze print-statements is in alle gevallen hetzelfde: '<__main__.Demo object at 0x7fe0adc4d910>'<\/code>. Dat is niet heel zinvolle informatie, en het is ook logisch dat bede methoden dezelfde output geven: de implementatie van __str__<\/code> in Object<\/code> roept gewoon __repr__<\/code> aan.<\/p>\n
Wat dan, wanneer we \u00e9\u00e9n van beide methoden in onze klasse implementeren?<\/p>\n
In [1<\/span>]: class<\/span> Demo<\/span>:<\/span>\n   ...:     def<\/span> __init__<\/span>(self<\/span>)<\/span><\/span>:\n   ...:         self<\/span>.demostr = 'hallo allemaal'<\/span>\n   ...: \n   ...:     def<\/span> __repr__<\/span>(self<\/span>)<\/span><\/span>:\n   ...:         return<\/span> f'Demo object met demostr: {self.demostr}'<\/span>\n   ...: \n   ...: d = Demo()\n   ...: print (d)\n\nDemo object met demostr:<\/span> hallo allemaal\n\nIn [2<\/span>]:<\/span>\n<\/code><\/pre>\n
Het resultaat van deze test is de string die door __repr__<\/code> wordt teruggegeven: Demo object met demostr: hallo allemaal<\/code>. Blijkbaar wordt door print<\/code> een call gedaan naar __repr__<\/code>. Maar wat nu als we beide methoden implementen?<\/p>\n
In [1<\/span>]: class<\/span> Demo<\/span>:<\/span>\n   ...:     def<\/span> __init__<\/span>(self<\/span>)<\/span><\/span>:\n   ...:         self<\/span>.demostr = 'hallo allemaal'<\/span>\n   ...: \n   ...:     def<\/span> __repr__<\/span>(self<\/span>)<\/span><\/span>:\n   ...:         return<\/span> f'Demo object met demostr: {self.demostr}'<\/span>\n   ...: \n   ...:     def<\/span> __str__<\/span>(self<\/span>)<\/span><\/span>:\n   ...:         return<\/span> f'De str-methode aangeroepen.'<\/span>\n   ...: \n   ...: \n   ...: d = Demo()\n   ...: print (d)\n\nDe str-methode aangeroepen.\n\nIn [2<\/span>]:<\/span>\n<\/code><\/pre>\n
Dit maakt duidelijk dat er een call naar __str__<\/code> gedaan wordt. Blijkbaar kijkt Python bij een print<\/code> eerst of er een implementatie van __str__<\/code> bestaat; als dat niet het geval is, wordt een poging gedaan __repr__<\/code> aan te roepen, en als die er ook niet is, wordt hetzelfde protocol bij de superklasse toegepast. En zo verder totdat we bij Object<\/code> aankomen.<\/p>\n
Het automatisch aanroepen van __repr__<\/code><\/h1>\n
Dus print<\/code> roept automatisch __str__<\/code> aan. Maar is er ook een situatie denkbaar waarin automatisch __repr__<\/code> wordt aangeroepen, zelfs wanneer beide methoden bestaan? Dit blijkt het geval te zijn wanneer we het object uitprinten zonder gebruik te maken van de methode print<\/code>, zoals we vaak doen in de interactieve shell:<\/p>\n
In [1<\/span>]: class<\/span> Demo<\/span>:<\/span>\n   ...:     def<\/span> __init__<\/span>(self<\/span>)<\/span><\/span>:\n   ...:         self<\/span>.demostr = 'hallo allemaal'<\/span>\n   ...: \n   ...:     def<\/span> __repr__<\/span>(self<\/span>)<\/span><\/span>:\n   ...:         return<\/span> f'Demo object met demostr: {self.demostr}'<\/span>\n   ...: \n   ...:     def<\/span> __str__<\/span>(self<\/span>)<\/span><\/span>:\n   ...:         return<\/span> f'De str-methode aangeroepen.'<\/span>\n   ...: \n   ...: \n   ...: d = Demo()\n   ...: print (d)\nDe str-methode aangeroepen.\n\nIn [2<\/span>]: d\nOut[2<\/span>]: Demo object met demostr:<\/span> hallo allemaal\n\nIn [3<\/span>]:<\/span>\n<\/code><\/pre>\n
Een andere situatie waarin __repr__<\/code> wordt aangeroepen is wanneer het object een onderdeel is van een tupel<\/code> of een dictionary<\/code> die wordt uitgeprint:<\/p>\n
In<\/span> [4<\/span>]: print ([d])\n[Demo<\/span> object met demostr: hallo allemaal]\n\nIn<\/span> [5<\/span>]: print ({'key'<\/span>:d})\n{'key'<\/span>: Demo<\/span> object met demostr: hallo allemaal}\n\nIn<\/span> [7<\/span>]:\n<\/code><\/pre>\n
Serialisatie door middel van __repr__<\/code><\/h1>\n
Zoals aangegeven, is het de bedoeling van __repr__<\/code> dat deze methode een representatie teruggeeft die in principe gebruikt kan worden om het object te regenereren. Dat betekent dat obj == eval(repr(obj))<\/code> in de regel een waarde zou moeten hebben van True<\/code> (dat kan niet altijd natuurlijk, maar dit is een ideaal). Hoe zou je zoiets kunnen realiseren?<\/p>\n
In principe is een object niks meer dan een zooi methoden met een interne status. Dus om een op basis van een bestaan object een nieuw object te maken, volstaat het om deze interne status aan het nieuwe object door te geven. Zolang dat nieuwe object van hetzelfde type is, heeft dat object ook de gewenste methoden.<\/p>\n
class<\/span> Demo<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self<\/span>, **kwargs)<\/span><\/span>:\n        self<\/span>.__dict__<\/span>.update(kwargs) \n\n    def<\/span> update<\/span>(self<\/span>, key, value)<\/span><\/span>:\n        self<\/span>.__dict__<\/span>[key] = value\n\n    def<\/span> __str__<\/span>(self<\/span>)<\/span><\/span>:\n        return<\/span> f'Demo object, verder niks aan de hand'<\/span>\n\n    def<\/span> __repr__<\/span>(self<\/span>)<\/span><\/span>:\n        return<\/span> self<\/span>.__dict__<\/span>\n\n# maak een object aan met wat data<\/span>\nobject1 = Demo(naam='Bart'<\/span>, woonplaats='Groningen'<\/span>, huisnummer=116<\/span>)\n# verander de interne status van het object<\/span>\nobject1.update('huisnummer'<\/span>, 200<\/span>) \n# en printen de interne status<\/span>\nprint (object1.__repr__<\/span>())\n\n# hier maken we een kopie aan van het eerste object<\/span>\nobject2 = Demo(**object1.__repr__<\/span>())\n# en printen de interne status; die is hetzelfde als object1<\/span>\nprint (object2.__repr__<\/span>())\n\n# nu passen we de interne status van het eerste object aan <\/span>\nobject2.update('huisnummer'<\/span>, 60<\/span>)\n\n# en printen van beide objecten de interne status af<\/span>\nprint (object1.__repr__<\/span>())\nprint (object2.__repr__<\/span>())\n<\/code><\/pre>\n
De code hierboven levert het volgende op:<\/p>\n
{'naam'<\/span>: 'Bart'<\/span>, 'woonplaats'<\/span>: 'Groningen'<\/span>, 'huisnummer'<\/span>: 116<\/span>}\n{'naam'<\/span>: 'Bart'<\/span>, 'woonplaats'<\/span>: 'Groningen'<\/span>, 'huisnummer'<\/span>: 200<\/span>}\n{'naam'<\/span>: 'Bart'<\/span>, 'woonplaats'<\/span>: 'Groningen'<\/span>, 'huisnummer'<\/span>: 200<\/span>}\n{'naam'<\/span>: 'Bart'<\/span>, 'woonplaats'<\/span>: 'Groningen'<\/span>, 'huisnummer'<\/span>: 60<\/span>}\n<\/code><\/pre>\n
Conclusie<\/h1>\n
Dus __str__<\/code> en __repr__<\/code> lijken er op elkaar; ze verschillen op nuance maar daardoor wel radicaal. Het beste advies voor de alledaagse gang van zaken is gewoon in de eigen klassen __str__<\/code> te implementeren, en __repr__<\/code> te gebruiken voor klassen die geserialiseerd moeten worden.<\/p>\n","protected":false},"excerpt":{"rendered":"
Inleiding Vaak vragen studenten wat het verschil is tussen de dunders __str__ en __repr__ in een Python-klasse. Een begrijpelijke vraag, want intu\u00eftief doen beide methoden hetzelfde: ze geven een string-representatie van het object in kwestie. Dus wat zijn inderdaad de overeenkomsten en verschillen? Er zijn natuurlijk al diverse blog-posts die dit uitleggen. Zo is er<\/p>\n
Read More<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[19],"tags":[42,43],"_links":{"self":[{"href":"https:\/\/www.bartbarnard.nl\/blog\/wp-json\/wp\/v2\/posts\/1086"}],"collection":[{"href":"https:\/\/www.bartbarnard.nl\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.bartbarnard.nl\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.bartbarnard.nl\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.bartbarnard.nl\/blog\/wp-json\/wp\/v2\/comments?post=1086"}],"version-history":[{"count":2,"href":"https:\/\/www.bartbarnard.nl\/blog\/wp-json\/wp\/v2\/posts\/1086\/revisions"}],"predecessor-version":[{"id":1088,"href":"https:\/\/www.bartbarnard.nl\/blog\/wp-json\/wp\/v2\/posts\/1086\/revisions\/1088"}],"wp:attachment":[{"href":"https:\/\/www.bartbarnard.nl\/blog\/wp-json\/wp\/v2\/media?parent=1086"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.bartbarnard.nl\/blog\/wp-json\/wp\/v2\/categories?post=1086"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.bartbarnard.nl\/blog\/wp-json\/wp\/v2\/tags?post=1086"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}