Plugging into Python Syntax: More Special Methods

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Plugging into Python Syntax: More Special Methods

In What Are Those Underscores?, you learned that some Python syntax, such as + or ==, triggers method calls. For example, when Python sees ’abc’ + ’123’, it turns that into ’abc’.__add__(’123’). When we call print(obj), then obj.__str__() is called to find out what string to print.

You can do this too. All you need to do is define these special methods inside your classes.

The output Python produces when we print a Book isn’t particularly useful:

	>>> python_book = Book(
	... 'Practical Programming',
	... ['Campbell', 'Gries', 'Montojo'],
	... 'Pragmatic Bookshelf',
	... '978-1-6805026-8-8',
	... 25.0)
	>>> print(python_book)
	<book.Book object at 0x59f410>

This is the default behavior for converting objects to strings: it just shows us where the object is in memory. This is the behavior defined in class object’s method __str__, which our Book class has inherited.

If we want to present a more useful string, we need to explore two more special methods, __str__ and __repr__. __str__ is called when an informal, human-readable version of an object is needed, and __repr__ is called when unambiguous, but possibly less readable, output is desired. In particular, __str__ is called when print is used, and it is also called by function str and by string method format. Method __repr__ is called when you ask for the value of a variable in the Python shell, and it is also called when a collection such as list is printed.

Let’s define method Book.__str__ to provide useful output; this method goes inside class Book, along with __init__ and num_authors:

	def __str__(self) -> str:
	"""Return a human-readable string representation of this Book.
	"""

	return """Title: {0}
	Authors: {1}
	Publisher: {2}
	ISBN: {3}
	Price: ${4}""".format(
	self.title, ', '.join(self.authors), self.publisher, self.ISBN, self.price)

Printing a Book now gives more useful information:

	>>> python_book = Book(
	... 'Practical Programming',
	... ['Campbell', 'Gries', 'Montojo'],
	... 'Pragmatic Bookshelf',
	... '978-1-6805026-8-8',
	... 25.0)
	>>> print(python_book)
	Title: Practical Programming
	Authors: Campbell, Gries, Montojo
	Publisher: Pragmatic Bookshelf
	ISBN: 978-1-6805026-8-8
	Price: $25.0

Method __repr__ is called to get an unambiguous string representation of an object. The string should include the type of the object as well as the values of any instance variables—ideally, if we were to evaluate the string, it would create an object that is equivalent to the one that owns method __repr__. We will show an example of __repr__ in A Case Study: Molecules, Atoms, and PDB Files.

The operator == triggers a call on method __eq__. This method is defined in class object, and so class Book has inherited it; object’s __eq__ produces True exactly when an object is compared to itself. That means that even if two objects contain identical information they will not be considered equal:

	>>> python_book_1 = book.Book(
	... 'Practical Programming',
	... ['Campbell', 'Gries', 'Montojo'],
	... 'Pragmatic Bookshelf',
	... '978-1-6805026-8-8',
	... 25.0)
	>>> python_book_2 = book.Book(
	... 'Practical Programming',
	... ['Campbell', 'Gries', 'Montojo'],
	... 'Pragmatic Bookshelf',
	... '978-1-6805026-8-8',
	... 25.0)
	>>> python_book_1 == python_book_2
	False
	>>> python_book_1 == python_book_1
	True
	>>> python_book_2 == python_book_2
	True

We can override an inherited method by defining a new version in our subclass. This replaces the inherited method so that it is no longer used. As an example, we’ll define method Book.__eq__ to compare two books for equality. Because ISBNs are unique, we can compare using them, but we first need to check whether the object we are comparing to is in fact a Book. We’ll add this method to class Book:

	def __eq__(self, other: Any) -> bool:
	"""Return True iff other is a book, and this book and other have
	the same ISBN.

	>>> python_book = Book(
	'Practical Programming',
	['Campbell', 'Gries', 'Montojo'],
	'Pragmatic Bookshelf',
	'978-1-6805026-8-8',
	25.0)
	>>> python_book_discounted = Book(
	'Practical Programming',
	['Campbell', 'Gries', 'Montojo'],
	'Pragmatic Bookshelf',
	'978-1-6805026-8-8',
	5.0)
	>>> python_book == python_book_discounted
	True
	>>> python_book == ['Not', 'a', 'book']
	False
	"""

	return isinstance(other, Book) and self.ISBN == other.ISBN

Here is our new method __eq__ in action:

	>>> python_book_1 = book.Book(
	... 'Practical Programming', ['Campbell', 'Gries', 'Montojo'],
	... 'Pragmatic Bookshelf', '978-1-6805026-8-8', 25.0)
	>>> python_book_2 = book.Book(
	... 'Practical Programming', ['Campbell', 'Gries', 'Montojo'],
	... 'Pragmatic Bookshelf', '978-1-6805026-8-8', 25.0)
	>>> survival_book = book.Book(
	... "New Programmer's Survival Manual", ['Carter'],
	... 'Pragmatic Bookshelf', '978-1-93435-681-4', 19.0)
	>>> python_book_1 == python_book_2
	True
	>>> python_book_1 == survival_book
	False
	>>> python_book_1 == ['Not', 'a', 'book']
	False

Here, then, are the lookup rules for a method call obj.method(...):

Look in the current object’s class. If we find a method with the right name, use it.
If we didn’t find it, look in the superclass. Continue up the class hierarchy until the method is found.

Python has lots of other special methods; the official Python website gives a full list.

In Function isinstance, Class object, and Class Book , we encountered these four special class attributes:

{'__module__', '__weakref__', '__dict__'}

Every class that you have defined contains these four attributes, plus several more.

The first one, __dict__, unsurprisingly refers to a dictionary. What you might find surprising is that this dictionary is used to keep track of the instance variables and their values! Here it is for our running python_book example:

	>>> python_book.__dict__
	{'publisher': 'Pragmatic Bookshelf', 'ISBN': '978-1-6805026-8-8',
	'title': 'Practical Programming', 'price': 25.0,
	'authors': ['Campbell', 'Gries', 'Montojo']}

Whenever you assign to an instance variable, it changes the contents of the object’s dictionary. You can even change it yourself directly, although we don’t recommend it.

Here are brief descriptions of some of the other special attributes of classes:

Variable __module__ refers to the module object in which the class of the object was defined.

Variable __weakref__ is used by Python to manage when the memory for an object can be reused.

Variables __name__ and __qualname__ refer to strings containing the simple and fully qualified names of classes, respectively; their values are usually identical, except when a class is defined inside another class, in which case the fully qualified name contains both the outer class name and the inner class name.

Variable __class__ refers to an object’s class object.

There are several more special attributes, and they are all used by Python to properly manage information about a program as it executes.

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.

Table of Contents for Plugging into Python Syntax: More Special Methods

Create new playlist

Sign In

Sign Up

Plugging into Python Syntax: More Special Methods

Table of Contents for
Plugging into Python Syntax: More Special Methods