Can I create a List of functions in python?

Can I create a List of functions in python? - python

I am trying to create a list of functions in my program in order to use the random module to randomly choose. in theory it look and work with this
import random
def test1():
print("1st function")
def test2():
print("2nd function")
def test3():
print("3rd function")
def test_func():
test_list = [test1(), test2(), test3()]
apple = random.choice(test_list)
return print(apple)
test_func()
the result of this is it prints out test_list and prints "NONE" for apple is there a way to get it to randomly pick a function and only print that function.

you should add function reference to the list and call the function after.
def test_func():
test_list = [test1, test2, test3]
apple = random.choice(test_list)()

The problem here is that you are assigning the list the return values of the functions you created. Since they do not have a return value, it will be None.
What you need to do is assign the function itself by removing the parenthesis. You would also need to call the apple function by adding the parenthesis to it, not by printing it. So, your code will look like this:
import random
def test1():
print("1st function")
def test2():
print("2nd function")
def test3():
print("3rd function")
def test_func():
test_list = [test1, test2, test3]
apple = random.choice(test_list)
apple()
test_func()

def test1():
print("1st function")
#This returns "None"
The reason you are getting "None" printed to console is because you are printing the function, which does return a NoneType. Return defaults to None if not specified. To make it only print the desired function remove the line return print(apple)
You would also want to store references to your functions:
test_list = [test1, test2, test3]
so that they are not executed. Then you can run apple() to execute them in your main function.

Yes, just don't call the functions when you put them in the list:
import random
def test1():
print("1st function")
def test2():
print("2nd function")
def test3():
print("3rd function")
def test_func():
test_list = [test1, test2, test3]
apple = random.choice(test_list)
return apple() #won't return anything due to it being a print function
test_func()

Related

Python Decorator is spitting out None

I am learning some new topics in python, and I finally got to decorators, which seems cool and all except theres one major issue. Below is the code I have running:
def new_dec(ori_func):
def WrapFunc():
print("First Line")
ori_func()
print("Second line")
return WrapFunc
def new_func():
print("This is the new function")
ThisFunc = new_dec(new_func)
print(ThisFunc())
However, when this code is executed it outputs:
First Line
This is the new function
Second line
None
And I do not remember adding a None statement, is this possibly a type variable that has been added? Why is this happening, and how can this be fixed.

You have four print statements. So four things get printed. And by default a function returns None:
>>> def f(): pass
>>> print(f())
None
Check what happens if you define:
def new_dec(ori_func):
def WrapFunc():
print("First Line")
ori_func()
print("Second line")
return "Fourth Line"
return WrapFunc
Alternatively you can remove the fourth print:
# print(ThisFunc())
ThisFunc()

By default, a function returns None. You just have to call the function to get what you expect.
def new_dec(ori_func):
def WrapFunc():
print("First Line")
ori_func()
print("Second line")
return WrapFunc
def new_func():
print("This is the new function")
ThisFunc = new_dec(new_func)
ThisFunc() # get rid of the print statement

Why are all my lists none when I pass them to a function?

I'm trying to make a program that requires me to pass more than one list to a function. But when I return each list in the function I passed it to, they come up as 'none'.
This is a coding of how one of my lists are made then passed.
def somelist(magslist):
return magslist
def main():
alist = []
for i in range(5):
alist.append(i)
somelist(alist)
main()

try this:
def somelist(magslist):
return magslist
def main():
alist = []
for i in range(5):
alist.append(i)
print somelist(alist) # print it here only, for python3 use print with brackets
main()
Or:
def somelist(magslist):
return magslist
def main():
alist = []
for i in range(5):
alist.append(i)
return somelist(alist)
my_list = main() # my_list will save the list return my main function
print my_list
you dont need somelist function:
def main():
alist = []
for i in range(5):
alist.append(i)
return alist # return alist directly
my_list = main() # my_list will save the list return my main function
print my_list

The somelist() function is fine. The problem is that main() isn't returning anything after calling somelist().
A function which exits either by falling off the end (as yours does) or with a plain 'return' statement actually returns None
Change the last line of main() to
return somelist(alist)
then, you will need to print the results of the call to main() to see what it returns if you are not in a REPL.

Using variables from another module wih a while loop

main.py:
import sys
sys.path.append('Pygame Projects')
import sub
from sub import *
loop = True
while loop:
print_hello()
true_the_another_loop()
while anotherLoop:
print_world()
sub.py:
def true_the_another_loop():
loop = False
anotherLoop = True
def print_hello():
print "hello"
def print_world():
print "world"
When I run main.py, it prints only "hello". Why is "world" not being printed?
In true_the_another_loop(), the line loop = Flase does not seem to be working.

You need to return the new values of those variables. Because they were just local variables, they are limited to only that function. You need to pass their values to the other variables.
...
while loop:
print_hello()
loop, anotherLoop = true_the_another_loop()
...
def true_the_another_loop():
loop = False
anotherLoop = True
return [loop,anotherLop]

Why can two functions with the same `id` have different attributes?

Why can two functions with the same id value have differing attributes like __doc__ or __name__?
Here's a toy example:
some_dict = {}
for i in range(2):
def fun(self, *args):
print i
fun.__doc__ = "I am function {}".format(i)
fun.__name__ = "function_{}".format(i)
some_dict["function_{}".format(i)] = fun
my_type = type("my_type", (object,), some_dict)
m = my_type()
print id(m.function_0)
print id(m.function_1)
print m.function_0.__doc__
print m.function_1.__doc__
print m.function_0.__name__
print m.function_1.__name__
print m.function_0()
print m.function_1()
Which prints:
57386560
57386560
I am function 0
I am function 1
function_0
function_1
1 # <--- Why is it bound to the most recent value of that variable?
1
I've tried mixing in a call to copy.deepcopy (not sure if the recursive copy is needed for functions or it is overkill) but this doesn't change anything.

You are comparing methods, and method objects are created anew each time you access one on an instance or class (via the descriptor protocol).
Once you tested their id() you discard the method again (there are no references to it), so Python is free to reuse the id when you create another method. You want to test the actual functions here, by using m.function_0.__func__ and m.function_1.__func__:
>>> id(m.function_0.__func__)
4321897240
>>> id(m.function_1.__func__)
4321906032
Method objects inherit the __doc__ and __name__ attributes from the function that they wrap. The actual underlying functions are really still different objects.
As for the two functions returning 1; both functions use i as a closure; the value for i is looked up when you call the method, not when you created the function. See Local variables in Python nested functions.
The easiest work-around is to add another scope with a factory function:
some_dict = {}
for i in range(2):
def create_fun(i):
def fun(self, *args):
print i
fun.__doc__ = "I am function {}".format(i)
fun.__name__ = "function_{}".format(i)
return fun
some_dict["function_{}".format(i)] = create_fun(i)

Per your comment on ndpu's answer, here is one way you can create the functions without needing to have an optional argument:
for i in range(2):
def funGenerator(i):
def fun1(self, *args):
print i
return fun1
fun = funGenerator(i)
fun.__doc__ = "I am function {}".format(i)
fun.__name__ = "function_{}".format(i)
some_dict["function_{}".format(i)] = fun

#Martjin Pieters is perfectly correct. To illustrate, try this modification
some_dict = {}
for i in range(2):
def fun(self, *args):
print i
fun.__doc__ = "I am function {}".format(i)
fun.__name__ = "function_{}".format(i)
some_dict["function_{}".format(i)] = fun
print "id",id(fun)
my_type = type("my_type", (object,), some_dict)
m = my_type()
print id(m.function_0)
print id(m.function_1)
print m.function_0.__doc__
print m.function_1.__doc__
print m.function_0.__name__
print m.function_1.__name__
print m.function_0()
print m.function_1()
c = my_type()
print c
print id(c.function_0)
You see that the fun get's a different id each time, and is different from the final one. It's the method creation logic that send's it pointing to the same location, as that's where the class's code is stored. Also, if you use the my_type as a sort of class, instances created with it have the same memory address for that function
This code gives:
id 4299601152
id 4299601272
4299376112
4299376112
I am function 0
I am function 1
function_0
function_1
1
None
1
None
<main.my_type object at 0x10047c350>
4299376112

You should save current i to make this:
1 # <--- Why is it bound to the most recent value of that variable?
1
work, for example by setting default value to function argument:
for i in range(2):
def fun(self, i=i, *args):
print i
# ...
or create a closure:
for i in range(2):
def f(i):
def fun(self, *args):
print i
return fun
fun = f(i)
# ...

Using a dictionary to select function to execute

I am trying to use functional programming to create a dictionary containing a key and a function to execute:
myDict={}
myItems=("P1","P2","P3",...."Pn")
def myMain(key):
def ExecP1():
pass
def ExecP2():
pass
def ExecP3():
pass
...
def ExecPn():
pass
Now, I have seen a code used to find the defined functions in a module, and I need to do something like this:
for myitem in myItems:
myDict[myitem] = ??? #to dynamically find the corresponding function
So my question is, How do I make a list of all the Exec functions and then assign them to the desired item using the a dictionary? so at the end I will have myDict["P1"]() #this will call ExecP1()
My real problem is that I have tons of those items and I making a library that will handle them so the final user only needs to call myMain("P1")
I think using the inspect module, but I am not so sure how to do it.
My reason to avoid:
def ExecPn():
pass
myDict["Pn"]=ExecPn
is that I have to protect code as I am using it to provide a scripting feature within my application.

Simplify, simplify, simplify:
def p1(args):
whatever
def p2(more args):
whatever
myDict = {
"P1": p1,
"P2": p2,
...
"Pn": pn
}
def myMain(name):
myDict[name]()
That's all you need.
You might consider the use of dict.get with a callable default if name refers to an invalid function—
def myMain(name):
myDict.get(name, lambda: 'Invalid')()
(Picked this neat trick up from Martijn Pieters)

Simplify, simplify, simplify + DRY:
tasks = {}
task = lambda f: tasks.setdefault(f.__name__, f)
#task
def p1():
whatever
#task
def p2():
whatever
def my_main(key):
tasks[key]()

Not proud of it, but:
def myMain(key):
def ExecP1():
pass
def ExecP2():
pass
def ExecP3():
pass
def ExecPn():
pass
locals()['Exec' + key]()
I do however recommend that you put those in a module/class whatever, this is truly horrible.
If you are willing to add a decorator for each function, you can define a decorator which adds each function to a dictionary:
def myMain(key):
tasks = {}
def task(task_fn):
tasks[task_fn.__name__] = task_fn
#task
def ExecP1():
print(1)
#task
def ExecP2():
print(2)
#task
def ExecP3():
print(3)
#task
def ExecPn():
print(4)
tasks['Exec' + key]()
Another option is to place all the functions under a class (or in a different module) and use getattr:
def myMain(key):
class Tasks:
def ExecP1():
print(1)
def ExecP2():
print(2)
def ExecP3():
print(3)
def ExecPn():
print(4)
task = getattr(Tasks, 'Exec' + key)
task()

# index dictionary by list of key names
def fn1():
print "One"
def fn2():
print "Two"
def fn3():
print "Three"
fndict = {"A": fn1, "B": fn2, "C": fn3}
keynames = ["A", "B", "C"]
fndict[keynames[1]]()
# keynames[1] = "B", so output of this code is
# Two

You can just use
myDict = {
"P1": (lambda x: function1()),
"P2": (lambda x: function2()),
...,
"Pn": (lambda x: functionn())}
myItems = ["P1", "P2", ..., "Pn"]
for item in myItems:
myDict[item]()

This will call methods from dictionary
This is python switch statement with function calling
Create few modules as per the your requirement.
If want to pass arguments then pass.
Create a dictionary, which will call these modules as per requirement.
def function_1(arg):
print("In function_1")
def function_2(arg):
print("In function_2")
def function_3(fileName):
print("In function_3")
f_title,f_course1,f_course2 = fileName.split('_')
return(f_title,f_course1,f_course2)
def createDictionary():
dict = {
1 : function_1,
2 : function_2,
3 : function_3,
}
return dict
dictionary = createDictionary()
dictionary[3](Argument)#pass any key value to call the method

#!/usr/bin/python
def thing_a(arg=None):
print 'thing_a', arg
def thing_b(arg=None):
print 'thing_b', arg
ghetto_switch_statement = {
'do_thing_a': thing_a,
'do_thing_b': thing_b
}
ghetto_switch_statement['do_thing_a']("It's lovely being an A")
ghetto_switch_statement['do_thing_b']("Being a B isn't too shabby either")
print "Available methods are: ", ghetto_switch_statement.keys()

Often classes are used to enclose methods and following is the extension for answers above with default method in case the method is not found.
class P:
def p1(self):
print('Start')
def p2(self):
print('Help')
def ps(self):
print('Settings')
def d(self):
print('Default function')
myDict = {
"start": p1,
"help": p2,
"settings": ps
}
def call_it(self):
name = 'start'
f = lambda self, x : self.myDict.get(x, lambda x : self.d())(self)
f(self, name)
p = P()
p.call_it()

class CallByName():
def method1(self):
pass
def method2(self):
pass
def method3(self):
pass
def get_method(self, method_name):
method = getattr(self, method_name)
return method()
callbyname = CallByName()
method1 = callbyname.get_method(method_name)
```

def p1( ):
print("in p1")
def p2():
print("in p2")
myDict={
"P1": p1,
"P2": p2
}
name=input("enter P1 or P2")
myDictname

You are wasting your time:
You are about to write a lot of useless code and introduce new bugs.
To execute the function, your user will need to know the P1 name anyway.
Etc., etc., etc.
Just put all your functions in the .py file:
# my_module.py
def f1():
pass
def f2():
pass
def f3():
pass
And use them like this:
import my_module
my_module.f1()
my_module.f2()
my_module.f3()
or:
from my_module import f1
from my_module import f2
from my_module import f3
f1()
f2()
f3()
This should be enough for starters.

Develop Reference

Python is a programming language that lets you work quickly and integrate systems more effectively.

Can I create a List of functions in python? - python

you should add function reference to the list and call the function after. def test_func(): test_list = [test1, test2, test3] apple = random.choice(test_list)()

Related

Python Decorator is spitting out None

Why are all my lists none when I pass them to a function?

Using variables from another module wih a while loop

Why can two functions with the same `id` have different attributes?

Using a dictionary to select function to execute

Categories

Resources