Шестнадцатиричные числа 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

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

0 000
1 001
2 010
3 011
4 100
5 101
6 110
7 111

Теперь допустим, что у нас есть восьмеричное число 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 = 0oct 0 0 0 0
    1hex = 1dec = 1oct 0 0 0 1
    2hex = 2dec = 2oct 0 0 1 0
    3hex = 3dec = 3oct 0 0 1 1
    4hex = 4dec = 4oct 0 1 0 0
    5hex = 5dec = 5oct 0 1 0 1
    6hex = 6dec = 6oct 0 1 1 0
    7hex = 7dec = 7oct 0 1 1 1
    8hex = 8dec = 10oct 1 0 0 0
    9hex = 9dec = 11oct 1 0 0 1
    Ahex = 10dec = 12oct 1 0 1 0
    Bhex = 11dec = 13oct 1 0 1 1
    Chex = 12dec = 14oct 1 1 0 0
    Dhex = 13dec = 15oct 1 1 0 1
    Ehex = 14dec = 16oct 1 1 1 0
    Fhex = 15dec = 17oct 1 1 1 1

    См. также

    Ссылки

    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

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

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

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

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

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