Блог

Проблема с Python для начинающих (я начинающий программист) Итак, я делал простой генератор последовательностей Фибоначчи и создал рабочую версию, но я не понимаю, как это работает. В коде (строки 8-9) первое число (0) становится новым значением второго значения (1). Но тогда это должно сделать все остальные числа равными 0, но похоже, что процесс определения идет в обратном направлении. Как правило, новое значение находится слева от знака равенства, а старое значение справа. Но тогда это означает, что все должно превратиться в 0. Но на самом деле каждое число превращается в 0, если я пытаюсь переопределить переменные обычным способом (b = a; c = b). Почему это так? Я прикрепил свой код внизу.

 def seq_loop():
    a = 0
    b = 1

    for i in range(15):
        print(a)
        c = a   b
        a = b
        b = c

print(seq_loop())
  

Внимательно посмотрите на свой код. Пройдитесь по ней и запишите a, b и c на каждой итерации (или, если вы знаете, как использовать отладчик, установите точку останова в цикле, чтобы проверить значения вашей переменной). Вы увидите, что ваше мышление неверно: в вашей первой итерации: a = b эквивалентно a = 1 и b = c эквивалентно b = 1 1 . Я не уверен, что ваша интерпретация назначений верна: назначение идет справа налево. Значение (переменной) в правой части = присваивается переменной в левой части =

Я не совсем понимаю, о чем вы спрашиваете, но хороший способ понять код — просто выполнить его вручную с помощью pen amp; paper и сохранить список всех переменных в области видимости и их текущие значения. Итак, давайте сделаем это сейчас.

В первой строке мы определяем и инициализируем переменную a значением 0 . Наши переменные в области видимости и их значения { a = 0 } .

Во второй строке мы определяем и инициализируем переменную b значением 1 . Наши переменные в области видимости и их значения { a = 0; b = 1 } .

В первой строке цикла мы печатаем текущее значение переменной a , которое мы можем посмотреть в нашем списке переменных 0 . Мы не назначили никаких переменных, поэтому наши переменные в области видимости остаются неизменными : { a = 0; b = 1 } . И консоль выглядит так:

 0
  

Во второй строке цикла мы определяем и инициализируем переменную c в результате вычисления выражения a b . Мы должны разыменовать две переменные, то есть посмотреть их значения в нашем списке, и их значения равны 0 и 1 . 0 1 это 1 означает, что мы инициализируем c 1 . Наши переменные в области видимости и их значения { a = 0; b = 1; c = 1 } .

В третьей строке цикла мы присваиваем переменную a . Значение, которое мы присваиваем переменной a , является текущим значением переменной b . Итак, мы смотрим на наш список переменных и видим, что текущее значение b равно 1 , что означает, что мы присваиваем 1 a . Наши переменные в области видимости и их значения { a = 1; b = 1; c = 1 } .

В четвертой строке цикла мы присваиваем переменную b . Значение, которое мы присваиваем переменной b , является текущим значением переменной c . Итак, мы смотрим на наш список переменных и видим, что текущее значение c равно 1 , что означает, что мы присваиваем 1 b . Наши переменные в области видимости и их значения { a = 1; b = 1; c = 1 } .

После четвертой строки цикла переменная c выходит из области видимости. Теперь наши переменные в области видимости и их значения { a = 1; b = 1 } .

Как вы можете видеть, мы начали первую итерацию цикла с { a = 1; b = 0 } , но после первой итерации цикла у нас есть { a = 1; b = 1 } , с чего мы начинаем вторую итерацию цикла. Важно, чтобы здесь что-то изменилось, иначе каждая итерация цикла выполняла бы одно и то же, и мы всегда получали бы один и тот же результат.

Итак, давайте посмотрим на вторую итерацию цикла.

В первой строке цикла мы печатаем текущее значение переменной a , которое мы можем посмотреть в нашем списке переменных 1 . Мы не назначили никаких переменных, поэтому наши переменные в области видимости остаются неизменными : { a = 1; b = 1 } . И консоль выглядит так:

 0
1
  

Во второй строке цикла мы определяем и инициализируем переменную c в результате вычисления выражения a b . Мы ищем их значения в нашем списке, и их значениями являются 1 и 1 . 1 1 это 2 означает, что мы инициализируем c 2 . Наши переменные в области видимости и их значения { a = 1; b = 1; c = 2 } .

В третьей строке цикла мы присваиваем переменную a . Значение, которое мы присваиваем переменной a , является текущим значением переменной b . Итак, мы смотрим на наш список переменных и видим, что текущее значение b равно 1 , что означает, что мы присваиваем 1 a . Наши переменные в области видимости и их значения { a = 1; b = 1; c = 2 } .

In the fourth line of the loop, we assign the variable b . The value we assign to the variable b is the current value of the variable c . So, we look at our variable list, and we see that the current value of c is 2 , which means we assign 2 to b . Our variables in scope and their values are { a = 1; b = 2; c = 2 } .

After the fourth line of the loop, the variable c goes out of scope. Our variables in scope and their values are now { a = 1; b = 2 } .

Now for the third iteration.

In the first line of the loop, we print the current value of the variable a , which we can look up in our variable list is 1 . We haven’t assigned any variables, so our variables in scope are still unchanged: { a = 1; b = 2 } . And the console looks like this:

 0
1
1
  

In the second line of the loop, we define and initialize the variable c to the result of evaluating the expression a b . We look up their values in our list, and their values are 1 and 2 . 1 2 is 3 , which means we initialize c to 3 . Our variables in scope and their values are { a = 1; b = 2; c = 3 } .

In the third line of the loop, we assign the variable a . The value we assign to the variable a is the current value of the variable b . So, we look at our variable list, and we see that the current value of b is 2 , which means we assign 2 to a . Our variables in scope and their values are { a = 2; b = 2; c = 3 } .

In the fourth line of the loop, we assign the variable b . The value we assign to the variable b is the current value of the variable c . So, we look at our variable list, and we see that the current value of c is 3 , which means we assign 3 to b . Our variables in scope and their values are { a = 2; b = 3; c = 3 } .

After the fourth line of the loop, the variable c goes out of scope. Our variables in scope and their values are now { a = 2; b = 3 } .

And this is the fourth iteration of the loop.

In the first line of the loop, we print the current value of the variable a , which we can look up in our variable list is 2 . We haven’t assigned any variables, so our variables in scope are still unchanged: { a = 2; b = 3 } . And the console looks like this:

 0
1
1
2
  

In the second line of the loop, we define and initialize the variable c to the result of evaluating the expression a b . We look up their values in our list, and their values are 2 and 3 . 2 3 is 5 , which means we initialize c to 5 . Our variables in scope and their values are { a = 2; b = 3; c = 5 } .

In the third line of the loop, we assign the variable a . The value we assign to the variable a is the current value of the variable b . So, we look at our variable list, and we see that the current value of b is 3 , which means we assign 3 to a . Our variables in scope and their values are { a = 3; b = 3; c = 5 } .

In the fourth line of the loop, we assign the variable b . The value we assign to the variable b is the current value of the variable c . So, we look at our variable list, and we see that the current value of c is 5 , which means we assign 5 to b . Our variables in scope and their values are { a = 3; b = 5; c = 5 } .

After the fourth line of the loop, the variable c goes out of scope. Our variables in scope and their values are now { a = 3; b = 5 } .

Let’s do one last iteration of the loop.

In the first line of the loop, we print the current value of the variable a , which we can look up in our variable list is 3 . We haven’t assigned any variables, so our variables in scope are still unchanged: { a = 3; b = 5 } . And the console looks like this:

 0
1
1
2
3
  

In the second line of the loop, we define and initialize the variable c to the result of evaluating the expression a b . We look up their values in our list, and their values are 3 and 5 . 3 5 is 8 , which means we initialize c to 8 . Our variables in scope and their values are { a = 3; b = 5; c = 8 } .

In the third line of the loop, we assign the variable a . The value we assign to the variable a is the current value of the variable b . So, we look at our variable list, and we see that the current value of b is 5 , which means we assign 5 to a . Our variables in scope and their values are { a = 5; b = 5; c = 8 } .

In the fourth line of the loop, we assign the variable b . The value we assign to the variable b is the current value of the variable c . So, we look at our variable list, and we see that the current value of c is 8 , which means we assign 8 to b . Our variables in scope and their values are { a = 5; b = 8; c = 8 } .

After the fourth line of the loop, the variable c goes out of scope. Our variables in scope and their values are now { a = 5; b = 8 } .

I hope it is somewhat clearer now.

One thing that is very important in programming is naming. Good names should be intention-revealing. In this case, none of the names are very good: what does the name a tell you about what the intent of the programmer is? The same goes for b , c , and i . seq_loop is also not very intention-revealing, i.e. what does this function actually do? It prints the Fibonacci sequence. How can I tell from the name that it prints the Fibonacci sequence? Well, I simply can’t!

So, here is the code with some better names, which should clear up some confusion:

 def print_fibonacci_sequence():
    previous = 0
    current  = 1

    for _ in range(15):
        print(previous)

        after    = previous   current
        previous = current
        current  = after


print(print_fibonacci_sequence())
  

You might ask yourself «How is _ a more intention-revealing name than i ?» The reason is that _ has a well-known meaning in the Python community: it is used as the name for a variable that is being ignored. Which is exactly what we are doing in this case.

Also, why after and not next ? next is already defined in Python and it is considered bad style to shadow or even worse redefine Python builtins.

There are a couple of other oddities in the code. For example, the function prints the elements of the Fibonacci sequence and it doesn’t return anything. And then you call the function and print the result of the call … but there is no result because the function doesn’t return anything! Renaming the function to have print in its name so that it is clear that it doesn’t return anything but prints it, makes that mistake more obvious:

 print(print_fibonacci_sequence())
  

You can immediately see that you print something which prints something, which makes no sense. It should just be

 print_fibonacci_sequence()
  

Another oddity is that the function always prints the first 15 terms of the Fibonacci sequence. Usually, you would want to let the caller decide how many terms to print. Maybe the caller only needs 3? Maybe 20? So, let’s do that:

 def print_fibonacci_sequence(number_of_elements):
    previous = 0
    current  = 1

    for _ in range(number_of_elements):
        print(previous)

        after    = previous   current
        previous = current
        current  = after


print_fibonacci_sequence(15)
  

Speaking of letting the caller decide what to do, what if the caller doesn’t want to print the Fibonacci sequence? What if the caller wants to format it as HTML or insert it into an Excel table?

You should always separate computation from input/output. So, in this case, instead of printing the Fibonacci sequence, we will return the Fibonacci sequence, and then the caller can print it if they want to:

 def fibonacci_sequence(number_of_elements):
    fibonacci_sequence = []

    previous = 0
    current  = 1

    for _ in range(number_of_elements):
        fibonacci_sequence.append(previous)

        after    = previous   current
        previous = current
        current  = after

    return fibonacci_sequence


print(fibonacci_sequence(15))
  

На самом деле, если вы подумаете об этом, передача вызывающим абонентом количества терминов в качестве аргумента все еще несколько ограничительна. Что делать, если вызывающий абонент не хочет первых n членов, но первые члены меньше n ? В этом случае им пришлось бы сначала вычислить последовательность Фибоначчи, чтобы увидеть, сколько членов в ней меньше n , а затем запросить это количество членов последовательности Фибоначчи, что, очевидно, противоречит цели использования функции в первую очередь.

Лучшим решением для вызывающей стороны было бы создать бесконечное количество терминов и позволить вызывающей стороне решить, какое условие использовать, чтобы решить, сколько терминов взять:

 def fibonacci_sequence():
    previous = 0
    current  = 1

    while True:
        yield previous

        after    = previous   current
        previous = current
        current  = after
  

Теперь вы можете использовать это так:

 from itertools import islice, takewhile

first_15_terms = islice(fibonacci_sequence(), 15)
terms_less_than_100 = takewhile(lambda term: term < 100, fibonacci_sequence())
  

И вы можете решить, что делать с результатом. Например, распечатайте его:

 for term in first_15_terms:
    print(term)

for term in terms_less_than_100:
    print(term)
  

Или вы можете превратить это в список:

 list_of_first_15_terms = list(first_15_terms)
list_of_terms_less_than_100 = list(terms_less_than_100)
  

И многое другое.

Это общий принцип в программировании, разработке программного обеспечения и разработке API: не только отделять ввод / вывод от вычислений, но и разбивать вычисления на отдельные части для получения значений, потребления значений, преобразования значений, фильтрации значений, представления значений в виде строк (для последующего вывода), синтаксического анализа строковых представленийв значения (поступающие извне) и так далее.

В одном предложении мы могли бы сказать: отделите то, что меняется.