Логические операторы в python

Содержание

На сегодняшний день Python является одним из самых популярных языков программирования. Это интерпретируемый высокоуровневый язык с элегантным и легко читаемым синтаксисом. Но Python, как правило, значительно медленнее, чем Java, C#, особенно C и C++, а также Fortran. И иногда вопросы производительности могут сильно влиять на возможность полноценно использовать приложения.

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

И наконец, всегда есть возможность написать функции Python на C, C++ или Cython и вызывать их потом из Python-приложения, ликвидировав таким образом узкие места в программе. Но это уже крайняя мера, и на практике так делать приходится редко.

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

В нашей статье мы будет сравнивать производительность различных способов поэлементного суммирования двух последовательностей. А именно:

  • с использованием цикла ;
  • с использованием цикла ;
  • с использованием представления списков;
  • с использованием библиотеки NumPy;

Но производительность это не главное при разработке программного обеспечения. Более того, как сказал Дональд Кнут в своей книге «Искусство программирования»: «Поспешная оптимизация — это корень всех (или почти всех) зол в программировании.» В конечном итоге, «важна читаемость (readability counts)». Это сказано в «Дзен Python» Тима Питерса.

Операции срезов

Срез — это не что иное, как способ обратиться к определенной части последовательности. В Python срезы позволяют нам проделывать различные трюки.

Разворот последовательности

# Разворот списков
lst = 

lst = lst

print(lst) # 

# Разворот строк

string = "Dog running on the park"

string = string

print(string) # krap eht no gninnur goD

Практический пример

Функция, возвращающая последовательность до заданного индекса:

def cutoff(seq, index):
    if not len(seq) > index:
        return "Sorry the index is bigger than the sequence"

    return seq

long_string = "This is a long description of a blog post about Python and technology"

print(cutoff(long_string, 15))
# This is a long 

print(cutoff(long_string, 70))
# Sorry the index is bigger than the sequence

Битовые операторы в 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)

Где используется Python и почему

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

К типичным областям использования Python относят:

  • Веб-разработка (сайты любой сложности и функциональности без проблем создаются при помощи данного языка);
  • Работа с базами данных (можно работать как с «встроенной» sqlite3, так и любыми другими – реляционными и нереляционными);
  • Графические приложения (реально не просто писать исполняемые скрипты, но и разрабатывать полноценные графические интерфейсы под свои нужды);
  • Научные задачи (сложные вычисления, машинное обучение, нейронные сети);
  • Сетевое программирование (включает не только взаимодействие с сайтами, но и почтовыми сервисами, JSON-объектами, Интернет-протоколами);
  • Бизнес-приложения и игровая индустрия (ERP-системы, непрерывная разработка и тестирование, простые игры).

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

Основные показаны ниже (рис. 1).

Сильные стороны языка Python

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

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

Скрипты на Python’e легко читать: нет лишних символов, нагромождения скобок, дополнительных уточнений.

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

Немаловажно и то, что исходный код Python свободно распространяется. Любая редакция языка доступна каждому как для личных, так и коммерческих нужд

Кроссплатформенность в дополнение ко всему гарантирует достижение идентичных результатов что на Windows, Linux, MacOS, так и на мобильных системах.

Отметим, также, ключевые плюсы и минуса Питона (таблица 1).

Плюсы Минусы
Легко изучать, писать и читать код Относительно медленный
Интерпретируемый (исполняет код на лету) Не всегда эффективно расходует память
Динамически типизированный Ограничен в мобильной разработке
С открытым исходным кодом При исполнении могут возникать ошибки, что требует тщательного тестирования
Имеет широкую поддержку  

Таблица 1 – Сильные и слабые стороны Python’a

Настройка оператора % для ваших собственных классов

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

Просто чтобы привести простой пример, который показывает, как это работает:

Этот пример не очень полезен, он просто печатает и затем делегирует оператор сохраненному значению, но он показывает, что вызывается, когда применяется к экземпляру:

Обратите внимание, что это также работает для без явной необходимости реализовать :

Однако вы также можете явно реализовать для перезаписи расширенного присваивания:

Теперь явно перезаписан для работы на месте:

# Упражнения

  1. Напишите следующую программу:

    • Присвойте двум переменным любые числовые значения.
    • с помощью оператора составьте два сложных логических выражения, одно из которых дает , другое – .
    • используя оператор составьте два сложных логических выражения, одно из которых дает , другое – .
  2. Составьте программу сравнения строковых переменных:

    • с пятью простыми разными логическими выражениями;
    • с четырьмя сложными логическими выражениями;
    • объясните результат.
  3. Напишите программу, которая спрашивает у пользователя: «What day of month is it?» И выводит — если день указан верно, и — если день указан не верно. Указанный день считается верным, если число от 1 до 31.

  4. Напишите программу, которая спрашивает у пользователя: «What number of month were you born?» И выводит — если месяц указан верно, и — если не верно. Указанный месяц считается верным, если число от 1 до 12.

Сложные логические выражения

Логические выражения типа являются простыми, так как в них выполняется только одна логическая операция. Однако, на практике нередко возникает необходимость в более сложных выражениях. Может понадобиться получить ответа «Да» или «Нет» в зависимости от результата выполнения двух простых выражений. Например, «на улице идет снег или дождь», «переменная news больше 12 и меньше 20″.

В таких случаях используются специальные операторы, объединяющие два и более простых логических выражения. Широко используются два оператора – так называемые логические И (and) и ИЛИ (or).

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

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

Допустим, переменной x было присвоено значение 8 (), переменной y присвоили 13 (). Логическое выражение будет выполняться следующим образом. Сначала выполнится выражение . Его результатом будет . Затем выполнится выражение . Его результатом будет . Далее выражение сведется к , что вернет .

>>> x = 8
>>> y = 13
>>> y < 15 and x > 8
False

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

В случае с оператором второе простое выражение проверяется, если первое вернуло ложь, и не проверяется, если уже первое вернуло истину

Так как для истинности всего выражения достаточно единственного , неважно по какую сторону от оно стоит

>>> y < 15 or x > 8
True

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

>>> not y < 15
False

Здесь возвращает . Отрицая это, мы получаем .

>>> a = 5
>>> b = 0
>>> not a
False
>>> not b
True

Число 5 трактуется как истина, отрицание истины дает ложь. Ноль приравнивается к . Отрицание дает .

Списки, кортежи, множества и словари

Списки, кортежи, множества и словари – еще 4 типа данных в Питоне, включающие в себя несколько значений и являющиеся итерируемыми (перебираемыми, как строки).

Особенности показаны в таблице 3.

Список (list) Кортеж (tuple) Множество (set) Словарь (dict)
Изменяемый Неизменяемый Изменяемое Изменяемый
Значения могут дублироваться Значения могут дублироваться Значения не могут дублироваться Ключи не могут дублироваться
Доступ по индексу возможен Доступ по индексу возможен Доступ по индексу невозможен Есть доступ к ключам и значениям

Таблица 3 – Коллекции данных в Python

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

Рассмотрим часть функционала.

Результат работы скрипта:

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

На их основании также возможны срезы, доступ по индексу, нахождение максимума или минимума (если элементы представлены числами), поиск количества вхождений значений.

Результат работы скрипта:

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

Важно и то, что порядок объектов внутри множества не гарантирован, что исключает доступ по индексу

Результат работы скрипта:

Словарь – особый тип коллекций. Все его элементы состоят из пар «ключ: значение». Ключ должен быть уникальным, а значения могут повторяться. Обозначается фигурными скобками.

Рассмотрим некоторые операции со словарями.

Результат работы скрипта:

Таким образом, в зависимости от ситуации применяется тот или иной тип коллекций. Чаще всего это списки и словари.

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

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

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

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

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

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.

Используем чистый Python

Начнем с двух списков по тысяче элементов в каждом. Целочисленная переменная равна длине этих списков. Списки и получены путем случайного выбора из списка .

n = 1_000
x, y = random.sample(r, n), random.sample(r, n)

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

%%timeit
i, z = 0, []
while i < n:
    z.append(x + y)
    i += 1

В результате получим:

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

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

%%timeit
z = []
for i in range(n):
    z.append(x + y)

Результатом будет:

В данном случае цикл не только работает быстрее, но и выглядит гораздо лучше, чем цикл .

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

%%timeit
z =  + y for i in range(n)]

В результате получим:

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

Использование библиотеки NumPy

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

На самом деле циклы, равно как и другие критичные для производительности операции, реализованы в NumPy на системном уровне. Именно это и позволяет функциям NumPy быть быстрее обычных функций языка Python. Еще одним преимуществом является то, как Numpy обрабатывает переменные и типы.

Давайте для начала создадим из списков целого типа Python и массивы NumPy типа integer 64-bit (целочисленный 64-х битный тип числа).

x_, y_ = np.array(x, dtype=np.int64), np.array(y, dtype=np.int64)

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

%%timeit
z = x_ + y_

Результат будет следующий:

Это почти в 85 раз быстрее, чем при использовании представления списков! И код крайне прост и красив. При работе с большими данными массивы NumPy — это самый лучший выбор. Причем, чем больше данных, тем больше выигрыш во времени.

И это не все. Если нам подходит 32-х битный целочисленный тип данных вместо 64-х битного, мы можем еще сэкономить не только память, но и время.

Точно так же теперь складываем два массива:

%%timeit
z = x_ + y_

И результат будет следующий:

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

% для чисел: операция по модулю / остаток / отдых

Знак процента — это . Это описано как:

Таким образом, он дает остаток / отдых, который остается , если вы «этаж разделить «х на у. Обычно (по крайней мере в Python) задается число и делитель :

Например, если вы разделите 5 на 2:

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

Вот как он используется в вашем примере, он не может быть простым, если он кратен другому числу (кроме себя и одного), вот что он делает:

Если вы чувствуете, что не очень описательный, вы можете поместить его в другую функцию с более описательным именем:

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

Подобно тому, как это часто используется, чтобы определить, является ли число «нечетным» или «четным»:

И в некоторых случаях он также используется для индексации массивов / списков, когда требуется поведение циклического (циклического) перебора, тогда вы просто модулируете «index» на «length массива», чтобы достичь этого:

Обратите внимание, что в стандартной библиотеке есть также функция для этого оператора (и псевдоним ):

Но есть также расширенное присваивание , которое присваивает результат переменной:

Присваивание

Операторы Python присваивают значение переменной.

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

Алгоритм работы:

  • вычисление левостороннего значения;
  • вычисление правостороннего значения;
  • присвоение одного значения другому — при конфликте типов должно быть осуществлено их приведение;
  • возврат результата операции — true или false.

И математической операции работают по такому принципу:

a x b, где x — это оператор, означает что a = a x b. Таким образом, a += b говорит о том, что значение переменной a прибавляется к значению переменной b, а их результат присваивается переменной a. То же самое происходит с другими примерами. Например, a **= b расшифровывается как a = a ** b, то есть a возводится в степень b, результат в итоге присваивается a.

Изучаем Python: куда дальше?

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

Какие темы освоить в первую очередь? Приводим список тем и команд для новичков:

  • типы данных в Python;
  • необязательные и ключевые аргументы функций (*args, **kwargs), лямбда-выражения (lambda);
  • объекты и классы, инициализация;
  • основные встроенные модули (functools, math, string, sys, os, collections, time);
  • генераторы и итераторы (yield, iter);
  • работа с разными файлами (csv, изображения, текст);
  • исключения и ошибки (exceptions);
  • списковые включения (list comprehension);
  • работа с сетью (requests, BeautifulSoup).

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

Потом стоит переходить к серьезным трудам (типа М. Лутца), ознакомлению с популярными фреймворками и библиотеками (Django, flask, pandas).

Отрицание логического значения в Python С помощью оператора not

Если вы не знаете о ключевом слове not, позвольте мне объяснить, что ключевое слово not является логическим оператором в Python. Особенность оператора not заключается в том, что он возвращает противоположное значение оператора. Это означает, что возвращаемое значение оператора not будет Истинным, если операторы не являются True; в противном случае он вернет False.

Давайте рассмотрим работу на примере.

Выход:

Приведенный выше пример прямолинейен для отрицания значения или выражения. Как видите, мы присвоили переменной значение True. После этого мы напечатали его, и наш вывод будет True, как и ожидалось. Но в следующей строке мы тоже использовали оператор not внутри функции print. Итак, на этот раз мы получаем вывод как False. Следовательно, мы успешно отрицаем логическое выражение с помощью оператора not в Python.

Выводы

В данной статье было произведено сравнение скорости работы циклов Python при поэлементном сложении списков или массивов. Результаты показывают, что представления списков работают быстрее обычных циклов , которые в свою очередь работают быстрее циклов . Простые циклы работают чуть-чуть быстрее вложенных (при одинаковом количестве элементов) во всех трех случаях.

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

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

Вывод

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

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

Счастливого Пифонирования!

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Adblock
detector