Целая часть числа питон

Целая часть числа питон

В программировании мы всегда взаимодействуем с данными, которые не являются какой-то абстрактной субстанцией. Все данные разделяются по определенному типу. На предыдущих уроках мы узнали, про строки, списки, словари и о логическом типе данных. Сегодня, поговорим о самом базовом типе данных в Python — числах.

Почему нельзя свалить все данные в одну общую кучу и не заморачиваться с каждым типом по отдельности? Допустим, мы присвоили переменной a цифру 5: a = 5. А теперь представьте, что никакого разделения по типу данных нет. Так что находится в переменной: число или строка? Если 10 — это число, то с ним можно произвести математические действия. А если это строка, то мы имеем дело с текстом и тогда Python задействует совсем другие методы.

# объединение строк (конкатенация)
d = ’10’
f = ‘негритят’
d + ‘ ‘ + f
’10 негритят’

Ключевой момент: У каждого типа данных свои методы.

Цифра 100 написанная без кавычек, относится к числовому типу данных. А цифра ‘100’ в кавычках — к строковому типу. С помощью синтаксиса, мы сообщаем Python, какой у нас тип данных. Числа в Python делятся на два вида: целое число и вещественное.

Целое число

К целым числам (int) относятся все положительные и отрицательные числа без дробной части. Все положительные целые числа называются натуральными.

-80, -10, -4, 0, 1, 2, 20

Вещественное число

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

Математические операции с числами

Ради математических вычислений в Python и существует числовой тип данных.

Сложение чисел

e = 45 + 55
print(e)
100

Вычитание чисел

Умножение чисел

Деление чисел

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

Целочисленное деление

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

Остаток от деления

Ответом будет остаток от деления. При обычном делении, ответ был бы 15.1. Но нам нужен только остаток. Убираем целое число и оставляем 1.

n = 16 % 3
print(n)
1

Возведение числа в степень

Число перед двумя звездочками — это объект, который нужно возвести в степень. Цифра после звездочек обозначает, в какую степень возводим: 4 возводим во вторую степень.

l = 4 ** 2
print(l)
16

В Python есть встроенные математические функции.

Модуль числа

Функция abs() находит модуль числа. Передаем в параметрах одно значение. Если передаваемое значение отрицательное, то abs() вернет положительное число. Модуль числа не может быть отрицательным.

Наименьшее число

Функция min() в Python возвращает самое маленькое число.

Максимальное число

Функция max() вернет самое большое число.

Округление до целого числа

Функция round() округляет до целого числа.

Вывести число в Python

Функция print() выводит числа на экран.

Ввести число в Python

Функция input() считывает вводимое значение пользователем в консоль и сохраняет его в переменной. Но что произойдет, если мы введем какое-нибудь число и затем обратимся к переменной?

>>> r = input()
33
>>> r
’33’ # это строка

Python вывел строку, так как число стоит в кавычках.

Для ввода целого числа, следует обернуть функцию input() в другую функцию int().

Для вещественного числа, соответственно в float().

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

В команде input() можно передавать подсказки.

w = int(input("Введите первое число: "))
q = int(input("Введите второе число: "))
summa=w+q
print(summa)

Введите первое число: 6
Введите второе число: 7
13

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

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

Порекомендуйте эту статью друзьям:

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

Она выглядит вот так:

  • BB-код ссылки для форумов (например, можете поставить её в подписи):
  • Комментарии ( 0 ):

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

    Copyright © 2010-2020 Русаков Михаил Юрьевич. Все права защищены.

    Числа в Python 3: целые, вещественные, комплексные. Работа с числами и операции над ними.

    Целые числа (int)

    Числа в Python 3 ничем не отличаются от обычных чисел. Они поддерживают набор самых обычных математических операций:

    Читайте также:  Чем выровнять пол в коридоре
    x + y Сложение
    x — y Вычитание
    x * y Умножение
    x / y Деление
    x // y Получение целой части от деления
    x % y Остаток от деления
    -x Смена знака числа
    abs(x) Модуль числа
    divmod(x, y) Пара (x // y, x % y)
    x ** y Возведение в степень
    pow(x, y[, z]) x y по модулю (если модуль задан)

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

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

    Над целыми числами также можно производить битовые операции

    x

    x | y Побитовое или
    x ^ y Побитовое исключающее или
    x & y Побитовое и
    x > y Битовый сдвиг вправо
    Инверсия битов

    Дополнительные методы

    int.bit_length() — количество бит, необходимых для представления числа в двоичном виде, без учёта знака и лидирующих нулей.

    int.to_bytes(length, byteorder, *, signed=False) — возвращает строку байтов, представляющих это число.

    classmethod int.from_bytes(bytes, byteorder, *, signed=False) — возвращает число из данной строки байтов.

    Системы счисления

    Те, у кого в школе была информатика, знают, что числа могут быть представлены не только в десятичной системе счисления. К примеру, в компьютере используется двоичный код, и, к примеру, число 19 в двоичной системе счисления будет выглядеть как 10011. Также иногда нужно переводить числа из одной системы счисления в другую. Python для этого предоставляет несколько функций:

    • int([object], [основание системы счисления]) — преобразование к целому числу в десятичной системе счисления. По умолчанию система счисления десятичная, но можно задать любое основание от 2 до 36 включительно.
    • bin(x) — преобразование целого числа в двоичную строку.
    • hex(х) — преобразование целого числа в шестнадцатеричную строку.
    • oct(х) — преобразование целого числа в восьмеричную строку.

    Вещественные числа (float)

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

    Для высокой точности используют другие объекты (например Decimal и Fraction)).

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

    Простенькие примеры работы с числами:

    Дополнительные методы

    float.as_integer_ratio() — пара целых чисел, чьё отношение равно этому числу.

    float.is_integer() — является ли значение целым числом.

    float.hex() — переводит float в hex (шестнадцатеричную систему счисления).

    classmethod float.fromhex(s) — float из шестнадцатеричной строки.

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

    Модуль math предоставляет более сложные математические функции.

    Модуль random реализует генератор случайных чисел и функции случайного выбора.

    Комплексные числа (complex)

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

    Также для работы с комплексными числами используется также модуль cmath.

    Числа в языке Python представлены тремя встроенными типами: целые ( int ), вещественные ( float ) и комплексные ( comlex ), а так же двумя типами чисел, которые предоставляет его стандартная библиотека: десятичные дроби неограниченной точности ( Decimal ) и обыкновенные дроби ( Float ).

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

    Начнем с того, что числовые литералы не содержат знаки " + " и " — ", т.е. с точки зрения Python число (-3.14) не является единым отрицательным числом, а является командой, которая состоит из унарного оператора ( — ) и числа (3.14). Это говорит о том, что знаки " + " и " — " хоть и способны обозначать положительные и отрицательные числа, но на самом деле эти знаки являются операторами:

    Помимо этого, числа встроенных типов (int, float и complex) относятся к немутирующим (неизменяемым) объектам, т.е. объектам чья структура не может быть изменена напрямую. Нельзя изменить какую-нибудь цифру существующего числа, нельзя расставить его цифры в обратном порядке. То что кажется изменением числа, на самом деле таковым не является. Например:

    Вроде бы мы создали объект-число со значением (1), а затем изменили его значение на (0). Но если это так, то id объекта (его адрес в памяти) не должен меняться, а он меняется:

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

    Читайте также:  Эжд мрко электронный дневник

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

    А если результат не может быть выражен типами int и float, то он будет преобразован к типу complex. Так что если вдруг будете вычислять корни четной степени из отрицательных чисел, не ждите ошибки:

    Причем такое преобразование работает только в одну сторону int -> float -> complex :

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

    Целые числа (int)

    В самом общем смысле, целые числа — это самые обыкновенные целые числа со знаком или без, например: (-11, 126, 0) или (401734511064747568885490523085290650630550748445698208825344). Последнее число в примере может показаться несовсем правдоподобным, но это (2^<198>), в чем очень легко убедиться:

    Да, длинная арифметика, нам доступна, что называется "из коробки". А это, надо сказать, очень приятный бонус, например, вы можете легко убедиться в том что (561) — число Кармайкла, действительно проходит тест Ферма:

    Однако, если вы попытаетесь проверить это для числа (9746347772161), то результата придется ждать очень долго (если вообще дождемся), вероятнее всего компьютер "встанет колом" и его придется перезагружать. Но вот если воспользоваться встроенной функцией pow() , то результат будет получен моментально:

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

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

    Вещественные числа (float)

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

    В качестве примера возьмем число (sqrt<2>), которое является вещественным потому что мы никогда не сможем выразить его с помощью обыкновенной дроби. А если мы все-таки извлечем корень из двойки, то обнаружим, что это бесконечная десятичная дробь. Но вычислив этот корень на Python:

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

    На самом деле, работая с числами с плавающей точкой, мы очень часто подразумеваем числа вещественные, например вот такое число (sqrt[77]<7>), его мы увидим в виде конечной десятичной дроби:

    А число (7^<-77>) в виде мантисы (8.461569363277291) (опять же конечной десятичной дроби) и порядка (-66):

    Кстати, можно было бы подумать, что 8.461569363277291*10**(-66) вернет результат идентичный предыдущему, но:

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

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

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

    Комплексные числа (complex)

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

    Читайте также:  Инвайт код для ворлд оф варшипс

    Комплексное число (z) – это число вида (a+bi), где (a) – действительная часть, (b) – мнимая часть, а (i) – мнимая единица. В Python комплексное число представляется в схожем виде a ± bj , где a и b могут быть любыми числами типа int и float, а j обозначает мнимую единицу, например:

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

    при (z=1+1j), то знайте – в этом нет ничего сложного:

    Десятичные дроби (Decimal)

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

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

    Но, как говорится "Дьявол кроется в мелочах" Очень неприятным последствием таких "ничтожно-маленьких" погрешностей является то, что вы не можете точно проверить истинность равенства:

    Потому что с точки зрения компьютера:

    А в финансовой и бухгалтерской среде подобные логические проверки выполняются постоянно.

    Вторым неприятным последствием становится то, что погрешности имеют свойство накопления. Расмотрим простой пример:

    Мы (100000000) раз сложили число (0.1) с самим собой, но вместо (10000000) мы получили (9999999.98112945), которое отличается от правильного результата на целых (0.018870549276471138). В принципе не так уж и сильно, отличается. Да и пример "притянут за уши". Но что-то подобное происходит при решении дифференциальных уравнений. Если с помощью таких уравнений строится траектория космического аппарата, то из-за такой мизерной погрешности он конечно полетит в сторону нужной планеты, но пролетит мимо. А если вы рассчитываете параметры химической реакции, то на компьютере все может выглядеть более чем безобидно, но в действительности, из-за этой мизерной погрешности вполне может произойти взрыв.

    Потребность в повышенной точности, возникает очень редко, но возникает неспроста. Именно эту потребность и призваны удовлетворить числа типа Decimal. Этот тип не является встроенным, а предоставляется модулем Decimal из стандартной библиотеки Python:

    Причем точность может быть настолько большой, насколько позволяет мощность компьютера. Допустим, мы хотим видеть результат с точностью (80) знаков после запятой (хотя можем увидеть и (1000)), вот они:

    Хотелось бы думать, что такая точность доступна абсолютно для всех математических операций и функций, например таких как всякие синусы, косинусы или даже Γ, Β, G, K функции и прочая экзотика. Но нет, слишком хорошо – тоже не хорошо. К тому же все эти и другие функции могут быть получены с помощью базовых математических операций, которые модулем Decimal прекрасно поддерживаются, например:

    Обыкновенные дроби (Fraction)

    Рациональные числа, они же — обыкновенные дроби предоставляются модулем fractions. Обыкновенная дробь в данном модуле представляется в виде пары двух чисел numerator – числитель и denominator – знаменатель:

    Честно говоря без чисел типа Fraction можно легко обойтись, но из примера видно, что данный модуль выполнил сокращение числителя и знаменателя автоматически, что довольно любопытно и наводит на вопрос "А где бы мне это могло пригодиться?". Самый очевидный ответ – числовые ряды и пределы. Для примера рассмотрим ряд Лейбница, который сходится к (pi/4) (правда медленно. ооочень медленно сходится):

    Или посмотреть на поведение вот такого предела:

    который тоже можно выразить с помощью чисел типа fractions:

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

    Ссылка на основную публикацию
    Футбольный менеджер без интернета
    Да, уже четыре года назад Испания выиграла Евро 2012. С того времени много воды утекло и теперь у других команд...
    Форд экоспорт белый фото
    Компания Форд славится тем, что каждое обновление их машин несет в себе кучу перемен. Не стал исключением и недорогой городской...
    Форм факторы корпусов пк размеры
    Главная FAQ Железо Типы компьютерных корпусов Типы компьютерных корпусов Говоря слово "компьютер" многие подразумевают системный блок компьютера, и в принципе...
    Футбольный менеджер с реальными командами
    Бесплатная онлайн игра. Только в нашем футбольном менеджере игры проходят в реальном времени и можно менять тактику непосредственно во время...
    Adblock detector