python - 艰难地学习Python ex25-想检查一下我的理解

Question

总体上，菜鸟对“学习Python的艰难方式”一事感到困惑。抱歉，如果已解决；我进行了搜索，只能找到有关无法从代码中获得所需结果的帖子。

我的问题与exercise 25中两个功能的相互作用有关：

def break_words(stuff):
    words = stuff.split(' ')
    return words

和

def sort_sentence(sentence):
    words = break_words(sentence)
    return sort_words(words)

因此，在练习Zed即将结束时，您已在终端中运行此命令：

>>> sorted_words = ex25.sort_sentence(sentence)
>>> sorted_words
['All', 'come', ’good’, ’things’, ’those’, ’to’, ’wait.’, ’who’]

现在，我假设“ sort_sentence”中的参数来自以下内容，它们是在练习开始时在终端中输入的：

>>> sentence = "All good things come to those who wait."

但是，尽管我们现在知道上面是'sort_sentence'的参数，但如果不运行'break_words'，并且再次以'sentence'作为其参数，'sort_sentence'就无法完成。这是我感到困惑的地方：'break_words'的参数标记为'stuff'。这有关系吗？可以将“句子”从“ sorted_words”传递到“ break_words”中，而不管标记了“ break_words”的参数是什么？

因此，假设我假设-参数标签无关紧要-'break_words'应该以'sentence'作为其参数运行并返回'words'，这是其中包含的函数'stuff.split'的输出。这是我真正感到困惑的地方-从'break_words'返回的'words'与定义为'sort_sentence'一部分的变量'words'有什么关系？我根本无法弄清楚这些功能如何协同工作。预先感谢您的帮助！

Answer 1

以下是Python如何运作的功能：

def function_name(parameter_name_used_locally_within_function_name):
    #do stuff with parameter_name_used_locally_within_function_name

    some_new_value = parameter_name_used_locally_within_function_name
    return some_new_value

请注意，参数仅在函数 function_name的范围内使用。因为该变量将仅在该函数中使用，而不在其外部使用。当我们从函数返回变量时，可以将其分配给另一个调用该函数的变量：

my_variable = function_name("hello")

自从我们调用函数以来， my_variable现在的值是 "hello"，传入值 "hello"。注意，我没有使用指定的变量名称调用该函数吗？我们不在乎参数名是什么，我们所知道的只是函数需要一个输入。该参数名称仅在函数中使用。请注意，在调用函数时，如何在不知道变量名的情况下接收 some_new_value的值？

让我给你一个更广泛的例子。功能可以认为是您交给某人执行的任务。可以说功能或任务是作为他们为我们做饭。厨师或任务需要烹饪的食材（这是我们的投入），我们希望取回食物（我们的输出回报）。可以说我想要一个煎蛋，我知道我必须给厨师鸡蛋让我做一个煎蛋，只要我收回我的蛋/煎蛋，我不在乎他是怎么做的或他对它做些什么。他可以随心所欲地叫鸡蛋，可以按自己的喜好将鸡蛋打碎，可以按自己的喜好在锅里煎鸡蛋，但是只要我拿到煎蛋，我就很高兴。

回到我们的编程世界，该函数将类似于：

def cook_me_something(ingredients):
    #I don't know how the chef makes things for us nor do I care
    if ingredients == "eggs":
        food = "omelette"
    elif ingredients == "water":
        food = "boiled water"
    return food

我们这样称呼它：

my_food_to_eat = cook_me_something("eggs")

注意，我给了他“鸡蛋”，还给了我一些“煎蛋”。我不是说鸡蛋是成分，也不是说他给我的食物叫什么。他只返回包含 food的 omelettes

现在让我们谈谈链接功能。

所以我们基本了解了我给厨​​师一些东西，然后他根据我给他的东西给了我食物。那么，如果我们给了他在烹饪之前需要处理的东西该怎么办。比方说，如果他不知道如何磨咖啡豆。但是他的厨师长也知道。他会将咖啡豆递给那个人，将咖啡豆磨碎，然后用退货过程做饭。

def cook_me_something(ingredients):
    #I don't know how the chef makes things for us nor do I care
    if ingredients == "eggs":
        food = "omelette"
    elif ingredients == "water":
        food = "boiled water"
    elif ingredients == "coffee beans"
        co_worker_finished_product = help_me_co_worker(ingredients)
        #makes coffee with the co_worker_finished_product which would be coffee grindings
        food = "coffee"
    return food

#we have to define that function of the co worker helping:

help_me_co_worker(chef_passed_ingredients):
    if chef_passed_ingredients == "coffee beans"
        ingredients = "coffee grinding"
    return ingredients

注意到同事如何具有局部变量 ingredients？这与厨师所拥有的不同，因为厨师拥有自己的食材，而同事拥有自己的食材。注意厨师如何不在乎同事称呼他的食材或他如何处理这些食材。厨师给了同事一些东西，并期望成品。

这或多或少是如何工作的。只要得到函数的输入，它们就可以工作并给出输出。我们不在乎它们在函数中称为变量的原因，因为它们是它们自己的项。

因此，让我们回到您的示例：

def break_words(stuff):
    words = stuff.split(' ')
    return words

def sort_sentence(sentence):
    words = break_words(sentence)
    return sort_words(words)

>>> sentence = "All good things come to those who wait."
>>> sorted_words = ex25.sort_sentence(sentence)
>>> sorted_words
['All', 'come', ’good’, ’things’, ’those’, ’to’, ’wait.’, ’who’]

让我们看看是否可以将其分解为您理解。

您调用了 sorted_words = ex25.sort_sentence(sentence)，并将 sorted_words设置为函数 sort_sentence()的输出，即 ['All', 'come', ’good’, ’things’, ’those’, ’to’, ’wait.’, ’who’]。您传入了输入 sentence

sort_sentence(sentence)获取执行。您在变量中传递的字符串现在称为 sentence。请注意，您可以像这样调用该函数，它仍将起作用：

sorted_words = ex25.sort_sentence("All good things come to those who wait.")

函数 sort_sentence()仍将调用该字符串 sentence。该函数基本上说出我输入的内容，我称它为句子。您可以将名为“句子”的对象传递给我，在使用它时，我将其重命名为“句子”。

堆栈上的下一个是：

words = break_words(sentence)

现在正在调用功能break_words，而功能 sort_sentence则将其输入为 sentence。因此，如果您遵循跟踪，则基本上就是这样：

words = break_words("All good things come to those who wait.")

堆栈上的下一个是：

words = stuff.split(' ')
return words

请注意，该函数将其作为 stuff输入。因此，使用了sort_sentence的输入，即名为 sentence的sort_sentence和函数 break_words现在将其称为 stuff。

它将“句子”分解为单词，并将其存储在列表中，然后返回列表“ words”

注意函数 sort_sentence如何将 break_words的输出存储在变量 words中。注意函数 break_words如何返回名为 words的变量吗？在这种情况下，它们是相同的，但是，如果使用不同的名称并不重要。 sort_sentence可以将输出存储为 foo，并且仍然可以使用。我们正在谈论变量的不同范围。在函数 break_words之外，变量 words可以是任何值，而 break_words则不在乎。但是在 break_words内部，该变量是函数的输出。

在我的房子下我的规则？在我家外面，您可以做任何您想做的事情。

对 sort_sentence返回变量，以及我们如何存储从中得到的返回值的处理相同。我们如何存储它或我们称之为它都无关紧要。

如果需要，可以将其重命名为：

def break_words(stuff):
    break_words_words = stuff.split(' ')
    return break_words_words

def sort_sentence(sentence):
    words = break_words(sentence)
    return sort_words(words) #not sure where this function sort_words is coming from. 
                             #return words would work normally. 

>>> sentence = "All good things come to those who wait."
>>> sorted_words = ex25.sort_sentence(sentence)
>>> sorted_words
['All', 'come', ’good’, ’things’, ’those’, ’to’, ’wait.’, ’who’]

您只需要考虑局部变量和参数，就像命名要使用的东西一样。就像我们与厨师的例子一样，厨师可能会称鸡蛋，配料，但我随便叫它什么，就把它叫“蛋”。一切都围绕事物的范围，将功能想像成房子，当您在房子里时，您可以命名房子中想要的任何对象，而在房子外，这些相同的名称可能是不同的东西，但在房子内部，它们就是您想要的样子。当您扔掉某些东西时，您将其命名为与外部世界无关，因为外部世界会为其命名。可能用相同的名字命名...

如果我漫步得太多，请提出问题，我会尽力为您解决。

已编辑

从午餐回来，我认为变量是容器，它们保存值，但您不在乎其他人的容器的名称。您只关心自己的东西，当有人给您一些东西时，您可以将其放入容器中并命名为您关心的东西，这将有助于您了解其中的内容。当您放弃一件物品时，您不会放弃该容器，因为您需要它来存储其他物品。