Теоретический материал: Python (версия 3)
Итак, мы видим, что Питон умеет работать как минимум с двумя видами данных — числами и строками. Числа записываются последовательностью цифр, также перед числом может стоять знак минус, а строки записываются в одинарных кавычках. 2 и ‘2’ — это разные объекты, первый объект — число, а второй —строка. Операция + для целых чисел и для строк работает по-разному: для чисел это сложение, а для строк —конкатенация.
Кроме целых чисел есть и другой класс чисел: действительные (вещественные числа), представляемые в виде десятичных дробей. Они записываются с использованием десятичной точки, например, 2.0. В каком-то смысле, 2 и 2.0 имеют равные значение, но это—разные объекты. Например, можно вычислить значения выражения ‘ABC’ * 10 (повторить строку 10 раз), но нельзя вычислить ‘ABC’ * 10.0.
Определить тип объекта можно при помощи функции type:
>>> type(2)
>>> type(‘2’)
>>> type(2.0)
Обратите внимание —type является функцией, аргументы функции указываются в скобках после ее имени.
Вот список основных операций для чисел:
A + B — сумма;
A — B — разность;
A * B — произведение;
A / B — частное;
A ** B — возведение в степень. Полезно помнить, что квадратный корень из числа x — это x ** 0.5, а корень степени n это x ** (1 / n).
Есть также унарный вариант операции -, то есть операция с одним аргументом. Она возвращает число, противоположное данному. Например: -A.
В выражении может встречаться много операций подряд. Как в этом случае определяется порядок действий? Например, чему будет равно 1 + 2 * 3 ** 1 + 1? В данном случае ответ будет 8, так как сначала выполняется возведение в степень, затем – умножение, затем — сложение.
Более общие правила определения приоритетов операций такие:
- Выполняются возведения в степень справа налево, то есть 3 ** 3 ** 3 это \(3^\) .
- Выполняются унарные минусы (отрицания).
- Выполняются умножения и деления слева направо. Операции умножения и деления имеют одинаковый приоритет.
- Выполняются сложения и вычитания слева направо. Операции сложения и вычитания имеют одинаковый приоритет.
Основные операции над строками:
A + B — конкатенация;
A * n — повторение n раз, значение n должно быть целого типа.
Интерактивный интерпретатор
Данный курс будет посвящен изучению программирования с использованием языка Python. Это — современный язык программирования, работающий на всех распространных операционных системах.
В настоящее время существует две версии языка Python: более старая, но пока ещё более распространненая версия 2 и современная версия 3. Они не вполне совместимы друг с другом: программа, написанная для одной версии языка может оказаться невыполнимой для другой версии. Но в основном обе версии очень похожи.
Мы будем использовать версию 3 данного языка, некоторые из используемых примеров не будут работать с версией 2. Последняя версия языка, доступная в сентябре 2010 года — 3.1.2, именно её необходимо установить дома, скачав данную версию с сайта www.python.org.
Запустить интерпретатор python можно из командной строки:
$ python3
Будьте внимательны — команда python запустит интерпретатор версии 2, с которым мы работать не будем. В системе Windows можно использовать пункт меню “Python (command line)”
Вы увидите примерно следующее приглашение командной строки:
Python 3.1.2 (r312:79147, Jun 12 2010, 15:29:06)
[GCC 4.4.3 20100316 (ALT Linux 4.4.3-alt2)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>
Смело вводите команды и наслаждайтесь результатом. А что можно вводить? Несколько примеров:
>>> 2 + 2
4
>>> 2 ** 100
1267650600228229401496703205376
>>> 'Hello' + 'World'
'HelloWorld'
>>> 'ABC' * 100
'ABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABC
ABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABC
ABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABC
ABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABC
ABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABC'
Первая команда вычисляет сумму двух чисел, вторая команда вычисляет 2 в степени 100, третья команда выполняет операцию конкатенации для строк, а четвертая команда печатает строку ‘ABC’, повторенную 100 раз.
Хотите закончить работу с питоном? Введите команду exit() (именно так, со скобочками, так как это — функция), или нажмите Ctrl+D.
Преобразование типов
Иногда бывает полезно целое число записать, как строку. И, наоборот, если строка состоит из цифр, то полезно эту строку представить в виде числа, чтобы дальше можно было выполнять арифметические операции с ней. Для этого используются функции, одноименные с именем типа, то есть int, float, str. Например, int(‘123’) вернет целое число 123, а str(123) вернет строку ‘123’.
>>> str(2 + 2) * int('2' + '2')
'4444444444444444444444'
Результатом будет строка из числа 4, повторенная 22 раза.
Пишем простейшие программы
В предыдущем задании мы использовали Питон для простых разовых вычислений, используя интерактивный режим. Например, было задание вычислить длину гипотенузы прямоугольного треугольника по ее катетам. Запустите текстовый редактор и напишите следующий текст:
a = 179
b = 197
c = (a ** 2 + b ** 2) ** 0.5
print (c)
Здесь мы используем переменные — объекты, в которых можно сохранять различные (числовые, строковые и прочие) значения. В первой строке переменной a присваивается значение 179, затем переменной b присваивается значение 971, затем переменной c присваивается значение арифметического выражения, равному длине гипотенузы.
После этого значение переменной c выводится на экран.
Сохраните этот текст в файле с именем hypot.py . Запустите терминал, перейдите в каталог, где лежит этот файл и выполните эту программу:
$ python3 hypot.py
Интерпретатор языка Питон, запущенный с указанием имени файла, запускается не в интерактивном режиме, а выполняет ту последовательность команд, которая сохранена в файле. При этом значения вычисленных выражений не выводятся на экран (в отличии от интерактивного режима), поэтому для того, чтобы вывести результат работы программы, то есть значение переменной c , нам понадобится специальная функция print .
Ввод данных: функция input()
Пример выше неудобен тем, что исходные данные для программы заданы в тексте программы, и для того, чтобы использовать программу для другого треугольника необходимо исправлять текст программы. Это неудобно, лучше, чтобы текст программы не менялся, а программа запрашивала бы у пользователя данные, необходимые для решения задачи, то есть запрашивала бы значения двух исходных переменных a и b . Для этого будем использовать функцию input() , которая считывает строку с клавиатуры и возвращает значение считанной строки, которое сразу же присвоим переменым a и b :
a = input()
b = input()
Правда, функция input возвращает текстовую строку, а нам нужно сделать так, чтобы переменные имели целочисленные значения. Поэтому сразу же после считывания выполним преобразование типов при помощи фунцкии int , и запишем новые значения в переменные a и b .
a = int(a)
b = int(b)
Можно объединить считывание строк и преобразование типов, если вызывать функцию int для того значения, которое вернет функция input :
a = int(input())
b = int(input())
Далее в программе вычислим значение переменной c и выведем результат на экран.
Теперь мы можем не меняя исходного кода программы многократно использовать ее для решения различных задач. Для того нужно запустить программу и после запуска программы ввести с клавиатуры два числа, нажимая после кажого числа клавишу Enter . Затем программа сама выведет результат.
Ввод данных: функция input()
Ввод данных: функция input()
Вывод данных: функция print()
Функция print может выводить не только значения переменных, но и значения любых выражений. Например, допустима запись print(2 + 2 ** 2) . Также при помощи функции print можно выводить значение не одного, а нескольких выражений, для этого нужно перечислить их через запятую:
a = 1
b = 2
print(a, '+', b, '=', a + b)
В данном случае будет напечатан текст 1 + 2 = 3 : сначала выводится зание переменной a , затем строка из знака “+”, затем значение переменной b , затем строка из знака “=”, наконец, значение суммы a + b .
Обратите внимание, выводимые значение разделяются одним пробелом. Но такое поведение можно изменить: можно разделять выводимые значения двумя пробелами, любым другим символом, любой другой строкой, выводить их в отдельных строках или не разделять никак. Для этого нужно функции print передать специальный именованный параметр, называемый sep , равный строке, используемый в качестве разделителя (sep — аббревиатура от слова separator, т.е. разделитель). По умолчанию параметр sep равен строке из одного пробела и между значениями выводится пробел. Чтобы использовать в качестве разделителя, например, символ двоеточия нужно передать параметр sep , равный строке ‘:’ :
print(a, b, c, sep = ':')
Аналогично, для того, чтобы совсем убрать разделитель при выводе нужно передать параметр sep , равный пустой строке:
print(a, '+', b, '=', a + b, sep = '')
Для того, чтобы значения выводились с новой строке, нужно в качестве параметра sep передать строку, состоящую из специального символа новой строки, которая задается так:
print(a, b, sep = '\n')
Символ обратного слэша в текстовых строках является указанием на обозначение специального символа, в зависимости от того, какой символ записан после него. Наиболее часто употребляется символ новой строки ‘\n’ . А для того, чтобы вставить в строку сам символ обратного слэша, нужно повторить его два раза: ‘\\’ .
Вторым полезным именованным параметром функции print является параметр end , который указывает на то, что выводится после вывода всех значений, перечисленных в функции print . По умолчанию параметр end равен ‘\n’ , то есть следующий вывод будет происходить с новой строки. Этот параметр также можно исправить, например, для того, чтобы убрать все дополнительные выводимые символы можно вызывать функцию print так:
print(a, b, c, sep = '', end = '')
Целочисленная арифметика
Для целых чисел определены ранее рассматривавшиеся операции + , — , * и ** . Операция деления / для целых чисел возвращает значение типа float . Также функция возведения в степень возвращает значение типа float , если показатель степени — отрицательное число.
Но есть и специальная операция целочисленного деления, выполняющегося с отбрасыванием дробной части, которая обозначается // . Она возвращает целое число: целую часть частного. Например:
>>> 17 // 3
5
>>> -17 // 3
-6
Другая близкая ей операция: это операция взятия остатка от деления, обозначаемая % :
>>> 17 % 3
2
>>> -17 % 3
1
Строковый тип данных в Python: string
Строка — это некоторая последовательность символов. В языке Python строковые данные имеют формат str.
Строка в Python
Создадим первую текстовую переменную. Для создания строки можно использовать как одинарные, так и двойные кавычки:
>>> s = 'Hello world' >>> s 'Hello world' >>> s = "Hello world" >>> s 'Hello world'Вывод в Python всегда будет в одинарных кавычках, так как производится перевод двойных кавычек в одинарные.
Проверим тип этой переменной:
>>> type(s)
Если необходимо задать большой фрагмент текста, то используются тройные кавычки:
>>> s='''Hello World!!''' >>> s 'Hello\nWorld!!'В данном примере сохранился знак перехода на новую строку (‘\n’).
Преобразование чисел в строки и обратно
Любое число можно преобразовать в строку. Для этого используется функция str() давайте попробуем:
>>> str(1232) '1232' >>> str(-0.5) '-0.5'Теперь попробуем выполнить обратное действие
>>> s = '123' >>> int(s) 123 >>> float(s) 123.0 >>> s = '1.23' >>> float(s) 1.23 >>> int(s) Traceback (most recent call last): File "", line 1, in int(s) ValueError: invalid literal for int() with base 10: '1.23'Если вид числа не удовлетворяет типу данных, то преобразование не выполняется. Компилятор выдает ошибку вида invalid literal, что в переводе означает недопустимый литерал (символ), из-за наличия точки, то есть данное число является числом с плавающей точкой (float).
Чтобы избежать данной ошибки, в первую очередь необходимо выполнить преобразование в тип float. Если нужно, то затем преобразовываем полученный float в int.
>>> s='0.23' >>> int(float(s)) 0Основные операции со строками в Python
Длина строки
В Python строка представляет собой массив символов, расположенных в определенной последовательности. Когда мы пишем:
>>> s='Hello world'Компьютер представляет это следующим образом:
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| H | e | l | l | o | w | o | r | l | d |
Воспользуемся функцией len(), чтобы узнать длину строки.
>>> len(s) 11Как и было указано выше, длина данной строки — 11 символов (нумерация начинается с нуля).
Строка является массивом, поэтому мы можем обратиться к каждому отдельному элементу строки, давайте попробуем:
>>> s[2] 'l' >>> s[4] 'o'Также можно получить, так называемый срез слова, то есть фрагмент из общей последовательности символов. Для этого нужно указать диапазон:
>>> s='Hello world' >>> s[2:5] 'llo'Сложение строк
Давайте попробуем сложить 2 строки:
>>> s1='Hello' >>> s2='world' >>> s1+s2 'Helloworld'Также при сложении можно добавлять не только переменные, которым присвоены строки, но и просто сами строки:
>>> s1='Hello' >>> s2='world' >>> s1+' '+s2+"!" 'Hello world!'Попробуем сложить строки и числа:
>>> s1='number ' >>> s1+1 Traceback (most recent call last): File "", line 1, in s1+1 TypeError: can only concatenate str (not "int") to strСтроковой тип данных можно складывать только с таким же типом.
Достаточно выполнить преобразование, чтобы получить правильное решение:
>>> s1+str(1) 'number 1'Умножение строк
Давайте попробуем выполнить различные умножения: на целое число, на дробное число, на само себя:
>>> s='Hi' >>> s*2 'HiHi' >>> s*1.2 Traceback (most recent call last): File "", line 1, in s*1.2 TypeError: can't multiply sequence by non-int of type 'float' >>> s*s Traceback (most recent call last): File "", line 1, in s*s TypeError: can't multiply sequence by non-int of type 'str'Операция умножения в данном случае является дублированием строки. Такое действие можно выполнить только целое число раз, поэтому при умножении на дробное число или на строку выдаёт ошибку.
Умножать строковой тип данных можно только на целые числа.
Курсы Робикс, в которых изучается этот материал.
- Программирование на Python в Minecraft
- Duckietown робот с системой Автопилота
Как конвертировать строки в целые числа в Python
Все типы данных в Python, включая целые числа и строки, являются объектами. Часто при написании кода на Python вам необходимо преобразовать один тип данных в другой. Например, чтобы выполнить математическую операцию с числом, представленным в виде строки, его необходимо преобразовать в целое число.
В этой статье мы покажем вам, как преобразовать строку Python в целое число.
Функция int() в Python
Встроенная функция int() возвращает десятичный целочисленный объект из заданного числа или строки. Он принимает следующую форму:
int(x, base=10)
Функция принимает два аргумента:
- x — Строка или число для преобразования в целое число.
- base — Он представляет собой систему счисления первого аргумента. Его значение может быть 0 и 2–36. Если база не указана, по умолчанию используется 10 (десятичное целое число).
Обычно целые числа выражаются в шестнадцатеричном (основание 16), десятичном (основание 10), восьмеричном (основание 8) или двоичном (основание 2) обозначении.
Если данный аргумент не может быть представлен как целое число, функция выдаст исключение ValueError.
Преобразование строки Python в целое число
В Python «строка» — это список символов, который объявляется с помощью одинарных (‘), двойных («) или тройных кавычек («»»).
Если переменная, которая содержит только числа, объявляется с помощью кавычек, ее тип данных устанавливается на String. Рассмотрим следующий пример:
days = "23" type(days)
Функция type() показывает нам , что daysэто объект типа String.
Давайте попробуем выполнить математическую операцию над переменной:
print(days+5)
Python выдаст ошибку исключения TypeError, потому что мы не можем выполнить сложное вычисление со строкой и целым числом:
Traceback (most recent call last): File "", line 1, in TypeError: cannot concatenate 'str' and 'int' objects
Чтобы преобразовать строковое представление десятичного целого числа int, передайте строку в функцию int(), которая возвращает десятичное целое число:
days = "23"days_int = int(days)type(days_int)
Если вы сейчас попытаетесь сделать математику, операция суммирования будет выполнена успешно:
print(days_int+5)
Если число включает запятые, отмечая тысячи, миллионы и т. д., вам необходимо удалить запятые перед передачей числа в функцию int():
total = "1,000,000"int(total.replace(",", ""))
1000000
При преобразовании строк, представляющих целые числа в разных системах счисления, убедитесь, что вы используете правильные значения base.
Например, в шестнадцатеричной системе число 54732 представляется как D5CF. Чтобы преобразовать его в десятичное целое, вам нужно использовать основание 16:
int("D5CF", 16)
54735
Если вы передадите D5CFстроку в функцию int() без установки базы, она выдаст исключение ValueError:
int("D5CF")
Traceback (most recent call last): File "", line 1, in ValueError: invalid literal for int() with base 10: 'D5CF'
Заключение
В Python вы можете преобразовать строку в целое число, используя функцию int().
Если у вас есть какие-либо вопросы или отзывы, не стесняйтесь оставлять комментарии.
Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.
Условия (if, else, elif) и операторы сравнения
На прошлом занятии мы научились выводить данные с помощью функции print() . Например, чтобы вывести число 5 на экран нужно написать в интерпретаторе print(5) , и он сделает свое дело.
Но что, если нужно что-то ввести в программу из внешнего мира? Например, если наш самописный калькулятор умеет складывать 2 числа и выводить ответ, то как ввести эти самые 2 числа? На помощь придет функция input() . Попробуем написать вышеописанный калькулятор.
Функции input() можно передать в качестве аргумента строку, которую увидит пользователь перед вводом.
>>> a = input('Введите число a: ') Введите число a: 56 >>> b = input('Введите число b: ') Введите число b: 23 >>> print(a + b) 5623 Как видно из примера, что-то пошло не так. Вместо заветных 46 после сложения 12 и 34 мы получили 1234. Все дело в типах данных. Функция input() всегда считывает данные в виде строки. Так и в примере она считала 12 и 34 как 2 строки и просто «слепила» их вместе. Мы же хотим складывать числа. Чтобы все работало хорошо, нужно выполнить преобразование типов данных.
В данном случае можно сделать вот так:
>>> a = int(input('Введите число a: ')) Введите число a: 56 >>> b = (input('Введите число b: ')) Введите число b: 23 >>> print(a + b) 79 То, чего мы и хотели.
Преобразовывать можно не только строку в целое число, но и наоборот. Вот несколько допустимых преобразований:
>>> # Преобразование числа в строку >>> a = 34 >>> b = str(a) >>> print('Преобразованное число:', b, ', его тип:', type(b)) Преобразованное число: 34 , его тип: class 'str'> >>> # Преобразование строки в число с плавающей точкой >>> a = '45.34' >>> b = float(a) >>> print(a, type(a)) 45.34 class 'str'> >>> print(b, type(b)) 45.34 float'> >>> b**2 2055.7156000000004 >>> # Преобразовать строку с НЕ числом в число не получится >>> a = 'python' >>> b = int(a) Traceback (most recent call last): File "", line 1, in module> b = int(a) ValueError: invalid literal for int() with base 10: 'python' В примерах мы используем функцию type() . Как должно быть понятно из её названия, она выясняет тип переменной. Возвращает она что-то страшное вида . Сейчас не стоит вникать почему так. Нам важно, что преобразование прошло правильно и получился тип str .
Как вы уже поняли, чтобы преобразовать что-то во что-то, надо взять и вызвать функцию, совпадающую по имени с названием типа данных. В нашем примере это str() , int() и float() .
Почему нужно конвертировать строки в числа
Возможно, решая очередную задачу, вы случайно не переведете строки в числа, а программа все равно будет работать. Например, у вас будет такая программа, вычисляющая, какое из 2 введенных чисел больше:
>>> a = input('Введите целое число:') Введите целое число:12 >>> b = input('Введите целое число:') Введите целое число:45 >>> if a > b: . print('Большее число:', a) . else: . print('Большее число:', b) Большее число: 45 Вы удовлетворитесь ответом и пойдете домой. Но потом выяснится, что если ввести другие 2 числа, то все сломается:
>>> a = input('Введите целое число:') Введите целое число:4 >>> b = input('Введите целое число:') Введите целое число:30 >>> if a > b: . print('Большее число:', a) . else: . print('Большее число:', b) Большее число: 4 Значит, не все так просто…
Чтобы разобраться в вопросе, нужно знать как сравниваются строки.
Компьютер умеет работать только с одним типом данных — числами. Мы же помимо чисел используем кучу разных типов данных: числа, строки, списки, словари, кортежи (последние 3 будут обсуждаться дальше в курсе). Оказывается, что и они все хранятся и обрабатываются компьютером в виде чисел. Разберемся со строчками.
Когда люди задумались, как можно обрабатывать строки, им прошла в голову простая идея — а давайте создадим единую таблицу, в которой каждому символу поставим в соответствие число. Так появилась таблица ASCII (American standard code for information interchange).
Когда люди стали пользоваться компютером не только в Америке (точнее говоря, не только в англоговорящих странах), то встал вопрос о том, что в таблице не хватает места. Так появились другие таблицы кодировок:
Python версии 3 использует Unicode — кодировку, которая на данный момент включает в себя знаки почти всех письменных языков мира. Emoji в ней, кстати, тоже есть ������������
При сравнении строк, Python переводит все символы строки в числа и производит сравнение чисел.
Если перевести “числовые” строки из примеров выше в списки чисел, то получится:
- ’12’ = [49, 50]
- ’45’ = [52, 53]
- ‘4’ = [52]
- ’30’ = [51, 48]
Когда же мы пишем ‘4’ < '30' , то Python снова сравнивает числа обоих строк по очереди, но на этот раз получается иначе: 52 < 51 - False и ответ получается '4' >’30’ , что абсолютно верно с точки зрения сравнения строк, но абсолютный бред с точки зрения сравнения чисел.
Python сравнивает числа по очереди. Если он уже на первом числе может ответить на вопрос “кто больше”, он прекращает сравнение и выдает ответ. Если же строки имеют одинаковую первую букву, то сравниваться они будут по второй и так далее. Такое сравнение называется лексикографическим
Поэтому, если вы работаете с числами, то всегда работайте с ними как с числами, а не как со строками.
Условия
Все рассматриваемые нами ранее программы имели линейную структуру — программа просто выполняла инструкции одну за другой сверху вниз. При этом никаких способов повлиять на ход выполнения у нас не было (разве что только на уровне выводимых на экран параметров). Также важно то, что наши предыдущие программы обязаны были выполнить все инструкции сверху вниз, в противном случае они бы завершались ошибкой.
Теперь предположим, что мы хотим определить абсолютное значение любого числа. Наша программа должна будет напечатать сам x в случае, если он неотрицателен и -x в противном случае. Линейной структурой программы здесь не обойтись*, поэтому нам на помощь приходит инструкция if (если). Вот как это работает в питоне:
>>> # Ввод данных с преобразованием типа >>> x = int(input()) >>> >>> if x > 0: . print(x) >>> else: . print(-x) На самом деле в python есть функция abs() , с помощью которой можно взять модуль числа. Но в качестве примера использования конструкции if и так хорошо.
Разберем этот кусочек кода. После слова if указывается проверяемое условие (x > 0) , завершающееся двоеточием (это важно). После этого идет блок (последовательность) инструкций, который будет выполнен, если условие истинно. В нашем примере это вывод на экран величины x . Затем идет слово else (иначе), также завершающееся двоеточием (и это важно), и блок инструкций, который будет выполнен, если проверяемое условие неверно. В данном случае будет выведено значение -x .
Обратите особенное внимание на отступы во фрагменте кода выше. Дело в том, что в питоне, для того, чтобы определить, какой именно код выполнить в результате того или иного условия используется как знак двоеточия (в строке с самим условием), так и отступы от левого края строки.
Небольшая ремарка относительно табуляции. Мы используем 4 пробела! В современных текстовых редакторах при нажатии на tab автоматически вставляется 4 пробела. Не надо жать 4 раза кнопку space как вот тут. Никакой войны, никаких табов. Просто 4 пробела.
Во многих других языках вместо отступов используются конструкции, явно указывающие на начало (begin или открывающаяся фигурная скобка в Си) и конец инструкций, связанных с условием (end или закрывающаяся фигурная скобка в Си). Отступы же выполняют примерно ту же роль, но и заодно делают код более читаемым, позволяя читающему быстро понять, какой именно код относится к условию.
Таким образом, условные конструкции в питоне имеют следующий общий вид:
if Условие: блок инструкций, в случае если условие истинно else: блок инструкций, в случае если условие не выполняется Вторая часть условной конструкции (та, что с else) может и отсутствовать, например так:
>>> x = int(input()) >>> >>> if x 0: . x = -x . >>> print(x) Эта программа тоже выведет абсолютное значение x, как и та, что была ранее.
Операторы сравнения
Все операторы сравнения в питоне достаточно интуитивны. Вот список основных:
> — больше. Условие истинно, если то, что слева от знака больше того, что справа.
< - меньше. Условие истинно, если то, что слева от знака меньше того, что справа.
>= — больше либо равно.
== — в точности равно.
!= — не равно.
Вложенные условные инструкции
Условия могут быть вложены одно в другое, чтобы реализовывать еще более сложную логику, например:
>>> a = int(input()) >>> b = int(input()) >>> >>> if a > 0: . if b > 0: . print("a, b > 0") . else: . print("a > 0, b < 0") . else: . if b > 0: . print("a, b < 0") . else: . print("a < 0, b >0") . Главное, не забывать отступы и двоеточия.
Тип данных bool
Операторы сравнения возвращают значения специального логического типа bool. Значения логического типа могут принимать одно из двух значений: True (истина) или False (ложь) .
Если преобразовать логическое True к типу int , то получится 1 , а преобразование False даст 0 . При обратном преобразовании число 0 преобразуется в False , а любое ненулевое число в True . При преобразовании str в bool пустая строка преобразовывается в False , а любая непустая строка в True .
Рассмотрим несколько примеров:
>>> # Сравнение строки >>> name = input('Введите своё имя:') >>> if name != '': >>> print('Привет,', name) >>> else: >>> print('Вы не ввели своё имя!') >>> # Преобразование bool к int >>> print(int(True)) 1 >>> print(int(False)) 0 Обратите внимание, ключевые слова True или False пишутся с большой буквы. Если написать их с маленькой, то python подумает, что это переменная, попытается её найти и сломается, когда не найдет 🙁 . А если вы вздумаете называть свои переменные false или true , то сдать зачет по курсу вам не светит 🙂 . Учитесь сразу хорошему стилю программирования.
>>> # Преобразование bool к int >>> print(int(true)) Traceback (most recent call last): File "", line 1, in module> print(int(true)) NameError: name 'true' is not defined Логические операторы
Если мы хотим проверить два или более условий за раз, мы можем воспользоваться операторами and , or или not . Вот как они работают:
and (логическое И) возвращает истину ( True ) только в случае если оба условия по отдельности верны (тоже возвращают True )
or (логическое ИЛИ) вернет истину в случае, если хотя бы одно из условий верно.
not (логическое НЕТ) возьмет результат условия и “обратит” его. То есть, если результат условия True , то not примененный к этому условию вернет False и наоборот.
Давайте посмотрим как это работает на примере. Код ниже проверяет, что хотя бы одно число из двух нацело делится на 10 (кончается на 0) и если так, то печатает YES, а если нет, то печатает NO:
>>> a = int(input()) >>> b = int(input()) >>> >>> if a % 10 == 0 or b % 10 == 0: . print('YES') . else: . print('NO') . Пусть теперь мы хотим проверить, что числа a и b должны быть еще и обязательно больше нуля:
>>> a = int(input()) >>> b = int(input()) >>> >>> if (a % 10 == 0 and a > 0) or (b % 10 == 0 and b > 0): . print('YES') . else: . print('NO') . Как видите, мы можем не только использовать and и or в одном if , но и группировать условия скобками для того, чтобы явно обозначить приоритет вычисления условий.
Посмотрим пример с not . Пусть мы хотим проверить, что число a — положительное, а число b — неотрицательное. Это можно проверить вот таким условием:
>>> if a > 0 and not (b 0): . pass . Оператор pass очень полезен, когда нужно ничего не делать. Если его не поставить, то будет синтаксическая ошибка. А так, код считается правильным!
Кстати, not (b < 0) можно было бы и заменить на b >= 0 и код бы работал точно так же.
Конструкция elif
Иногда писать конструкции if-else долго и утомительно, особенно если приходится проверять много условий разом. В этом случае на помощь придет elif (сокращение от else if). По сути elif позволяет существенно упростить конструкцию ниже:
>>> if a > 0: . pass . else: . if b > 0: . pass . И сделать ее вот такой:
>>> if a > 0: . pass . elif b > 0: . pass . Обратите внимание, мы избавились от одного уровня вложенности. То есть, сам код стал более читаемым, но при этом нисколько не проиграл в функциональности. Разумеется, конструкции типа if-elif могут завершиться и блоком else , например так:
>>> if a > 0: . pass . elif b > 0: . pass . elif c > 0: . pass . else: . pass . Задача: знак числа
В математике есть функция sgn, показывающая знак числа. Она определяется так: если число больше 0, то функция возвращает 1. Если число меньше нуля, то функция возвращает -1. Если число равно 0, то функция возвращает 0. Реализуйте данную функцию — для введенного числа выведите число, определяющее его знак. Используйте операторы сравнения и конструкцию if-elif-else .
>>> x = int(input()) >>> >>> if x > 0: . print(1) . elif x 0: . print(-1) . else: . print(0) . Задача: високосный год
Дано натуральное число. Требуется определить, является ли год с данным номером високосным. Если год является високосным, то выведите YES, иначе выведите NO. Напомним, что в соответствии с григорианским календарем, год является високосным, если его номер кратен 4, но не кратен 100, а также если он кратен 400.
>>> year = int(input()) >>> if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0): . print('YES') . else: . print('NO') . Ссылки по теме
- http://pythontutor.ru/lessons/ifelse/
- http://pythonicway.com/python-conditionals
Домашнее задание
Вам надо написать на питоне 6 программ, каждая из которых будет спрашивать у пользователя 3 числа (a, b, c) и печатать на экран удовлетворяют ли введенные числа перечисленным свойствам:
- a и b в сумме дают c
- a умножить на b равно c
- a даёт остаток c при делении на b
- c является решением линейного уравнения ax + b = 0
- a разделить на b равно c
- a в степени b равно c
Оформите каждую программу в виде отдельного файла с расширением .py .