What is the purpose of Python's built-in bool method __ror__?

Question

In the interactive interpreter, if you type the following in order you can see some pretty interesting stuff:

1) help()

2) modules

3) __builtin__

When reading through the output for awhile I came across these lines in class bool:

__or__(...)
    x.__or__(y) <==> x|y

and then later on:

__ror__(...)
    x.__ror__(y) <==> y|x

This last method appears to describe reverse or. Why does this method exist? What could possibly cause __or__(...) to return anything different than __ror__(...)?

Blanketing

Answered in https://mcmap.net/q/76694/-__rlshift__-__ror__-in-python – Mernamero

Take a look here: docs.python.org/2/reference/… – Homing

Check this project for an example: github.com/JulienPalard/Pipe – Teethe

Answer 1

Suppose you write your own integer class, and you want it to work with the built-in integers. You might define __or__

class MyInt(int):

    def __or__(self, other):
        # Not a recommended implementation!
        return self | int(other)

so that you can write code like

# Because this is equivalent to MyInt.__or__(MyInt(6), 7)
MyInt(6) | 7

However, Python wouldn't know what to do with

# First interpretation is int.__or__(7, MyInt(6))
7 | MyInt(6)

because int.__or__ wouldn't know how to work with an instance of MyInt. In such a case, Python swaps the order of the operands and tries

MyInt.__ror__(MyInt(6), 7)

that is, looks for the swapped version of the magic method in the class of the right-hand argument.

Exhaustive

Answer 2

Here's a practical use in the REPL:

Suppose you want to inspect an object. Here I'll use the time module as an example.

>>> import time
>>> vars(time)
{'timezone': 0, '_STRUCT_TM_ITEMS': 11, '__package__': '', 'mktime': <built-in function mktime>, 'altzone': 0, '__doc__': 'This module provides various functions to manipulate time values.\n\nThere are two standard representations of time.  One is the number\nof seconds since the Epoch, in UTC (a.k.a. GMT).  It may be an integer\nor a floating point number (to represent fractions of seconds).\nThe Epoch is system-defined; on Unix, it is generally January 1st, 1970.\nThe actual value can be retrieved by calling gmtime(0).\n\nThe other representation is a tuple of 9 integers giving local time.\nThe tuple items are:\n  year (including century, e.g. 1998)\n  month (1-12)\n  day (1-31)\n  hours (0-23)\n  minutes (0-59)\n  seconds (0-59)\n  weekday (0-6, Monday is 0)\n  Julian day (day in the year, 1-366)\n  DST (Daylight Savings Time) flag (-1, 0 or 1)\nIf the DST flag is 0, the time is given in the regular time zone;\nif it is 1, the time is given in the DST time zone;\nif it is -1, mktime() should guess based on the date and time.\n\nVariables:\n\ntimezone -- difference in seconds between UTC and local standard time\naltzone -- difference in  seconds between UTC and local DST time\ndaylight -- whether local time should reflect DST\ntzname -- tuple of (standard time zone name, DST time zone name)\n\nFunctions:\n\ntime() -- return current time in seconds since the Epoch as a float\nclock() -- return CPU time since process start as a float\nsleep() -- delay for a number of seconds given as a float\ngmtime() -- convert seconds since Epoch to UTC tuple\nlocaltime() -- convert seconds since Epoch to local time tuple\nasctime() -- convert time tuple to string\nctime() -- convert time in seconds to string\nmktime() -- convert local time tuple to seconds since Epoch\nstrftime() -- convert time tuple to string according to format specification\nstrptime() -- parse string to time tuple according to format specification\ntzset() -- change the local timezone', 'strptime': <built-in function strptime>, 'clock_settime': <built-in function clock_settime>, 'CLOCK_MONOTONIC': 1, 'strftime': <built-in function strftime>, 'time': <built-in function time>, 'CLOCK_PROCESS_CPUTIME_ID': 2, 'monotonic': <built-in function monotonic>, 'gmtime': <built-in function gmtime>, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, 'get_clock_info': <built-in function get_clock_info>, 'clock_getres': <built-in function clock_getres>, 'asctime': <built-in function asctime>, 'CLOCK_THREAD_CPUTIME_ID': 3, 'tzname': ('UTC', 'UTC'), 'CLOCK_MONOTONIC_RAW': 4, 'clock_gettime': <built-in function clock_gettime>, 'clock': <built-in function clock>, 'ctime': <built-in function ctime>, '__spec__': ModuleSpec(name='time', loader=<class '_frozen_importlib.BuiltinImporter'>, origin='built-in'), 'sleep': <built-in function sleep>, 'localtime': <built-in function localtime>, 'struct_time': <class 'time.struct_time'>, 'CLOCK_REALTIME': 0, 'perf_counter': <built-in function perf_counter>, 'tzset': <built-in function tzset>, 'process_time': <built-in function process_time>, 'daylight': 0, '__name__': 'time'}

You can use pprint to make it easier to read

>>> import pprint
>>> pprint(vars(time))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'module' object is not callable
>>> pprint.pprint(vars(time))
{'CLOCK_MONOTONIC': 1,
 'CLOCK_MONOTONIC_RAW': 4,
 'CLOCK_PROCESS_CPUTIME_ID': 2,
 'CLOCK_REALTIME': 0,
 'CLOCK_THREAD_CPUTIME_ID': 3,
 '_STRUCT_TM_ITEMS': 11,
 '__doc__': 'This module provides various functions to manipulate time '
            'values.\n'
            '\n'
            'There are two standard representations of time.  One is the '
            'number\n'
            'of seconds since the Epoch, in UTC (a.k.a. GMT).  It may be an '
            'integer\n'
            'or a floating point number (to represent fractions of seconds).\n'
            'The Epoch is system-defined; on Unix, it is generally January '
            '1st, 1970.\n'
            'The actual value can be retrieved by calling gmtime(0).\n'
...

But if I have to do that a bunch of times it's tiresome to have to type pprint and the parens over and over, so let me define a special object:

>>> pp = type("", (), {"__ror__": lambda self, v: pprint.pprint(v)})()
>>> vars(time) | pp
{'CLOCK_MONOTONIC': 1,
 'CLOCK_MONOTONIC_RAW': 4,
 'CLOCK_PROCESS_CPUTIME_ID': 2,
 'CLOCK_REALTIME': 0,
 'CLOCK_THREAD_CPUTIME_ID': 3,
 '_STRUCT_TM_ITEMS': 11,
 '__doc__': 'This module provides various functions to manipulate time '
            'values.\n'
            '\n'
            'There are two standard representations of time.  One is the '
            'number\n'
            'of seconds since the Epoch, in UTC (a.k.a. GMT).  It may be an '
            'integer\n'
            'or a floating point number (to represent fractions of seconds).\n'
            'The Epoch is system-defined; on Unix, it is generally January '
            '1st, 1970.\n'
            'The actual value can be retrieved by calling gmtime(0).\n'
...

I can now just add "| pp" whenever I want to pretty print the returned value.

Oswin