What does the return statement do? How should it be used in Python?
How does return differ from print?
See also
Often, people try to use print in a loop inside a function in order to see multiple values, and want to be able to use the results from outside. They need to be returned, but return exits the function the first time. See How can I use `return` to get back multiple values from a loop? Can I put them in a list?.
Often, beginners will write a function that ultimately prints something rather than returning it, and then also try to print the result, resulting in an unexpected None. See Why is "None" printed after my function's output?.
Occasionally in 3.x, people try to assign the result of print to a name, or use it in another expression, like input(print('prompt:')). In 3.x, print is a function, so this is not a syntax error, but it returns None rather than what was displayed. See Why does the print function return None?.
Occasionally, people write code that tries to print the result from a recursive call, rather than returning it properly. Just as if the function were merely called, this does not work to propagate the value back through the recursion. See Why does my recursive function return None?.
Consider How do I get a result (output) from a function? How can I use the result later? for questions that are simply about how to use return, without considering print.
The print() function writes, i.e., "prints", a string in the console. The return statement causes your function to exit and hand back a value to its caller. The point of functions in general is to take in inputs and return something. The return statement is used when a function is ready to return a value to its caller.
For example, here's a function utilizing both print() and return:
def foo():
print("hello from inside of foo")
return 1
Now you can run code that calls foo, like so:
if __name__ == '__main__':
print("going to call foo")
x = foo()
print("called foo")
print("foo returned " + str(x))
If you run this as a script (e.g. a .py file) as opposed to in the Python interpreter, you will get the following output:
going to call foo
hello from inside foo
called foo
foo returned 1
I hope this makes it clearer. The interpreter writes return values to the console so I can see why somebody could be confused.
Here's another example from the interpreter that demonstrates that:
>>> def foo():
... print("hello within foo")
... return 1
...
>>> foo()
hello within foo
1
>>> def bar():
... return 10 * foo()
...
>>> bar()
hello within foo
10
You can see that when foo() is called from bar(), 1 isn't written to the console. Instead it is used to calculate the value returned from bar().
print() is a function that causes a side effect (it writes a string in the console), but execution resumes with the next statement. return causes the function to stop executing and hand a value back to whatever called it.
Think of the print statement as causing a side-effect, it makes your function write some text out to the user, but it can't be used by another function.
I'll attempt to explain this better with some examples, and a couple definitions from Wikipedia.
Here is the definition of a function from Wikipedia
A function, in mathematics, associates one quantity, the argument of the function, also known as the input, with another quantity, the value of the function, also known as the output..
Think about that for a second. What does it mean when you say the function has a value?
What it means is that you can actually substitute the value of a function with a normal value! (Assuming the two values are the same type of value)
Why would you want that you ask?
What about other functions that may accept the same type of value as an input?
def square(n):
return n * n
def add_one(n):
return n + 1
print square(12)
# square(12) is the same as writing 144
print add_one(square(12))
print add_one(144)
#These both have the same output
There is a fancy mathematical term for functions that only depend on their inputs to produce their outputs: Referential Transparency. Again, a definition from Wikipedia.
Referential transparency and referential opaqueness are properties of parts of computer programs. An expression is said to be referentially transparent if it can be replaced with its value without changing the behavior of a program
It might be a bit hard to grasp what this means if you're just new to programming, but I think you will get it after some experimentation.
In general though, you can do things like print in a function, and you can also have a return statement at the end.
Just remember that when you use return you are basically saying "A call to this function is the same as writing the value that gets returned"
Python will actually insert a return value for you if you decline to put in your own, it's called "None", and it's a special type that simply means nothing, or null.
I think the dictionary is your best reference here
Return and Print
In short:
return gives something back or replies to the caller of the function while print produces text
In python, we start defining a function with def, and generally - but not necessarily - end the function with return.
Suppose we want a function that adds 2 to the input value x. In mathematics, we might write something like f(x) = x + 2, describing that relationship: the value of the function, evaluated at x, is equal to x + 2.
In Python, it looks like this instead:
def f(x):
return x + 2
That is: we define a function named f, which will be given an x value. When the code runs we figure out x + 2, and return that value. Instead of describing a relationship, we lay out steps that must be taken to calculate the result.
After defining the function, it can be called with whatever argument you like. It doesn't have to be named x in the calling code, and it doesn't even have to be a variable:
print f(2)
>>> 4
We could write the code for the function in some other ways. For example:
def f(x):
y = x + 2
return y
or even
def f(x):
x = x + 2
return x
Again, we are following steps in order - x = x + 2 changes what x refers to (now it means the result from the sum), and that is what gets returned by return x (because that's the value *at the time that the return happens).
return means "output this value from this function".
print means "send this value to (generally) stdout"
In the Python REPL, a function's return value will be output to the screen by default (this isn't the same as printing it). This output only happens at the REPL, not when running code from a .py file. It is the same as the output from any other expression at the REPL.
This is an example of print:
>>> n = "foo\nbar" #just assigning a variable. No output
>>> n #the value is output, but it is in a "raw form"
'foo\nbar'
>>> print(n) #the \n is now a newline
foo
bar
>>>
This is an example of return:
>>> def getN():
... return "foo\nbar"
...
>>> getN() #When this isn't assigned to something, it is just output
'foo\nbar'
>>> n = getN() # assigning a variable to the return value. No output
>>> n #the value is output, but it is in a "raw form"
'foo\nbar'
>>> print(n) #the \n is now a newline
foo
bar
>>>
This answer goes over some of the cases that have not been discussed above.
The return statement allows you to terminate the execution of a function before you reach the end. This causes the flow of execution to immediately return to the caller.
In line number 4:
def ret(n):
if n > 9:
temp = "two digits"
return temp #Line 4
else:
temp = "one digit"
return temp #Line 8
print("return statement")
ret(10)
After the conditional statement gets executed the ret() function gets terminated due to return temp (line 4).
Thus the print("return statement") does not get executed.
Output:
two digits
This code that appears after the conditional statements, or the place the flow of control cannot reach, is the dead code.
Returning Values
In lines number 4 and 8, the return statement is being used to return the value of a temporary variable after the condition has been executed.
To bring out the difference between print and return:
def ret(n):
if n > 9:
print("two digits")
return "two digits"
else :
print("one digit")
return "one digit"
ret(25)
Output:
two digits
'two digits'
Note that return can also be used for control flow. By putting one or more return statements in the middle of a function, we can say: "stop executing this function. We've either got what we wanted or something's gone wrong!"
For example, imagine trying to implement str.find(sub) if we only had str.index(sub) available (index raises a ValueError if the substring isn't found, whereas find returns -1).
We could use a try/except block:
def find(s: str, sub: str) -> int:
try:
return s.index(sub)
except ValueError:
return -1
This is fine, and it works, but it's not very expressive. It's not immediately clear what would cause str.index to raise a ValueError: a reader of this code must understand the workings of str.index in order to understand the logic of find.
Rather than add a doc-string, saying "...unless sub isn't found, in which case return -1", we could make the code document itself, like this:
def find(s: str, sub: str) -> int:
if sub not in s:
return -1
return s.index(sub)
This makes the logic very clear.
The other nice thing about this is that once we get to return s.index(sub) we don't need to wrap it in a try/except because we already know that the substring is present!
See the Code Style section of the Python Guide for more advice on this way of using return.
To put it as simply as possible:
return makes the value (a variable, often) available for use by the caller (for example, to be stored by a function that the function using return is within). Without return, your value or variable wouldn't be available for the caller to store/re-use.
print, by contrast, prints to the screen - but does not make the value or variable available for use by the caller.
Difference between "return" and "print" can also be found in the following example:
RETURN:
def bigger(a, b):
if a > b:
return a
elif a <b:
return b
else:
return a
The above code will give correct results for all inputs.
PRINT:
def bigger(a, b):
if a > b:
print a
elif a <b:
print b
else:
print a
NOTE: This will fail for many test cases.
ERROR:
----
FAILURE: Test case input: 3, 8.
Expected result: 8
FAILURE: Test case input: 4, 3.
Expected result: 4
FAILURE: Test case input: 3, 3.
Expected result: 3
You passed 0 out of 3 test cases
Here is my understanding. (hope it will help someone and it's correct).
def count_number_of(x):
count = 0
for item in x:
if item == "what_you_look_for":
count = count + 1
return count
So this simple piece of code counts number of occurrences of something. The placement of return is significant. It tells your program where do you need the value. So when you print, you send output to the screen. When you return you tell the value to go somewhere. In this case you can see that count = 0 is indented with return - we want the value (count + 1) to replace 0.
If you try to follow logic of the code when you indent the return command further the output will always be 1, because we would never tell the initial count to change.
I hope I got it right.
Oh, and return is always inside a function.
return should be used for recursive functions/methods or you want to use the returned value for later applications in your algorithm.
print should be used when you want to display a meaningful and desired output to the user and you don't want to clutter the screen with intermediate results that the user is not interested in, although they are helpful for debugging your code.
The following code shows how to use return and print properly:
def fact(x):
if x < 2:
return 1
return x * fact(x - 1)
print(fact(5))
This explanation is true for all of the programming languages not just python.
return is part of a function definition, while print outputs text to the standard output (usually the console).
A function is a procedure accepting parameters and returning a value. return is for the latter, while the former is done with def.
Example:
def timestwo(x):
return x*2
Best thing about return function is you can return a value from function but you can do same with print so whats the difference ?
Basically return not about just returning it gives output in object form so that we can save that return value from function to any variable but we can't do with print because its same like stdout/cout in C Programming.
Follow below code for better understanding
CODE
def add(a, b):
print "ADDING %d + %d" % (a, b)
return a + b
def subtract(a, b):
print "SUBTRACTING %d - %d" % (a, b)
return a - b
def multiply(a, b):
print "MULTIPLYING %d * %d" % (a, b)
return a * b
def divide(a, b):
print "DIVIDING %d / %d" % (a, b)
return a / b
print "Let's do some math with just functions!"
age = add(30, 5)
height = subtract(78, 4)
weight = multiply(90, 2)
iq = divide(100, 2)
print "Age: %d, Height: %d, Weight: %d, IQ: %d" % (age, height, weight, iq)
# A puzzle for the extra credit, type it in anyway.
print "Here is a puzzle."
what = add(age, subtract(height, multiply(weight, divide(iq, 2))))
print "That becomes: ", what, "Can you do it by hand?"
We are now doing our own math functions for add, subtract, multiply, and divide. The important thing to notice is the last line where we say return a + b (in add). What this does is the following:
Our function is called with two arguments: a and b.
We print out what our function is doing, in this case "ADDING."
Then we tell Python to do something kind of backward: we return the addition of a + b. You might say this as, "I add a and b then return them."
Python adds the two numbers. Then when the function ends, any line that runs it will be able to assign this a + b result to a variable.
The simple truth is that print and return have nothing to do with each other. print is used to display things in the terminal (for command-line programs).1 return is used to get a result back when you call a function, so that you can use it in the next step of the program's logic.
Many beginners are confused when they try out code at Python's interpreter prompt2, like
>>> def example():
... return 1
...
>>> example()
1
The value was displayed; doesn't this mean that return displays things? No. If you try the same code in a .py file, you can see for yourself that running the script doesn't cause the 1 to display.
This shouldn't actually be confusing, because it works the same way as any other expression:
>>> 1 + 1
2
This displays at the interactive prompt, but not if we make a script that just says 1 + 1 and try running it.
Again: if you need something to display as part of your script, print it. If you need to use it in the next step of the calculation, return it.
The secret is that the interactive prompt is causing the result to be displayed, not the code. It's a separate step that the prompt does for you, so that you can see how the code works a step at a time, for testing purposes.
Now, let's see what happens with print:
>>> def example():
... return 'test'
...
>>> print(example())
test
The result will display, whether we have this in an interactive prompt or in a script. print is explicitly used to display the value - and as we can see, it displays differently. The interactive prompt uses what is called the repr of the value that was returned from example, while print uses the str of the value.
In practical terms: print shows us what the value looks like, in text form (for a string, that just means the contents of the string as-is). The interactive prompt shows us what the value is - typically, by writing something that looks like the source code we would use to create it.3
But wait - print is a function, right? (In 3.x, anyway). So it returned a value, right? Isn't the interpreter prompt supposed to display that in its separate step? What happened?
There is one more trick: print returns the special value None, which the interpreter prompt will ignore. We can test this by using some expressions that evaluate to None:
>>> None
>>> [None][0]
>>> def example():
... pass # see footnote 4
...
>>> example()
>>>
In each case, there is no separate line at all for output, not even a blank line - the interpreter prompt just goes back to the prompt.
1 It can also be used to write into files, although this is a less common idea and normally it will be clearer to use the .write method.
2 This is sometimes called the REPL, which stands for "read-eval-print loop".
3 This isn't always practical, or even possible - especially once we start defining our own classes. The firm rule is that repr will lean on the .__repr__ method of the object to do the dirty work; similarly, str leans on .__str__.
4 Functions in Python implicitly return None if they don't explicitly return a value.
Return statement -- will return some values according your function.
def example(n):
if n == 5:
return true
else:
return false
if you call above function and you pass number 5 then it will return true else it will return false.
Printing function -- it will print content that you have given to the print function or with in print function bracket.
def example(n):
if n == 5:
print("number is equal")
else:
print("number is not equal")
Related
In the following code i am try to find kth factor of given number it's works fine until i created function and pass value to it can anyone tell me why it's returning wrong output.
when you call function only ones no matter what number you pass it shows correct output but when call function two time it returning wrong output.
#Code
fact = []
def factor(N,k):
for i in range(1,N+1):
if N % i == 0:
fact.append(i)
if len(fact)<k:
print(1)
else:
print(fact[k])
factor(12,3)
factor(30,9)
You have defined the fact variable of type list outside your function. So it is being referenced and used by both functions calls when you call it twice.
If you declare fact inside the function the scope of the variable will not persist and the number of times it is called will not be an issue.
def factor(N,k):
fact = []
for i in range(1,N+1):
if N % i == 0:
fact.append(i)
if len(fact)<k:
print(1)
else:
print(fact[k])
Could anyone provide insight into why my program keeps terminating when I am trying to break?
Below is the prompt:
Write a function that returns a list of numbers, say make_list. make_list will not take any arguments. In the function body, construct an empty list and then prompt the user to enter a nonnegative number, -999 to quit. You will need a loop. If the user enters a number other than -999, add it to the list. Once the user enters -999, quit the loop and return the list. (Do not include -999 in the list.)
Write another function, say sum_list, that takes a list of numbers as an argument and returns the sum of the list of numbers. If the list is empty return 0. Do not use the built-in sum function. Use a loop.
You need to call both functions. First call the make_list function. Then use the returned list as the argument for the sum_list function. Print the result.
My solution:
def make_list():
i=[]
while(True):
n=int(input("Enter a number (-999 to quit): "))
if n==-999:
break
i+=[n]
return i
def sum_list(i):
if len(1)==0:
return 0
sum1=0
for k in i:
sum1+=k
return sum1
i=make_list()
s=sum_list(i)
print("Sum :", s)
This question already has answers here:
Why does my recursive function return None?
(4 answers)
Closed 3 years ago.
I am trying to implement Euclid's algorithm for computing the greatest common divisor using recursion. Below is the code for the same.
def euclid(a,b):
if a>b:
r=a%b
if (r == 0):
return b
else:
a=b
b=r
euclid(a,b)
print(euclid(20,4)) # Returns 4
print(euclid(20,8)) # Returns None
For the first data set, I get the correct result. But for euclid(20,8) I get a return of None.
While checking in the debugger, I did see the return value of b become 4 but then for some reason, my code jumps to euclid(a,b) and returns None.
The major takeaway here would be to understand why the code does not return 4 but jumps to the euclid(a,b) and return None.
Please refrain from giving alternative code solutions but you are very much encouraged to point out the reason for the current behaviour of the code.
The reason for that code to return None at some point is that in your control flow you eventually end up in a situation where there is no return statement, e.g. for a <= b in your first if or when r != 0 in your second if. The default behavior of Python in that case is to return None, as you seems to have discovered the hard way.
def euclid(a,b):
if a>b:
r=a%b
if (r == 0):
return b
else: # <--- no `return` in this branch!
a=b
b=r
euclid(a,b)
# else: # <--- no `return` in this branch!
# ...
Here is an updated version of your code, that addresses that and also a number of other issues:
the name of the function should be meaningful: Euclid is kind of popular and there is a bunch of things named after him, better specify that you actually want to compute the greatest common divisor (GCD)
the first if is not really needed, as it is taken care of by the subsequent code: computing r and the recursive call will take care of swapping a and b if a < b, and if a == b then r == 0, so you b is being returned directly
a = b and b = r are useless, do not use them, just have your recursive call use b and r directly
the second if can be written more clearly in one line
def gcd_euclid_recursive(a, b):
r = a % b
return gcd_euclid_recursive(b, r) if r else b
gcd_euclid_recursive(120, 72)
# 24
gcd_euclid_recursive(64, 120)
# 8
You don't actually return anything in the else path so it just assumes you know best and returns None for you.
The only reason you get 4 for print(euclid(20,4)) is because 4 is a factor of 20 so never uses the else path. Instead it returns b immediately. For anything else, the thing returned from the first recursive call to euclid() will always be None (even if a lower call to that function returns something, you throw it away when returning from the first call).
You need return euclid(a,b) rather than just euclid(a,b).
As an aside (this isn't necessary to answer your specific question but it goes a long way toward improving the implementation of the code), I'm not a big fan of the if something then return else … construct since the else is totally superfluous (if it didn't return, the else bit is automatic).
Additionally, you don't need to assign variables when you can just change what gets passed to the next recursive level.
Taking both those into account (and simplifying quite a bit), you can do something like:
def euclid(a, b):
if b == 0: return a
return euclid(b, a % b)
Your code has an indentation error and one path is missing in your code(r!=0). It should be
def euclid(a,b):
if a>=b:
r=a%b
if (r == 0):
return b
return euclid(b, r)
else:
return euclid(b, a)
I am new to python and i have written the code below but there are 2 to 3 problems with it .
While loop does not print the else statement when
ever i enter 6 or 7 it again asks for input .
Once while loop was started for one function for
example addTwoNumbers it would remain in it that i have handled
through the return is there any other way to do that also ?
Thanks
def main():
choice=menu()
while choice!='5':
num1=int(input("enter first number: "))
num2=int(input("enter the second number: "))
if choice=='1':
total= addTwoNumber(num1,num2)
print("sum of two numbers is: ",total)
conti=contin()
return
elif choice=='2':
sub=minTwoNumber(num1,num2)
print("num1-num2",sub)
conti=contin()
return
elif choice=='3':
quo,remain=qrTwoNumber(num1,num2)
print(quo)
print(remain)
conti=contin()
return
else:
print("Wrong Option.Kindly choose between 1 to 4 : ")
choice=menu()
def menu():
print("Welcome to the menu.Kindly choose from below: ")
print("1.To add two numbers: ")
print("2.To subtract two numbers: ")
print("3.For quotient and remainder :")
print("4.Exit Program")
opt=input("Enter number between 1-4")
if opt=='4':
print('Exiting program')
return opt
def addTwoNumber(n1,n2):
sum=n1+n2
return sum
def minTwoNumber(a1,a2):
minus=a1-a2
return minus
def qrTwoNumber(q1,q2):
quotient=q1//q2
remainder=q1%q2
return quotient,remainder
def contin():
con=input("Do you want to continue (Y/N):")
if con=='y' or con=='Y':
choice=menu()
else:
print("Exiting program")
sys.exit()
main()
These are some mistakes:
while choice!='5' should be while choice!='4'
You are returning after if statements. That exits from the loop.
In that if statements you are calling contin() but storing the return value in conti but you are not using it. It should be choice.
In the contin() you are not returning the choice.
Your problems are related, the control flow of your program is mixed up, and you need to be aware of variable scope. As a short example your menu is doing this:
def main():
choice = 5
print(choice)
contin()
print(choice)
def contin():
choice = 10
main()
It sets 'choice' in the top main function, and then tries to change it later on in the contin function. Those are actually two different variables with the same name. The variable scope is only inside the function where the value was set.
Therefore, since the value of choice never changes in main(), the while loop can never quit, the math function can never be different, and you are stuck doing the same math function over and over again.
And the way the program needs to work is like this:
menu
-> choice
-> numbers
-> math
<-
menu
-> choice
-> numbers
-> math
<-
menu
-> choice
-> numbers
-> math
<-
menu
# you quit here, and the program exits
But your code goes into conti() which then goes into main() again, so it gets more and more nested, like this:
menu
-> choice
-> numbers
-> math
-> menu
-> choice
-> numbers
-> math
-> menu
-> choice
-> numbers
-> math
-> menu
# you try to quit here but end up
choice #back at this level
That means that when you eventually press 7 to quit the menu, instead of exiting the program, you exit the last conti() call and are put back up to the top of the while loop, and prompted for more numbers.
The real issue with your code is that the control flow doesn't work how you think it does.
Pretend to be your computer. Take a hard look at your code, looking at it line by line.
The first bit of code that is run is main(). So look at that function.
Inside main, you first call your menu and get a number from your user.
Next, you set up a loop. As long as this first number from the user isn't 5, your loop will run. For now, we'll pretend the user entered 1.
Then you get two numbers as input from your user. That works fine.
Since they entered 1 as the choice, the condition for your first if statement (choice=='1') is true, so the code inside gets run.
You addTwoNumber function is run, and the returned output is stored in total.
Next, you call contin() and store its output in conti. But take a look inside contin(), let's go line-by-line in this function.
You ask the user if they want to continue, and if they enter y (or Y), you call menu() again and store its output in choice, which your loop checks, right? Well, that's not quite right. The thing is, whenever you define a variable in a function, that variable only exists inside that function. Functions can't see the variables inside other functions (unless you pass them as parameters, or you use global variables... but you really shouldn't use global variables). So the choice variable you're using in contin belongs to that function, but there's another, separate variable that also has the name choice for the main function!
To fix this, you can change the choice=menu() line to return menu(). Then change conti=contin() to choice=contin().
Also, you don't need those returns after you call contin(). If you return there, your function will exit, and your loop will stop running.
Here's a portion of your code with the fixes I mentioned. Do you understand why it works? Can you figure out what else has to be changed for everything to be fixed?
def main():
choice = menu()
while choice != '5':
num1 = int(input("enter first number: "))
num2 = int(input("enter the second number: "))
if choice == '1':
total = addTwoNumber(num1, num2)
print("sum of two numbers is: ", total)
choice = contin()
elif choice == '2':
and
def contin():
con = input("Do you want to continue (Y/N):")
if con == 'y' or con == 'Y':
return menu()
else:
I'm making a little toy command window with Tk, and currently trying to make it copy some interpreter behavior.
I'd never scrutinized the interpreter before, but it's decisions on when to print a value are a little mystifying.
>>> 3 + 4 # implied print(...)
7
>>> 3 # implied print(...)
3
>>> a = 3 # no output, no implied print(...), bc result is None maybe?
>>> None # no output, no print(...) implied... doesn't like None?
>>> print(None) # but it doesn't just ban all Nones, allows explicit print()
None
>>> str(None) # unsurprising, the string 'None' is just a string, and echoed
'None'
The goal is to mimic this behavior, printing some Nones, not others (made slightly more complicated because I'm not entirely sure what the rules are).
So, turning to my program, I have history_text and entry_text, which are StringVar()s that control a label above an entry box in the Tk window. Then the following event is bound to the Return key, to process commands and update the history with the result.
def to_history(event):
print("command entered") # note to debugging window
last_history = history_text.get()
# hijack stdout
buffer = io.StringIO('')
sys.stdout = buffer
# run command, output to buffer
exec(entry_text.get())
# buffered output to a simple string
buffer.seek(0)
buffer_str = ''
for line in buffer.readlines():
# maybe some rule goes here to decide if an implied 'print(...)' is needed
buffer_str = buffer_str + line + '\n'
# append typed command for echo
new_history = entry_text.get() + '\n' + buffer_str
# cleanup (let stdout go home)
sys.stdout = sys.__stdout__
buffer.close()
history_text.set(last_history + "\n" + new_history)
entry_text.set('')
As is, it does not provide any output for a simple entry of '3' or 'None' or even '3 + 4'. Adding an implied print() statement all the time seems to print too often, I don't skip the print for 'None' or 'a = 3' type statements.
I found some documentation for sys.displayhook, which seems to govern when the interpreter will actually display a result, but I'm not sure how to use it here. I thought I could just wrap sys.displayhook() around my exec() call, and have it do all this work for me... but found that it does not imply print() statements for statements like '3 + 4' or '3'.
Any suggestions? Am I on the right track with sys.displayhook?
The interpreter prints out repr(result) only if result is not None.
There are no "implied prints" like you thought.
3 + 4 results to 7, so repr(7) is printed
a = 3 is an assignment, I think nothing is printed because it does not work with eval
None results to None, so nothing is printed
print(None) results to None (because the print function returns nothing), so nothing is printed. However, the print function itself printed the None.
I honestly didn't read your code, but here's a function that takes a string with code and produces the same output as the interpreter would:
def interactive(code):
try:
result = eval(code)
if result is not None:
print(repr(result))
except SyntaxError:
exec(code)