somelist.remove(x) removes the first element it finds that equals x from somelist. It doesn't return the modified list. To print the modified list, simply print the list.

print(Question_tk_l)

If you want to turn it into a nice string, you should join it with space.

print(' '.join(Question_tk_l))

You can specify a default value, to return, in case no element matches. Something like:

def html_check(td, text):
        if td.text == text:
            value = td.find_next('td').text
            return value
        return "Default Value"

Also, you can spcify the default value via argument, which would somewhat look like :

 def html_check(td, text, default_value):
            if td.text == text:
                value = td.find_next('td').text
                return value
    return default_value

And, then use it like:

for tr in table_body.find_all('tr'):      
            for td in tr:  
                description= html_check(td, 'Description', 'Default Description')
                category = html_check(td, 'Category','Default Category')
                department = html_check(td, 'Department', 'Default Department')
                justification = html_check(td, 'Justification', 'Default Justification')
print(description, category, department, justification)

Remove the print() call, the function is returning None.

The default return value of a function is None in python. If you're printing inside a function and not returning anything from it then there's no need of print() when calling the function.

Demo:

>>> def func():
...     print ("foo")
...     
>>> print(func())
foo
None
>>> func()      #works fine without `print()`
foo

I think returning None is a "no go" from a usability standpoint rather than style. As briefly mentioned in this answer, consider raising an exception instead. For example:

def foobar(arg):
    # connect to page by httplib
    # check for arg in a certain pattern by lxml
    if not check:
        raise ValueError("arg did not match pattern in lxml")         
    return result

try:
    result = foobar(arg)
except ValueError:
    result = None

if result is not None:
    # do stuff
else:
    # do other stuff

The advantage of this approach is that it makes it explicit when there is not a match. Other people using your function won't need to know that None is the return value they should expect when there isn't a match and they can handle the exception as they see fit.

Use isupper,

def remove_upper_case(x):
        return ''.join(i for i in x if not i.isupper())

Execution:

In [281]: remove_upper_case("Georgia Institute of Technology")
Out[281]: 'eorgia nstitute of echnology'

In [282]: remove_upper_case("A1B2C3D")
Out[282]: '123'

Per PEP-20, explicit is better than implicit, so when I'm writing code where None is a valid answer, I explicitly return a None. If it's an error to get to the end, raise an error.

If it's a hack/preliminary code, I don't care. For production level code, I have one return and it's the last line of the function/method. For a short function, I don't really care, but definitely for a long function.

remove mutates the list in-place, and returns None. You have to put it in a variable, and then change that:

>>> var = ['p', 's', 'c', 'x', 'd']
>>> var.remove('d')   # Notice how it doesn't return anything.
>>> var
['p', 's', 'c', 'x']

To expound on what others have said, I use a return None if the function is supposed to return a value. In Python, all functions return a value, but often we write functions that only ever return None, because their return value is ignored. In some languages, these would be called procedures.

So if a function is supposed to return a value, then I make sure all code paths have a return, and that the return has a value, even if it is None.

If a function "doesn't" return a value, that is, if it is never called by someone using its return value, then it's ok to end without a return, and if I need to return early, I use the bare form, return.