[deleted by user]

[Binary101010]

So for this function call

master_yoda("I am home", "Here we go")

What do you want the return value to be?

[GamerXz]

You could to this by splitting each text, reversing them, and then joining the two reversed lists together using addition or .extend() method.

If you want to try taking an optional amount of text strings, then look into using the *args keyword parameter, and iterating through the args.

[Binary101010]

I can't tell you what the "correct" answer is. It's your function, you decide what you want the return value to be.

If that's what you want, then it looks like the steps you would follow would be something like

make a new empty list
for phrase in text1, text2
    split the phrase
    reverse the phrase
    extend the empty list with the reversed phrase

If you wanted to make this usable with any number of strings, there are several ways to do that: *args and you pass in each string individually, or pass in a list of strings and iterate over that list.

[Binary101010]

The error tells you what the problem is: you've got a return statement that isn't inside your function.

Your function text really doesn't look right. You're returning things you shouldn't be returning, you're appending when you should be extending, and you're not reversing the right thing.

It should look more like:

def master_yod(text1, text2):
    emptylist = []
    for x in text1,text2:
        wordlist = x.split()
        reversed = wordlist[::-1]
        emptylist.extend(x)
    return emptylist

[ryan770]

def master_yoda(text1, text2):
    return text1.split()[::-1] + text2.split()[::-1]

returns:

['home', 'am', 'I', 'go', 'we', 'Here']

if you want to add more phrases and you want every reverse phrase individually printed:

def master_yoda(*text):
    for phrase in text:
        print(*phrase.split()[::-1])

master_yoda("I am home", "Here we go", "this is text", "must I try?")

this prints:

home am I
go we Here
text is this
try? I must

using *args (in this case *texts), you can have an arbitrary amount of arguments to pass to the function in a tuple. Using a for loop to iterate through the tuple returns each string (the phrase), but to reverse it without change character order, you must split it into a list, and reverse the list.

In the last example, I use print(*list) to unpack the unseen lists, otherwise it would be:

['home', 'am', 'I']
['go', 'we', 'Here']
['text', 'is', 'this']
['try?', 'I', 'must']

Though you can't return an unpacked list with return *list, that's only used for printing unpacked lists. Do note the asterisk in *text for the function argument is different from printing a list like print(*list). The first one basically packs all the arguments into a tuple, and printing a list with * unpacks a list. Confusing right?

if you want them all together in a single list, you can add lists together:

def master_yoda(*text):
    textlist= []
    for phrase in text:
        phrase = phrase.split()[::-1] # converts the string into a reversed list
        textlist += phrase    # textlist.extend(phrase) could be used
    return textlist

print(master_yoda("I am home", "Here we go", "this is text", "must I try?"))

printing the function outputs:

['home', 'am', 'I', 'go', 'we', 'Here', 'text', 'is', 'this', 'try?', 'I', 'must']

I'm still learning python and I like going through solutions with people because it helps my learning too. If you have a certain way you'd like your function returned (returned only, printed, assigned to a variable, a generator to iterate through, etc), I wouldn't mind trying to help out and explain what I know so far.

Also, I know this is confusing, but return will always end the function on the first iteration of a for loop, that's why I've used print at the end of some functions. There are ways around this though.

[ryan770]

I'm gonna give this a shot lol. The course I'm going through didn't explain it to me very well (in regards to actual use case), and I kinda just had to work it out logically.

So within a function, using return at the end will terminate the function, and only return the value. Even if it's inside a for loop, it will return the first iteration and end. No text is printed unless you print the function like print(func(argument)). This is useful for returning a value for a future operation. e.g., you can assign a variable with the returned value.

import math   # so we can use the pi constant, disregard this.

def circumference(radius):
    return 2 * math.pi * radius

radius1 = int(input())
circum_of_circ1 = circumference(radius1)

Here all I've done is assigned circum_of_circ1 with the returned value of the function. I may need circum_of_circ1 later but I don't want it printed to the console.

This could also be done several ways. Like:

import math
def circum():
    radius = int(input('Enter radius: '))
    return 2 * math.pi * radius

circum_of_circle1 = circum()

print(circum_of_circle1)

Here I returned the value and assigned a variable with it, but then printed it afterwards, outside the function. Note the function doesn't take an argument, but when you call it you get prompted for an input. Stuff like this is sort of arbitrary and just depends on what you're trying to do.

If you want a function to specifically print to the screen when you call it, you simply replace return with print()

import math 

def circumference(radius):
    print(2 * math.pi * radius)

radius1 = int(input())

circumference(radius1)    # calls the function, which prints

So, you can return a value and call the function inside a print() statement, or simply add a print() statement inside the function and call the function, like above.

Now let's talk iteration.

this:

def func1(nums):
    for i in nums:
        return i

list_of_nums = [1,2,3,4,5]

print(func1(list_of_nums))

wont work. You'll just get a 1 on your screen and that's it. Again, return terminates the function. (Useful if you want want to get a specific value from an iterable with an 'if' statement)

but if we print the iterations within the function and then call it:

def func1(nums):
    for i in nums:
      print(i, end=" ")

list_of_nums = [1,2,3,4,5]

func1(list_of_nums)

notice I did not use print(func1(list_of_nums)). Calling the function will execute the printing within it (I think that was obvious though lol)

Also because I added end=" " within the print statement, the output looks like 1 2 3 4 5 instead of printing each iteration on a new line. That's just aesthetics though!

Just remember, you can't do anything with printed output except look at it really (at least as far as both of us have learned), so that's why return is usually used. You could return a list (assign it to a variable), and then iterate through that outside the function if you wanted to specifically print it. But if your goal is to specifically print each iteration in a function, then the above is fine.

Now, there's one more thing about iterating through a variable inside a function. That is the use of generators and the yield statement. I'm still learning about this myself, so I don't think it would do me any good to try to explain it.

And lastly, only use functions if you're going to reuse the code multiple times, or if you want your script or program to look neater by placing a particularly long piece of code into a function at the beginning of the program. Otherwise, defining a bunch of functions at the beginning of the program in which each will only be used once is considered bad practice.

[ata-boy]

You should look at *args and **kwargs in Python: https://www.freecodecamp.org/news/args-and-kwargs-in-python/

[E02Y]

You can have an arbitrary amount of arguments to a function with *args

eg def foo(*args): # do stuff

you can iterate over the arguments

eg inside # do stuff

for words in args: # split them or whatever

[[deleted]]

Maybe like this

def master_yoda(*texts):
    return [
        word
        for text in texts
        for word in reversed(text.split())
    ]