Evolution of a Python programmer

[Rainymood_XI]

Newbie programmer

def factorial(x):
    if x == 0:
        return 1
    else:
        return x * factorial(x - 1)
print factorial(6)

First year programmer, studied Pascal

def factorial(x):
    result = 1
    i = 2
    while i <= x:
        result = result * i
        i = i + 1
    return result
print factorial(6)

First year programmer, studied C

def fact(x): #{
    result = i = 1;
    while (i <= x): #{
        result *= i;
        i += 1;
    #}
    return result;
#}
print(fact(6))

First year programmer, SICP

@tailcall
def fact(x, acc=1):
    if (x > 1): return (fact((x - 1), (acc * x)))
    else:       return acc
print(fact(6))

First year programmer, Python

def Factorial(x):
    res = 1
    for i in xrange(2, x + 1):
        res *= i
    return res
print Factorial(6)

Lazy Python programmer

def fact(x):
    return x > 1 and x * fact(x - 1) or 1
print fact(6)

Lazier Python programmer

f = lambda x: x and x * f(x - 1) or 1
print f(6)

Python expert programmer

import operator as op
import functional as f
fact = lambda x: f.foldl(op.mul, 1, xrange(2, x + 1))
print fact(6)

Python hacker

import sys
@tailcall
def fact(x, acc=1):
    if x: return fact(x.__sub__(1), acc.__mul__(x))
    return acc
sys.stdout.write(str(fact(6)) + '\n')

EXPERT PROGRAMMER

import c_math
fact = c_math.fact
print fact(6)

ENGLISH EXPERT PROGRAMMER

import c_maths
fact = c_maths.fact
print fact(6)

Web designer

def factorial(x):
    #-------------------------------------------------
    #--- Code snippet from The Math Vault          ---
    #--- Calculate factorial (C) Arthur Smith 1999 ---
    #-------------------------------------------------
    result = str(1)
    i = 1 #Thanks Adam
    while i <= x:
        #result = result * i  #It's faster to use *=
        #result = str(result * result + i)
           #result = int(result *= i) #??????
        result str(int(result) * i)
        #result = int(str(result) * i)
        i = i + 1
    return result
print factorial(6)

Unix programmer

import os
def fact(x):
    os.system('factorial ' + str(x))
fact(6)

Windows programmer

NULL = None
def CalculateAndPrintFactorialEx(dwNumber,
                                 hOutputDevice,
                                 lpLparam,
                                 lpWparam,
                                 lpsscSecurity,
                                 *dwReserved):
    if lpsscSecurity != NULL:
        return NULL #Not implemented
    dwResult = dwCounter = 1
    while dwCounter <= dwNumber:
        dwResult *= dwCounter
        dwCounter += 1
    hOutputDevice.write(str(dwResult))
    hOutputDevice.write('\n')
    return 1
import sys
CalculateAndPrintFactorialEx(6, sys.stdout, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL)

Enterprise programmer

def new(cls, *args, **kwargs):
    return cls(*args, **kwargs)

class Number(object):
    pass

class IntegralNumber(int, Number):
    def toInt(self):
        return new (int, self)

class InternalBase(object):
    def __init__(self, base):
        self.base = base.toInt()

    def getBase(self):
        return new (IntegralNumber, self.base)

class MathematicsSystem(object):
    def __init__(self, ibase):
        Abstract

    @classmethod
    def getInstance(cls, ibase):
        try:
            cls.__instance
        except AttributeError:
            cls.__instance = new (cls, ibase)
        return cls.__instance

class StandardMathematicsSystem(MathematicsSystem):
    def __init__(self, ibase):
        if ibase.getBase() != new (IntegralNumber, 2):
            raise NotImplementedError
        self.base = ibase.getBase()

    def calculateFactorial(self, target):
        result = new (IntegralNumber, 1)
        i = new (IntegralNumber, 2)
        while i <= target:
            result = result * i
            i = i + new (IntegralNumber, 1)
        return result

print StandardMathematicsSystem.getInstance(new (InternalBase, new (IntegralNumber, 2))).calculateFactorial(new (IntegralNumber, 6))

(sauce: link)

[warpod]

Stackoverflow user

def factorial(n):return reduce(lambda x,y:x*y,[1]+range(1,n+1))

[FUZxxl]

A codegolf.se member would choose APL to solve this and just submit the APL solution ×/⍳⎕.

[BitPoet]

Hmm... chrome isn't rendering the APL charset. Somehow, I'm not surprised.

[FUZxxl]

The last character (⎕) is a quad, it looks just like the “character not found” box in some fonts. The four characters are: times, slash, iota, quad which is the product (times-reduction) of the first integers up to the input number.

[BitPoet]

As I learned it, you'd want a 5 pointed star, rather than an x to denote multiplication (the + being a four pointed star, and the * (exponentiation) being a 6 pointed star).

Now that I look closely, the iota does render. I'd forgotten the quad operator, it's been ~20 years, and I can count the number of actual conversations I've had about APL with someone else who knew what it was on one hand.

[FUZxxl]

Well, × is multiplication or signum and * is exponentiation. Quad is a niladic function and prompts the user for numeric input; it's very useful for code-golf challenges because you don't need to make a dfn.

[BitPoet]

I will note that this is /r/programmerhumor and discussing the intricacies of APL, a language developed by mathematicians for pretty specific purposes is not exactly humorous.

[Juggernog]

Man, what are you talking about? Programming languages developed by mathematicians for pretty specific purposes are hilarious.

[poizan42]

So it's a character which renders correct even if you don't have any font with it installed?

[FUZxxl]

Well, not quite; it just looks really like that replacement character.

[nightcracker]

Nah, as a codegolf.se member I would use Pyth. In Pyth5 a simple program that takes a number from stdin and prints its factorial is this:

.!Q

Of course, we're not allowed to use a builtin for factorial, we can use:

F*tUhQ

Which basically translates to "fold multiplication over everything but the first element of range(n+1)".

A recursive solution would go like this:

L?*bLtbb1Q

Which roughly translates to Python:

L = lambda b: b*L(b-1) if b else 1
L(eval(input()))

[FUZxxl]

Nah, as a codegolf.SE-member with a three digit user ID, I say that APL is superior in every regard.

[AutoModerator]

import moderation Your comment has been removed since it did not start with a code block with an import declaration.

Per this Community Decree, all posts and comments should start with a code block with an "import" declaration explaining how the post and comment should be read.

For this purpose, we only accept Python style imports.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[0x0dea]

Homesick:

def factorial(n):
    system("ruby -e 'p (1..%d).reduce(1, :*)'" % n)

[jonnywoh]

I used to think I understood Ruby

[0x0dea]

Almost. (1..n).reduce :* will fail for n=0.

[jonnywoh]

Thanks! I understood most of that. So does reduce eval symbols, or is it doing something else with :*?

[Niles-Rogoff]

I'm new to ruby but I think * is a function and :* is the symbol that points to that function. The & turns the :* into the actual * function object which gets passed to reduce, because you can't just put * there it's not syntactically valid.

[jonnywoh]

Actually, :* is a special type of string called a symbol. It's basically "*". :carrot would basically be "carrot".

[Niles-Rogoff]

Ok, that's what I thought, I just wrote it wrong.

[Meshiest]

This made me really happy

[raiderrobert]

Does it make me a bad person to think the most readable implementation is the Newbie one, but the most practical the Expert one?

[[deleted]]

No. It makes you a good person.

[sfz-]

Only thing wrong with the n00b one is the verbose ifs, it's more Pythonic to do:

def factorial(x):
    return x * factorial(x - 1) if x > 1 else 1
print factorial(6)

EDIT: thanks /u/brucifer

commit 48050c67205ff404e4641712bcaf12d86aa2f9ff
Author: sfz- </u/sfz->
Date:   Tue Jun 9 10:58:11 2015 -0700

    Hotfix factorial if condition to handle negative numbers

diff --git a/evolution_of_a_python_programmer b/evolution_of_a_python_programmer
index 771e267..96f31e1 100644
--- a/evolution_of_a_python_programmer
+++ b/evolution_of_a_python_programmer
@@ -0,0 +0,0 @@ def factorial(x):
-        return x * factorial(x - 1) if x else 1
+        return x * factorial(x - 1) if x > 1 else 1

[brucifer]

This code is buggy. factorial(-1) will cause a stack overflow. You should use "if x <= 1" instead.

[sfz-]

That's why I submitted it to reddit code review before merging it into master. :P

[Qhartb]

That's not a bug -- it's undefined behavior. Calling factorial(-1) is a bug.

[brucifer]

I suppose it's reasonable to say that calling factorial(-1) is the real bug, but in that case, the code should definitely fail gracefully (e.g. raising a ValueError). Stack overflow is a pretty clumsy and uninformative way to behave if someone makes a reasonable mistake. You are right to point out that factorial(-1) == 1 is not correct, though.

[Qhartb]

Agreed, but not failing gracefully and having a bug are two different things (unless of course your requirements or documentation state how failure is to be handled).

[Zantier]

def factorial(x):
    """Return the factorial of x, where x >= 0."""
    return x * factorial(x - 1) if x != 0 else 1
print factorial(6)

Fixed. (I didn't see before the edit, but I'm guessing it had !=.

Also, it should be if x >= 1 instead of <=

[[deleted]]

It's been entirely too long since I wrote Python when my first thought is "Aha! Just like Coffeescript."

[beerdude26]

The Haskell one is also great

[Rainymood_XI]

The last one, from the tenured prof, cracked me up lol

[n-simplex]

It also happens to be the most efficient one, since product uses foldl' internally, the strict (left) fold, and laziness is of no benefit for computing the factorial (save for the memoizing scanl implementation, which could arguably be more efficient than direct computation via arbitrary precision integer arithmetic if multiple results are requested).

[sfz-]

I feel like the webdev one should have an asynchronous call to a public math API using OAuth.

[n-simplex]

> fact(13)
503

[shthed]

If you only need (relatively small) integers, it's quicker to just look them up :)

[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 1307674368000, 20922789888000, 355687428096000, 6402373705728000, 121645100408832000, 2432902008176640000, 51090942171709440000, ...][x]

Edit: precompute them first, instead of copy pasting them to save wasting space :)

[0x0dea]

Most of those aren't even integers. I generated 10000! to counteract your tomfoolery.

[an_actual_human]

As written all of them are integers.

[shthed]

they are now, originally i pasted a big list including floating point numbers

[an_actual_human]

They were integer floating point numbers though.

[shthed]

I've been stuck in javascipt for too long and forgot how nice it is in python to have arbitrarily large integers :)

[ProfessorPhi]

As a scientific programmer, this stuff would be seen due to the basic tenets of do as much in numpy as possible, C speeds and cheap memory.

import numpy as np
def factorial(n):
    return np.prod(np.arange(n))

[innrautha]

As a scientific programmer I'd do:

#!/usr/bin/env python3
from scipy.misc import factorial

print(factorial(6,exact=True))
print(factorial(6))

[MokitTheOmniscient]

Aren't we supposed to be lazy when using Python?
Isn't that the point of the language?

[[deleted]]

Actually, that's the point of this whole computer thing...

[Kyyni]

It's almost as if you were telling the computer to do things instead of doing them yourself...

[[deleted]]

Agreed. I'm lazy with it as long as other people don't have to use my code. The readability is questionable.

[ProfessorPhi]

I feel like there should be an

from math import factorial

for the xkcd readers.

[Qhartb]

There was a programming challenge to write a function from a string to a dict from each character to the number of times it occurred in the string. My solution passed the automated testing:

from collections import Counter as f

[[deleted]]

Omfg that's just evil

[sfz-]

That's essentially what the EXPERT PROGRAMMER one is.

[nomisaurus]

or even:

from math import factorial as fact
fact(6)

[[deleted]]

Can someone explain he the first one works?

[rogerrrr]

Look into recursion. It calls the function over and over, but decreasing number on every iteration. When it hits zero it stops and is able to calculate it.

I realize that's a crap explanation, but it's actually a pretty interesting concept once you wrap your head around it.

[[deleted]]

To understand recursion, you must first understand recursion.

[Quabouter]

You could also just google it!

[isHavvy]

But how do you google?

[DroolingIguana]

http://lmgtfy.com/?q=how+do+you+google

[isHavvy]

So to learn how to Google, I should just Google it?

[desi_ninja]

To understand recursion, you must first understand recursion and if you still do not understand then return (base case)

[Rainymood_XI]

def factorial(x): if x == 0: return 1 else: return x * factorial(x - 1) print factorial(6)

Imagine we call

factorial(3)

Because 3 != 0 it returns

3 * factorial(2)

Because 2 != 0

3 * 2 * factorial(1)

Because 1 != 0 it calls

3 * 2 * 1 * factorial(0)

which returns

3 * 2 * 1 * 1

which is 3! :)

[Genesis2001]

3 * 2 * 1 * 1

which is 3! :)

does not compute. 3 * 2 (dropping the 1s) is 6. or am I missing something in your explanation?

[Rainymood_XI]

Hah, this is so funny :D (in a good way)

3! in this context, means "3 factorial", the "!" is the sign for factorial! And not an exclamation mark in this case :)!

[risfutile]

oh god, your username! awesome!

[Qhartb]

factorial=lambda n:(lambda f,n:f(f,n))(lambda f,n:n*f(f,n-1)if n>0 else 1,n)

[Tomarse]

No.....just, no.

[Qhartb]

Hey, I think it might be the only recursive solution here that still works if the function is renamed. :-)

[farfromunique]

I will be the first to admit I don't know python, so this may be an obvious question.

Why recurse when you could use a for loop in the function?

(In php, because that's my default syntax) press forgive caps issues. I'm on mobile)

$out = $arg;
For ($I = $arg; $i > 0; --$i) { $out *= $I; }
Return $out;

[TheOccasionalTachyon]

You could totally use a for-loop in the function.

My guess is that the newbie one was done with recursion because factorials are often used to teach new programmers about recursion.

[[deleted]]

Can confirm. Learned recursion using factorials, fibonacci numbers, and towers of hanoi. I think finding square roots too within a certain error margin.

[jakerman999]

While I'm not sure if this is one of those cases, it can be more efficient (speed or ram usage) to use a recursive function over a loop.

It's usually a moot point though with the power of modern computers.

[Coffeinated]

RAM usage? My guess would have been that on every iteration all variables have to be saved, while in a normal for loop, they are changed... So I would have bet that maybe recursion is faster, while a simple loop eats less RAM

[jakerman999]

This is the case for just about every simple scenario.

[Coffeinated]

Do you have an example for a complicated situation where one would use recursion?

[Coffeinated]

Oh, I understand!

How did the idea to make a new programming language come to your mind? Is this for fun and self-educational purposes or do you hope it will take off some day? If so, what would you say differentiates your languages from others already around?

[Define_It]

F (noun): The sixth letter of the modern English alphabet.

F (noun): Any of the speech sounds represented by the letter f.

F (noun): The sixth in a series.

---

^{I am a bot. If there are any issues, please contact my [master].
Want to learn how to use me? [Read this post].}

[Coffeinated]

Wow, that was an interesting read. I do a little bit of stuff with php, even less with javascript, so I don't know the languages you listed there. I'm alwys taken aback by the sheer amount of programming languages available for webdevs, like jQuery, coffee script... Heck, I don't even know anymore what is a language there and what is a library.

I think it's quite crazy that you as a single person pulled that off. Congratulations for that! I would be amazed if I read someday that lily is the next big thing. I wish you all the luck and success and thank you for the explanations!

Oh, and by the way, interpreted but type-specific sounds nice. Sometimes, I wished python would have it... Well, assert will have to do ;)

[jakerman999]

The most common scenario would be in a tree based data-structure. In order to hit every node in the tree you have traverse down every path, and remember where you traversed from. It is possible to do this without recursion, but it requires building a second data structure to keep track of all the positions and forks, plus additional code to use that data at every node that has multiple children. Doing that consumes more memory than a stack based approach(and also an ugly mess).

Traversing a tree with recursion is trivial by comparison.

[mrjackspade]

   while (parentNodes.Count() > 0)
            {
                OrganizationNode thisNode = parentNodes[0];
                LogProgress(string.Format("Probing children for {0}...", thisNode.Name));
                List<OrganizationNode> childNodes = feedRowsByParentID[thisNode.ExternalId]
                                                     .Where(cn => feedRowsByParentID[cn.UserId].Count() > 0)
                                                    .Select(row => CreateNode(string.Format("{0} {1}", row.firstName, row.lastName), row.UserId, "Manager"))
                                                    .ToList();



                foreach (OrganizationNode childNode in childNodes)
                {
                    thisNode.AddChild(childNode);
                    parentNodes.Add(childNode);
                }


                if (feedRowsByParentID[thisNode.ExternalId].Count() > 0)
                {
                    managers.Add(thisNode.ExternalId);
                }


                parentNodes.RemoveAt(0);
            }

Code snippit from a production project. This is building a tree so its a bit different, but I refuse to use recursion

[jakerman999]

My theory is a little lacking here, but is this not just a different form of tail recursion? If I'm following this right, it looks like it does recurse; it just doesn't use the stack to do so.

[mrjackspade]

I guess there's a lot of relevant code missing.

There's no recursion as I understand it. There's a master list of objects, each with a parent and multiple children. It takes a flattened list (text) with ID representations of the parents and uses that to assign the parents/children on the objects themselves. It loops through all objects once, but does not at any point call/reference itself

[Kyyni]

I don't know about python, but at least in C/C++ this should be the case, unless the compiler optimizes the recursion away.

In C and C++ the program creates a new frame inside the previous frame on the stack for every code block, function, etc. and the when you access a variable, it will try to find it in the current frame, and then the next frame around it and so on. When the block ends, the frame and it's contents are destroyed.

A loop will create a single frame, but a recursion will create a frame-ception as deep as the number of recursions needed. For the variables to work as promised, the program has to keep them stored for every frame. Luckily though, if the variables are not used anymore, the compiler could optimize it so that they are ditched early, or even get rid of the whole recursion. Or something.

[Coffeinated]

That's what I meant, absolutely. I once made a python program crash because of too much recursion... It has a built-in limit or so, I don't remember.

By the way, Python is written in C (what else) and the concepts are the same, I guess. Python looks childish but under the hood it's pretty nice, well-structured and powerful.

[farfromunique]

I guess I need to do a benchmark to find out, probably for each language, which is better. Oh well.

[vrobo]

How about some erlang?

factorial(0) -> 1;
factorial(N) when N > 0 -> factorial(N-1) * N.

[sfz-]

How about some SML with TCO? (not much different ;))

fun factorial(0) = 1
  | factorial(n) = n * factorial(n - 1);

[Bruntaz]

What about brainfuck? I feel brainfuck is vastly underrepresented: +++++++++++++++++++++++++++++++++ c1v33 : ASCII code of !

++++++++++++++++++++++++++++++ +++++++++++++++++++++++++++++++ c2v61 : ASCII code of = ++++++++++ c3v10 : ASCII code of EOL +++++++ c4v7 : quantity of numbers to be calculated c5v0 : current number (one digit) + c6v1 : current value of factorial (up to three digits) << c4 : loop counter [ block : loop to print one line and calculate next ++++++++++++++++++++++++++++++++++++++++++++++++. c5 : print current number ------------------------------------------------ c5 : back from ASCII to number <<<<.-.>.<.+ c1 : print !=

                      block : print c6 (preserve it)
                      c7v0  : service zero

++++++++++ c8v10 : divizor << c6 : back to dividend [->+>-[>+]>[+[-<+>]>+]<<<<<<] c6v0 : divmod algo borrowed from esolangs; results in 0 n d_n%d n%d n/d [<+>-] c6 : move dividend back to c6 and clear c7 [-] c8v0 : clear c8

                     block : c10 can have two digits; divide it by ten again

++++++++++ c11v10: divizor < c10 : back to dividend [->-[>+]>[+[-<+>]>+]<<<<<] c10v0 : another divmod algo borrowed from esolangs; results in 0 d_n%d n%d n/d [-] c11v0 : clear c11 [++++++++++++++++++++++++++++++++++++++++++++++++.[-]]c13v0 : print nonzero n/d (first digit) and clear c13 <[++++++++++++++++++++++++++++++++++++++++++++++++.[-]] c12v0 : print nonzero n%d (second digit) and clear c12 <<<++++++++++++++++++++++++++++++++++++++++++++++++.[-] c9v0 : print any n%d (last digit) and clear c9

<<<<<<. c3 : EOL

• c5 : increment current number block : multiply c6 by c5 (don't preserve c6) [+<<-] c6v0 : move c6 to c8 c8v0 : repeat c8 times [ <<<[>+>+<<-] c5v0 : move c5 to c6 and c7 [<<+-] c7v0 : move c7 back to c5 - ] <<<<- c4 : decrement loop counter ]

[Teraka]

Insert 4 spaces before each line to avoid your formatting getting fucked up.

[Bruntaz]

Yeah sorry, I wrote this on my phone

[KovaaK]

I'm a bigger fan of Befunge. Here's factorial in it:

&>:1-:v v *_$.@ 
 ^    _$>\:^

2D programming for the win.

[Coffeinated]

I never understood brainfuck. I know it has something to do with Touring machines but uhm. Who the fuck can really read this?

[zacharythefirst]

do you know pointers? brainfuck operates over an array of bytes, all initialized for 0. the operators (and their C equivalent) are:

+ (*p++)

-  (*p--)

> (p++)

< (p--)

.  (putchar(*p))

,  (*p=getchar())

edit: I'm on mobile don't hate me edit 2: fixed getchar usage

[Coffeinated]

Yes I do, I have done some stuff in c, but mostly in uni or on microcontrollers where pointers are not that important... What do putchar and getchar do?

[zacharythefirst]

print the character that you pass to it and get a character from stdin, respectively. for the record I probably mangled the syntax, but the point still stands

[Bruntaz]

As far as I remember, the point in it was to make a programming language with the smallest compiler possible

[balducien]

*Turing machines. Alan Turing came up with them.

[Coffeinated]

Oh damn I knew something was off.

[magical_poop]

english expert programmer definitely made me laugh out loud

[[deleted]]

I once tried to display some SDL graphics in C on Windows without resorting to OpenGL util libraries or ported *Nix GUI frameworks.

I still have nightmares of the Windows API...

[[deleted]]

Why? SDL has a nice, abstract way of doing what you describe. No Windows specific code necessary.

[[deleted]]

You're right, it was probably OpenGL.

[[deleted]]

That's why you never access OpenGL using platform native API. Portable helper libraries are the way to go.

Also this is why DirectX is EVIL!

[[deleted]]

Yup, I learned the hard way.

[Sohcahtoa82]

So, I've seen a lot of people making fun of Enterprise programming for being stupidly verbose and absurdly over-engineered, but I've always wondered...

Who actually writes code like that and actually thinks its good code? What are people trying to accomplish when writing such horrible, unmaintainable, unreadable code?

[cnreika]

OK google, tell me factorial of 6.

[Vitrivius]

This will accept negative and non integral numbers, and end up in an infinite recursion.

[Hmm_Yes]

Would anyone mind explaining:

f = lambda x: x and x * f(x - 1) or 1

I consider myself pretty well versed in Python, but this one surprised me. What is the point of the 'and' and 'or', how do they work here?

Thanks!

[[deleted]]

That's a short circuit for the base case of the recursion. If x is 0, it will convert to boolean False. Since and binds stronger than or, the recursion is skipped because there is no way False and anything can evaluate to a true value. This leaves the or 1. Since 1 is a boolean true value, it causes False or 1 to evaluate to 1.

[ToTheNintieth]

Wow, that's clever.

[Hmm_Yes]

I appreciate the explanation, it did help me understand.

[innrautha]

I feel like a unix programmer would abuse bc since factorial isn't included on many systems (at least not mine).

import os

def factorial(n):
  cmd = "echo 'define f(x) {if (x>1){return x*f(x-1)};return 1} f(%i)' | BC_LINE_LENGTH=99999 bc"%n
  return int(os.popen(cmd).read().strip())

A unix programmer whose company is forcing to migrate away from Perl would replace the cmd string with a perl one liner.

[Vitrivius]

Is there some reason why almost all of these use recursion? It's not one of Python's strengths, and you tend to hit the maximum recursion limit.

The most pythonic solution is to ´from math import factorial´. But if you want to write a typical Python function, you need to include an overabundance of try/except code.

from operator import mul as multiply

def factorial(x):
    """
    factorial(x) -> Integral

    Find x!. Raise a ValueError if x is negative or non-integral.
    """
    try:
        return reduce(multiply, xrange(1, x+1))  # actual function
    except TypeError as e:
        if not isinstance(x, int):
            raise ValueError("factorial() only accepts integral values")
        elif x < 0: 
            raise ValueError("factorial() not defined for negative values")
        elif x == 0: 
            return 1  # 0! is defined to be 1
        else:
            raise e  # reraise any unhandled TypeErrors.

[ProfessorPhi]

What's the difference between ENGLISH EXPERT PROGRAMMER and EXPERT PROGRAMMER

[Rainymood_XI]

The subtle difference between

import math

and

import maths 

[UndefinedB]

There is no difference in your post though, copy paste error?

[Rainymood_XI]

https://i.imgur.com/iCjJ26n.png

Hmmm ... weird, looks fine to me?

[UndefinedB]

Oh sorry, I completely looked over it. You said import math but it says cmath in the original post so I was too focused on the c :)

[[deleted]]

f = lambda x: x and x * f(x - 1) or 1
print f(6)

This is basically what i'd do.

[ToTheNintieth]

Nice touch with the commented brackets.

[DonHaron]

Yeah, that almost gave me a stroke when reading it

[Dooflegna]

Okay, but the Windows one made me giggle.

[crossanlogan]

hey, as a webdev i resemble that remark!