Can you create a global variable which you can check to decide how much you want to print ? By doing that you can control the amount of logging as you require.

  if printLevel > 3:
      print("Bobby hits a fly ball for an out")

Not is very similar to the if condition !=. If a value is truthy, then it returns false. If a value is falsy, it returns true. Since most strings are truthy, it returns false, and since a None value is falsy, it returns true so for example print(not(True)) would return false and print(not(False)) would return true

Python does not automatically call main() (and you'll need to use the sys library to get argv).

#!/usr/bin/python

import sys

def main():
    print  "hell0\n"

main()

Output is often buffered in order to preserve system resources. This means that in this case, the system holds back the Python output until there's enough to release together.

To overcome this, you can explicitly "flush" the output:

import sys, json

# simple JSON echo script
for line in sys.stdin:
    print(json.dumps(json.loads(line)))
    sys.stdout.flush()                      # <--- added line to flush output

If you're using Python 3.3 or higher, you may alternatively use:

import sys, json

# simple JSON echo script
for line in sys.stdin:
    print(json.dumps(json.loads(line)), flush=True)   # <--- added keyword

Your program does not output anything because you are never calling your function.

This will do what you expect:

def GetNum():
    x = int(input("Input something: "))
    while (x > 0):
        x = int(input("Input something: "))

    print(x)

GetNum()

I removed the function argument Text, added a call to the GetNum function and added type conversions from str to int for both input() calls.

def bla(value, rep):
    try:
        print value*rep
    except TypeError:
        print "sorry '%s' is not a valid parameter" % rep

see "Ask forgiveness not permission" - explain

Use with

Based on @FakeRainBrigand solution I'm suggesting a safer solution:

import os, sys

class HiddenPrints:
    def __enter__(self):
        self._original_stdout = sys.stdout
        sys.stdout = open(os.devnull, 'w')

    def __exit__(self, exc_type, exc_val, exc_tb):
        sys.stdout.close()
        sys.stdout = self._original_stdout

Then you can use it like this:

with HiddenPrints():
    print("This will not be printed")

print("This will be printed as before")

This is much safer because you can not forget to re-enable stdout, which is especially critical when handling exceptions.

Bad practice: Without with

The following example uses enable/disable prints functions that were suggested in previous answer.

Imagine that there is a code that may raise an exception. We had to use finally statement in order to enable prints in any case.

try:
    disable_prints()
    something_throwing()
    enable_prints() # This will not help in case of exception
except ValueError as err:
    handle_error(err)
finally:
    enable_prints() # That's where it needs to go.

If you forgot the finally clause, none of your print calls would print anything anymore.

It is safer to use the with statement, which makes sure that prints will be reenabled.

Note: It is not safe to use sys.stdout = None, because someone could call methods like sys.stdout.write()

I would assume it's due to buffering. Try adding flush=True as one of the optional parameter to print.