В примерах, которые мы использовали ранее, иногда требовалось выполнить одну и ту же работу несколько раз. Мы используем счетчик, чтобы проверить, сколько раз код должен быть выполнен. Эта техника известна как циклирование. Сначала мы рассмотрим оператор while для циклирования.
Цикл while
Синтаксис для оператора while выглядит следующим образом:
while условие:
оператор1
оператор2
Код, который мы хотим повторно использовать, должен быть правильно отступлен под оператором while. Они будут выполнены, если условие истинно. Как и в операторе if-else, любое ненулевое значение считается истинным. Давайте напишем простой код для вывода чисел от 0 до 10:
>>> n = 0
>>> while n < 11:
... print(n)
... n += 1
...
0
1
2
3
4
5
6
7
8
9
10
В первой строке мы устанавливаем n = 0, затем в операторе while условие n < 11, что означает, что любая строка с отступом ниже будет выполняться до тех пор, пока n не станет равным или больше 11. Внутри цикла мы просто выводим значение n и затем увеличиваем его на единицу.
Числа Фибоначчи
Давайте попробуем решить задачу о числах Фибоначчи. В этой последовательности следующее число получается путем сложения двух предыдущих чисел. Таким образом, последовательность выглядит как 1,1,2,3,5,8,13 …….
#!/usr/bin/env python3
a, b = 0, 1
while b < 100:
print(b)
a, b = b, a + b
Результат
$ ./fibonacci1.py
1
1
2
3
5
8
13
21
34
55
89
В первой строке кода мы инициализируем a и b, затем выполняем цикл, пока значение b меньше 100. Внутри цикла сначала выводим значение b, а затем в следующей строке присваиваем a значение b, а b — значение a + b.
Если в вызове функции print передать дополнительный аргумент end и указать строку с пробелом, то значения будут выводиться в одной строке с разделителем в виде пробела. По умолчанию значение end равно ‘n’.
#!/usr/bin/env python3
a, b = 0, 1
while b < 100:
print(b, end=' ')
a, b = b, a + b
Результат
$ ./fibonacci2.py
1 1 2 3 5 8 13 21 34 55 89
Ряды Тейлора
Давайте напишем программу для вычисления ряда Тейлора. Ряд выглядит как e**x =1+x+x**2/2! +x**3/3! +….+ x**n/n! где 0 < x < 1
#!/usr/bin/env python3
x = float(raw_input("Enter the value of x: "))
n = term = num = 1
sum = 1.0
while n <= 100:
term *= x / n
sum += term
n += 1
if term < 0.0001:
break
print("No of Times= %d and Sum= %f" % (n, sum))
Результат выполнения
$ ./powerseries.py
Enter the value of x: 0
No of Times= 2 and Sum= 1.000000
$ ./powerseries.py
Enter the value of x: 0.1
No of Times= 5 and Sum= 1.105171
$ ./powerseries.py
Enter the value of x: 0.5
No of Times= 7 and Sum= 1.648720
В этой программе мы ввели новое ключевое слово break. Что делает break - это останавливает самый внутренний цикл. В этом примере мы используем break под условием if
if term < 0.0001:
break
Это означает, что если значение term меньше 0.0001, то выходим из цикла.
Таблица умножения
В этом примере мы собираемся вывести таблицу умножения до 10.
#!/usr/bin/env python3
i = 1
print("-" * 50)
while i < 11:
n = 1
while n <= 10:
print("%4d" % (i * n), end=' ')
n += 1
print()
i += 1
print("-" * 50)
Результат выполнения
$ ./multiplication.py
--------------------------------------------------
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
--------------------------------------------------
Здесь мы использовали один цикл while внутри другого цикла, это известно как вложенное циклирование. Также вы можете увидеть одну интересную инструкцию здесь
print "-" * 50
В инструкции print, если мы умножим строку на целое число n, строка будет выведена n раз. Несколько примеров
>>> print("*" * 10)
**********
>>> print("#" * 20)
####################
>>> print("--" * 20)
----------------------------------------
>>> print("-" * 40)
----------------------------------------
Некоторые примеры печати *
Вот несколько примеров, которые вы можете часто встречать в отчетах колледжа
Дизайн 1
#!/usr/bin/env python3
row = int(input("Введите количество строк: "))
n = row
while n >= 0:
x = "*" * n
print(x)
n -= 1
Результат
$ ./design1.py
Введите количество строк: 5
*****
****
***
**
*
Дизайн 2
#!/usr/bin/env python3
n = int(input("Введите количество строк: "))
i = 1
while i <= n:
print("*" * i)
i += 1
Результат
$ ./design2.py
Введите количество строк: 5
*
**
***
****
*****
Дизайн 3
#!/usr/bin/env python
row = int(input("Введите количество строк: "))
n = row
while n >= 0:
x = "*" * n
y = " " * (row - n)
print(y + x)
n -= 1
Результат
$ ./design3.py
Введите количество строк: 5
*****
****
***
**
*
Списки
Мы собираемся изучить структуру данных, называемую списком, прежде чем перейти к изучению циклов. Списки могут быть записаны как список значений, разделенных запятыми (элементов), заключенных в квадратные скобки.
>>> a = [ 1, 342, 2233423, 'India', 'Fedora']
>>> a
[1, 342, 2233423, 'India', 'Fedora']
Списки могут содержать любые другие данные. Они также работают как последовательности, что означает
>>> a[0]
1
>>> a[4]
'Fedora'
Вы даже можете разделить его на разные части, примеры приведены ниже
>>> a[4]
'Fedora'
>>> a[-1]
'Fedora'
>>> a[-2]
'India'
>>> a[0:-1]
[1, 342, 2233423, 'India']
>>> a[2:-2]
[2233423]
>>> a[:-2]
[1, 342, 2233423]
>>> a[0::2]
[1, 2233423, 'Fedora']
В последнем примере мы использовали два :(s), последнее значение в третьих скобках указывает шаг. s[i:j:k] означает срез s от i до j с шагом k.
Чтобы проверить, существует ли какое-либо значение в списке или нет, вы можете сделать
>>> a = ['Fedora', 'is', 'cool']
>>> 'cool' in a
True
>>> 'Linux' in a
False
Это означает, что мы можем использовать приведенное выше выражение в качестве условия для if. Встроенная функция len() может сообщить длину списка.
>>>
## Цикл for
Существует другой способ организации цикла с использованием оператора *for*. В Python оператор *for* отличается от того, как он работает в *C*. Здесь оператор for перебирает элементы любой последовательности (списка или строки). Пример приведен ниже
a = [‘Fedora’, ‘is’, ‘powerfull’] for x in a: … print x, … Fedora is powerfull
Мы также можем делать такие вещи, как
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] for x in a[::2]: … print(x) 1 3 5 7 9
функция range()
range() — это встроенный класс. Из документации справки
class range(object)
range(stop) -> объект range
range(start, stop[, step]) -> объект range
Возвращает виртуальную последовательность чисел от start до stop с шагом step.
Теперь, если вы хотите увидеть это сообщение справки в вашей системе, введите help(range) в интерпретаторе Python. help(s) вернет сообщение справки для объекта s. Примеры функции range
>>> range(1, 5)
[1, 2, 3, 4]
>>> range(1, 15, 3)
[1, 4, 7, 10, 13]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Оператор continue
Так же, как и break, у нас есть другой оператор, continue, который пропускает выполнение кода после себя и возвращается к началу цикла. Это означает, что он поможет вам пропустить часть цикла. В приведенном ниже примере мы попросим пользователя ввести целое число, если ввод отрицательный, то мы спросим снова, если положительный, то возведем число в квадрат. Чтобы выйти из бесконечного цикла, пользователь должен ввести 0.
#!/usr/bin/env python3
while True:
n = int(input("Пожалуйста, введите целое число: "))
if n < 0:
continue #это вернет выполнение к началу цикла
elif n == 0:
break
print("Квадрат равен ", n ** 2)
print("До свидания")
Вывод
$ ./continue.py
Пожалуйста, введите целое число: 34
Квадрат равен 1156
Пожалуйста, введите целое число: 4
Квадрат равен 16
Пожалуйста, введите целое число: -9
Пожалуйста, введите целое число: 0
До свидания
Else loop
Мы можем иметь необязательное else выражение после любого цикла. Оно будет выполнено после цикла, если только оператор break не остановил цикл.
>>> for i in range(0, 5):
... print(i)
... else:
... print("Bye bye")
...
0
1
2
3
4
Bye bye
Мы увидим больше примеров использования break и continue позже в книге.
Игра в палочки
Это очень простая игра в палочки. Есть 21 палочка, сначала пользователь выбирает количество палочек от 1 до 4, затем компьютер выбирает палочки (от 1 до 4). Тот, кто возьмет последнюю палочку, проиграет. Сможете ли вы определить случай, когда пользователь выиграет?
#!/usr/bin/env python3
sticks = 21
print("Есть 21 палочка, вы можете взять от 1 до 4 палочек за раз.")
print("Тот, кто возьмет последнюю палочку, проиграет")
while True:
print("Осталось палочек: " , sticks)
sticks_taken = int(input("Возьмите палочки (1-4):"))
if sticks == 1:
print("Вы взяли последнюю палочку, вы проиграли")
break
if sticks_taken >= 5 or sticks_taken <= 0:
print("Неверный выбор")
continue
print("Компьютер взял: " , (5 - sticks_taken) , "\n")
sticks -= 5