Цикл if в c: Оператор if (C) | Microsoft Learn

условия и описание, как работает на примерах

В этом руководстве мы узнаем об операторе if … else в C++ для создания программ принятия решений с помощью примеров.

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

Например, выставление оценок (A, B, C) на основе оценок, полученных студентом;

• если процент выше 90, присвойте оценку A;
• если процент выше 75, присвойте оценку B;
• если процент выше 65, присвойте оценку C.

В С++ есть три формы операторов if … else:

1. if;
2. if…else;
3. if … else if … else.

Синтаксис оператора:

if (condition) {
   // body of if statement
}

Оператор if оценивает условие в круглых скобках ():

• Если условие truth, выполняется код внутри тела if.
• Если условие оценивается как truth, код внутри тела if пропускается.

Примечание.

Код внутри {} является телом оператора if.

Пример 1

// Program to print positive number entered by the user
// If the user enters a negative number, it is skipped

#include <iostream>
using namespace std;

int main() {
    int number;

    cout << "Enter an integer: ";
    cin >> number;

    // checks if the number is positive
    if (number > 0) {
        cout << "You entered a positive integer: " << number << endl;
    }
    cout << "This statement is always executed.";
    return 0;
}

Выход 1:

Enter an integer: 5
You entered a positive number: 5
This statement is always executed.

Когда пользователь вводит 5, число условия > 0 оценивается, как truth, и выполняется инструкция внутри тела if.

Выход 2:

 Enter a number: -5
This statement is always executed. 

Когда пользователь вводит -5, число условия > 0 оценивается как false, и оператор внутри тела if не выполняется.

Оператор if..else

Оператор if может иметь необязательное предложение else. Его синтаксис:

if (condition) {
    // block of code if condition is true
}
else {
    // block of code if condition is false
}

Оператор if..else оценивает условие внутри круглых скобок.

Если условие true:

• код внутри тела if – выполняется;
• код внутри тела else – пропускается из выполнения.

Если условие оценивается, как false:

• код внутри тела else – выполняется;
• код внутри тела if – пропускается из выполнения.

Пример 2: оператор if … else

 // Program to check whether an integer is positive or negative
// This program considers 0 as a positive number

#include <iostream>
using namespace std;

int main() {
     int number;

    cout << "Enter an integer: ";
    cin >> number;
    if (number >= 0) {
        cout << "You entered a positive integer: " << number << endl;
    }
    else {
        cout << "You entered a negative integer: " << number << endl;
    }
    cout << "This line is always printed. ";
    return 0;
}

Выход 1:

Enter an integer: 4
You entered a positive integer: 4.
This line is always printed.

В приведенной выше программе у нас есть номер условия > = 0. Если мы вводим число, большее или равное

, то условие оценивается, как true.

Здесь мы вводим 4. Итак, условие верно, следовательно, выполняется инструкция внутри тела if.

Выход 2:

Enter an integer: -4
You entered a negative integer: -4.
This line is always printed.

Здесь мы вводим -4. Итак, условие false, следовательно, выполняется инструкция внутри тела else.

if … else … else if

Оператор if … else используется для выполнения блока кода из двух альтернатив. Однако, если нам нужно сделать выбор между более чем двумя альтернативами, мы используем оператор if … else if … else.

Синтаксис оператора:

if (condition1) {
    // code block 1
}
else if (condition2){
    // code block 2
}
else {
    // code block 3
}

Где:

• Если условие1 true, кодовый блок 1 выполняется.
• Если условие1 оценивается как false, то оценивается условие 2.
• Если условие 2 true, выполняется блок кода 2.
• Если условие 2 false, кодовый блок 3 выполняется.

Примечание: может быть больше одного оператора if, но только один оператор if и else.

Пример 3

// Program to check whether an integer is positive, negative or zero

#include <iostream>
using namespace std;

int main() {
     int number;

    cout << "Enter an integer: ";
    cin >> number;
    if (number > 0) {
        cout << "You entered a positive integer: " << number << endl;
    } 
else if (number < 0) {
      cout << "You entered a negative integer: " << number << endl;
     } 
else {
        cout << "You entered 0." << endl;
    }
     cout << "This line is always printed.
  ";
    return 0;
}

Выход 1:

Enter an integer: 1
You entered a positive integer: 1.
This line is always printed.

Выход 2:

Enter an integer: -2
You entered a negative integer: -2.
This line is always printed.

Выход 3:

Enter an integer: 0
You entered 0.
This line is always printed.

В этой программе мы берем номер у пользователя. Затем мы используем if … else if … else, чтобы проверить, является ли число положительным, отрицательным или нулевым.

Если число больше 0, код выполняется внутри блока if. Если число меньше 0, код выполняется внутри блока else if. В противном случае код выполняется внутри блока else.

if … else

Иногда нам нужно использовать в C++ оператор if внутри другого оператора if. Это называется вложенным оператором.

Синтаксис:

// outer if statement
if (condition1) {
    // statements

    // inner if statement
    if (condition2) {
        // statements
    }
}

Заметки:

• При необходимости мы можем добавить операторы else и else if к внутреннему оператору if.
• Внутренний оператор if также может быть вставлен во внешний оператор else или else if (если они существуют).
• Мы можем вложить несколько уровней операторов if.

Пример 4

// C++ program to find if an integer is even or odd or neither (0)
// using nested if statements

#include <iostream>
using namespace std;

int main() {
    int num;
    
    cout << "Enter an integer: ";  
     cin >> num;    

    // outer if condition
    if (num != 0) {
        
        // inner if condition
        if ((num % 2) == 0) {
            cout << "The number is even." << endl;
        }
         // inner else condition
        else {
            cout << "The number is odd." << endl;
        }  
    }
    // outer else condition
    else {
        cout << "The number is 0 and it is neither even nor odd.
  " << endl;
    }
    cout << "This line is always printed." << endl;
}

Выход 1:

Enter an integer: 34
The number is even.
This line is always printed.

Выход 2:

Enter an integer: 35
The number is odd.
This line is always printed.

Выход 3:

Enter an integer: 0
The number is 0 and it is neither even nor odd.
This line is always printed.

В приведенном выше примере:

• Мы берем целое число в качестве ввода от пользователя и сохраняем его в переменной num.
• Затем мы используем оператор if … else, чтобы проверить, не равно ли num 0.
  • Если true, то выполняется внутренний оператор if … else.
  • Если false, выполняется код внутри внешнего условия else, который печатает «Число равно 0, и не является ни четным, ни нечетным».
• Внутренний оператор if … else проверяет, делится ли введенное число на 2.
  • Если это true, то мы печатаем утверждение, что число четное.
  • Если false, печатаем, что число нечетное.

Обратите внимание, что 0 также делится на 2, но на самом деле это не четное число. Вот почему мы сначала убеждаемся, что входное число не равно 0 во внешнем условии if.

Примечание. Как видите, вложенные if … else усложняют вашу логику. Поэтому вы всегда должны стараться избегать вложенных if … else.

if … else с одним утверждением

Если в if … else есть только один оператор, вы можете опустить {} в программе. Например, вы можете заменить:

int number = 5;

    if (number > 0) {
        cout << "The number is positive." << endl;
    }
    else {
        cout << "The number is negative." << endl;
    }

С участием:

int number = 5;

    if (number > 0)
        cout << "The number is positive.  " << endl;
    else
        cout << "The number is negative." << endl;

Вывод обеих программ будет одинаковым.

Примечание. Хотя нет необходимости использовать {}, если тело if … else содержит только один оператор, использование {} делает ваш код более читабельным в С++.

Заключение

В определенных ситуациях тернарный оператор может заменить оператор if … else. Если нам нужно сделать выбор между более чем одной альтернативой на основе заданного условия теста, можно использовать оператор switch в C++.

Оператор if неполная форма в C++. Урок 3.

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

На втором уроке мы говорили про логические выражения. Логические выражения нам позволяли получить уже какую-то вариативность в результате. А сегодня мы поговорим о том: «Что же делать, если нам не хватает полного контроля над кодом»?

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

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

Раньше у нас была линейная программа:

1. Начало;
2. Действие 1;
3. Действие 2;
4. Действие 3;
5. Действие 4;
6. Конец.

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

Есть у нас начало программы, после этого выполнилось какое-то действие. После этого действия стоит условие. Если результатом этого условия будет 1, то мы выполним действие под номером 2. Если результатом условия будет 0? Мы выполним действие под номером 3. Что можно подразумевать под словом действие? Все что угодно. Мы можем запустить какую-либо функцию, можем вывести что-то на экран, можем запросить какие-либо дополнительные данные от пользователя и т.д. и т.п.

Но сегодня мы с вами пройдем только неполную форму условного оператора.

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

Неполная форма условного оператора

Неполная форма условного оператора – это когда кусочек кода будет выполнятся, если условие истинно (true). А если условие ложно (false), тогда ничего не произойдет. Например, если Иван опоздал на занятие, то сделать ему замечание, а в противном случае мы ничего не будем делать.

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

Синтаксис

Если (if) логическое выражение true, то мы будем выполнять те действия, которые записаны в фигурных скобках.

Вы можете встретить и такую запись

В C++ допускается не брать в скобки действие, если оно одно. Но лучшей практикой будет не использовать такую форму записи. К тому же бывают такие случаи, когда при такой форме записи, наша программа может сработать не так, как мы ожидаем, они редки, но все же случаются. Поэтому мы возьмем за правило, всегда использовать фигурные скобки.

Решение задач

Поменяй местами

Даны два числа a и b. Ваша программа должна поменять два числа местами, если a Формат входных данных
Даны два целых числа a и b (∣a∣,∣b∣ 9).
Формат выходных данных
Требуется вывести числа в том же формате, в котором они вводились.
Примеры
входные данные
3 5
11 4
выходные данные
5 3
11 4

Положительные в квадрат

Даны три числа — a, b, c. Требуется возвести положительные числа в квадрат, а отрицательные оставить без изменений и вывести числа в том же порядке.

Формат входных данных
На единственной строке входного файла содержатся три целых числа (−10⁴4).
Формат выходных данных
Единственная строка выходного файла должна содержать три получившихся числа: a, b и c в исходном порядке, где положительные возведены в квадрат, а отрицательные оставлены без изменений.

Видео по теме урока

Можете ли вы поместить цикл for в оператор if? | Встроенный

Структуры потока управления, такие как операторы if и циклы for, являются мощными способами создания логичного, чистого и хорошо организованного кода в Python. Операторы If проверяют условие , а затем завершают действие, если проверка верна. Циклы for делают что-то для определенного количества элементов. Понимание списков — это способ Python создавать списки на лету с помощью одной строки кода.

Можно ли поместить цикл for в оператор If?

Цикл for выполняет задачу для определенного количества элементов, в то время как оператор if проверяет условие, а затем завершает действие в зависимости от того, является ли результат истинным или ложным. Вы можете поместить цикл for внутрь оператора if, используя технику, называемую вложенным потоком управления. Это процесс размещения управляющего оператора внутри другого управляющего оператора для выполнения действия.

Вы можете поместить операторы if внутрь для циклов. Например, вы можете просмотреть список, чтобы проверить, соответствуют ли элементы определенным условиям.

Структура операторов потока в Python состоит из двух частей. Одной из них является родительская строка оператора , которая определяет оператор с ключевыми словами «if» или «for» . Эта строка должна заканчиваться двоеточием . Второй является дочерним оператором , который содержит блок кода , который должен быть реализован, если условие истинно в случае оператора if, или реализован повторно в случае цикла for. Дочерние операторы должны иметь отступ в четыре пробела (или табуляции) в начале, иначе Произойдет ошибка отступа .

 родительский оператор:
    дочерний оператор или блок кода с отступом в 4 пробела
 

 

Что такое оператор if?

Это оператор, который начинается с ключевого слова «if», за которым следует условие, которое должно оцениваться как True или False , за которым следует двоеточие. Блок кода находится во второй строке и имеет отступ в начале с четырьмя пробелами. Это код, который будет реализован, если условие будет выполнено.

 Если условие:
    кодовый блок
 

Обратите внимание, что в приведенном ниже примере, если условие ложно, ничего не будет отображаться. Нет ошибки.

, если 5 > 1:
    print('Верно, пять больше единицы')
### Полученные результаты
Правда, пять больше, чем один
 

Подробнее о PythonИспользование декораторов классов Python

 

Как написать оператор If-Else

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

 Если условие:
    кодовый блок
еще:
    кодовый блок
 

Ниже приведен пример оператора if-else.

, если «а» > «б»:
    распечатать('Верно')
еще:
    print('Ложь, "а" не больше, чем "b"')
#Полученные результаты
Ложь, "а" не больше, чем "б"
 

 

Как написать оператор If-Elif-Else

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

 возраст = 60
если возраст >= 55:
    print("Вы старший")
Элиф возраст < 35:
    print("Ты молодой")
еще:
    print("Вы среднего возраста")
### Полученные результаты
Вы старший
 

 

Что такое циклы For?

Цикл for вводит понятие итерации, когда процесс повторяется над несколькими элементами, например, в списке.

Цикл for содержит четыре компонента; a для ключевого слова , повторяемый , такой как список, содержащий элементы для цикла, имя переменной, которое будет представлять каждый элемент в списке, и блок кода , который будет выполняться для каждого элемента. Блок кода имеет отступ с четырьмя пробелами.

 для variable_name в списке:
    кодовый блок
 

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

 для имени в ['sue', 'joe', 'gee']:
    печать (имя)
для числа в [1,2,3,4,5]:
    печать (число + 1)
### Полученные результаты
Сью Джо Джи
2 3 4 5 6
 

 

Знакомство с Range()

Эта функция используется для создания списков целых чисел, которые можно использовать в циклах for. Вы можете создать список на диапазон (стоп) , диапазон (старт, стоп) или диапазон (старт, стоп, шаг) . Start (необязательно) определяет первое число в последовательности. По умолчанию ноль. Стоп (необязательно) определяет, где заканчивается список, но этот номер не включен в список. Следовательно, последнее число в последовательности — это стоп минус один. Шаг (необязательный) — это приращение для каждого числа в списке, значение по умолчанию равно единице. Например, range(10) создает список от нуля до девяти, range(2,10) создает список от двух до девяти и range(1,10,2) создает список один, три, пять , семь, девять. Обратите внимание, что range() создает только списки целых чисел и выдает TypeError , если вы передаете ему что-либо, кроме целого числа.

 для i в диапазоне (5):
    печать (я)
для я в диапазоне (2, 9):
    печать (я)
для я в диапазоне (0, 11, 2):
    печать (я)
### Полученные результаты
0 1 2 3 4
2 3 4 5 6 7 8
0 2 4 6 8 10
 

Вы также можете перебирать списки в обратном порядке, используя reverse(list) .

 л = ['один','два', 'три']
для оборотов в обратном (л):
    печать (об.)
для r в обратном порядке (диапазон (95,101)):
    печать (г)
### Полученные результаты
три, два, один
100 99 98 97 96 95
 

Произошла ошибка.

Невозможно выполнить JavaScript. Попробуйте посмотреть это видео на сайте www.youtube.com или включите JavaScript, если он отключен в вашем браузере.

Объяснение условных операторов и операторов цикла. | Видео: эдурека!

 

Как написать вложенный поток управления

Вы можете вложить операторы if внутрь для циклов. Например, вы можете просмотреть список, чтобы проверить, соответствуют ли элементы определенным условиям.

 возрастов = [78, 34, 21, 47, 9]
для возраста в возрасте:
    если возраст >= 55:
        print("{} старший".format(age))
    Элиф возраст < 35:
        print("{} это молодежь".format(age))
    еще:
        print("{} среднего возраста".format(age))
 

Вы также можете иметь цикл for внутри другого цикла for. В этом примере для каждого элемента в первом списке мы перебираем все элементы во втором списке.

 first_names = ['Джон', 'Сэм', 'Уилл']
last_names = ['белый', 'кузнец', 'александр']
для fname в first_names:
    для lname в last_names:
        распечатать (имя, имя)
### Полученные результаты
Джон Уайт
Джон Смит
Джон Александр
Сэм Уайт
Сэм Смит
Сэм Александр
будет белым
Уилл Смит
будет александр
 

Станьте экспертом по PythonИзучите мастер-класс по программированию на Python

 

Что такое списки?

Включение списков — способ создания новых списков из существующих списков после применения к ним преобразований .

Каждое понимание списка имеет вывод, обычно, но не обязательно, преобразованный, и цикл for, заключенный в квадратные скобки. Мы используем квадратные скобки, потому что строим список.

 [преобразовано_l для l в списке] 

Чтобы создать набор или кортеж, заключите включение списка в {} или () соответственно.

Первый код ниже умножает каждый элемент в исходном списке на два, чтобы создать новый список. num*2 — желаемый результат, за которым следует цикл for . Второй код не преобразует элементы и выводит тот же список.

 print([число*2 для числа в [2,4,6,8,10]])
print([число для числа в [2,4,6,8,10]])
### Результат
[4, 8, 12, 16, 20]
[2, 4, 6, 8, 10]
 

 

Условная логика

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

 [вывод для l в списке, если условие]
 

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

 [l для l в списке, если l>2]
 

Этот код возвращает список людей ростом более 160 см.

 высот = [144, 180, 165, 120, 199]
высокий = [h для h в высоте, если h > 160]
печать (высокий)
### Полученные результаты
[180, 165, 199]
 

Вы можете иметь условные выходные данные с if-else в выходной части . Например, вы можете классифицировать элементы в списке, создав новый список, в котором будет указано, к какому классу принадлежит каждый элемент в исходном списке. В этом случае вы должны имеют оба if и else ключевые слова. В противном случае выдается SyntaxError . Elif здесь не применяется.

 [вывод, если условие еще выводится для l в списке]
 

Приведенный ниже код создает список от нуля до девяти. Затем мы определяем генератор списка, который выполняет итерацию по списку и выводит «четное» или «нечетное» для каждого числа в списке. Мы используем оператор по модулю ( % ), который возвращает остаток от деления. Число четное, если остаток от деления на два равен нулю. В противном случае число нечетное.

 число = список (диапазон (10))
num_classes = ['четный', если num%2 == 0, иначе 'нечетный' для числа в числах]
печать (число_классов)
### Полученные результаты
['четный', 'нечетный', 'четный', 'нечетный', 'четный', 'нечетный', 'четный', 'нечетный', 'четный', 'нечетный']
 

 

Объяснение функций

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

Функции начинаются с ключевого слова def , затем нужного имени функции, круглых скобок () и двоеточия в конце родительского оператора. Необязательные аргументы могут быть указаны внутри круглых скобок, которые являются просто переменными, которые вы передаете в функцию. Следующая строка содержит блок кода с отступом в четыре пробела. У вас может быть необязательный оператор return в последней строке блока кода, который будет результатом (выводом) функции.

 имя по умолчанию():
    кодовый блок
    возвращаемое значение
 

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

 имя()
 

Следующий код определяет функцию, которая при вызове печатает «Привет». Этот блок кода не имеет оператора возврата.

 по умолчанию привет():
    print('Привет')
привет()
### Полученные результаты
Всем привет
 

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

 по определению Square_number(число):
    вернуть число * число
пять_в квадрате = квадратное_число (5)
печать (пять_в квадрате)
### Полученные результаты
25
 

Функция должна содержать блок кода. Это может быть просто оператор return, код , который что-то делает, или ключевое слово pass, которое ничего не делает. Если оператора возврата нет, функция по умолчанию вернет «Нет» .

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание

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. Если условие верно, выполнить каждый из операторов в теле и затем вернитесь к шагу 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"]),
            ("Питер", ["Социология", "Экономика", "Право", "Статистика", "Музыка"]))]
 

Здесь мы присвоили список из пяти элементов переменной student . Давайте распечатаем имя каждого учащегося и количество предметов, которые они посещают. 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 не существуют, пока им не присвоены значения, они инициализируются при их создании. В других языках программирования это это не так, и переменные могут быть созданы без инициализированы, в этом случае у них либо дефолт, либо мусор ценности.

итерация

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

цикл

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

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

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

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

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

вложенность

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

новая строка

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

приглашение

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

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

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

tab

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

трихотомия

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