I'm having a hard time to understand how to work with functions - I can make then but after that I don't know how to use them. My question is how can I print this code with a function?
string = "Hello"
reverse = string[::-1]
print(reverse)
I tried putting it in a function but I cannot make it print Hello.
def reverse_a_string(string):
string = "Hello"
reverse = string[::-1]
print(reverse)
also tried this
def reverse_a_string(string):
string = "Hello"
reverse = string[::-1]
print(reverse)
Nothing seems to work. I'm having same problem with this as well.
total = 0
def length(words):
for i in words:
total += 1
return total
Functions without a return value
Functions that just take action or do something without returning a value (for example, print).
Functions that don't return a value can be defined like that:
def sayHello():
print "Hello!"
And can be used (called) like that:
sayHello()
And the output will be:
Hello!
Function parameters
A function can also receive parameters (type of variables) from the caller. It's better to demonstrate it with an example.
A function that receives a name and greets this name:
def sayHelloTo(name):
print "Hello", name
It can be called like that:
sayHelloTo("Yotam")
And the output will be:
Hello Yotam
The parameters are the function's input.
Functions with a return value
Other functions, unlike sayHello() or sayHelloTo(name) (that just do something) can return a value. For example, let's make a function that rolls a dice (returns a random number between 1 and 6).
from random import randint
def rollDice():
result = randint(1, 6)
return result
The return keyword just sets the output value of the function and exits the function. An example use of the rollDice function will be:
dice = rollDice()
print "The dice says", dice
When the function hits a return keyword, it finishes and the return value (in our case, the variable result) will be placed instead of the function call. Let's assume randint(1, 6) has produced the number 3.
Result becomes 3.
Result is returned.
Now, instead of the line:
dice = rollDice()
We can treat the line as:
dice = 3
(rollDice() was replaced with 3)
Functions with parameters and a return value
Some functions (for example, math functions) can take inputs AND produce outputs. For example, let's make a function that receives 2 numbers and outputs the greater one.
def max(a,b):
if a > b:
return a
else:
return b
What it does is pretty clear, isn't it? If a is greater, it returns the value of it. Otherwise, returns the value of b.
It can be used like that:
print max(4, 6)
And the output will be:
6
Now, your case
What you want to do is a function that reverses a string. It should take 1 parameter (input) - the string you want to reverse, and output 1 value - the reversed string. This can be accomplished like that:
def reverse_a_string(my_text):
return my_text[::-1]
now you can do something like that:
s = raw_input("Please enter a string to be reversed\n") #input in Python3
r = reverse_a_string(s)
print r
r will contain the reversed value of s, and will be printed.
About your second function - well, I assume that based on this answer you can make it yourself, but comment me if you need assistance with the second one.
Local variables
About your 3rd example:
def reverse_a_string(string):
string = "Hello"
reverse = string[::-1]
print(reverse)
This is something that is really worth delaying and understanding.
the variable reverse is first used inside the function. This makes it a local variable.
This means that the variable is stored in the memory when the function is called, and when it finishes, it is removed. You can say it's lifetime is from when the function is called to when the function is done.
This means that even if you called reverse_a_string(string), you wouln't be able to use the reverse variable outside of the function, because it would be local.
If you do want to pass a value like that, you have to "declare" your variable outside of the function and to use the global keyword, like that:
reverse = "" #This makes reverse a global variable
def reverse_a_string(string):
global reverse #Stating that we are going to use the global variable reverse
reverse = string[::-1]
# Then you can call it like that:
reverse_a_string("Hello")
print reverse
The output will be
olleH
Although it's strongly not recommended to do it in Python, or in any other language.
Once you create a function you must call it. You have created the function reverse_a_string but then you never actually call it. Think about a function as a button that does something everytime it is pushed (or in our case called). If you never push the button then although it has the potential to do something, it never will. In order for the set of instructions to happen we need to push the button (or in our case call the function). So in order for your code to work you first need to define the function then actually call it:
def reverse_a_string():
string="Hello"
reverse = string[::-1]
print reverse
reverse_a_string()
Result: 'olleH'
If you want to pass your own string in to the function so it doesn't just return 'olleH' all the time your code needs to look like such:
def reverse_a_string(stringThatWillBeReversed):
reverse = stringThatWillBeReversed[::-1]
print reverse
reverse_a_string('whateverStringYouWant')
Result: The reverse of the string you entered.
Hope that helps!
I don't know whether you are asking how to define functions in python or something else
If you want to learn python functions, go to http://www.tutorialspoint.com/python/python_functions.htm or just write python tutorial in google, you will get billions of good sites
def reverse_a_string(string):
#function definition
reverse = string[::-1]
print(reverse)
#function call
reverse_a_string("your string")
But you to define function for this, you could simply do
print( string[::-1] )
# defines the 'Reverse a String' function and its arguments
def reverse_a_string():
print(string)
reverse = string[::-1]
print(reverse)
print("Type a string") # asks the user for a string input
string = input() # assigns whatever the user input to the string variable
reverse_a_string() # simply calls the function
for functions, you have to define the function, then simply call it with the function name i.e. funtion()
In my example, I ask for a string, assign that to the variable, and use it within the function. If you just want to print hello (I'm a little unclear from your question) then simply including the print("hello") or w/ variable print(string) will work inside the function as well.
Related
I am trying to create a function in which I will store formulas for my converter. When X formula will be needed, it will be called from it. When trying it with simple 0:a+b it works when returning, but when trying to store it as string meters_to_foots, it doesn't work. I need to have that formula stored as something since I need to output it later.Here is a part of the code which I have problems with. NameError: name 'meters_input' is not defined
def my_formulas(i):
switcher={
0:(meters_input/0.3048)
}
return switcher.get(i,"Invalid formula")
distance_pick=input("Please pick one of the current convertions : \n \n1.Meters to X \n2.Inches to X \n3.Feets to X ")
if(distance_pick=="1"):
cls()
distance_choice = input ("Please select which converter would you like to use ! : \n \n1.Meter to Foot \n2.Meter to Yard \n3.Meters to Inches ")
if(distance_choice=="1"):
meters_input=float(input("Make sure to enter distance in Meters ! : "))
my_formulas(0)
print ("\nYou entered", meters_input , "meters, which is equal to",my_formulas(0),"foots.")
time.sleep (3)
cls ()
read_carefully_message()
To create a function in Python use either lambda functions or the regular function definition. Examples are respectively:
def divide(meters_input):
return meters_input / 0.3048
or
divide = lambda meters_input: meters_input / 0.3048
Generally the regular function definition is preferred since it improves readability. You can define your function mapping as follows:
def my_formulas(i):
switcher={
0:divide # do not write divide()
}
If these will always be simple functions you can use a lambda expression for this:
def my_formulas(i):
switcher= {
0:lambda meters_input: meters_input/0.3048
}
return switcher.get(i,"Invalid formula")
my_formulas(0)(27) #88.58267716535433
If your function lookup will always be a number starting with zero you might be better off storing the functions as an array. You could do something like this as well:
def my_formulas(index):
def meters2Feet(meters):
return meters/0.3048
def hours2Minutes(hours):
return hours * 60
def invalid(*args):
return "Invalid formula"
lookup = [
meters2Feet,
meters2Feet
]
if index >= len(lookup):
return invalid
return lookup[index]
my_formulas(0)(27) # 88.58267716535433
It's a little more complicated, but probably easier to read and understand.
Try changing your function to this:
def my_formulas(i):
switcher = (i/0.3048)
return switcher
The "i" in the function is a local variable for the function. In your code you are passing 0 into the my_formulas() function. i then becomes 0, but meters_input is out of scope for the function.
def testfunction():
for i in range(10):
return('a')
print(testfunction())
I want 'a' outputed 10 times in one line. If I use print instead of return, it gives me 10 'a's but each on a new line. Can you help?
return terminates the current function, while print is a call to another function(atleast in python 3)
Any code after a return statement will not be run.
Python's way of printing 10 a's would be:
print('a' * 10)
In your case it would look like the following:
def testfunction ():
return 'a' * 10
print(testfunction ())
The reason its only printing once is because the return statment finishes the function (the return function stops the loop).
In order to print 'a' 10 times you want to do the following:
def testfunction():
for i in range(10):
print('a')
testfunction()
If you want "a" printed 10 times in one single line then you can simply go for:
def TestCode():
print("a"*10)
There's no need to use the for loop. For loop will just "a" for 10 times but every time it'll be a new line.
You can also take in a function argument and get "a" printed as many times as desired.
Such as:
def TestCode(times):
t = "a"*times
print(t)
Test:
TestCode(5)
>>> aaaaa
TestCode(7)
>>> aaaaaaa
print and return get mixed up when starting Python.
A function can return anything but it doesn't mean that the value will be printed for you to see. A function can even return another function (it's called functional programming).
The function below is adapted from your question and it returns a string object. When you call the function, it returns the string object into the variable called x. That contains all of the info you wanted and you can print that to the console.
You could have also used yield or print in your for loop but that may be outside of the scope.
def test_function(item:str="a", n:int=10):
line = item*n # this will be a string object
return line
ten_a_letters = test_function()
print(ten_a_letters)
"aaaaaaaaaa"
two_b_letters = test_function("b",2)
print(two_b_letters)
"bb"
I want 'a' outputed 10 times in one line. If I use print instead of
return, it gives me 10 'a's but each on a new line.
If you want to use print, the you need to pass a 2nd parameter as follows:
def testfunction():
for i in range(10):
print('a', end='')
However, I think the pythonic way would be to do the following:
def testfunction():
print('a' * 10)
When you use return you end the execution of the function immediately and only one value is returned.
Other answers here provide an easier way to solve your problem (which is great), but I would like to suggest a different approach using yield (instead of return) and create a generator (which might be an overkill but a valid alternative nonetheless):
def testfunction():
for i in range(10):
yield('a')
print(''.join(x for x in testfunction()))
1. What does "yield" keyword do?
def test ():
print('a' * 10)
test()
Output will be 'aaaaaaaaaa'.
def apply_twice(func,arg):
return func(func(arg))
def add_five(x):
return x+5
print (apply_twice(add_five,10))
The output I get is 20.
This one is actually confusing me like how is it working.Can anybody explain me how this is working by breaking it down
The function apply_twice(func,arg) takes two arguments, a function object func and an argument to pass to the function func called arg.
In Python, functions can easily be passed around to other functions as arguments, they are not treated differently than any other argument type (i.e first class citizens).
Inside apply_twice, func is called twice in the line:
func(func(arg))
Which, alternatively, can be viewed in a more friendly way as:
res = func(arg)
func(res)
If you replace func with the name of the function passed in add_five you get the following:
res = add_five(arg) # equals: 15
add_five(res) # result: 20
which, of course, returns your expected result.
The key point to remember from this is that you shouldn't think of functions in Python as some special construct, functions are objects just like ints, listss and everything else is.
Expanding the code it executes as follows, starting with the print call:
apply_twice(add_five,10))
add_five(add_five(10)) # add_five(10) = 15
add_five(15) # add_five(15) = 20
Which gives you the result: 20.
When apply_twice is called, you are passing in a function object and a value. As you can see in the apply_twice definition, where you see func that is substituted with the function object passed to it (in this case, add_five). Then, starting with the inner func(arg) call, evaluate the result, which is then passed to add_five again, in the outer return func( ... ) call.
What you need to understand here is that
apply_twice(func,arg)
is a higher function which accepts two arguments (another function named func and an argument arg). The way it works is that it first evaluate the value of the other function, then use the value as an argument inside the higher function.
remember we have a function add_five(x) which add 5 to the argument supply in it...
then this function add_five(x) is then passed as an argument to another function called
apply_twice_(func,arg) which return func(func(arg)).
now splitting func(func(arg)) we have
func(arg) #lets called it a
then func(func(arg))==func(a) since a = func(agr)
and (a) is our add_five(x) function, after it add 5, then the value we got is re-used as another fresh argument to add another 5 to it, that is why we have 20 as our result.
Another example is:
def test(func, arg):
return func(func(arg))
def mult(x):
return x * x
print(test(mult, 2))
which give 16 as result.
If I use this
def myfunction():
print('asd')
print(myfunction)
The IDE tells me None
but if I use this
import math
print (math.cos(90))
The IDE tells me the COS90°
Why?
It's all about return value.
def myfun(x):
return x
print(myfun("hello")) will return hello.
Your function (myfunction) does not return a value, that's to say it returns None value. So, print (a built in python function) returns that value.
When functions are called they always return something they processes.
def myfunction():
print('asd')
This will print the output. Since there is nothing explicitly returned, the function by default return None
Now lets add a bit of complexity to your function:
def myfunction(text):
print(text * 2)
This will print the text it gets twice. And it works just fine. But lets say you need to store the "printed twice" text to a variable.
Try this:
def myfunction(text):
print(text * 2)
twoText = myFunction("some text foo")
print(twoText)
Output should look like this:
some text foosome text foo
None
This is happening because you are in your function first printing twice some text foo and then printing what your function returned. In this case it returned None since nothing was explicitly returned.
To fix this you just replace print with return.
def myfunction(text):
return text * 2
twoText = myFunction("some text foo")
print(twoText)
The output is correct because you print only the return of the function.
some text foosome text foo
The math function returnes data like this:
def cos(number):
# Insert super complex math calculation here
return result
If it didn't do this you would not be able to store the result in a variable, instead it would just be printed.
If a Question is general than there is no difference except built-in function is one that is properly tested and approved by author's command; You can contribute too if You write something good and useful - don't shy offer it to community; ppl will thank You.
But if You mean exactly Your example then You have to change code to be:
def myfunction():
print('asd')
myfunction()
this is the way to call function without arguments, You could have
def myfunction(n):
print(n)
myfunction('hi')
this would print hi and so on
Trying to gain access to this string to test it if it has 3 or more blues "b" inside of it. ---Both test and three_or_more_blues are functions.----- I'm completely lost, any one got an idea? Please change my title if it doesn't fit my question. Not sure really how to ask the question. Thanks!
test(three_or_more_blues, "brrrrrbrrrrrb")
Assuming test is a function that takes a function and a string as paramters, and three_or_more_blues is a function that returns true if its string parameter has 3 or more 'b' characters, then
def test(func, str):
if func(str):
# do something with str
test(three_or_more_blues, "brrrrrbrrrrrb")
You could use .count().
sentence = 'brrrrrbrrrrrb'
amount = sentence.count('b')
print(amount)
And then you could use a loop to calculate your next step.
if (amount >= 3):
# Do something
I am not sure if I understand you correctly - you are asking how to pass the string 'brrrrrbrrrrrb' to the three_or_more_blues function?
If that is the case, than you just simply pass it when you call the three_or_more_blues function like this:
def test(func, some_string):
func(some_string) # here you call the passed function
# if three_or_more_blues would look like this:
def three_or_more_blues(some_string):
print "Yes, 3 or more b's" if some_string.count('b') >= 0 else "No"
# you would get this from your function call
test(three_or_more_blues, "brrrrrbrrrrrb") # prints: "Yes, 3 or more b's"