Основы Python — Условия и Циклы

Теперь, когда мы понимаем переменные, мы можем начать разрабатывать более сложные структуры кода, которые могут встроить более интересные функциональные возможности в наши скрипты. До этого момента наши скрипты были довольно простыми и ограничивались только выполнением в порядке нисхождения, с одной командой или операцией в строке. Следующие два понятия: Условия и Циклы являются двумя базовыми структурами "управления потоком", которые фактически могут изменять последовательность выполнения нашего кода, создавая тем самым более сложное поведение и более интересные функциональные возможности.

Условия

Условия — это структуры внутри кода, которые могут выполнять различные строки кода на основе определенных "условий", которые выполняются. В Python самый простой тип условного выражения проверяет логическое значение, чтобы удостовериться, является ли оно истинным, а затем выполняет некоторый код, если оно подходит:

b = True

if b:

print 'b is True'

Здесь, поскольку b на самом деле истинно, он проходит тест, вызывая выполнение кода, вставленного после строки "if b:". Попробуйте запустить код еще раз, на этот раз установив b в значение False, чтобы убедиться, что ничего не происходит. В этом случае, если b не проходит тест, весь блок кода вставки после первой условной строки пропускается и игнорируется. В этом коде "if b:" сокращенно означает "if b is True:". Если вы хотите проверить ложность, вы можете использовать сокращенное выражение Python "if not b:" или написать полное "if b is False:".

В Python строка, заканчивающаяся на ":", за которой следуют строки кода вставки, является базовым синтаксисом для создания иерархической структуры и используется со всеми более высокими кодовыми структурами, включая условия, циклы, функции и объекты. Хитрость заключается в том, что Python очень специфичен в том, как эти вставки задаются. У вас есть возможность использовать вкладки или ряд пробелов, но вы не можете смешивать и сопоставлять, и вы должны очень четко указать количество каждого из них, которое вы используете, основываясь на уровне структуры. Например, этот код:

b = False

if b:

print 'b is True'

print 'b is False'

пропустит обе строки печати, если b равно False. Однако, удалив отступ в последней строке, вы извлекаете эту строку из вложенной структуры, и теперь она будет выполняться независимо от того, является ли b истинным или ложным:

b = False

if b:

print 'b is True'

print 'b is False'

С другой стороны, если вы вставите последнюю строку на один уровень дальше:

b = False

if b:

print 'b is True'

print 'b is False'

IndentationError: unexpected indent (неожиданный отступ)

а это значит, что с вашим отступом что-то не так. В этом случае вы сделали отступ до уровня, который не существует в структуре кода. Такие ошибки чрезвычайно распространены и могут быть довольно раздражающими, так как они могут возникнуть либо из-за неправильного отступа, смешивания пробелов с табуляциями, либо из-за того и другого. С другой стороны, этот акцент на правильном отступе обеспечивает визуальную ясность в скриптах Python, которая часто отсутствует в других языках.

Двигаясь дальше, если условный тест не проходит и первый блок кода передается, он может быть пойман оператором else (иначе):

b = True

if b:

print 'b is True'

else:

print 'b is False'

В этом случае, когда b истинно, будет выполняться первое утверждение, а когда b ложно, будет выполняться второе утверждение. Попробуйте этот код в обоих направлениях, чтобы увидеть.

Помимо использования логических значений, вы также можете создавать условные выражения с помощью различных операторов сравнения. Например, условное условие может проверить размер числа:

num = 7

if num > 5:

print 'число больше, чем 5'

t = 'это текст'

if t == 'это текст':

print 'текст соответствует'

В этом примере я использую оператор double equals "==" (двойное равенство), чтобы проверить, соответствует ли одна вещь другой. Это стандартный способ проверки равенства, так как единственное равенство "=" зарезервировано для присвоения значений переменным. Наиболее распространенными операторами сравнения являются:

Вы можете использовать оператор "elif:" (конкатенация else и if) для объединения условий в цепочку для создания более сложных логик:

num1 = 3

num2 = 7

if num1 > 5:

print 'num1 больше чем 5'

elif num2 > 5:

print 'num2 больше чем 5'

else:

print "они оба слишком маленькие!"

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

Наконец, вы также можете объединить несколько тестов в одной строке, используя ключевые слова "and" (И) и "or" (ИЛИ):

num1 = 3

num2 = 7

if num1 < 5 and num2 < 5:

print "они оба слишком малы!"

if num1 < 5 or num2 < 5:

print "по крайней мере один из них слишком мал!"

Циклы

Циклы (Loops) — это второй основной тип структуры "управления потоком", и они могут быть использованы для многократного повторения кода в определенных условиях. Самый простой тип цикла — это цикл, который повторяет каждое значение в списке:

fruits = ['apples', 'oranges', 'bananas']

for fruit in fruits:

print fruit

Структура "for item in list:" ("для элемента в списке") — это основной способ построения циклов в Python. Он в основном запускает код вставки в структуре один раз для каждого элемента в списке, каждый раз устанавливая текущий элемент в переменную, указанную перед "in". В этом случае он будет запускать код "print" три раза, по одному разу для каждого фрукта в списке. Каждый раз, когда код выполняется, переменная "fruit" устанавливается в следующий по порядку фрукт в списке. Это часто используется для применения определенного вида анализа или обработки к каждому элементу в списке.

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

dict = {'a': 1, 'b': 2, 'c': 3}

for key in dict.keys():

print dict[key]

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

В дополнение к повторению каждого элемента в списке или словаре, циклы часто используются для простого повторения определенного фрагмента кода определенное количество раз. Для этого очень полезна функция Python range(), которая принимает целочисленное значение и возвращает список целых чисел, начинающихся с 0, вплоть до этого значения, но не включая его:

Используя функцию range(), мы можем настроить базовый цикл следующим образом:

for i in range(5):

print 'Hello'

Это будет просто запустит код внутри цикла пять раз, так как в действительности мы создаем список из пяти последовательных чисел, а затем повторяем каждый элемент в этом списке. Кроме того, мы также храним каждое последующее число в переменной i, которую мы также можем использовать в цикле. Распространенным примером является объединение обеих стратегий путем привязки функции range() к длине списка (с помощью функции len()), а затем с помощью итерационного числа для получения элементов из этого списка:

fruits = ['apples', 'oranges', 'bananas']

for i in range(len(fruits)):

print fruits[i]

Хотя это может показаться излишним в первом примере, бывают случаи, когда вы хотите построить цикл, который имеет доступ как к элементу в списке, так и к итератору, определяющему его индекс. В таких случаях можно использовать специальную функцию enumerate() (перечислить), которая принимает список и возвращает как элемент, так и его индекс:

fruits = ['apples', 'oranges', 'bananas']

for i, fruit in enumerate(fruits):

print 'the ' + fruit + ' are in position ' + str(i)

В то время как цикл for будет служить большинству целей, существует еще один вид цикла, который будет повторять фрагмент кода до тех пор, пока не будет выполнено определенное условие:

i = 0

while i < 5:

print i

i += 1

В этом случае цикл будет продолжаться, пока выполняется его условие, и остановится только после того, как переменная i получит значение, большее или равное 5. Этот тип цикла может быть полезен, если вы не знаете, как долго должен выполняться цикл, или если вы хотите сделать критерии завершения каким-то образом динамическими по отношению к другим действиям в скрипте. Однако это требует немного большей настройки, так как тестируемое значение должно быть сначала инициализировано (i = 0), и в цикле должен быть код, который изменяет это значение таким образом, чтобы оно в конечном итоге соответствовало критериям выхода. Обозначение + = здесь является сокращением в Python для добавления значения к переменной. Вы можете написать то же самое явно, как:

Этот тип цикла по своей сути более опасен, чем цикл for, Потому что он может легко создать ситуацию, когда цикл никогда не сможет выйти. Теоретически такой цикл будет выполняться бесконечно, хотя на практике он наверняка приведет к сбою Python. Самый опасный вид петли также является самым простым:

while True:

print 'infinity'

(пока значение = Истина, печатай "бесконечность") потому что по определению она не может когда-либо закончиться. Удивительно, но такой цикл действительно имеет некоторые общие применения, но вы никогда не должны писать такой код, если вы абсолютно не знаете, что вы делаете (возможно, попробуйте его только один раз, чтобы вы могли получить представление о его эффектах).

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