Типы переменных | bookhtml.ru
|
00;
Например, можно было бы определить так:Типы данных в Python — Робикс кружок робототехники
Главная › База знаний › Программирование › Python › Числовые типы данных в Python: integer, float
Переменные
Любые данные хранятся в ячейках памяти компьютера.
Когда мы вводим число, оно помещается в какую-либо ячейку памяти. Возникают вопросы: Куда именно? Как впоследствии обращаться к этим данными?
В программе данные связываются с каким-либо именем. В дальнейшем обращение к ним возможно по этому имени-переменной.
Термин «переменная» обозначает, что ее сущность может меняться, она непостоянна.
В программе на языке Python, как и на большинстве других языков, связь между данными и переменными устанавливается с помощью знака = (знак равно). Данная операция называется присваиванием.
Например, выражение, представленное ниже, означает, что на объект, представляющий собой число 4, находящееся в определенной области памяти, теперь ссылается переменная a.
Имена переменных могут быть любыми. Однако есть несколько общих правил их написания:
- Желательно давать переменным осмысленные имена, говорящие о назначении данных, на которые они ссылаются.
- Имя переменной не должно совпадать с командами языка (зарезервированными ключевыми словами).
- Имя переменной должно начинаться с буквы или символа подчеркивания, но не с цифры.
- Имя переменной не должно содержать пробелы.
Чтобы узнать значение, на которое ссылается переменная, находясь в режиме интерпретатора, достаточно ее вызвать, то есть написать имя и нажать Enter.
Числовые типы данных
Напишите в консоли следующую команду и нажмите Enter:
>>> 1 + 1
В результате получим следующее:
При программировании мы чаще всего будем сталкиваться с такими числовыми типами данных (формализация информации), как целые числа и числа с плавающей точкой.
Целые числа (тип int) — это положительные и отрицательные целые числа, а также 0, например: 0, -1, 1, 1827 и т.д.
Числа с плавающей точкой (тип float) — это вещественные, числа (рациональные + иррациональные числа), например: 0, -1, 1, 1827, 0.
5, -0.76, 3.141592 (число пи) и т.д.
Операции
Операция — это выполнение каких-либо действий над данными (операндами). Действие выполняется оператором (сложение(+), умножение(*) и т.п. ). Результат операции зависит как от оператора, так и от операндов.
Изменение типа переменных
Давайте создадим две переменные A и B, которым присвоим некоторые значения:
>>> A = 10 >>> B = 1.24
В зависимости от введенной информации, Python самостоятельно определяет тип переменно. Чтобы посмотреть типы заданных переменных, воспользуемся функцией type(), для этого введем следующую команду:
>>> type(A)
После ввода на экране появится тип переменной А, в нашем случае это будет целое число, то есть на экране мы увидим следующее:
>>> type(A) <class 'int'>
Проведем ту же операцию со второй переменой, на экране увидим следующее:
>>> type(B) <class 'float'>
Попробуем сложить переменные разных типов данных и выясним, к какому типу относится полученный результат:
>>> С = A + B >>> type(С) <class 'float'>
Как можете заметить, в итоге мы получили переменную float.
Любые математические действия можно выполнять только над одинаковыми типами данных, т.е. либо все float, либо все int и т.д.
Но тогда как мы сейчас смогли это сделать? Python самостоятельно производит перевод переменных в нужный тип данных. Вы можете самостоятельно произвести данный переход с помощью функций int(), float():
>>> type(A) <class 'int'> >>> A = float(A) >>> type(A) <class 'float'> >>> type(B) <class 'float'> >>> B = int(B) >>> type(B) <class 'int'> >>> A 10.0 >>> B 1
>>> A1 = 0.1 >>> A2 = 0.4 >>> A3 = 0.7 >>> A4 = 1.1 >>> A1 = int(A1) >>> A2 = int(A2) >>> A3 = int(A3) >>> A4 = int(A4) >>> A1 0 >>> A2 0 >>> A3 0 >>> A4 1
Как можно заметить, округление происходит до ближайшего целого числа по направлению в сторону нуля, то есть в меньшую сторону.
Основные математические операции в Python
- Cложение (+) используется для получения суммы (в отношении чисел), было нами рассмотрено выше.
- Вычитание (-) — операция, противоположная сложению.
- Умножение(*) используется для получения произведения сомножителей.
>>> type(2 * 2) <class 'int'> >>> type(0.1 * 2) <class 'float'> >>> type(0.2 * 5) <class 'float'>
- Возведение в степень (**) используется для возведения числа в степень, то есть умножение числа на само себя столько раз, сколько указано в степени.
>>> 2 ** 3 8 >>> 2 ** 4 16
- Деление (/) — действие, обратное умножению, используется для получения частного
>>> 4 / 2 2.0 >>> type(4/2) <class 'float'> >>> 2 / 4 0.5
Даже если делимое и делитель являются целыми числами и делитель содержится в делимом целое число раз, то результат деления будет float.
- Целочисленное деление (//) нужно для получения целочисленного результата деления, то есть при данной операции отбрасывается дробная часть числа.
>>> 4 // 2 2 >>> type(4 / 2) <class 'float'> >>> 2//4 0 >>> type(2 // 4) <class 'int'>
- Получение остатка от деления (%). В результате данной операции Вы получаете то, что осталось от деления, то есть вы получаете то, что невозможно дальше делить. Например, в первом случае 4 делится без остатка — в 4 две 2, во втором случае 2 не разделить на 4, оно сразу уходит в остаток, в третьем случае 7 содержит две 3 (6), в остаток уходит 7 — 6 = 1.
>>> 4 % 2 0 >>> 2 % 4 2 >>> 7 % 3 1
- Модуль числа (abs()) используется для получения модуля числа, то есть отбрасывается знак перед числом
>>> abs(-0.1) 0.1 >>> abs(0) 0 >>> abs(-283) 283 >>> abs(45) 45
- Округление (round()) — данная операция округляет число до ближайшего целого числа, формат int.
>>> round(0.5) 0 >>> round(0.6) 1 >>> round(1.1) 1 >>> round(1.5) 2 >>> round(1.4) 1
Курсы Робикс, в которых изучается этот материал.
- Программирование на Python в Minecraft
- Duckietown робот с системой Автопилота
Сохраните или поделитесь
python — Проверить, является ли число целым или плавающим
спросил
Изменено 3 месяца назад
Просмотрено 726 тысяч раз
На этот вопрос уже есть ответы здесь :
Каков канонический способ проверки типа в Python? (15 ответов)
Закрыт 8 месяцев назад.
Вот как я это сделал:
inNumber = somenumber
inNumberint = целое (inNumber)
если inNumber == inNumberint:
напечатайте "это число является целым числом"
еще:
вывести "это число является числом с плавающей запятой"
Что-то в этом роде.
Есть ли более привлекательные способы сделать это?
- питон
6
Использовать isinstance .
>>> х = 12 >>> isinstance(x, int) Истинный >>> у = 12,0 >>> isinstance(y, float) Истинный
Итак:
>>> if isinstance(x, int):
print('x - это целое число!')
х является целым числом!
В случае длинных целых чисел описанное выше не работает. Значит нужно сделать:
>>> x = 12L >>> импортировать номера >>> isinstance(x, числа.Интеграл) Истинный >>> isinstance(x, int) ЛОЖЬ
12
Мне больше всего нравится ответ @ninjagecko.
Также подойдет:
для Python 2.x
isinstance(n, (int, long, float))
Python 3.x не имеет long
isinstance(n, (int, float))
есть еще тип комплекс для комплексных номеров
2
(примечание: это вернет True для типа bool , по крайней мере, в cpython, что может быть не тем, что вам нужно. Спасибо комментаторам.)
Однострочник:
isinstance(yourNumber, numbers.Real)
Это позволяет избежать некоторых проблем:
>>> isinstance(99**10,int) ЛОЖЬ
Демонстрация:
>>> импортировать номера >>> некоторыйInt = 10 >>> someLongInt = 100000L >>> someFloat = 0,5 >>> isinstance(someInt, numbers.Real) Истинный >>> isinstance(someLongInt, numbers.Real) Истинный >>> isinstance(someFloat, numbers.
Real)
Истинный
2
Вы можете использовать модуль по модулю, чтобы определить, является ли x целым числом. Метод isinstance(x, int) определяет, является ли x целым числом только по типу:
def isInt(x):
если х%1 == 0:
напечатать «X — целое число»
еще:
напечатать «X не является целым числом»
2
Вы также можете использовать type() Пример:
, если тип (inNumber) == int : напечатайте «Это число является целым числом» elif type(inNumber) == float : print "Это число является числом с плавающей запятой"
1
Легче попросить прощения, чем разрешения. Просто выполните операцию. Если это работает, объект был приемлемого, подходящего, надлежащего типа. Если операция не работает, значит, объект был неподходящего типа.
Знание типа редко помогает.
Просто попробуйте выполнить операцию и посмотрите, работает ли она.
inNumber = некоторое число
пытаться:
inNumberint = целое (inNumber)
напечатайте "это число является целым числом"
кроме ValueError:
проходить
пытаться:
inNumberfloat = с плавающей запятой (inNumber)
вывести "это число является числом с плавающей запятой"
кроме ValueError:
проходить
8
Пробовал в Python версии 3.6.3 Shell
>>> x = 12 >>> импортировать номера >>> isinstance(x, числа.Интеграл) Истинный >>> isinstance(x,int) Истинный
Ничего не нашел для работы.
Вот фрагмент кода, который проверяет, является ли число целым или нет, он работает как для Python 2, так и для Python 3.
import sys
если sys.version < '3':
integer_types = (целое, длинное,)
еще:
целые_типы = (целое,)
isinstance(yourNumber, integer_types) # возвращает True, если это целое число
isinstance(yourNumber, float) # возвращает True, если это число с плавающей запятой
Обратите внимание, что Python 2 имеет оба типа int и long , а Python 3 имеет только тип int .
Источник.
Если вы хотите проверить, является ли ваше число числом с плавающей запятой , представляющим int , сделайте следующее
(isinstance(yourNumber, float) and (yourNumber).is_integer()) # True for 3.0
Если вам не нужно различать int и float, и вы согласны с любым из них, тогда ответ ninjegecko — это то, что вам нужно
импортировать номера isinstance(yourNumber, numbers.Real)
Я знаю, что это старая тема, но я использую ее и подумал, что это может помочь.
Работает в python 2.7 и python 3< .
по определению is_float(число):
"""
Проверяет, является ли число числом с плавающей запятой или целым числом
Аргументы:
num(float или int): число для проверки
Возвращает:
Истинно, если число плавающее
"""
вернуть не (с плавающей запятой (число)).is_integer()
класс TestIsFloat (unittest.TestCase):
определение test_float (я):
self.assertTrue (is_float (2. 2))
определение test_int (я):
self.assertFalse (is_float (2))
2))
определение test_int (я):
self.assertFalse (is_float (2))
как насчет этого решения?
, если тип(x) in (float, int):
# делай что угодно
еще:
# делай что угодно
Я не уверен, почему это не было предложено раньше, но как насчет использования встроенного метода Python для числа с плавающей запятой с именем is_integer() ? По сути, вы могли бы дать ему какое-то число, приведенное как число с плавающей запятой, и спросить, является ли оно целым числом или нет. Например:
>>> (-13.0).is_integer() Истинный >>> (3.14).is_integer() ЛОЖЬ
Однако для полноты учтите:
isinstance(i, int) или i.is_integer()
1
Вы можете сделать это с помощью простого оператора if
Проверить наличие числа с плавающей запятой
if type(a)==type(1.1)
Проверить целочисленный тип
if type(a)==type(1)
1
пожалуйста, проверьте это: импортировать числа
импортировать математику а = 1,1 - 0,1 распечатать print isinstance(a, numbers.
Integral)
распечатать math.floor(a)
если (math.floor(a) == a):
напечатать "Это целое число"
еще:
печатать Ложь
Хотя X является числом с плавающей запятой, но значение является целым числом, поэтому, если вы хотите проверить, является ли значение целым числом, вы не можете использовать isinstance, и вам нужно сравнивать значения, а не типы.
0
абс. = абс.(x) округлый = округлый (абсолютный) если абсолютное - округленное == 0: напечатать «Целое число» еще: напечатать 'нецелое число'
Обновление: Попробуйте это
inNumber = [32, 12,5, 'е', 82, 52, 92, '1224,5', '12,53',
10 000 000, 10 000 459',
'Это предложение с запятой номер 1 и точкой.', '121.124']
пытаться:
определение find_float (число):
число = число.split('.')
если num[-1] не None и num[-1].isdigit():
вернуть Истина
еще:
вернуть ложь
для я в inNumber:
я = ул (я). заменить (',', '.')
если '.' в i и find_float(i):
print('Это число с плавающей запятой', i)
Элиф i.isnumeric():
print('Это целое число', я)
еще:
print('Это не число?', i)
кроме исключения как ошибки:
печать (ошибка)
заменить (',', '.')
если '.' в i и find_float(i):
print('Это число с плавающей запятой', i)
Элиф i.isnumeric():
print('Это целое число', я)
еще:
print('Это не число?', i)
кроме исключения как ошибки:
печать (ошибка)
3
Используйте самый простой вывод типа, который есть в python:
>>> # Float Check >>> мое число = 2,56 >>> print(type(myNumber) == int) ЛОЖЬ >>> print(type(myNumber) == float) Истинный >>> print(type(myNumber) == bool) ЛОЖЬ >>> >>> # Целочисленная проверка >>> мой номер = 2 >>> print(type(myNumber) == int) Истинный >>> print(type(myNumber) == float) ЛОЖЬ >>> print(type(myNumber) == bool) ЛОЖЬ >>> >>> # Логическая проверка >>> мой номер = ложь >>> print(type(myNumber) == int) ЛОЖЬ >>> print(type(myNumber) == float) ЛОЖЬ >>> print(type(myNumber) == bool) Истинный >>>
Самый простой и надежный подход, на мой взгляд
def is_int(x):
абсолютный = абс (х)
округлый = округлый (абсолютный)
если абсолютное - округленное == 0:
print str(x) + "целое число"
еще:
print str(x) +" не является целым числом"
is_int(7. 0) # напечатает 7.0 - целое число
0) # напечатает 7.0 - целое число
3
Попробуйте это...
def is_int(x): абсолютный = абс (х) округлый = округлый (абсолютный) вернуть абсолютное - округленное == 0
variable.isnumeric проверяет, является ли значение целым числом:
если myVariable.isnumeric:
print('это числовое значение')
еще:
печать('не числовой')
Очень активный вопрос . Заработайте 10 репутации (не считая бонуса ассоциации), чтобы ответить на этот вопрос. Требование к репутации помогает защитить этот вопрос от спама и отсутствия ответа.
Как определить тип переменной Python?
Итак, если у вас есть переменная, например:
один = 1
Хотите узнать его тип?
В Python есть правильные и неправильные способы делать почти все. Вот правильный путь:
Используйте тип
>>> тип (один) <тип 'целое число'>
Вы можете использовать атрибут __name__ для получения имени объекта.
(Это один из немногих специальных атрибутов, необходимых для использования __dunder__ имя, к которому нужно добраться - для него даже нет метода в модуле inspect .)
>>> type(one).__name__ 'инт'
Не использовать
__class__ В Python имена, начинающиеся с символов подчеркивания, семантически не являются частью общедоступного API, и пользователям рекомендуется избегать их использования. (За исключением случаев крайней необходимости.)
Так как тип дает нам класс объекта, нам следует избегать прямого получения этого значения. :
>>> один.__класс__
Обычно это первое, что приходит людям при доступе к типу объекта в методе — они уже ищут атрибуты, поэтому тип кажется странным. Например:
класс Foo(объект):
деф фу(я):
сам.__класс__
Не надо. Вместо этого введите type(self):
class Foo(object):
деф фу(я):
тип (я)
Детали реализации целых чисел и чисел с плавающей запятой
Как узнать тип переменной, является ли она 32-битной без знака, 16-битной со знаком и т.
д.?В Python эти особенности являются деталями реализации. Так что в Python мы обычно не беспокоимся об этом. Однако, чтобы удовлетворить ваше любопытство...
В Python 2 int обычно представляет собой целое число со знаком, равное разрядности слова реализации (ограничено системой). Обычно это реализуется как long в C. Когда целые числа становятся больше, чем это, мы обычно конвертируем их в long Python (с неограниченной точностью, не путать с long C).
Например, в 32-битном Python 2 мы можем сделать вывод, что int — это 32-битное целое число со знаком:
>>> импорт системы >>> формат(sys.maxint, '032b') '01111111111111111111111111111111' >>> format(-sys.maxint - 1, '032b') # минимальное значение, см. документы. '-10000000000000000000000000000000'
В Python 3 старый int исчезает, и мы просто используем (Python) long вместо int, который имеет неограниченную точность.
Мы также можем получить некоторую информацию о числах с плавающей запятой в Python, которые обычно реализуются как двойники в C:
>>> sys.
