Системы счисления
В системе счисления с основанием больше 10, цифры записываются так: 0, 1, 2, . 9, A, B, C, .
В тексте программ на языке Python можно использовать целочисленные константы, записанные в двоичной (префикс 0b ), восьмеричной (префикс 0o ) и шестнадцатеричной (префикс 0x ) системах счисления. После указанного префикса идут цифры, которые в двоичной системе счисления могут быть только 0 или 1, в восьмеричной — от 0 до 7, в шестнадцатеричной — от 0 до 9, а также буквы латинского алфавита от A до F (могут быть как строчными, так и заглавными). Например, десятичной число 179 можно задать несколькими способами.
A = 179 A = 0b10110011 A = 0o263 A = 0xB3
Если вы знаете стандартные функции языка Python для перевода представления чисел между различными системами счисления, то этими функциями пользоваться нельзя. Также нельзя использовать функции типа eval , exec и т.д.
Если программа выводит результат в системе счисления с основанием больше 10, то цифры записываются так: 0, 1, 2, . 9, A, B, C, .
A: Шестнадцатеричную цифру в int
Дана шестнадцатеричная цифра, записанная в строке из одного символа. Определите её числовое значение.
Решение оформите в виде функции hex2int(c: str) -> int.
На проверку сдайте только тело функции.
В решении нельзя использовать списки, словари, строки типа «ABCDEF» и т.д.
hex2int('9')
hex2int('F')
B: int в шестнадцатеричную цифру
Решите задачу, обратную предыдущей.
Решение оформите в виде функции int2hex(n: int) -> str.
int2hex(9)
int2hex(15)
C: Из двоичной в int
Дано число, записанное в двоичной системе счисления. Переведите его в тип int.
Решение оформите в виде функции bin2int(s: str) -> int .
Решение должно использовать схему Горнера.
bin2int('10110011')
D: Из шестнадцатеричной в int
Решите предыдущую задачу в случае, когда входное число задано в шестнадцатеричном виде. Соответствующая функция должна называться hex2int(s: str) -> int.
hex2int('B3')
E: Из int в двоичную
Переведите число из int в двоичную систему числения.
Решение оформите в виде функции int2bin(n: int) -> str.
int2bin(179)
'10110011'
F: Из int в шестнадцатеричную
Переведите число из десятичной системы в шестнадцатеричную.
Решение оформите в виде функции int2hex(n: int) -> str.
int2hex(179)
G: Из любой в любую
Напишите программу, переводящую запись числа между двумя произвольными системами счисления.
На вход программа получает три величины: n, A, k, где n и k – натуральные числа от 2 до 36: основания системы счисления, A – число, записанное в в системе счисления с основанием n, A
Необходимо вывести значение A в системе счисления с основанием k без лидирующих нулей.
Решение должно содержать две функции перевода — из числа в произвольной системе счисления, записанного в переменной типа str в переменную типа int и обратно.
2
101111
16
10
35
36
H: Из шестнадцатеричной в двоичную
Переведите число из шестнадцатеричной системы счисления в двоичную. Исходное число может быть очень большим (до \(2\times10^5\) символов). Необходимо вывести результат без лидирующих нулей.
Решение оформите в виде функции hex2bin(s: str) -> str
hex2bin('2F')
'101111'
I: Из двоичной в шестнадцатеричную
Переведите число из двоичной системы счисления в шестнадцатеричную. Исходное число может быть очень большим (до \(12\times10^6\) символов).
Решение оформите в виде функции bin2hex(s: str) -> str
bin2hex('101111')
J: Из уравновешенной троичной в int
В уравновешенной троичной системе счисления используется основание 3 и три цифры: 0, 1 и -1. Цифру -1 будем обозначать знаком $. Достоинство уравновешенной троичной системы счисления: простота хранения отрицательных чисел и удобство нахождения числа, противоположному данному.
Вот как записываются небольшие числа в уравновешенной троичной системе счисления:
| Десятичная | -9 | -8 | -7 | -6 | -5 | -4 | -3 | -2 | -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Уравнов. троичная | $00 | $01 | $1$ | $10 | $11 | $$ | $0 | $1 | $ | 0 | 1 | 1$ | 10 | 11 | 1$$ | 1$0 | 1$1 | 10$ | 100 |
Подробней о уравновешенной троичной системе счисления можно прочитать в Википедии (статья Троичная система счисления, там используется термин «троичная симметричная система счисления»).
Дана запись числа в уравновешенной троичной системе счисления. Переведите её в значение типа int.
Решение оформите в виде функции ter2int(s: str) -> int
ter2int('$01')
K: Из фибоначчиевой в int
Рассмотрим последовательность Фибоначчи: \(\varphi_1=1\), \(\varphi_2=2\), \(\varphi_n=\varphi_+\varphi_\) при \(n\gt 2\). В частности, \(\varphi_3=3\), \(\varphi_4=5\), \(\varphi_5=8\) и т.д.
Любое натуральное число можно представить в виде суммы нескольких членов последовательности Фибоначчи. Такое представление будет неоднозначным, но если наложить дополнительное условие, что в представлении нет двух соседних членов последовательности Фибоначчи, то представление становится единственным.
Будем говорить, что число \(A\) представимо в фибоначчиевой системе счисления в виде \(a_ka_. a_1\), где \(a_i\in\\), если \(A=a_k\varphi_k+. +a_1\varphi_1\) и в записи \(a_ka_. a_1\) нет двух единиц подряд.
Вот как записываются небольшие числа в фибоначчиевой системе счисления:
| Десятичная | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Фибоначчиева | 1 | 10 | 100 | 101 | 1000 | 1001 | 1010 | 10000 | 10001 | 10010 | 10100 | 10101 | 100000 |
Подробней о фибоначчиевой системе счисления можно прочитать в Википедии (статья Фибоначчиева система счисления).
Дана запись числа в фибоначчиевой системе счисления. Переведите его в тип int.
Решение оформите в виде функции fib2int(s: str) -> int
fib2int('10101')
L: Из int в уравновешенную троичную
Дано целое число oт \(-2\times 10^9\) до \(2\times 10^9\). Найдите его представление в уравновешенной троичной системе счисления без лидирующих нулей (за исключением числа 0, запись которого имеет вид 0).
Решение оформите в виде функции int2ter(n: int) -> str
int2ter(-8)
M: Из int в фибоначчиеву
Дано целое число oт 1 до \(2\times 10^9\). Выведите его представление в фибоначчиевой системе счисления без лидирующих нулей.
Решение оформите в виде функции int2fib(n: int) -> str
int2fib(12)
'10101'
N: Инкремент
Дана запись числа в некоторой системе счисления. Увеличьте число на 1 и верните его представление в этой же системе счисления. Сдайте на проверку только тело функции.
Решение оформите в виде функции inc(n: str, base: int) -> str .
Первый параметр — запись числа в некоторой системе счисления, запись содержит символы ‘0’, . ‘9’, ‘A’, . ‘Z’, второй параметр — основание системы счисления, не превосходящее 36. Длина числа не превосходит 100000 символов.
inc('19A', 11)
O: Декремент
Решите аналогичную задачу для уменьшения числа на 1.
Решение оформите в виде функции dec(n: str, base: int) -> str .
dec('1A0', 11)
P: Инкремент в уравновешенной троичной системе счисления
Реализуйте инкремент числа в уравновешенной троичной системе счисления.
Решение оформите в виде функции inc_ter(n: str) -> str .
Входная строка может иметь длину до 100000 символов.
inc_ter('$01')
Q: Декремент в уравновешенной троичной системе счисления
Реализуйте декремент числа в уравновешенной троичной системе счисления.
Решение оформите в виде функции dec_ter(n: str) -> str .
Входная строка может иметь длину до 100000 символов.
dec_ter('$1$')
R: Фибоначчиев инкремент
Реализуйте инкремент числа в фибоначчиевой системе счисления.
Решение оформите в виде функции inc_fib(n: str) -> str .
Входная строка может иметь длину до 100000 символов.
inc_fib('100101')
'101000'
S: Фибоначчиев декремент
Реализуйте декремент числа в фибоначчиевой системе счисления.
Решение оформите в виде функции dec_fib(n: str) -> str .
Входная строка может иметь длину до 100000 символов.
dec_fib('101000')
'100101'
T: Шестнадцатеричное сложение
Дано два шестнадцатеричных числа, длиной до 100000 символов каждый. Вычислите их сумму.
Решение оформите в виде функции sum_hex(n1: str, n2: str) -> str .
sum_hex('F1', 'F')
U: Уравновешенное троичное сложение
Реализуйте сложение в уравновешенной троичной системе счисления.
Решение оформите в виде функции sum_ter(n1: str, n2: str) -> str .
sum_ter('1$$$', '$0$')
Пример соответствует выражению 14+(-10)=4.
V: Фибоначчиево сложение
Реализуйте сложение в фибоначчиевой системе счисления.
Решение оформите в виде функции sum_fib(n1: str, n2: str) -> str .
Сложность решения: квадрат от длины входных чисел (длина входных чисел до 1000 знаков, ограничение по времени — 1 секунда).
sum_fib('10010', '10101')
'1000001'
W: Шестнадцатеричное вычитание
Реализуйте алгоритм вычитания двух чисел, записанных в шестнадцатеричной системе счисления.
Решение оформите в виде функции dif_hex(n1: str, n2: str) -> str .
Сложность решения: линейная от длины входных чисел (длина чисел до 100000 знаков, ограничение по времени — 1 секунда).
dif_hex('100', 'F')
X: Фибоначчиево вычитание
Реализуйте вычитание в фибоначчиевой системе счисления.
Решение оформите в виде функции dif_fib(n1: str, n2: str) -> str . Гарантируется, что первое данное число не меньше второго.
Сложность решения: квадрат от длины входных чисел (длина чисел до 1000 знаков, ограничение по времени — 1 секунда).
dif_fib('1000001', '10101')
'10010'
Y: Умножение длинного числа на короткое
Реализуйте алгоритм умножения длинного числа, записанного в шестнадцатеричной системе счисления, на короткое число (из одной шестнадцатеричной цифры).
Решение оформите в виде функции mul_hex(n1: str, n2: str) -> str . Гарантируется, что второй параметр состоит ровно из одной цифры.
Сложность решения: линейная от длины первого числа (длина числа до 100000 знаков, ограничение по времени — 1 секунда).
Не забудьте, что в ответе может получиться 0, который записывается строкой «0».
mul_hex('A38', 'D')
'84D8'
Z: Шестнадцатеричное умножение
Реализуйте алгоритм умножения двух чисел, записанных в шестнадцатеричной системе счисления.
Решение оформите в виде функции mul_hex(n1: str, n2: str) -> str .
Сложность решения: квадрат от длины входных чисел (длина чисел до 1000 знаков).
- Использование длинной арифметики Python (например, привести число в int, перемножить, перевести обратно в строку).
- Переход к большему основанию системы счисления (например, к основанию 256 или 65536).
- Переведите строку в список цифр (значений типа int), все вычисления проводите только с числами, а не со строками. Перевод обратно в строку выполняйте в самом конце.
- “Разверите“ число: под индексом \(i\) в списке должна храниться цифра, соответствующая \(16^i\). Тогда при перемножении двух цифр \(a_i\) и \(b_j\) результат попадает в разряд \(i+j\).
- Можно не обращать внимания на переполнения разрядов и не следить за тем, что все полученные цифры будут меньше 16. Считайте, что вы храните произвольные коэффициенты, соответствующие степеням основания, а нормализацию представления выполните в самом конце.
mul_hex('A1', '7F')
'4FDF'
ZA: Развёрнутая фибоначчиева форма
В развёрнутой фибоначчиевой форме запись числа в фибоначчиевой системе счисления не содержит двух подряд идущих нулей. Для каждого числа существует единственное представление в развёрнутой фибоначчиевой форме.
Дано целое число oт 1 до 2·10 9 . Найдите его представление в развёрнутой фибоначчиевой форме.
Решение оформите в виде функции int2fib(n: int) -> str
int2fib(13)
'10110'
ZZ: Умножение Карацубы
Реализуйте алгоритм умножения длинных чисел, записанных в шестнадцатеричной системе счисления, при помощи метода Карацубы.
Решение оформите в виде функции mul_hex(n1: str, n2: str) -> str .
Требования к решению: вычисления должны проводиться в 16-ричной системе счисления (нельзя переходить к большему основанию, например, 256 или 65536). Длина входных чисел — до 10000 знаков, ограничение по времени — 10 секунд.
Советы по реализации
- Метод Карацубы — рекурсивный алгоритм, вы сводите задачу умножения длинных чисел к задаче умножение чисел меньшей длины. При этом при маленькой длине чисел метод Карацубы не даёт выгоды, используйте умножение “в столбик”. Скорее всего при длинах чисел меньше 100 выгоднее использовать умножение “в столбик”, а не метод Карацубы. Возможно, вам придется подбирать эту границу экспериментально.
- Можно не обращать внимания на переполнение разрядов и даже можно считать, что при умножении в некоторых разрядах могут получаться отрицательные значения (там же есть вычитание). Да и вычитание можно реализовать без заёма значений из старших разрядов, просто считайте, что цифры могут быть и отрицательными. Нормализацию представления результата выполняйте в самом конце.
mul_hex('A1', '7F')
Почему Python не работает с системами счисления, основания которых превышают 36?
Допустим, я желаю изменить эту программу таким образом, чтобы она работала не с 9-чной, а с 37-чной системой счисления. Оказывается, я не могу этого сделать:
ValueError: int() base must be >= 2 and
Как выйти из данного положения? P.S. Ктати, а разве бывает позиционная система счисления с основанием 0? Почему её Python разрешает?
Отслеживать
задан 14 фев 2023 в 23:39
Ян Альбертович Дененберг Ян Альбертович Дененберг
327 1 1 золотой знак 2 2 серебряных знака 6 6 бронзовых знаков
точно этот код возвращает такую ошибку? мне кажется вы не все выложили
14 фев 2023 в 23:44
Возвращает, если поменять 9 на 37.
14 фев 2023 в 23:463 ответа 3
Сортировка: Сброс на вариант по умолчанию
Почему Python не работает с системами счисления, основания которых превышают 36?
Потому что Python не «знает» цифр больше 35. Первые десять берутся из обычной десятичной: 0. 9, следующие 26 — буквы латиницы a. z. Так исторически сложилось ещё полвека назад. А какой символ по вашему он должен использовать для цифры 36?
Кcтати, а разве бывает позиционная система счисления с основанием 0? Почему её Python разрешает?
0 используется как специальное значение, означающее автоматическое определение основания системы счисления по формату строки. int(«10», 0) == 10 , int(«0x10», 0) == 16 , int(«0b10», 0) == 2 .
Если же основание системы счисления не указано, то считается равным 10.
Отслеживать
ответ дан 15 фев 2023 в 5:31
Герман Борисов Герман Борисов
10.5k 14 14 серебряных знаков 38 38 бронзовых знаков
@AlexeyTen, спасибо за исправление.
15 фев 2023 в 9:42Ошибка возникает, потому что в Python встроенная функция int() принимает второй аргумент только от 2 до 36. Чтобы работать с числами в системе счисления больше 36, можно воспользоваться библиотекой intlib.
from intlib import Int n = 12345 base = 37 n_base_37 = Int(n).to_base(base)Также в intlib есть метод from_base() , который можно использовать для перевода числа из другой системы счисления в 10-ую:
from intlib import Int n_base_37 = "a1b2c3d4e5" base = 37 n = Int(n_base_37, base=base)Отслеживать
ответ дан 15 фев 2023 в 0:01
Senior Pomidor Senior Pomidor
12.7k 3 3 золотых знака 21 21 серебряный знак 41 41 бронзовый знакСчитайте значение в тридцатисимеричной системе руками. Функция из пяти строк:
import math def is_prime(n): """Check if a number is prime.""" return n >= 2 and all(n % i != 0 for i in range(2, math.isqrt(n) + 1)) def is_valid_in_base(n, base): """Check if a number is valid in given base.""" return all(int(d) < base for d in str(n)) def value_in_base(n, base): v = 0 for d in str(n): v = base * v + int(d) return v base = 37 primes_base = [] for n in range(2, 4000): if is_valid_in_base(n, base) and is_prime(n) and is_prime(value_in_base(n, base)): primes_base.append(n) print(primes_base)$ py temp.py [2, 3, 5, 7, 29, 41, 43, 61, 67, 113, 131, 137, 139, 179, 197, 227, 241, 263, 269, 283, 331, 397, 401, 463, 487, 599, 607, 641, 647, 683, 719, 733, 751, 797, 821, 863, 883, 1033, 1039, 1051, 1093, 1097, 1231, 1277, 1297, 1307, 1361, 1381, 1439, 1543, 1567, 1613, 1619, 1697, 1699, 1787, 1811, 1831, 1877, 1907, 1949, 1987, 2063, 2069, 2081, 2089, 2137, 2203, 2221, 2287, 2333, 2339, 2371, 2423, 2447, 2531, 2539, 2557, 2683, 2711, 2797, 2803, 2861, 2957, 2999, 3037, 3109, 3167, 3251, 3343, 3389, 3457, 3491, 3547, 3617, 3659, 3691, 3701, 3767, 3769, 3923, 3929, 3943]Расширенное представление чисел. Системы счисления
На этом занятии мы поговорим о различных форматах представления чисел в Python. Мы с вами неоднократно записывали в программе целые и вещественные значения в виде:
a = 500 b = 0.01Это классическая запись. Еще существует экспоненциальная, когда числа записываются через степень десятки. Например, число:
Здесь e2 – это 10 в квадрате, то есть, 100 и оно умножается на 5, получаем 500. Причем, обратите внимание, число 500 представляется как вещественное, а не целое.
Аналогичным образом можно задать и второе значение 0,01 как:
Здесь e-2 – это 10 в минус второй степени, то есть, 0,01 и все умножается на 1. Причем, единичка вначале строго обязательна – это формат записи чисел: сначала идет число, которое умножается на степень десятки.
Зачем это может понадобиться? Часто в инженерных задачах оперируют очень большими или очень малыми числами. Например, мы хотим указать шаг сходимости градиентного алгоритма как 10^-8. Записывать это число в классическом виде:
не очень удобно, да и легко ошибиться в количестве нулей. А вот в экспоненциальной форме все очень удобно и наглядно:
И то же самое с очень большими числами, например, число Авогадро (примерно):
6,02 * 10^23 = 6.02e23
Прописывать такое число в классическом виде было бы совсем уж неудобно. Причем, вначале указано вещественное число 6,02, а затем, степень десятки. Так тоже можно делать.
Думаю, вы теперь знаете и сможете применять в своих программах экспоненциальную запись для чисел. Далее, мы с вами посмотрим, как можно представлять числа не только в десятичном формате, как это делали до сих пор, но и в других системах счисления: двоичной, шестнадцатеричной, восьмеричной. На самом деле их бесконечно много, так как можно придумать любую свою систему, скажем 132-ричную или еще какую, но на практике в 99% случаях ограничиваются именно такими.
Вкратце я напомню, что в десятичной системе счисления все цифры умножаются на степени десяток, в зависимости от позиции их написания. Например:
123 = 1*10^2 + 2*10^1 + 3*10^0
При этом, нам достаточно иметь десять различных цифр для представления любого числа.
Если же переходим к двоичной системе счисления, что все числа кодируются двумя символами: 0 и 1 – это все цифры двоичной системы (они называются битами). В результате, получаем, например, такие записи чисел в этой системе счисления:
001 = 0*2^2 + 0*2^1 + 1*2^0 = 1
1101 = 1*2^3 + 1*2^2 + 0*2^1 + 1*2^0 = 13
10001101 = 1*2^7 + 1*2^3 + 1*2^2 + 1*2^0 = 141Я здесь сразу привел их перевод в десятичную систему счисления, учитывая, что все позиции цифр – это соответствующие степени двойки. Так вот, в Python мы можем записывать числа непосредственно в двоичной системе, следующим образом:
a = 0b001 b = 0b1101 c = 0b10001101Причем, все числа получаются целыми. Если нужно определить отрицательное значение в двоичной записи, то проще всего перед его определением поставить унарный минус:
d = -0b1111Конечно, первая реакция человека, впервые столкнувшегося с двоичным представлением чисел, зачем это нужно? Куда привычнее использовать десятичную запись. Да, и часто именно ее применяют. Но бывают ситуации, например, работа с числами на уровне бит, когда нам требуется включить или выключить отдельный бит числа, или проверить является ли текущий бит равным 1 (то есть включенным) или 0 (выключенным). Здесь двоичное представление нам помогает визуализировать такой процесс.
Следующая часто используемая система счисления – шестнадцатеричная. Здесь уже используется 16 различных обозначений. Для этого берут десять цифр из десятичной системы и еще первые шесть букв латинского алфавита:
Числа принимают уже такой вид:
и т.п. Для перевода их в привычную нам десятичную систему, используется тот же принцип. Распишем их в виде:
1A = 1*16^1 + A*16^0 = 26
FB = F*16^1 + B*16^0 = 240 + 11 = 251
C2DE = C*16^3 + 2*16^2 + D*16^1 + E*16^0 = 49886Здесь буква A соответствует значению 10 в десятичной системе, поэтому получаем значение 26. Буква F = 15, B = 11, поэтому имеем значение 251. А последнее число расшифруйте самостоятельно, должно получиться значение 49886.
В чем ценность шестнадцатеричной системы счисления? Она получила широкое распространение благодаря удобному представлению байтовых данных. Один байт – это восемь бит. Если разделить байт на две части, то получим по четыре бита. В эти четыре бита можно записать одно из шестнадцати значений, то есть, одно из значений шестнадцатеричной системы счисления:
Получается, что два символа шестнадцатеричной системы, как раз описывают один байт. Причем, делают это независимо друг от друга.
При определенной тренировке, глядя на шестнадцатеричную запись, мы легко можем ее перевести и в десятичную и в двоичную системы.
В Python можно записывать числа сразу в шестнадцатеричной системе, например:
a = 0x1AПричем, можно использовать не только заглавные, но и малые латинские буквы:
b = 0xde c = 0xaa3fВезде получаем целые положительные значения. Для определения отрицательных чисел можно вначале указать унарный минус:
d = -0x342Последняя восьмеричная система, которую мы рассмотрим, работает по аналогии с предыдущими, только используется основания для восьмерки. Соответственно, для определения чисел достаточно восемь различных обозначений – используют первые восемь цифр десятичной системы. Сами числа записываются в виде:
27 = 2*8^1 + 7*8^0 = 23
54 = 5*8^1 + 4*8^0 = 44
775 = 7*8^2 + 7*8^1 + 5*8^0 = 509Здесь я сразу перевел их в десятичный вид. Если нам нужно определить число в восьмеричной системе, то в Python используется следующая запись:
a = 0o27 b = 0o54 c = -0o775Вот такие базовые системы счисления можно использовать в Python для определения чисел, а также применять экспоненциальную форму их представления.
Видео по теме
#1. Первое знакомство с Python Установка на компьютер
#2. Варианты исполнения команд. Переходим в PyCharm
#3. Переменные, оператор присваивания, функции type и id
#4. Числовые типы, арифметические операции
#5. Математические функции и работа с модулем math
#6. Функции print() и input(). Преобразование строк в числа int() и float()
#7. Логический тип bool. Операторы сравнения и операторы and, or, not
#8. Введение в строки. Базовые операции над строками
#9. Знакомство с индексами и срезами строк
#10. Основные методы строк
#11. Спецсимволы, экранирование символов, row-строки
#12. Форматирование строк: метод format и F-строки
#13. Списки - операторы и функции работы с ними
#14. Срезы списков и сравнение списков
#15. Основные методы списков
#16. Вложенные списки, многомерные списки
#17. Условный оператор if. Конструкция if-else
#18. Вложенные условия и множественный выбор. Конструкция if-elif-else
#19. Тернарный условный оператор. Вложенное тернарное условие
#20. Оператор цикла while
#21. Операторы циклов break, continue и else
#22. Оператор цикла for. Функция range()
#23. Примеры работы оператора цикла for. Функция enumerate()
#24. Итератор и итерируемые объекты. Функции iter() и next()
#25. Вложенные циклы. Примеры задач с вложенными циклами
#26. Треугольник Паскаля как пример работы вложенных циклов
#27. Генераторы списков (List comprehensions)
#28. Вложенные генераторы списков
#29. Введение в словари (dict). Базовые операции над словарями
#30. Методы словаря, перебор элементов словаря в цикле
#31. Кортежи (tuple) и их методы
#32. Множества (set) и их методы
#33. Операции над множествами, сравнение множеств
#34. Генераторы множеств и генераторы словарей
#35. Функции: первое знакомство, определение def и их вызов
#36. Оператор return в функциях. Функциональное программирование
#37. Алгоритм Евклида для нахождения НОД
#38. Именованные аргументы. Фактические и формальные параметры
#39. Функции с произвольным числом параметров *args и **kwargs
#40. Операторы * и ** для упаковки и распаковки коллекций
#41. Рекурсивные функции
#42. Анонимные (lambda) функции
#43. Области видимости переменных. Ключевые слова global и nonlocal
#44. Замыкания в Python
#45. Введение в декораторы функций
#46. Декораторы с параметрами. Сохранение свойств декорируемых функций
#47. Импорт стандартных модулей. Команды import и from
#48. Импорт собственных модулей
#49. Установка сторонних модулей (pip install). Пакетная установка
#50. Пакеты (package) в Python. Вложенные пакеты
#51. Функция open. Чтение данных из файла
#52. Исключение FileNotFoundError и менеджер контекста (with) для файлов
#53. Запись данных в файл в текстовом и бинарном режимах
#54. Выражения генераторы
#55. Функция-генератор. Оператор yield
#56. Функция map. Примеры ее использования
#57. Функция filter для отбора значений итерируемых объектов
#58. Функция zip. Примеры использования
#59. Сортировка с помощью метода sort и функции sorted
#60. Аргумент key для сортировки коллекций по ключу
#61. Функции isinstance и type для проверки типов данных
#62. Функции all и any. Примеры их использования
#63. Расширенное представление чисел. Системы счисления
#64. Битовые операции И, ИЛИ, НЕ, XOR. Сдвиговые операторы
#65. Модуль random стандартной библиотеки
#66. Аннотация базовыми типами
#67. Аннотации типов коллекций
#68. Аннотации типов на уровне классов
#69. Конструкция match/case. Первое знакомство
#70. Конструкция match/case с кортежами и списками
#71. Конструкция match/case со словарями и множествами
#72. Конструкция match/case. Примеры и особенности использования
© 2024 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта
Перевод чисел в Python
В данной статье мы рассмотрим встроенные функции языка программирования Python по переводу чисел в различные системы счисления. А так же напишем универсальную функцию по переводу десятичных чисел в другие системы счисления.
Перевод чисел из десятичной системы счисления
Для перевода числа из десятичной системы счисления в двоичную можно воспользоваться оператором bin(). В качестве аргумента нужно передать значение в виде числа, а оператор вернет строку с двоичным числом. У результата также будет префикс 0b, указывающий на основание системы счисления.number = 123 result = bin(number) print(result)>'0b1111011'Для перевода в восьмеричную систему счисления есть оператор oct(). Он также возвращает строку с восьмеричным числом и префиксом 0o.
number = 123 result = oct(number) print(result)>'0o173'При переводе в шестнадцатеричную систему счисления воспользуемся оператором hex(). Он вернет строку шестнадцатеричным числом и префиксом 0x
number = 123 result = hex(number) print(result)>'0x7b'Если же вам не нужен префикс у результата перевода, то всегда можно взять срез у полученной строки.
print(bin(123)[2:]) print(oct(123)[2:]) print(hex(123)[2:])>'1111011' >'173' >'7b'Так же выводить числа в других системах счисления можно используя f-строки и формат вывода. Для этого в строке, через символ : указываем буквы b - для двоичной, o - для восьмеричной и x - для шестнадцатеричной системы счисления.
n = 1984 print(f'Двоичное: ') print(f'Восьмеричное: ') print(f'Шестнадцатеричное: ')Двоичное: 11111000000 Восьмеричное: 3700 Шестнадцатеричное: 7c0А теперь напишем универсальную функцию convert_to() по переводу чисел из десятичной системы счисления в систему счисления в любым основанием. Наша функция будет ограничена только наличием символов в переводимой системе счисления.
Данная функция принимает три аргумента, два из которых обязательные. Это десятичное целое число number и основание переводимой системы счисления base. Третий аргумент upper служит для указания регистра вывода строки переведенного числа. По умолчанию он установлен в значение False.def convert_to(number, base, upper=False): digits = '0123456789abcdefghijklmnopqrstuvwxyz' if base > len(digits): return None result = '' while number > 0: result = digits[number % base] + result number //= base return result.upper() if upper else resultВо второй строке мы задаем переменную digits, содержащую набор символов цифр и букв английского языка. Она нам понадобится для составления символов переведенного числа на основании остатков.
В третьей строке мы проверяем основание переданной системы счисления на его длину. Если основание окажется больше, чем количество символов в нашей строке digits, то мы прекращаем выполнение функции через вызов оператора return и возвращаем None. Это такая своеобразная защита функции от неправильно переданных аргументов. Если мы попробуем перевести число в большую систему счисления по основанию, чем у нас есть символов для его записи, то мы его не сможем записать.
Дальше заведем переменную result для хранения результата работы функции и зададим ей значение в виде пустой строки. Теперь с помощью цикла с условием будем находить остаток от деления числа number на основание base, а также уменьшать number в base раз используя целочисленное деление.
Остаток от деления числа на основание переводимой системы счисления мы будем использовать как индекс для получения символа в строке digits и добавлять его к результату result. Добавлять это значение следует слева, т.к. самый первый остаток является самым правым разрядом. Цикл выполняется до тех пор, пока исходное значение переменной number больше нуля.
После завершения цикла мы вернем результат через вызов return. Для этого воспользуемся тернарным оператором и проверим наш третий аргумент. Если он будет в значении True, то для строки result вызовем строкой метод .upper() который заменит все прописные символы английского языка на строчные. Иначе, вернем результат как есть.А теперь проверим работу нашей функции. Для этого попробуем перевести числа в 2ю, 8ю, 16ю, 32ю и 64ю системы счисления. Для перевода в 32ю систему счисления мы укажем третий необязательный аргумент upper и зададим ему значение True.
print(convert_to(123, 2)) print(convert_to(123, 8)) print(convert_to(123, 16)) print(convert_to(123, 32, upper=True)) print(convert_to(123, 64))>'1111011' >'173' >'7b' >'3R' >NoneПеревод чисел в десятичную систему счисления
Для обратного перевода в десятичную систему счисления мы будем использовать оператор int(). Для этого передадим ему два аргумента, первый - это строка с числом в какой-то системе счисления, а второй - это основание системы счисления самого числа. По умолчанию для этого необязательного аргумента стоит значение равное 10.
В качестве самого числа нужно обязательно передать строку. Строка может содержать или само число или число с префиксом системы счисления.
Для перевода из двоичной системы счисления:number = '11001' result = int(number, 2) print(result)number = '0b11001' result = int(number, 2) print(result)
