A function, to apply a function to a list

Question

I am trying to write a function, that applies a function to a list. I am trying to capitalise all the words in a list but can't get it to work. Here is what I've done so far:

list = ("hello", "this", "is", "a", "test")

def firstFunction(x):
    return list.upper()

print firstFunction

The error I get is:

<function firstFunction at 0x0000000002352A58>

I'm really stuck on what to do next, any help would be greatly appreciated.

EDIT: I've just changed it but it's still not working:

mylist = ("hello", "this", "is", "james")

def firstFunction(x):
    return may(lambda: x.upper(), mylist)

print firstFunction()

Answer 1

That isn't an error. It is the function's address in memory. You are seeing it because you didn't invoke the function.

Overall, there are three problems with your code:

1. You are not invoking the function. Adding (...) after it will do this.
2. You are not passing in an argument to the function, which it requires.
3. There is no upper method on a tuple (list in this case is a tuple).

Below is a fixed version of the code that does what I think you want:

# Don't name a variable 'list' -- it overshadows the built-in.
lst = ("hello", "this", "is", "a", "test")

def firstFunction(x):
    return tuple(y.upper() for y in x)

print firstFunction(lst)

Output:

('HELLO', 'THIS', 'IS', 'A', 'TEST')

Here are some references on everything done here:

http://docs.python.org/2/reference/compound_stmts.html#function-definitions

https://wiki.python.org/moin/Generators

http://docs.python.org/2.7/library/stdtypes.html#str.upper

Answer 2

While other answers are great, I want to mention that there's already a function in python, called map(), and it does almost exactly what you need:

Apply function to every item of iterable and return a list of the results..... The iterable arguments may be a sequence or any iterable object; the result is always a list.

So you code becomes

print map(str.upper, lst)

or, if you need a tuple, then:

print tuple(map(str.upper, lst))

You don't need anonymous lambda function here, because str.upper() accepts one argument. I think there's a debate about how pythonic this functional programming is, but I personally like it sometimes.

Answer 3

Actually nor the list, nor the tuple has no a method .upper(). So to achieve this you could just execute this statement:

print tuple(x.upper() for x in ("hello", "this", "is", "a", "test"))

http://codepad.org/MZ14yXeV

or this one:

print map(lambda x: x.upper(), ("hello", "this", "is", "a", "test"))

http://codepad.org/kc1LaNCY

Answer 4

list = ("hello", "this", "is", "a", "test")

is a tuple, an immutable, you cannot alter it, use,

print tuple((ele.upper() for ele in list))

Answer 5

I think this is the most pythonic one:

def cap(tup):
    return map(str.upper, tup)

>>> tup = ("hello", "this", "is", "a", "test")
>>> cap(tup)
['HELLO', 'THIS', 'IS', 'A', 'TEST']
>>>

Answer 6

What you are trying to do involves list comprehensions:

print [firstFunction(x) for x in list]

what this does is: construct the list whose elements are the result of applying the function to each of the items in you input list and then printing it.

Some (hopefully helpful) comments

• It is bad practice to name a variable list; even though it is not a keyword, it is the name of a fundamental python type, so re-binding it could cause confusion elsewhere.
• In your definition def firstFunction(list) -- the name list that appears in the argument list does not have any relationship to the list variable that was defined earlier in your example. You may want to look at this question or the python documentation to understand how the scoping rules work in python.