Як написати менше в Пітоні

Оператори більше і менше в Python

Для порівняння двох значень між собою використовуються оператори більше > , більше > = , менше , менше чи одно .

Нехай у нас є змінна tst :

Давайте дізнаємося чи більше нуля значення цієї змінної:

Тепер давайте змінимо значення змінної на негативне:

Нехай тепер значення змінної дорівнює 0. У цьому випадку виконається блок else:

Давайте змінимо умову на більше чи одно:

Якщо змінити умову на менше або одно, то також спрацює перший блок:

Перевірте, що вона більша за 10 .

Перевірте, чи змінна tst менше 10 .

Перевірте, чи змінна tst більша або дорівнює 5 .

Перевірте, що змінна tst менша або дорівнює -5 .

Перевірте, що вона більша за 10 .

if age >= 18: print('Ви маєте доступ до мережі') else: print('Ви не маєте доступу до сайту')

Встановіть змінної age число з вашим віком. Скажіть, що вивелось у консоль.

Операції порівняння в Python, ланцюжки порівнянь

У Python є шість операцій порівняння. Усі вони мають однаковий пріоритет, який вищий, ніж у логічних операцій.

Дозволені операції порівняння:

x < y - строго x менше y,
x
x > y - строго x більше y,
x >= y - x більше або одно y ,
x == y - x дорівнює y ,
x != y - x не дорівнює y.

Порівняння можуть бути пов'язані довільно і записані в ланцюжки порівнянь, у яких з'єднання порівнянь використовуються неявні логічні оператори and .

x

y

z
# еквівалентно
x

y
and
y

z

a

b

c

d
# еквівалентно
a

b
and
b

c
and
c

d

У такій формі порівняння легше читаються, і кожен вираз обчислюється принаймні один раз.

Об'єкти різних типів, крім різних числових типів, будь-коли будуть рівними.

Оператор == завжди визначений, але деяких типів об'єктів, наприклад об'єктів класу, еквівалентний оператору ідентичності is .

Оператори < , і >= застосовуються лише там, де мають сенс, наприклад вони викликають виняток TypeError , коли з аргументів є комплексним числом.

Неідентичні екземпляри класу зазвичай при порівнянні будуть нерівні, якщо клас не визначає метод __eq__() .

Примірники класу не можуть бути впорядковані щодо інших екземплярів того ж класу або інших типів об'єктів, якщо клас не визначає достатню кількість методів __lt__() , __le__() , __gt__() та __ge__() . У випадку визначення методів __lt__() і __eq__() цих цілей буває достатньо.

Важливо! Числа типу float не є десятковими дробами (decimal.Decimal) і використовують двійкову арифметику, тому іноді вирази можуть обчислюватися з мізерними похибками. Через ці похибки операції порівняння працюють не так, як очікується.

>>>
0.8
-
0.5
==
0.3
# False
>>>
0.8
-
0.5
-
0.3
==
0
# False
>>>
0.8
-
0.5
-
0.3
# 5.551115123125783e-17
>>>
from
decimal
import
Decimal
>>>
Decimal('0.8')
-
Decimal('0.5')
-
Decimal('0.3')
==
0
# True
>>>
Decimal('0.8')
-
Decimal('0.5')
-
Decimal('0.3')
# Decimal('0.0')

Поведінка вбудованих типів в операціях порівняння:

Числа вбудованих числових типів int, float, complex і стандартних бібліотечних типів fractions.Fraction і decimal.Decimal можна порівнювати всередині та між їх типами, з обмеженням, що комплексні числа не підтримують порівняння порядку. У межах задіяних типів вони математично порівнюють (алгоритмічно) правильно без втрати точності. Нечислові значення float('NaN') та decimal.Decimal('NaN') є особливими. Будь-яке впорядковане порівняння числа з нечисловим значенням неправильне. Нечислові значення не дорівнюють самим собі.Наприклад, якщо x = float('NaN') , 3 < x , x < 3 і x == x всі хибні, а x! = X істинно.

Щоб дві колекції були рівними, вони повинні бути одного типу, мати однакову довжину, і кожна пара відповідних елементів повинна бути рівною.
Колекції, що підтримують порівняння порядку (сортування), упорядковуються також, як їх перші нерівні елементи, наприклад [1,2, x]

Підводне каміння (пастки ланцюжків порівняння).

Незважаючи на те, що ланцюжки порівняння виглядають дуже розумно, є пара підводних каменів, на які необхідно звернути увагу.

Нетранзитивні оператори.

Щоб перевірити, чи збігаються a , b і c можна використовувати ланцюжок порівняння a == b == c . ВСЕ Чи вони різні? Перше, що спадає на думку - це a! = b! = C, і потрапляємо в першу пастку!

>>>
a
=
c
=
1
>>>
b
=
2
>>>
a
!=
b
!=
c
# True

Але це не так. Вони не всі різні, адже a == c . Проблема тут у тому, що a ! від a і від c, але нічого не говорить про те, як пов'язані a і c.

З математичної точки зору, != не є транзитивним, тобто знання того, як a відноситься до b і знання того, як b відноситься до c не говорить про те, як a відноситься до c . можна взяти оператор рівності == .

Непостійне значення у виразі.

Якщо b містить щось непостійне або вираз з побічними ефектами, ці два вирази не еквівалентні.

Цей приклад показує різницю у кількості оцінок значення у середині виразу:

def
f():
print("run")
return
3
>>>
1

f()

5
# run
# True
>>>
1

f()
and
f()

5
# run
# run
# True

lst
=
[-2,
2]
def
f():
global
lst
lst
=
lst[::-1]
return
lst[0]
>>>
1

f()
and
f()

0
# True
>>>
1

f()

0
# False

Синтаксис lst[::-1] - це зріз, що перевертає список.

Ланцюжки порівняння, що погано читаються.

Ланцюжки порівняння виглядають дійсно природно, але в деяких конкретних випадках вона не така гарна. Це досить суб'єктивне питання, але краще уникати ланцюжка, у яких оператори не "вирівняні", наприклад:

Можна стверджувати, наприклад, що a c читається як "перевіримо, b більше, ніж a і c?", але краще цей ланцюжок записати так max(a, c) max(a, c).

Є деякі інші ланцюжки, які просто збивають з пантелику:

У Python оператори is, is not, in і not in є операторами порівняння, отже їх також можна зв'язати з іншими операторами. Це створює дивні ситуації, такі як:

>>>
a
=
3
>>>
lst
=
[3,
5]
>>>
a
in
lst
==
True
# False

Приклади використання ланцюжків порівняння.

>>>
a
=
1
>>>
b
=
2
>>>
c
=
3
>>>
a

b

c
# True

Інший приклад використання – коли необхідно переконатися, що всі три значення однакові:

>>>
a
=
b
=
1
>>>
c
=
2
>>>
if
a
==
b
==
c:
.
print("усі рівні")
.
else:
.
print("деякі відрізняються")
деякі відрізняються
>>>
c
=
1
>>>
if
a
==
b
==
c:
.
print("усі рівні")
.
else:
.
print("деякі відрізняються")
# всі рівні

Насправді можна пов'язати довільну кількість операторів порівняння у ланцюжок? Наприклад, a == b == c == d == e перевіряє, чи всі п'ять змінних збігаються, тоді як a < b < c < d < e перевіряє, чи є строго зростаюча послідовність.

Умови (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 як два рядки і просто «зліпила» їх разом. Ми ж хочемо складати числа. Щоб усе працювало добре, потрібно виконати перетворення типів даних.

В даному випадку можна зробити так:

>>>
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 перекладає всі символи рядка в числа і здійснює порівняння чисел.

Якщо перевести "числові" рядки з прикладів вище до списків чисел, то вийде:

Коли ми пишемо '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 , то не застосований до цієї умови поверне 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')
.

Посилання по темі

Домашнє завдання

Вам треба написати на пітоні 6 програм, кожна з яких запитуватиме у користувача 3 числа (a, b, c) і друкувати на екран чи задовольняють введені числа перерахованим властивостям: