Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 8 years ago.
Improve this question
I am relatively new to Python and I've been stuck on something that seems very trivial, so hoping someone can help.
What I'm trying to do is call a method inside a method in Python. I want to call this method several times, in various different methods, so I don't want to have to keep on copying and pasting the code if I'm going to be using it ~10 times - just to keep calling that "def".
I have tried things such as:
return anotherMethod()
Any ideas how to do this?!
Thanks!
Edit:
Sorry about the vagueness of the question. I'm trying to get my head around the terminology.
def scaleC():
pianoIcon = Icon("PianoScaleC.png")
d1 = Display("iPiano", pianoIcon.getWidth(), pianoIcon.getHeight())
d1.add(pianoIcon)
return piano()
def scaleCS():
pianoIcon = Icon("PianoScaleCS.png")
d1 = Display("iPiano", pianoIcon.getWidth(), pianoIcon.getHeight())
d1.add(pianoIcon)
return piano()
def piano:
#play the piano keys, etc
So you are doing something like this?:
def my_global_function():
def my_local_function():
print('hello world')
my_local_function()
And then outside of that definition you want to call that function again?
But it has been destroyed because you exited the scope.
You can make it a global then:
my_local_function_global_scope = None
def my_global_function():
def my_local_function():
print('hello world')
# Declare variable space as global and assign to it
global my_local_function_global_scope
my_local_function_global_scope = my_local_function
my_local_function()
my_local_function_global_scope()
SO you want to call the same function/method ten times? Do it in a loop eh?
for i in range(10):
print('Iteration Number %s' % i)
anotherMethod()
if you want to return the results of the function ten times in a list, you can use list comprehension
return [anotherMethod() for _ in range(10)]
Note: the _ variable is a convention used when you are required to have an assignment but you do not want to store that variable, naming it _ will effectively delete it as I understand.
my last idea is that you wan to reference the callable once and call it ten times. You can do that too (And its one of my favorite things about python)
my_method = anotherMethod
my_method()
my_method()
...
my_method()
my_method()
If you are asking on how to define methods in Python that can be called from everywhere you can write the method you want on a library.py file like this:
def fun(a , b):
return a + b
and then call it from another file (ie. program.py) like this:
from library import fun
def main():
# your code
print fun(1, 2)
a = 4
b = 5
c = fun(a, b)
print c
if __name__ == '__main__': main()
this will output:
3
9
hope that helps.
Well it is quite simple. You just literally call that function inside your other function. Here is an example:
def Examples():
print 'Function successfully called!'
def Example()
print 'Calling function...'
Examples() #This will call the function above it
Example()
Your result should be:
Calling function...
Function successfully called!
No errors should pop up and this should work. Just add a variable:
loop = 0
and put the functions in a while loop:
while loop <> 10:
loop += 1
def Examples():
print 'Function successfully called!'
def Example()
print 'Calling function...'
Examples() #This will call the function above it
Example()
This will should solve your problem. I hope this helps you! Your final code with this implied should be:
loops = 0
while loops <> 10:
loops += 1
def scaleC():
pianoIcon = Icon("PianoScaleC.png")
d1 = Display("iPiano", pianoIcon.getWidth(), pianoIcon.getHeight())
d1.add(pianoIcon)
piano()
def scaleCS():
pianoIcon = Icon("PianoScaleCS.png")
d1 = Display("iPiano", pianoIcon.getWidth(), pianoIcon.getHeight())
d1.add(pianoIcon)
piano()
def piano:
#play the piano keys, etc
If I understand your question right, you just need to use it like this.
class YourClass(object):
def method(self):
pass # here goes your method
def method_where_i_want_to_use_other_method(self):
self.method()
#other things you need in this method
Related
So I am not sure if this can be done at all, but was curious anyway. Let us suppose I have the following piece of code:
def statement1():
# Do something
def statement2():
# Do something
def statement3():
# Do something
statement1()
statement2()
statement3()
Now, as you can see here, I have to execute all the above functions one after the other. They are also named in a similar fashion, so that made me wonder- is there a way to loop over function calls?
I basically want to have something like a for loop which loops over 'statements', and I don't end up calling each one again and again with only a slight modification in the name.
A side note- I am new to the community so feel free to give me feedback on how to ask and comment on the answers, would go a long way in helping me.
Thanks in advance!
You can use globals() with fstring if the function name is always follow the specific pattern
def statement1():
print("s1")
def statement2():
print("s2")
def statement3():
print("s3")
for i in range(3):
globals()[f"statement{i+1}"]()
Output:
s1
s2
s3
Try this:
def st1():
return 'Hi 1'
def st2():
return 'Hi 2'
def st3():
return 'Hi 3'
list1 = [st1(), st2(), st3()]
for word in list1:
print(word)
Here is a way if you don't want to use globals:
import sys
def statement1():
print(1)
def statement2():
print(2)
def statement3():
print(3)
for i in range(1, 4):
f_name = 'statement{}'.format(i)
getattr(sys.modules[__name__], f_name)()
#deadshot has provided one option how it can be done. On the other hand, if you want to design it this way, I guess this is because you plan that the standard usage will require running all three functions in this exact order? In this case the more classic way would be to define a main function:
def statement1():
# Do something
def statement2():
# Do something
def statement3():
# Do something
def main():
statement1()
statement2()
statement3()
if __name__ == '__main__':
main()
If the functions to similar things, you usually do this via arguments:
def statement(arg):
# do something with arg
for i in range(3):
statement(i)
Consider using this one eval() built in function in python; you could even use eval() when you want to pass parameters to the functions as you can see bellow. However, you should be careful when using eval with the OS module imported and taking input from the user with input() since eval() runs and executes everything it receives.
def statement1(num):
print("Statement_{} -> number-{}".format(num, num))
def statement2(num):
print("Statement_{} -> number-{}".format(num, num))
def statement3(num):
print("Statement_{} -> number-{}".format(num, num))
for i in range(3):
eval("statement{}({})".format(i+1, i+1))
Output would look like:
Statement_1 -> number-1
Statement_2 -> number-2
Statement_3 -> number-3
You can choose the functions which have sign word,the run the choosed functions use vars() or globals() dict.
def statement1():
print("s1")
def statement2():
print("s2")
def statement3():
print("s3")
functionSign = 'statement'
for varName in list(vars().keys()):
if functionSign in varName:
vars()[varName]()
Output:
s1
s2
s3
Below is solution. It is inelegant but will work. Please wait for an elegant solution to appear.
import re
def statement1():
# Do something
print("Statement 1")
def statement2():
# Do something
print("Statement 2")
def statement3():
# Do something
print("Statement 3")
for i in dir():
if re.fullmatch(r'^__[a-zA-Z0-9_]*__$' , i):
continue
else:
if re.fullmatch(r'^statement[0-9]*$',i):
eval('%s()'%i)
The output is
Statement 1
Statement 2
Statement 3
Functions are objects as well so you can used them as variables. Something like:
fns = [statement1, statement2, statement3]
for fn in fns:
fn()
Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 3 years ago.
Improve this question
I written a code having an function
Def product(a,b,c)
And declared those values at the end
But when I'm using these variables in program or if and else statements
It is showing an undefined 'a' name error
Please help me it always showing this error how to rectify it.
The Error's on your code were due to:
incorrect indentation
wrong declaration of variable rupees_to_make.
The Logical Errors in your code were:-
Variable five_needed expects a integer as an input, but gets
float on your code because five_needed = rupees_to_make/5 (on
python 3.x) resolves to a floating point number.
The Logical error of the previous line, eventually causes variable one_needed to store a floating value too.
Rectified Code:-
def make_amount(rupees_to_make, no_of_five, no_of_one):
five_needed = rupees_to_make//5
one_needed = rupees_to_make - (5*five_needed)
if rupees_to_make > (5*no_of_five+no_of_one):
print(-1)
elif five_needed < no_of_five and one_needed < no_of_one:
print("No. of Five needed :", five_needed)
print("No. of One needed :", one_needed)
else:
print(-1)
make_amount(28, 8, 5)
OUTPUT:
No. of Five needed : 5
No. of One needed : 3
From Your style of code, I believe that you are new to Python language, and came from a non-weakly typed language background (C, C++, Java etc).(Cause you were using redundant parenthesis after each expression, and initializing a variable with a value before using it which is, uncommon/wasteful in Python as variables are weakly typed in Python). Try avoiding their use, unless necessary from later on.
If you declared those values at the end of your function it's normal that it do not work, you need to declare them at the begining of your function before to use them.
I think the problem you have is the fact that variables in a function are not global (able to be used out of the function) by default.
So if you have something like this:
def product (a,b,c):
#do something
a = "something"
b = "something"
c = "something"
print(a)
You will get NameError: name 'a' is not defined error, since a can't be used out of the function
To get around this, return the values from your function and then print them.
You can't return multiple values individually, but you can add them to a list and then return it.
Eg.
def product (a,b,c):
#do something
a = "something"
b = "something"
c = "something"
return [a,b,c]
p = product (1,2,3)
print(p[0]) #prints a, which is 'something'
print(p[1]) #prints b, which is 'something'
print(p[2]) #prints c, which is 'something'
OR ...
Use the global keyword.
def product (a,b,c):
#do something
global a = "something"
global b = "something"
global c = "something"
print(a)
print(b)
print(c)
>>> something
>>> something
>>> something
Note that this method is dangerous if you have, for instance, a var a defined before the function, since it will be overridden if you define global a in your function.
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 4 years ago.
Improve this question
I want to have a black box in python where
The input is a list A.
There is a random number C for the black box which is randomly selected the first time the black box is called and stays the same for the next times the black box is called.
Based on list A and number C, the output is a list B.
I was thinking of defining this black box as a function but the issue is that a function cannot keep the selected number C for next calls. Note that the input and output of the black box are as described above and we cannot have C also as output and use it for next calls. Any suggestion?
Make it a Class so C will persist.
class BlackBox():
def __init__(self):
self.C = rand.randint(100)
etc...
As a side note, using some pretty cool Python functionality...
You can make objects of this class callable by implementing __call__() for your new class.
#inside the BlackBox class
def __call__(self, A):
B = []
#do something to B with A and self.C
return B
You can then use this in your main code.
bb = BlackBox()
A = [1, 2, 3]
B = bb(A)
the issue is that a function cannot keep the selected number C for next calls.
This may be true in other languages, but not so in Python. Functions in Python are objects like any other, so you can store things on them. Here's a minimal example of doing so.
import random
def this_function_stores_a_value():
me = this_function_stores_a_value
if 'value' not in me.__dict__:
me.value = random.random()
return me.value
This doesn't directly solve your list problem, but it should point you in the right direction.
Side note: You can also store persistent data in optional arguments, like
def this_function_also_stores_a_value(value = random.random()):
...
I don't, however, recommend this approach because users can tamper with your values by passing an argument explicitly.
There are many ways to store persistent data for a function. They all have their uses, but in general, the ones that come first are useful more often than the ones that come later. (To keep things shorter, I'm solving a slightly simpler problem than the one you asked about, but it should be obvious how to adapt it.)
Instance attribute
class BlackBox:
def __init__(self):
self.C = rand.randint(100)
def check(self, guess):
return (guess - self.C) / abs(guess - self.C)
Now you can create one or more BlackBox() instances, and each one has its own random number.
Closure variable
def blackbox():
C = rand.random()
def check(guess):
return (guess - C) / abs(guess - C)
return check
Now, you can create one or more check functions, and each one has its own random number. (This is dual to the instance variable—that is, it has the same capabilities—but usually one or the other is more readable.)
Global variable
def makeblackbox():
global C
C = random.randint(100)
def check(guess):
return (guess - C) / abs(guess - C)
This way, there's only a single blackbox for the entire program. That's usually not as good a design, which is one of the reasons that "globals are bad". Plus, it's polluting the global namespace with a C variable that means nothing to anyone but the check function, which is another one of the reasons that "globals are bad".
Function attribute
def makeblackbox():
check.C = random.randint(100)
def check():
return (guess - check.C) / abs(guess - check.C)
This is equivalent to a global in that you can only ever have one black box, but at least the variable is hidden away on the check function instead of polluting the global namespace.
Class attribute
class BlackBox:
C = rand.randint(100)
#staticmethod
def check(guess):
return (guess - BlackBox.C) / abs(guess - BlackBox.C)
This is again equivalent to a global variable without polluting the global namespace. But it has a downside over the function attribute—you're creating a class that has no useful instances is often misleading.
Class attribute 2
class BlackBox:
C = rand.randint(100)
#classmethod
def check(cls, guess):
return (guess - cls.C) / abs(guess - cls.C)
This is different from the last three in that you can create new blackboxes by creating subclasses of BlackBox. But this is very rarely what you actually want to do. If you want multiple persistent values, you probably want instances.
Since you are asking in the comments.
This is probably not recommended way but it's easy and works so I'll add it here.
You can use global variable to achieve your goal.
import random
persistant_var = 0
def your_func():
global persistant_var
if persistant_var:
print('variable already set {}'.format(persistant_var))
else:
print('setting variable')
persistant_var = random.randint(1,10)
your_func()
your_func()
Output:
setting variable
variable already set 7
Hope this is clear.
I would like to be able to tell when a method has been called for the first time. I primarily need this for when I am printing out to a delimited file, and if it is the first iteration, I would like to print a header before the actual information. This is what I normally do:
def writeFile(number, count):
if count == 1:
print('number')
print(str(count))
else:
print(str(count))
count = 1
for i in range(10):
writeFile(i, count)
count += 1
This provides the following output:
number
1
2
3
4
5
6
7
8
9
10
Though this achieves the goal I am after, I am curious as to if there is a better/more efficient way of doing this. Is there some way to detect if a method has been called for the first time without having to pass an additional argument to it?
Thank you,
There are multiple ways to do this. Here are three.
First:
firstRun=True
def writeFile(number):
global firstRun
if firstRun:
print('number')
firstRun=False
print(str(number))
for i in range(10):
writeFile(i)
Second:
def writeFile(number):
print(str(number))
for i in range(10):
if not i:
print('number')
writeFile(i)
Third:
for i in range(10):
print(('' if i else 'number\n')+str(i))
I'm assuming this is just a test problem meant to indicate cases where function calls initialize or reset data. I prefer ones that hide the information from the calling function (such as 1). I am new to Python, so I may be using bad practices.
You could write the header to the file before you call the function. That would negate your need for the if statements. I'm a basic level programmer, but this seems logical to me. For example:
def writeFile(count):
print(str(count))
print('number')
for i in range(10):
writeFile(i)
This is a bit more deep respect to the other answers but I prefer it since it uses the OOP-ness of Python, the idea is to assign to the function itself the "called" variable: this can be done since everything in Python is an object (even a function inside its own scope).
The concept can be extended also to functions defined in other scopes - besides class scope - as well.
class SampleClass:
def sample(self, *args, **kwargs):
try:
if self.__class__.sample.called:
# do what you have to do with the method
print("normal execution")
except AttributeError:
# do what you have to do with the first call
print("first call")
self.__class__.sample.called = True
self.__class__.sample(self, *args, **kwargs)
Example:
>>>SampleClass().sample()
first call
normal execution
>>>SampleClass().sample()
normal execution
So I'm fairly new to python and I am working on an algorithm and I have let's say 2 functions
func1(x)
func2(x)
already defined outside the main function.
Now I want to call these functions inside the main functions one nested inside the other
Something like this
def funcmain(func1(func2(x)))
It obviously is not working I haven't been able to get it work anyway I want. Any tips on this?
Edit: What I meant to do is that I want to input a string, I want it to go through func2 first, then the return value from func2 to go through func1 and finally the return value of func1 to go through func main. I have tested each function separately and they are working as intended but I can't seem to get them interlinked together
I hope this code snippet will help to clarify things for you.
#!/usr/bin/python
def func1(x):
return x + 1
def func2(x):
return x + 2
def main(x):
print func1(func2(x))
if __name__ == '__main__':
main(0)
The output is 3.
Is this what you mean? Your question is not too clear. I assume x is also defined globally somewhere.
def funcmain():
return func1(func2(x))
take the following functions:
def func1(x):
return x+1
def func2(x):
return x*2
by itself you COULD do this: func1(func2(3)) which would return 3 times 2 plus 1. This works because by itself func1(func2(3)) actually returns a value, not a function.
BUT since you are trying to put it as the basic argument for the main function like this:
def main(func1(func2(x))): #dont do this, this is what you did, it is bad
return x*3
its not going to know what to do with that because there is no default for x...
you CAN DO THIS THOUGH:
def main(x=func1(func2(1)):
return x*3
this would do the appropriate math to 1 and then assign it as x (Because as we saw earlier, func1(func2(3))` would return THE RESULT OF FUNCTIONS not a function itself, then multiply it by 3. since you are defaulting x to equal a value ( which is func1(func2(1))
This is bad practice still, because you are defaulting to whatever func1(func2(1) comes out to.
what you probably want in the end is something simpler:
def main(x):
y = func1(func2(x))
return y*3
or maybe even simpler than that
def main(x):
return x*3
#and then just call it like this
main(func1(func2(1))