Чем заменить if в python

Используем Словари как Альтернативу Конструкции if-else

Причина

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

В этой статье мы сфокусируемся на использовании словарей в качестве альтернативы if-else выражениям.

Собираем конструкцию if-else с бонусом в виде значений по умолчанию

Представим, что у нас есть список с ценами продуктового магазина:

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

Шикарно. Оператор if-else делает именно то, что мы хотим: возвращает значение по умолчанию, когда элемент недоступен. Но мы дважды обращаемся к словарю и используем два оператора, чтобы вернуть почти одно и то же. Можем ли мы сделать лучше? Есть ли способ, который вернет значение по умолчанию в том случае, если элемент отсутствует в списке? К счастью, есть возможность сделать это с помощью метода словарей Python get()

Метод get() ищет ключ и возвращает значение по умолчанию если такого ключа не находит. Код определенно выглядит короче, но работает ли он так, как мы хотим?

Но могу ли я использовать словарь в функции, для замены if/else конструкции, которая не использует словари?

Хороший вопрос. Давайте рассмотрим пример, который абсолютно не использует словарь.

Представьте, что вы хотите создать функцию, которая возвращает значение для операции между 2 числами. Итак, вот что вы придумали:

Здесь использование словаря будет еще более впечатляющим:

Имена операторов становятся ключами, а lambda эффективно пихает функции в значения словарей. get() возвращает значение по умолчанию, когда ключ не найден.

Заключение

Поздравляем! Теперь вы узнали, как использовать словари в качестве альтернативы выражениям if-else. Итак, когда вы будете применять эти трюки? Если вы заметите, что операторы if-else будут повторяться, стоит задуматься. Возможно, именно там лучше будет смотреться словарь. Эта техника, конечно, не всегда будет полезна, но ведь приятно иметь дополнительную примочку в вашем наборе инструментов.

Источник

Чем заменить многократные elif

Сабж, собственно. Изучаю python и хочу узнать, можно ли более красиво и правильно сделать сие:

засунь данные значения в массив кортежей, типа

и пройдись по нему циклом

Только не циклом, а поиском делением пополам.

switch/case на словарях, кек

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

Ну не в смысле range, а список значений (list какой-нить), которые проверить нужно

примерно так должно быть:

И на одном уровне с for добавить else, для реализации того, что будет, если внутри цикла ни одно условие не выполнится

Не хватает вариантов с полюсами

можно просто перед циклом назначить p8 дефолтное значение. но так тоже пойдёт, а семантически даже правильнее. но может затруднить понимание кода для незнакомых с этой конструкцией людей, как мне сейчас

Сам на прошлой недели о ней узнал, тогда и пригодилась.

Комментарий о том, как это работает я при этом оставил

Советую Паскаль. Там всё просто:

Не любят на лоре такое, но всё-таки, если от кучи условий по указанным выше советам не избавиться, то вот так в функциональном стиле, сначала может и непривычно, но ориентироваться проще чем в ветках elif.

Всего 16 направлений. Таблица из 16 названий направлений. 360/16=22.5 град на направление или +/-11.25.

Анонимус как всегда лучший. В первом коменте сказали про бисект, а вы все равно глину месите.

Вот как с бисектом делается:

Ну. т.е. если убрать лишнее

Недостающие цифры и буквы сам добавишь

Ну зачем так явно разрушать питономирок.

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

Но ведь фортран лучше чем паскаль

+1 за дефолтное значение, это куда как более распространённая и ожидаемая практика.

UPD: сам тоже хорош, север не туда поставил.

Тут не нужны словари вообще.

Фортран просто много использовался разными математиками. А Паскаль создан профессором Никлаусом Виртом, которого наградили премией имени Тьюринга именно за создание Паскаля. Паскаль рулит.

А при чём тут словари? Иди перепиши своё решение на свич-кейсах ))

Которые тут тоже не нужны? Проспись.

Джон Бэкус (англ. John Warner Backus[1]; 3 декабря 1924 года — 17 марта 2007 года) — американский учёный в области информатики, руководитель команды создателей первого высокоуровневого языка программирования Фортран, изобретатель формы Бэкуса — Наура — одной из самых распространённых и универсальных нотаций для определения синтаксиса формальных языков, лауреат премии Тьюринга (1977).

Награда: За его глубокий, продолжительный и оказавший большое влияние вклад в проектирование практических высокоуровневых программных систем, в частности за его работу над языком Фортран, и его оригинальную публикацию по формализации спецификаций языков программирования

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

IMHO, лучше всё на 4 умножить, и работать исключительно в целых числах.

Так никто и не спорит. Однако, Фортран, в отличие от Паскаля, давно не развивается.

Почитай код внимательнее, обе претензии мимо.

UPD: По поводу границ ты прав, а я поспешил. Надо было так:

Источник

Оператор выбора в Python (if else)

Зачем нужны условные инструкции

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

Говоря простыми словами, конструкция if else в Python указывает интерпретатору, следует ли выполнять определенный участок кода или нет.

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

Как работает if else

Синтаксис

Оператор if else в языке Python — это типичная условная конструкция, которую можно встретить и в большинстве других языков программирования.

# самый простой пример, где есть всего одно условие a = 1 if a == 1: print(«It is true») > It is true

Синтаксически конструкция выглядит следующим образом:

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

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

Отступы

Отступы — важная и показательная часть языка Python. Их смысл интуитивно понятен, а определить их можно, как размер или ширину пустого пространства слева от начала программного кода.

# начало кода # код # код # код # начало первого отступа # первый отступ # первый отступ # начало второго отступа # второй отступ # второй отступ # конец второго отступа # конец первого отступа

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

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

Примеры

Рассмотрим несколько практических примеров использования условного оператора.

Пример №1 : создание ежедневного бэкапа (например базы данных):

Пример №2 : Проверка доступа пользователя к системе. В данном примере if проверяет наличие элемента в списке:

BLACK_LIST = [‘192.34.12.3’, ‘192.34.12.5’, ‘192.34.10.23’] USERS = [‘rolli34’, ‘constantinpetrovv’, ‘kate901’] def access_available(user_name, ip): if user_name in USERS: if ip not in BLACK_LIST: return True else: print(f»write to log: user [ip: ] in block list») else: print(f»write to log: user [ip: ] does not exists») return False if access_available(«rolli34», «192.34.12.111»): print(f»Hello!!») > Hello!! if access_available(«rolli34», «192.34.10.23»): print(f»Hello!!») > write to log: user rolli34 [ip: 192.34.10.23] in block list if access_available(«devnull», «192.34.10.11»): print(f»Hello!!») > write to log: user devnull [ip: 192.34.10.11] does not exists

Оператор elif

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

shinobi = ‘Naruto’ if shinobi == ‘Orochimaru’: print(‘fushi tensei’) elif shinobi == ‘Naruto’: print(‘RASENGAN’) elif shinobi == ‘Sasuke’: print(‘chidori’) > RASENGAN

Такая конструкция может содержать сколь угодно большую последовательность условий, которые интерпретатор будет по порядку проверять.

Но помните, что первое условие всегда задается с if

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

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

Если ни одно из условий для частей if и elif не выполняется, то срабатывает заключительный блок под оператором еlse (если он существует).

Заглушка pass

Оператор-заглушка pass заменяет собой отсутствие какой-либо операции.

Наличие тела инструкции в Python обязательно

sum = 100000 account_first = 12000 account_second = 360000 if account_first > sum: pass elif account_second > sum: pass else: print(sum)

if else в одну строку

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

В Python отсутствует тернарный оператор

Такая конструкция может показаться сложной, поэтому для простоты восприятия, нужно поделить ее на 3 блока:

Стоит ли использовать такой синтаксис? Если пример простой, то однозначно да:

# полная версия count = 3 if count

Вполне читаемо смотрятся и следующие 2 примера:

x = «Kate» if «Alex» in «My name is Alex» else «Mary» print(x) > Kate y = 43 if 42 in range(100) else 21 print(y) > 43

Но если вы используете несколько условий, сокращенная конструкция усложняется и становится менее читаемой:

x = 10 result = 100 if x > 42 else 42 if x == 42 else 0 print(result) > 0

Вложенные условия

Ограничений для уровней вложенности в Pyhton не предусмотрено, а регулируются они все теми же отступами:

# делать код менее читаемым можно до бесконечности def run(action): if action: print(some_func()) else: if some_func(): num = one_func() if num: if 0

Стоит ли использовать такие вложенности? Скорее нет, чем да. Одно из положений Python Zen гласит:

Flat is better than nested (развернутое лучше вложенного).

Большая вложенность имеет следующие недостатки:

Но что делать, если в скрипте не получается уйти от большой вложенности if-else? 🤷‍♂️

Чтобы уйти от большой вложенности, попробуйте не использовать оператор else

Пример выше, можно записать следующим образом:

def run(action): if action: print(some_func()) return if not some_func(): return num = one_func() if not num: return if 0

Конструкция switch case

В Python отсутствует инструкция switch case

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

Свято место пусто не бывает, поэтому в питоне такое множественное ветвление, в обычном случае, выглядит как последовательность проверок if-elif :

n = 5 if n == 1: print(n) elif n == 2: print(n) else: print(«There is no your number») > «There is no your number»

Однако есть и более экзотический вариант реализации этой конструкции, задействующий в основе своей python-словари :

number = 1 switch_dict = < 1: 1, 2: 2, 3: 3, >print(switch_dict.get(number, «There is no your number»)) > «There is no your number»

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

Источник

Python Tips, Tricks, and Hacks (часть 3)

4. Выбор значений

4.1. Правильный путь

Начиная с версии 2.5, Python поддерживает синтаксис «value_if_true if test else value_if_false». Таким образом, вы можете выбрать одно из двух значений, не прибегая к странному синтаксису и подробным пояснениям:

Увы, это всё еще немного некрасиво. Вы также можете использовать несколько таких конструкций в одной строке:

Сначала выполняется первый if/else, а если test1 = false, выполняется второй if/else. Вы можете делать и более сложные вещи, особенно если воспользуетесь скобками.

Этот способ весьма новый, и я испытываю к нему смешанные чувства. Это правильная, понятная конструкция, она мне нравится… но она всё еще уродлива, особенно при использовании нескольких вложенных конструкций. Конечно, синтаксис всех уловок для выбора значений некрасив. У меня слабость к описанному ниже способу с and/or, сейчас я нахожу его интуитивным, сейчас я понимаю, как он работает. К тому же он ничуть не менее эффективен, чем «правильный» способ.

Хотя инлайновый if/else — новый, более правильный способ, вам всё же стоит ознакомиться со следующими пунктами. Даже если вы планируете использовать Python 2.5, вы встретите эти способы в старом коде. Разумеется, если вам нужна обратная совместимость, будет действительно лучше просмотреть их.

4.2. Уловка and/or

«and» и «or» в Python — сложные создания. Применение and к нескольким выражениям не просто возвращает True или False. Оно возвращает первое false-выражение, либо последнее из выражений, если все они true. Результат ожидаем: если все выражения верны, возвращается последнее, являющееся true; если одно из них false, оно и возвращается и преобразуется к False при проверке логического значения.

Аналогично, операция or возвращает первое true-значение, либо последнее, если ни одно из них не true.

Это вам не поможет, если вы просто проверяете логическое значение выражения. Но можно использовать and и or в других целях. Мой любимый способ — выбор значения в стиле, аналогичном тернарному оператору языка C «test? value_if_true: value_if_false»:

Внимание, будьте осторожны со средним значением («if_true»). Если оно окажется false, выражение с or будет всегда пропускать его и возвращать последнее значение («if_false»), независимо от значения test.

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

Конечно, если вам нужна совместимость с предыдущими версиями Python, «правильный» способ не будет работать. В этом случае and/or — лучший выбор в большинстве ситуаций.

4.3. True/False в качестве индексов

Другой способ выбора из двух значений — использование True и False как индексов списка с учетом того факта, что False == 0 и True == 1:

Этот способ более честный, и value_if_true не обязано быть true. Однако у него есть существенный недостаток: оба элемента списка вычисляются перед проверкой. Для строк и других простых элементов это не проблема. Но если каждый из них требует больших вычислений или операций ввода-вывода, вычисление обоих выражений недопустимо. Поэтому я предпочитаю обычную конструкцию или and/or.

Также заметьте, что этот способ работает только тогда, когда вы уверены, что test — булево значение, а не какой-то объект. Иначе придется писать bool(test) вместо test, чтобы он работал правильно.

5. Функции

5.1. Значения по умолчанию для аргументов вычисляются только один раз

Начнем этот раздел с предупреждения. Эта проблема много раз смущала многих программистов, включая меня, даже после того, как я разобрался в проблеме. Легко ошибиться, используя значения по умолчанию:

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

Решение проблемы: не используйте изменяемые объекты в качестве значений по умолчанию. Вы можете оставить всё как есть, если не изменяете их, но это плохая идея. Вот как следовало написать предыдущий пример:

None неизменяем (в любом случае, мы не пытаемся его изменить), так что мы обезопасили себя от внезапного изменения дефолтного значения.

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

5.1.1. Заставляем дефолтные значения вычисляться каждый раз

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

Просто примените этот декоратор к функции, чтобы получить ожидаемые результаты:

5.2. Переменное число аргументов

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

Зачем это нужно? Например, функция должна принимать несколько элементов и делать с ними одно и то же (например, складывать). Можно заставить пользователя передавать функции список: sum_all([1,2,3]). А можно позволить передавать произвольное число аргументов, тогда получится более чистый код: sum_all(1,2,3).

Функция также может иметь переменное число именованных аргументов. После определения всех остальных аргументов укажите переменную с «**» в начале. Python присвоит этой переменной словарь полученных именованных аргументов, кроме обязательных:

Зачем так делать? Я считаю, самая распространенная причина — функция является оберткой другой функции (или функций), и неиспользуемые именованные аргументы могут быть переданы другой функции (см. п. 5.3).

5.2.1. Уточнение

Использование именованных аргументов и произвольного числа обычных аргументов после них, по-видимому, невозможно, потому что именованные аргументы должны быть определены до «*»-параметра. Например, представим функцию:

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

Единственный способ задать actually_print в этой ситуации — передать его как обычный аргумент:

5.3. Передача списка или словаря в качестве нескольких аргументов

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

А для словаря (что используется чаще) нужно поставить две звездочки:

Историческая справка: в Python до версии 2.3 для этих целей использовалась встроенная функция apply (function, arg_list, keyword_arg_dict)’.

Источник

Оператор if else в Python

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

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

Операторы управления бывают следующих типов:

В этом уроке речь пойдет о первых трех операторах управления.

Оператор if

Синтаксис оператора if следующий:

Стоит обратить внимание, что у каждой инструкции в блоке if одинаковый отступ от слова if. Многие языки, такие как C, C++, Java и PHP, используют фигурные скобки ( <> ), чтобы определять начало и конец блока, но в Python используются отступы.

Когда выполняется инструкция if, проверяется условие. Если условие истинно, тогда все инструкции в блоке if выполняются. Но если условие оказывается неверным, тогда все инструкции внутри этого блока пропускаются.

Инструкции следом за условием if, у которых нет отступов, не относятся к блоку if. Например, — это не часть блока if, поэтому она будет выполнена в любом случае.

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

Рассмотрим следующий код:

Здесь важно обратить внимание, что только выражения на строках 3, 4 и 5 относятся к блоку if. Следовательно, они будут исполнены только в том случае, когда условие if будет истинно. Но инструкции на строках 7 и 8 выполнятся в любом случае.

Консоль Python реагирует иначе при использовании операторов управления прямо в ней. Стоит напомнить, что для разбития выражения на несколько строк используется оператор продолжение ( \ ). Но в этом нет необходимости с операторами управления. Интерпретатор Python автоматически активирует мультистрочный режим, если нажать Enter после условия if. Например:

Чтобы закончить инструкцию if, нужно добавить еще одну инструкцию в блок if:

Python не будет автоматически добавлять отступ. Это нужно сделать самостоятельно. Закончив ввод инструкции, нужно дважды нажать Enter, чтобы исполнить инструкцию. После этого консоль вернется к изначальному состоянию.

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

Оператор if-else

Оператор if-else исполняет одну порцию инструкций, если условие истинно и другое — если нет. Таким образом этот оператор предлагает два направления действий. Синтаксис оператора if-else следующий:

Пример 1: программа для расчета площади и длины окружности круга.

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

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

Если попробовать запустить эту программу, то появится следующая ошибка:

Для исправления проблемы нужно вертикально выровнять if и else

Пример 2: программа для проверки пароля, введенного пользователем.

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

Использовать операторы if-else можно внутри других инструкций if или if-else. Это лучше объяснить на примерах:

Оператор if внутри другого if-оператора

Пример 1: программа, проверяющая, имеет ли студент право на кредит.

Здесь оператор if используется внутри другого if-оператора. Внутренним называют вложенный оператором if. В этом случае внутренний оператор if относится к внешнему блоку if, а у внутреннего блока if есть только одна инструкция, которая выводит “Поздравляем, вам выдан кредит”.

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

Пример 2: инструкция if-else внутри другого оператора if.

Эта программа работает та же, как и предыдущая. Единственное отличие — у вложенного оператора if теперь есть инструкция else. Теперь если ввести балл GRE меньше, чем 150, программа выведет: “У вас низкий кредитный лимит”

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

Оператор if-else внутри условия else

Пример 3: программа для определения оценки студента на основе введенных баллов.

Хотя вложенные операторы if-else позволяют проверять несколько условий, их довольно сложно читать и писать. Эти же программы можно сделать более читабельными и простыми с помощью if-elif-else.

Оператор if-elif-else

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

Перепишем программу с помощью if-elif-else.

Источник