Как перевести строку в байты python

Байтовые строки bytes в Python

Тип данных bytes — это неизменяемые последовательности отдельных байтов. Основные двоичные протоколы основаны на кодировании текста ASCII .

Синтаксис для байтовых литералов в основном такой же, как и для строковых литералов, за исключением того, что добавляется префикс ‘b’ :

Одинарные кавычки: b’still allows embedded «double» quotes’
Двойные кавычки: b»still allows embedded ‘single’ quotes»
Тройные кавычки: b»’3 single quotes»’b»»»3 double quotes»»»

Как и в случае строковых литералов, байтовые литералы могут также использовать префикс ‘r’ для отключения обработки escape-последовательностей.

Помимо литеральных форм, объекты bytes могут быть созданы с помощью встроенного класса bytes() :

Заполненный нулями объект байтов указанной длины: bytes(10) .
Из итерируемых целых чисел: bytes(range(20)) .
Копирование существующих двоичных данных через буферный протокол: bytes(obj) .

В то время как байтовые литералы основаны на тексте ASCII , байтовые объекты фактически ведут себя как неизменяемые последовательности целых чисел, причем каждое значение в последовательности ограничено таким образом, что 0

Для байтовых строк доступны следующие операции:

общие операции c последовательностями;
методы доступные bytes и bytearray типам.

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

bytes.fromhex(string) ::

Метод bytes.fromhex() возвращает объект bytes , декодируя данный строковый объект. Строка должна содержать две шестнадцатеричные цифры на байт, при этом пробелы ASCII игнорируются.

>>> bytes.fromhex('2Ef0 F1f2 ') # b'.\xf0\xf1\xf2'

bytes.hex() ::

Метод bytes.hex() преобразовывает объект bytes в его шестнадцатеричное представление. Возвращает строковый объект, содержащий две шестнадцатеричные цифры для каждого байта.

>>> b'\xf0\xf1\xf2'.hex() # 'f0f1f2'

В Python-3.8 метод bytes.hex() поддерживает необязательные параметры sep и bytes_per_sep для вставки разделителей между байтами в шестнадцатеричный вывод.

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

>>> value = b'\xf0\xf1\xf2' >>> value.hex('-') # 'f0-f1-f2' >>> value.hex('_', 2) # 'f0_f1f2' >>> b'UUDDLRLRAB'.hex(' ', -4) #'55554444 4c524c52 4142'

Важно: Поскольку байтовые объекты являются неизменяемыми последовательностями целых чисел (подобно кортежу), то для байтового объекта ‘b’ , b[0] будет целым числом, а b[0:1] — байтовым объектом длины 1. Это контрастирует с текстовыми строками, где индексация и срез будут производить строку длиной 1 символ.

Представление объектов bytes использует литеральный формат (b’. ‘) так как это часто более полезно и наглядно, чем, например, bytes([46, 46, 46]) . Вы всегда можете преобразовать объект bytes в список целых чисел с помощью list(b).

Примеры использования:

>>> b = bytes([46, 46, 46]) >>> b # b'. ' >>> list(b) # [46, 46, 46] >>> b = bytes(range(40,60,2)) >>> b # b'(*,.02468:' >>> list(b) [40, 42, 44, 46, 48, 50, 52, 54, 56, 58]

КРАТКИЙ ОБЗОР МАТЕРИАЛА.
Утиная типизация ‘Duck Typing’
Что такое вызываемый объект callable?
Как проверить тип переменной/объекта
Логический тип данных bool
Целые числа int
Ограничение длины преобразования целочисленной строки
Вещественные числа float
Комплексные числа complex
Типы последовательностей
Список list
Кортеж tuple
Диапазон range
Текстовые строки str
Словарь dict
Множество set и frozenset
Итератор Iterator, протокол итератора
Генератор generator и выражение yield
Контекстный менеджер with
Байтовые строки bytes
Байтовый массив bytearray
Тип memoryview, буфер обмена
Файловый объект file object
Универсальный псевдоним GenericAlias
Объект объединения Union

Преобразование байтов в строку в Python

В этой статье мы рассмотрим, как преобразовать байты в строку в Python. К концу этой статьи у вас будет четкое представление о том, что это за типы и как эффективно обрабатывать данные с их помощью.

В зависимости от версии Python, которую вы используете, эта задача будет отличаться. Хотя Python 2 подошел к концу, многие проекты все еще используют его, поэтому мы включим оба подхода — Python 2 и Python 3.

Преобразование байтов в строку в Python 3

Начиная с Python 3, пришлось отказаться от старого способа работы с ASCII, и Python стал полностью Unicode.

Это означает, что мы потеряли явный тип Unicode: u»string» — каждая строка — это u»string» !

Чтобы отличить эти строки от старых добрых строк байтов, мы познакомились с новым спецификатором для них — b»string» .

Это было добавлено в Python 2.6, но не служило реальной цели, кроме подготовки к Python 3, поскольку все строки были байтовыми строками в 2.6.

Строки байтов в Python 3 официально называются bytes , неизменной последовательностью целых чисел в диапазоне 0

Преобразование байтов в строку с помощью decode()

Давайте посмотрим, как мы можем преобразовать байты в String, используя встроенный метод decode() для класса bytes :

b = b"Lets grab a \xf0\x9f\x8d\x95!" # Let's check the type print(type(b)) # # Now, let's decode/convert them into a string s = b.decode('UTF-8') print(s) # "Let's grab a ��!"

Передав формат кодирования, мы преобразовали объект bytes в строку и распечатали ее.

Преобразование байтов в строку с кодеками

Как вариант, для этой цели мы можем использовать встроенный модуль codecs :

import codecs b = b'Lets grab a \xf0\x9f\x8d\x95!' print(codecs.decode(b, 'UTF-8')) # "Let's grab a ��!"

Вам действительно не нужно передавать параметр кодировки, однако рекомендуется передавать его:

print(codecs.decode(b)) # "Let's grab a ��!"

Преобразование байтов в строку с помощью str()

Наконец, вы можете использовать str() функцию, которая принимает различные значения и преобразует их в строки:

b = b'Lets grab a \xf0\x9f\x8d\x95!' print(str(b, 'UTF-8')) # "Let's grab a ��!"

Не забудьте указать аргумент кодировки str() , иначе вы можете получить неожиданные результаты:

print(str(b)) # b'Lets grab a \xf0\x9f\x8d\x95!'

Это снова подводит нас к кодировкам. Если вы укажете неправильную кодировку, в лучшем случае произойдет сбой вашей программы, потому что она не может декодировать данные. Например, если бы мы попытались использовать функцию str() с UTF-16 , нас бы встретили:

print(str(b, 'UTF-16')) # '敌❴\u2073牧扡愠\uf020趟↕'

Это даже более важно, учитывая, что Python 3 любит использовать Unicode, поэтому, если вы работаете с файлами или источниками данных, которые используют непонятную кодировку, обязательно обратите на это особое внимание.

Преобразование байтов в строку в Python 2

В Python 2 набор байтов и строка — это практически одно и то же: строки — это объекты, состоящие из однобайтовых символов, что означает, что каждый символ может хранить 256 значений. Вот почему их иногда называют строками байтов.

Это замечательно при работе с байтовыми данными — мы просто загружаем их в переменную и готовы к печати:

s = "Hello world!" print(s) # 'Hello world!' print(len(s)) # 12

Однако использование символов Unicode в строках байтов немного меняет это поведение:

s = "Let's grab a ��!" print(s) # 'Lets grab a \xf0\x9f\x8d\x95!' # Where has the pizza gone to? print(len(s)) # 17 # Shouldn't that be 15?

Преобразование байтов в Unicode (Python 2)

Здесь нам придется использовать тип Python 2 Unicode , который предполагается и автоматически используется в Python 3. В нем строки хранятся как последовательность кодовых точек, а не байтов.

Представляет собой байты \xf0\x9f\x8d\x95 , последовательность шестнадцатеричных чисел и Python не знает, как представить их в виде ASCII:

>>> u = u"Let's grab a ��!" u"Let's grab a \U0001f355!"" >>> u "Let's grab a ��!" # Yum. >>> len(u) 15

Как вы можете видеть выше, строка Unicode содержит \U0001f355 — экранированный символ Unicode, который наш терминал распечатывает как кусок пиццы! Установить это было так же просто, как использовать спецификатор u перед значением байтовой строки.

Итак, как мне переключаться между ними?

Вы можете получить строку Unicode, расшифровав свою байтовую строку. Это можно сделать, создав объект Unicode, предоставив байтовую строку и строку, содержащую имя кодировки в качестве аргументов, или вызвав .decode(encoding) у байтовой строки.

Преобразование байтов в строку с помощью decode() (Python 2)

Вы также можете использовать codecs.encode(s, encoding) из модуля codecs .

>>> s = "Let's grab a \xf0\x9f\x8d\x95!" >>> u = unicode(s, 'UTF-8') >>> u "Let's grab a ��!" >>> s.decode('UTF-8') "Let's grab a ��!"

Преобразование байтов в строку с помощью кодеков (Python 2)

Или, используя модуль codecs :

import codecs >>> codecs.decode(s, 'UTF-8') "Let's grab a ��!"

Помните о своей кодировке

Здесь следует предостеречь — байты могут по-разному интерпретироваться в разных кодировках. Из- за того, что из коробки доступно около 80 различных кодировок, может быть нелегко узнать, есть ли у вас правильная!

s = '\xf8\xe7' # This one will let us know we used the wrong encoding >>> s.decode('UTF-8') UnicodeDecodeError: 'utf8' codec can't decode byte 0xf8 in position 0: invalid start byte # These two overlaps and this is a valid string in both >>> s.decode('latin1') øç s.decode('iso8859_5') јч

Исходное сообщение было либо, øç либо јч , и оба кажутся допустимыми преобразованиями.

Как преобразовать переменную в байты

Вы хотите переменную в байты перевести? Или полученную строку присвоить к переменной?

25 сен 2021 в 8:54

Или всё-таки строку?

25 сен 2021 в 8:55

@Tehnorobot переменную в байты

25 сен 2021 в 9:05

@dontHacker1234 так нельзя делать, лучше используйте переменную в качестве носителя строки.

25 сен 2021 в 9:08

3 ответа 3

Сортировка: Сброс на вариант по умолчанию

Да много вариантов есть. В дополнение к предыдущим:

a=bytes('Строка байт', encoding = 'utf-8') b=a print (b) b'\xd0\xa1\xd1\x82\xd1\x80\xd0\xbe\xd0\xba\xd0\xb0 \xd0\xb1\xd0\xb0\xd0\xb9\xd1\x82'

a='Это будет строка байт'.encode('utf-8') b = bytearray(a) print (b) bytearray(b'\xd0\xad\xd1\x82\xd0\xbe \xd0\xb1\xd1\x83\xd0\xb4\xd0\xb5\xd1\x82 \xd1\x81\xd1\x82\xd1\x80\xd0\xbe\xd0\xba\xd0\xb0 \xd0\xb1\xd0\xb0\xd0\xb9\xd1\x82')

Или даже так: именно «готовая» переменная — в байты:

t='Строка байт' a=bytes(t, encoding = 'utf-8') print (a)

Метод str.encode() в Python, преобразует строку в байты

Метод str.encode() вернет закодированную версию строки str как объект байтов. Другими словами кодирует текстовую строку str в строку байтов, используя указанную кодировку encoding .

Аргумент encoding по умолчанию используется ‘utf-8’ . Для получения списка всех схем кодирования смотрите Стандартные кодировки.

Аргумент errors может быть задан для установки другой схемы обработки ошибок. Значение по умолчанию для ошибок является ‘strict’ , это означает, что при ошибке кодирования будет подниматься исключение UnicodeError .Другие стандартные значения обработчика ошибок, это ‘ignore’ , ‘replace’ , ‘xmlcharrefreplace’ , ‘backslashreplace’ или любое другое значение, зарегистрированное с помощью codecs.register_error() .

Стандартные схемы обработки ошибок:

strict — возбуждается UnicodeError , при попадании ошибочных символов*;
ignore — ошибочных символов* пропускаются;
replace — ошибочных символов* заменяются на ? ;
xmlcharrefreplace — ошибочных символов* заменяются на соответствующее им XML-представление;
backslashreplace — ошибочных символов* заменяются на последовательности, начинающиеся с обратной косой черты;
namereplace — ошибочных символов* заменяются на последовательности вида \N ;
surrogateescape — заменяет каждый байт на код суррогата, от U+DC80 до U+DCFF ;
surrogatepass — игнорирует коды суррогатов. Используется со следующими кодеками: utf-8, utf-16, utf-32, utf-16-be, utf-16-le, utf-32-be, utf-32-le;

*ошибочные символы — это символы, которые не поддерживаются указанной encoding кодировкой.

Изменено в Python-3.1: добавлена поддержка ключевых слов.

Примеры преобразования текстовых строк в байтовые строки.

>>> x = 'кодирует в строку байтов' # У закодированной строки появился литерал 'b' - строка байтов >>> x.encode('utf-8') # b'\xd0\xba\xd0\xbe\xd0\xb4\xd0\xb8\xd1\x80\xd1\x83\xd0\xb5\xd1\x82 / # \xd0\xb2 \xd1\x81\xd1\x82\xd1\x80\xd0\xbe\xd0\xba\xd1\x83 / # \xd0\xb1\xd0\xb0\xd0\xb9\xd1\x82\xd0\xbe\xd0\xb2' # В кодировке ascii нет русских букв >>> x.encode('ascii') # Traceback (most recent call last): # File "", line 1, in # UnicodeEncodeError: 'ascii' codec can't encode characters in # position 0-7: ordinal not in range(128) # В кодировке ascii нет русских букв >>> x.encode('ascii', errors='ignore') # b' ' >>> x.encode('ascii', errors='replace') # b'. ? . . ' >>>

ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
Метод str.capitalize(), первая буква в строке заглавная
Метод str.casefold(), сворачивает регистр строки
Метод str.center(), выравнивает строку по центру
Метод str.count(), считает совпадения в строке
Метод str.encode(), преобразует строку в байты
Метод str.endswith(), совпадение с концом строки
Метод str.expandtabs(), меняет табуляцию на пробел
Метод str.find(), индекс первого совпадения в строке
Метод str.format(), форматирует строку
Метод str.format_map()
Метод str.index(), индекс первого совпадения подстроки
Метод str.isalnum(), строка состоит из цифр и букв
Метод str.isalpha(), строка состоит только из букв
Метод str.isascii(), все символы в строке являются ASCII
Метод str.isdecimal(), проверяет строку на десятичное число
Метод str.isdigit(), строка состоит только из цифр
Метод str.isidentifier() проверяет строку на идентификатор Python
Метод str.islower( ), проверяет строку на нижний регистр
Метод str.isnumeric(), проверяет строку на числовые символы
Метод str.isprintable(), проверяет на доступность для печати
Метод str.isspace(), является ли строка пробелом
Метод str.istitle(), проверяет наличие заглавных букв в словах
Метод str.isupper(), проверяет строку на верхний регистр
Метод str.join(), объединяет список строк
Метод str.ljust(), ровняет строку по левому краю
Метод str.lower(), строку в нижний регистр
Метод str.lstrip(), обрезает символы в начале строки
Метод str.maketrans(), таблица символов для str.translate()
Метод str.partition(), делит строку по первому совпадению
Метод str.removeprefix(), удаляет префикс строки
Метод str.removesuffix(), удаляет суффикс строки
Метод str.replace(), меняет подстроку/символ в строке
Метод str.rfind(), индекс последнего совпадения подстроки
Метод str.rindex(), индекс последнего совпадения в строке
Метод str.rjust(), ровняет строку по правому краю
Метод str.rpartition(), делит строку по последнему совпадению
Метод str.rsplit(), делит строку справа
Метод str.rstrip(), обрезает символы на конце строки
Метод str.split(), делит строку по подстроке
Метод str.splitlines(), делит текст по символу ‘\n’
Метод str.startswith(), совпадение с началом строки
Метод str.strip(), обрежет строку с обоих концов
Метод str.swapcase(), сменит регистр символов в строке
Метод str.title(), каждое слово с заглавной буквы
Метод str.translate(), транслирование строки
Метод str.upper(), переведет строку в верхний регистр
Метод str.zfill(), дополнит строку нулями
Форматирование строк в стиле printf
F-string. Форматированные строки