1

Python does not have an 'is_even' method or anything of the sort for integers.

Why is this the case?

Additionally, should I write is_even functions in my code for the sake of readability?

For example:

if integer_value % 2 == 0:
    # Do something

It is not apparent what exactly that is supposed to do.

Whereas this is instantly more understandable:

if is_even(integer_value):
    # Do something

This however means that I have to write an is_even function where I want it.

def is_even(integer):
    if integer % 2 == 0:
        return True
    else:
        return False

What is the better option? Have code that is itself readable and with apparent purpose, or have comments everywhere?

To quote a recent blog entry that is doing the rounds:

"Notice also how much stronger this approach is than using comments. If you change the logic there is immediate pressure on you to change the variable names. Not so with comments. I agree with DHH, comments are dangerous and tend to rot - much better to write self-documenting code." - http://peternixey.com/post/83510597580/how-to-be-a-great-software-developer

Am I taking this too far?

B0073D
  • 61
  • 1
  • 8
  • 3
    If there was a function for every numeric properties of numbers, the implementation size would grow very fast. – merlin2011 Apr 24 '14 at 04:54
  • 4
    'It is not apparent what exactly that is supposed to do'. No, absolutely not. It is very apparent what that does and if you write some 'is_even' method, it will actually confuse people. – Jayanth Koushik Apr 24 '14 at 04:55
  • 1
    I agree. When I see `x % 2`, no matter what the language, it is immediately apparent what someone is trying to do. Incidentally, implementing your own `is_even` function is as simple as `is_even = lambda x: not x % 2` – Joel Cornett Apr 24 '14 at 04:59
  • If you like approachingly-infinite builtin methods, you might be more interested in ruby. In my experience I can't remember half the methods ruby's built-in types provide and I spend a disproportionate amount of time searching the docs for the "right" method when I code in ruby. – roippi Apr 24 '14 at 05:03
  • But why do you want to have a built in function for this? This is pretty straightforward technique. – vamosrafa Apr 24 '14 at 05:49
  • I guess it comes down to inexperience. I am not at a level where I would recognise that immediately for what it is trying to achieve. is_even makes more sense to me because I can see what it is trying to do as opposed to an (at the time) alien function. – B0073D Apr 24 '14 at 06:06

2 Answers2

2

Create a utility module with all the commonly used functions and put your comments only there. Later, import the utility module wherever you need it and invoke the functions.

This way, you are not writing the same function more than once and it becomes easily maintainable.

Also, your is_even can be shortened like this

def iseven(number):
    """
    Checks if a number is even or odd.

    Examples:
        >>> iseven(5)
        False
        >>> iseven(6)
        True
        >>> iseven(6.0)
        True
        >>> iseven(5.5)
        False
    """
    return number % 2 == 0

if __name__ == "__main__":
    import doctest
    doctest.testmod()
Intrastellar Explorer
  • 3,005
  • 9
  • 52
  • 119
thefourtheye
  • 233,700
  • 52
  • 457
  • 497
1

There is usually no problem with creating local functions - or using lambdas - and I usually do when they make the intent that much more clear.

However, making this class of specialized functions part of the core language is generally unnecessary, and to add such as global/built-in function (or even as methods on the particular type) tends to head down the path of a bloated core: e.g. why not also is_prime or is_natural?

def do_my_stuff(numbers):
    def is_even(i):
        return i % 2 == 0

    # use is_even, where it can be trivially referenced above
    return map(is_even, numbers)
Vitalis11
  • 99
  • 9
user2864740
  • 60,010
  • 15
  • 145
  • 220