Главная » Языки программирования

Примеры int в питоне

На чтение 10 мин
Содержание
  1. Подробно про int() в Python
  2. Параметры
  3. Возвращаемое значение
  4. Пример 1
  5. Пример 2: Как работает для десятичных, восьмеричных и шестнадцатеричных чисел?
  6. Пример 3: Для пользовательских объектов
  7. int(x, base=10)
  8. Параметры ¶
  9. Возвращаемое значение ¶
  10. Примеры ¶
  11. Функция int
  12. Числа в Python: Int, float
  13. Вещественные числа в Python
  14. Создание int и float чисел
  15. Арифметические операции над целыми и числами с плавающей точкой
  16. Сложение
  17. Вычитание
  18. Умножение
  19. Деление
  20. Деление без остатка
  21. Остаток от деления
  22. Возведение в степень
  23. Комплексные числа
  24. Конвертация типов чисел
  25. Случайные числа

Подробно про int() в Python

Метод int() в Python возвращает целочисленный объект из любого числа или строки.

Параметры

Функция принимает два аргумента:

  • x – число или строка, которые нужно преобразовать в целочисленный объект. Аргумент по умолчанию равен нулю.
  • base – основание числа в x. Может быть 0 (буквальный код) или 2-36.

Возвращаемое значение

  • целочисленный объект из данного числа или строки обрабатывает базу по умолчанию как 10;
  • возвращает 0 (без параметров);
  • обрабатывает строку в заданной базе (0, 2, 8, 10, 16).

Пример 1

# integer print("int(123) is:", int(123)) # float print("int(123.23) is:", int(123.23)) # string print("int('123') is:", int('123'))
int(123) is: 123 int(123.23) is: 123 int('123') is: 123

Пример 2: Как работает для десятичных, восьмеричных и шестнадцатеричных чисел?

# binary 0b or 0B print("For 1010, int is:", int('1010', 2)) print("For 0b1010, int is:", int('0b1010', 2)) # octal 0o or 0O print("For 12, int is:", int('12', 8)) print("For 0o12, int is:", int('0o12', 8)) # hexadecimal print("For A, int is:", int('A', 16)) print("For 0xA, int is:", int('0xA', 16))
For 1010, int is: 10 For 0b1010, int is: 10 For 12, int is: 10 For 0o12, int is: 10 For A, int is: 10 For 0xA, int is: 10

Пример 3: Для пользовательских объектов

Внутри функция вызывает метод объекта __int __().

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

Вы можете сделать это, переопределив методы __index __() и __int __() класса для возврата числа.

Эти два метода должны возвращать то же значение, поскольку более старые версии Python используют __int __(), а более новые используют метод __index __().

class Person: age = 23 def __index__(self): return self.age def __int__(self): return self.age person = Person() print('int(person) is:', int(person))

Источник

int(x, base=10)

Преобразует x к целому числу в десятичной системе счисления. Вместо десятичной системы можно указать любое основание от 2 до 36 включительно.

Параметры ¶

Функция int() принимает два параметра:

  • value — любая числовая строка, байтовый объект или число
  • base необязательный — система счисления, в которой в данный момент находится значение

Возвращаемое значение ¶

  • целая часть числа — для одного значения аргумента (любое число)
  • 0 — без аргументов
  • целочисленное представление числа с заданным основанием (0, 2, 8, 10, 16)

Примеры ¶

# int() с целочисленным значением
print("int(94) is:", int(94))
 
# int() со значением с плавающей запятой
print("int(58.23) is:", int(58.23))
 
# int() с числовым строковым значением
print("int('123') is:", int("123"))
 
# Результат: 
int(94) is: 94
int(58.23) is: 58
int('123') is: 123
Мы используем файлы cookie

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

Читайте также:  Индекс элемента множества python

Источник

Функция int

В языке программирования Python встроенная функция int() возвращает целое число (экземпляр класса int ) в десятичной системе счисления. Если преобразовать переданный в функцию первый или единственный аргумент в десятичное число не удается, то генерируется исключение ValueError .

Если вызвать функцию int() без аргументов, она вернет 0.

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

>>> int('4') 4 >>> int('3a') Traceback (most recent call last): File "", line 1, in int('3a') ValueError: invalid literal for int() with base 10: '3a'

Если передать функции целое число, то она вернет его же. Если передать вещественное число, то оно будет округлено до целого в сторону нуля (т. е. дробная часть будет отброшена).

>>> int(87) 87 >>> int(-103) -103 >>> int(234.879) 234 >>> int(-0.3) 0 >>> int(-0.9) 0

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

>>> int('101.1') Traceback (most recent call last): File "", line 1, in int('101.1') ValueError: invalid literal for int() with base 10: '101.1'

Чтобы преобразовать дробное число в строковом представлении в целое число, сначала можно использовать функцию float() , затем int() .

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

>>> int('12', 8) 10 >>> int('13h', 20) 477 >>> int('111001', 2) 57

Основание системы счисления не должно превышать 36.

>>> int('w0y', 36) 41506 >>> int('w0y', 37) Traceback (most recent call last): File "", line 1, in ValueError: int() base must be >= 2 and

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

>>> int(0b11) 3 >>> int(0o10) 8 >>> int(0xA5) 165 >>> int('0b11') Traceback (most recent call last): File "", line 1, in int('0b11') ValueError: invalid literal for int() with base 10: '0b11' >>> int('0b11', 2) 3

В классах функцию int() переопределяют методы __int__() , __index__() , __trunc__() .

>>> class A: . a = 'H' . def __int__(self): . return ord(self.a) . >>> obj = A() >>> int(obj) 72 >>> obj.a = '!' >>> int(obj) 33

Источник

Числа в Python: Int, float

Основы

В данном уроке мы изучим работу с числовыми данными в Питоне. Python очень зрелый язык и, естественно, работа с числами в нём сделана удобно, но позволяет сделать очень многое. В данном языке, в отличие от многих других, типов числовых данных достаточно мало. Это целочисленный тип, реальные и комплексные числа. И если первые два типа представлены в любом языке, то комплексные числа – изюминка именно Пайтона.

Вещественные числа в Python

Вещественные числа это:
— Числа без дробной части. Могут быть как положительными, так и отрицательными. В Python представлены типом int. Пример: 0, -22, 48947364316
— Числа с дробной частью. Могут быть как положительными, так и отрицательными. В Python представлены типом float. Пример: 0.15, -5445454.45456465, 0.0

Создание int и float чисел

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

i = 5 x = 0.0 print('type(i):', type(i)) print('type(x):', type(x)) # Вывод: type(i): type(x):
print('type(7):', type(7)) print('type(-1.2):', type(-1.2)) # Вывод: type(7): type(-1.2):
print('type(\'7\'):', type('7')) print('type("-1.2"):', type("-1.2")) # Вывод: type('7'): type("-1.2"):

Как Вы уже видели выше, тип любого объекта можно проверить используя функцию type(). Даже тип самой функции type(). Даже тип типа))

print('type(7):', type(7)) print('type(type):', type(type)) print('type(type(7)):', type(type(7))) # Вывод: type(7): type(type): type(type(7)):

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

a = 7_7 b = 999_999_999 c = 123_456.789_123 print('a:', a) print('b:', b) print('c:', c) # Вывод: a: 77 b: 999999999 c: 123456.789123
 
Арифметические операции над целыми и числами с плавающей точкой
 
Естественно, со всеми числовыми типами данных можно совершать арифметические операции.
 
Сложение
 
В Пайтоне сложение выполняется с помощью оператора +(странно, правда?). 
 
print('1+1:', 1 + 1) print('1+0.0:', 1 + 0.0) print('1.0 + 1.0:', 1.0 + 1.0) # Вывод: 1+1: 2 1+0.0: 1.0 1.0 + 1.0: 2.0
 
Примечательно то, что если в любой арифметической операции участвует число с дробной частью, то результат приводится к типу float. Обратите внимание, что в числах с дробной частью, которые лежат в диапазоне от 1 до -1, ноль слева от точки можно опускать. 
 
print('0.12+0.1:', 0.12 + 0.1) print('.12+.1:', .12 + .1) # Вывод: 0.12+0.1: 0.22 .12+.1: 0.22
 
Вычитание
 
В Python для операции вычитания используется оператор -. Рассмотрим примеры. 
 
print('1 - 1.1:', 1 - 1) print('1.1 - 1.1:', 1.1 - 1.1) print('1 - 1.1:', 1 - 1.1) print('1.1 - 1:', 1.1 - 1) # Вывод: 1 - 1.1: 0 1.1 - 1.1: 0.0 1 - 1.1: -0.10000000000000009 1.1 - 1: 0.10000000000000009
 
Положительные числа получаются в случае вычитания маленького числа из более крупного. Если же из маленького наоборот вычесть большое, то результатом будет отрицательно число. По аналогии с операцией сложения при вычитании если один из операндов является числом с плавающей точкой, то и весь результат будет такого типа. И да, с типом float бывают проблемы. Подробнее об этом мы рассказывали в одном из предыдущих уроков.
 
Умножение
 
Для умножения в Python применяется оператор *. 
 
print('1 * 1.1:', 1 * 1) print('1.1 * 1.1:', 1.1 * 1.1) print('1 * 1.1:', 1 * 1.1) print('1.1 * 1:', 1.1 * 1) # Вывод: 1 * 1.1: 1 1.1 * 1.1: 1.2100000000000002 1 * 1.1: 1.1 1.1 * 1: 1.1
 
Если перемножить два целых числа, то результатом будет целое число. Если же использовать число с плавающей точкой, то результатом будет также число с плавающей точкой.
 
Деление
 
В Python деление выполняется с помощью оператора /. 
 
print('1 / 1.1:', 1 / 1) print('1.1 / 1.1:', 1.1 / 1.1) print('1 / 1.1:', 1 / 1.1) print('1.1 / 1:', 1.1 / 1) # Вывод: 1 / 1.1: 1.0 1.1 / 1.1: 1.0 1 / 1.1: 0.9090909090909091 1.1 / 1: 1.1
 
В отличие от трех предыдущих операций при делении результатом всегда будет число с плавающей точкой. Также нужно помнить о том, что на 0 делить нельзя, иначе Python вернет ошибку ZeroDivisionError. Вот пример такого поведения. 
 
print('1 / 0:', 1 / 0) # Вывод: Traceback (most recent call last): File "C:\Users\ivand\AppData\Roaming\JetBrains\PyCharm2021.2\scratches\scratch.py", line 1, in print('1 / 0:', 1 / 0) ZeroDivisionError: division by zero Process finished with exit code 1
 
Деление без остатка
 
При обычном делении с использованием оператора / результатом будет точное число с плавающей точкой. Но иногда достаточно получить лишь целую часть операции. Для этого есть операции интегрального деления. Стоит рассмотреть ее на примере. 
 
print('1 // 1.1:', 1 // 1) print('1.1 // 1.1:', 1.1 // 1.1) print('1 // 1.1:', 1 // 1.1) print('1.1 // 1:', 1.1 // 1) # Вывод: 1 // 1.1: 1 1.1 // 1.1: 1.0 1 // 1.1: 0.0 1.1 // 1: 1.0
 
Результатом такой операции становится частное. Остаток же можно получить с помощью модуля, о котором речь пойдет дальше.
 
Остаток от деления
 
Для получения остатка деления двух чисел используется оператор деления по модулю %. 
 
print('1 % 1.1:', 1 % 1) print('1.1 % 1.1:', 1.1 % 1.1) print('1 % 1.1:', 1 % 1.1) print('1.1 % 1:', 1.1 % 1) # Вывод: 1 % 1.1: 0 1.1 % 1.1: 0.0 1 % 1.1: 1.0 1.1 % 1: 0.10000000000000009
 
Возведение в степень
 
Число можно возвести в степень с помощью оператора **. 
 
print('1 ** 1.1:', 1 ** 1) print('1.1 ** 1.1:', 1.1 ** 1.1) print('1 ** 1.1:', 1 ** 1.1) print('1.1 ** 1:', 1.1 ** 1) # Вывод: 1 ** 1.1: 1 1.1 ** 1.1: 1.1105342410545758 1 ** 1.1: 1.0 1.1 ** 1: 1.1
 
Комплексные числа
 
Комплексные числа — это числа, которые включают мнимую часть. Python поддерживает и их. 
 
первая_переменная = 2 + 2j вторая_переменная = 3 + 4j сумма = первая_переменная + вторая_переменная print("Сумма двух комплексных чисел равна: ", сумма) # Вывод: Сумма двух комплексных чисел равна: (5+6j)
 
В этом примере были созданы два комплексных числа. После этого было выполнено их сложение с помощью оператора +. Результат вывели на экран с помощью функции print().
 
Конвертация типов чисел
 
Конвертация типа — это метод конвертации числа из одного типа в другой. Для этого можно использовать функции float(), int() и complex(). 
 
целое = 147 дробное = 147.741 комплексное = 147+741j print('целое:', целое, 'тип:', type(целое)) print('дробное:', дробное, 'тип:', type(дробное)) print('комплексное:', комплексное, 'тип:', type(комплексное)) a = float(целое) # преобразование целого числа в число с плавающей точкой b = int(дробное) # преобразование числа с плавающей точкой в целое число c = complex(целое) # преобразование целого числа в комплексное d = complex(дробное) # преобразование числа с плавающей точкой в комплексное print('дробное:', a, 'тип:', type(a)) print('целое:', b, 'тип:', type(b)) print('комплексное:', c, 'тип:', type(c)) print('комплексное:', d, 'тип:', type(d)) # Вывод: целое: 147 тип: дробное: 147.741 тип: комплексное: (147+741j) тип: дробное: 147.0 тип: целое: 147 тип: комплексное: (147+0j) тип: комплексное: (147.741+0j) тип:
 
Случайные числа
 
Случайные числа используются в играх, криптографии и так далее. В Python нативной поддержки случайных чисел нет, но есть встроенный модуль random, который используется для работы с целыми числами. Рассмотрим пример генерации случайных чисел с помощью такого модуля. 
 
Источник
Оцените статью
© 2023 Программирование