Как посчитать количество четных чисел в питоне

Не могу составить код который будет вычислять четное/нечетное число на python

Суть кода в том что — ‘Пользователь вводит число (a). Найти количество всех нечетных чисел, на диапазоне
Я настрогал пару строчек кода, но все равно не выходит в ответе. Когда ввожу даже 1 число просто ничего не выводиться, и даже причину не могу понять.

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

Введённое значение преобразовать в число при помощи функции int() .
Проверять остаток от деления a % 2 == 0 .
Ну и функцию таки следует вызвать sum() .

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

Нажимая «Принять все файлы cookie» вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.

Name already in use

py_training_ru / lecture_04.md

Go to file T
Go to line L
Copy path
Copy permalink

Open with Desktop
View raw
Copy raw contents Copy raw contents

Copy raw contents

Лекция 4. Циклы. Операторы присваивания с модификацией. Логический тип данных. Строки

Значки, используемые в тексте

�� — отмечает, что высказывание не совсем верно, но будет уточнено позднее.
⭐ — выделяет определение нового понятия.
❗ — привлекает внимание к высказыванию.
☝️ — указывает на небольшое отступление от темы или уточнение.
�� — индикатор традиций и договорённостей.
⚠️ — требуется осторожность: возможно, сложное высказывание.

Повторение терминов из третьей лекции

Функция — это сущность, которая может принимать значения и возвращать результат.
Функция input() — это функция, запрашивающая ввод значения пользователем.
Функции abs(x) , min(x, y, . ) , max(x, y, . ) , round(x) и round(x, N) — встроенные функции в Python.
Пользовательские функции — функции, объявляемые в программах с использованием ключевого слова def .
Контекст вызова и контекст объявления функции — состояние программы в моменты соответственно вызова и объявления функции, то есть набор доступных функции переменных: в качестве аргументов или для использования в теле функции.
Утверждение return — утверждение, указывающее интерпретатору на окончание выполнения функции и необходимость возврата предоставленного выражения в контекст вызова в качестве результата.
Константы — переменные, объявляемые один раз и используемые в дальнейшем только для вычислений, имеющие специальное оформление идентификаторов в заглавном регистре.
Объект None («ничто») — объект, возвращаемый функцией в случае отсутствия в ней утверждения return или неполучения им управления (программа до него «не дошла»).

Циклический алгоритм. Цикл while

Мы с вами уже не раз встречались с заданиями, в которых требовалось повторить одно и то же действие несколько раз: ввести несколько значений, сравнить несколько чисел (найти максимум или минимум), посчитать значения, соответствующие условию. Часто подобные операции однотипны и повторяются по определённому шаблону. Например, умножение на N — это повторение операции сложения N раз, возведение в степень — это повторение операции умножения, а посчитать количество чётных чисел из набора заданных — это повторение операции присваивания с увеличением счётчика на единицу, если число делится на 2 без остатка.

Попробуем записать это в псевдокоде:

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

В Python эта возможность является элементарной и обеспечивается конструкцией while — «пока», и выглядит она так:

⭐ Конструкция цикла while — это сложное утверждение, вводимое ключевым словом while и указывающее на повторение содержащегося в нём блока кода до тех пор, пока выполняется заданное в ней условие.

Смысл данной конструкции такой: вначале проверяется УСЛОВИЕ, если оно верно, то выполняется БЛОК_КОДА (тело цикла), в котором изменяются используемые в условии значения; затем снова проверяется условие, и так до тех пор, пока оно верно; затем управление переходит к следующему утверждению. Если условие изначально неверно, то весь БЛОК_КОДА пропускается.

Продемонстрируем цикл на следующем задании: вывести числа от 1 до 10.

Эта конструкция очень похожа на if -конструкцию, с той лишь разницей, что блок кода в if -утверждении выполняется 0 или 1 раз, а в while -утверждении — 0 или более раз.

⭐ Одно выполнение цикла называется итерацией, таким образом цикл состоит из 0 или более итераций.

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

Операторы присваивания «на месте» (in-place). Оператор остатка от деления по модулю %

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

Также существуют вычитание с модификацией: x -= y , умножение: x *= y , деление: x /= y , и возведение в степень: x **= y .

В задании к прошлой лекции мы вычисляли остаток от деления по модулю. Впрочем, в Python уже есть и такой оператор:

означает остаток от деления x на y (как целочисленного, так и вещественного). И для него есть аналогичный оператор присваивания «на месте»:

☝️ В других ЯП типа С, помимо указанных операторов, существуют и операторы ++ и — (увеличить и уменьшить на 1). В Python такого оператора намеренно нет, чтобы всегда сохранять явность операнда.

Логический тип данных

Теперь мы можем записать наш пример по подсчёту чётных чисел на Python во всей красе. ⚠️ Для краткости (и также ради демонстрации техники работы с циклами) мы не будем вводить отдельный счётчик цикла, а сразу уменьшать введённую нами переменную количество_проверок, пока она не достигнет 0:

Если мы введём первое число 5, то условие inputs_count > 0 в утверждении while проверится 6 раз, и на 6-й раз оно будет неверно. Также мы проверяем в теле цикла условие x % 2 == 0 , и если оно верно применительно к введённому в текущей итерации x , увеличиваем счётчик чётных чисел.

Мы уже не раз использовали слова «верно» или «неверно» применительно к условиям, и как оказывается, в Python существует тип данных специально для таких понятий.

Мы можем выразить «счётчик чётных чисел» простым языком: количество чётных чисел во множестве равно сумме раз, когда число чётное. Если обозначить результат проверки каждого числа за 1 («раз»), если оно чётное (условие «верно») и 0, есло оно нечётное («неверно»), сумма этих результатов и будет искомым счётчиком. Например, для множества чисел 2, 3, 5, 8, 13, это будет суммой 1 + 0 + 0 + 1 + 0 = 2.

И действительно, в Python существует логический тип данных (так называемый Булевский или «булев» тип, по имени изобретателя логической алгебры Джорджа Буля), который состоит из двух значений, являющихся встроенными в язык объектами True (истинно, верно) и False (ложно, неверно). При этом, True — это «надстройка» над 1, а False — «надстройка» над 0. Что это значит, мы узнаем буквально через пару строк.

❗ Результатом любой операции сравнения является булев объект True или False .

Записав в интерактивном python условное выражение, мы увидим именно булев результат:

А вот и объяснение про магическую надстройку:

Фактически, мы можем использовать True и False вместо 1 и 0. Конечно, там, где это уместно. В нашем примере мы спокойно можем заменить if -конструкцию на одно утверждение присваивания с модификацией:

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

☝️ И всё-таки так писать не рекомендую, ибо эта форма записи часто не интуитивна и сбивает с толку.

Приведение выражений к булеву типу

Мы выяснили, что можно использовать True вместо 1, False вместо 0. Можно ли наоборот? Да, можно:

То есть, в блоке УСЛОВИЕ в if -конструкции допускается число. С 0 и 1 всё понятно — будут использоваться их булевы эквиваленты, а что же с другими числами? Ответ прост: любое число, кроме 0, считается в контексте «УСЛОВИЕ» истинным. Этот ответ выводится из булевой алгебры, а именно логических операций И и ИЛИ, которые являются аналогами соответственно умножения и сложения.

☝️ Для доказательства, давайте немного вспомним алгебру логики. Это нам пригодится чуть позже. Итак, у нас существует выражения, которые могут иметь значение ИСТИНА или ЛОЖЬ, и три определённых над ними операции: И, ИЛИ, НЕ. Таким образом, например, НЕ ИСТИНА = ЛОЖЬ, ИСТИНА ИЛИ ЛОЖЬ = ИСТИНА, ЛОЖЬ И ИСТИНА = ЛОЖЬ и т.п. (Подробнее см. Алгебра логики.)

Возьмём два положительных числа A и B. Обозначим, в контексте доказательства, логическую операцию И как * , а операцию ИЛИ как + .

А * В всегда ненулевое (выражение А И В истинно, если истинны и А, и В), в то же время А * 0 == В * 0 == 0 .
А + В равно нулю только если А == В == 0 ( А ИЛИ В истинно, если хоть одно из А и В истинно), в то же время А + 0 == А , В + 0 == В .

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

На отрицательные числа распространяется то же правило — любое ненулевое отрицательное число истинно. Это следует из того, что арифметическое понятие знака для логического выражения не имеет смысла и не меняет значения его истинности. (Существующая логическая операция отрицания, НЕ, арифметически может быть эквивалентна выражению 1 — A для А из множества логических значений 0 и 1.)

❗ Помимо чисел, мы уже знаем ещё один тип данных, к которому принадлежит объект None . Так вот, объект None в логическом контексте эквивалентен значению False .

В Python, неудивительно, поддерживается и набор логических операторов, которые мы перечислили выше, только записываются они на английском языке. Эти операторы: И — and , ИЛИ — or , НЕ — not , где and , or , not — ключевые слова. Операторы and и or принимают по 2 операнда, а not , как и оператор изменения знака — , является унарным правоассоциативным (относится к выражению справа от себя).

Их используют для того, чтобы в одном блоке УСЛОВИЕ можно было указать несколько выражений. Например:

Порядок вычисления таков: это операторы с самым низким приоритетом, ниже операторов сравнения. При этом они выполняются последовательно так же, как и читаются:

Приоритет вычислений можно, как обычно, изменять скобками.

☝️ Выражения вида not x == y предпочтительнее записывать в виде x != y , т.е. менять оператор сравнения на противоположный по смыслу. Но в некоторых редких случаях нагляднее бывает использовать not .

Вычисление выражений с логическими операторами

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

если x = 0 , то очевидно, что условие уже никак не сможет быть истинным. То есть, два следующих выражения, в принципе, можно и не вычислять. Для x = 20 , достаточно двух первых выражений, чтобы сказать, что всё условие будет эквивалентно False .

Python поступает точно так же: он не вычисляет «ненужные» выражения-операнды. «Ненужность» определяется во время вычисления, то есть когда получено достаточно информации о том, что дальнейшие выражения не повлияют на результат условия.

❗ Если одного из двух операндов операторов and и or достаточно для определения истинности всего выражения, то результатом всего выражения будет результат этого операнда, и вычисление второго операнда не состоится. В противном случае результатом выражения будет результат второго операнда.

Выше мы упомянули о том, что условие необязательно должно иметь булев тип: это может быть и арифметическое выражение, и объект типа None , и т.п. Логические операторы and и or в Python имеют одну важную особенность:
они всегда сохраняют тип выражений-операндов, в отличие от not — выражение, начинающееся с not , всегда будет иметь булев тип.

Результатом составного выражения с and или or будет «чистый» результат того из выражений, которое должно быть вычислено исходя из правил логики после приведения выражений к логическому типу.

Так, например, значением выражения 0 and 1 будет целое число 0 , а не False ; 0 or 1 — 1 , а не True ; 5 and 0 or None — None и т.п.; выражение not 0 , однако, будет равно True , not 1 — False , как и not 5 и not -10 , то есть not возвращает булево значение, противоположное уже приведённому к булеву типу.

Мы с вами уже, пожалуй, достаточно хорошо знаем арифметику и различные элементы синтаксиса Python, чтобы перейти к изучению строк. Строковые данные в Python представлены двумя типами, str и unicode , пока рассмотрим первый.

⭐ Строка — это упорядоченная последовательность любых символов. При использовании в строках (и не только) символов кириллицы необходимо помнить о требовании указания кодировки с помощью комментария coding: utf-8 в первой строке программы. (В интерактивном режиме кодировка берётся из окружения и чаще всего уже установлена в utf-8.)

Строковые литералы в Python записываются с помощью кавычек и апострофов:

Данные две строки абсолютно эквивалентны, и их единственным отличием является возможность вставки апострофа в строку с кавычками и кавычек в строку с апострофом. (Кавычки и апострофы можно вставлять в любую строку, если при этом «экранировать» эти символы с помощью вставки перед ними символа \ (обратный слэш):

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

Для того, чтобы не было необходимости экранировать большие количества кавычек, можно воспользоваться ещё одной парой способов объявления строк — тройными кавычками или тройными апострофами:

(Однако надо иметь в виду, что четыре кавычки или апострофа подряд не будут распознаны корректно, поэтому в таких случаях их нужно экранировать!)

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

У утверждения print существует также возможность выводить несколько разных объектов в одном утверждении, разделяя их запятыми (при выводе они будут отделены пробелами):

Операции со строками

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

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

В данном случае плейсхолдер %s будет заменён на значение 1 .

Для того, чтобы явно преобразовать выражение в булев тип (узнать его булево значение), существует функция bool(expr) , возвращающая всегда булев тип, в соответствии со значением истинности выражения:

Такие же функции есть и для целого числа — int() , и для дробного — float() . Но их аргументом может быть только численный или булев тип, либо численная строка, в противном случае возникнет ошибка TypeError или ValueError:

Также почти любой тип данных можно преобразовать в строку с помощью функции str() — фактически именно это происходит, когда мы передаём нестроковые аргументы в утверждение print :

И то же преобразование в строку происходит при передаче значения в интерполяции:

Улучшенная функция input()

Мы много раз сталкивались с тем, что функция input() при вызове из программы просто ожидает ввода, но пользователю не всегда понятно, что происходит и что делать. Для того, чтобы явно показать, что программа ожидает ввода, функция input() принимает один аргумент — строку, которая будет выведена перед запросом на ввод.

Так гораздо понятнее, что программа не «висит», а ждёт ввода.

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

Посчитать чётные и нечётные цифры числа на Python

Статьи

Введение

В ходе статьи напишем программу для подсчёта чётных и нечётных цифр в числе на языке программирования Python.

Написание кода программы для подсчёта чётных и нечётных цифр числа

Для начала дадим пользователю возможность ввода числа и создадим две переменные, одна для чётных цифр, вторая для нечётных:

Создадим цикл while, который не закончится пока number > 0:

Внутри цикла зададим условие, если number делится на 2 без остатка, то цифра чётная и прибавляем к even единицу, если условие не сработало, то цифра нечётная и прибавляем единицу к odd:

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

Выведем результат используя форматирование f-string:

Введите число: 9876124
Количество чётных цифр: 4
Количество нечётных цифр: 3

Заключение

В ходе статьи мы с Вами написали программу для подсчёта чётных и нечётных цифр в числе на языке программирования Python. Надеюсь Вам понравилась статья, желаю удачи и успехов! ��

Посчитать нечетные цифры числа методом рекурсии?

Vindicar

И у вас все равно будут выводиться нули. Объявляйте переменные even odd вне функции и передавайте их в эту функцию в качестве параметра.

Если у вас python 3.6 и выше, то там завезли f-строки. Они поудобнее, ваш вывод был бы более читабелен
print(f»четных — , нечетных — «) (return в этой строке не нужен, как и в остальных случаях)

А рекурсивно — это требование задачи? Или вы посчитали, что так будет лучше?