Условные операторы в python: Условный оператор — Основы Python

Python. Урок 5. Условные операторы и циклы

В этом уроке рассмотрим оператор ветвления if и операторы цикла while и for.  Основная цель – это дать общее представление об этих операторах и на простых примерах показать базовые принципы работы с ними.

Условный оператор ветвления if

Оператор ветвления if  позволяет выполнить определенный набор инструкций в зависимости от некоторого условия. Возможны следующие варианты использования.

1. Конструкция if

Синтаксис оператора if выглядит так.

if выражение:
    инструкция_1
    инструкция_2
    ...
    инструкция_n

После оператора if  записывается выражение. Если это выражение истинно, то выполняются инструкции, определяемые данным оператором. Выражение является истинным, если его результатом является число не равное нулю, непустой объект, либо логическое True. После выражения нужно поставить двоеточие “:”.

ВАЖНО: блок кода, который необходимо выполнить, в случае истинности выражения, отделяется четырьмя пробелами слева!

Примеры:

if 1:
   print("hello 1")

Напечатает: hello 1

a = 3
if a == 3:
    print("hello 2")

Напечатает: hello 2

a = 3
if a > 1:
   print("hello 3")

Напечатает: hello 3

lst = [1, 2, 3]
if lst :
   print("hello 4")

Напечатает: hello 4

2. Конструкция if – else

Бывают случаи, когда необходимо предусмотреть альтернативный вариант выполнения программы. Т.е. при истинном условии нужно выполнить один набор инструкций, при ложном – другой. Для этого используется конструкция if – else.

if выражение:
    инструкция_1
    инструкция_2
    ...
    инструкция_n
else:
    инструкция_a
    инструкция_b
    . ..
    инструкция_x

Примеры.

a = 3
if a > 2:
   print("H")
else:
   print("L")

Напечатает: H

a = 1
if a > 2:
   print("H")
else:
   print("L")

Напечатает: L

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

a = 17
b = True if a > 10 else False
print(b)

В результате выполнения такого кода будет напечатано: True

3. Конструкция if – elif – else

Для реализации выбора из нескольких альтернатив можно использовать конструкцию if – elif – else.

if выражение_1:
    инструкции_(блок_1)
elif выражение_2:
    инструкции_(блок_2)
elif выражение_3:
    инструкции_(блок_3)
else:
    инструкции_(блок_4)

Пример.

a = int(input("введите число:"))
if a < 0:
   print("Neg")
elif a == 0:
   print("Zero")
else:
   print("Pos")

Если пользователь введет число меньше нуля, то будет напечатано “Neg“, равное нулю – “Zero“, большее нуля – “Pos“.

Оператор цикла while

Оператор цикла while  выполняет указанный набор инструкций до тех пор, пока условие цикла истинно. Истинность условия определяется также как и в операторе if. Синтаксис оператора while 

выглядит так.

while выражение:
    инструкция_1
    инструкция_2
    ...
    инструкция_n

Выполняемый набор инструкций называется телом цикла.

Пример.

a = 0
while a < 7:
   print("A")
   a += 1

Буква “А” будет выведена семь раз в столбик.

Пример бесконечного цикла.

a = 0
while a == 0:
   print("A")

Операторы

break и continue

При работе с циклами используются операторы break  и continue.

Оператор break  предназначен для досрочного прерывания работы цикла while.

Пример.

a = 0
while a >= 0:
   if a == 7:
       break
   a += 1
   print("A")

В приведенном выше коде, выход из цикла произойдет при достижении переменной a  значения 7. Если бы не было этого условия, то цикл выполнялся бы бесконечно.

Оператор continue  запускает цикл заново, при этом код, расположенный после данного оператора, не выполняется.

Пример.

a = -1
while a < 10:
   a += 1
   if a >= 7:
       continue
   print("A")

При запуске данного кода символ “А” будет напечатан 7 раз, несмотря на то, что всего будет выполнено 11 проходов цикла.

Оператор цикла for

Оператор for  выполняет указанный набор инструкций заданное количество раз, которое определяется количеством элементов в наборе.

Пример. 

for i in range(5):
   print("Hello")

В результате “Hello” будет выведено пять раз.

Внутри тела цикла можно использовать операторы break  и continue, принцип работы их точно такой же как и в операторе while.

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

lst = [1, 3, 5, 7, 9]
for i in lst:
   print(i ** 2)

Также можно пройти по всем буквам в строке.

word_str = "Hello, world!"
for l in word_str:
   print(l)

Строка “Hello, world!” будет напечатана в столбик.

На этом закончим краткий обзор операторов ветвления и цикла.

P.S.

Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.

<<< Python. Урок 4. Арифметические операции   Python. Урок 6. Работа с IPython и Jupyter Notebook >>>

Язык программирования «Python». Условный оператор if

Оператор if

Условный оператор if позволяет выполнить определенный набор инструкций в зависимости от некоторого условия. Использовать этот оператор можно в нескольких вариантах.

В этом видео разберем только 2 варианта.

1 Конструкция if

В простейшем варианте использование оператора if выглядит так:

if условие:
    блок команд 1
блок команд 2

После оператора if обязательно записывается условие. После условия необходимо поставить знак двоеточия “:”. Если данное условие будет истинно, то выполняется блок команд 1. Вне зависимости от условия блок команд 2 будет выполняться в любом случае.

Рассмотрим пример

if a==777:
    print("Этот принт сработает, если а будет равно 777.")
    print("И так же этот принт.")
    print("И этот.")

print("А это сообщение выведется в любом случае")

Здесь 3 команды, сдвинутые отступами, будут выполняться только в том случае, если переменная а будет равна 777. А последняя команда будет выполняться в любом случае, т.к. по оступам она стоит на том же уровне, что и оператор if, тем самым как бы закрывая собой блок команд внутри условного оператора.

Еще пример

money = 100
ticket = 90
if money > ticket:
    print("УРАААА!!!")
    print("Я иду в кино!")
print("Пора идти домой")

Что касается отступов. Внутри блока инструкции должны находиться на одинаковом уровне отступов. В противном случае будет ошибка.

if 5>1:
  print("Тут оступ в 2 пробела.")
    print("А здесь в четыре. Будет ошибка.")

Пример программы:

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

a=int(input())
b=int(input())
if b>a:
    a,b = b,a
print(a,b)

2 Конструкция if-else

В состав оператора if может входить необязательный оператор else. Схема использования выглядит следующим образом:

if условие:
    блок команд 1
else:
    блок команд 2
блок команд 3

Инструкции, входящие в блок команд 1, будут выполняться только в случае, если условие будет истинно. В противном случае будет выполняться блок команд 2. А блок команд 3 выполнится после этого в любом случае.

Пример программы на if-else

Вводится одно число и необходимо вывести сообщение «Четное», если число делится на 2 без остатка, или «Нечетное» — в противном случае

a = int(input())
if a%2==0:
    print('Четное')
else:
    print('Нечетное')

Еще пример программы на if-else

Вводится два числа и необходимо вывести самое большое значение среди них.

a = int(input())
b = int(input())
if a>b:
    print(a)
else:
    print(b)

Вопросы для проверки пройденного:

1. 1 Исправьте следующий код:

   score = int(input("Ваш балл за экзамен")
   if score > 80:
       print("Хороший результат.")

2. 2 В этом коде две ошибки. Найдите и исправьте их:

   x == 7
   if x % 2 !=0:
       print("x - нечетное число.  ")
   else
       print("x - четное число.")

   3 В этом коде четыре ошибки. Скопируйте код в IDLE и найдите ошибки.

   day = input("Как называется 5й день недели?")
   if day = "Friday" or d=="friday":
       print("Верно!")
       else
       print("Неверно!")

   4 Подумайте почему эта программа неправильно работает.

   x=input("Как настроение?")
   if x=="Хорошо" or "Прекрасно":
       print("Приятно слышать!")

4. Условные операторы и циклы. Начальное программирование на Python для начинающих веб-разработчиков

4.1. Условное исполнение

4.2. Связанные условные операторы

Иногда существует более двух возможностей, и нам нужно более двух ветви. Один из способов выразить такое вычисление — цепочка . условное :

 если x < y:
    STATEMENTS_A
Элиф х > у:
    STATEMENTS_B
еще:
    STATEMENTS_C
 

Блок-схема этого связанного условия

elif является сокращением от else if . Опять же, ровно одна ветвь будет казнен. Количество операторов elif не ограничено, а только один (и необязательный) окончательный оператор else разрешен, и он должен быть последняя ветвь в операторе:

, если выбор == 'a':
    print("Вы выбрали 'а'.")
Элиф выбор == 'б':
    print("Вы выбрали 'b'.")
Элиф выбор == 'с':
    print("Вы выбрали 'c'.")
еще:
    print("Неверный выбор")
 

Каждое условие проверяется по порядку. Если первое ложно, проверяется следующее, и так далее. Если одно из них истинно, выполняется соответствующая ветвь, и заявление заканчивается. Даже если верно несколько условий, верно только первое филиал выполняет.

4.3. Вложенные условные операторы

Одно условное выражение также может быть вложенным в другое. (это одна и та же тема опять-таки композицию!) Мы могли бы написать предыдущий пример следующим образом:

Блок-схема этого вложенного условного оператора

, если х < у:
    STATEMENTS_A
еще:
    если х > у:
        STATEMENTS_B
    еще:
        STATEMENTS_C
 

Внешнее условное предложение содержит две ветви. Вторая ветвь содержит другой оператор if , который имеет две собственные ветви. Эти две ветви также может содержать условные операторы.

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

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

 if 0 < x: # предположим, что x здесь является целым числом
    если х < 10:
        print("x - положительная цифра")
 

Функция print вызывается только в том случае, если мы проходим оба условия, поэтому мы можем использовать оператор и :

, если 0 < x и x < 10:
    print("x - положительная цифра")
 

Note

Python на самом деле допускает для этого краткую ручную форму, поэтому следующее будет также работает:

, если 0 < x < 10:
    print("x - положительная цифра")
 

4.

4. Итерация

Компьютеры часто используются для автоматизации повторяющихся задач. Повторение идентичных или подобные задачи без ошибок — это то, с чем компьютеры справляются хорошо и люди плохо работают.

Повторное выполнение набора операторов называется итерацией. Python имеет два оператора для итерация - вместо оператора , с которым мы познакомились в прошлой главе, и в то время как заявление.

Прежде чем мы рассмотрим их, нам нужно рассмотреть несколько идей.

4.4.1. Reassignmnent

Как мы видели в разделе «Переменные являются переменными», это разрешено делать более одного присваивания одной и той же переменной. Новое задание заставляет существующую переменную ссылаться на новое значение (и перестает ссылаться на старое ценить).

 Брюс = 5
печать (брюс)
Брюс = 7
печать (брюс)
 

Вывод этой программы

, потому что при первом выводе bruce его значение равно 5, а при втором время, его значение равно 7.

Вот как выглядит переназначение на снимке состояния:

При переназначении особенно важно различать оператор присваивания и логическое выражение, проверяющее равенство. Потому что Python использует токен равенства ( = ) для назначения, заманчиво интерпретировать такое утверждение, как a = b в качестве логического теста. В отличие от математики, это не так! Помните, что токен Python для равенства оператор == .

Также обратите внимание, что проверка на равенство симметрична, а присваивание — нет. Для например, если a == 7 , то 7 == a . Но в Python оператор a = 7 является законным, а 7 = a - нет.

Более того, в математике утверждение о равенстве всегда истинно. Если а == b сейчас, потом a всегда будет равно b . В Python оператор присваивания может сделать две переменные равными, но из-за возможности переназначения они не должны оставаться такими:

 a = 5
b = a # после выполнения этой строки a и b теперь равны
a = 3 # после выполнения этой строки a и b больше не равны
 

Третья строка изменяет значение на , но не меняет значение b , так что они уже не равны.

Примечание

В некоторых языках программирования для назначения используется другой символ, например <- или := , чтобы избежать путаницы. Python решил использовать токены = для присваивания и == для равенства. это общий выбор, также встречающийся в таких языках, как C, C++, Java, JavaScript и PHP, хотя это немного сбивает с толку новых программистов.

4.4.2. Обновление переменных

Когда выполняется оператор присваивания, правостороннее выражение (т.е. выражение, которое следует за токеном назначения), оценивается первым. Затем результат этой оценки записывается в переменную слева сторону, тем самым изменяя ее.

Одной из наиболее распространенных форм переназначения является обновление, когда новое значение переменной зависит от ее старого значения.

 n = 5
п = 3 * п + 1
 

Вторая строка означает «получить текущее значение n, умножить его на три и добавить один, и поместите ответ обратно в n в качестве его нового значения». Итак, после выполнения двумя строками выше n будет иметь значение 16.

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

 >>> ш = х + 1
Traceback (последний последний вызов):
  Файл "<интерактивный ввод>", строка 1, в
NameError: имя «x» не определено
 

Прежде чем вы сможете обновить переменную, вы должны инициализировать ее, обычно с помощью простое присвоение:

 >>> x = 0
>>> х = х + 1
 

Второй оператор — обновление переменной путем прибавления к ней 1 — очень общий. Это называется приращением переменной; вычитание 1 называется уменьшение .

4.5. Цикл

for

Цикл for обрабатывает каждый элемент в последовательности, поэтому он используется с Python типы данных последовательности - строки, списки и кортежи.

Каждый элемент в свою очередь (повторно) присваивается переменной цикла, а тело выполняется цикл.

Общая форма цикла для :

 для LOOP_VARIABLE в ПОСЛЕДОВАТЕЛЬНОСТИ:
    ЗАЯВЛЕНИЯ
 

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

Переменная цикла создается при выполнении оператора for , поэтому вы не нужно создать переменную до этого. Каждая итерация назначает цикл переменной к следующему элементу в последовательности, а затем выполняет операторы в организме. Оператор завершается, когда последний элемент последовательности достиг.

Этот тип потока называется цикл , потому что он возвращается к началу после каждой итерации.

 для друга в ['Марго', 'Кэтрин', 'Присила']:
    приглашение = "Привет " + друг + ". Пожалуйста, приходите на мою вечеринку в субботу!"
    печать (приглашение)
 

Прохождение всех элементов в последовательности называется обходом последовательность или обход .

Вы должны запустить этот пример, чтобы увидеть, что он делает.

Подсказка

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

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

Часто вам понадобится цикл, повторяющийся заданное количество раз, или перебирает заданную последовательность чисел. Функция диапазона пригодится для этого.

 >>> для i в диапазоне (5):
... print('я сейчас:', я)
...
я сейчас 0
мне сейчас 1
мне сейчас 2
мне сейчас 3
мне сейчас 4
>>>
 

4.6. Таблицы

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

Когда на сцене появились компьютеры, одной из первых реакций было «Это отлично! Мы можем использовать компьютеры для создания таблиц, так что не будет ошибки». Это оказалось правдой (в основном), но недальновидной. Вскоре после этого, компьютеры и калькуляторы были настолько распространены, что таблицы устарели.

Ну, почти. Для некоторых операций компьютеры используют таблицы значений, чтобы получить приблизительный ответ, а затем выполнить вычисления, чтобы улучшить приближение. В некоторых случаях в базовых таблицах были ошибки, наиболее известные из которых в таблице чип процессора Intel Pentium, используемый для выполнения операций с плавающей запятой разделение.

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

 для x в диапазоне (13): # Генерация чисел от 0 до 12
    напечатать (х, '\ т', 2 ** х)
 

Использование символа табуляции ( '\t' ) обеспечивает хорошее выравнивание вывода.

 0 1
1 2
2 4
3 8
4 16
5 32
6 64
7 128
8 256
9512
10 1024
11 2048
12 4096
 

4.7. Оператор

while

Общий синтаксис оператора while выглядит следующим образом:

 while BOOLEAN_EXPRESSION:
    ЗАЯВЛЕНИЯ
 

Подобно операторам ветвления и циклу for , оператор while составной оператор, состоящий из заголовка и тела. Цикл в то время как выполняется неизвестное количество раз, пока значение BOOLEAN EXPRESSION истинно.

Вот простой пример:

 число = 0
prompt = "В чем смысл жизни, вселенной и всего остального?"
в то время как число! = "42":
    число = ввод (подсказка)
 

Обратите внимание, что если в первой строке номер установлен на 42 , тело сообщения , в то время как оператор вообще не будет выполняться.

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

 имя = 'Харрисон'
Guess = input("Итак, я думаю об имени человека.  Попробуйте угадать его:")
позиция = 0
в то время как угадать != имя и pos < len (имя):
    print("Нет, это не то! Подсказка: буква ", end='')
    print(pos + 1, "is", name[pos] + ".", end='')
    предположение = ввод ("Угадай еще раз:")
    позиция = позиция + 1
если pos == len(имя) и имя != предположение:
    print("Жаль, вы не смогли его получить. Имя было ", name + ".")
еще:
    print("\nОтлично, вы поняли", pos + 1, "догадки!")
 

Последовательность выполнения оператора while работает следующим образом:

1. Вычислить условие ( BOOLEAN EXPRESSION ), выдав False или Правда .

2. Если условие ложно, выйти из инструкции while и продолжить выполнение на следующем операторе.

3. Если условие верно, выполнить каждый из STATEMENTS в теле и затем вернитесь к шагу 1.

Тело состоит из всех операторов под заголовком с тем же отступ.

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

Бесконечным источником развлечения для программистов является наблюдение, что указания на шампунь, пену, полоскание, повторение - бесконечный цикл.

В этом случае мы можем доказать, что цикл завершается, потому что мы знаем, что значение len(name) конечно, и мы видим, что значение pos увеличивается каждый раз в цикле, поэтому в конечном итоге он должен быть равен лен(имя) . В других случаях это не так просто сказать.

Здесь вы заметите, что цикл while вам больше подходит — программатор — чем эквивалент для цикла . При использовании пока loop нужно самостоятельно контролировать переменную цикла: присвоить ей начальное значение, тест на завершение, а затем убедитесь, что вы изменили что-то в теле, чтобы что цикл завершается.

4.8. Выбор между

для и , в то время как

Так зачем иметь два вида цикла, если для выглядит проще? Следующий пример показывает случай, когда нам нужна дополнительная мощность, которую мы получаем от цикла , в то время как .

Используйте цикл для , если вы знаете, прежде чем начать цикл, максимальное количество раз, когда вам нужно выполнить тело. Например, если вы пересекаете список элементов, вы знаете, что максимальное количество итераций цикла вы можете возможно, нужно «все элементы в списке». Или если вам нужно распечатать Таблица умножения на 12, мы сразу знаем, сколько раз нужно будет выполнить цикл.

Таким образом, любая проблема, такая как «перебрать эту модель погоды для 1000 циклов» или «поиск этот список слов», «найти все простые числа до 10000» предполагают, что для цикла лучше всего.

Напротив, если вам нужно повторять некоторые вычисления до тех пор, пока условие выполняется, и вы не можете заранее рассчитать, когда это произойдет, так как мы сделали в программе «Величайшее имя», вам понадобится цикл while .

Мы называем первый случай определенной итерацией — у нас есть определенные границы для того, что нужно. Последний случай называется бесконечная итерация — мы не уверены, сколько итераций нам потребуется — мы даже не можем установить верхняя граница!

4.9. Отслеживание программы

Для написания эффективных компьютерных программ программисту необходимо развить способность до отслеживать выполнение компьютерной программы. Трейсинг включает в себя «становление компьютер» и следуя за потоком выполнения через пример запуска программы, запись состояния всех переменных и любых выходных данных, которые программа генерирует после каждая инструкция выполняется.

Чтобы понять этот процесс, давайте проследим выполнение программы с Раздел операторов while.

В начале трассировки у нас есть локальная переменная, имя с начальным значение 'Харрисон' . Пользователь вводит строку, которая хранится в переменная, догадка . Предположим, они вводят «Марибель» . Следующая строка создает переменную с именем pos и присваивает ей начальное значение 0 .

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

 угадывание имени pos выход
---- ----- --- ------
'Харрисон' 'Марибель' 0
 

Поскольку угадайте != name and pos < len(name) оценивается как True (потратьте минуту, чтобы убедиться в этом), тело цикла выполняется.

Теперь пользователь увидит

 Нет, это не так! Подсказка: буква 1 — «Н». Угадай еще раз:
 

Если на этот раз пользователь введет Karen , pos будет увеличено, предположение != имя и позиция < len(name) снова оценивается как True , и наш трассировка теперь будет выглядеть так:

 имя угадай поз вывод
---- ----- --- ------
'Харрисон' 'Марибель' 0 Нет, это не то! Подсказка: буква 1 — «Н».  Угадай еще раз:
'Гаррисон' 'Генри' 1 Нет, это не так! Подсказка: буква 2 — «а». Угадай еще раз:
 

Полная трассировка программы может дать что-то вроде этого: ---- ----- --- ------ 'Харрисон' 'Марибель' 0 Нет, это не то! Подсказка: буква 1 — «Н». Угадай еще раз: 'Гаррисон' 'Генри' 1 Нет, это не так! Подсказка: буква 2 — «а». Угадай еще раз: 'Харрисон' 'Хаким' 2 Нет, это не так! Подсказка: буква 3 — «р». Угадай еще раз: 'Гаррисон' 'Гарольд' 3 Нет, это не так! Подсказка: буква 4 — «р». Угадай еще раз: 'Гаррисон' 'Гарри' 4 Нет, это не так! Подсказка: буква 5 — «i». Угадай еще раз: 'Harrison' 'Harrison' 5 Отлично, вы угадали за 6 попыток!

Трассировка может быть немного утомительной и подверженной ошибкам (вот почему мы заставляем компьютеры выполнять это в первую очередь!), но это важный навык для программиста иметь. Из трассировки мы можем многое узнать о том, как работает наш код.

4.11. Другой пример

в то время как : Игра в угадайку

Следующая программа реализует простую игру в угадайку:

 import random # Импорт случайного модуля
number = random. randrange(1, 1000) # Получить случайное число от [1 до 1000)
догадки = 0
угадай = int(input("Угадай мое число от 1 до 1000: "))
пока угадай != число:
    догадки += 1
    если угадать > число:
        print(угадайте, "слишком высоко")
    Элиф угадать < число:
        print(угадайте, "слишком мало")
    предположение = int(input("Угадай еще раз:"))
print("\n\nОтлично, вы поняли", догадки, "догадки!")
 

Эта программа использует математический закон трихотомии (данные реальные числа a и b, ровно одно из этих трех должно быть истинным: a > b, a < b или а == б).

4.14. Другой пример

вместо

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

 предложение = ввод('Пожалуйста, введите предложение:')
нет_пробелов = ''
на букву в предложении:
    если буква != ' ':
        no_spaces += буква
print("Вы предлагаете с удаленными пробелами:")
печать (без_пробелов)
 

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

4.15. Вложенные циклы для вложенных данных

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

 студентов = [("Алехандро", ["CompSci", "Физика"]),
            ("Джастин", ["Математика", "CompSci", "Статистика"]),
            ("Ed", ["CompSci", "Бухгалтерский учет", "Экономика"]),
            ("Марго", ["InfSys", "Бухгалтерский учет", "Экономика", "CommLaw"]),
            ("Питер", ["Социология", "Экономика", "Право", "Статистика", "Музыка"]))]
 

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

 # вывести всех студентов с количеством их курсов.
по (название, предметы) у учащихся:
    print(имя, "берет", len(предметы), "курсы")
 

Python отвечает следующим выводом:

 Альхандро проходит 2 курса
Джастин проходит 3 курса
Эд проходит 4 курса
Марго посещает 4 курса
Питер проходит 5 курсов
 

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

 # Подсчитайте, сколько студентов сдают CompSci
счетчик = 0
по (название, предметы) у учащихся:
    for s в темах: # вложенный цикл!
        если s == "CompSci":
            счетчик += 1
print("Количество студентов, изучающих CompSci, равно", counter)
 

 Количество студентов, изучающих CompSci, равно 3
 

Вам следует составить список интересующих вас данных — возможно, список ваших компакт-дисков, каждый из которых содержит список названий песен на компакт-диске или список названия фильмов, каждое из которых содержит список кинозвезд, снявшихся в фильме. Ты Затем можно было бы задать такие вопросы, как «В каких фильмах снималась Анджелина Джоли?»

4.16. Включение списков

Включение списков — это синтаксическая конструкция, позволяющая создавать списки. создан из других списков с использованием компактного математического синтаксиса:

 >>> числа = [1, 2, 3, 4]
>>> [x**2 вместо x в цифрах]
[1, 4, 9, 16]
>>> [x**2 вместо x в цифрах, если x**2 > 8]
[9, 16]
>>> [(x, x**2, x**3) для x в цифрах]
[(1, 1, 1), (2, 4, 8), (3, 9, 27), (4, 16, 64)]
>>> files = ['bin', 'Данные', 'Рабочий стол', '. bashrc', '.ssh', '.vimrc']
>>> [имя вместо имени в файлах, если имя[0] != '.']
['bin', 'Данные', 'Рабочий стол']
>>> буквы = ['а', 'б', 'с']
>>> [n * буква вместо n цифрами вместо буквы буквами]
['a', 'b', 'c', 'aa', 'bb', 'cc', 'aaa', 'bbb', 'ccc', 'aaaa', 'bbbb', 'cccc']
>>>
 

Общий синтаксис для выражения понимания списка:

 [выражение для элемента 1 в последовательности 1 для элемента 2 в последовательности 2 ... для элемента x в последовательности, если условие]
 

Это выражение списка имеет тот же эффект, что и:

 output_sequence = []
для элемента 1 в последовательности 1:
    для item2 в seq2:
        ...
            для itemx в seqx:
                если условие:
                    output_sequence.append(выражение)
 

Как видите, понимание списка намного компактнее.

4.17. Глоссарий

append

Для добавления новых данных в конец файла или другого объекта данных.

блок

Группа последовательных операторов с одинаковым отступом.

body

Блок операторов в составном операторе, следующий за заголовок.

филиал

Один из возможных путей потока выполнения определяется условное исполнение.

цепочка условных

Условная ветвь с более чем двумя возможными потоками выполнения. В Связанные условные операторы Python записываются с помощью if ... elif ... else заявления.

составной оператор

Оператор Python, состоящий из двух частей: заголовка и тела . заголовок начинается с ключевого слова и заканчивается двоеточием ( : ). Тело содержит ряд других операторов Python с одинаковым отступом количество.

Note

Мы будем использовать стандарт Python из 4 пробелов для каждого уровня отступ.

условие

Логическое выражение в условном выражении, которое определяет, какое ветка выполнена.

условный оператор

Оператор, управляющий потоком выполнения в зависимости от некоторых состояние. В Python ключевые слова if , elif и else используется для условных операторов.

counter

Переменная, используемая для подсчета чего-либо, обычно инициализируется нулем и увеличивается в теле цикла.

курсор

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

уменьшение

Уменьшение на 1.

определенная итерация

Цикл, в котором у нас есть верхняя граница числа повторений тело будет казнено. Определенная итерация обычно лучше всего закодирована как для цикла .

разделитель

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

приращение

Как существительное, так и глагол, приращение означает увеличение на 1.

бесконечный цикл

Цикл, в котором условие завершения никогда не выполняется.

бесконечная итерация

Цикл, в котором нам просто нужно продолжать, пока не будет выполнено какое-то условие. А , тогда как для этого случая используется оператор .

инициализация (переменной)

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

итерация

Повторное выполнение набора операторов программирования.

цикл

Оператор или группа операторов, которые выполняются многократно до тех пор, пока условие завершения выполнено.

переменная цикла

Переменная, используемая как часть условия завершения цикла.

вложенный цикл

Цикл внутри тела другого цикла.

вложенность

Одна структура программы внутри другой, например, условный оператор внутри ветви другого условного оператора.

новая строка

Специальный символ, который заставляет курсор перемещаться в начало следующая строка.

приглашение

Визуальная подсказка, указывающая пользователю на ввод данных.

переназначение

Выполнение более одного присвоения одной и той же переменной в течение выполнение программы.

табуляция

Специальный символ, который заставляет курсор перемещаться на следующую позицию табуляции на текущей строке.

трихотомия

Для любых действительных чисел a и b точно одно из следующих выполняется соотношение: a < b , a > b , или a == b . Таким образом, когда вы можете установить, что два из отношений ложны, можно предположить, что оставшийся один верный.

трассировка

Следить за ходом выполнения программы вручную, записывая изменение состояния переменных и любого произведенного вывода.

4.18. Упражнения

• Глава 4, набор упражнений 0: Обзор главы

• Набор для упражнений по главе 4 1

• Глава 4, набор упражнений 2

Условные операторы — программирование на Python

Содержание

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

если условие:
    код, который будет выполнен, если условие верно
 

 класс = 34
если класс >= 60:
    print('Вы сдали экзамен.')
    print('Поздравляем!')
 

Примеры условных операторов

Пример: определение четности или нечетности элементов списка

Модуль % — это математический оператор, который можно использовать для проверки делимости. Выражение a % b возвращает остаток от a после деления на b . Если этот остаток равен 0, то это означает, что a делится на b .

Например:

 печатать(27 % 3 == 0)
печать (17 % 3 == 0)
 

 Правда
ЛОЖЬ
 

Одним из распространенных применений оператора модуля является проверка, является ли число четным или нечетным.

 печать(19 % 2 == 0 )
печать (16% 2 == 0)
 

 Ложь
Истинный
 

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

 [x] четно.
[х] нечетное.
 

 мой_список = [74, -55, -77, 58, 0, 91, 62, 0, -91, 61]
для i в диапазоне (0, len (my_list)):
    если my_list[i] % 2 == 0:
        print(str(my_list[i]) + "четно.")
    еще:
        print(str(my_list[i]) + " нечетно.")
 

 74 четно.
-55 странно.
-77 странно.
58 четно. 
0 четно.
91 странно.
62 четно.
0 четно.
-91 странно.
61 странно.
 

Пример: определение того, являются ли элементы списка положительными, отрицательными или ни одним из них

Ячейка ниже содержит внешний вид, который распечатывает одно из следующих сообщений для каждого элемента в0015 мой_список .

 [x] положительный.
[х] отрицательно.
[x] не является ни положительным, ни отрицательным.
 

 для i в диапазоне (0, len (my_list)):
    
    если my_list[i] < 0:
        print(str(my_list[i]) + "отрицательно.")
    Элиф my_list[i] > 0:
        print(str(my_list[i]) + " положительный.")
    еще:
        print(str(my_list[i]) + "не является ни положительным, ни отрицательным.")
 

 74 положительный.
-55 отрицательный.
-77 отрицательный.
58 положительный.
0 не является ни положительным, ни отрицательным.
91 положительный.
62 положительный.
0 не является ни положительным, ни отрицательным.
-91 отрицательный.
61 положительный.
 

Пример: Классификация кредитных баллов

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

• 0 - 599 считается «плохим».

• 600 - 649 считается «плохим».

• 650 - 699 считается «справедливым».

• 700 - 749 считается «хорошим».

• 750 и выше считается «отлично».

 имен = ['Анна', 'Бет', 'Чад', 'Дрю', 'Эльза', 'Фред']
кредит = [683, 580, 752, 607, 615, 703]
 

Ячейка ниже содержит цикл, который печатает заявление следующего вида для каждого человека:

 [имя] имеет [плохой/плохой/удовлетворительный/хороший/отличный] кредитный рейтинг.
 

 для i в диапазоне (0, len (имена)):
    
    если (кредит [i] <= 599):
        print(names[i] + " имеет плохой кредитный рейтинг.")
    Элиф (кредит [i] <= 649):
        print(names[i] + " имеет плохой кредитный рейтинг. ")
    Элиф (кредит [i] <= 699):
        print(names[i] + " имеет удовлетворительный кредитный рейтинг.")
    Элиф (кредит [i] <= 749):
        print(names[i] + " имеет хороший кредитный рейтинг.")
    еще:
        print(names[i] + " имеет отличный кредитный рейтинг.")
 

 У Анны удовлетворительный кредитный рейтинг.
У Бет плохой кредитный рейтинг.
У Чада отличный кредитный рейтинг.
У Дрю плохой кредитный рейтинг.
У Эльзы плохой кредитный рейтинг.
У Фреда хороший кредитный рейтинг.
 

 кредит_группа = []
для i в диапазоне (0, len (имена)):
    
    если кредит[i] >= 750:
        credit_group.append(4)
    Элиф кредит[я] >= 700:
        credit_group.append(3)
    Элиф кредит[я] >= 650:
        credit_group.append(2)
    Элиф кредит[я] >= 600:
        credit_group.append(1)
    еще:
        credit_group.append (0)
        
печать (кредит)
печать (кредит_группа)
 

 [683, 580, 752, 607, 615, 703]
[2, 0, 4, 1, 1, 3]
 

Пример: результаты экзамена

В ячейке ниже нам предоставлены три списка. Список имен содержит имена учащихся, классов1 содержит баллы за экзамен 1 и классов2 содержит баллы за экзамен 2.

 имен = ['Анна', 'Бет', 'Чад', 'Дрю', ' Эльза», «Фред»]
оценки 1 = [56, 92, 87, 43, 75, 62]
оценки2 = [81, 95, 72, 21, 58, 64]
 

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

 [имя] сдал оба экзамена.
[имя] сдал экзамен 1, но не сдал экзамен 2.
[имя] сдал экзамен 2, но не сдал экзамен 1.
[имя] провалил оба экзамена.
 

 для i в диапазоне (длина (имена)): 
 если (классы 1[i] >= 60) и (классы 2[i] >= 60):
 print(names[i], 'сдал оба экзамена.') 
 elif (grades1[i] >= 60) и (grades2[i] <60):
 print(names[i], 'экзамен 1 сдан, но не экзамен 2.') 
 elif (grades1[i] < 60) и (grades2[i] >= 60):
 print(names[i], 'экзамен 2 сдан, но не экзамен 1.') 
 elif (классы 1 [i] < 60) и (классы 2 [i] < 60):
 print(names[i], 'не сдал оба экзамена.
No related posts.