Создание функции для печати показателей без использования **

Question

Мне поручено написать функцию в Python 3, чтобы по существу воссоздать команду ** для степеней двойки с заданным числом (например, если n = 10, распечатать 1,2,4 ... 1024).

Я не могу использовать какой-либо предопределенный импорт или функции (math.pow).

Мой мыслительный процесс заключался бы в использовании a для l oop и затем на каждой следующей итерации умножить на 2, чтобы воссоздать это:

• 2 ^ 0 = 1
• 2 ^ 1 = 2 * 1 (из последней строки)
• 2 ^ 2 = 2 * 2 (из последней строки)
• 2 ^ 3 = 2 * (2 * 2) (из последней строки)
• 2 ^ 4 = 2 * (2 ^ 3) (из последней line)

Сначала я подумал, что у меня будет для l oop, просто напечатайте 2, n количество раз:

n = 5
for i in range of (n+1)
    print(2)

, и на выходе будет просто

• (что делать с этим пустым пространством?), 2 2 2 2 2

но я ничего не могу поделать с этим, кроме как понять, что i в l oop соответствует показателю 2 ** i.

Тогда я подумал, что буду использовать присваивание умножения * = для первого print (2), но затем также умножьте его на предыдущую итерацию, чтобы сохранить его как новое значение и распечатать переменные по мере их перезаписи, но я не был уверен, как настроить my for l oop, чтобы сделать такую ​​вещь.

Есть какие-нибудь подсказки, с какого метода лучше всего начать решать этот вопрос? Я в растерянности.

Answer 1

Указанные индексы представляют собой просто повторное умножение, вы можете использовать for l oop для постепенного умножения.

Что-то вроде:

n = 5
runningPower = 1
for i in range(n + 1):
  runningPower *= 2
  print(runningPower)

Answer 2

Как мы все знаем, pow - это просто повторное умножение.

Итак, мы можем создать al oop, который на каждой итерации будет умножать переменную (мы объявим переменную, его начальное значение равно 1) на 2.

Пример кода:

powers = 1 # Declare variable.
for pow in range(10): # Set a loop for range(10).
    print(powers) # Print the variable.
    powers *= 2 # Power it by 2.

Answer 3

Если вы просто хотите напечатать их, это похоже на хороший способ начать изучать тонкости Python, в частности, использование генераторов:

def twoPower(count):
    val = 1
    for _ in range(count):
        yield val
        val = val * 2

Вы можете создайте список с помощью этого генератора, просто используя понимание списка:

>>> [_ for _ in twoPower(5)]
[1, 2, 4, 8, 16]

И, конечно, вы можете сделать его более читаемым, превратив их в строки и присоединив к ним (используйте "\n" вместо " ", если вы хотите, чтобы каждый номер был в отдельной строке):

>>> print(" ".join([str(_) for _ in twoPower(5)]))
1 2 4 8 16

Если вместо этого вам нужна функция , которая даст вам мощность (по крайней мере, для неотрицательных целых показателей), вы можете просто использовать рекурсию, зная, что выражение n<sup>p</sup> имеет вид:

• n * n<sup>p-1</sup> где p больше нуля; или
• 1, где p равно нулю.

Это означает, что функция может быть такой же простой, как показано ниже:

def pwr(n, p):
    if p == 0:
        return 1
    return n * pwr(n, p - 1)

# Test harness.

for n1 in range(-2, 4):
    for n2 in range(0, 4):
        print(f"{n1:3} ** {n2:3} = {pwr(n1, n2):3}")

Выполняется этот код дает желаемый результат:

 -2 **   0 =   1
 -2 **   1 =  -2
 -2 **   2 =   4
 -2 **   3 =  -8
 -1 **   0 =   1
 -1 **   1 =  -1
 -1 **   2 =   1
 -1 **   3 =  -1
  0 **   0 =   1
  0 **   1 =   0
  0 **   2 =   0
  0 **   3 =   0
  1 **   0 =   1
  1 **   1 =   1
  1 **   2 =   1
  1 **   3 =   1
  2 **   0 =   1
  2 **   1 =   2
  2 **   2 =   4
  2 **   3 =   8
  3 **   0 =   1
  3 **   1 =   3
  3 **   2 =   9
  3 **   3 =  27

Теперь он не обрабатывает отрицательные показатели, но вы можете исправить это с помощью:

def pwr(n, p):
    if p < 0:
        return 1 / pwr(n, -p)
    if p == 0:
        return 1
    return n * pwr(n, p - 1)

Он также не будет обрабатывать не- интегральные показатели, но это намного сложнее, поэтому я предпочитаю сразу их отклонять:

def pwr(n, p):
    if str(type(p)) != "<class 'int'>":
        raise Exception("Non-integral power")
    if p < 0:
        return 1 / pwr(n, -p)
    if p == 0:
        return 1
    return n * pwr(n, p - 1)