Шестнадцатиричные числа c: c++ — Шестнадцатеричные числа в Си

(исключающее ИЛИ), << (сдвиг влево), >> (сдвиг вправо), ~ (поразрядное дополнение до единицы). Рассмотрим на примерах, как они работают, но перед этим уделим внимание выводу в языке C чисел в отличных от десятичной системах счисления.

В С можно присваивать целочисленные значения в десятичной, восьмеричной и шестнадцатеричной системах счисления. Для того, чтобы присвоить переменной число в восьмеричной системе счисления, перед ним надо написать 0 (ноль), в шестнадцатеричной — 0x (ноль и икс), например:

int a, b;
a = 077; // восьмеричное число
b = 0x1F; // шестнадцатеричное число

Любые целые числа можно выводить на экран в десятичном, восьмеричном и шестнадцатеричном представлении. Пример кода для вывода определенных ранее двух переменных в различных системаъ счисления:

printf("%d %o %x %X\n", a,a,a,a);
printf("%d %o %x %X\n", b,b,b,b);

В результате на экране вы увидите:

63 77 3f 3F
31 37 1f 1F

Восьмеричные и шестнадцатеричные числа используются из-за удобства при работе с двоичной системой счисления. Каждая цифра восьмеричного числа может быть заменена тремя цифрами двоичного. И каждая цифра шестнадцатеричного числа легко заменяет четыре разряда двоичного числа. Вот таблица соответствия цифр восьмеричной системы счисления числам двоичной системы:

0000
1001
2010
3011
4100
5101
6110
7111

Теперь допустим, что у нас есть восьмеричное число 037. По таблице легко понять, что в двоичном выражении оно будет выглядеть как 011 111.

  1. Как будут выглядеть восьмеричные числа 04271 и 03566 в двоичном представлении.
  2. Составьте на бумаге таблицу соответствия шестнадцатеричный цифр двоичным числам. Переведите числа 7D, FFFF, 2C9 в двоичную систему счисления. 036 = 021
    017 > 2 = 03
    ~017 = 037777777760

    Этот результат будет проще понять с помощью рисунка:

    В последнем случае получилось такое большое число потому, что под форматы вывода целых чисел (%d, %o, %X) выделяется по 4 байта.

    • Используя шестнадцатеричные числа, напишите аналогичную приведенной выше программу. Объясните результат.
    • Попробуйте составлять сложные битовые операции (в несколько действий) и оценивать их результат.

    Теперь рассмотрим пример использования битовых операций. Допустим, у нас есть массив, требуется снять с него «маску», которая бы отражала, в какой позиции стоят отрицательные, а в какой положительные элементы. Пусть единица в бите обозначает соответствующий ей положительный элемент массива, а ноль — отрицательный. Другими словами, если у нас есть массив {4, -3, 2, 2, 8, -1}, то его «битовая маска» будет выглядеть как 101110, или в восьмеричном представлении как 056. Составим алгоритм решения этой задачи:

    1. Будем считать, что массив состоит не более чем из 32 элементов. Поэтому для хранения его «маски» достаточно переменной типа int. Назовем ее mask и присвоим значение 0.
    2. Перебрать элементы массива в цикле for. Если встречается положительный элемент, то установить соответствующий ему бит значения mask в 1.
    3. Вывести значение переменной mask на экран в виде восьмеричного числа.

    Вроде бы все просто, но как установить в единицу определенный бит числа? Существует закономерность соответствия степеней двойки и двоичного представления числа:
    20 = 0000 0001
    21 = 0000 0010
    22 = 0000 0100
    23 = 0000 1000
    24 = 0001 0000
    и т.д. Теперь если применить к mask побитовую операцию | (ИЛИ), а в качестве второго операнда использовать определенную степень двойки, то один бит будет установлен в 1. Например:
    (0) 0000 0000 | (25) 0010 0000 = 0010 0000
    (32) 0010 0000 | (27) 1000 0000 = 1010 0000

    При переборе первый элемент массива имеет индекс 0, но соответствующий ему бит в maskдолжен стоять впереди остальных. Если известно общее количество элементов массива (N), то можно определить степень двойки по формуле N - i - 1. Действительно, имея третий положительный элемент массива из 10 элементов, следует установить в единицу восьмой с конца бит, а это значит надо использовать вторым операндом битового ИЛИ 27, а 7 как раз будет 10(N) — 2(i) — 1.

    Другая проблема — как в языке C возвести число в степень. Понятно, что можно написать свой код, но скорее всего в стандартной библиотеке уже есть подобная функция. С помощью заголовочного файла math.h можно подключить библиотеку с математическими функциями. Среди них есть функция pow(), которая принимает два числа и возвращает результат возведения первого числа в степень, выраженную вторым числом. Однако результат возвращается в виде вещественного числа, а нам требуется целое. Как быть? В языке программирования С есть операции приведения типов, которые меняют тип значения с одного на другой. Например, чтобы преобразовать значение вещественной переменной a в целое, следует написать (int) a.
    Вот как может выглядеть вышеописанная программа:

    #include <stdio.h>
#include <math.h>
 
#define N 12
 
int main() {  
    int nums[N] = {7, 3, 9, -5, -3, 2, 
                   1, 0, 16, -4, 2, 0};
    int mask = 0, i;
 
    for (i=0; i < N; i++)
        if (nums[i] >= 0)
            mask = mask|(int)pow(2,N-i-1);
 
    printf("%o\n", mask);
}

    Напишите предыдущую программу. Оцените как она работает1. Подумайте над тем, как вывести на экран двоичное представление восьмеричного числа. Попробуйте реализовать это.

    1 Если у вас не получается скомпилировать программу, добавьте в конце вызова gcc опцию -lm (например, gcc -o bits bits.c -lm).

    Курс с решением части задач:
    android-приложение, pdf-версия

    Содержание

    python — Двоичное представление числа с плавающей точкой в Python (биты не шестнадцатеричные)

    Как получить строку в виде двоичного IEEE 754 представления 32-разрядного числа с плавающей запятой?

    Пример

    1.00 -> ‘00111111100000000000000000000000’

    54

    TheMeaningfulEngineer

    8 Май 2013 в 19:37

    12 ответов

    Лучший ответ

    Вы можете сделать это с помощью пакета struct:

    import struct
def binary(num):
    return ''.join(bin(ord(c)).replace('0b', '').rjust(8, '0') for c in struct.pack('!f', num))

    Это упаковывает его как сетевой упорядоченный байт, а затем преобразует каждый из результирующих байтов в 8-битное двоичное представление и объединяет их:

    >>> binary(1)
'00111111100000000000000000000000'

    Edit : Была просьба расширить объяснение. Я расширю это, используя промежуточные переменные, чтобы комментировать каждый шаг.

    def binary(num):
    # Struct can provide us with the float packed into bytes. The '!' ensures that
    # it's in network byte order (big-endian) and the 'f' says that it should be
    # packed as a float. Alternatively, for double-precision, you could use 'd'.
    packed = struct.pack('!f', num)
    print 'Packed: %s' % repr(packed)

    # For each character in the returned string, we'll turn it into its corresponding
    # integer code point
    # 
    # [62, 163, 215, 10] = [ord(c) for c in '>\xa3\xd7\n']
    integers = [ord(c) for c in packed]
    print 'Integers: %s' % integers

    # For each integer, we'll convert it to its binary representation.
    binaries = [bin(i) for i in integers]
    print 'Binaries: %s' % binaries

    # Now strip off the '0b' from each of these
    stripped_binaries = [s.replace('0b', '') for s in binaries]
    print 'Stripped: %s' % stripped_binaries

    # Pad each byte's binary representation's with 0's to make sure it has all 8 bits:
    #
    # ['00111110', '10100011', '11010111', '00001010']
    padded = [s.rjust(8, '0') for s in stripped_binaries]
    print 'Padded: %s' % padded

    # At this point, we have each of the bytes for the network byte ordered float
    # in an array as binary strings. Now we just concatenate them to get the total
    # representation of the float:
    return ''.join(padded)

    И результат для нескольких примеров:

    >>> binary(1)
Packed: '?\x80\x00\x00'
Integers: [63, 128, 0, 0]
Binaries: ['0b111111', '0b10000000', '0b0', '0b0']
Stripped: ['111111', '10000000', '0', '0']
Padded: ['00111111', '10000000', '00000000', '00000000']
'00111111100000000000000000000000'

>>> binary(0.32)
Packed: '>\xa3\xd7\n'
Integers: [62, 163, 215, 10]
Binaries: ['0b111110', '0b10100011', '0b11010111', '0b1010']
Stripped: ['111110', '10100011', '11010111', '1010']
Padded: ['00111110', '10100011', '11010111', '00001010']
'00111110101000111101011100001010'

    62

    Dan Lecocq
    13 Ноя 2014 в 17:43

    Некоторые из этих ответов не работали так, как написано на Python 3, или не давали правильного представления для отрицательных чисел с плавающей запятой. Я нашел следующее, чтобы работать для меня (хотя это дает 64-битное представление, которое мне нужно)

    def float_to_binary_string(f):
    def int_to_8bit_binary_string(n):
        stg=bin(n).replace('0b','')
        fillstg = '0'*(8-len(stg))
        return fillstg+stg
    return ''.join( int_to_8bit_binary_string(int(b)) for b in struct.pack('>d',f) )

    0

    dkhammond
    23 Сен 2016 в 19:01

    Конвертировать поплавок между 0..1

    def float_bin(n, places = 3): 
    if (n < 0 or n > 1):
        return "ERROR, n must be in 0..1"

    answer = "0."
    while n > 0:
        if len(answer) > places: 
            return answer

        b = n * 2
        if b > 1:
            answer += '1'
            n = b - 1
        else:
            answer += '0'
            n = b

    return answer

    0

    tttzof351
    29 Дек 2019 в 02:28

    С помощью этих двух простых функций ( Python> = 3.6 ) вы можете легко преобразовать число с плавающей запятой в двоичное и наоборот, для IEEE 754 binary64.

    import struct

def bin2float(b):
    ''' Convert binary string to a float.

    Attributes:
        :b: Binary string to transform.
    '''
    h = int(b, 2).to_bytes(8, byteorder="big")
    return struct.unpack('>d', h)[0]


def float2bin(f):
    ''' Convert float to 64-bit binary string.

    Attributes:
        :f: Float number to transform.
    '''
    [d] = struct.unpack(">Q", struct.pack(">d", f))
    return f'{d:064b}'

    Например:

    print(float2bin(1.618033988749894))
print(float2bin(3.14159265359))
print(float2bin(5.125))
print(float2bin(13.80))

print(bin2float('0011111111111001111000110111011110011011100101111111010010100100'))
print(bin2float('0100000000001001001000011111101101010100010001000010111011101010'))
print(bin2float('0100000000010100100000000000000000000000000000000000000000000000'))
print(bin2float('0100000000101011100110011001100110011001100110011001100110011010'))

    Результат:

    0011111111111001111000110111011110011011100101111111010010100100
0100000000001001001000011111101101010100010001000010111011101010
0100000000010100100000000000000000000000000000000000000000000000
0100000000101011100110011001100110011001100110011001100110011010
1.618033988749894
3.14159265359
5.125
13.8

    Надеюсь, вам понравится, у меня это отлично работает.

    0

    JavDomGom
    9 Янв 2020 в 11:25

    Для полноты вы можете достичь этого с помощью numpy:

    f = 1.00
int32bits = np.asarray(f, dtype=np.float32).view(np.int32).item()  # item() optional

    Затем вы можете напечатать это с отступом, используя спецификатор формата b

    print('{:032b}'.format(int32bits))

    5

    Eric
    8 Июл 2017 в 21:05

    Эту проблему легче решить, разбив ее на две части.

    Первый — преобразовать число с плавающей точкой в int с эквивалентным битовым шаблоном:

    def float32_bit_pattern(value):
    return sum(ord(b) << 8*i for i,b in enumerate(struct.pack('f', value)))

    Затем преобразуйте int в строку:

    def int_to_binary(value, bits):
    return bin(value).replace('0b', '').rjust(bits, '0')

    Теперь объедините их:

    >>> int_to_binary(float32_bit_pattern(1.0), 32)
'00111111100000000000000000000000'

    8

    Mark Ransom
    8 Май 2013 в 16:28

    Нашли другое решение, используя модуль bitstring.

    import bitstring
f1 = bitstring.BitArray(float=1.0, length=32)
print f1.bin

    Выход:

    00111111100000000000000000000000

    21

    maddin25
    6 Сен 2018 в 14:37

    После просмотра множества похожих вопросов я написал что-то, что, надеюсь, делает то, что я хотел.

    f = 1.00
negative = False
if f < 0:
    f = f*-1
    negative = True

s = struct.pack('>f', f)
p = struct.unpack('>l', s)[0]
hex_data =  hex(p)

scale = 16
num_of_bits = 32
binrep = bin(int(hex_data, scale))[2:].zfill(num_of_bits)
if negative:
    binrep = '1' + binrep[1:]

    binrep является результатом. Каждая часть будет объяснена.

    f = 1.00
negative = False
if f < 0:
    f = f*-1
    negative = True

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

    s = struct.pack('>f', f)                          #'?\x80\x00\x00'
p = struct.unpack('>l', s)[0]                     #1065353216
hex_data =  hex(p)                                #'0x3f800000'

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

    scale = 16
num_of_bits = 32
binrep = bin(int(hex_data, scale))[2:].zfill(num_of_bits)
if negative:
    binrep = '1' + binrep[1:]

    scale является основанием 16 для гекса. num_of_bits равен 32, поскольку число с плавающей запятой составляет 32 бита, позднее оно используется для заполнения дополнительных мест 0 для перехода к 32. Получил код для binrep из этот вопрос. Если число было отрицательным, просто измените первый бит.

    Я знаю, что это уродливо, но я не нашел хорошего пути, и мне нужно было быстро. Комментарии приветствуются.

    2

    Community
    23 Май 2017 в 11:55

    Вот уродливый …

    >>> import struct
>>> bin(struct.unpack('!i',struct.pack('!f',1.0))[0])
'0b111111100000000000000000000000'

    По сути, я просто использовал модуль struct для преобразования float в int …

    Вот немного лучше, используя ctypes:

    >>> import ctypes
>>> bin(ctypes.c_uint.from_buffer(ctypes.c_float(1.0)).value)
'0b111111100000000000000000000000'

    По сути, я создаю float и использую ту же область памяти, но отмечаю ее как c_uint. Значение c_uint является целым числом Python, для которого вы можете использовать встроенную функцию bin.

    33

    mgilson
    26 Сен 2017 в 15:55

    Это немного больше, чем просили, но это было то, что мне было нужно, когда я нашел эту запись. Этот код даст мантиссу, основание и знак 32-разрядного числа с плавающей запятой IEEE 754.

    import ctypes
def binRep(num):
    binNum = bin(ctypes.c_uint.from_buffer(ctypes.c_float(num)).value)[2:]
    print("bits: " + binNum.rjust(32,"0"))
    mantissa = "1" + binNum[-23:]
    print("sig (bin): " + mantissa.rjust(24))
    mantInt = int(mantissa,2)/2**23
    print("sig (float): " + str(mantInt))
    base = int(binNum[-31:-23],2)-127
    print("base:" + str(base))
    sign = 1-2*("1"==binNum[-32:-31].rjust(1,"0"))
    print("sign:" + str(sign))
    print("recreate:" + str(sign*mantInt*(2**base)))

binRep(-0.75)

    Выход:

    bits: 10111111010000000000000000000000
sig (bin): 110000000000000000000000
sig (float): 1.5
base:-1
sign:-1
recreate:-0.75

    2

    johnml1135
    11 Ноя 2016 в 13:04

    Вы можете использовать .format для простейшего представления битов на мой взгляд:

    Мой код будет выглядеть примерно так:

    def fto32b(flt):
# is given a 32 bit float value and converts it to a binary string
if isinstance(flt,float):
    # THE FOLLOWING IS AN EXPANDED REPRESENTATION OF THE ONE LINE RETURN
            #   packed = struct.pack('!f',flt) <- get the hex representation in (!)Big Endian format of a (f) Float
            #   integers = []
            #   for c in packed:
            #       integers.append(ord(c))    <- change each entry into an int
            #   binaries = []
            #   for i in integers:
            #       binaries.append("{0:08b}".format(i)) <- get the 8bit binary representation of each int (00100101)
            #   binarystring = ''.join(binaries) <- join all the bytes together
            #   return binarystring
    return ''.join(["{0:08b}".format(i) for i in [ord(c) for c in struct.pack('!f',flt)]])
return None

    Выход:

    >>> a = 5.0
'01000000101000000000000000000000'
>>> b = 1.0
'00111111100000000000000000000000'

    -1

    Robert Hughes
    1 Мар 2016 в 02:44

    Свинья с ответом Дэна с цветной версией для Python3:

    import struct

BLUE = "\033[1;34m"
CYAN = "\033[1;36m"
GREEN = "\033[0;32m"
RESET = "\033[0;0m"


def binary(num):
    return [bin(c).replace('0b', '').rjust(8, '0') for c in struct.pack('!f', num)]


def binary_str(num):
    bits = ''.join(binary(num))
    return ''.join([BLUE, bits[:1], GREEN, bits[1:10], CYAN, bits[10:], RESET])


def binary_str_fp16(num):
    bits = ''.join(binary(num))
    return ''.join([BLUE, bits[:1], GREEN, bits[1:10][-5:], CYAN, bits[10:][:11], RESET])

x = 0.7
print(x, "as fp32:", binary_str(0.7), "as fp16 is sort of:", binary_str_fp16(0.7))

    0

    y.selivonchyk
    24 Фев 2020 в 21:29

    Шестнадцатиричные числа — это… Что такое Шестнадцатиричные числа?

    Шестнадцатиричные числа

    Шестнадцатеричная система счисления (шестнадцатеричные числа) — позиционная система счисления по целочисленному основанию 16. Обычно в качестве шестнадцатеричных цифр используются десятичные цифры от 0 до 9 и латинские буквы от A до F для обозначения цифр от 10 до 15.

    Применение

    Широко используется в низкоуровневом программировании и вообще в компьютерной документации, поскольку в современных компьютерах минимальной единицей памяти является 8-битный байт, значения которого удобно записывать двумя шестнадцатеричными цифрами. Такое использование началось с системы IBM/360, где вся документация использовала шестнадцатеричную систему, в то время как в документации других компьютерных систем того времени (даже с 8-битными символами, как, например, БЭСМ-6) использовали восьмеричную систему.

    В стандарте Юникода номер символа принято записывать в шестнадцатеричном виде, используя не менее 4 цифр (при необходимости — с ведущими нулями).

    Способы записи

    В математике

    В математике систему счисления принято писать в подстрочном знаке. Например, десятичное число 1443 можно записать как 144310 или как 5A316.

    В языках программирования

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

    • В Ада и
    • В Си и языках схожего синтаксиса, например, в
    • В некоторых ассемблерах используют букву «h», которую ставят после числа. Например, «5A3h». При этом, если число начинается не с десятичной цифры, впереди ставится «0» (ноль): «0FFh» (25510)
    • Другие ассемблеры (AT&T, Motorola), а также Паскаль и некоторые версии Бэйсика используют префикс «$». Например, «$5A3».
    • Некоторые иные платформы, например ZX Spectrum в своих ассемблерах (MASM, TASM, ALASM, GENS и т.д.) использовали запись #5A3, обычно выровненную до одного или двух байт: #05A3.
    • Другие версии Бэйсика используют для указания шестнадцатеричных цифр сочетание «&h». Например, «&h5A3».
    • В Unix-подобных операционных системах (и многих языках программирования, имеющих корни в Unix/linux) непечатные символы при выводе/вводе кодируются как \xCC, где CC — шестнадцатеричный код символа.

    Перевод чисел из одной системы счисления в другую

    Перевод чисел из шестнадцатеричной системы в десятичную

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

    Например, требуется перевести шестнадцатеричное число 5A3 в десятичное. В этом числе 3 цифры. В соответствии с вышеуказанным правилом представим его в виде суммы степеней с основанием 16:

    5A316=5·162+10·161+3·160
    =5·256+10·16+3·1=1280+160+3=144310

    Перевод чисел из двоичной системы в шестнадцатеричную

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

    Например:

    101101000112=0101 1010 0011=5A316

    Таблица перевода чисел

    0hex=0dec=0oct0000
    1hex=1dec=1oct0001
    2hex=2dec=2oct0010
    3hex=3dec=3oct0011
    4hex=4dec=4oct0100
    5hex=5dec=5oct0101
    6hex=6dec=6oct0110
    7hex=7dec=7oct0111
    8hex=8dec=10oct1000
    9hex=9dec=11oct1001
    Ahex=10dec=12oct1010
    Bhex=11dec=13oct1011
    Chex=12dec=14oct1100
    Dhex=13dec=15oct1101
    Ehex=14dec=16oct1110
    Fhex=15dec=17oct1111

    См. также

    Ссылки

    Wikimedia Foundation.
    2010.

    • Шестнадцать
    • Шестнадцатиричная система исчисления

    Смотреть что такое «Шестнадцатиричные числа» в других словарях:

    • ЦИФРА — условный знак для обозначения числа. В узком смысле слова, цифрой называются знаки от 0 до 9. Различают цифры арабские, римские, двоичные, троичные, десятичные, шестнадцатиричные, значащие, нулевые и т.д. (См. (), система цифровая.) …   Большая политехническая энциклопедия

    PHP | Типы данных

    Типы данных

    Последнее обновление: 28.02.2021

    PHP является языком с динамической типизацией. Это значит, что тип данных переменной выводится во время выполнения,
    и в отличии от ряда других языков программирования в PHP не надо указывать перед переменной тип данных.

    В PHP есть десять базовых типов данных:

    • bool (логический тип)

    • int (целые числа)

    • float (дробные числа)

    • string (строки)

    • array (массивы)

    • object (объекты)

    • callable (функции)

    • mixed (любой тип)

    • resource (ресурсы)

    • null (отсутствие значения)

    Из этих типов данных первые четыре являются скалярными: bool, int, float, string. Поэтому вначале именно их и рассмотрим.

    int (целочисленный тип)

    Представляет целое число со знаком.

    
$num = -100;
echo $num;

    Здесь переменная $num представляет целочисленный тип, так как ей присваивается целочисленное значение.

    Кроме десятичных целых чисел PHP обладает возможностью использовать также двоичные, восьмеричные и шестнадцатеричные числа. Шаблоны чисел для других систем:

    • шестнадцатеричные : 0[xX][0-9a-fA-F]

    • восьмеричные : 0[0-7]

    • двоичные : 0b[01]

    Например:

    
<?php
// Все числа в десятичной системе имеют значение 28
$num_10 = 28; // десятичное число
$num_2 = 0b11100; // двоичное число (28 в десятичной системе)
$num_8 = 034; // восьмеричное число (28 в десятичной)
$num_16 = 0x1C; // шестнадцатиричное число (28 в десятичной)
echo "num_10 = $num_10 <br>"; 
echo "num_2 = $num_2 <br>"; 
echo "num_8 = $num_8 <br>";  
echo "num_16 = $num_16";
?>

    Переменная типа int занимает в памяти 32 бита, то есть может принимаь значения от -2 147 483 648 до 2 147 483 647.4
    $a3 = 6E-8; // 0.00000006
    ?>

    Тип bool (логический тип)

    Переменные логического типа могут принимать два значения: true и false или иначе говоря истина и ложь.
    Чаще всего логические значения используются в условных конструкциях:

    
<?php
$foo = true;
$boo = false;
?>

    Тип string (строки)

    Для работы с текстом можно применять строки. Строки бывают двух типов: в двойных кавычках и одинарных. От типа кавычек
    зависит обработка строк интерпретатором. Так, переменные в двойных кавычках заменяются значениями, а переменные в одинарных кавычках остаются неизменными.

    
<?php
$a=10;
$b=5;
$result = "$a+$b <br>";
echo $result;
$result = '$a+$b';
echo $result;
?>

    В этом случае мы получим следующий вывод:

    
10+5 
$a+$b

    Кроме обычных символов, строка может содержать специальные символы, которые могут быть неправильно интерпретированы. Например, нам надо добавить в строку кавычку:

    
$text = "Модель "Apple II"";

    Данная запись будет ошибочна. Чтобы исправить ошибку, мы можем сочетать различные типы кавычек (‘Модель «Apple II»‘ или «Модель ‘Apple III'») или использовать слеш, чтобы ввести кавычку в строку:

    
$text = "Модель \"Apple II\"";

    Специальное значение null

    Значение null указывает, переменная не имеет значения. Использование данного значения полезно в тех случаях, когда мы
    хотим указать, что переменная не имеет значения. Например, если мы просто определим переменную без ее инициализации, и затем попробуем ее использовать,
    то нам интерпретатор выдаст сообщение, что переменная не установлена:

    
<?php
$a;
echo $a;
?>

    Использование значения null поможет избежать данной ситуации. Кроме того, мы сможем проверять наличие значения и в зависимости от результатов проверки
    производить те или иные действия:

    
<?php
$a = null;
echo "a = $a";
?>

    Константа null не чувствительна к регистру, поэтому мы можем написать и так:

    
$a = NULL;

    Динамическая типизация

    Поскольку PHP — язык с динамической типизацией, то мы можем присваивать одной и той же переменной значения разных типов:

    
<?php
$id = 123;
echo "<p>id = $id</p>";
$id = "jhveruuyeru";
echo "<p>id = $id</p>";
?>

    int целые числа | Python

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

    Python поддерживает десятичные, двоичные, восьмеричные и шестнадцатеричные целые числа, причем не накладывается никаких ограничений на величину (длину) числа, лишь бы хватило памяти для его хранения.
    SyntaxError: invalid token

    Двоичные числа состоят из префикса 0b (или 0B) и двоичных цифр: \(0\) и \(1\):

    >>> 0b0, 0b1, 0b10, 0b111, 0b10001010001110111011001
(0, 1, 2, 7, 4529625)

    Восьмеричные числа начинаются с префикса 0o (0O) и могут содержать только восьмиричные цифры: \(0\), \(1\), \(2\), \(3\), \(4\), \(5\), \(6\) и \(7\):

    >>> 0o0, 0o1, 0o10, 0o77, 0o12345670
(0, 1, 8, 63, 2739128)

    Шестнадцатеричные числа начинаются с префикса 0x (0X) и могут содержать как все десятичные цифры, так и символы латинского алфавита: a, b, c, d, e, f (или A, B, C, D, E, F), которые в данном случае выступают в роли цифр:

    >>> 0x0, 0x1, 0x10, 0xabcdf, 0x10f0a5d34a
(0, 1, 16, 703711, 72756876106)

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

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

    >>> int('111', 2)
7
>>> int('111', 3)
13
>>> int('111', 8)
73
>>> int('111', 16)
273
>>> int('1az', 36)
1691

    Арифметические операции

    Целые числа поддерживают следующие математические операции, которые отсортированы по убыванию приоритета:

    №ОперацияРезультатЗамечание
    1x ** yвозводит x в степень y(I)
    2pow(x, y[, z])возводит x в степень y по модулю z, где z – необязательный аргумент(I)
    3divmod(x, y)возвращает кортеж с парой чисел (x // y, x % y)(II)
    4x.conjugate()возвращает \(\bar{x}\) — число, которое комплексно сопряжено с \(x\)
    5complex(re, im)преобразует re в комплексное число (по умолчанию im = 0)(VI)
    6float(x)преобразует x в вещественное число (число с плавающей точкой)(VI)
    7int(x)переобразует x в целое число, представленное в десятичной системе счисления(V)(VI)
    8abs(x)абсолютное значение (модуль) числа x
    9+xделает число x положительным
    10-xделает число x отрицательным
    11x % yостаток от деления x на y(II)
    12x // yрезультат целочисленного деления x на y(III) (II)
    13x / yрезультат «истинного» деления x на y(IV)
    14x * yпроизведение x и y
    15x - yразность x и y
    16x + yсумма x и y

    Важно: приоритет математических операций выше побитовых логических операций и операций сравнения.

    Замечания:

    I. возведение \(0\) в степень \(0\) возвращает \(1\):

    >>> 0**0, pow(0, 0)
(1, 1)

    Извлечение корней четной степени из отрицательных чисел не вызывает ошибки, а возвращает комплексное число:

    >>> (-1)**0.5
(6.123233995736766e-17+1j)
>>> 
>>> pow(-25, 1/4)
(1.5811388300841898+1.5811388300841895j)

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

    III. если оба числа типа int то и результат будет типа int. Данная операция всегда возвращает целое число, т.е. если число x можно представить в виде d*y + r, то x//y = d (r – остаток от деления). Так же следует иметь ввиду, что результат данной операции всегда округляется в сторону минус бесконечности:

    >>> 1//2, (-1)//2, 1//(-2), (-1)//(-2)
(0, -1, -1, 0)

    Это немного сбивает с толку, но проверив результат по формуле x = d*y + r, вы убедитесь что все верно.

    IV. даже если оба числа типа int, то результат все равно будет преобразован к типу float.

    V. встроенная функция int() пропускает числа (объекты) типа int «как есть», не выполняя над ними, абсолютно никаких действий.

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

    Логические побитовые операции

    Фактически, если число можно перевести в двоичную систему счисления, значит его можно рассматривать как двоичные данные. Учитывая, что такие данные состоят из нулей и единиц, которые интерпретируются как логические значения True и False, мы можем выполнять над ними логические операции. Логические операции выполняются по отдельным битам соответствующих разрядов. Если в операции учавствуют числа с разным количеством разрядов, то недостающие разряды дополняются нулями слева.

    Данные операции могут быть выполнены, только над целыми числами. Если в выражении или в результате операции имеются отрицательные числа, то они представляются в виде дополнительного кода. Например, мы знаем, что результатом логического оператора ~ (побитовое НЕ) примененного, скажем, к числу 0b111 должно быть число 0b000, но вместо этого мы видим число дополнительный код которого соответствует данной операции:

    >>> bin(7)
'0b111'
>>> ~7
-8
>>> bin(-8)
'-0b1000'

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

    №ОперацияРезультатЗамечание
    1~xинвертирование битов x(I)
    2x >> nсдвиг битов числа x вправо на n разрядов(II)(III)
    3x << nсдвиг битов числа x влево на n разрядов(II)(IV)
    4x & yпобитовое И чисел x и y
    5x ^ yпобитовое исключающее ИЛИ чисел x и y
    6x | yпобитовое ИЛИ чисел x и y

    Важно: приоритет побитовых операций ниже математически, но выше операций сравнения.

    Замечания:

    I. унарные операции ~, + и - имеют одинаковый приоритет.

    II. отрицательное значение в выражеиях x << n и x >> n приведет к ошибке и вызовет исключение ValueError.

    III. операция x << n эквивалентна команде x*pow(2, n), но проверка переполнения в этой команде не выполняется:

    >>> 7 << 3, 7*pow(2, 3)
(56, 56)

    IV. операция x >> n эквивалентна команде x // pow(2, n), но проверка переполнения в этой команде не выполняется:

    >>> 63 >> 3, 63//pow(2, 3)
(7, 7)

    Операции сравнения

    Для сравнения чисел, доступно \(8\) операций сравнения, причем все они имеют одинаковый приоритет:

    №ОперацияРезультатЗамечание
    1x < yTrue если x меньше y, иначе False
    2x <= yTrue если x меньше или равно y, иначе False
    3x > nTrue если x больше y, иначе False
    4x >= nTrue если x больше или равно y, иначе False
    5x == yTrue если x равно y, иначе False
    6x != yTrue если x не равно y, иначе False
    7x is yTrue если x и y это один и тот же объект, иначе False
    8x is not yTrue если x и y это не один и тот же объект, иначе False

    Важно: приоритет операций сравнения ниже математических и побитовых операций.

    Наряду с оператором сравнения значений чисел == и !=, в Python имеются операторы is и is not, которые позволяют выяснить, являются сравниваемые значения одним и тем же объектом или нет. Например:

    >>> a = 1001
>>> b = 1000 + 1
>>> 
>>> a == b
True
>>> 
>>> a is b, a is not b
(False, True)

    Не смотря на то, что значения a и b равны, в памяти компьютера они хранятся как разные объекты:

    >>> id(a), id(b)
(3071801680, 3071801728)

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

    В Python сравнение x > y and y > z является эквивалентным x > y > z т.е. сравнения связаные оператором and в произвольные цепочки могут быть записаны в более компактной форме. Выполнение таких выражений начинается слева направо и останавливается как только будет получено первое значение False. Это означает, что если в выражении x > y > z сравнение x > y вернет False то сравнение y > z выполняться не будет.

    Методы целых чисел

    Целые числа – это объекты, которые обладают следующими методами:

    int.bit_length()¶
    возвращает количество бит, которое необходимо для представления числа в памяти, без учета знака и незначащих нулей:
    >>> x = 204
>>> bin(x)
'0b11001100'
>>> 
>>> x.bit_length()
8
>>> 
>>> (-0b000000000000001).bit_length()
1
    int.to_bytes(length, byteorder, *, signed=False)¶
    возвращает массив байтов, который соответствует данному числу:

    Параметр length задает необходимое количество байтов, а byteorder определяет в каком порядке возвращать байты: значение 'big' – от старшего к младшему, 'little' – от младшего к старшему. Оба параметра являются обязательными:

    >>> (129).to_bytes(2, byteorder = 'big')
b'\x00\x81'
>>> 
>>> (129).to_bytes(5, 'big')
b'\x00\x00\x00\x00\x81'
>>> 
>>> (129).to_bytes(5, 'little')
b'\x81\x00\x00\x00\x00

    Если указанных байтов недостаточно для представления числа, то будет вызвано исключение OverflowError. А что бы узнать и (или) использовать порядок байтов который использует машина, выполняющая код используйте sys.byteorder.

    Параметр signed позволяет установить использование дополнительного кода для отрицательных целых чисел:

    >>> (127).to_bytes(2, 'big', signed = True)
b'\x00\x7f'
>>> 
>>> (-127).to_bytes(2, 'big', signed = True)
b'\xff\x81'

    Если signed = False, а число является отрицательным, то будет вызвано исключение OverflowError.

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

    Параметры bytes и byteorder являются обязательными. bytes — должен быть байто-подобным объектом (строки байтов, массивы байтов, array.array и т.д.). Описание параметров byteorder и signed смотрите в int.to_bytes():

    >>> int.from_bytes(b'\x00\x7f', byteorder = 'big')
127
>>> 
>>> int.from_bytes(b'\x00\x7f', byteorder = 'little')
32512
>>> 
>>> int.from_bytes(b'\xff\x81', 'big', signed = True)
-127
>>> 
>>> 
>>> int.from_bytes([1, 0], 'big')    #  можно указать "массив" байтов
256
>>> int.from_bytes([255, 255], 'big')
65535

    Шестнадцатеричная арифметика

    Десятичные012345678910111213141516
    Шестнадцатеричные0123456789abcdef10
    10-ная система16-ная система
    00
    11
    22
    33
    44
    55
    66
    77
    88
    99
    10a
    11b
    12c
    13d
    14e
    15f
    1610

    +0123456789ABCDEF
    00123456789ABCDEF
    1123456789ABCDEF10
    223456789ABCDEF1011
    33456789ABCDEF101112
    4456789ABCDEF10111213
    556789ABCDEF1011121314
    66789ABCDEF101112131415
    7789ABCDEF10111213141516
    889ABCDEF1011121314151617
    99ABCDEF101112131415161718
    AABCDEF10111213141516171819
    BBCDEF101112131415161718191A
    CCDEF101112131415161718191A1B
    DDEF101112131415161718191A1B1C
    EEF101112131415161718191A1B1C1D
    FF101112131415161718191A1B1C1D1E

    +

    		F4240

    		7A120

    		16E360

    –16E360

    		F4240

    		7A120

    ×0123456789ABCDEF
    00000000000000000
    10123456789ABCDEF
    202468ACE10121416181A1C1E
    30369CF1215181B1E2124272A2D
    4048C1014181C2024282C3034383C
    505AF14191E23282D32373C41464B
    606C12181E242A30363C42484E545A
    707E151C232A31383F464D545B6269
    8081018202830384048505860687078
    909121B242D363F48515A636C757E87
    A0A141E28323C46505A646E78828C96
    B0B16212C37424D58636E79848F9AA5
    C0C1824303C4854606C7884909CA8B4
    D0D1A2734414E5B6875828F9CA9B6C3
    E0E1C2A38465462707E8C9AA8B6C4D2
    F0F1E2D3C4B5A69788796A5B4C3D2E1

    ×

    		1F4

    		2D
    +1964
    3E8

    		57E4

    1

    2

    3

    4

    5

    6

    7

    8

    11

    12

    13

    14

    15

    16

    17

    18

    19

    #include

    #include

    int main ()

    {

    int decimal_number, остаток, hexadecimal_number = 0;

    int count = 0;

    printf («Введите десятичное число: \ t»);

    scanf ("% d", & десятичное_число);

    , а (десятичное_число! = 0)

    {

    остаток = десятичное_число% 16;

    шестнадцатеричное_число = шестнадцатеричное_число + остаток * pow (10, count);

    десятичное_число = десятичное_число / 16;

    счет ++;

    }

    printf ("\ nШестнадцатеричный эквивалент: \ t% d \ n", шестнадцатеричное_число);

    возврат 0;

    }

    1

    2

    3

    4

    5

    6

    6

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    #include

    #include

    int main ()

    {

    int decimal_number, остаток, hexadecimal_number = 0;

    int count;

    printf («Введите десятичное число: \ t»);

    scanf ("% d", & десятичное_число);

    для (count = 0; decimal_number> 0; count ++)

    {

    остаток = decimal_number% 16;

    шестнадцатеричное_число = шестнадцатеричное_число + остаток * pow (10, count);

    десятичное_число = десятичное_число / 16;

    }

    printf ("\ nШестнадцатеричный эквивалент: \ t% d \ n", шестнадцатеричное_число);

    возврат 0;

    }

    1

    2

    3

    4

    5

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    # включить

    #include

    int decimal_to_hexadecimal (int x)

    {

    int hexadecimal_number, остаток, count = 0;

    для (count = 0; x> 0; count ++)

    {

    остаток = x% 16;

    шестнадцатеричное_число = шестнадцатеричное_число + остаток * pow (10, count);

    х = х / 16;

    }

    вернуть шестнадцатеричное_число;

    }

    int main ()

    {

    int decimal_number, результат;

    printf («Введите десятичное число: \ t»);

    scanf ("% d", & десятичное_число);

    результат = десятичное_значное_шестнадцатеричное (десятичное_число);

    printf ("\ nШестнадцатеричный эквивалент: \ t% d \ n", результат);

    возврат 0;

    }

    Шестнадцатеричное число Десятичное число 4-разрядное двоичное число без знака
    0 0 1

    0001
    2 2 0010
    3 3 0011
    4 4 0100 5358 6 6 0110
    7 7 0111
    8 8 1000
    9 9 9 9 9 9

    		 1010
    B 11 1011
    C 12110 0
    D 13 1101
    E 14 1110
    F 15 1111
    Начните с числа (d) Деление Остаток Цифра шестнадцатеричного числа
    Начните с десятичного числа (d = 7)
    Разделить на 16 d / 16 = 7/16 = 0 7 h 0 = 7

    Действие Деление Остаток Цифра шестнадцатеричного числа
    Начните с десятичного числа (d = 100)

    39 Разделите на d / 16 = 100/16 = 6

    		 4 h 0 = 4
    Разделить на 16 d / 16 = 6/16 = 0 6 h 1 = 6

    Начните с числа (d) Деление Остаток Цифра шестнадцатеричного числа
    Начните с десятичного числа (d = 255)
    Разделить на 16 d / 16 = 255/16 = 15 15 h 0 = F
    Разделить на 16 d / 16 = 15/16 = 0 15 h 1 = F

    Десятичное Двоичное без знака Восьмеричное Шестнадцатеричное BCD
    0 00003 0 1 1 0001
    2 0010 2 2 0010
    3 001133 4 4 0100
    5 0101 5 5 0101
    6 0110 6 0110 6 0111 7 7 0111
    8 1000 10 1000
    9 1001 11 9 1001
    10 1010 12 A B 00010001
    12 1100 14 C 00010010
    13 1101 15 E 00010100
    15 1111 17 F 00010101

    5. Двоичная позиция Беззнаковое двоичное число Двоичное взвешивание Десятичное значение
    23 100000000000000000000000.0000000000000000 2 23 8388608
    22 010000000000000000000000,0000000000000000 2 22 4194304
    21 +010000000000000000000000,0000000000000000 2 21 2097152
    20 000100000000000000000000.0000000000000000 2 20 1,048,576
    19 000010000000000000000000.0000000000000000 2 19 524288
    18 +000001000000000000000000,0000000000000000 2 18 262144
    17 +000000100000000000000000,0000000000000000 2 17 +131072
    16 000000010000000000000000.0000000000000000 2 16 65,536
    15 000000001000000000000000.0000000000000000 2 15 32768
    14 +000000000100000000000000,0000000000000000 2 14 16384
    13 000000000010000000000000,0000000000000000 2 13 8192
    12 000000000001000000000000.0000000000000000 2 12 4,096
    11 000000000000100000000000.0000000000000000 2 11 2,048
    10 000000000000010000000000,0000000000000000 2 10 1,024
    9

    0

    0

    0

    0

    0

    		 000000000000000100000000.0000000000000000 2 8 256
    7 000000000000000010000000.0000000000000000 2 7 128
    6 000000000000000001000000.0000000000000000 2 6 64
    5

    080000

    5

    03 00003

    		000000000000000000010000.0000000000000000 2 4 16
    3 000000000000000000001000.0000000000000000 2 3 8
    2 000000000000000000000100.0000000000000000 2 2 4
    1

    0800000000 2

    1
    1 000000000000000000000001.0000000000000000 2 0 1
    Десятичная точка (.)
    –1 000000000000000000000000.1000000000000000 2 –1 0,5
    –2 000000000000000000000000.0100000000000000 2 –2 0,25
    3 000025

    		02
    3 000025

    		8
    –4 000000000000000000000000.0001000000000000 2 –4 0,0625
    –5 000000000000000000000000.0000100000000000 2 –5 0,03125
    –6 000000000000000000000000.0000010000000000 2 –6 0,015625
    0,015625
    0,015625
    –8 000000000000000000000000.0000000100000000 2 –8 0.003

    –9 000000000000000000000000.0000000010000000 2 -9
    -10 000000000000000000000000,0000000001000000 2 -10
    -11 000000000000000000000000,0000000000100000 2 -11
    –12 000000000000000000000000.0000000000010000 2 –12 0.00024414063
    –13 000000000000000000000000.0000000000001000 2 -13
    -14 +000000000000000000000000,0000000000000100 2 -14
    -15 000000000000000000000000,0000000000000010 2 -15
    –16 000000000000000000000000.0000000000000001 2 –16 0.000015258789

    Цифра Двоичная
    0 0000
    1 0001
    2 0010
    5 0101
    6 0110
    7 0111
    8 1000
    9
    		1011
    c 1100
    d 1101
    e 1110
    f