Работа с числами в python

Оператор else

В некоторых ситуациях необходимо, чтобы программа выполнила какое-то действие даже тогда, когда выражение if ложно. Например, программа grade.py может сообщать не только об успешном результате теста, но и о его провале.

Для этого используется оператор else. Добавьте его в код:

Сохраните и запустите программу.

Итак, значение переменной grade – целое число 60, что не отвечает условию grade >= 65. Раньше программа просто молчала, теперь благодаря оператору else она может вернуть:

Перепишите программу, присвойте переменной grade значение 65. Запустите её снова. На экране появится:

Теперь попробуйте добавить оператор else в программу account.py.

В данном случае программа выведет сообщение:

Мы присвоили переменной balance положительное значение, после чего оператор else отобразил на экране вышеприведённое сообщение.

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

Не в Python Как Оператор Идентификации

Операторы идентификации используются для сравнения объектов. У нас есть «нет» href=»https://www.w3schools.com/python/python_operators.asp»>оператор href=»https://www.w3schools.com/python/python_operators.asp»>оператор

Программа для деления list1 из list2, но если какой-либо элемент в (Знаменателе не может

list1= 
list2= 
list3=[] 
for i in range(len(list1)): 
   #Denominator cannot be 0 
   if list2 is not 0: 
       list3.append(list1/list2) 
   else: 
       list3.append("Not Possible") 
print(list3) 

Output- 

list1= 
# list containing integers 
int_list=[] 
# list containing float values 
float_list=[] 
for i in list1: 
   # if the data type of  
   if type(i) is not int: 
        float_list.append(i) 
   else: 
        int_list.append(i) 
print("float list",float_list) 
print("integer list",int_list) 

Output- 
float list  
integer list 

Python Удалить Дубликаты Из СпискаPython Печать Без Новой СтрокиLearn Python the Hard Way Review PDFPython Map

Понятие об операторе if statement

Данное выступление посвящено оператору как показателю плохого кода (code smell). Начну с того, что не собираюсь ругать ничей код. Просто хочу поделиться опытом, благодаря которому могу использовать схему написания немного более понятного и подходящего для тестов кода.

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

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

Давайте перейдем к конкретике. Вот немножко питона.

Наш код проверяет будет ли переменная равна дню рождения пользователя. Если условие выполняется, мы выводим (print) сообщение с поздравлением. Если нет, то пропускаем его и продолжаем исполнение программы, как будто этого кода не существует.

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

Основные строковые функции

capitalize()	Преобразует первый символ строки в верхний регистр	str_name.capitalize()
casefold()	Он преобразует любую строку в нижний регистр независимо от ее регистра	str_name.casefold()
center()	Используется для выравнивания строки по центру	str_name.center (длина, символ)
count()	Для подсчета количества раз, когда определенное значение появляется в строке.	str_name.count (значение, начало, конец)
endswith()	Проверяет, заканчивается ли строка указанным значением, затем возвращает True	str_name.endswith (значение, начало, конец)
find()	Используется для определения наличия указанного значения в строке	str_name.find (значение, начало, конец)
index()	Он используется для поиска первого вхождения указанного значения в строке	str_name.index (значение, начало, конец)
isalnum()	Проверяет, все ли символы являются буквенно-цифровыми, затем возвращает True	str_name.isalnum()
isalpha()	Проверяет, все ли символы являются алфавитными (az), затем возвращает True	str_name.isalpha()
isdecimal()	Проверяет, все ли символы являются десятичными (0-9), затем возвращает True	str_name.isdecimal()
isdigit()	Проверяет, все ли символы являются цифрами, затем возвращает True	str_name.isdigit()
islower()	Проверяет, все ли символы в нижнем регистре, затем возвращает True	str_name.islower()
isnumeric()	Проверяет, все ли символы являются числовыми (0-9), затем возвращает True	str_name.isnumeric()
isspace()	Проверяет, все ли символы являются пробелами, затем возвращает True	str_name.isspace()
isupper()	Проверяет, все ли символы в верхнем регистре, затем возвращает True	str_name.isupper()
lower()	Используется для преобразования всех символов в нижний регистр	str_name.lower()
partition()	Используется для разделения строки на кортеж из трех элементов.	str_name.partition (значение)
replace()	Используется для замены указанного слова или фразы другим словом или фразой в строке.	str_name.replace (старое значение, новое значение, количество)
split()	Используется для разделения строки на список	str_name.split (разделитель, maxsplit)
splitlines()	Используется для разделения строки и составления ее списка. Разбивается на разрыв строки.	str_name.splitlines (keeplinebreaks)
startswith()	Проверяет, начинается ли строка с указанного значения, затем возвращает True	str_name.startswith (значение, начало, конец)
strip()	Используется для удаления символов, указанных в аргументе, с обоих концов	str_name.strip (символы)
swapcase()	Используется для замены строки верхнего регистра на нижний регистр или наоборот.	str_name.swapcase()
title()	Преобразует начальную букву каждого слова в верхний регистр	str_name.title()
upper()	Он используется для преобразования всех символов в строке в верхний регистр	str_name.upper()

О чем следует помнить

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

Далее, можно прикинуть, насколько часто предполагается менять код. Если такие планы есть, то лучше уделить время рефакторингу кода, чтобы вывести его на более высокий уровень абстракции. В этом смысле мне нравится следовать правилу трех этапов, тоже взятому из книги Мартина Фаулера «Refactoring»:

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

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

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

Вспомним дзен Python:

Что касается наследования (inheritance), стараемся не создавать слишком глубокие уровни. Это усложняет код и лишает его гибкости. К тому же, вместо необходимости разобраться в нескольких уровнях условных выражений, нам придется разбираться в уровнях наследования классов. Получится, что один комплект проблем просто заменен на другой.

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

Но выбирать неверное направление абстракции тоже неправильно. Лучше уж копировать и вставлять дублирующийся код. На эту тему есть отличное выступление Санди Метца (Sandi Metz) с конференции по Ruby.

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

Логические операции

Логические операции
and  (логическое И),
or  (логическое ИЛИ),
not  (логичесткое НЕ) работают вполне предсказуемо, , только для обозначения используются английские слова, вместо двух символов:

Python

$ python3
Python 3.5.3 (default, Sep 27 2018, 17:25:39)
on linux
Type «help», «copyright», «credits» or «license» for more information.
>>> x = true
Traceback (most recent call last):
File «<stdin>», line 1, in <module>
NameError: name ‘true’ is not defined
>>> x = True
>>> y = False
>>> print (x and y)
False
>>> print (x or y)
True
>>> print(not(x))
False

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

$python3 Python3.5.3(default,Sep272018,172539) GCC6.3.020170516on linux Type»help»,»copyright»,»credits»or»license»formore information. >>>x=true Traceback(most recent call last) File»<stdin>»,line1,in<module> NameErrorname’true’isnotdefined >>>x=True >>>y=False >>>print(xandy) False >>>print(xory) True >>>print(not(x)) False

Битовые операторы в Python

Побитовые операторы работают над битами и выполняют операции бит за битом. Допустим, если а = 60; и б = 13; В настоящее время в двоичном формате они будут выглядить следующим образом:

—————–

а&б = 0000 1100

а|б = 0011 1101

а^б = 0011 0001

Встроенная функция bin() в Python может быть использована для получения двоичного представления целого числа.

Следующие Битовые операторы поддерживаются языком Python:

Оператор	Описание	Пример
& бинарный И	копии оператора бита, в результате, если они существует в обоих операндах	(а & б) (0000 означает 1100)
| бинарный ИЛИ	копирует бит, если он существует в любом из операндов.	(а | б) = 61 (означает 0011 1101)
^ бинарный Исключающий или	копирует бит, если он установлен в одном операнде, но не в обоих.	(а ^ б) = 49 (означает 0011 0001)
~ Бинарным комплемент	Это унарное и имеет эффект бит «листать».	(~ а) = -61 (в форме означает двойной комплемент 1100 0011 из-за подписанного двоичного числа.
	Значение левого операнда перемещается влево на число битов, заданное правым операндом.	а
>> Двоичный сдвиг вправо	Значение левого операнда перемещается вправо на число битов, заданное правым операндом.	а >> = 15 (0000 означает 1111)

Условия

Все рассматриваемые нами ранее программы имели линейную структуру — программа просто выполняла инструкции одну за другой сверху вниз

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

Теперь предположим, что мы хотим определить абсолютное значение любого числа. Наша программа должна будет напечатать сам в случае, если он неотрицателен и в противном случае. Линейной структурой программы здесь не обойтись*, поэтому нам на помощь приходит инструкция if (если). Вот как это работает в питоне:

Разберем этот кусочек кода

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

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

Обратите особенное внимание на отступы во фрагменте кода выше. Дело в том, что в питоне, для того, чтобы определить, какой именно код выполнить в результате того или иного условия используется как знак двоеточия (в строке с самим условием), так и отступы от левого края строки

Во многих других языках вместо отступов используются конструкции, явно указывающие на начало (begin или открывающаяся фигурная скобка в Си) и конец инструкций, связанных с условием (end или закрывающаяся фигурная скобка в Си). Отступы же выполняют примерно ту же роль, но и заодно делают код более читаемым, позволяя читающему быстро понять, какой именно код относится к условию.

Таким образом, условные конструкции в питоне имеют следующий общий вид:

Вторая часть условной конструкции (та, что с else) может и отсутствовать, например так:

Эта программа тоже выведет абсолютное значение x, как и та, что была ранее.

Логический оператор OR

Давайте посмотрим на простой пример логического оператора OR.

x = 10
y = 20

if x > 0 or y > 0:
    print('At least one of x and y is positive number')

Выход: по крайней мере одно из x и y является положительным числом.

Давайте подтвердим это простым фрагментом кода. Мы будем повторно использовать класс данных, определенный ранее.

d1 = Data(10)
d2 = Data(20)

# The expressions are evaluated until it's required
if d1 or d2:
    print('At least one of d1 and d2 id is a positive number')
else:
    print('Both d1 and d2 id are negative')

Вывод:

Data bool method called
At least one of d1 and d2 id is a positive number

Обратите внимание, что метод __bool __() вызывается только один раз и, поскольку он оценивается как True, дальнейшие выражения не оцениваются. Давайте запустим еще один пример, в котором оба логических значения объекта данных возвращают False

Давайте запустим еще один пример, в котором оба логических значения объекта данных возвращают False.

d1 = Data(-10)
d2 = Data(-20)

if d1 or d2:
    print('At least one of d1 and d2 id is a positive number')
else:
    print('Both d1 and d2 id are negative')

Вывод:

Data bool method called
Data bool method called
Both d1 and d2 id are negative

Наконец, на изображении ниже изображена блок-схема логического оператора или оператора.

Оператор if

Для начала рассмотрим оператор if. Он определяет условие как истинное или ложное, и если условие истинно, программа выполняет соответствующее действие.

Откройте текстовый редактор и наберите следующие строки:

В этом коде присутствует переменная grade, её значение – целое число 70. Оператор if сравнивает значение переменной с числом 65 и определяет, пройден ли тест. Если значение переменной меньше 65, тест не пройден. Если условие соблюдено, и значение переменной больше или равно 65, программа выведет на экран «Passing grade».

Сохраните эту простую программу как grade.py и запустите её в локальной среде:

• Настройка локальной среды разработки для Python 3 в CentOS 7
• Настройка локальной среды разработки для Python 3 в Windows 10
• Настройка локальной среды разработки для Python 3 в Mac OS X
• Настройка локальной среды разработки для Python 3 в Ubuntu 16.04

В данной ситуации значение переменной 70 отвечает условиям, потому на экране появится:

Попробуйте уменьшить значение переменной grade:

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

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

Создайте файл account.py и добавьте в него такие строки:

Запустите программу:

Команда вернёт:

Заданная в программе переменная balance имеет значение -5, что меньше 0. Это отвечает условию оператора if (balance < 0), потому программа возвращает указанное сообщение. Попробуйте самостоятельно увеличить значение переменной balance и снова запустить программу.

Оператор else if

Часто нам нужна программа, которая оценивает более двух возможных результатов. Для этого мы будем использовать оператор else if, который указывается в Python как elif. Оператор elif или else if выглядит как оператор if и оценивает другое условие.

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

• Баланс ниже 0.
• Баланс равен 0.
• Баланс выше 0.

Условие elif будет размещено между  if и оператором else следующим образом:

if balance < 0:
 print("Balance is below 0, add funds now or you will be charged a penalty.")

elif balance == 0:
    print("Balance is equal to 0, add funds soon.")

else:
    print("Your balance is 0 or above.")

После запуска программы:

• Если переменная balance равна 0, мы получим сообщение из оператора elif («Balance is equal to 0, add funds soon»).
• Если переменной balance задано положительное число, мы получим сообщение из оператора else («Your balance is 0 or above»).
• Если переменной balance задано отрицательное число, выведется сообщение из оператора if («Balance is below 0, add funds now or you will be charged a penalty»).

А что если нужно реализовать более трех вариантов сообщения? Этого можно достигнуть, используя более одного оператора elif.

В программе grade.py создадим несколько буквенных оценок, соответствующих диапазонам числовых:

• 90% или выше эквивалентно оценке А.
• 80-89% эквивалентно оценке B.
• 70-79%  — оценке C.
• 65-69%  — оценке D.
• 64 или ниже эквивалентно оценке F.

Для этого нам понадобится один оператор if, три оператора elif и оператор else, который будет обрабатывать непроходные баллы.

Мы можем оставить оператор else без изменений.

if grade >= 90:
    print("A grade")

elif grade >=80:
    print("B grade")

elif grade >=70:
    print("C grade")

elif grade >= 65:
    print("D grade")

else:
    print("Failing grade")

Поскольку операторы elif будут оцениваться по порядку, можно сделать их довольно простыми. Эта программа выполняет следующие шаги:

1. Если оценка больше 90, программа выведет «A grade». Если оценка меньше 90, программа перейдет к следующему оператору.
2. Если оценка больше или равна 80, программа выведет «B grade». Если оценка 79 или меньше, программа перейдет к следующему оператору.
3. Если оценка больше или равна 70, программа выведет  «C grade». Если оценка 69 или меньше, программа перейдет к следующему оператору.
4. Если оценка больше или равна 65, программа выведет  «D grade». Если оценка 64 или меньше, программа перейдет к следующему оператору.
5. Программа выведет «Failing grade», если все перечисленные выше условия не были выполнены.

Ввод данных и преобразования типов

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

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

Как видно из примера, что-то пошло не так. Вместо заветных 46 после сложения 12 и 34 мы получили 1234. Все дело в типах данных. Функция всегда считывает данные в виде строки. Так и в примере она считала 12 и 34 как 2 строки и просто «слепила» их вместе. Мы же хотим складывать числа. Чтобы все работало хорошо, нужно выполнить преобразование типов данных.

В данном случае можно сделать вот так:

То, чего мы и хотели.

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

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

Вложенные операторы if

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

Программа может вернуть такие результаты:

Если выражение statement1 истинно, программа оценит выражение nested_statement как истинное или ложное. Если вложенное выражение также истинно, она вернёт:

Если statement1 истинно, а nested_statement ложно, программа выведет на экран:

Если выражение statement1 ложно, программа не будет оценивать вложенные выражения и выведет:

В код можно добавить неограниченное количество вложенных операторов: э

Рассмотрим вложенные операторы на примере программы grade.py. К примеру, сначала программа может убедиться, что результаты теста можно засчитать (для этого нужно выполнить правильно минимум 65% заданий), а затем уже выставить оценки. Таким образом, если тест провален, программа не будет сверять значение переменной со всеми выражениями, а сразу выведет Failing grade.

К примеру, если значение переменной grade – 92, то первое условие выполнено,  и программа вернёт:

Затем она сравнит значение переменной с остальными выражениями. Поскольку в данном случае значение соответствует первому условию (grade >= 90), программа выведет:

Попробуйте установить переменной grade значение 60 и посмотрите, как поведёт себя программа. В этом случае первичное выражение if ложно, потому она сразу перейдёт к первичному оператору else и выведет:

Вы можете добавить в программу больше параметров, например, разделить оценки на А+, А, А- и так далее. Такой код будет выглядеть так:

Если переменная grade имеет значение 96, то:

• Программа убедится, что значение переменной больше или равно 65 (в данном случае это условие выполняется).
• Выведет на экран Passing grade of:.
• Затем она сравнит значение с условием grade >= 90 (в данном случае оно истинно).
• Программа проверит условие grade > 96 (ложно).
• После этого она убедится, что значение больше 93 и меньше или равно 96 (истинно).
• Программа выведет А.

Вывод команды будет выглядеть так:

Вложенные операторы if позволяют создать несколько дополнительных уровней кода и расширить его функции.

Операторы сравнения в Python

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

Предположим, переменная а
содержит значение 10, а переменная б
имеет значение 20, то:

оператор	Описание	пример
==	Если значения двух операндов равны, то условие становится истинным.	(а == б) не верно.
!=	Если значения двух операндов не равны, то условие становится истинным.	(а! = б) истинно.
>	Если значение левого операнда больше значения правого операнда, то условие становится истинным.	(а > б) не верно.
	Если значение левого операнда меньше значения правого операнда, то условие становится истинным.	(а
> =	Если значение левого операнда больше или равно значению правого операнда, то условие становится истинным.	(а >= б) не верно.
	Если значение левого операнда меньше или равно значению правого операнда, то условие становится истинным.	(а

Вложенные операторы If

Вложенные операторы if используются, когда нужно проверить второе условие, когда первое условие выполняется. Для этого можно использовать оператор if-else внутри другого оператора if-else. Синтаксис вложенного оператора if:

if statement1:              #внешний оператор if
    print("true")

    if nested_statement:    #вложенный оператор if
        print("yes")

    else:                   #вложенный оператор else 
        print("no")

else:                       #внешний оператор else 
    print("false")

Результатом работы программы может быть:

Если значение statement1 равно true, программа проверяет, равно ли true значение nested_statement. Если оба условия выполняются, результат будет следующим:

Вывод:

true
yes

Если statement1оценивается как true, но nested_statement оценивается как false, вывод будет уже другим:

Вывод:trueno

Значение statement1 равно false, а вложенный оператор if-else не будет выполняться, поэтому «сработает» оператор else:

Вывод:

false

Также можно использовать несколько вложенных операторов if:

if statement1:                  #внешний if 
    print("hello world")

    if nested_statement1:       #первый вложенный if 
        print("yes")

    elif nested_statement2:     # первый вложенный elif
        print("maybe")

    else:                       # первый вложенный else
        print("no")

elif statement2:                # внешний elif
    print("hello galaxy")

    if nested_statement3:       #второй вложенный if
        print("yes")

    elif nested_statement4:     # второй вложенный elif
        print("maybe")

    else:                       # второй вложенный else
        print("no")

else:                           # внешний else
    statement("hello universe")

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

Используем пример вложенных операторов if в программе grade.py.  Сначала проверим, является ли балл проходным (больше или равно 65%). Затем оценим, какой буквенной оценке соответствует балл. Но если балл непроходной, нам не нужно проверять буквенные оценки. И можно сразу информировать ученика, что балл является непроходным. Модифицированный код с вложенным оператором if:

if grade >= 65:
    print("Passing grade of:")

    if grade >= 90:
        print("A")

    elif grade >=80:
        print("B")

    elif grade >=70:
        print("C")

    elif grade >= 65:
        print("D")

else:
    print("Failing grade")

При переменной grade равной 92 первое условие будет выполнено, и программа выведет «Passing grade of:». Затем она проверит, является ли оценка больше или равной 90. Это условие также будет выполнено и она выведет A.

Если переменная grade равна 60, то первое условие не будет выполнено. Поэтому программа пропустит вложенные операторы if, перейдет к оператору else и выведет сообщение «Failing grade».

Но можно добавить еще больше вариантов и использовать второй слой вложенных if. Например, чтобы определить оценки A+, A и A-. Мы можем сделать это, сначала проверив, является ли оценка проходной, затем, является ли оценка 90 или выше. А после этого, превышает ли оценка 96 для A+, например:

if grade >= 65:
    print("Passing grade of:")

    if grade >= 90:
        if grade > 96:
            print("A+")

        elif grade > 93 and grade <= 96:
            print("A")

        elif grade >= 90:
            print("A-")

Для переменной grade со значением 96 программа выполнит следующее:

1. Проверит, является ли оценка больше или равной 65 (true).
2. Выведет «Passing grade of:»
3. Проверит, является ли оценка больше или равной 90 (true).
4. Проверит, превышает ли оценка 96 (false).
5. Проверит, является ли оценка больше 93, а также меньше или равна 96 (true).
6. Выведет
7. Пропустит оставшиеся вложенные условные операторы и вернется к остающемуся коду.

Результат работы программы для переменной grade равной 96:

Вывод:

Passing grade of:
A

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

Примеры решения задач

Проверить является ли клетка шахматной доски белой

# Два числа выбираются случайным образом (координаты клетки шахматного поля, от 1 до 8)
# Вывести YES, если клетка белая, и NO, если клетка черная
from random import randint

x = randint(1,8)

y = randint(1,8)
print(x, y)
if (x + y) % 2 == 1:

    print(‘YES’)
else:

    print(‘NO’)

Во втором случаем числа вводятся с клавиатуры

x = int(input(‘Введите координату x: ‘))

y = int(input(‘Введите координату y: ‘))
if (x + y) % 2 == 1:

    print(‘YES’)
else:

    print(‘NO’)

Проверить может ли слон ходить с первой шахматной на вторую

# Четыре числа выбираются случайным образом (координаты клетки шахматного поля, от 1 до 8)
# Вывести YES, если ладья может сходить с первой клетки на вторую, и NO, если не может
# Напомню, что ладья ходит так:
# Л ——X
# |
# |
# |
# X
from random import randint

x1 = randint(1, 8)

x2 = randint(1, 8)

y1 = randint(1, 8)

y2 = randint(1, 8)
print(x1, y1)
print(x2, y2)
if x1 == x2 and y1 != y2 or x1 != x2 and y1 == y2:

    print(‘YES’)
else:

    print(‘NO’)

То же самое, но с помощью ввода с клавиатуры

x1 = int(input(‘Введите координату x1: ‘))

x2 = int(input(‘Введите координату y1: ‘))

y1 = int(input(‘Введите координату x2: ‘))

y2 = int(input(‘Введите координату y2: ‘))
if x1 == x2 and y1 != y2 or x1 != x2 and y1 == y2:

    print(‘YES’)
else:

    print(‘NO’)

# Преобразование к логическому типу

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

1234

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

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

12

Возможно и обратное. Можно преобразовать какое-либо значение к булевому типу:

12345

И здесь работает правило: всё, что не и , является правдой: .

Методы словарей Python

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

d.get(ключ)

Метод get() позволяет получить значение. Ему нужно указать ключ для поиска. Можно вернуть значение по умолчанию, если ключ не будет найден. По умолчанию это None:

>>> print(sample_dict.get('address'))
None
>>> print(sample_dict.get('address', 'Not Found'))
Not Found

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

Во втором примере показано, как установить по умолчанию строку “Not Found”.

d.clear()

Метод clear() используется, чтобы удалить все элементы из словаря.

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> sample_dict
{'email': 'jdoe@gmail.com', 'first_name': 'James', 'last_name': 'Doe'}
>>> sample_dict.clear()
>>> sample_dict
{}

d.copy()

Чтобы создать простую копию словаря, используется метод copy().

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> copied_dict = sample_dict.copy()
>>> copied_dict
{'email': 'jdoe@gmail.com', 'first_name': 'James', 'last_name': 'Doe'}

Если в словаре есть объекты или словари, то можно столкнуться с логическими ошибками. Так как изменение одного словаря может повлиять на его копию. В этом случае необходимо использовать модуль Python copy, в котором есть функция deepcopy(). Она создаетотдельную копию словаря.

d.Items()

Метод items() возвращает новое представление из элементов словаря.

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> sample_dict.items()
dict_items()

Этот объект представления будет меняться по мере изменения самого словаря.

d.keys()

Чтобы получить представление ключей, которые есть в словаре, используется метод keys(). Он предоставляет динамическое представление ключей словаря. Можно представление, а также проверить принадлежность представлению по ключевому слову in.

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> keys = sample_dict.keys()
>>> keys
dict_keys()
>>> 'email' in keys
True
>>> len(keys)
3

d.values()

Метод values() возвращает объект динамического представления значений словаря.

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> values = sample_dict.values()
>>> values
dict_values()
>>> 'Doe' in values
True
>>> len(values)
3

d.pop(ключ)

Чтобы удалить ключ из словаря, используется метод pop(). Он принимает ключ и строку параметра по умолчанию. Если не установить значение по умолчанию и ключ не будет найден, то выведется ошибка KeyError.

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> sample_dict.pop('something')
Traceback (most recent call last):
Python Shell, prompt 146, line 1
builtins.KeyError: 'something'
>>> sample_dict.pop('something', 'Not found!')
'Not found!'
>>> sample_dict.pop('first_name')
'James'
>>> sample_dict
{'email': 'jdoe@gmail.com', 'last_name': 'Doe'}

d.popitem()

Метод popitem() используется для удаления и возвращает пары ключ-значение из словаря в порядке «последним добавлен — первым удален». Если метод вызывается в пустом словаре, то отобразится KeyError.

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> sample_dict.popitem()
('email', 'jdoe@gmail.com')
>>> sample_dict
{'first_name': 'James', 'last_name': 'Doe'}

d.update()

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

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> sample_dict.update()
>>> sample_dict
{'email': 'jdoe@gmail.com',
'first_name': 'James',
'last_name': 'Doe',
'something': 'else'}