Арифметические операторы (справочник по C#)
Следующие операторы выполняют арифметические операции с операндами числовых типов:
- унарные — ++ (приращение), — (уменьшение), + (плюс) и — (минус);
- бинарные — * (умножение), / (деление), % (остаток от деления), + (сложение) и — (вычитание).
Эти операторы поддерживаются всеми целочисленными типами и типами с плавающей запятой.
В случае целочисленных типов эти операторы (за исключением операторов ++ и — ) определяются для типов int , uint , long и ulong . Если операнды принадлежат к другим целочисленным типам ( sbyte , byte , short , ushort или char ), их значения преобразуются в тип int , который также является типом результата операции. Если операнды принадлежат к разным целочисленным типам или типам с плавающей запятой, их значения преобразуются в ближайший содержащий тип, если такой тип существует. Дополнительные сведения см. в разделе Числовые повышения уровня в статье Спецификации языка C#. Операторы ++ и — определяются для всех целочисленных числовых типов и числовых типов с плавающей запятой, а также типа char. Тип результата выражения сложного назначения является типом левого операнда.
Оператор инкремента ++
Оператор инкремента ++ увеличивает операнд на 1. Операндом должна быть переменная, свойство или индексатор.
Оператор инкремента поддерживается в двух формах: постфиксный оператор инкремента ( x++ ) и префиксный оператор инкремента ( ++x ).
Постфиксный оператор приращения
Результатом x++ является значение x перед выполнением операции, как показано в следующем примере:
int i = 3; Console.WriteLine(i); // output: 3 Console.WriteLine(i++); // output: 3 Console.WriteLine(i); // output: 4 Префиксный оператор инкремента
Результатом ++x является значение x после выполнения операции, как показано в следующем примере:
double a = 1.5; Console.WriteLine(a); // output: 1.5 Console.WriteLine(++a); // output: 2.5 Console.WriteLine(a); // output: 2.5 Оператор декремента —
Унарный оператор декремента — уменьшает операнд на 1. Операндом должна быть переменная, свойство или индексатор.
Оператор декремента поддерживается в двух формах: постфиксный оператор декремента ( x— ) и префиксный оператор декремента ( —x ).
Постфиксный оператор уменьшения
Результатом x— является значение x перед выполнением операции, как показано в следующем примере:
int i = 3; Console.WriteLine(i); // output: 3 Console.WriteLine(i--); // output: 3 Console.WriteLine(i); // output: 2 Префиксный оператор декремента
Результатом —x является значение x после выполнения операции, как показано в следующем примере:
double a = 1.5; Console.WriteLine(a); // output: 1.5 Console.WriteLine(--a); // output: 0.5 Console.WriteLine(a); // output: 0.5 Операторы унарного плюса и минуса
Унарный оператор + возвращает значение полученного операнда. Унарный оператор — изменяет знак операнда на противоположный.
Console.WriteLine(+4); // output: 4 Console.WriteLine(-4); // output: -4 Console.WriteLine(-(-4)); // output: 4 uint a = 5; var b = -a; Console.WriteLine(b); // output: -5 Console.WriteLine(b.GetType()); // output: System.Int64 Console.WriteLine(-double.NaN); // output: NaN Тип ulong не поддерживает унарный оператор — .
Оператор умножения *
Оператор умножения * вычисляет произведение операндов:
Console.WriteLine(5 * 2); // output: 10 Console.WriteLine(0.5 * 2.5); // output: 1.25 Console.WriteLine(0.1m * 23.4m); // output: 2.34 Оператор деления /
Оператор деления / делит левый операнд на правый.
Деление целых чисел
Для операндов цельночисленных типов результат оператора / является целочисленным типом, который равен частному двух операндов, округленному в сторону нуля:
Console.WriteLine(13 / 5); // output: 2 Console.WriteLine(-13 / 5); // output: -2 Console.WriteLine(13 / -5); // output: -2 Console.WriteLine(-13 / -5); // output: 2 Чтобы получить частное двух операндов в виде числа с плавающей запятой, используйте тип float , double или decimal :
Console.WriteLine(13 / 5.0); // output: 2.6 int a = 13; int b = 5; Console.WriteLine((double)a / b); // output: 2.6 Деление чисел с плавающей запятой
Для типов float , double и decimal результатом оператора / является частное двух операндов:
Console.WriteLine(16.8f / 4.1f); // output: 4.097561 Console.WriteLine(16.8d / 4.1d); // output: 4.09756097560976 Console.WriteLine(16.8m / 4.1m); // output: 4.0975609756097560975609756098 Если один из операндов — это decimal , второй операнд не может быть ни float , ни double , так как ни float , ни double не преобразуется неявно в тип decimal . Необходимо явным образом преобразовать операнд float или double в тип decimal . Дополнительные сведения о числовых преобразованиях см. в разделе Встроенные числовые преобразования.
Оператор остатка %
Оператор остатка % вычисляет остаток от деления левого операнда на правый.
Целочисленный остаток
Для целочисленных операндов результатом a % b является значение, произведенное a — (a / b) * b . Знак ненулевого остатка такой же, как и у левого операнда, как показано в следующем примере:
Console.WriteLine(5 % 4); // output: 1 Console.WriteLine(5 % -4); // output: 1 Console.WriteLine(-5 % 4); // output: -1 Console.WriteLine(-5 % -4); // output: -1 Используйте метод Math.DivRem для вычисления результатов как целочисленного деления, так и определения остатка.
Остаток с плавающей запятой
Для операндов типа float и double результатом x % y для конечных x и y будет значение z , так что:
- знак z , если отлично от нуля, совпадает со знаком x ;
- абсолютное значение z является значением, произведенным |x| — n * |y| , где n — это наибольшее возможное целое число, которое меньше или равно |x| / |y| , а |x| и |y| являются абсолютными значениями x и y , соответственно.
Этот метод вычисления остатка аналогичен тому, который использовался для целочисленных операндов, но отличается от спецификации IEEE 754. Если вам нужна операция вычисления остатка, которая соответствует спецификации IEEE 754, используйте метод Math.IEEERemainder.
Сведения о поведение оператора % в случае неконечных операндов см. в разделе Оператор остаткаспецификации языка C#.
Для операндов decimal оператор остатка % эквивалентен оператору остатка типа System.Decimal.
В следующем примере показано поведение оператора остатка для операндов с плавающей запятой:
Console.WriteLine(-5.2f % 2.0f); // output: -1.2 Console.WriteLine(5.9 % 3.1); // output: 2.8 Console.WriteLine(5.9m % 3.1m); // output: 2.8 Оператор сложения +
Оператор сложения + вычисляет сумму своих операндов:
Console.WriteLine(5 + 4); // output: 9 Console.WriteLine(5 + 4.3); // output: 9.3 Console.WriteLine(5.1m + 4.2m); // output: 9.3 Кроме того, оператор + можно использовать для объединения строк и делегатов. Дополнительные сведения см. в статье Операторы + и += .
Оператор вычитания —
Оператор вычитания — вычитает правый операнд из левого:
Console.WriteLine(47 - 3); // output: 44 Console.WriteLine(5 - 4.3); // output: 0.7 Console.WriteLine(7.5m - 2.3m); // output: 5.2 Кроме того, оператор — можно использовать для удаления делегатов. Дополнительные сведения см. в статье Операторы — и -= .
Составное присваивание
Для бинарного оператора op выражение составного присваивания в форме
x op= y x = x op y за исключением того, что x вычисляется только один раз.
Следующий пример иллюстрирует использование составного присваивания с арифметическими операторами:
int a = 5; a += 9; Console.WriteLine(a); // output: 14 a -= 4; Console.WriteLine(a); // output: 10 a *= 2; Console.WriteLine(a); // output: 20 a /= 4; Console.WriteLine(a); // output: 5 a %= 3; Console.WriteLine(a); // output: 2 Из-за восходящих приведений результат операции op может быть невозможно неявно преобразовать в тип T из x . В этом случае, если op является предопределенным оператором, и результат операции является явно преобразуемым в тип T x , выражение составного присваивания формы x op= y эквивалентно x = (T)(x op y) , за исключением того, что x вычисляется только один раз. В следующем примере продемонстрировано такое поведение.
byte a = 200; byte b = 100; var c = a + b; Console.WriteLine(c.GetType()); // output: System.Int32 Console.WriteLine(c); // output: 300 a += b; Console.WriteLine(a); // output: 44 В предыдущем примере значение является результатом преобразования значения 44 300 в byte тип.
В контексте проверка переполнения проверка, приведенный выше пример вызывает исключениеOverflowException. Дополнительные сведения см. в разделе арифметического переполнения целочисленного числа.
Вы также можете использовать операторы += и -= для подписки и отмены подписки на события соответственно. Дополнительные сведения см. в разделе Практическое руководство. Подписка и отмена подписки на события.
Очередность и ассоциативность операторов
В следующем списке перечислены арифметические операторы в порядке убывания приоритета:
- Постфиксный инкремент x++ и декремент x—
- Префиксный инкремент ++x и декремент —x , унарные операторы + и —
- Мультипликативные операторы * , / , и %
- Аддитивные операторы + и —
Бинарные арифметические операторы имеют левую ассоциативность. То есть операторы с одинаковым приоритетом вычисляются в направлении слева направо.
Порядок вычисления, определяемый приоритетом и ассоциативностью операторов, можно изменить с помощью скобок ( () ).
Console.WriteLine(2 + 2 * 2); // output: 6 Console.WriteLine((2 + 2) * 2); // output: 8 Console.WriteLine(9 / 5 / 2); // output: 0 Console.WriteLine(9 / (5 / 2)); // output: 4 Полный список операторов C#, упорядоченный по уровню приоритета, можно найти в разделе Приоритет операторов статьи Операторы C#.
Арифметическое переполнение и деление на нуль
Если результат арифметической операции выходит за пределы диапазона возможных конечных значений соответствующего числового типа, поведение арифметического оператора зависит от типа его операндов.
Целочисленное арифметическое переполнение
Деление целого числа на ноль всегда вызывает исключение DivideByZeroException.
В случае целочисленного арифметического переполнения итоговое поведение определяется проверяемым или непроверяемым контекстом проверки переполнения:
- Если в проверяемом контексте переполнение возникает в константном выражении, происходит ошибка времени компиляции. В противном случае, если операция производится во время выполнения, возникает исключение OverflowException.
- В непроверяемом контексте результат усекается путем удаления старших разрядов, которые не помещаются в целевой тип данных.
Вместе с проверяемыми и непроверяемыми операторами можно использовать операторы checked и unchecked , чтобы управлять контекстом проверки переполнения, в котором вычисляется выражение:
int a = int.MaxValue; int b = 3; Console.WriteLine(unchecked(a + b)); // output: -2147483646 try < int d = checked(a + b); >catch(OverflowException) < Console.WriteLine($"Overflow occurred when adding to ."); > По умолчанию арифметические операции выполняются в непроверяемом контексте.
Арифметическое переполнение с плавающей запятой
Арифметические операции с типами float и double никогда не вызывают исключение. Результатом арифметических операций с этими типами может быть одно из специальных значений, представляющих бесконечность и объект, не являющийся числовым:
double a = 1.0 / 0.0; Console.WriteLine(a); // output: Infinity Console.WriteLine(double.IsInfinity(a)); // output: True Console.WriteLine(double.MaxValue + double.MaxValue); // output: Infinity double b = 0.0 / 0.0; Console.WriteLine(b); // output: NaN Console.WriteLine(double.IsNaN(b)); // output: True Для операндов типа decimal арифметическое переполнение всегда выдает исключение OverflowException, а деление на нуль — DivideByZeroException.
Ошибки округления
Из-за общих ограничений, касающихся представления вещественных чисел в форме с плавающей запятой и арифметических операций с плавающей запятой, при вычислениях с использованием типов с плавающей запятой могут возникать ошибки округления. То есть полученный результат выражения может отличаться от ожидаемого математического результата. В следующем примере показано несколько таких случаев:
Console.WriteLine(.41f % .2f); // output: 0.00999999 double a = 0.1; double b = 3 * a; Console.WriteLine(b == 0.3); // output: False Console.WriteLine(b - 0.3); // output: 5.55111512312578E-17 decimal c = 1 / 3.0m; decimal d = 3 * c; Console.WriteLine(d == 1.0m); // output: False Console.WriteLine(d); // output: 0.9999999999999999999999999999 См. заметки в справочной документации по System.Double, System.Single и System.Decimal.
Возможность перегрузки оператора
Определяемый пользователем тип может перегружать унарные ( ++ , — , + и — ) и бинарные ( * , / , % , + и — ) арифметические операторы. При перегрузке бинарного оператора соответствующий оператор составного присваивания также неявно перегружается. Явная перегрузка составного оператора присваивания для пользовательского типа невозможна.
Проверенные операторы, определяемые пользователем
Начиная с C# 11 при перегрузке арифметического оператора можно использовать ключевое слово checked , чтобы определить проверенную версию этого оператора. Следующий пример показывает, как это сделать:
public record struct Point(int X, int Y) < public static Point operator checked +(Point left, Point right) < checked < return new Point(left.X + right.X, left.Y + right.Y); >> public static Point operator +(Point left, Point right) < return new Point(left.X + right.X, left.Y + right.Y); >> При определении проверенного оператора следует также определить соответствующий оператор без модификатора checked . Проверенный оператор вызывается в проверенном контексте. Оператор без модификатора checked вызывается в непроверенном контексте. Если указать только оператора без модификатора checked , он будет вызываться как в контексте checked , так и в unchecked .
При определении обеих версий оператора их поведение будет различаться только в том случае, если результат операции слишком велик, чтобы представить его тип следующим образом:
- Проверенный оператор вызывает OverflowException.
- Оператор без модификатора checked возвращает экземпляр, который представляет усеченный результат.
Сведения о разнице в поведении встроенных арифметических операторов см. в разделе Арифметическое переполнение и деление на ноль.
Модификатор checked можно использовать только при перегрузке следующих операторов:
- Унарные операторы ++ , — и —
- Бинарные операторы * , / , + и —
- Операторы явного преобразования
Контекст проверки переполнения в теле проверенного оператора не изменяется при наличии модификатора checked . Контекст по умолчанию определяется значением параметра компилятора CheckForOverflowUnderflow. С помощью операторов checked и unchecked можно явно указать контекст проверки переполнения, как показано в примере в начале этого раздела.
Спецификация языка C#
Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:
- Постфиксные операторы инкремента и декремента
- Префиксные операторы инкремента и декремента
- Оператор унарного плюса
- Оператор унарного минуса
- Оператор умножения
- Оператор деления
- Оператор остатка
- Оператор сложения
- Оператор вычитания
- Составное присваивание
- Операторы checked и unchecked
- Восходящие приведения числовых типов
См. также
- справочник по C#
- Операторы и выражения C#
- System.Math
- System.MathF
- Числовые значения в .NET
Совместная работа с нами на GitHub
Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.
Какого типа будет результат операции 4 2
Как мы уже упоминали, для каждого типа данных определены действия, применимые к его значениям. Например, если переменная относится к порядковому типу данных , то она может фигурировать в качестве аргумента стандартных функций Ord () , Pred () и Succ () (см. п. « Совместимость типов данных » ниже). А к вещественным типам эти функции применить невозможно.
Итак, поговорим теперь об операциях — стандартных действиях, разрешённых для переменных того или иного базового типа данных. Основу будут составлять арифметические операции , но, конечно же, мы не забудем и о логическом типе данных (операции, определённые для значений символьного типа , будут подробно рассмотрены в лекции 5 ).
Замечание: Все перечисленные ниже операции (за исключением унарных «-» , «+» и not ) требуют двух операндов.
-
Логические операции (and, or, not, xor) применимы только к значениям типа Boolean . Их результатом также служат величины типа Boolean . Приведём таблицы значений для этих операций:
| Оператор | Операнд 1 | Операнд 2 | Результат |
|---|---|---|---|
| not | False | — | True |
| True | — | False | |
| and | False | False | False |
| False | True | False | |
| True | False | False | |
| True | True | True | |
| or | False | False | False |
| False | True | True | |
| True | False | True | |
| True | True | True | |
| xor | False | False | False |
| False | True | True | |
| True | False | True | |
| True | True | False |
a div b — деление а на b нацело (не нужно, наверное, напоминать, что деление на 0 запрещено, поэтому в таких случаях операция выдаёт ошибку). Результат будет принадлежать к типу данных, общему для тех типов, к которым принадлежат операнды. Например, (ShortInt div Byte = Integer). Пояснить это можно так: Integer — это минимальный тип, подмножествами которого являются одновременно и Byte , и ShortInt . a mod b — взятие остатка при делении а на b нацело. Тип результата, как и в предыдущем случае, определяется типами операндов, а 0 является запрещённым значением для b. В отличие от математической операции mod, результатом которой всегда является неотрицательное число, знак результата «программистской» операции mod определяется знаком её первого операнда. Таким образом, если в математике (-2 mod 5) = 3, то у нас (-2 mod 5) = -2. a shl k — сдвиг значения а на k битов влево (это эквивалентно умножению значения переменной а на 2 k ). Результат операции будет иметь тот же тип, что и первый её операнд (а). a shr k — сдвиг значения а на k битов вправо (это эквивалентно делению значения переменной а на 2 k нацело). Результат операции будет иметь тот же тип, что и первый её операнд (а). and, or, not, xor — операции двоичной арифметики , работающие с битами двоичного представления целых чисел, по тем же правилам, что и соответствующие им логические операции .
Другие операции
Помимо арифметических, существуют и другие операции, специфичные для значений некоторых стандартных типов данных языка Pascal. Эти операции мы рассмотрим в соответствующих разделах:
Стандартные арифметические функции
К арифметическим операциям примыкают и стандартные арифметические функции . Их список с кратким описанием мы приводим в таблице.
| Описание | Тип аргумента | Тип результата 1 | |
|---|---|---|---|
| Abs (x) | Абсолютное значение (модуль) числа | Арифметический | Совпадает с типом аргумента |
| ArcTan (x) | Арктангенс (в радианах) | Арифметический | Вещественный |
| Cos (x) | Косинус (в радианах) | Арифметический | Вещественный |
| Exp (x) | Экспонента (e x ) | Арифметический | Вещественный |
| Frac (x) | Взятие дробной части числа | Арифметический | Вещественный |
| Int (x) | Взятие целой части числа | Арифметический | Вещественный |
| Ln (x) | Натуральный логарифм (по основанию e) | Арифметический | Вещественный |
| Odd (x) | Проверка нечётности числа | Целый | Boolean |
| Pi | Значение числа π | — | Вещественный |
| Round (x) | Округление к ближайшему целому | Арифметический | Целый |
| Trunc (x) | Округление «вниз» — к ближайшему меньшему целому | Арифметический | Целый |
| Sin (x) | Синус (в радианах) | Арифметический | Вещественный |
| Sqr (x) | Возведение в квадрат | Арифметический | Совпадает с типом аргумента |
| Sqrt (x) | Извлечение квадратного корня | Арифметический | Вещественный |
Арифметические выражения
Все арифметические операции можно сочетать друг с другом — конечно, с учётом допустимых для их операндов типов данных.
В роли операндов любой операции могут выступать переменные, константы, вызовы функций или выражения, построенные на основе других операций. Всё вместе и называется выражением . Определение выражения через выражение не должно вас смущать, ведь рекурсивное задание конструкций вообще свойственно программированию (см. лекцию 9 ).
(x < 0) and (y > 0) — выражение, результат которого принадлежит к типу Boolean ;
z shl Abs (k) — вторым операндом является вызов стандартной функции;
(x mod k) + Min(a,b) + Trunc (z) — сочетание арифметических операций и вызовов функций;
Odd ( Round (x / Abs (x))) — «многоэтажное» выражение.
Полнота вычислений
if (xто для случая, когда x положительно, этих сложных вычислений можно избежать.
Порядок вычислений
Если в выражении расставлены скобки, то вычисления производятся в порядке, известном всем ещё с начальной школы: чем меньше глубина вложенности скобок, тем позже вычисляется заключённая в них операция. Если же скобок нет, то сначала вычисляются значения операций с более высоким приоритетом , затем — с менее высоким. Несколько подряд идущих операций одного приоритета вычисляются в последовательности «слева направо».
| Таблица 2.1. Приоритеты (для всех) операций языка Pascal | Операции | Приоритет |
|---|---|---|
| Унарные 2 операции | +, -, not, @, ^, # | Первый(высший) |
| Операции, эквивалентные умножению | *, /, div, mod, and, shl, shr | Второй |
| Операции, эквивалентные сложению | +, -, or, xor | Третий |
| Операции сравнения | =, <>, >, =, in | Четвёртый |
Замечание: Вызов любой функции имеет более высокий приоритет, чем все внешние относительно этого вызова операции. Выражения, являющиеся аргументами вызываемой функции, вычисляются в момент вызова (см. лекцию 8 ).
Примеры выражений (с указанием последовательности вычислений) для целых чисел:
страницы: 1 2 3
Ввод-вывод, оператор присваивания, арифметические операции
Язык программирования Паскаль. Знакомство со средой программирования Турбо Паскаль. Основные понятия. Первая программа
Паскаль - язык профессионального программирования, который назван в честь французского математика и философа Блеза Паскаля (1623-1662) и разработан в 1968-1971 гг. Никлаусом Виртом. Первоначально был разработан для обучения, но вскоре стал использоваться для разработки программных средств в профессиональном программировании.
Паскаль популярен среди программистов по следующим причинам:
- Прост для обучения.
- Отражает фундаментальные идеи алгоритмов в легко воспринимаемой форме, что предоставляет программисту средства, помогающие проектировать программы.
- Позволяет четко реализовать идеи структурного программирования и структурной организации данных.
- Использование простых и гибких структур управления: ветвлений, циклов.
- Надежность разрабатываемых программ.
Турбо Паскаль - это система программирования, созданная для повышения качества и скорости разработки программ (80-е гг.). Слово Турбо в названии системы программирования - это отражение торговой марки фирмы-разработчика Borland International (США).
Систему программирования Турбо Паскаль называют интегрированной (integration - объединение отдельных элементов в единое целое) средой программирования, т.к. она включает в себя редактор, компилятор, отладчик, имеет сервисные возможности.
Основные файлы Турбо Паскаля:
Turbo.exe - исполняемый файл интегрированной среды программирования;
Turbo.hlp - файл, содержащий данные для помощи;
Turbo.tp - файл конфигурации системы;
Turbo.tpl - библиотека стандартных модулей, в которых содержатся встроенные процедуры и функции (SYSTEM, CRT, DOS, PRINTER, GRAPH, TURBO3, GRAPH3).
Запуск интегрированной среды программирования
Для запуска интегрированной среды программирования нужно установить текущим каталог с Турбо Паскалем (TP7\BIN) и ввести команду: turbo.exe.
Задание. Запустите среду программирования и рассмотрите экран. Перед вами полоса меню, область окна и строка статуса. Нажмите клавишу F10 - теперь вам доступны все опции меню. Используя клавиши управления курсором, рассмотрите меню. С командами меню мы будем знакомиться постепенно. Нажмите клавишу Esc (вы вышли из меню). Перемещая курсор в окне, следите за строкой статуса. Какая информация отражается в этой строке?
Почти все, что вы видите и делаете в среде Турбо Паскаль, происходит в окнах.
Окно - это область экрана, которую можно перемещать, изменять в размере, перекрывать, закрывать и открывать.
Интегрированная среда программирования Турбо Паскаль позволяет иметь любое количество открытых окон, но в любой момент времени активным может быть только одно.
Активное окно – это окно, с которым вы в настоящий момент работаете.
Общие горячие клавиши:
F2 - сохраняет файл активного окна;
F3 - появление диалогового окна и возможность открыть файл;
F4 - запускает программу до строки, на которой стоит курсор;
F5 - масштабирует диалоговое окно;
F6 - переходит к следующему открытому окну;
F7 - запускает программу в режиме отладки с заходом внутрь процедур;
F8 - запускает программу в режиме отладки, минуя вызов процедур;
F9 - компилирование программы в текущем окне;
F10 - возвращение в меню.
Мы начнем изучение меню с наиболее важных и необходимых режимов.
Как войти в меню? Всего есть три возможности:
С помощью клавиш управления курсором подсветите слово FILE и нажмите клавишу "Enter". Что вы видите?
Появилась вертикальная таблица со списком команд, называемая выпадающим меню. Познакомимся с ним.
Open-F3 - открыть существующий файл (при активизации этой опции появляется окно со списком файлов, где можно выбрать необходимый),
New - создать новый файл (очищает память редактора и переводит в режим создания нового файла, которому присваивается имя Noname.pas; имя можно изменить при записи файла на диск),
Save-F2 - сохранить файл (переписывает файл из памяти редактора на диск),
Save as - сохранить с новым именем,
Save all - сохранить все в окнах (записывает содержимое всех окон редактора в соответствующие файлы),
Change dir - смена каталога (позволяет изменить установленный по умолчанию диск или каталог),
Print - печать файла,
Get info - выдача информации о текущем состоянии программы и используемой памяти,
DOS Shell - выход в DOS без выгрузки из памяти (для возврата ввести команду exit),
Exit - выход и выгрузка из памяти.
Программы на языке Паскаль имеют блочную структуру:
1. Блок типа PROGRAM - имеет имя, состоящее только из латинских букв и цифр. Его присутствие не обязательно, но рекомендуется записывать для быстрого распознавания нужной программы среди других листингов.
2. Программный блок, состоящий в общем случае из 7 разделов:
-
раздел описания модулей (uses);
Общая структура программы на языке Паскаль следующая:
Начнем знакомство с Паскалем с программы, которая складывает два числа и выводит сумму на экран.
Откройте файл, в который Вы запишите эту программу. Для этого нажмите клавишу F10, чтобы выйти в главное меню, затем клавишами перемещения курсора выберите опцию File, а в выпавшем меню команду New.
Примечание. Обратите внимание на оформление текста программы.
-
Найдите в этой программе заголовок, раздел описания переменных, признак начала программы, признак конца программы, тело программы, комментарий.
А теперь подведем итог вашим размышлениям.
Имя этой программы Summa2. Заметим, что требования к имени выполняются: оно отражает содержание программы, а также не содержит недопустимых символов.
Далее идет специально выделенный комментарий, в котором вы должны записать подробно условие задачи и указать, кто написал эту программу и когда.
Из разделов описаний имеется лишь один - раздел переменных. Он начинается со служебного слова Var. Мы описали три переменные: number1, number2, result. Все они переменные целого типа. Поэтому мы перечислили их через запятую, поставили двоеточие и указали тип переменных. Подобные объявления разделяются между собой точкой с запятой.
После описательной части идет раздел операторов, начинающийся со служебного слова Begin, после которого идут операторы языка.
Недостатком этой программы является то, что значения переменных постоянны. А нам нужно научиться писать такие программы, которые решают поставленные задачи в общем виде, т. е. для любых значений переменных. Для этого мы научимся запрашивать значения у пользователя, анализировать их и выдавать соответствующий результат.
Python: Логический тип
Языки программирования адаптировали все математические операции сравнения в неизменном виде, кроме операторов равенства и неравенства. В математике для этого используется обычное равно = , но в программировании такое встречается редко.
Во многих языках символ = используется, чтобы присвоить переменным значения. Поэтому в Python сравнивают с помощью == .
Список операций сравнения:
Эти операции применяются не только к числам. Например, с помощью оператора равенства можно сравнить строки: password == text — это сравнение идентичности строк, которые записаны в разных переменных.
Логическая операция типа 5 > 4 или password == text — это выражение. Его результат — специальное значение True («истина») или False («ложь»). Это новый для нас тип данных — bool .
result = 5 > 4 print(result) # => True print('one' != 'one') # => False Наряду со строками ( str ) и целыми и рациональными числами, тип bool (булев) — это один из примитивных типов данных в Python.
Попробуем написать простую функцию, которая принимает на вход возраст ребенка и определяет, младенец ли он. Младенцами считаются дети до года:
def is_infant(age): return age < 1 print(is_infant(3)) # =>False Любая операция — это выражение, поэтому единственной строчкой функции пишем «вернуть то значение, которое получится в результате сравнения age < 1 ». В зависимости от того, какой аргумент пришел, сравнение будет истинным ( True ) или ложным ( False ), а return вернет этот результат.
А теперь проверим ребенка, которому полгода:
print(is_infant(0.5)) # => True Результат операции True . Значит, ребенок действительно младенец.
Задание
Напишите функцию is_pensioner() , которая принимает возраст в качестве единственного аргумента и проверяет, является ли этот возраст пенсионным. Пенсионным считается возраст 60 лет и больше.
is_pensioner(75) # True is_pensioner(18) # False Упражнение не проходит проверку — что делать? ��
Если вы зашли в тупик, то самое время задать вопрос в «Обсуждениях». Как правильно задать вопрос:
- Обязательно приложите вывод тестов, без него практически невозможно понять что не так, даже если вы покажете свой код. Программисты плохо исполняют код в голове, но по полученной ошибке почти всегда понятно, куда смотреть.
В моей среде код работает, а здесь нет ��
Тесты устроены таким образом, что они проверяют решение разными способами и на разных данных. Часто решение работает с одними входными данными, но не работает с другими. Чтобы разобраться с этим моментом, изучите вкладку «Тесты» и внимательно посмотрите на вывод ошибок, в котором есть подсказки.
Мой код отличается от решения учителя ��
Это нормально ��, в программировании одну задачу можно выполнить множеством способов. Если ваш код прошел проверку, то он соответствует условиям задачи.
В редких случаях бывает, что решение подогнано под тесты, но это видно сразу.
Прочитал урок — ничего не понятно ��
Создавать обучающие материалы, понятные для всех без исключения, довольно сложно. Мы очень стараемся, но всегда есть что улучшать. Если вы встретили материал, который вам непонятен, опишите проблему в «Обсуждениях». Идеально, если вы сформулируете непонятные моменты в виде вопросов. Обычно нам нужно несколько дней для внесения правок.
Кстати, вы тоже можете участвовать в улучшении курсов: внизу есть ссылка на исходный код уроков, который можно править прямо из браузера.
Полезное
Определения
- Логический тип (bool) — тип данных с двумя возможными значениями: True (истина) и False (ложь).